Repository: stdlib-js/stdlib (2025-03-02T09:28:31Z)

Issue:
[RFC]: add `blas/ext/base/wasm/dnansumkbn2`
## Description

This RFC proposes adding a new package to the `blas/ext/base/wasm/*` namespace: `@stdlib/blas/ext/base/wasm/dnansumkbn2`.

This package is the WebAssembly counterpart to [`@stdlib/blas/ext/base/dnansumkbn2`](https://github.com/stdlib-js/stdlib/tree/develop/lib/node_modules/%40stdlib/blas/ext/base/dnansumkbn2).

### Key Points

When implementing this package, you'll need to do the following:

#### Install the Emscripten SDK

If you have not already installed the Emscripten SDK via stdlib, run the following [command](https://github.com/stdlib-js/stdlib/tree/c4898b75e43d00fccc2591254486e73548c909d5/tools/make/lib/install#emscripten-sdk) to install the Emscripten SDK, which is necessary for compiling C source files to WebAssembly.

```bash
make install-deps-emsdk
```

Please do **not** attempt to install the Emscripten SDK outside of stdlib, as we rely on specific known installation paths.

#### Install the WebAssembly Binary Toolkit

Similar to the step above, run the following [command](https://github.com/stdlib-js/stdlib/tree/c4898b75e43d00fccc2591254486e73548c909d5/tools/make/lib/install#webassembly-binary-toolkit) to install the WebAssembly binary toolkit, which is necessary for compiling a WebAssembly binary to the WebAssembly text format.

```bash
make install-deps-wabt
```

Please do **not** attempt to install the WebAssembly Binary Toolkit (WABT) outside of stdlib.

#### Create package files

To see examples of similar packages, see [`@stdlib/blas/ext/base/wasm/dapxsumkbn`](https://github.com/stdlib-js/stdlib/tree/develop/lib/node_modules/%40stdlib/blas/ext/base/wasm/dapxsumkbn) (returns a scalar) and [`@stdlib/blas/base/wasm/daxpy`](https://github.com/stdlib-js/stdlib/tree/develop/lib/node_modules/%40stdlib/blas/base/wasm/daxpy) (mutates and returns a vector).

While the package proposed in this RFC will **not** match the implementations found in the above packages, those packages should provide a conceptual idea of what is desired. Do **not** simply copy-paste the code found in those packages without reasoning about expected behavior and API design.

When creating package files, the `src` directory should **not** include either a `main.wasm` or a `main.wat` file. Both of those files will be generated during a subsequent step.

Additionally, the `lib` directory should **not** include the file `binary.browser.js`. This file will also be generated during a subsequent step.

#### Update package.json

In the package's `package.json` file, ensure that there is a private `__stdlib__` configuration object with the following field

```diff
  "__stdlib__": {
    ...,
+    "wasm": true
    ...
  }
```

Setting this field ensures that project tooling is able to resolve this package as one containing WebAssembly.

#### Update exports file

Consult the equivalent JavaScript/C package [`@stdlib/blas/ext/base/dnansumkbn2`](https://github.com/stdlib-js/stdlib/tree/develop/lib/node_modules/%40stdlib/blas/ext/base/dnansumkbn2). In particular, examine the `src` folder and determine the names of the functions which are publicly exposed in the C source files. They should be similar to `stdlib_strided_foo` and `stdlib_strided_foo_ndarray`.

In `src/exports.json` file in the WebAssembly package, include the names of those exported functions, making sure to prefix each function name with a leading underscore.

#### Update the upstream package's manifest file

Next, in the upstream JavaScript/C package [`@stdlib/blas/ext/base/dnansumkbn2`](https://github.com/stdlib-js/stdlib/tree/develop/lib/node_modules/%40stdlib/blas/ext/base/dnansumkbn2), closely examine the `manifest.json` file in that package. In particular, confirm that the file has a `"wasm"` field and an associated build configuration.

For an example of a package's having a WebAssembly configuration, see [`@stdlib/blas/ext/base/dapxsumkbn`](https://github.com/stdlib-js/stdlib/blob/8a80a811f4c4d710106c73b6381fe0d3ed2ab901/lib/node_modules/%40stdlib/blas/ext/base/dapxsumkbn/manifest.json).

If the upstream package lacks a WebAssembly build configuration, you'll need to add such a configuration. For an example of a commit adding a WebAssembly configuration to an upstream package, see https://github.com/stdlib-js/stdlib/commit/b0d1c0ee0ff6fa05c8d5019939990d3fbdf08537.

#### Update the WebAssembly package's manifest file

In the `manifest.json` file in the WebAssembly package, update the source dependency to point to the upstream JavaScript/C package. This package also happens to include the C implementation which will be what is compiled to WebAssembly.

```diff
+     "dependencies": [
+        "@stdlib/blas/ext/base/dnansumkbn2"
+      ]
```

#### Compile WebAssembly

Before attempting to compile WebAssembly, go ahead and run the clean command from the root stdlib repository directory (not the package folder!) to remove any generated files.

```bash
make clean-wasm PKGS_WASM_PATTERN="blas/ext/base/wasm/dnansumkbn2"
```

To compile the upstream C implementation to WebAssembly, run the following command from the root stdlib repository directory (not the package folder!)

```bash
make wasm PKGS_WASM_PATTERN="blas/ext/base/wasm/dnansumkbn2"
```

After running the above command, check the `src` folder to confirm that both a `*.wasm` and a `*.wat` file were created, and check the `lib` folder to confirm that a `binary.browser.js` was created.

If, for whatever reason, you need to recompile WebAssembly, you always first need to remove any generated files using the following command

```bash
make clean-wasm PKGS_WASM_PATTERN="blas/ext/base/wasm/dnansumkbn2"
```

and then rerun

```bash
make wasm PKGS_WASM_PATTERN="blas/ext/base/wasm/dnansumkbn2"
```

#### Add a license header

In the `*.wat` file, add a license header.

```
;; @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.

```

For reference, see [`@stdlib/blas/ext/base/wasm/dapxsumkbn`](https://github.com/stdlib-js/stdlib/tree/develop/lib/node_modules/%40stdlib/blas/ext/base/wasm/dapxsumkbn).

Note that, if you regenerate the `*.wat` file at any point, you'll need to manually re-add the license header above.

#### Update all tests, documentation, and examples

Now that the WebAssembly binary has been generated, proceed to update all tests, documentation, and examples to reflect the API and expected behavior for the package. You should spend some time studying the tests in [`@stdlib/blas/ext/base/dnansumkbn2`](https://github.com/stdlib-js/stdlib/tree/develop/lib/node_modules/%40stdlib/blas/ext/base/dnansumkbn2). We expect the WebAssembly package to have equivalent and fully comprehensive tests.

To see an example of what is expected, study the tests in

-   [`@stdlib/blas/ext/base/wasm/dapxsumkbn`](https://github.com/stdlib-js/stdlib/tree/develop/lib/node_modules/%40stdlib/blas/ext/base/wasm/dapxsumkbn) and [`@stdlib/blas/ext/base/dapxsumkbn`](https://github.com/stdlib-js/stdlib/tree/develop/lib/node_modules/%40stdlib/blas/ext/base/dapxsumkbn) — this is a package which returns a scalar value.
-   [`@stdlib/blas/base/daxpy`](https://github.com/stdlib-js/stdlib/tree/develop/lib/node_modules/%40stdlib/blas/base/daxpy) and [`@stdlib/blas/base/wasm/daxpy`](https://github.com/stdlib-js/stdlib/tree/develop/lib/node_modules/%40stdlib/blas/base/wasm/daxpy) — this is a package which mutates and returns a vector.

Compare and contrast the tests in those pairs of packages. As should be inferred from those packages, all tests for various strides, offsets, and other behavior should be carried over and modified for the WebAssembly package.

For each of the following commands, please run them from the root stdlib repository directory (not the package folder!).

To run unit tests,

```bash
make test TESTS_FILTER=".*/blas/ext/base/wasm/dnansumkbn2/.*"
```

To run examples,

```bash
make examples EXAMPLES_FILTER=".*/blas/ext/base/wasm/dnansumkbn2/.*"
```

To run benchmarks,

```bash
make benchmark BENCHMARKS_FILTER=".*/blas/ext/base/wasm/dnansumkbn2/.*"
```

### Create pull request

Provided all tests, examples, and benchmarks successfully execute and pass and that you've updated the package's documentation, you are now ready to open a pull request!

* * *

## Notes

- If you are interested in contributing a PR which addresses this RFC and still getting familiar with our project conventions, please do **not** submit LLM-generated code. Please consult our [contributing guidelines](https://github.com/stdlib-js/stdlib/blob/develop/CONTRIBUTING.md) and the associated [development guide](https://github.com/stdlib-js/stdlib/blob/develop/docs/development.md). Failure to respect project conventions will result in your PR being rejected without review. Thank you for understanding!

### Checklist

- [X] I have read and understood the [Code of Conduct](https://github.com/stdlib-js/stdlib/blob/develop/CODE_OF_CONDUCT.md).
- [X] Searched for existing issues and pull requests.
- [X] The issue name begins with `[RFC]:`.



Discussion:

Patch:
diff --git a/lib/node_modules/@stdlib/blas/ext/base/dnansumkbn2/manifest.json b/lib/node_modules/@stdlib/blas/ext/base/dnansumkbn2/manifest.json
index 57e9af5c51e3..8f502b747310 100644
--- a/lib/node_modules/@stdlib/blas/ext/base/dnansumkbn2/manifest.json
+++ b/lib/node_modules/@stdlib/blas/ext/base/dnansumkbn2/manifest.json
@@ -1,6 +1,7 @@
 {
   "options": {
-    "task": "build"
+    "task": "build",
+    "wasm": false
   },
   "fields": [
     {
@@ -27,6 +28,7 @@
   "confs": [
     {
       "task": "build",
+      "wasm": false,
       "src": [
         "./src/main.c"
       ],
@@ -49,6 +51,7 @@
     },
     {
       "task": "benchmark",
+      "wasm": false,
       "src": [
         "./src/main.c"
       ],
@@ -66,6 +69,25 @@
     },
     {
       "task": "examples",
+      "wasm": false,
+      "src": [
+        "./src/main.c"
+      ],
+      "include": [
+        "./include"
+      ],
+      "libraries": [],
+      "libpath": [],
+      "dependencies": [
+        "@stdlib/math/base/assert/is-nan",
+        "@stdlib/math/base/special/abs",
+        "@stdlib/blas/base/shared",
+        "@stdlib/strided/base/stride2offset"
+      ]
+    },
+    {
+      "task": "build",
+      "wasm": true,
       "src": [
         "./src/main.c"
       ],
diff --git a/lib/node_modules/@stdlib/blas/ext/base/wasm/dnansumkbn2/README.md b/lib/node_modules/@stdlib/blas/ext/base/wasm/dnansumkbn2/README.md
new file mode 100644
index 000000000000..71f7b75535e5
--- /dev/null
+++ b/lib/node_modules/@stdlib/blas/ext/base/wasm/dnansumkbn2/README.md
@@ -0,0 +1,289 @@
+<!--
+
+@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.
+
+-->
+
+# dnansumkbn2
+
+> Calculate the sum of double-precision floating-point strided array elements, ignoring `NaN` values and using a second-order iterative Kahan–Babuška algorithm.
+
+<section class="intro">
+
+</section>
+
+<!-- /.intro -->
+
+<section class="usage">
+
+## Usage
+
+```javascript
+var dnansumkbn2 = require( '@stdlib/blas/ext/base/wasm/dnansumkbn2' );
+```
+
+#### dnansumkbn2.main( N, x, strideX )
+
+Computes the sum of double-precision floating-point strided array elements, ignoring `NaN` values and using a second-order iterative Kahan–Babuška algorithm.
+
+```javascript
+var Float64Array = require( '@stdlib/array/float64' );
+
+var x = new Float64Array( [ 1.0, -2.0, NaN, 2.0 ] );
+
+var sum = dnansumkbn2.main( x.length, x, 1 );
+// returns 1.0
+```
+
+The function has the following parameters:
+
+-   **N**: number of indexed elements.
+-   **x**: input [`Float64Array`][@stdlib/array/float64].
+-   **strideX**: stride length for `x`.
+
+The `N` and stride parameters determine which elements in the strided arrays are accessed at runtime. For example, to compute the sum of every other element in `x`,
+
+```javascript
+var Float64Array = require( '@stdlib/array/float64' );
+
+var x = new Float64Array( [ 1.0, 2.0, NaN, -7.0, NaN, 3.0, 4.0, 2.0 ] );
+
+var v = dnansumkbn2.main( 4, x, 2 );
+// returns 5.0
+```
+
+Note that indexing is relative to the first index. To introduce an offset, use [`typed array`][mdn-typed-array] views.
+
+<!-- eslint-disable stdlib/capitalized-comments -->
+
+```javascript
+var Float64Array = require( '@stdlib/array/float64' );
+
+var x0 = new Float64Array( [ 2.0, 1.0, NaN, -2.0, -2.0, 2.0, 3.0, 4.0 ] );
+var x1 = new Float64Array( x0.buffer, x0.BYTES_PER_ELEMENT*1 ); // start at 2nd element
+
+var v = dnansumkbn2.main( 4, x1, 2 );
+// returns 5.0
+```
+
+#### dnansumkbn2.ndarray( N, x, strideX, offsetX )
+
+Computes the sum of double-precision floating-point strided array elements, ignoring `NaN` values and using a second-order iterative Kahan–Babuška algorithm and alternative indexing semantics.
+
+```javascript
+var Float64Array = require( '@stdlib/array/float64' );
+
+var x = new Float64Array( [ 1.0, -2.0, NaN, 2.0 ] );
+
+var v = dnansumkbn2.ndarray( x.length, x, 1, 0 );
+// returns 1.0
+```
+
+The function has the following additional parameters:
+
+-   **offsetX**: starting index for `x`.
+
+While [`typed array`][mdn-typed-array] views mandate a view offset based on the underlying buffer, the offset parameter supports indexing semantics based on a starting index. For example, to calculate the sum of every other element starting from the second element:
+
+```javascript
+var Float64Array = require( '@stdlib/array/float64' );
+
+var x = new Float64Array( [ 2.0, 1.0, NaN, -2.0, -2.0, 2.0, 3.0, 4.0 ] );
+
+var v = dnansumkbn2.ndarray( 4, x, 2, 1 );
+// returns 5.0
+```
+
+* * *
+
+### Module
+
+#### dnansumkbn2.Module( memory )
+
+Returns a new WebAssembly [module wrapper][@stdlib/wasm/module-wrapper] instance which uses the provided WebAssembly [memory][@stdlib/wasm/memory] instance as its underlying memory.
+
+<!-- eslint-disable node/no-sync -->
+
+```javascript
+var Memory = require( '@stdlib/wasm/memory' );
+
+// Create a new memory instance with an initial size of 10 pages (640KiB) and a maximum size of 100 pages (6.4MiB):
+var mem = new Memory({
+    'initial': 10,
+    'maximum': 100
+});
+
+// Create a BLAS routine:
+var mod = new dnansumkbn2.Module( mem );
+// returns <Module>
+
+// Initialize the routine:
+mod.initializeSync();
+```
+
+#### dnansumkbn2.Module.prototype.main( N, xp, sx )
+
+Computes the sum of double-precision floating-point strided array elements, ignoring `NaN` values and using a second-order iterative Kahan–Babuška algorithm.
+
+<!-- eslint-disable node/no-sync -->
+
+```javascript
+var Float64Array = require( '@stdlib/array/float64' );
+var Memory = require( '@stdlib/wasm/memory' );
+
+// Create a new memory instance with an initial size of 10 pages (640KiB) and a maximum size of 100 pages (6.4MiB):
+var mem = new Memory({
+    'initial': 10,
+    'maximum': 100
+});
+
+// Create a BLAS routine:
+var mod = new dnansumkbn2.Module( mem );
+// returns <Module>
+
+// Initialize the routine:
+mod.initializeSync();
+
+// Specify a vector length:
+var N = 4;
+
+// Define a pointer (i.e., byte offset) for storing the input vector:
+var xptr = 0;
+
+// Write vector values to module memory:
+mod.write( xptr, new Float64Array( [ 1.0, 2.0, 3.0, NaN ] ) );
+
+// Perform computation:
+var sum = mod.main( N, xptr, 1 );
+// returns 6.0
+```
+
+The function has the following parameters:
+
+-   **N**: number of indexed elements.
+-   **xp**: input [`Float64Array`][@stdlib/array/float64] pointer (i.e., byte offset).
+-   **sx**: stride length for `x`.
+
+#### dnansumkbn2.Module.prototype.ndarray( N, xp, sx, ox )
+
+Computes the sum of double-precision floating-point strided array elements, ignoring `NaN` values and using a second-order iterative Kahan–Babuška algorithm and alternative indexing semantics.
+
+<!-- eslint-disable node/no-sync -->
+
+```javascript
+var Float64Array = require( '@stdlib/array/float64' );
+var Memory = require( '@stdlib/wasm/memory' );
+
+// Create a new memory instance with an initial size of 10 pages (640KiB) and a maximum size of 100 pages (6.4MiB):
+var mem = new Memory({
+    'initial': 10,
+    'maximum': 100
+});
+
+// Create a BLAS routine:
+var mod = new dnansumkbn2.Module( mem );
+// returns <Module>
+
+// Initialize the routine:
+mod.initializeSync();
+
+// Specify a vector length:
+var N = 4;
+
+// Define a pointer (i.e., byte offset) for storing the input vector:
+var xptr = 0;
+
+// Write vector values to module memory:
+mod.write( xptr, new Float64Array( [ 1.0, 2.0, 3.0, NaN ] ) );
+
+// Perform computation:
+var sum = mod.ndarray( N, xptr, 1, 0 );
+// returns 6.0
+```
+
+The function has the following additional parameters:
+
+-   **ox**: starting index for `x`.
+
+</section>
+
+<!-- /.usage -->
+
+<section class="notes">
+
+* * *
+
+## Notes
+
+-   If `N <= 0`, both `main` and `ndarray` methods return `0.0`.
+-   This package implements routines using WebAssembly. When provided arrays which are not allocated on a `dnansumkbn2` module memory instance, data must be explicitly copied to module memory prior to computation. Data movement may entail a performance cost, and, thus, if you are using arrays external to module memory, you should prefer using [`@stdlib/blas/ext/base/dnansumkbn2`][@stdlib/blas/ext/base/dnansumkbn2]. However, if working with arrays which are allocated and explicitly managed on module memory, you can achieve better performance when compared to the pure JavaScript implementations found in [`@stdlib/blas/ext/base/dnansumkbn2`][@stdlib/blas/ext/base/dnansumkbn2]. Beware that such performance gains may come at the cost of additional complexity when having to perform manual memory management. Choosing between implementations depends heavily on the particular needs and constraints of your application, with no one choice universally better than the other.
+
+</section>
+
+<!-- /.notes -->
+
+<section class="examples">
+
+* * *
+
+## Examples
+
+<!-- eslint no-undef: "error" -->
+
+```javascript
+var discreteUniform = require( '@stdlib/random/array/discrete-uniform' );
+var dnansumkbn2 = require( '@stdlib/blas/ext/base/wasm/dnansumkbn2' );
+
+var opts = {
+    'dtype': 'float64'
+};
+var x = discreteUniform( 10, 0, 100, opts );
+console.log( x );
+
+var sum = dnansumkbn2.ndarray( x.length, x, 1, 0 );
+console.log( sum );
+```
+
+</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">
+
+[mdn-typed-array]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray
+
+[@stdlib/array/float64]: https://github.com/stdlib-js/stdlib/tree/develop/lib/node_modules/%40stdlib/array/float64
+
+[@stdlib/wasm/memory]: https://github.com/stdlib-js/stdlib/tree/develop/lib/node_modules/%40stdlib/wasm/memory
+
+[@stdlib/wasm/module-wrapper]: https://github.com/stdlib-js/stdlib/tree/develop/lib/node_modules/%40stdlib/wasm/module-wrapper
+
+[@stdlib/blas/ext/base/dnansumkbn2]: https://github.com/stdlib-js/stdlib/tree/develop/lib/node_modules/%40stdlib/blas/ext/base/dnansumkbn2
+
+</section>
+
+<!-- /.links -->
diff --git a/lib/node_modules/@stdlib/blas/ext/base/wasm/dnansumkbn2/benchmark/benchmark.js b/lib/node_modules/@stdlib/blas/ext/base/wasm/dnansumkbn2/benchmark/benchmark.js
new file mode 100644
index 000000000000..ee021220341f
--- /dev/null
+++ b/lib/node_modules/@stdlib/blas/ext/base/wasm/dnansumkbn2/benchmark/benchmark.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 bench = require( '@stdlib/bench' );
+var hasWebAssemblySupport = require( '@stdlib/assert/has-wasm-support' );
+var uniform = require( '@stdlib/random/base/uniform' );
+var bernoulli = require( '@stdlib/random/base/bernoulli' );
+var filledarrayBy = require( '@stdlib/array/filled-by' );
+var isnan = require( '@stdlib/math/base/assert/is-nan' );
+var pow = require( '@stdlib/math/base/special/pow' );
+var pkg = require( './../package.json' ).name;
+var dnansumkbn2 = require( './../lib' );
+
+
+// VARIABLES //
+
+var opts = {
+	'skip': !hasWebAssemblySupport()
+};
+
+
+// FUNCTIONS //
+
+/**
+* Returns a random number.
+*
+* @private
+* @returns {number} random number
+*/
+function rand() {
+	if ( bernoulli( 0.7 ) > 0 ) {
+		return uniform( -100.0, 100.0 );
+	}
+	return NaN;
+}
+
+/**
+* Creates a benchmark function.
+*
+* @private
+* @param {PositiveInteger} len - array length
+* @returns {Function} benchmark function
+*/
+function createBenchmark( len ) {
+	var x = filledarrayBy( len, 'float64', rand );
+	return benchmark;
+
+	/**
+	* Benchmark function.
+	*
+	* @private
+	* @param {Benchmark} b - benchmark instance
+	*/
+	function benchmark( b ) {
+		var sum;
+		var i;
+
+		b.tic();
+		for ( i = 0; i < b.iterations; i++ ) {
+			sum = dnansumkbn2.main( x.length, x, 1 );
+			if ( isnan( sum ) ) {
+				b.fail( 'should not return NaN' );
+			}
+		}
+		b.toc();
+		if ( isnan( sum ) ) {
+			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, opts, f );
+	}
+}
+
+main();
diff --git a/lib/node_modules/@stdlib/blas/ext/base/wasm/dnansumkbn2/benchmark/benchmark.module.js b/lib/node_modules/@stdlib/blas/ext/base/wasm/dnansumkbn2/benchmark/benchmark.module.js
new file mode 100644
index 000000000000..4d342b073f3a
--- /dev/null
+++ b/lib/node_modules/@stdlib/blas/ext/base/wasm/dnansumkbn2/benchmark/benchmark.module.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 bench = require( '@stdlib/bench' );
+var hasWebAssemblySupport = require( '@stdlib/assert/has-wasm-support' );
+var Memory = require( '@stdlib/wasm/memory' );
+var pkg = require( './../package.json' ).name;
+var dnansumkbn2 = require( './../lib' );
+
+
+// VARIABLES //
+
+var opts = {
+	'skip': !hasWebAssemblySupport()
+};
+
+
+// MAIN //
+
+bench( pkg+':Module:constructor', opts, function benchmark( b ) {
+	var values;
+	var o;
+	var v;
+	var i;
+
+	o = {
+		'initial': 0
+	};
+	values = [
+		new Memory( o ),
+		new Memory( o )
+	];
+
+	b.tic();
+	for ( i = 0; i < b.iterations; i++ ) {
+		v = new dnansumkbn2.Module( values[ i%values.length ] );
+		if ( typeof v !== 'object' ) {
+			b.fail( 'should return an object' );
+		}
+	}
+	b.toc();
+	if ( typeof v !== 'object' ) {
+		b.fail( 'should return an object' );
+	}
+	b.pass( 'benchmark finished' );
+	b.end();
+});
diff --git a/lib/node_modules/@stdlib/blas/ext/base/wasm/dnansumkbn2/benchmark/benchmark.module.main.js b/lib/node_modules/@stdlib/blas/ext/base/wasm/dnansumkbn2/benchmark/benchmark.module.main.js
new file mode 100644
index 000000000000..705d61aa7c93
--- /dev/null
+++ b/lib/node_modules/@stdlib/blas/ext/base/wasm/dnansumkbn2/benchmark/benchmark.module.main.js
@@ -0,0 +1,145 @@
+/**
+* @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 hasWebAssemblySupport = require( '@stdlib/assert/has-wasm-support' );
+var Memory = require( '@stdlib/wasm/memory' );
+var bytesPerElement = require( '@stdlib/ndarray/base/bytes-per-element' );
+var uniform = require( '@stdlib/random/base/uniform' );
+var bernoulli = require( '@stdlib/random/base/bernoulli' );
+var filledarrayBy = require( '@stdlib/array/filled-by' );
+var isnan = require( '@stdlib/math/base/assert/is-nan' );
+var pow = require( '@stdlib/math/base/special/pow' );
+var pkg = require( './../package.json' ).name;
+var dnansumkbn2 = require( './../lib' );
+
+
+// VARIABLES //
+
+var opts = {
+	'skip': !hasWebAssemblySupport()
+};
+var options = {
+	'dtype': 'float64'
+};
+
+
+// FUNCTIONS //
+
+/**
+* Returns a random number.
+*
+* @private
+* @returns {number} random number
+*/
+function rand() {
+	if ( bernoulli( 0.7 ) > 0 ) {
+		return uniform( -100.0, 100.0 );
+	}
+	return NaN;
+}
+
+/**
+* Creates a benchmark function.
+*
+* @private
+* @param {PositiveInteger} len - array length
+* @returns {Function} benchmark function
+*/
+function createBenchmark( len ) {
+	return benchmark;
+
+	/**
+	* Benchmark function.
+	*
+	* @private
+	* @param {Benchmark} b - benchmark instance
+	*/
+	function benchmark( b ) {
+		var xptr;
+		var mod;
+		var mem;
+		var sum;
+		var nb;
+		var i;
+
+		// Create a new BLAS routine interface:
+		mem = new Memory({
+			'initial': 0
+		});
+		mod = new dnansumkbn2.Module( mem );
+
+		// Initialize the module:
+		mod.initializeSync(); // eslint-disable-line node/no-sync
+
+		// Reallocate the underlying memory to allow storing a vector:
+		nb = bytesPerElement( options.dtype );
+		mod.realloc( len*nb );
+
+		// Define a pointer (i.e., byte offset) to the first vector element:
+		xptr = 0;
+
+		// Write random values to module memory:
+		mod.write( xptr, filledarrayBy( len, 'float64', rand ) );
+
+		b.tic();
+		for ( i = 0; i < b.iterations; i++ ) {
+			sum = mod.main( len, xptr, 1 );
+			if ( isnan( sum ) ) {
+				b.fail( 'should not return NaN' );
+			}
+		}
+		b.toc();
+		if ( isnan( sum ) ) {
+			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+'::module,pointers:len='+len, opts, f );
+	}
+}
+
+main();
diff --git a/lib/node_modules/@stdlib/blas/ext/base/wasm/dnansumkbn2/benchmark/benchmark.module.ndarray.js b/lib/node_modules/@stdlib/blas/ext/base/wasm/dnansumkbn2/benchmark/benchmark.module.ndarray.js
new file mode 100644
index 000000000000..ea2ded100cdf
--- /dev/null
+++ b/lib/node_modules/@stdlib/blas/ext/base/wasm/dnansumkbn2/benchmark/benchmark.module.ndarray.js
@@ -0,0 +1,145 @@
+/**
+* @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 hasWebAssemblySupport = require( '@stdlib/assert/has-wasm-support' );
+var Memory = require( '@stdlib/wasm/memory' );
+var bytesPerElement = require( '@stdlib/ndarray/base/bytes-per-element' );
+var uniform = require( '@stdlib/random/base/uniform' );
+var bernoulli = require( '@stdlib/random/base/bernoulli' );
+var filledarrayBy = require( '@stdlib/array/filled-by' );
+var isnan = require( '@stdlib/math/base/assert/is-nan' );
+var pow = require( '@stdlib/math/base/special/pow' );
+var pkg = require( './../package.json' ).name;
+var dnansumkbn2 = require( './../lib' );
+
+
+// VARIABLES //
+
+var opts = {
+	'skip': !hasWebAssemblySupport()
+};
+var options = {
+	'dtype': 'float64'
+};
+
+
+// FUNCTIONS //
+
+/**
+* Returns a random number.
+*
+* @private
+* @returns {number} random number
+*/
+function rand() {
+	if ( bernoulli( 0.7 ) > 0 ) {
+		return uniform( -100.0, 100.0 );
+	}
+	return NaN;
+}
+
+/**
+* Creates a benchmark function.
+*
+* @private
+* @param {PositiveInteger} len - array length
+* @returns {Function} benchmark function
+*/
+function createBenchmark( len ) {
+	return benchmark;
+
+	/**
+	* Benchmark function.
+	*
+	* @private
+	* @param {Benchmark} b - benchmark instance
+	*/
+	function benchmark( b ) {
+		var xptr;
+		var mod;
+		var mem;
+		var sum;
+		var nb;
+		var i;
+
+		// Create a new BLAS routine interface:
+		mem = new Memory({
+			'initial': 0
+		});
+		mod = new dnansumkbn2.Module( mem );
+
+		// Initialize the module:
+		mod.initializeSync(); // eslint-disable-line node/no-sync
+
+		// Reallocate the underlying memory to allow storing a vector:
+		nb = bytesPerElement( options.dtype );
+		mod.realloc( len*nb );
+
+		// Define a pointer (i.e., byte offset) to the first vector element:
+		xptr = 0;
+
+		// Write random values to module memory:
+		mod.write( xptr, filledarrayBy( len, 'float64', rand ) );
+
+		b.tic();
+		for ( i = 0; i < b.iterations; i++ ) {
+			sum = mod.ndarray( len, xptr, 1, 0 );
+			if ( isnan( sum ) ) {
+				b.fail( 'should not return NaN' );
+			}
+		}
+		b.toc();
+		if ( isnan( sum ) ) {
+			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+'::module,pointers:ndarray:len='+len, opts, f );
+	}
+}
+
+main();
diff --git a/lib/node_modules/@stdlib/blas/ext/base/wasm/dnansumkbn2/benchmark/benchmark.ndarray.js b/lib/node_modules/@stdlib/blas/ext/base/wasm/dnansumkbn2/benchmark/benchmark.ndarray.js
new file mode 100644
index 000000000000..ffd49ea6e7a0
--- /dev/null
+++ b/lib/node_modules/@stdlib/blas/ext/base/wasm/dnansumkbn2/benchmark/benchmark.ndarray.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 bench = require( '@stdlib/bench' );
+var hasWebAssemblySupport = require( '@stdlib/assert/has-wasm-support' );
+var uniform = require( '@stdlib/random/base/uniform' );
+var bernoulli = require( '@stdlib/random/base/bernoulli' );
+var filledarrayBy = require( '@stdlib/array/filled-by' );
+var isnan = require( '@stdlib/math/base/assert/is-nan' );
+var pow = require( '@stdlib/math/base/special/pow' );
+var pkg = require( './../package.json' ).name;
+var dnansumkbn2 = require( './../lib' );
+
+
+// VARIABLES //
+
+var opts = {
+	'skip': !hasWebAssemblySupport()
+};
+
+
+// FUNCTIONS //
+
+/**
+* Returns a random number.
+*
+* @private
+* @returns {number} random number
+*/
+function rand() {
+	if ( bernoulli( 0.7 ) > 0 ) {
+		return uniform( -100.0, 100.0 );
+	}
+	return NaN;
+}
+
+/**
+* Creates a benchmark function.
+*
+* @private
+* @param {PositiveInteger} len - array length
+* @returns {Function} benchmark function
+*/
+function createBenchmark( len ) {
+	var x = filledarrayBy( len, 'float64', rand );
+	return benchmark;
+
+	/**
+	* Benchmark function.
+	*
+	* @private
+	* @param {Benchmark} b - benchmark instance
+	*/
+	function benchmark( b ) {
+		var sum;
+		var i;
+
+		b.tic();
+		for ( i = 0; i < b.iterations; i++ ) {
+			sum = dnansumkbn2.ndarray( x.length, x, 1, 0 );
+			if ( isnan( sum ) ) {
+				b.fail( 'should not return NaN' );
+			}
+		}
+		b.toc();
+		if ( isnan( sum ) ) {
+			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+':ndarray:len='+len, opts, f );
+	}
+}
+
+main();
diff --git a/lib/node_modules/@stdlib/blas/ext/base/wasm/dnansumkbn2/docs/repl.txt b/lib/node_modules/@stdlib/blas/ext/base/wasm/dnansumkbn2/docs/repl.txt
new file mode 100644
index 000000000000..4dbce35fa400
--- /dev/null
+++ b/lib/node_modules/@stdlib/blas/ext/base/wasm/dnansumkbn2/docs/repl.txt
@@ -0,0 +1,501 @@
+
+{{alias}}.main( N, x, strideX )
+    Computes the sum of double-precision floating-point strided array elements,
+    ignoring `NaN` values and using a second-order iterative Kahan–Babuška
+    algorithm.
+
+    The `N` and stride parameters determine which elements in the strided array
+    are accessed at runtime.
+
+    Indexing is relative to the first index. To introduce an offset, use a typed
+    array view.
+
+    If `N <= 0`, the function returns `0.0`.
+
+    Parameters
+    ----------
+    N: integer
+        Number of indexed elements.
+
+    x: Float64Array
+        Input array.
+
+    strideX: integer
+        Stride length.
+
+    Returns
+    -------
+    out: number
+        Sum.
+
+    Examples
+    --------
+    // Standard Usage:
+    > var x = new {{alias:@stdlib/array/float64}}( [ 1.0, -2.0, NaN, 2.0 ] );
+    > {{alias}}.main( x.length, x, 1 )
+    1.0
+
+    // Using `N` and stride parameters:
+    > x = new {{alias:@stdlib/array/float64}}( [ -2.0, 1.0, 1.0, -5.0, 2.0, -1.0, NaN, NaN ] );
+    > {{alias}}.main( 4, x, 2 )
+    1.0
+
+    // Using view offsets:
+    > var x0 = new {{alias:@stdlib/array/float64}}( [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0, NaN, NaN ] );
+    > var x1 = new {{alias:@stdlib/array/float64}}( x0.buffer, x0.BYTES_PER_ELEMENT*1 );
+    > {{alias}}.main( 4, x1, 2 )
+    -1.0
+
+
+{{alias}}.ndarray( N, x, strideX, offsetX )
+    Computes the sum of double-precision floating-point strided array elements,
+    ignoring `NaN` values and using a second-order iterative Kahan–Babuška
+    algorithm and alternative indexing semantics.
+
+    While typed array views mandate a view offset based on the underlying
+    buffer, the offset parameter supports indexing semantics based on a
+    starting index.
+
+    Parameters
+    ----------
+    N: integer
+        Number of indexed elements.
+
+    x: Float64Array
+        Input array.
+
+    strideX: integer
+        Stride length.
+
+    offsetX: integer
+        Starting index.
+
+    Returns
+    -------
+    out: number
+        Sum.
+
+    Examples
+    --------
+    // Standard Usage:
+    > var x = new {{alias:@stdlib/array/float64}}( [ 1.0, -2.0, NaN, 2.0 ] );
+    > {{alias}}.ndarray( x.length, x, 1, 0 )
+    1.0
+
+    // Using offset parameter:
+    > var x = new {{alias:@stdlib/array/float64}}( [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0, NaN, NaN ] );
+    > {{alias}}.ndarray( 4, x, 2, 1 )
+    -1.0
+
+
+{{alias}}.Module( memory )
+    Returns a new WebAssembly module wrapper which uses the provided WebAssembly
+    memory instance as its underlying memory.
+
+    Parameters
+    ----------
+    memory: Memory
+        WebAssembly memory instance.
+
+    Returns
+    -------
+    mod: Module
+        WebAssembly module wrapper.
+
+    Examples
+    --------
+    // Create a new memory instance:
+    > var mem = new {{alias:@stdlib/wasm/memory}}( { 'initial': 0 } );
+
+    // Create a new routine:
+    > var mod = new {{alias}}.Module( mem );
+
+    // Initialize the routine:
+    > mod.initializeSync();
+
+
+{{alias}}.Module.prototype.binary
+    Read-only property which returns WebAssembly binary code.
+
+    Returns
+    -------
+    out: Uint8Array
+        WebAssembly binary code.
+
+    Examples
+    --------
+    > var mem = new {{alias:@stdlib/wasm/memory}}( { 'initial': 0 } );
+    > var mod = new {{alias}}.Module( mem );
+    > mod.initializeSync();
+    > mod.binary
+    <Uint8Array>
+
+
+{{alias}}.Module.prototype.memory
+    Read-only property which returns WebAssembly memory.
+
+    Returns
+    -------
+    mem: Memory|null
+        WebAssembly memory.
+
+    Examples
+    --------
+    > var mem = new {{alias:@stdlib/wasm/memory}}( { 'initial': 0 } );
+    > var mod = new {{alias}}.Module( mem );
+    > mod.initializeSync();
+    > mod.memory
+    <Memory>
+
+
+{{alias}}.Module.prototype.buffer
+    Read-only property which returns a WebAssembly memory buffer as a
+    Uint8Array.
+
+    Returns
+    -------
+    buf: Uint8Array|null
+        WebAssembly memory buffer.
+
+    Examples
+    --------
+    > var mem = new {{alias:@stdlib/wasm/memory}}( { 'initial': 0 } );
+    > var mod = new {{alias}}.Module( mem );
+    > mod.initializeSync();
+    > mod.buffer
+    <Uint8Array>
+
+
+{{alias}}.Module.prototype.view
+    Read-only property which returns a WebAsssembly memory buffer as a DataView.
+
+    Returns
+    -------
+    view: DataView|null
+        WebAssembly memory view.
+
+    Examples
+    --------
+    > var mem = new {{alias:@stdlib/wasm/memory}}( { 'initial': 0 } );
+    > var mod = new {{alias}}.Module( mem );
+    > mod.initializeSync();
+    > mod.view
+    <DataView>
+
+
+{{alias}}.Module.prototype.exports
+    Read-only property which returns "raw" WebAssembly module exports.
+
+    Returns
+    -------
+    out: Object|null
+        WebAssembly module exports.
+
+    Examples
+    --------
+    > var mem = new {{alias:@stdlib/wasm/memory}}( { 'initial': 0 } );
+    > var mod = new {{alias}}.Module( mem );
+    > mod.initializeSync();
+    > mod.exports
+    {...}
+
+
+{{alias}}.Module.prototype.initialize()
+    Asynchronously initializes a WebAssembly module instance.
+
+    Returns
+    -------
+    p: Promise
+        Promise which resolves upon initializing a WebAssembly module instance.
+
+    Examples
+    --------
+    > var mem = new {{alias:@stdlib/wasm/memory}}( { 'initial': 0 } );
+    > var mod = new {{alias}}.Module( mem );
+    > mod.initialize();
+
+
+{{alias}}.Module.prototype.initializeAsync( clbk )
+    Asynchronously initializes a WebAssembly module instance.
+
+    Parameters
+    ----------
+    clbk: Function
+        Callback to invoke upon initializing a WebAssembly module instance.
+
+    Examples
+    --------
+    > var mem = new {{alias:@stdlib/wasm/memory}}( { 'initial': 0 } );
+    > var mod = new {{alias}}.Module( mem );
+    > function clbk() { console.log( 'done' ) };
+    > mod.initializeAsync( clbk );
+
+
+{{alias}}.Module.prototype.initializeSync()
+    Synchronously initializes a WebAssembly module instance.
+
+    In web browsers, JavaScript engines may raise an exception when attempting
+    to synchronously compile large WebAssembly binaries due to concerns about
+    blocking the main thread. Hence, to initialize WebAssembly modules having
+    large binaries (e.g., >4KiB), consider using asynchronous initialization
+    methods in browser contexts.
+
+    Returns
+    -------
+    mod: Module
+        Module wrapper instance.
+
+    Examples
+    --------
+    > var mem = new {{alias:@stdlib/wasm/memory}}( { 'initial': 0 } );
+    > var mod = new {{alias}}.Module( mem );
+    > mod.initializeSync();
+
+
+{{alias}}.Module.prototype.realloc( nbytes )
+    Reallocates the underlying WebAssembly memory instance to a specified number
+    of bytes.
+
+    WebAssembly memory can only *grow*, not shrink. Hence, if provided a number
+    of bytes which is less than or equal to the size of the current memory, the
+    function does nothing.
+
+    When non-shared memory is resized, the underlying the `ArrayBuffer` is
+    detached, consequently invalidating any associated typed array views. Before
+    resizing non-shared memory, ensure that associated typed array views no
+    longer need byte access and can be garbage collected.
+
+    Parameters
+    ----------
+    nbytes: integer
+        Memory size (in bytes).
+
+    Returns
+    -------
+    bool: boolean
+        Boolean indicating whether the resize operation was successful.
+
+    Examples
+    --------
+    > var mem = new {{alias:@stdlib/wasm/memory}}( { 'initial': 0 } );
+    > var mod = new {{alias}}.Module( mem );
+    > mod.initializeSync();
+    > mod.realloc( 100 )
+    <boolean>
+
+
+{{alias}}.Module.prototype.hasCapacity( byteOffset, values )
+    Returns a boolean indicating whether the underlying WebAssembly memory
+    instance has the capacity to store a provided list of values starting from a
+    specified byte offset.
+
+    Parameters
+    ----------
+    byteOffset: integer
+        Byte offset at which to start writing values.
+
+    values: ArrayLikeObject
+        Input array containing values to write.
+
+    Returns
+    -------
+    bool: boolean
+        Boolean indicating whether the underlying WebAssembly memory instance
+        has enough capacity.
+
+    Examples
+    --------
+    > var mem = new {{alias:@stdlib/wasm/memory}}( { 'initial': 0 } );
+    > var mod = new {{alias}}.Module( mem );
+    > mod.initializeSync();
+    > mod.realloc( 100 );
+    > mod.hasCapacity( 0, [ 1, 2, 3, 4 ] )
+    true
+
+
+{{alias}}.Module.prototype.isView( values )
+    Returns a boolean indicating whether a provided list of values is a view of
+    the underlying memory of the WebAssembly module.
+
+    Parameters
+    ----------
+    values: ArrayLikeObject
+        Input array.
+
+    Returns
+    -------
+    bool: boolean
+        Boolean indicating whether the list is a memory view.
+
+    Examples
+    --------
+    > var mem = new {{alias:@stdlib/wasm/memory}}( { 'initial': 0 } );
+    > var mod = new {{alias}}.Module( mem );
+    > mod.initializeSync();
+    > mod.realloc( 100 );
+    > mod.isView( [ 1, 2, 3, 4 ] )
+    false
+
+
+{{alias}}.Module.prototype.write( byteOffset, values )
+    Writes values to the underlying WebAssembly memory instance.
+
+    The function infers element size (i.e., number of bytes per element) from
+    the data type of the input array. For example, if provided a Float32Array,
+    the function writes each element as a single-precision floating-point number
+    to the underlying WebAssembly memory instance.
+
+    In order to write elements as a different data type, you need to perform an
+    explicit cast *before* calling this method. For example, in order to write
+    single-precision floating-point numbers contained in a Float32Array as
+    signed 32-bit integers, you must first convert the Float32Array to an
+    Int32Array before passing the values to this method.
+
+    If provided an array having an unknown or "generic" data type, elements are
+    written as double-precision floating-point numbers.
+
+    Parameters
+    ----------
+    byteOffset: integer
+        Byte offset at which to start writing values.
+
+    values: ArrayLikeObject
+        Input array containing values to write.
+
+    Returns
+    -------
+    mod: Module
+        Module wrapper instance.
+
+    Examples
+    --------
+    > var mem = new {{alias:@stdlib/wasm/memory}}( { 'initial': 0 } );
+    > var mod = new {{alias}}.Module( mem );
+    > mod.initializeSync();
+    > mod.realloc( 100 );
+    > mod.write( 0, [ 1, 2, 3, 4 ] );
+
+
+{{alias}}.Module.prototype.read( byteOffset, out )
+    Reads values from the underlying WebAssembly memory instance.
+
+    The function infers element size (i.e., number of bytes per element) from
+    the data type of the output array. For example, if provided a Float32Array,
+    the function reads each element as a single-precision floating-point number
+    from the underlying WebAssembly memory instance.
+
+    In order to read elements as a different data type, you need to perform an
+    explicit cast *after* calling this method. For example, in order to read
+    single-precision floating-point numbers contained in a Float32Array as
+    signed 32-bit integers, you must convert the Float32Array to an Int32Array
+    after reading memory values using this method.
+
+    If provided an output array having an unknown or "generic" data type,
+    elements are read as double-precision floating-point numbers.
+
+    Parameters
+    ----------
+    byteOffset: integer
+        Byte offset at which to start reading values.
+
+    out: ArrayLikeObject
+        Output array for storing read values.
+
+    Returns
+    -------
+    mod: Module
+        Module wrapper instance.
+
+    Examples
+    --------
+    > var mem = new {{alias:@stdlib/wasm/memory}}( { 'initial': 0 } );
+    > var mod = new {{alias}}.Module( mem );
+    > mod.initializeSync();
+    > mod.realloc( 100 );
+    > mod.write( 0, [ 1, 2, 3, 4 ] );
+    > var out = [ 0, 0, 0, 0 ];
+    > mod.read( 0, out );
+    > out
+    [ 1, 2, 3, 4 ]
+
+
+{{alias}}.Module.prototype.main( N, xp, sx )
+    Computes the sum of double-precision floating-point strided array elements,
+    ignoring `NaN` values and using a second-order iterative Kahan–Babuška
+    algorithm.
+
+    Parameters
+    ----------
+    N: integer
+        Number of indexed elements.
+
+    xp: integer
+        Input array pointer (i.e., byte offset).
+
+    sx: integer
+        Stride length.
+
+    Returns
+    -------
+    sum: number
+        Sum.
+
+    Examples
+    --------
+    > var mem = new {{alias:@stdlib/wasm/memory}}( { 'initial': 1 } );
+    > var mod = new {{alias}}.Module( mem );
+    > mod.initializeSync();
+
+    // Define a "pointer" (i.e., byte offset) into module memory:
+    > var xptr = 0;
+
+    // Write data to module memory:
+    > mod.write( xptr, new {{alias:@stdlib/array/float64}}( [ 1.0, 2.0, 3.0, NaN ] ) );
+
+    // Perform computation:
+    > var s = mod.main( 3, xptr, 1 )
+    6.0
+
+
+{{alias}}.Module.prototype.ndarray( N, xp, sx, ox )
+    Computes the sum of double-precision floating-point strided array elements,
+    ignoring `NaN` values and using a second-order iterative Kahan–Babuška
+    algorithm.
+
+    Parameters
+    ----------
+    N: integer
+        Number of indexed elements.
+
+    xp: integer
+        Input array pointer (i.e., byte offset).
+
+    sx: integer
+        Stride length.
+
+    ox: integer
+        Starting index.
+
+    Returns
+    -------
+    sum: number
+        Sum.
+
+    Examples
+    --------
+    > var mem = new {{alias:@stdlib/wasm/memory}}( { 'initial': 1 } );
+    > var mod = new {{alias}}.Module( mem );
+    > mod.initializeSync();
+
+    // Define a "pointer" (i.e., byte offset) into module memory:
+    > var xptr = 0;
+
+    // Write data to module memory:
+    > mod.write( xptr, new {{alias:@stdlib/array/float64}}( [ 1.0, 2.0, 3.0, NaN ] ) );
+
+    // Perform computation:
+    > var s = mod.ndarray( 4, xptr, 1, 0 )
+    6.0
+
+    See Also
+    --------
diff --git a/lib/node_modules/@stdlib/blas/ext/base/wasm/dnansumkbn2/docs/types/index.d.ts b/lib/node_modules/@stdlib/blas/ext/base/wasm/dnansumkbn2/docs/types/index.d.ts
new file mode 100644
index 000000000000..a3af0a9f8904
--- /dev/null
+++ b/lib/node_modules/@stdlib/blas/ext/base/wasm/dnansumkbn2/docs/types/index.d.ts
@@ -0,0 +1,310 @@
+/*
+* @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 { ModuleWrapper, Memory } from '@stdlib/types/wasm';
+
+/**
+* Interface defining a module constructor which is both "newable" and "callable".
+*/
+interface ModuleConstructor {
+	/**
+	* Returns a new WebAssembly module wrapper instance which uses the provided WebAssembly memory instance as its underlying memory.
+	*
+	* @param mem - WebAssembly memory instance
+	* @returns module wrapper instance
+	*
+	* @example
+	* var Memory = require( '@stdlib/wasm/memory' );
+	* var oneTo = require( '@stdlib/array/one-to' );
+	*
+	* // Create a new memory instance with an initial size of 10 pages (640KiB) and a maximum size of 100 pages (6.4MiB):
+	* var mem = new Memory({
+	*     'initial': 10,
+	*     'maximum': 100
+	* });
+	*
+	* // Create a BLAS routine:
+	* var mod = new dnansumkbn2.Module( mem );
+	* // returns <Module>
+	*
+	* // Initialize the routine:
+	* mod.initializeSync();
+	*
+	* // Define a vector data type:
+	* var dtype = 'float64';
+	*
+	* // Specify a vector length:
+	* var N = 3;
+	*
+	* // Define a pointer (i.e., byte offset) to the first vector element:
+	* var xptr = 0;
+	*
+	* // Write vector values to module memory:
+	* mod.write( xptr, oneTo( N, dtype ) );
+	*
+	* // Perform computation:
+	* var out = mod.main( N, xptr, 1 );
+	* // returns 6.0
+	*/
+	new( mem: Memory ): Module; // newable
+
+	/**
+	* Returns a new WebAssembly module wrapper instance which uses the provided WebAssembly memory instance as its underlying memory.
+	*
+	* @param mem - WebAssembly memory instance
+	* @returns module wrapper instance
+	*
+	* @example
+	* var Memory = require( '@stdlib/wasm/memory' );
+	* var oneTo = require( '@stdlib/array/one-to' );
+	*
+	* // Create a new memory instance with an initial size of 10 pages (640KiB) and a maximum size of 100 pages (6.4MiB):
+	* var mem = new Memory({
+	*     'initial': 10,
+	*     'maximum': 100
+	* });
+	*
+	* // Create a BLAS routine:
+	* var mod = dnansumkbn2.Module( mem );
+	* // returns <Module>
+	*
+	* // Initialize the routine:
+	* mod.initializeSync();
+	*
+	* // Define a vector data type:
+	* var dtype = 'float64';
+	*
+	* // Specify a vector length:
+	* var N = 3;
+	*
+	* // Define a pointer (i.e., byte offset) to the first vector element:
+	* var xptr = 0;
+	*
+	* // Write vector values to module memory:
+	* mod.write( xptr, oneTo( N, dtype ) );
+	*
+	* // Perform computation:
+	* var out = mod.main( N, xptr, 1 );
+	* // returns 6.0
+	*/
+	( mem: Memory ): Module; // callable
+}
+
+/**
+* Interface describing a `dnansumkbn2` WebAssembly module.
+*/
+interface Module extends ModuleWrapper {
+	/**
+	* Computes the sum of double-precision floating-point strided array elements, ignoring `NaN` values and using a second-order iterative Kahan–Babuška algorithm.
+	*
+	* @param N - number of indexed elements
+	* @param xptr - input array pointer (i.e., byte offset)
+	* @param strideX - stride length
+	* @returns sum
+	*
+	* @example
+	* var Float64Array = require( '@stdlib/array/float64' );
+	* var Memory = require( '@stdlib/wasm/memory' );
+	*
+	* // Create a new memory instance with an initial size of 10 pages (640KiB) and a maximum size of 100 pages (6.4MiB):
+	* var mem = new Memory({
+	*     'initial': 10,
+	*     'maximum': 100
+	* });
+	*
+	* // Create a BLAS routine:
+	* var mod = new dnansumkbn2.Module( mem );
+	* // returns <Module>
+	*
+	* // Initialize the routine:
+	* mod.initializeSync();
+	*
+	* // Specify a vector length:
+	* var N = 4;
+	*
+	* // Define a pointer (i.e., byte offset) to the first vector element:
+	* var xptr = 0;
+	*
+	* // Write vector values to module memory:
+	* var x = new Float64Array( [ 1.0, 2.0, 3.0, NaN ] );
+	* mod.write( xptr, x );
+	*
+	* // Perform computation:
+	* var out = mod.main( N, xptr, 1 );
+	* // returns 6.0
+	*/
+	main( N: number, xptr: number, strideX: number ): number;
+
+	/**
+	* Computes the sum of double-precision floating-point strided array elements, ignoring `NaN` values and using a second-order iterative Kahan–Babuška algorithm and alternative indexing semantics.
+	*
+	* @param N - number of indexed elements
+	* @param xptr - input array pointer (i.e., byte offset)
+	* @param strideX - stride length
+	* @param offsetX - starting index
+	* @returns sum
+	*
+	* @example
+	* var Float64Array = require( '@stdlib/array/float64' );
+	* var Memory = require( '@stdlib/wasm/memory' );
+	*
+	* // Create a new memory instance with an initial size of 10 pages (640KiB) and a maximum size of 100 pages (6.4MiB):
+	* var mem = new Memory({
+	*     'initial': 10,
+	*     'maximum': 100
+	* });
+	*
+	* // Create a BLAS routine:
+	* var mod = new dnansumkbn2.Module( mem );
+	* // returns <Module>
+	*
+	* // Initialize the routine:
+	* mod.initializeSync();
+	*
+	* // Specify a vector length:
+	* var N = 4;
+	*
+	* // Define a pointer (i.e., byte offset) to the first vector element:
+	* var xptr = 0;
+	*
+	* // Write vector values to module memory:
+	* var x = new Float64Array( [ 1.0, 2.0, 3.0, NaN ] );
+	* mod.write( xptr, x );
+	*
+	* // Perform computation:
+	* var out = mod.ndarray( N, xptr, 1, 0 );
+	* // returns 6.0
+	*/
+	ndarray( N: number, xptr: number, strideX: number, offsetX: number ): number;
+}
+
+/**
+* Interface describing `dnansumkbn2`.
+*/
+interface Routine extends ModuleWrapper {
+	/**
+	* Computes the sum of double-precision floating-point strided array elements, ignoring `NaN` values and using a second-order iterative Kahan–Babuška algorithm.
+	*
+	* @param N - number of indexed elements
+	* @param x - input array
+	* @param strideX - stride length
+	* @returns sum
+	*
+	* @example
+	* var Float64Array = require( '@stdlib/array/float64' );
+	*
+	* var x = new Float64Array( [ 1.0, -2.0, NaN, 2.0 ] );
+	*
+	* var out = dnansumkbn2.main( 4, x, 1 );
+	* // returns 1.0
+	*/
+	main( N: number, x: Float64Array, strideX: number ): number;
+
+	/**
+	* Computes the sum of double-precision floating-point strided array elements, ignoring `NaN` values and using a second-order iterative Kahan–Babuška algorithm and alternative indexing semantics.
+	*
+	* @param N - number of indexed elements
+	* @param x - input array
+	* @param strideX - stride length
+	* @param offsetX - starting index
+	* @returns sum
+	*
+	* @example
+	* var Float64Array = require( '@stdlib/array/float64' );
+	*
+	* var x = new Float64Array( [ 2.0, 1.0, -2.0, NaN, -2.0, 2.0, 3.0, 4.0 ] );
+	*
+	* var out = dnansumkbn2.ndarray( 4, x, 2, 1 );
+	* // returns 7.0
+	*/
+	ndarray( N: number, x: Float64Array, strideX: number, offsetX: number ): number;
+
+	/**
+	* Returns a new WebAssembly module wrapper instance which uses the provided WebAssembly memory instance as its underlying memory.
+	*
+	* @param mem - WebAssembly memory instance
+	* @returns module wrapper instance
+	*
+	* @example
+	* var Memory = require( '@stdlib/wasm/memory' );
+	* var Float64Array = require( '@stdlib/array/float64' );
+	*
+	* // Create a new memory instance with an initial size of 10 pages (640KiB) and a maximum size of 100 pages (6.4MiB):
+	* var mem = new Memory({
+	*     'initial': 10,
+	*     'maximum': 100
+	* });
+	*
+	* // Create a BLAS routine:
+	* var mod = new dnansumkbn2.Module( mem );
+	* // returns <Module>
+	*
+	* // Initialize the routine:
+	* mod.initializeSync();
+	*
+	* // Specify a vector length:
+	* var N = 4;
+	*
+	* // Define a pointer (i.e., byte offset) to the first vector element:
+	* var xptr = 0;
+	*
+	* // Write vector values to module memory:
+	* var x = new Float64Array( [ 1.0, 2.0, 3.0, NaN ] );
+	* mod.write( xptr, x );
+	*
+	* // Perform computation:
+	* var out = mod.main( N, xptr, 1 );
+	* // returns 6.0
+	*/
+	Module: ModuleConstructor;
+}
+
+/**
+* Computes the sum of double-precision floating-point strided array elements, ignoring `NaN` values and using a second-order iterative Kahan–Babuška algorithm.
+*
+* @param N - number of indexed elements
+* @param x - input array
+* @param strideX - stride length
+* @returns sum
+*
+* @example
+* var Float64Array = require( '@stdlib/array/float64' );
+*
+* var x = new Float64Array( [ 1.0, -2.0, NaN, 2.0 ] );
+*
+* var out = dnansumkbn2.main( 4, x, 1 );
+* // returns 1.0
+*
+* @example
+* var Float64Array = require( '@stdlib/array/float64' );
+*
+* var x = new Float64Array( [ 2.0, 1.0, -2.0, NaN, -2.0, 2.0, 3.0, 4.0 ] );
+*
+* var out = dnansumkbn2.ndarray( 4, x, 2, 1 );
+* // returns 7.0
+*/
+declare var dnansumkbn2: Routine;
+
+
+// EXPORTS //
+
+export = dnansumkbn2;
diff --git a/lib/node_modules/@stdlib/blas/ext/base/wasm/dnansumkbn2/examples/index.js b/lib/node_modules/@stdlib/blas/ext/base/wasm/dnansumkbn2/examples/index.js
new file mode 100644
index 000000000000..0538d95fc3f4
--- /dev/null
+++ b/lib/node_modules/@stdlib/blas/ext/base/wasm/dnansumkbn2/examples/index.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';
+
+var hasWebAssemblySupport = require( '@stdlib/assert/has-wasm-support' );
+var discreteUniform = require( '@stdlib/random/base/discrete-uniform' );
+var bernoulli = require( '@stdlib/random/base/bernoulli' );
+var filledarrayBy = require( '@stdlib/array/filled-by' );
+var dnansumkbn2 = require( './../lib' );
+
+function clbk() {
+	if ( bernoulli( 0.7 ) > 0 ) {
+		return discreteUniform( 0, 100 );
+	}
+	return NaN;
+}
+
+function main() {
+	if ( !hasWebAssemblySupport() ) {
+		console.error( 'Environment does not support WebAssembly.' );
+		return;
+	}
+	// Specify a vector length:
+	var N = 4;
+
+	// Create an input array:
+	var x = filledarrayBy( 4, 'float64', clbk );
+
+	// Perform computation:
+	var sum = dnansumkbn2.ndarray( N, x, 1, 0 );
+
+	// Print the result:
+	console.log( sum );
+}
+
+main();
diff --git a/lib/node_modules/@stdlib/blas/ext/base/wasm/dnansumkbn2/examples/little_endian_arrays.js b/lib/node_modules/@stdlib/blas/ext/base/wasm/dnansumkbn2/examples/little_endian_arrays.js
new file mode 100644
index 000000000000..e51c00667a13
--- /dev/null
+++ b/lib/node_modules/@stdlib/blas/ext/base/wasm/dnansumkbn2/examples/little_endian_arrays.js
@@ -0,0 +1,65 @@
+/**
+* @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 hasWebAssemblySupport = require( '@stdlib/assert/has-wasm-support' );
+var Memory = require( '@stdlib/wasm/memory' );
+var discreteUniform = require( '@stdlib/random/base/discrete-uniform' ).factory;
+var gfillBy = require( '@stdlib/blas/ext/base/gfill-by' );
+var Float64ArrayLE = require( '@stdlib/array/little-endian-float64' );
+var dnansumkbn2 = require( './../lib' );
+
+function main() {
+	if ( !hasWebAssemblySupport() ) {
+		console.error( 'Environment does not support WebAssembly.' );
+		return;
+	}
+	// Create a new memory instance with an initial size of 10 pages (640KiB) and a maximum size of 100 pages (6.4MiB):
+	var mem = new Memory({
+		'initial': 10,
+		'maximum': 100
+	});
+
+	// Create a BLAS routine:
+	var mod = new dnansumkbn2.Module( mem );
+	// returns <Module>
+
+	// Initialize the routine:
+	mod.initializeSync(); // eslint-disable-line node/no-sync
+
+	// Specify a vector length:
+	var N = 3;
+
+	// Define a pointer (i.e., byte offset) for storing the input vector:
+	var xptr = 0;
+
+	// Create a typed array view over module memory:
+	var x = new Float64ArrayLE( mod.memory.buffer, xptr, N );
+
+	// Write values to module memory:
+	gfillBy( N, x, 1, discreteUniform( -10.0, 10.0 ) );
+
+	// Perform computation:
+	var sum = mod.ndarray( N, xptr, 1, 0 );
+
+	// Print the result:
+	console.log( sum );
+}
+
+main();
diff --git a/lib/node_modules/@stdlib/blas/ext/base/wasm/dnansumkbn2/examples/module.js b/lib/node_modules/@stdlib/blas/ext/base/wasm/dnansumkbn2/examples/module.js
new file mode 100644
index 000000000000..5794c188fcd2
--- /dev/null
+++ b/lib/node_modules/@stdlib/blas/ext/base/wasm/dnansumkbn2/examples/module.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 hasWebAssemblySupport = require( '@stdlib/assert/has-wasm-support' );
+var Memory = require( '@stdlib/wasm/memory' );
+var Float64Array = require( '@stdlib/array/float64' );
+var dnansumkbn2 = require( './../lib' );
+
+function main() {
+	if ( !hasWebAssemblySupport() ) {
+		console.error( 'Environment does not support WebAssembly.' );
+		return;
+	}
+	// Create a new memory instance with an initial size of 10 pages (640KiB) and a maximum size of 100 pages (6.4MiB):
+	var mem = new Memory({
+		'initial': 10,
+		'maximum': 100
+	});
+
+	// Create a BLAS routine:
+	var mod = new dnansumkbn2.Module( mem );
+	// returns <Module>
+
+	// Initialize the routine:
+	mod.initializeSync(); // eslint-disable-line node/no-sync
+
+	// Specify a vector length:
+	var N = 3;
+
+	// Define a pointer (i.e., byte offset) for storing the input vector:
+	var xptr = 0;
+
+	// Write vector values to module memory:
+	var x = new Float64Array( [ 1.0, 2.0, 3.0, NaN ] );
+	mod.write( xptr, x );
+
+	// Perform computation:
+	var sum = mod.ndarray( N, xptr, 1, 0 );
+
+	// Print the result:
+	console.log( sum );
+}
+
+main();
diff --git a/lib/node_modules/@stdlib/blas/ext/base/wasm/dnansumkbn2/lib/binary.browser.js b/lib/node_modules/@stdlib/blas/ext/base/wasm/dnansumkbn2/lib/binary.browser.js
new file mode 100644
index 000000000000..1835d968bf8d
--- /dev/null
+++ b/lib/node_modules/@stdlib/blas/ext/base/wasm/dnansumkbn2/lib/binary.browser.js
@@ -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.
+*/
+
+'use strict';
+
+// MODULES //
+
+var base64ToUint8Array = require( '@stdlib/string/base/base64-to-uint8array' );
+
+
+// MAIN //
+
+var wasm = base64ToUint8Array( 'AGFzbQEAAAAADwhkeWxpbmsuMAEEAAAAAAETA2AAAGADf39/AXxgBH9/f38BfAIPAQNlbnYGbWVtb3J5AgAAAwQDAAECB1cDEV9fd2FzbV9jYWxsX2N0b3JzAAAac3RkbGliX3N0cmlkZWRfZG5hbnN1bWtibjIAASJzdGRsaWJfc3RyaWRlZF9kbmFuc3Vta2JuMl9uZGFycmF5AAIKnQMDAwABCxoAIAAgASACQQEgAGsgAmxBACACQQBMGxACC/sCAgV8A38CQCAAQQBMDQACQAJAIAIEQANAIAAgCUYNBCAJQQFqIQkgA0EDdCELIAIgA2oiCiEDIAEgC2orAwAiBCAEYg0ACyAERAAAAAAAAAAAYQ0BIAkhA0EBIQsMAgsgASADQQN0aisDACIEIARiDQIgBCAAuKIPCyAAIAkgACAJShshAwNAIAAgCUwEQEEAIQsMAgsgASAKQQN0aisDACIFIAVhBEAgBUQAAAAAAAAAAGIEQEEBIQsgCSEDDAMLIAQgBaAhBAsgCUEBaiEJIAIgCmohCgwACwALIAMgACAAIANIGyEARAAAAAAAAAAAIQUDQCAAIANGRQRAIAEgCkEDdGorAwAiBiAGYQRAIAcgBiAEIAQgBqAiCKGgIAQgBiAIoaAgBJkgBplmGyIEIAUgBSAEoCIGoaAgBSAEIAahoCAFmSAEmWYboCEHIAYhBSAIIQQLIANBAWohAyACIApqIQoMAQsLIAcgBCAFoKAgBCALGyEFCyAFCw==' );
+
+
+// EXPORTS //
+
+module.exports = wasm;
diff --git a/lib/node_modules/@stdlib/blas/ext/base/wasm/dnansumkbn2/lib/binary.js b/lib/node_modules/@stdlib/blas/ext/base/wasm/dnansumkbn2/lib/binary.js
new file mode 100644
index 000000000000..2b83fe651780
--- /dev/null
+++ b/lib/node_modules/@stdlib/blas/ext/base/wasm/dnansumkbn2/lib/binary.js
@@ -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.
+*/
+
+'use strict';
+
+// MODULES //
+
+var resolve = require( 'path' ).resolve;
+var readWASM = require( '@stdlib/fs/read-wasm' ).sync;
+
+
+// MAIN //
+
+var wasm = readWASM( resolve( __dirname, '..', 'src', 'main.wasm' ) );
+
+
+// EXPORTS //
+
+module.exports = wasm;
diff --git a/lib/node_modules/@stdlib/blas/ext/base/wasm/dnansumkbn2/lib/index.js b/lib/node_modules/@stdlib/blas/ext/base/wasm/dnansumkbn2/lib/index.js
new file mode 100644
index 000000000000..89f10d287d9d
--- /dev/null
+++ b/lib/node_modules/@stdlib/blas/ext/base/wasm/dnansumkbn2/lib/index.js
@@ -0,0 +1,97 @@
+/**
+* @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';
+
+/**
+* WebAssembly routine to compute the sum of double-precision floating-point strided array elements, ignoring `NaN` values and using a second-order iterative Kahan–Babuška algorithm.
+*
+* @module @stdlib/blas/ext/base/wasm/dnansumkbn2
+*
+* @example
+* var Float64Array = require( '@stdlib/array/float64' );
+* var dnansumkbn2 = require( '@stdlib/blas/ext/base/wasm/dnansumkbn2' );
+*
+* // Define a strided array:
+* var x = new Float64Array( [ 1.0, -2.0, NaN, 2.0 ] );
+*
+* // Perform operation:
+* var v = dnansumkbn2.main( x.length, x, 1 );
+* // returns 1.0
+*
+* @example
+* var Float64Array = require( '@stdlib/array/float64' );
+* var dnansumkbn2 = require( '@stdlib/blas/ext/base/wasm/dnansumkbn2' );
+*
+* // Define a strided array:
+* var x = new Float64Array( [ 2.0, 1.0, -2.0, NaN, -2.0, 2.0, 3.0, 4.0 ] );
+*
+* // Perform operation:
+* var v = dnansumkbn2.ndarray( 4, x, 2, 1 );
+* // returns 7.0
+*
+* @example
+* var Memory = require( '@stdlib/wasm/memory' );
+* var Float64Array = require( '@stdlib/array/float64' );
+* var dnansumkbn2 = require( '@stdlib/blas/ext/base/wasm/dnansumkbn2' );
+*
+* // Create a new memory instance with an initial size of 10 pages (640KiB) and a maximum size of 100 pages (6.4MiB):
+* var mem = new Memory({
+*     'initial': 10,
+*     'maximum': 100
+* });
+*
+* // Create a BLAS routine:
+* var mod = new dnansumkbn2.Module( mem );
+* // returns <Module>
+*
+* // Initialize the routine:
+* mod.initializeSync();
+*
+* // Specify a vector length:
+* var N = 4;
+*
+* // Define a pointer (i.e., byte offset) for storing the input vector:
+* var xptr = 0;
+*
+* // Write vector values to module memory:
+* var x = new Float64Array( [ 1.0, 2.0, 3.0, NaN ] );
+* mod.write( xptr, x );
+*
+* // Perform computation:
+* var sum = mod.main( N, xptr, 1 );
+* // returns 6.0
+*/
+
+// MODULES //
+
+var setReadOnly = require( '@stdlib/utils/define-nonenumerable-read-only-property' );
+var main = require( './main.js' );
+var Module = require( './module.js' );
+
+
+// MAIN //
+
+setReadOnly( main, 'Module', Module );
+
+
+// EXPORTS //
+
+module.exports = main;
+
+// exports: { "Module": "main.Module" }
diff --git a/lib/node_modules/@stdlib/blas/ext/base/wasm/dnansumkbn2/lib/main.js b/lib/node_modules/@stdlib/blas/ext/base/wasm/dnansumkbn2/lib/main.js
new file mode 100644
index 000000000000..1c3e0b5344fc
--- /dev/null
+++ b/lib/node_modules/@stdlib/blas/ext/base/wasm/dnansumkbn2/lib/main.js
@@ -0,0 +1,62 @@
+/**
+* @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 Routine = require( './routine.js' );
+
+
+// MAIN //
+
+/**
+* WebAssembly routine to compute the sum of double-precision floating-point strided array elements, ignoring `NaN` values and using a second-order iterative Kahan–Babuška algorithm.
+*
+* @name dnansumkbn2
+* @type {Routine}
+*
+* @example
+* var Float64Array = require( '@stdlib/array/float64' );
+* var dnansumkbn2 = require( '@stdlib/blas/ext/base/wasm/dnansumkbn2' );
+*
+* // Define a strided array:
+* var x = new Float64Array( [ 1.0, -2.0, NaN, 2.0 ] );
+*
+* // Perform operation:
+* var v = dnansumkbn2.main( 4, x, 1 );
+* // returns 1.0
+*
+* @example
+* var Float64Array = require( '@stdlib/array/float64' );
+* var dnansumkbn2 = require( '@stdlib/blas/ext/base/wasm/dnansumkbn2' );
+*
+* // Define a strided array:
+* var x = new Float64Array( [ 2.0, 1.0, -2.0, NaN, -2.0, 2.0, 3.0, 4.0 ] );
+*
+* // Perform operation:
+* var v = dnansumkbn2.ndarray( 4, x, 2, 1 );
+* // returns 7.0
+*/
+var dnansumkbn2 = new Routine();
+dnansumkbn2.initializeSync(); // eslint-disable-line node/no-sync
+
+
+// EXPORTS //
+
+module.exports = dnansumkbn2;
diff --git a/lib/node_modules/@stdlib/blas/ext/base/wasm/dnansumkbn2/lib/module.js b/lib/node_modules/@stdlib/blas/ext/base/wasm/dnansumkbn2/lib/module.js
new file mode 100644
index 000000000000..6f88e4aeb708
--- /dev/null
+++ b/lib/node_modules/@stdlib/blas/ext/base/wasm/dnansumkbn2/lib/module.js
@@ -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.
+*/
+
+/* eslint-disable no-restricted-syntax, no-invalid-this */
+
+'use strict';
+
+// MODULES //
+
+var isWebAssemblyMemory = require( '@stdlib/assert/is-wasm-memory' );
+var setReadOnly = require( '@stdlib/utils/define-nonenumerable-read-only-property' );
+var inherits = require( '@stdlib/utils/inherit' );
+var WasmModule = require( '@stdlib/wasm/module-wrapper' );
+var format = require( '@stdlib/string/format' );
+var wasmBinary = require( './binary.js' );
+
+
+// MAIN //
+
+/**
+* BLAS routine WebAssembly module wrapper constructor.
+*
+* @constructor
+* @param {Object} memory - WebAssembly memory instance
+* @throws {TypeError} must provide a WebAssembly memory instance
+* @returns {Module} module instance
+*
+* @example
+* var Memory = require( '@stdlib/wasm/memory' );
+* var Float64Array = require( '@stdlib/array/float64' );
+*
+* // Create a new memory instance with an initial size of 10 pages (640KiB) and a maximum size of 100 pages (6.4MiB):
+* var mem = new Memory({
+*     'initial': 10,
+*     'maximum': 100
+* });
+*
+* // Create a BLAS routine:
+* var dnansumkbn2 = new Module( mem );
+* // returns <Module>
+*
+* // Initialize the routine:
+* dnansumkbn2.initializeSync();
+*
+* // Specify a vector length:
+* var N = 4;
+*
+* // Define a pointer (i.e., byte offset) for storing the input vector:
+* var xptr = 0;
+*
+* // Write vector values to module memory:
+* var x = new Float64Array( [ 1.0, 2.0, 3.0, NaN ] );
+* dnansumkbn2.write( xptr, x );
+*
+* // Perform computation:
+* var sum = dnansumkbn2.main( N, xptr, 1 );
+* // returns 6.0
+*/
+function Module( memory ) {
+	if ( !( this instanceof Module ) ) {
+		return new Module( memory );
+	}
+	if ( !isWebAssemblyMemory( memory ) ) {
+		throw new TypeError( format( 'invalid argument. Must provide a WebAssembly memory instance. Value: `%s`.', memory ) );
+	}
+	// Call the parent constructor:
+	WasmModule.call( this, wasmBinary, memory, {
+		'env': {
+			'memory': memory
+		}
+	});
+
+	return this;
+}
+
+// Inherit from the parent constructor:
+inherits( Module, WasmModule );
+
+/**
+* Computes the sum of double-precision floating-point strided array elements, ignoring `NaN` values and using a second-order iterative Kahan–Babuška algorithm.
+*
+* @name main
+* @memberof Module.prototype
+* @readonly
+* @type {Function}
+* @param {PositiveInteger} N - number of indexed elements
+* @param {NonNegativeInteger} xptr - input array pointer (i.e., byte offset)
+* @param {integer} strideX - stride length
+* @returns {number} sum
+*
+* @example
+* var Memory = require( '@stdlib/wasm/memory' );
+* var Float64Array = require( '@stdlib/array/float64' )
+*
+* // Create a new memory instance with an initial size of 10 pages (640KiB) and a maximum size of 100 pages (6.4MiB):
+* var mem = new Memory({
+*     'initial': 10,
+*     'maximum': 100
+* });
+*
+* // Create a BLAS routine:
+* var dnansumkbn2 = new Module( mem );
+* // returns <Module>
+*
+* // Initialize the routine:
+* dnansumkbn2.initializeSync();
+*
+* // Specify a vector length:
+* var N = 4;
+*
+* // Define a pointer (i.e., byte offset) for storing the input vector:
+* var xptr = 0;
+*
+* // Write vector values to module memory:
+* var x = new Float64Array( [ 1.0, 2.0, 3.0, NaN ] );
+* dnansumkbn2.write( xptr, x );
+*
+* // Perform computation:
+* var sum = dnansumkbn2.main( N, xptr, 1 );
+* // returns 6.0
+*/
+setReadOnly( Module.prototype, 'main', function dnansumkbn2( N, xptr, strideX ) {
+	return this._instance.exports.stdlib_strided_dnansumkbn2( N, xptr, strideX );
+});
+
+/**
+* Computes the sum of double-precision floating-point strided array elements, ignoring `NaN` values and using a second-order iterative Kahan–Babuška algorithm.
+*
+* @name ndarray
+* @memberof Module.prototype
+* @readonly
+* @type {Function}
+* @param {PositiveInteger} N - number of indexed elements
+* @param {NonNegativeInteger} xptr - input array pointer (i.e., byte offset)
+* @param {integer} strideX - stride length
+* @param {NonNegativeInteger} offsetX - starting index
+* @returns {number} sum
+*
+* @example
+* var Memory = require( '@stdlib/wasm/memory' );
+* var Float64Array = require( '@stdlib/array/float64' );
+*
+* // Create a new memory instance with an initial size of 10 pages (640KiB) and a maximum size of 100 pages (6.4MiB):
+* var mem = new Memory({
+*     'initial': 10,
+*     'maximum': 100
+* });
+*
+* // Create a BLAS routine:
+* var dnansumkbn2 = new Module( mem );
+* // returns <Module>
+*
+* // Initialize the routine:
+* dnansumkbn2.initializeSync();
+*
+* // Specify a vector length:
+* var N = 4;
+*
+* // Define a pointer (i.e., byte offset) for storing the input vector:
+* var xptr = 0;
+*
+* // Write vector values to module memory:
+* var x = new Float64Array( [ 1.0, 2.0, 3.0, NaN ] );
+* dnansumkbn2.write( xptr, x );
+*
+* // Perform computation:
+* var sum = dnansumkbn2.ndarray( N, xptr, 1, 0 );
+* // returns 6.0
+*/
+setReadOnly( Module.prototype, 'ndarray', function dnansumkbn2( N, xptr, strideX, offsetX ) {
+	return this._instance.exports.stdlib_strided_dnansumkbn2_ndarray( N, xptr, strideX, offsetX ); // eslint-disable-line max-len
+});
+
+
+// EXPORTS //
+
+module.exports = Module;
diff --git a/lib/node_modules/@stdlib/blas/ext/base/wasm/dnansumkbn2/lib/routine.js b/lib/node_modules/@stdlib/blas/ext/base/wasm/dnansumkbn2/lib/routine.js
new file mode 100644
index 000000000000..887a022e1809
--- /dev/null
+++ b/lib/node_modules/@stdlib/blas/ext/base/wasm/dnansumkbn2/lib/routine.js
@@ -0,0 +1,166 @@
+/**
+* @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, no-restricted-syntax, no-invalid-this */
+
+'use strict';
+
+// MODULES //
+
+var setReadOnly = require( '@stdlib/utils/define-nonenumerable-read-only-property' );
+var inherits = require( '@stdlib/utils/inherit' );
+var stride2offset = require( '@stdlib/strided/base/stride2offset' );
+var Memory = require( '@stdlib/wasm/memory' );
+var arrays2ptrs = require( '@stdlib/wasm/base/arrays2ptrs' );
+var strided2object = require( '@stdlib/wasm/base/strided2object' );
+var Module = require( './module.js' );
+
+
+// MAIN //
+
+/**
+* Routine constructor.
+*
+* @private
+* @constructor
+* @returns {Routine} routine instance
+*
+* @example
+* var Float64Array = require( '@stdlib/array/float64' );
+*
+* // Create a new routine:
+* var dnansumkbn2 = new Routine();
+*
+* // Initialize the module:
+* dnansumkbn2.initializeSync();
+*
+* // Define a strided array:
+* var x = new Float64Array( [ 1.0, -2.0, NaN, 2.0 ] );
+*
+* // Perform operation:
+* var sum = dnansumkbn2.main( 4, x, 1 );
+* // returns 1.0
+*
+* @example
+* var Float64Array = require( '@stdlib/array/float64' );
+*
+* // Create a new routine:
+* var dnansumkbn2 = new Routine();
+*
+* // Initialize the module:
+* dnansumkbn2.initializeSync();
+*
+* // Define a strided array:
+* var x = new Float64Array( [ 2.0, 1.0, -2.0, NaN, -2.0, 2.0, 3.0, 4.0 ] );
+*
+* // Perform operation:
+* var sum = dnansumkbn2.ndarray( 4, x, 2, 1 );
+* // returns 7.0
+*/
+function Routine() {
+	if ( !( this instanceof Routine ) ) {
+		return new Routine();
+	}
+	Module.call( this, new Memory({
+		'initial': 0
+	}));
+	return this;
+}
+
+// Inherit from the parent constructor:
+inherits( Routine, Module );
+
+/**
+* Computes the sum of double-precision floating-point strided array elements, ignoring `NaN` values and using a second-order iterative Kahan–Babuška algorithm.
+*
+* @name main
+* @memberof Routine.prototype
+* @readonly
+* @type {Function}
+* @param {PositiveInteger} N - number of indexed elements
+* @param {Float64Array} x - input array
+* @param {integer} strideX - stride length
+* @returns {number} sum
+*
+* @example
+* var Float64Array = require( '@stdlib/array/float64' );
+*
+* // Create a new routine:
+* var dnansumkbn2 = new Routine();
+*
+* // Initialize the module:
+* dnansumkbn2.initializeSync();
+*
+* // Define a strided array:
+* var x = new Float64Array( [ 1.0, -2.0, NaN, 2.0 ] );
+*
+* // Perform operation:
+* var sum = dnansumkbn2.main( 4, x, 1 );
+* // returns 1.0
+*/
+setReadOnly( Routine.prototype, 'main', function dnansumkbn2( N, x, strideX ) {
+	return this.ndarray( N, x, strideX, stride2offset( N, strideX ) );
+});
+
+/**
+* Computes the sum of double-precision floating-point strided array elements, ignoring `NaN` values and using a second-order iterative Kahan–Babuška algorithm and alternative indexing semantics.
+*
+* @name ndarray
+* @memberof Routine.prototype
+* @readonly
+* @type {Function}
+* @param {PositiveInteger} N - number of indexed elements
+* @param {Float64Array} x - input array
+* @param {integer} strideX - stride length
+* @param {NonNegativeInteger} offsetX - starting index
+* @returns {number} sum
+*
+* @example
+* var Float64Array = require( '@stdlib/array/float64' );
+*
+* // Create a new routine:
+* var dnansumkbn2 = new Routine();
+*
+* // Initialize the module:
+* dnansumkbn2.initializeSync();
+*
+* // Define a strided array:
+* var x = new Float64Array( [ 2.0, 1.0, -2.0, NaN, -2.0, 2.0, 3.0, 4.0 ] );
+*
+* // Perform operation:
+* var sum = dnansumkbn2.ndarray( 4, x, 2, 1 );
+* // returns 7.0
+*/
+setReadOnly( Routine.prototype, 'ndarray', function dnansumkbn2( N, x, strideX, offsetX ) {
+	var ptrs;
+	var p0;
+
+	// Convert the input arrays to "pointers" in the module's memory:
+	ptrs = arrays2ptrs( this, [
+		strided2object( N, x, strideX, offsetX )
+	]);
+	p0 = ptrs[ 0 ];
+
+	// Perform computation by calling the corresponding parent method:
+	return Module.prototype.ndarray.call( this, N, p0.ptr, p0.stride, p0.offset );
+});
+
+
+// EXPORTS //
+
+module.exports = Routine;
diff --git a/lib/node_modules/@stdlib/blas/ext/base/wasm/dnansumkbn2/manifest.json b/lib/node_modules/@stdlib/blas/ext/base/wasm/dnansumkbn2/manifest.json
new file mode 100644
index 000000000000..83471c579196
--- /dev/null
+++ b/lib/node_modules/@stdlib/blas/ext/base/wasm/dnansumkbn2/manifest.json
@@ -0,0 +1,36 @@
+{
+    "options": {},
+    "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": [
+      {
+        "src": [],
+        "include": [],
+        "libraries": [],
+        "libpath": [],
+        "dependencies": [
+          "@stdlib/blas/ext/base/dnansumkbn2"
+        ]
+      }
+    ]
+  }
diff --git a/lib/node_modules/@stdlib/blas/ext/base/wasm/dnansumkbn2/package.json b/lib/node_modules/@stdlib/blas/ext/base/wasm/dnansumkbn2/package.json
new file mode 100644
index 000000000000..9d4c4f937d2f
--- /dev/null
+++ b/lib/node_modules/@stdlib/blas/ext/base/wasm/dnansumkbn2/package.json
@@ -0,0 +1,81 @@
+{
+  "name": "@stdlib/blas/ext/base/wasm/dnansumkbn2",
+  "version": "0.0.0",
+  "description": "Compute the sum of double-precision floating-point strided array elements, ignoring `NaN` values and using a second-order iterative Kahan–Babuška algorithm.",
+  "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",
+  "browser": {
+    "./lib/binary.js": "./lib/binary.browser.js"
+  },
+  "directories": {
+    "benchmark": "./benchmark",
+    "doc": "./docs",
+    "example": "./examples",
+    "lib": "./lib",
+    "scripts": "./scripts",
+    "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",
+    "statistics",
+    "stats",
+    "mathematics",
+    "math",
+    "blas",
+    "extended",
+    "sum",
+    "total",
+    "summation",
+    "strided",
+    "strided array",
+    "typed",
+    "array",
+    "float64",
+    "double",
+    "float64array",
+    "wasm",
+    "webassembly"
+  ],
+  "__stdlib__": {
+    "wasm": true
+  }
+}
diff --git a/lib/node_modules/@stdlib/blas/ext/base/wasm/dnansumkbn2/scripts/build.js b/lib/node_modules/@stdlib/blas/ext/base/wasm/dnansumkbn2/scripts/build.js
new file mode 100644
index 000000000000..5f54efd4e40f
--- /dev/null
+++ b/lib/node_modules/@stdlib/blas/ext/base/wasm/dnansumkbn2/scripts/build.js
@@ -0,0 +1,66 @@
+#!/usr/bin/env node
+
+/**
+* @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 readFile = require( '@stdlib/fs/read-file' ).sync;
+var writeFile = require( '@stdlib/fs/write-file' ).sync;
+var replace = require( '@stdlib/string/replace' );
+
+
+// VARIABLES //
+
+var wpath = resolve( __dirname, '..', 'src', 'main.wasm' );
+var tpath = resolve( __dirname, 'template.txt' );
+var opath = resolve( __dirname, '..', 'lib', 'binary.browser.js' );
+var currentYear = require( '@stdlib/time/current-year' );
+
+var opts = {
+	'encoding': 'utf8'
+};
+
+var PLACEHOLDER = '{{WASM_BASE64}}';
+var YEAR = '{{YEAR}}';
+
+
+// MAIN //
+
+/**
+* Main execution sequence.
+*
+* @private
+*/
+function main() {
+	var wasm;
+	var tmpl;
+
+	wasm = readFile( wpath );
+	tmpl = readFile( tpath, opts );
+
+	tmpl = replace( tmpl, YEAR, currentYear().toString() );
+	tmpl = replace( tmpl, PLACEHOLDER, wasm.toString( 'base64' ) );
+
+	writeFile( opath, tmpl, opts );
+}
+
+main();
diff --git a/lib/node_modules/@stdlib/blas/ext/base/wasm/dnansumkbn2/scripts/template.txt b/lib/node_modules/@stdlib/blas/ext/base/wasm/dnansumkbn2/scripts/template.txt
new file mode 100644
index 000000000000..c5ce3488619c
--- /dev/null
+++ b/lib/node_modules/@stdlib/blas/ext/base/wasm/dnansumkbn2/scripts/template.txt
@@ -0,0 +1,34 @@
+
+/**
+* @license Apache-2.0
+*
+* Copyright (c) {{YEAR}} 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 base64ToUint8Array = require( '@stdlib/string/base/base64-to-uint8array' );
+
+
+// MAIN //
+
+var wasm = base64ToUint8Array( '{{WASM_BASE64}}' );
+
+
+// EXPORTS //
+
+module.exports = wasm;
diff --git a/lib/node_modules/@stdlib/blas/ext/base/wasm/dnansumkbn2/src/Makefile b/lib/node_modules/@stdlib/blas/ext/base/wasm/dnansumkbn2/src/Makefile
new file mode 100644
index 000000000000..1b1f35347760
--- /dev/null
+++ b/lib/node_modules/@stdlib/blas/ext/base/wasm/dnansumkbn2/src/Makefile
@@ -0,0 +1,243 @@
+#/
+# @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.
+#/
+
+#/
+# To compile targets listed in this Makefile, use top-level project `make`
+# commands rather than commands listed in this Makefile. The top-level project
+# `make` commands will ensure that various environment variables and flags are
+# appropriately set.
+#/
+
+# 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 to WebAssembly:
+ifdef EMCC_COMPILER
+	EMCC := $(EMCC_COMPILER)
+else
+	EMCC := emcc
+endif
+
+# Define the program used for compiling WebAssembly files to the WebAssembly text format:
+ifdef WASM2WAT
+	WASM_TO_WAT := $(WASM2WAT)
+else
+	WASM_TO_WAT := wasm2wat
+endif
+
+# Define the program used for compiling WebAssembly files to JavaScript:
+ifdef WASM2JS
+	WASM_TO_JS := $(WASM2JS)
+else
+	WASM_TO_JS := wasm2js
+endif
+
+# Define the path to the Node.js executable:
+ifdef NODE
+	NODEJS := $(NODE)
+else
+	NODEJS := node
+endif
+
+# Define the integer size:
+ifdef CBLAS_INT
+	INT_TYPE := $(CBLAS_INT)
+else
+	INT_TYPE := int32_t
+endif
+
+# Define the command-line options when compiling C files:
+CFLAGS ?= \
+	-std=c99 \
+	-O3 \
+	-flto \
+	-Wall \
+	-pedantic \
+	-D CBLAS_INT=$(INT_TYPE)
+
+# Define the command-line options when compiling C files to WebAssembly and asm.js:
+EMCCFLAGS ?= $(CFLAGS)
+
+# Define shared `emcc` flags:
+EMCC_SHARED_FLAGS := \
+	-Oz \
+	-fwasm-exceptions \
+	-s SUPPORT_LONGJMP=1 \
+	-s SIDE_MODULE=2 \
+	-s EXPORTED_FUNCTIONS="$(shell cat exports.json | tr -d ' \t\n' | sed s/\"/\'/g)"
+
+# Define WebAssembly `emcc` flags:
+EMCC_WASM_FLAGS := $(EMCC_SHARED_FLAGS) \
+	-s WASM=1 \
+	-s WASM_BIGINT=0
+
+# 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 WebAssembly targets:
+wasm_targets := main.wasm
+
+# List of WebAssembly WAT targets:
+wat_targets := main.wat
+
+# List of WebAssembly JavaScript targets:
+wasm_js_targets := main.wasm.js
+
+# List of other JavaScript targets:
+browser_js_targets := ./../lib/binary.browser.js
+
+
+# RULES #
+
+#/
+# Compiles source files.
+#
+# @param {string} [EMCC_COMPILER] - EMCC compiler (e.g., `emcc`)
+# @param {string} [EMCCFLAGS] - EMCC compiler options
+# @param {string} [WASM2WAT] - WebAssembly text format compiler (e.g., `wasm2wat`)
+# @param {string} [WASM2JS] - WebAssembly JavaScript compiler (e.g., `wasm2js`)
+# @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: wasm
+
+.PHONY: all
+
+#/
+# Compiles source files to WebAssembly.
+#
+# @param {string} [EMCC_COMPILER] - EMCC compiler (e.g., `emcc`)
+# @param {string} [EMCCFLAGS] - EMCC compiler options
+# @param {string} [WASM2WAT] - WebAssembly text format compiler (e.g., `wasm2wat`)
+# @param {string} [WASM2JS] - WebAssembly JavaScript compiler (e.g., `wasm2js`)
+# @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 wasm
+#/
+wasm: $(wasm_targets) $(wat_targets) $(browser_js_targets)
+
+.PHONY: wasm
+
+#/
+# Compiles C source files to WebAssembly binaries.
+#
+# @private
+# @param {string} EMCC - EMCC compiler (e.g., `emcc`)
+# @param {string} EMCCFLAGS - EMCC compiler options
+# @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`)
+#/
+$(wasm_targets):
+	$(QUIET) $(EMCC) $(EMCCFLAGS) $(EMCC_WASM_FLAGS) $(INCLUDE) -o $@ $(SOURCE_FILES) $< $(LIBPATH) $(LIBRARIES)
+
+#/
+# Compiles WebAssembly binary files to the WebAssembly text format.
+#
+# @private
+# @param {string} WASM2WAT - WAT compiler (e.g., `wasm2wat`)
+#/
+$(wat_targets): %.wat: %.wasm
+	$(QUIET) $(WASM_TO_WAT) -o $@ $(wasm_targets)
+
+#/
+# Compiles WebAssembly binary files to JavaScript.
+#
+# @private
+# @param {string} WASM2JS - JavaScript compiler (e.g., `wasm2js`)
+#/
+$(wasm_js_targets): %.wasm.js: %.wasm
+	$(QUIET) $(WASM_TO_JS) -o $@ $(wasm_targets)
+
+#/
+# Generates an inline WebAssembly build for use in bundlers.
+#
+# @private
+# @param {string} NODE - Node.js executable
+#/
+$(browser_js_targets): $(wasm_targets)
+	$(QUIET) $(NODEJS) ./../scripts/build.js
+
+#/
+# Removes generated WebAssembly files.
+#
+# @example
+# make clean-wasm
+#/
+clean-wasm:
+	$(QUIET) -rm -f *.wasm *.wat *.wasm.js $(browser_js_targets)
+
+.PHONY: clean-wasm
+
+#/
+# Removes generated files.
+#
+# @example
+# make clean
+#/
+clean: clean-wasm
+
+.PHONY: clean
diff --git a/lib/node_modules/@stdlib/blas/ext/base/wasm/dnansumkbn2/src/exports.json b/lib/node_modules/@stdlib/blas/ext/base/wasm/dnansumkbn2/src/exports.json
new file mode 100644
index 000000000000..383f963b32a8
--- /dev/null
+++ b/lib/node_modules/@stdlib/blas/ext/base/wasm/dnansumkbn2/src/exports.json
@@ -0,0 +1,4 @@
+[
+    "_stdlib_strided_dnansumkbn2",
+    "_stdlib_strided_dnansumkbn2_ndarray"
+  ]
diff --git a/lib/node_modules/@stdlib/blas/ext/base/wasm/dnansumkbn2/src/main.wasm b/lib/node_modules/@stdlib/blas/ext/base/wasm/dnansumkbn2/src/main.wasm
new file mode 100755
index 000000000000..f8ce9d9d0cd7
Binary files /dev/null and b/lib/node_modules/@stdlib/blas/ext/base/wasm/dnansumkbn2/src/main.wasm differ
diff --git a/lib/node_modules/@stdlib/blas/ext/base/wasm/dnansumkbn2/src/main.wat b/lib/node_modules/@stdlib/blas/ext/base/wasm/dnansumkbn2/src/main.wat
new file mode 100644
index 000000000000..6582cd67549b
--- /dev/null
+++ b/lib/node_modules/@stdlib/blas/ext/base/wasm/dnansumkbn2/src/main.wat
@@ -0,0 +1,251 @@
+;; @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.
+
+(module
+  (type (;0;) (func))
+  (type (;1;) (func (param i32 i32 i32) (result f64)))
+  (type (;2;) (func (param i32 i32 i32 i32) (result f64)))
+  (import "env" "memory" (memory (;0;) 0))
+  (func (;0;) (type 0)
+    nop)
+  (func (;1;) (type 1) (param i32 i32 i32) (result f64)
+    local.get 0
+    local.get 1
+    local.get 2
+    i32.const 1
+    local.get 0
+    i32.sub
+    local.get 2
+    i32.mul
+    i32.const 0
+    local.get 2
+    i32.const 0
+    i32.le_s
+    select
+    call 2)
+  (func (;2;) (type 2) (param i32 i32 i32 i32) (result f64)
+    (local f64 f64 f64 f64 f64 i32 i32 i32)
+    block  ;; label = @1
+      local.get 0
+      i32.const 0
+      i32.le_s
+      br_if 0 (;@1;)
+      block  ;; label = @2
+        block  ;; label = @3
+          local.get 2
+          if  ;; label = @4
+            loop  ;; label = @5
+              local.get 0
+              local.get 9
+              i32.eq
+              br_if 4 (;@1;)
+              local.get 9
+              i32.const 1
+              i32.add
+              local.set 9
+              local.get 3
+              i32.const 3
+              i32.shl
+              local.set 11
+              local.get 2
+              local.get 3
+              i32.add
+              local.tee 10
+              local.set 3
+              local.get 1
+              local.get 11
+              i32.add
+              f64.load
+              local.tee 4
+              local.get 4
+              f64.ne
+              br_if 0 (;@5;)
+            end
+            local.get 4
+            f64.const 0x0p+0 (;=0;)
+            f64.eq
+            br_if 1 (;@3;)
+            local.get 9
+            local.set 3
+            i32.const 1
+            local.set 11
+            br 2 (;@2;)
+          end
+          local.get 1
+          local.get 3
+          i32.const 3
+          i32.shl
+          i32.add
+          f64.load
+          local.tee 4
+          local.get 4
+          f64.ne
+          br_if 2 (;@1;)
+          local.get 4
+          local.get 0
+          f64.convert_i32_u
+          f64.mul
+          return
+        end
+        local.get 0
+        local.get 9
+        local.get 0
+        local.get 9
+        i32.gt_s
+        select
+        local.set 3
+        loop  ;; label = @3
+          local.get 0
+          local.get 9
+          i32.le_s
+          if  ;; label = @4
+            i32.const 0
+            local.set 11
+            br 2 (;@2;)
+          end
+          local.get 1
+          local.get 10
+          i32.const 3
+          i32.shl
+          i32.add
+          f64.load
+          local.tee 5
+          local.get 5
+          f64.eq
+          if  ;; label = @4
+            local.get 5
+            f64.const 0x0p+0 (;=0;)
+            f64.ne
+            if  ;; label = @5
+              i32.const 1
+              local.set 11
+              local.get 9
+              local.set 3
+              br 3 (;@2;)
+            end
+            local.get 4
+            local.get 5
+            f64.add
+            local.set 4
+          end
+          local.get 9
+          i32.const 1
+          i32.add
+          local.set 9
+          local.get 2
+          local.get 10
+          i32.add
+          local.set 10
+          br 0 (;@3;)
+        end
+        unreachable
+      end
+      local.get 3
+      local.get 0
+      local.get 0
+      local.get 3
+      i32.lt_s
+      select
+      local.set 0
+      f64.const 0x0p+0 (;=0;)
+      local.set 5
+      loop  ;; label = @2
+        local.get 0
+        local.get 3
+        i32.eq
+        i32.eqz
+        if  ;; label = @3
+          local.get 1
+          local.get 10
+          i32.const 3
+          i32.shl
+          i32.add
+          f64.load
+          local.tee 6
+          local.get 6
+          f64.eq
+          if  ;; label = @4
+            local.get 7
+            local.get 6
+            local.get 4
+            local.get 4
+            local.get 6
+            f64.add
+            local.tee 8
+            f64.sub
+            f64.add
+            local.get 4
+            local.get 6
+            local.get 8
+            f64.sub
+            f64.add
+            local.get 4
+            f64.abs
+            local.get 6
+            f64.abs
+            f64.ge
+            select
+            local.tee 4
+            local.get 5
+            local.get 5
+            local.get 4
+            f64.add
+            local.tee 6
+            f64.sub
+            f64.add
+            local.get 5
+            local.get 4
+            local.get 6
+            f64.sub
+            f64.add
+            local.get 5
+            f64.abs
+            local.get 4
+            f64.abs
+            f64.ge
+            select
+            f64.add
+            local.set 7
+            local.get 6
+            local.set 5
+            local.get 8
+            local.set 4
+          end
+          local.get 3
+          i32.const 1
+          i32.add
+          local.set 3
+          local.get 2
+          local.get 10
+          i32.add
+          local.set 10
+          br 1 (;@2;)
+        end
+      end
+      local.get 7
+      local.get 4
+      local.get 5
+      f64.add
+      f64.add
+      local.get 4
+      local.get 11
+      select
+      local.set 5
+    end
+    local.get 5)
+  (export "__wasm_call_ctors" (func 0))
+  (export "stdlib_strided_dnansumkbn2" (func 1))
+  (export "stdlib_strided_dnansumkbn2_ndarray" (func 2)))


Test patch:
diff --git a/lib/node_modules/@stdlib/blas/ext/base/wasm/dnansumkbn2/docs/types/test.ts b/lib/node_modules/@stdlib/blas/ext/base/wasm/dnansumkbn2/docs/types/test.ts
new file mode 100644
index 000000000000..7bc7926a480d
--- /dev/null
+++ b/lib/node_modules/@stdlib/blas/ext/base/wasm/dnansumkbn2/docs/types/test.ts
@@ -0,0 +1,345 @@
+/*
+* @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 Memory = require( '@stdlib/wasm/memory' );
+import dnansumkbn2 = require( './index' );
+
+
+// TESTS //
+
+// Attached to the main export is a `main` method which returns a number...
+{
+	const x = new Float64Array( 10 );
+
+	dnansumkbn2.main( x.length, x, 1 ); // $ExpectType number
+}
+
+// The compiler throws an error if the `main` method is provided a first argument which is not a number...
+{
+	const x = new Float64Array( 10 );
+
+	dnansumkbn2.main( '10', x, 1 ); // $ExpectError
+	dnansumkbn2.main( true, x, 1 ); // $ExpectError
+	dnansumkbn2.main( false, x, 1 ); // $ExpectError
+	dnansumkbn2.main( null, x, 1 ); // $ExpectError
+	dnansumkbn2.main( undefined, x, 1 ); // $ExpectError
+	dnansumkbn2.main( [], x, 1 ); // $ExpectError
+	dnansumkbn2.main( {}, x, 1 ); // $ExpectError
+	dnansumkbn2.main( ( x: number ): number => x, x, 1 ); // $ExpectError
+}
+
+// The compiler throws an error if the `main` method is provided a second argument which is not a Float64Array...
+{
+	const x = new Float64Array( 10 );
+
+	dnansumkbn2.main( x.length, '10', 1 ); // $ExpectError
+	dnansumkbn2.main( x.length, true, 1 ); // $ExpectError
+	dnansumkbn2.main( x.length, false, 1 ); // $ExpectError
+	dnansumkbn2.main( x.length, null, 1 ); // $ExpectError
+	dnansumkbn2.main( x.length, undefined, 1 ); // $ExpectError
+	dnansumkbn2.main( x.length, [], 1 ); // $ExpectError
+	dnansumkbn2.main( x.length, {}, 1 ); // $ExpectError
+	dnansumkbn2.main( x.length, ( x: number ): number => x, 1 ); // $ExpectError
+}
+
+// The compiler throws an error if the `main` method is provided a third argument which is not a number...
+{
+	const x = new Float64Array( 10 );
+
+	dnansumkbn2.main( x.length, x, '10' ); // $ExpectError
+	dnansumkbn2.main( x.length, x, true ); // $ExpectError
+	dnansumkbn2.main( x.length, x, false ); // $ExpectError
+	dnansumkbn2.main( x.length, x, null ); // $ExpectError
+	dnansumkbn2.main( x.length, x, undefined ); // $ExpectError
+	dnansumkbn2.main( x.length, x, [] ); // $ExpectError
+	dnansumkbn2.main( x.length, x, {} ); // $ExpectError
+	dnansumkbn2.main( x.length, x, ( x: number ): number => x ); // $ExpectError
+}
+
+// The compiler throws an error if the `main` method is provided an unsupported number of arguments...
+{
+	const x = new Float64Array( 10 );
+
+	dnansumkbn2.main(); // $ExpectError
+	dnansumkbn2.main( x.length ); // $ExpectError
+	dnansumkbn2.main( x.length, x ); // $ExpectError
+	dnansumkbn2.main( x.length, x, 1, 10, 2 ); // $ExpectError
+}
+
+// Attached to main export is an `ndarray` method which returns a number...
+{
+	const x = new Float64Array( 10 );
+
+	dnansumkbn2.ndarray( x.length, x, 1, 0 ); // $ExpectType number
+}
+
+// The compiler throws an error if the `ndarray` method is provided a first argument which is not a number...
+{
+	const x = new Float64Array( 10 );
+
+	dnansumkbn2.ndarray( '10', x, 1, 0 ); // $ExpectError
+	dnansumkbn2.ndarray( true, x, 1, 0 ); // $ExpectError
+	dnansumkbn2.ndarray( false, x, 1, 0 ); // $ExpectError
+	dnansumkbn2.ndarray( null, x, 1, 0 ); // $ExpectError
+	dnansumkbn2.ndarray( undefined, x, 1, 0 ); // $ExpectError
+	dnansumkbn2.ndarray( [], x, 1, 0 ); // $ExpectError
+	dnansumkbn2.ndarray( {}, x, 1, 0 ); // $ExpectError
+	dnansumkbn2.ndarray( ( x: number ): number => x, x, 1, 0 ); // $ExpectError
+}
+
+// The compiler throws an error if the `ndarray` method is provided a second argument which is not a Float64Array...
+{
+	const x = new Float64Array( 10 );
+
+	dnansumkbn2.ndarray( x.length, '10', 1, 0 ); // $ExpectError
+	dnansumkbn2.ndarray( x.length, true, 1, 0 ); // $ExpectError
+	dnansumkbn2.ndarray( x.length, false, 1, 0 ); // $ExpectError
+	dnansumkbn2.ndarray( x.length, null, 1, 0 ); // $ExpectError
+	dnansumkbn2.ndarray( x.length, undefined, 1, 0 ); // $ExpectError
+	dnansumkbn2.ndarray( x.length, [], 1, 0 ); // $ExpectError
+	dnansumkbn2.ndarray( x.length, {}, 1, 0 ); // $ExpectError
+	dnansumkbn2.ndarray( x.length, ( x: number ): number => x, 1, 0 ); // $ExpectError
+}
+
+// The compiler throws an error if the `ndarray` method is provided a third argument which is not a number...
+{
+	const x = new Float64Array( 10 );
+
+	dnansumkbn2.ndarray( x.length, x, '10', 0 ); // $ExpectError
+	dnansumkbn2.ndarray( x.length, x, true, 0 ); // $ExpectError
+	dnansumkbn2.ndarray( x.length, x, false, 0 ); // $ExpectError
+	dnansumkbn2.ndarray( x.length, x, null, 0 ); // $ExpectError
+	dnansumkbn2.ndarray( x.length, x, undefined, 0 ); // $ExpectError
+	dnansumkbn2.ndarray( x.length, x, [], 0 ); // $ExpectError
+	dnansumkbn2.ndarray( x.length, x, {}, 0 ); // $ExpectError
+	dnansumkbn2.ndarray( x.length, x, ( x: number ): number => x, 0 ); // $ExpectError
+}
+
+// The compiler throws an error if the `ndarray` method is provided a fourth argument which is not a number...
+{
+	const x = new Float64Array( 10 );
+
+	dnansumkbn2.ndarray( x.length, x, 1, '10' ); // $ExpectError
+	dnansumkbn2.ndarray( x.length, x, 1, true ); // $ExpectError
+	dnansumkbn2.ndarray( x.length, x, 1, false ); // $ExpectError
+	dnansumkbn2.ndarray( x.length, x, 1, null ); // $ExpectError
+	dnansumkbn2.ndarray( x.length, x, 1, undefined ); // $ExpectError
+	dnansumkbn2.ndarray( x.length, x, 1, [] ); // $ExpectError
+	dnansumkbn2.ndarray( x.length, x, 1, {} ); // $ExpectError
+	dnansumkbn2.ndarray( x.length, x, 1, ( x: number ): number => x ); // $ExpectError
+}
+
+// The compiler throws an error if the `ndarray` method is provided an unsupported number of arguments...
+{
+	const x = new Float64Array( 10 );
+
+	dnansumkbn2.ndarray(); // $ExpectError
+	dnansumkbn2.ndarray( x.length ); // $ExpectError
+	dnansumkbn2.ndarray( x.length, x ); // $ExpectError
+	dnansumkbn2.ndarray( x.length, x, 1 ); // $ExpectError
+	dnansumkbn2.ndarray( x.length, x, 1, 0, 10, 2 ); // $ExpectError
+}
+
+// Attached to the main export is a `Module` constructor which returns a module...
+{
+	const mem = new Memory({
+		'initial': 0
+	});
+
+	dnansumkbn2.Module( mem ); // $ExpectType Module
+}
+
+// The compiler throws an error if the `Module` constructor is not provided a WebAssembly memory instance...
+{
+	dnansumkbn2.Module( '10' ); // $ExpectError
+	dnansumkbn2.Module( true ); // $ExpectError
+	dnansumkbn2.Module( false ); // $ExpectError
+	dnansumkbn2.Module( null ); // $ExpectError
+	dnansumkbn2.Module( undefined ); // $ExpectError
+	dnansumkbn2.Module( [] ); // $ExpectError
+	dnansumkbn2.Module( {} ); // $ExpectError
+	dnansumkbn2.Module( ( x: number ): number => x ); // $ExpectError
+}
+
+// The `Module` constructor returns a module instance having a `main` method which returns a number...
+{
+	const mem = new Memory({
+		'initial': 1
+	});
+	const mod = dnansumkbn2.Module( mem );
+
+	mod.main( 10, 0, 1 ); // $ExpectType number
+}
+
+// The compiler throws an error if the `main` method of a module instance is provided a first argument which is not a number...
+{
+	const mem = new Memory({
+		'initial': 1
+	});
+	const mod = dnansumkbn2.Module( mem );
+
+	mod.main( '10', 0, 1 ); // $ExpectError
+	mod.main( true, 0, 1 ); // $ExpectError
+	mod.main( false, 0, 1 ); // $ExpectError
+	mod.main( null, 0, 1 ); // $ExpectError
+	mod.main( undefined, 0, 1 ); // $ExpectError
+	mod.main( [], 0, 1 ); // $ExpectError
+	mod.main( {}, 0, 1 ); // $ExpectError
+	mod.main( ( x: number ): number => x, 0, 1 ); // $ExpectError
+}
+
+// The compiler throws an error if the `main` method of a module instance is provided a second argument which is not a number...
+{
+	const mem = new Memory({
+		'initial': 1
+	});
+	const mod = dnansumkbn2.Module( mem );
+
+	mod.main( 10, '10', 1 ); // $ExpectError
+	mod.main( 10, true, 1 ); // $ExpectError
+	mod.main( 10, false, 1 ); // $ExpectError
+	mod.main( 10, null, 1 ); // $ExpectError
+	mod.main( 10, undefined, 1 ); // $ExpectError
+	mod.main( 10, [], 1 ); // $ExpectError
+	mod.main( 10, {}, 1 ); // $ExpectError
+	mod.main( 10, ( x: number ): number => x, 1 ); // $ExpectError
+}
+
+// The compiler throws an error if the `main` method of a module instance is provided a third argument which is not a number...
+{
+	const mem = new Memory({
+		'initial': 1
+	});
+	const mod = dnansumkbn2.Module( mem );
+
+	mod.main( 10, 0, '10' ); // $ExpectError
+	mod.main( 10, 0, true ); // $ExpectError
+	mod.main( 10, 0, false ); // $ExpectError
+	mod.main( 10, 0, null ); // $ExpectError
+	mod.main( 10, 0, undefined ); // $ExpectError
+	mod.main( 10, 0, [] ); // $ExpectError
+	mod.main( 10, 0, {} ); // $ExpectError
+	mod.main( 10, 0, ( x: number ): number => x ); // $ExpectError
+}
+
+// The compiler throws an error if the `main` method of a module instance is provided an unsupported number of arguments...
+{
+	const mem = new Memory({
+		'initial': 1
+	});
+	const mod = dnansumkbn2.Module( mem );
+
+	mod.main(); // $ExpectError
+	mod.main( 10 ); // $ExpectError
+	mod.main( 10, 0 ); // $ExpectError
+	mod.main( 10, 0, 1, 5 ); // $ExpectError
+}
+
+// The `Module` constructor returns a module instance having an `ndarray` method which returns a number...
+{
+	const mem = new Memory({
+		'initial': 1
+	});
+	const mod = dnansumkbn2.Module( mem );
+
+	mod.ndarray( 10, 0, 1, 0 ); // $ExpectType number
+}
+
+// The compiler throws an error if the `ndarray` method of a module instance is provided a first argument which is not a number...
+{
+	const mem = new Memory({
+		'initial': 1
+	});
+	const mod = dnansumkbn2.Module( mem );
+
+	mod.ndarray( '10', 0, 1, 0 ); // $ExpectError
+	mod.ndarray( true, 0, 1, 0 ); // $ExpectError
+	mod.ndarray( false, 0, 1, 0 ); // $ExpectError
+	mod.ndarray( null, 0, 1, 0 ); // $ExpectError
+	mod.ndarray( undefined, 0, 1, 0 ); // $ExpectError
+	mod.ndarray( [], 0, 1, 0 ); // $ExpectError
+	mod.ndarray( {}, 0, 1, 0 ); // $ExpectError
+	mod.ndarray( ( x: number ): number => x, 0, 1, 0 ); // $ExpectError
+}
+
+// The compiler throws an error if the `ndarray` method of a module instance is provided a second argument which is not a number...
+{
+	const mem = new Memory({
+		'initial': 1
+	});
+	const mod = dnansumkbn2.Module( mem );
+
+	mod.ndarray( 5.0, '10', 0, 1 ); // $ExpectError
+	mod.ndarray( 5.0, true, 0, 1 ); // $ExpectError
+	mod.ndarray( 5.0, false, 0, 1 ); // $ExpectError
+	mod.ndarray( 5.0, null, 0, 1 ); // $ExpectError
+	mod.ndarray( 5.0, undefined, 0, 1 ); // $ExpectError
+	mod.ndarray( 5.0, [], 0, 1 ); // $ExpectError
+	mod.ndarray( 5.0, {}, 0, 1 ); // $ExpectError
+	mod.ndarray( 5.0, ( x: number ): number => x, 0, 1 ); // $ExpectError
+}
+
+// The compiler throws an error if the `ndarray` method of a module instance is provided a third argument which is not a number...
+{
+	const mem = new Memory({
+		'initial': 1
+	});
+	const mod = dnansumkbn2.Module( mem );
+
+	mod.ndarray( 10, 0, '10', 0 ); // $ExpectError
+	mod.ndarray( 10, 0, true, 0 ); // $ExpectError
+	mod.ndarray( 10, 0, false, 0 ); // $ExpectError
+	mod.ndarray( 10, 0, null, 0 ); // $ExpectError
+	mod.ndarray( 10, 0, undefined, 0 ); // $ExpectError
+	mod.ndarray( 10, 0, [], 0 ); // $ExpectError
+	mod.ndarray( 10, 0, {}, 0 ); // $ExpectError
+	mod.ndarray( 10, 0, ( x: number ): number => x, 0 ); // $ExpectError
+}
+
+// The compiler throws an error if the `ndarray` method of a module instance is provided a fourth argument which is not a number...
+{
+	const mem = new Memory({
+		'initial': 1
+	});
+	const mod = dnansumkbn2.Module( mem );
+
+	mod.ndarray( 10, 0, 1, '10' ); // $ExpectError
+	mod.ndarray( 10, 0, 1, true ); // $ExpectError
+	mod.ndarray( 10, 0, 1, false ); // $ExpectError
+	mod.ndarray( 10, 0, 1, null ); // $ExpectError
+	mod.ndarray( 10, 0, 1, undefined ); // $ExpectError
+	mod.ndarray( 10, 0, 1, [] ); // $ExpectError
+	mod.ndarray( 10, 0, 1, {} ); // $ExpectError
+	mod.ndarray( 10, 0, 1, ( x: number ): number => x ); // $ExpectError
+}
+
+// The compiler throws an error if the `ndarray` method of a module instance is provided an unsupported number of arguments...
+{
+	const mem = new Memory({
+		'initial': 1
+	});
+	const mod = dnansumkbn2.Module( mem );
+
+	mod.ndarray(); // $ExpectError
+	mod.ndarray( 10 ); // $ExpectError
+	mod.ndarray( 10, 0 ); // $ExpectError
+	mod.ndarray( 10, 0, 1 ); // $ExpectError
+	mod.ndarray( 10, 0, 1, 0, 10 ); // $ExpectError
+}
diff --git a/lib/node_modules/@stdlib/blas/ext/base/wasm/dnansumkbn2/test/test.js b/lib/node_modules/@stdlib/blas/ext/base/wasm/dnansumkbn2/test/test.js
new file mode 100644
index 000000000000..5c9d41f542f6
--- /dev/null
+++ b/lib/node_modules/@stdlib/blas/ext/base/wasm/dnansumkbn2/test/test.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 tape = require( 'tape' );
+var dnansumkbn2 = require( './../lib' );
+
+
+// TESTS //
+
+tape( 'main export is an object', function test( t ) {
+	t.ok( true, __filename );
+	t.strictEqual( typeof dnansumkbn2, 'object', 'returns expected value' );
+	t.end();
+});
+
+tape( 'attached to the main export is a `main` method', function test( t ) {
+	t.strictEqual( typeof dnansumkbn2.main, 'function', 'returns expected value' );
+	t.end();
+});
+
+tape( 'attached to the main export is an `ndarray` method', function test( t ) {
+	t.strictEqual( typeof dnansumkbn2.ndarray, 'function', 'returns expected value' );
+	t.end();
+});
+
+tape( 'attached to the main export is a `Module` constructor', function test( t ) {
+	t.strictEqual( typeof dnansumkbn2.Module, 'function', 'returns expected value' );
+	t.end();
+});
+
+tape( 'the main export is a `Module` instance', function test( t ) {
+	t.strictEqual( dnansumkbn2 instanceof dnansumkbn2.Module, true, 'returns expected value' );
+	t.end();
+});
diff --git a/lib/node_modules/@stdlib/blas/ext/base/wasm/dnansumkbn2/test/test.main.js b/lib/node_modules/@stdlib/blas/ext/base/wasm/dnansumkbn2/test/test.main.js
new file mode 100644
index 000000000000..2399723bb84f
--- /dev/null
+++ b/lib/node_modules/@stdlib/blas/ext/base/wasm/dnansumkbn2/test/test.main.js
@@ -0,0 +1,202 @@
+/**
+* @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 Float64Array = require( '@stdlib/array/float64' );
+var dnansumkbn2 = require( './../lib' );
+
+
+// TESTS //
+
+tape( 'main export is an object', function test( t ) {
+	t.ok( true, __filename );
+	t.strictEqual( typeof dnansumkbn2, 'object', 'main export is an object' );
+	t.end();
+});
+
+tape( 'the function has an arity of 3', function test( t ) {
+	t.strictEqual( dnansumkbn2.main.length, 3, 'returns expected value' );
+	t.end();
+});
+
+tape( 'the function calculates the sum of strided array elements (ignoring NaN values)', function test( t ) {
+	var x;
+	var v;
+
+	x = new Float64Array( [ 1.0, -2.0, -4.0, 5.0, 0.0, NaN, 3.0, 0.0, -3.0, 3.0, NaN ] ); // eslint-disable-line max-len
+	v = dnansumkbn2.main( x.length, x, 1 );
+	t.strictEqual( v, 3.0, 'returns expected value' );
+
+	x = new Float64Array( [ 1.0, -2.0, -4.0, NaN, 5.0, 0.0, 3.0, NaN ] );
+	v = dnansumkbn2.main( x.length, x, 1 );
+	t.strictEqual( v, 3.0, 'returns expected value' );
+
+	x = new Float64Array( [ -4.0, NaN, -4.0 ] );
+	v = dnansumkbn2.main( x.length, x, 1 );
+	t.strictEqual( v, -8.0, 'returns expected value' );
+
+	x = new Float64Array( [ NaN, 4.0 ] );
+	v = dnansumkbn2.main( x.length, x, 1 );
+	t.strictEqual( v, 4.0, 'returns expected value' );
+
+	x = new Float64Array( [ NaN, NaN ] );
+	v = dnansumkbn2.main( x.length, x, 1 );
+	t.strictEqual( v, 0.0, 'returns expected value' );
+
+	x = new Float64Array( [ NaN ] );
+	v = dnansumkbn2.main( x.length, x, 1 );
+	t.strictEqual( v, 0.0, 'returns expected value' );
+
+	x = new Float64Array( [ 4.0 ] );
+	v = dnansumkbn2.main( x.length, x, 1 );
+	t.strictEqual( v, 4.0, 'returns expected value' );
+
+	x = new Float64Array( [ 1.0, 1.0e100, 1.0, -1.0e100 ] );
+	v = dnansumkbn2.main( x.length, x, 1 );
+	t.strictEqual( v, 2.0, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'if provided a `stride` parameter equal to `0` and the first element is NaN, the function returns 0', function test( t ) {
+	var x;
+	var v;
+
+	x = new Float64Array( [ NaN, -2.0, -4.0, 5.0, 3.0 ] );
+
+	v = dnansumkbn2.main( x.length, x, 0 );
+	t.strictEqual( v, 0.0, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'if provided an `N` parameter less than or equal to `0`, the function returns `0.0`', function test( t ) {
+	var x;
+	var v;
+
+	x = new Float64Array( [ 1.0, -2.0, -4.0, 5.0, 3.0 ] );
+
+	v = dnansumkbn2.main( 0, x, 1 );
+	t.strictEqual( v, 0.0, 'returns expected value' );
+
+	v = dnansumkbn2.main( -1, x, 1 );
+	t.strictEqual( v, 0.0, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'if provided an `N` parameter equal to `1`, the function returns the first element', function test( t ) {
+	var x;
+	var v;
+
+	x = new Float64Array( [ 1.0, -2.0, -4.0, 5.0, 3.0 ] );
+
+	v = dnansumkbn2.main( 1, x, 1 );
+	t.strictEqual( v, 1.0, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function supports a `stride` parameter', 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,
+		NaN,  // 4
+		NaN
+	]);
+
+	v = dnansumkbn2.main( 5, x, 2 );
+
+	t.strictEqual( v, 5.0, 'returns expected value' );
+	t.end();
+});
+
+tape( 'the function supports a negative `stride` parameter', function test( t ) {
+	var x;
+	var v;
+
+	x = new Float64Array([
+		NaN,  // 4
+		NaN,
+		1.0,  // 3
+		2.0,
+		2.0,  // 2
+		-7.0,
+		-2.0, // 1
+		3.0,
+		4.0,  // 0
+		2.0
+	]);
+
+	v = dnansumkbn2.main( 5, x, -2 );
+
+	t.strictEqual( v, 5.0, 'returns expected value' );
+	t.end();
+});
+
+tape( 'if provided a `stride` parameter equal to `0`, the function returns the sum of the first element repeated N times', function test( t ) {
+	var x;
+	var v;
+
+	x = new Float64Array( [ 1.0, -2.0, -4.0, 5.0, 3.0 ] );
+
+	v = dnansumkbn2.main( x.length, x, 0 );
+	t.strictEqual( v, 5.0, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function supports view offsets', function test( t ) {
+	var x0;
+	var x1;
+	var v;
+
+	x0 = new Float64Array([
+		2.0,
+		1.0,  // 0
+		2.0,
+		-2.0, // 1
+		-2.0,
+		2.0,  // 2
+		3.0,
+		4.0,  // 3
+		6.0,
+		NaN,  // 4
+		NaN
+	]);
+
+	x1 = new Float64Array( x0.buffer, x0.BYTES_PER_ELEMENT*1 ); // start at 2nd element
+
+	v = dnansumkbn2.main( 5, x1, 2 );
+	t.strictEqual( v, 5.0, 'returns expected value' );
+
+	t.end();
+});
diff --git a/lib/node_modules/@stdlib/blas/ext/base/wasm/dnansumkbn2/test/test.module.js b/lib/node_modules/@stdlib/blas/ext/base/wasm/dnansumkbn2/test/test.module.js
new file mode 100644
index 000000000000..0cdcd97ef151
--- /dev/null
+++ b/lib/node_modules/@stdlib/blas/ext/base/wasm/dnansumkbn2/test/test.module.js
@@ -0,0 +1,154 @@
+/**
+* @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 Memory = require( '@stdlib/wasm/memory' );
+var ModuleWrapper = require( '@stdlib/wasm/module-wrapper' );
+var Module = require( './../lib' ).Module;
+
+
+// TESTS //
+
+tape( 'main export is a function', function test( t ) {
+	t.ok( true, __filename );
+	t.strictEqual( typeof Module, 'function', 'returns expected value' );
+	t.end();
+});
+
+tape( 'the function is a constructor', function test( t ) {
+	var mem;
+	var mod;
+
+	mem = new Memory({
+		'initial': 0
+	});
+	mod = new Module( mem );
+	t.strictEqual( mod instanceof Module, true, 'returns expected value' );
+	t.end();
+});
+
+tape( 'the function is a constructor which does not require `new`', function test( t ) {
+	var mem;
+	var mod;
+
+	mem = new Memory({
+		'initial': 0
+	});
+	mod = Module( mem ); // eslint-disable-line new-cap
+	t.strictEqual( mod instanceof Module, true, 'returns expected value' );
+	t.end();
+});
+
+tape( 'the module constructor throws an error if provided a first argument which is not a WebAssembly memory instance (new)', 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() {
+			return new Module( value );
+		};
+	}
+});
+
+tape( 'the module constructor throws an error if provided a first argument which is not a WebAssembly memory instance (no new)', 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() {
+			return Module( value ); // eslint-disable-line new-cap
+		};
+	}
+});
+
+tape( 'the module instance returned by the module constructor inherits from a module wrapper', function test( t ) {
+	var mem;
+	var mod;
+
+	mem = new Memory({
+		'initial': 0
+	});
+	mod = new Module( mem );
+
+	t.strictEqual( mod instanceof ModuleWrapper, true, 'returns expected value' );
+	t.end();
+});
+
+tape( 'attached to a module instance is a `main` method', function test( t ) {
+	var mem;
+	var mod;
+
+	mem = new Memory({
+		'initial': 0
+	});
+	mod = new Module( mem );
+
+	t.strictEqual( typeof mod.main, 'function', 'returns expected value' );
+	t.end();
+});
+
+tape( 'attached to a module instance is an `ndarray` method', function test( t ) {
+	var mem;
+	var mod;
+
+	mem = new Memory({
+		'initial': 0
+	});
+	mod = new Module( mem );
+
+	t.strictEqual( typeof mod.ndarray, 'function', 'returns expected value' );
+	t.end();
+});
diff --git a/lib/node_modules/@stdlib/blas/ext/base/wasm/dnansumkbn2/test/test.module.main.js b/lib/node_modules/@stdlib/blas/ext/base/wasm/dnansumkbn2/test/test.module.main.js
new file mode 100644
index 000000000000..20296e46a043
--- /dev/null
+++ b/lib/node_modules/@stdlib/blas/ext/base/wasm/dnansumkbn2/test/test.module.main.js
@@ -0,0 +1,255 @@
+/**
+* @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 node/no-sync */
+
+'use strict';
+
+// MODULES //
+
+var tape = require( 'tape' );
+var Memory = require( '@stdlib/wasm/memory' );
+var Float64Array = require( '@stdlib/array/float64' );
+var Module = require( './../lib' ).Module;
+
+
+// TESTS //
+
+tape( 'main export is a function', function test( t ) {
+	t.ok( true, __filename );
+	t.strictEqual( typeof Module, 'function', 'main export is a function' );
+	t.end();
+});
+
+tape( 'a module instance has a `main` method which has an arity of 3', function test( t ) {
+	var mem;
+	var mod;
+
+	mem = new Memory({
+		'initial': 0
+	});
+	mod = new Module( mem );
+	t.strictEqual( mod.main.length, 3, 'returns expected value' );
+	t.end();
+});
+
+tape( 'a module instance has a `main` method which calculates the sum of strided array elements (ignoring NaN values)', function test( t ) {
+	var mem;
+	var mod;
+	var xp;
+	var v;
+
+	mem = new Memory({
+		'initial': 1
+	});
+	mod = new Module( mem );
+	mod.initializeSync();
+
+	xp = 0;
+
+	mod.write( xp, new Float64Array( [ 1.0, -2.0, -4.0, 5.0, 0.0, NaN, 3.0, 0.0, -3.0, 3.0, NaN ] ) ); // eslint-disable-line max-len
+	v = mod.main( 11, xp, 1 );
+	t.strictEqual( v, 3.0, 'returns expected value' );
+
+	mod.write( xp, new Float64Array( [ 1.0, -2.0, -4.0, NaN, 5.0, 0.0, 3.0, NaN ] ) );
+	v = mod.main( 8, xp, 1 );
+	t.strictEqual( v, 3.0, 'returns expected value' );
+
+	mod.write( xp, new Float64Array( [ -4.0, NaN, -4.0 ] ) );
+	v = mod.main( 3, xp, 1 );
+	t.strictEqual( v, -8.0, 'returns expected value' );
+
+	mod.write( xp, new Float64Array( [ NaN, 4.0 ] ) );
+	v = mod.main( 2, xp, 1 );
+	t.strictEqual( v, 4.0, 'returns expected value' );
+
+	mod.write( xp, new Float64Array( [ NaN, NaN ] ) );
+	v = mod.main( 2, xp, 1 );
+	t.strictEqual( v, 0.0, 'returns expected value' );
+
+	mod.write( xp, new Float64Array( [ NaN ] ) );
+	v = mod.main( 1, xp, 1 );
+	t.strictEqual( v, 0.0, 'returns expected value' );
+
+	mod.write( xp, new Float64Array( [ 4.0 ] ) );
+	v = mod.main( 1, xp, 1 );
+	t.strictEqual( v, 4.0, 'returns expected value' );
+
+	mod.write( xp, new Float64Array( [ 1.0, 1.0e100, 1.0, -1.0e100 ] ) );
+	v = mod.main( 4, xp, 1 );
+	t.strictEqual( v, 2.0, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'if provided a `stride` parameter equal to `0` and the first element is NaN, a module instance has a `main` method which returns 0', function test( t ) {
+	var mem;
+	var mod;
+	var xp;
+	var v;
+
+	mem = new Memory({
+		'initial': 1
+	});
+	mod = new Module( mem );
+	mod.initializeSync();
+
+	xp = 0;
+
+	mod.write( xp, new Float64Array( [ NaN, -2.0, -4.0, 5.0, 3.0 ] ) );
+
+	v = mod.main( 5, xp, 0 );
+	t.strictEqual( v, 0.0, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'if provided an `N` parameter less than or equal to `0`, a module instance has a `main` method which returns `0.0`', function test( t ) {
+	var mem;
+	var mod;
+	var xp;
+	var v;
+
+	mem = new Memory({
+		'initial': 1
+	});
+	mod = new Module( mem );
+	mod.initializeSync();
+
+	xp = 0;
+
+	mod.write( xp, new Float64Array( [ 1.0, -2.0, -4.0, 5.0, 3.0 ] ) );
+
+	v = mod.main( 0, xp, 1 );
+	t.strictEqual( v, 0.0, 'returns expected value' );
+
+	v = mod.main( -1, xp, 1 );
+	t.strictEqual( v, 0.0, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'if provided an `N` parameter equal to `1`, a module instance has a `main` method which returns the first element', function test( t ) {
+	var mem;
+	var mod;
+	var xp;
+	var v;
+
+	mem = new Memory({
+		'initial': 1
+	});
+	mod = new Module( mem );
+	mod.initializeSync();
+
+	xp = 0;
+
+	mod.write( xp, new Float64Array( [ 1.0, -2.0, -4.0, 5.0, 3.0 ] ) );
+
+	v = mod.main( 1, xp, 1 );
+	t.strictEqual( v, 1.0, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'a module instance has an `main` method which supports a `stride` parameter', function test( t ) {
+	var mem;
+	var mod;
+	var xp;
+	var v;
+
+	mem = new Memory({
+		'initial': 1
+	});
+	mod = new Module( mem );
+	mod.initializeSync();
+
+	xp = 0;
+
+	mod.write( xp, new Float64Array([
+		1.0,  // 0
+		2.0,
+		2.0,  // 1
+		-7.0,
+		-2.0, // 2
+		3.0,
+		4.0,  // 3
+		2.0,
+		NaN,  // 4
+		NaN
+	]) );
+
+	v = mod.main( 5, xp, 2 );
+
+	t.strictEqual( v, 5.0, 'returns expected value' );
+	t.end();
+});
+
+tape( 'a module instance has an `main` method which supports a negative `stride` parameter', function test( t ) {
+	var mem;
+	var mod;
+	var xp;
+	var v;
+
+	mem = new Memory({
+		'initial': 1
+	});
+	mod = new Module( mem );
+	mod.initializeSync();
+
+	xp = 0;
+
+	mod.write( xp, new Float64Array([
+		NaN,  // 4
+		NaN,
+		1.0,  // 3
+		2.0,
+		2.0,  // 2
+		-7.0,
+		-2.0, // 1
+		3.0,
+		4.0,  // 0
+		2.0
+	]) );
+
+	v = mod.main( 5, xp, -2 );
+
+	t.strictEqual( v, 5.0, 'returns expected value' );
+	t.end();
+});
+
+tape( 'if provided a `stride` parameter equal to `0`, a module instance has a `main` method which returns the sum of the first element repeated N times', function test( t ) {
+	var mem;
+	var mod;
+	var xp;
+	var v;
+
+	mem = new Memory({
+		'initial': 1
+	});
+	mod = new Module( mem );
+	mod.initializeSync();
+
+	xp = 0;
+
+	mod.write( xp, new Float64Array( [ 1.0, -2.0, -4.0, 5.0, 3.0 ] ) );
+
+	v = mod.main( 5, xp, 0 );
+	t.strictEqual( v, 5.0, 'returns expected value' );
+
+	t.end();
+});
diff --git a/lib/node_modules/@stdlib/blas/ext/base/wasm/dnansumkbn2/test/test.module.ndarray.js b/lib/node_modules/@stdlib/blas/ext/base/wasm/dnansumkbn2/test/test.module.ndarray.js
new file mode 100644
index 000000000000..52db1babd1b7
--- /dev/null
+++ b/lib/node_modules/@stdlib/blas/ext/base/wasm/dnansumkbn2/test/test.module.ndarray.js
@@ -0,0 +1,317 @@
+/**
+* @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 node/no-sync */
+
+'use strict';
+
+// MODULES //
+
+var tape = require( 'tape' );
+var isPositiveZero = require( '@stdlib/math/base/assert/is-positive-zero' );
+var isNegativeZero = require( '@stdlib/math/base/assert/is-negative-zero' );
+var Memory = require( '@stdlib/wasm/memory' );
+var Float64Array = require( '@stdlib/array/float64' );
+var Module = require( './../lib' ).Module;
+
+
+// TESTS //
+
+tape( 'main export is a function', function test( t ) {
+	t.ok( true, __filename );
+	t.strictEqual( typeof Module, 'function', 'main export is a function' );
+	t.end();
+});
+
+tape( 'a module instance has a `ndarray` method which has an arity of 4', function test( t ) {
+	var mem;
+	var mod;
+
+	mem = new Memory({
+		'initial': 0
+	});
+	mod = new Module( mem );
+	t.strictEqual( mod.ndarray.length, 4, 'returns expected value' );
+	t.end();
+});
+
+tape( 'a module instance has an `ndarray` method which calculates the sum of strided array elements (ignoring NaN values)', function test( t ) {
+	var mem;
+	var mod;
+	var xp;
+	var v;
+
+	mem = new Memory({
+		'initial': 1
+	});
+	mod = new Module( mem );
+	mod.initializeSync();
+
+	xp = 0;
+
+	mod.write( xp, new Float64Array( [ 1.0, -2.0, -4.0, 5.0, NaN, 0.0, 3.0, 0.0, -3.0, 3.0 ] ) ); // eslint-disable-line max-len
+	v = mod.ndarray( 11, xp, 1, 0 );
+	t.strictEqual( v, 3.0, 'returns expected value' );
+
+	mod.write( xp, new Float64Array( [ 1.0, -2.0, -4.0, NaN, 5.0, 0.0, 3.0 ] ) );
+	v = mod.ndarray( 7, xp, 1, 0 );
+	t.strictEqual( v, 3.0, 'returns expected value' );
+
+	mod.write( xp, new Float64Array( [ -4.0, -4.0 ] ) );
+	v = mod.ndarray( 2, xp, 1, 0 );
+	t.strictEqual( v, -8.0, 'returns expected value' );
+
+	mod.write( xp, new Float64Array( [ NaN, 4.0 ] ) );
+	v = mod.ndarray( 2, xp, 1, 0 );
+	t.strictEqual( v, 4.0, 'returns expected value' );
+
+	mod.write( xp, new Float64Array( [ NaN, NaN ] ) );
+	v = mod.ndarray( 2, xp, 1, 0 );
+	t.strictEqual( v, 0.0, 'returns expected value' );
+
+	mod.write( xp, new Float64Array( [ NaN ] ) );
+	v = mod.ndarray( 1, xp, 1, 0 );
+	t.strictEqual( v, 0.0, 'returns expected value' );
+
+	mod.write( xp, new Float64Array( [ 4.0 ] ) );
+	v = mod.ndarray( 1, xp, 1, 0 );
+	t.strictEqual( v, 4.0, 'returns expected value' );
+
+	mod.write( xp, new Float64Array( [ 1.0, 1.0e100, 1.0, -1.0e100 ] ) );
+	v = mod.ndarray( 4, xp, 1, 0 );
+	t.strictEqual( v, 2.0, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'a module instance has an `ndarray` method which preserves the sign of zero', function test( t ) {
+	var mem;
+	var mod;
+	var xp;
+	var v;
+
+	mem = new Memory({
+		'initial': 1
+	});
+	mod = new Module( mem );
+	mod.initializeSync();
+
+	xp = 0;
+
+	mod.write( xp, new Float64Array( [ -0.0, -0.0, -0.0 ] ) );
+
+	v = mod.ndarray( 3, xp, 1, 0 );
+	t.strictEqual( isNegativeZero( v ), true, 'returns expected value' );
+
+	mod.write( xp, new Float64Array( [ 0.0, -0.0, -0.0 ] ) );
+
+	v = mod.ndarray( 3, xp, 1, 0 );
+	t.strictEqual( isPositiveZero( v ), true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'if provided a `stride` parameter equal to `0` and the first element is NaN, a module instance has an `ndarray` method which returns 0', function test( t ) {
+	var mem;
+	var mod;
+	var xp;
+	var v;
+
+	mem = new Memory({
+		'initial': 1
+	});
+	mod = new Module( mem );
+	mod.initializeSync();
+
+	xp = 0;
+
+	mod.write( xp, new Float64Array( [ NaN, -2.0, -4.0, 5.0, 3.0 ] ) );
+
+	v = mod.ndarray( 5, xp, 0, 0 );
+	t.strictEqual( v, 0.0, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'if provided an `N` parameter less than or equal to `0`, a module instance has an `ndarray` method which returns `0.0`', function test( t ) {
+	var mem;
+	var mod;
+	var xp;
+	var v;
+
+	mem = new Memory({
+		'initial': 1
+	});
+	mod = new Module( mem );
+	mod.initializeSync();
+
+	xp = 0;
+
+	mod.write( xp, new Float64Array( [ 1.0, -2.0, -4.0, 5.0, 3.0 ] ) );
+
+	v = mod.ndarray( 0, xp, 1, 0 );
+	t.strictEqual( v, 0.0, 'returns expected value' );
+
+	v = mod.ndarray( -1, xp, 1, 0 );
+	t.strictEqual( v, 0.0, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'if provided an `N` parameter equal to `1`, a module instance has an `ndarray` method which returns the first indexed element', function test( t ) {
+	var mem;
+	var mod;
+	var xp;
+	var v;
+
+	mem = new Memory({
+		'initial': 1
+	});
+	mod = new Module( mem );
+	mod.initializeSync();
+
+	xp = 0;
+
+	mod.write( xp, new Float64Array( [ 1.0, -2.0, -4.0, 5.0, 3.0 ] ) );
+
+	v = mod.ndarray( 1, xp, 1, 0 );
+	t.strictEqual( v, 1.0, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'a module instance has an `ndarray` method which supports a `stride` parameter', function test( t ) {
+	var mem;
+	var mod;
+	var xp;
+	var v;
+
+	mem = new Memory({
+		'initial': 1
+	});
+	mod = new Module( mem );
+	mod.initializeSync();
+
+	xp = 0;
+
+	mod.write( xp, new Float64Array([
+		1.0,  // 0
+		2.0,
+		2.0,  // 1
+		-7.0,
+		-2.0, // 2
+		3.0,
+		4.0,  // 3
+		2.0,
+		NaN,  // 4
+		NaN
+	]) );
+
+	v = mod.ndarray( 5, xp, 2, 0 );
+
+	t.strictEqual( v, 5.0, 'returns expected value' );
+	t.end();
+});
+
+tape( 'a module instance has an `ndarray` method which supports a negative `stride` parameter', function test( t ) {
+	var mem;
+	var mod;
+	var xp;
+	var v;
+
+	mem = new Memory({
+		'initial': 1
+	});
+	mod = new Module( mem );
+	mod.initializeSync();
+
+	xp = 0;
+
+	mod.write( xp, new Float64Array([
+		NaN,  // 4
+		NaN,
+		1.0,  // 3
+		2.0,
+		2.0,  // 2
+		-7.0,
+		-2.0, // 1
+		3.0,
+		4.0,  // 0
+		2.0
+	]) );
+
+	v = mod.ndarray( 5, xp, -2, 8 );
+
+	t.strictEqual( v, 5.0, 'returns expected value' );
+	t.end();
+});
+
+tape( 'if provided a `stride` parameter equal to `0`, a module instance has an `ndarray` method which returns the sum of the first element repeated N times', function test( t ) {
+	var mem;
+	var mod;
+	var xp;
+	var v;
+
+	mem = new Memory({
+		'initial': 1
+	});
+	mod = new Module( mem );
+	mod.initializeSync();
+
+	xp = 0;
+
+	mod.write( xp, new Float64Array( [ 1.0, -2.0, -4.0, 5.0, 3.0 ] ) );
+
+	v = mod.ndarray( 5, xp, 0, 0 );
+	t.strictEqual( v, 5.0, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'a module instance has an `ndarray` method which supports an `offset` parameter', function test( t ) {
+	var mem;
+	var mod;
+	var xp;
+	var v;
+
+	mem = new Memory({
+		'initial': 1
+	});
+	mod = new Module( mem );
+	mod.initializeSync();
+
+	xp = 0;
+
+	mod.write( xp, new Float64Array([
+		2.0,
+		1.0,  // 0
+		2.0,
+		-2.0, // 1
+		-2.0,
+		2.0,  // 2
+		3.0,
+		4.0,  // 3
+		NaN,
+		NaN   // 4
+	]) );
+
+	v = mod.ndarray( 5, xp, 2, 1 );
+	t.strictEqual( v, 5.0, 'returns expected value' );
+
+	t.end();
+});
diff --git a/lib/node_modules/@stdlib/blas/ext/base/wasm/dnansumkbn2/test/test.ndarray.js b/lib/node_modules/@stdlib/blas/ext/base/wasm/dnansumkbn2/test/test.ndarray.js
new file mode 100644
index 000000000000..2bc0ed0b9539
--- /dev/null
+++ b/lib/node_modules/@stdlib/blas/ext/base/wasm/dnansumkbn2/test/test.ndarray.js
@@ -0,0 +1,217 @@
+/**
+* @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 isPositiveZero = require( '@stdlib/math/base/assert/is-positive-zero' );
+var isNegativeZero = require( '@stdlib/math/base/assert/is-negative-zero' );
+var Float64Array = require( '@stdlib/array/float64' );
+var dnansumkbn2 = require( './../lib' );
+
+
+// TESTS //
+
+tape( 'main export is an object', function test( t ) {
+	t.ok( true, __filename );
+	t.strictEqual( typeof dnansumkbn2, 'object', 'main export is an object' );
+	t.end();
+});
+
+tape( 'the function has an arity of 4', function test( t ) {
+	t.strictEqual( dnansumkbn2.ndarray.length, 4, 'returns expected value' );
+	t.end();
+});
+
+tape( 'the function calculates the sum of strided array elements (ignoring NaN values)', function test( t ) {
+	var x;
+	var v;
+
+	x = new Float64Array( [ 1.0, -2.0, -4.0, 5.0, NaN, 0.0, 3.0, 0.0, -3.0, 3.0 ] ); // eslint-disable-line max-len
+	v = dnansumkbn2.ndarray( x.length, x, 1, 0 );
+	t.strictEqual( v, 3.0, 'returns expected value' );
+
+	x = new Float64Array( [ 1.0, -2.0, -4.0, NaN, 5.0, 0.0, 3.0 ] );
+	v = dnansumkbn2.ndarray( x.length, x, 1, 0 );
+	t.strictEqual( v, 3.0, 'returns expected value' );
+
+	x = new Float64Array( [ -4.0, -4.0 ] );
+	v = dnansumkbn2.ndarray( x.length, x, 1, 0 );
+	t.strictEqual( v, -8.0, 'returns expected value' );
+
+	x = new Float64Array( [ NaN, 4.0 ] );
+	v = dnansumkbn2.ndarray( x.length, x, 1, 0 );
+	t.strictEqual( v, 4.0, 'returns expected value' );
+
+	x = new Float64Array( [ NaN, NaN ] );
+	v = dnansumkbn2.ndarray( x.length, x, 1, 0 );
+	t.strictEqual( v, 0.0, 'returns expected value' );
+
+	x = new Float64Array( [ NaN ] );
+	v = dnansumkbn2.ndarray( x.length, x, 1, 0 );
+	t.strictEqual( v, 0.0, 'returns expected value' );
+
+	x = new Float64Array( [ 4.0 ] );
+	v = dnansumkbn2.ndarray( x.length, x, 1, 0 );
+	t.strictEqual( v, 4.0, 'returns expected value' );
+
+	x = new Float64Array( [ 1.0, 1.0e100, 1.0, -1.0e100 ] );
+	v = dnansumkbn2.ndarray( x.length, x, 1, 0 );
+	t.strictEqual( v, 2.0, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function preserves the sign of zero', function test( t ) {
+	var x;
+	var v;
+
+	x = new Float64Array( [ -0.0, -0.0, -0.0 ] );
+
+	v = dnansumkbn2.ndarray( x.length, x, 1, 0 );
+	t.strictEqual( isNegativeZero( v ), true, 'returns expected value' );
+
+	x = new Float64Array( [ 0.0, -0.0, -0.0 ] );
+
+	v = dnansumkbn2.ndarray( x.length, x, 1, 0 );
+	t.strictEqual( isPositiveZero( v ), true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'if provided a `stride` parameter equal to `0` and the first element is NaN, the function returns 0', function test( t ) {
+	var x;
+	var v;
+
+	x = new Float64Array( [ NaN, -2.0, -4.0, 5.0, 3.0 ] );
+
+	v = dnansumkbn2.ndarray( x.length, x, 0, 0 );
+	t.strictEqual( v, 0.0, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'if provided an `N` parameter less than or equal to `0`, the function returns `0.0`', function test( t ) {
+	var x;
+	var v;
+
+	x = new Float64Array( [ 1.0, -2.0, -4.0, 5.0, 3.0 ] );
+
+	v = dnansumkbn2.ndarray( 0, x, 1, 0 );
+	t.strictEqual( v, 0.0, 'returns expected value' );
+
+	v = dnansumkbn2.ndarray( -1, x, 1, 0 );
+	t.strictEqual( v, 0.0, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'if provided an `N` parameter equal to `1`, the function returns the first indexed element', function test( t ) {
+	var x;
+	var v;
+
+	x = new Float64Array( [ 1.0, -2.0, -4.0, 5.0, 3.0 ] );
+
+	v = dnansumkbn2.ndarray( 1, x, 1, 0 );
+	t.strictEqual( v, 1.0, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function supports a `stride` parameter', 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,
+		NaN,  // 4
+		NaN
+	]);
+
+	v = dnansumkbn2.ndarray( 5, x, 2, 0 );
+
+	t.strictEqual( v, 5.0, 'returns expected value' );
+	t.end();
+});
+
+tape( 'the function supports a negative `stride` parameter', function test( t ) {
+	var x;
+	var v;
+
+	x = new Float64Array([
+		NaN,  // 4
+		NaN,
+		1.0,  // 3
+		2.0,
+		2.0,  // 2
+		-7.0,
+		-2.0, // 1
+		3.0,
+		4.0,  // 0
+		2.0
+	]);
+
+	v = dnansumkbn2.ndarray( 5, x, -2, 8 );
+
+	t.strictEqual( v, 5.0, 'returns expected value' );
+	t.end();
+});
+
+tape( 'if provided a `stride` parameter equal to `0`, the function returns the sum of the first element repeated N times', function test( t ) {
+	var x;
+	var v;
+
+	x = new Float64Array( [ 1.0, -2.0, -4.0, 5.0, 3.0 ] );
+
+	v = dnansumkbn2.ndarray( x.length, x, 0, 0 );
+	t.strictEqual( v, 5.0, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function supports an `offset` parameter', 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
+		NaN,
+		NaN   // 4
+	]);
+
+	v = dnansumkbn2.ndarray( 5, x, 2, 1 );
+	t.strictEqual( v, 5.0, 'returns expected value' );
+
+	t.end();
+});
diff --git a/lib/node_modules/@stdlib/blas/ext/base/wasm/dnansumkbn2/test/test.routine.js b/lib/node_modules/@stdlib/blas/ext/base/wasm/dnansumkbn2/test/test.routine.js
new file mode 100644
index 000000000000..d90a5804a8e1
--- /dev/null
+++ b/lib/node_modules/@stdlib/blas/ext/base/wasm/dnansumkbn2/test/test.routine.js
@@ -0,0 +1,71 @@
+/**
+* @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 ModuleWrapper = require( '@stdlib/wasm/module-wrapper' );
+var Module = require( './../lib/module.js' );
+var Routine = require( './../lib/routine.js' );
+
+
+// TESTS //
+
+tape( 'main export is a function', function test( t ) {
+	t.ok( true, __filename );
+	t.strictEqual( typeof Routine, 'function', 'returns expected value' );
+	t.end();
+});
+
+tape( 'the function is a constructor', function test( t ) {
+	var mod = new Routine();
+	t.strictEqual( mod instanceof Routine, true, 'returns expected value' );
+	t.end();
+});
+
+tape( 'the function is a constructor which does not require `new`', function test( t ) {
+	var mod = Routine(); // eslint-disable-line new-cap
+	t.strictEqual( mod instanceof Routine, true, 'returns expected value' );
+	t.end();
+});
+
+tape( 'the module instance returned by the constructor inherits from a module wrapper', function test( t ) {
+	var mod = new Routine();
+	t.strictEqual( mod instanceof ModuleWrapper, true, 'returns expected value' );
+	t.end();
+});
+
+tape( 'the module instance returned by the constructor inherits from a BLAS routine module', function test( t ) {
+	var mod = new Routine();
+	t.strictEqual( mod instanceof Module, true, 'returns expected value' );
+	t.end();
+});
+
+tape( 'attached to a module instance is a `main` method', function test( t ) {
+	var mod = new Routine();
+	t.strictEqual( typeof mod.main, 'function', 'returns expected value' );
+	t.end();
+});
+
+tape( 'attached to a module instance is an `ndarray` method', function test( t ) {
+	var mod = new Routine();
+	t.strictEqual( typeof mod.ndarray, 'function', 'returns expected value' );
+	t.end();
+});