From cf73143aae25ed7df3424d2d6226f83bdccb7ccd Mon Sep 17 00:00:00 2001
From: kaustubh <kaustubh.mp007@gmail.com>
Date: Sat, 27 Dec 2025 17:30:14 +0530
Subject: [PATCH 01/10] feat: add blas/ext/base/snancusumkbn

---
 .../blas/ext/base/snancusumkbn/README.md      | 340 ++++++++++++++++
 .../base/snancusumkbn/benchmark/benchmark.js  | 114 ++++++
 .../benchmark/benchmark.native.js             | 119 ++++++
 .../benchmark/benchmark.ndarray.js            | 114 ++++++
 .../benchmark/benchmark.ndarray.native.js     | 119 ++++++
 .../base/snancusumkbn/benchmark/c/Makefile    | 146 +++++++
 .../benchmark/c/benchmark.length.c            | 213 ++++++++++
 .../blas/ext/base/snancusumkbn/binding.gyp    | 170 ++++++++
 .../blas/ext/base/snancusumkbn/docs/repl.txt  | 121 ++++++
 .../base/snancusumkbn/docs/types/index.d.ts   | 106 +++++
 .../ext/base/snancusumkbn/docs/types/test.ts  | 280 ++++++++++++++
 .../ext/base/snancusumkbn/examples/c/Makefile | 146 +++++++
 .../base/snancusumkbn/examples/c/example.c    |  41 ++
 .../ext/base/snancusumkbn/examples/index.js   |  41 ++
 .../blas/ext/base/snancusumkbn/include.gypi   |  53 +++
 .../stdlib/blas/ext/base/snancusumkbn.h       |  45 +++
 .../blas/ext/base/snancusumkbn/lib/index.js   |  70 ++++
 .../blas/ext/base/snancusumkbn/lib/main.js    |  35 ++
 .../blas/ext/base/snancusumkbn/lib/native.js  |  35 ++
 .../blas/ext/base/snancusumkbn/lib/ndarray.js | 114 ++++++
 .../base/snancusumkbn/lib/ndarray.native.js   |  58 +++
 .../ext/base/snancusumkbn/lib/snancusumkbn.js |  65 ++++
 .../snancusumkbn/lib/snancusumkbn.native.js   |  56 +++
 .../blas/ext/base/snancusumkbn/manifest.json  |  85 ++++
 .../blas/ext/base/snancusumkbn/package.json   |  83 ++++
 .../blas/ext/base/snancusumkbn/src/Makefile   |  70 ++++
 .../blas/ext/base/snancusumkbn/src/addon.c    |  68 ++++
 .../blas/ext/base/snancusumkbn/src/main.c     | 127 ++++++
 .../blas/ext/base/snancusumkbn/test/test.js   |  82 ++++
 .../base/snancusumkbn/test/test.ndarray.js    | 357 +++++++++++++++++
 .../snancusumkbn/test/test.ndarray.native.js  | 366 ++++++++++++++++++
 .../snancusumkbn/test/test.snancusumkbn.js    | 304 +++++++++++++++
 .../test/test.snancusumkbn.native.js          | 313 +++++++++++++++
 33 files changed, 4456 insertions(+)
 create mode 100644 lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/README.md
 create mode 100644 lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/benchmark/benchmark.js
 create mode 100644 lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/benchmark/benchmark.native.js
 create mode 100644 lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/benchmark/benchmark.ndarray.js
 create mode 100644 lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/benchmark/benchmark.ndarray.native.js
 create mode 100644 lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/benchmark/c/Makefile
 create mode 100644 lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/benchmark/c/benchmark.length.c
 create mode 100644 lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/binding.gyp
 create mode 100644 lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/docs/repl.txt
 create mode 100644 lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/docs/types/index.d.ts
 create mode 100644 lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/docs/types/test.ts
 create mode 100644 lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/examples/c/Makefile
 create mode 100644 lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/examples/c/example.c
 create mode 100644 lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/examples/index.js
 create mode 100644 lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/include.gypi
 create mode 100644 lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/include/stdlib/blas/ext/base/snancusumkbn.h
 create mode 100644 lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/lib/index.js
 create mode 100644 lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/lib/main.js
 create mode 100644 lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/lib/native.js
 create mode 100644 lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/lib/ndarray.js
 create mode 100644 lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/lib/ndarray.native.js
 create mode 100644 lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/lib/snancusumkbn.js
 create mode 100644 lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/lib/snancusumkbn.native.js
 create mode 100644 lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/manifest.json
 create mode 100644 lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/package.json
 create mode 100644 lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/src/Makefile
 create mode 100644 lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/src/addon.c
 create mode 100644 lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/src/main.c
 create mode 100644 lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/test/test.js
 create mode 100644 lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/test/test.ndarray.js
 create mode 100644 lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/test/test.ndarray.native.js
 create mode 100644 lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/test/test.snancusumkbn.js
 create mode 100644 lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/test/test.snancusumkbn.native.js

diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/README.md b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/README.md
new file mode 100644
index 000000000000..27b1db49f968
--- /dev/null
+++ b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/README.md
@@ -0,0 +1,340 @@
+<!--
+
+@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.
+
+-->
+
+# snancusumkbn
+
+> Calculate the cumulative sum of single-precision floating-point strided array elements ignoring `NaN` values and using an improved Kahan–Babuška algorithm.
+
+<section class="intro">
+
+</section>
+
+<!-- /.intro -->
+
+<section class="usage">
+
+## Usage
+
+```javascript
+var snancusumkbn = require( '@stdlib/blas/ext/base/snancusumkbn' );
+```
+
+#### snancusumkbn( N, sum, x, strideX, y, strideY )
+
+Computes the cumulative sum of single-precision floating-point strided array elements ignoring `NaN` values and using an improved Kahan–Babuška algorithm.
+
+```javascript
+var Float32Array = require( '@stdlib/array/float32' );
+
+var x = new Float32Array( [ 1.0, -2.0, NaN ] );
+var y = new Float32Array( x.length );
+
+snancusumkbn( x.length, 0.0, x, 1, y, 1 );
+// y => <Float32Array>[ 1.0, -1.0, -1.0 ]
+
+x = new Float32Array( [ 1.0, -2.0, NaN ] );
+y = new Float32Array( x.length );
+
+snancusumkbn( x.length, 10.0, x, 1, y, 1 );
+// y => <Float32Array>[ 11.0, 9.0, 9.0 ]
+```
+
+The function has the following parameters:
+
+-   **N**: number of indexed elements.
+-   **sum**: initial sum.
+-   **x**: input [`Float32Array`][@stdlib/array/float32].
+-   **strideX**: stride length for `x`.
+-   **y**: output [`Float32Array`][@stdlib/array/float32].
+-   **strideY**: stride length for `y`.
+
+The `N` and stride parameters determine which elements in the strided arrays are accessed at runtime. For example, to compute the cumulative sum of every other element:
+
+```javascript
+var Float32Array = require( '@stdlib/array/float32' );
+
+var x = new Float32Array( [ 1.0, 2.0, 2.0, -7.0, -2.0, 3.0, NaN, NaN ] );
+var y = new Float32Array( x.length );
+
+var v = snancusumkbn( 4, 0.0, x, 2, y, 1 );
+// y => <Float32Array>[ 1.0, 3.0, 1.0, 1.0, 0.0, 0.0, 0.0, 0.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 Float32Array = require( '@stdlib/array/float32' );
+
+// Initial arrays...
+var x0 = new Float32Array( [ 2.0, 1.0, 2.0, -2.0, -2.0, 2.0, NaN, NaN ] );
+var y0 = new Float32Array( x0.length );
+
+// Create offset views...
+var x1 = new Float32Array( x0.buffer, x0.BYTES_PER_ELEMENT*1 ); // start at 2nd element
+var y1 = new Float32Array( y0.buffer, y0.BYTES_PER_ELEMENT*3 ); // start at 4th element
+
+snancusumkbn( 4, 0.0, x1, -2, y1, 1 );
+// y0 => <Float32Array>[ 0.0, 0.0, 0.0, 0.0, 2.0, 0.0, 1.0, 0.0 ]
+```
+
+#### snancusumkbn.ndarray( N, sum, x, strideX, offsetX, y, strideY, offsetY )
+
+Computes the cumulative sum of single-precision floating-point strided array elements ignoring `NaN` values and using an improved Kahan–Babuška algorithm and alternative indexing semantics.
+
+```javascript
+var Float32Array = require( '@stdlib/array/float32' );
+
+var x = new Float32Array( [ 1.0, -2.0, NaN ] );
+var y = new Float32Array( x.length );
+
+snancusumkbn.ndarray( x.length, 0.0, x, 1, 0, y, 1, 0 );
+// y => <Float32Array>[ 1.0, -1.0, -1.0 ]
+```
+
+The function has the following additional parameters:
+
+-   **offsetX**: starting index for `x`.
+-   **offsetY**: starting index for `y`.
+
+While [`typed array`][mdn-typed-array] views mandate a view offset based on the underlying buffer, the offset parameters support indexing semantics based on starting indices. For example, to calculate the cumulative sum of every other element in the strided input array starting from the second element and to store in the last `N` elements of the strided output array starting from the last element:
+
+```javascript
+var Float32Array = require( '@stdlib/array/float32' );
+
+var x = new Float32Array( [ 2.0, 1.0, 2.0, -2.0, -2.0, 2.0, NaN, NaN ] );
+var y = new Float32Array( x.length );
+
+snancusumkbn.ndarray( 4, 0.0, x, 2, 1, y, -1, y.length-1 );
+// y => <Float32Array>[ 0.0, 0.0, 0.0, 0.0, 1.0, 1.0, -1.0, 1.0 ]
+```
+
+</section>
+
+<!-- /.usage -->
+
+<section class="notes">
+
+## Notes
+
+-   If `N <= 0`, both functions return `y` unchanged.
+
+</section>
+
+<!-- /.notes -->
+
+<section class="examples">
+
+## Examples
+
+<!-- eslint no-undef: "error" -->
+
+```javascript
+var discreteUniform = require( '@stdlib/random/base/discrete-uniform' );
+var bernoulli = require( '@stdlib/random/base/bernoulli' );
+var filledarrayBy = require( '@stdlib/array/filled-by' );
+var zeros = require( '@stdlib/array/zeros' );
+var snancusumkbn = require( '@stdlib/blas/ext/base/snancusumkbn' );
+
+function rand() {
+    if ( bernoulli( 0.7 ) > 0 ) {
+        return discreteUniform( 0, 100 );
+    }
+    return NaN;
+}
+
+var x = filledarrayBy( 10, 'float32', rand );
+console.log( x );
+
+var y = zeros( 10, 'float32' );
+console.log( y );
+
+snancusumkbn( x.length, 0.0, x, 1, y, -1 );
+console.log( y );
+```
+
+</section>
+
+<!-- /.examples -->
+
+<!-- C interface documentation. -->
+
+* * *
+
+<section class="c">
+
+## C APIs
+
+<!-- Section to include introductory text. Make sure to keep an empty line after the intro `section` element and another before the `/section` close. -->
+
+<section class="intro">
+
+</section>
+
+<!-- /.intro -->
+
+<!-- C usage documentation. -->
+
+<section class="usage">
+
+### Usage
+
+```c
+#include "stdlib/blas/ext/base/snancusumkbn.h"
+```
+
+#### stdlib_strided_snancusumkbn( N, sum, \*X, strideX, \*Y, strideY )
+
+Computes the cumulative sum of single-precision floating-point strided array elements ignoring `NaN` values and using an improved Kahan–Babuška algorithm.
+
+```c
+const float x[] = { 1.0f, 2.0f, 3.0f, 4.0f };
+float y[] = { 0.0f, 0.0f, 0.0f, 0.0f };
+
+stdlib_strided_snancusumkbn( 4, 0.0f, x, 1, y, 1 );
+```
+
+The function accepts the following arguments:
+
+-   **N**: `[in] CBLAS_INT` number of indexed elements.
+-   **sum**: `[in] float` initial sum.
+-   **X**: `[in] float*` input array.
+-   **strideX**: `[in] CBLAS_INT` stride length for `X`.
+-   **Y**: `[out] float*` output array.
+-   **strideY**: `[in] CBLAS_INT` stride length for `Y`.
+
+```c
+void stdlib_strided_snancusumkbn( const CBLAS_INT N, const float sum, const float *X, const CBLAS_INT strideX, float *Y, const CBLAS_INT strideY );
+```
+
+<!-- lint disable maximum-heading-length -->
+
+#### stdlib_strided_snancusumkbn_ndarray( N, sum, \*X, strideX, offsetX, \*Y, strideY, offsetY )
+
+<!-- lint enable maximum-heading-length -->
+
+Computes the cumulative sum of single-precision floating-point strided array elements ignoring `NaN` values and using an improved Kahan–Babuška algorithm and alternative indexing semantics.
+
+```c
+const float x[] = { 1.0f, 2.0f, 3.0f, 4.0f };
+float y[] = { 0.0f, 0.0f, 0.0f, 0.0f };
+
+stdlib_strided_snancusumkbn_ndarray( 4, 0.0f, x, 1, 0, y, 1, 0 );
+```
+
+The function accepts the following arguments:
+
+-   **N**: `[in] CBLAS_INT` number of indexed elements.
+-   **sum**: `[in] float` initial sum.
+-   **X**: `[in] float*` input array.
+-   **strideX**: `[in] CBLAS_INT` stride length for `X`.
+-   **offsetX**: `[in] CBLAS_INT` starting index for `X`.
+-   **Y**: `[out] float*` output array.
+-   **strideY**: `[in] CBLAS_INT` stride length for `Y`.
+-   **offsetY**: `[in] CBLAS_INT` starting index for `Y`.
+
+```c
+void stdlib_strided_snancusumkbn_ndarray( const CBLAS_INT N, const float sum, const float *X, const CBLAS_INT strideX, const CBLAS_INT offsetX, float *Y, const CBLAS_INT strideY, const CBLAS_INT offsetY );
+```
+
+</section>
+
+<!-- /.usage -->
+
+<!-- C API usage notes. Make sure to keep an empty line after the `section` element and another before the `/section` close. -->
+
+<section class="notes">
+
+</section>
+
+<!-- /.notes -->
+
+<!-- C API usage examples. -->
+
+<section class="examples">
+
+### Examples
+
+```c
+#include "stdlib/blas/ext/base/snancusumkbn.h"
+#include <stdio.h>
+
+int main( void ) {
+    // Create strided arrays:
+    const float x[] = { 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 0.0f/0.0f, 0.0f/0.0f };
+    float y[] = { 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f };
+
+    // Specify the number of elements:
+    const int N = 4;
+
+    // Specify stride lengths:
+    const int strideX = 2;
+    const int strideY = -2;
+
+    // Compute the cumulative sum:
+    stdlib_strided_snancusumkbn( N, 0.0f, x, strideX, y, strideY );
+
+    // Print the result:
+    for ( int i = 0; i < 8; i++ ) {
+        printf( "y[ %d ] = %f\n", i, y[ i ] );
+    }
+}
+```
+
+</section>
+
+<!-- /.examples -->
+
+</section>
+
+<!-- /.c -->
+
+<section class="references">
+
+## References
+
+-   Neumaier, Arnold. 1974. "Rounding Error Analysis of Some Methods for Summing Finite Sums." _Zeitschrift Für Angewandte Mathematik Und Mechanik_ 54 (1): 39–51. doi:[10.1002/zamm.19740540106][@neumaier:1974a].
+
+</section>
+
+<!-- /.references -->
+
+<!-- Section for related `stdlib` packages. Do not manually edit this section, as it is automatically populated. -->
+
+<section class="related">
+
+</section>
+
+<!-- /.related -->
+
+<!-- Section for all links. Make sure to keep an empty line after the `section` element and another before the `/section` close. -->
+
+<section class="links">
+
+[@stdlib/array/float32]: https://github.com/stdlib-js/stdlib/tree/develop/lib/node_modules/%40stdlib/array/float32
+
+[mdn-typed-array]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray
+
+[@neumaier:1974a]: https://doi.org/10.1002/zamm.19740540106
+
+</section>
+
+<!-- /.links -->
diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/benchmark/benchmark.js b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/benchmark/benchmark.js
new file mode 100644
index 000000000000..778ad2137e4b
--- /dev/null
+++ b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/benchmark/benchmark.js
@@ -0,0 +1,114 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*    http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+'use strict';
+
+// MODULES //
+
+var bench = require( '@stdlib/bench' );
+var uniform = require( '@stdlib/random/base/uniform' );
+var bernoulli = require( '@stdlib/random/base/bernoulli' );
+var filledarrayBy = require( '@stdlib/array/filled-by' );
+var zeros = require( '@stdlib/array/zeros' );
+var isnanf = require( '@stdlib/math/base/assert/is-nanf' );
+var pow = require( '@stdlib/math/base/special/pow' );
+var pkg = require( './../package.json' ).name;
+var snancusumkbn = require( './../lib/snancusumkbn.js' );
+
+
+// VARIABLES //
+
+var options = {
+	'dtype': 'float32'
+};
+
+
+// FUNCTIONS //
+
+/**
+* Returns a random number.
+*
+* @private
+* @returns {number} random number
+*/
+function rand() {
+	if ( bernoulli( 0.8 ) > 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, options.dtype, rand );
+	var y = zeros( len, options.dtype );
+	return benchmark;
+
+	function benchmark( b ) {
+		var v;
+		var i;
+
+		b.tic();
+		for ( i = 0; i < b.iterations; i++ ) {
+			x[ 0 ] += 1.0;
+			v = snancusumkbn( x.length, 0.0, x, 1, y, 1 );
+			if ( isnanf( v[ i % len ] ) ) {
+				b.fail( 'should not return NaN' );
+			}
+		}
+		b.toc();
+		if ( isnanf( v[ i % len ] ) ) {
+			b.fail( 'should not return NaN' );
+		}
+		b.pass( 'benchmark finished' );
+		b.end();
+	}
+}
+
+
+// MAIN //
+
+/**
+* Main execution sequence.
+*
+* @private
+*/
+function main() {
+	var len;
+	var min;
+	var max;
+	var f;
+	var i;
+
+	min = 1; // 10^min
+	max = 6; // 10^max
+
+	for ( i = min; i <= max; i++ ) {
+		len = pow( 10, i );
+		f = createBenchmark( len );
+		bench( pkg+':len='+len, f );
+	}
+}
+
+main();
diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/benchmark/benchmark.native.js b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/benchmark/benchmark.native.js
new file mode 100644
index 000000000000..1f450baa6464
--- /dev/null
+++ b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/benchmark/benchmark.native.js
@@ -0,0 +1,119 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*    http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+'use strict';
+
+// MODULES //
+
+var resolve = require( 'path' ).resolve;
+var bench = require( '@stdlib/bench' );
+var uniform = require( '@stdlib/random/base/uniform' );
+var bernoulli = require( '@stdlib/random/base/bernoulli' );
+var filledarrayBy = require( '@stdlib/array/filled-by' );
+var zeros = require( '@stdlib/array/zeros' );
+var isnanf = require( '@stdlib/math/base/assert/is-nanf' );
+var pow = require( '@stdlib/math/base/special/pow' );
+var tryRequire = require( '@stdlib/utils/try-require' );
+var pkg = require( './../package.json' ).name;
+
+
+// VARIABLES //
+
+var options = {
+	'dtype': 'float32'
+};
+var snancusumkbn = tryRequire( resolve( __dirname, './../lib/snancusumkbn.native.js' ) );
+var opts = {
+	'skip': ( snancusumkbn instanceof Error )
+};
+
+
+// FUNCTIONS //
+
+/**
+* Returns a random number.
+*
+* @private
+* @returns {number} random number
+*/
+function rand() {
+	if ( bernoulli( 0.8 ) > 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, options.dtype, rand );
+	var y = zeros( len, options.dtype );
+	return benchmark;
+
+	function benchmark( b ) {
+		var v;
+		var i;
+
+		b.tic();
+		for ( i = 0; i < b.iterations; i++ ) {
+			x[ 0 ] += 1.0;
+			v = snancusumkbn( x.length, 0.0, x, 1, y, 1 );
+			if ( isnanf( v[ i % len ] ) ) {
+				b.fail( 'should not return NaN' );
+			}
+		}
+		b.toc();
+		if ( isnanf( v[ i % len ] ) ) {
+			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+'::native:len='+len, opts, f );
+	}
+}
+
+main();
diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/benchmark/benchmark.ndarray.js b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/benchmark/benchmark.ndarray.js
new file mode 100644
index 000000000000..657c033b19d8
--- /dev/null
+++ b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/benchmark/benchmark.ndarray.js
@@ -0,0 +1,114 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*    http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+'use strict';
+
+// MODULES //
+
+var bench = require( '@stdlib/bench' );
+var uniform = require( '@stdlib/random/base/uniform' );
+var bernoulli = require( '@stdlib/random/base/bernoulli' );
+var filledarrayBy = require( '@stdlib/array/filled-by' );
+var zeros = require( '@stdlib/array/zeros' );
+var isnanf = require( '@stdlib/math/base/assert/is-nanf' );
+var pow = require( '@stdlib/math/base/special/pow' );
+var pkg = require( './../package.json' ).name;
+var snancusumkbn = require( './../lib/ndarray.js' );
+
+
+// VARIABLES //
+
+var options = {
+	'dtype': 'float32'
+};
+
+
+// FUNCTIONS //
+
+/**
+* Returns a random number.
+*
+* @private
+* @returns {number} random number
+*/
+function rand() {
+	if ( bernoulli( 0.8 ) > 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, options.dtype, rand );
+	var y = zeros( len, options.dtype );
+	return benchmark;
+
+	function benchmark( b ) {
+		var v;
+		var i;
+
+		b.tic();
+		for ( i = 0; i < b.iterations; i++ ) {
+			x[ 0 ] += 1.0;
+			v = snancusumkbn( x.length, 0.0, x, 1, 0, y, 1, 0 );
+			if ( isnanf( v[ i % len ] ) ) {
+				b.fail( 'should not return NaN' );
+			}
+		}
+		b.toc();
+		if ( isnanf( v[ i % len ] ) ) {
+			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, f );
+	}
+}
+
+main();
diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/benchmark/benchmark.ndarray.native.js b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/benchmark/benchmark.ndarray.native.js
new file mode 100644
index 000000000000..9eba60dc5a6c
--- /dev/null
+++ b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/benchmark/benchmark.ndarray.native.js
@@ -0,0 +1,119 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*    http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+'use strict';
+
+// MODULES //
+
+var resolve = require( 'path' ).resolve;
+var bench = require( '@stdlib/bench' );
+var uniform = require( '@stdlib/random/base/uniform' );
+var bernoulli = require( '@stdlib/random/base/bernoulli' );
+var filledarrayBy = require( '@stdlib/array/filled-by' );
+var zeros = require( '@stdlib/array/zeros' );
+var isnanf = require( '@stdlib/math/base/assert/is-nanf' );
+var pow = require( '@stdlib/math/base/special/pow' );
+var tryRequire = require( '@stdlib/utils/try-require' );
+var pkg = require( './../package.json' ).name;
+
+
+// VARIABLES //
+
+var options = {
+	'dtype': 'float32'
+};
+var snancusumkbn = tryRequire( resolve( __dirname, './../lib/ndarray.native.js' ) );
+var opts = {
+	'skip': ( snancusumkbn instanceof Error )
+};
+
+
+// FUNCTIONS //
+
+/**
+* Returns a random number.
+*
+* @private
+* @returns {number} random number
+*/
+function rand() {
+	if ( bernoulli( 0.8 ) > 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, options.dtype, rand );
+	var y = zeros( len, options.dtype );
+	return benchmark;
+
+	function benchmark( b ) {
+		var v;
+		var i;
+
+		b.tic();
+		for ( i = 0; i < b.iterations; i++ ) {
+			x[ 0 ] += 1.0;
+			v = snancusumkbn( x.length, 0.0, x, 1, 0, y, 1, 0 );
+			if ( isnanf( v[ i % len ] ) ) {
+				b.fail( 'should not return NaN' );
+			}
+		}
+		b.toc();
+		if ( isnanf( v[ i % len ] ) ) {
+			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+'::native:ndarray:len='+len, opts, f );
+	}
+}
+
+main();
diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/benchmark/c/Makefile b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/benchmark/c/Makefile
new file mode 100644
index 000000000000..cce2c865d7ad
--- /dev/null
+++ b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/benchmark/c/Makefile
@@ -0,0 +1,146 @@
+#/
+# @license Apache-2.0
+#
+# Copyright (c) 2025 The Stdlib Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#/
+
+# VARIABLES #
+
+ifndef VERBOSE
+	QUIET := @
+else
+	QUIET :=
+endif
+
+# Determine the OS ([1][1], [2][2]).
+#
+# [1]: https://en.wikipedia.org/wiki/Uname#Examples
+# [2]: http://stackoverflow.com/a/27776822/2225624
+OS ?= $(shell uname)
+ifneq (, $(findstring MINGW,$(OS)))
+	OS := WINNT
+else
+ifneq (, $(findstring MSYS,$(OS)))
+	OS := WINNT
+else
+ifneq (, $(findstring CYGWIN,$(OS)))
+	OS := WINNT
+else
+ifneq (, $(findstring Windows_NT,$(OS)))
+	OS := WINNT
+endif
+endif
+endif
+endif
+
+# Define the program used for compiling C source files:
+ifdef C_COMPILER
+	CC := $(C_COMPILER)
+else
+	CC := gcc
+endif
+
+# Define the command-line options when compiling C files:
+CFLAGS ?= \
+	-std=c99 \
+	-O3 \
+	-Wall \
+	-pedantic
+
+# Determine whether to generate position independent code ([1][1], [2][2]).
+#
+# [1]: https://gcc.gnu.org/onlinedocs/gcc/Code-Gen-Options.html#Code-Gen-Options
+# [2]: http://stackoverflow.com/questions/5311515/gcc-fpic-option
+ifeq ($(OS), WINNT)
+	fPIC ?=
+else
+	fPIC ?= -fPIC
+endif
+
+# List of includes (e.g., `-I /foo/bar -I /beep/boop/include`):
+INCLUDE ?=
+
+# List of source files:
+SOURCE_FILES ?=
+
+# List of libraries (e.g., `-lopenblas -lpthread`):
+LIBRARIES ?=
+
+# List of library paths (e.g., `-L /foo/bar -L /beep/boop`):
+LIBPATH ?=
+
+# List of C targets:
+c_targets := benchmark.length.out
+
+
+# RULES #
+
+#/
+# Compiles source files.
+#
+# @param {string} [C_COMPILER] - C compiler (e.g., `gcc`)
+# @param {string} [CFLAGS] - C compiler options
+# @param {(string|void)} [fPIC] - compiler flag determining whether to generate position independent code (e.g., `-fPIC`)
+# @param {string} [INCLUDE] - list of includes (e.g., `-I /foo/bar -I /beep/boop/include`)
+# @param {string} [SOURCE_FILES] - list of source files
+# @param {string} [LIBPATH] - list of library paths (e.g., `-L /foo/bar -L /beep/boop`)
+# @param {string} [LIBRARIES] - list of libraries (e.g., `-lopenblas -lpthread`)
+#
+# @example
+# make
+#
+# @example
+# make all
+#/
+all: $(c_targets)
+
+.PHONY: all
+
+#/
+# Compiles C source files.
+#
+# @private
+# @param {string} CC - C compiler (e.g., `gcc`)
+# @param {string} CFLAGS - C compiler options
+# @param {(string|void)} fPIC - compiler flag determining whether to generate position independent code (e.g., `-fPIC`)
+# @param {string} INCLUDE - list of includes (e.g., `-I /foo/bar`)
+# @param {string} SOURCE_FILES - list of source files
+# @param {string} LIBPATH - list of library paths (e.g., `-L /foo/bar`)
+# @param {string} LIBRARIES - list of libraries (e.g., `-lopenblas`)
+#/
+$(c_targets): %.out: %.c
+	$(QUIET) $(CC) $(CFLAGS) $(fPIC) $(INCLUDE) -o $@ $(SOURCE_FILES) $< $(LIBPATH) -lm $(LIBRARIES)
+
+#/
+# Runs compiled benchmarks.
+#
+# @example
+# make run
+#/
+run: $(c_targets)
+	$(QUIET) ./$<
+
+.PHONY: run
+
+#/
+# Removes generated files.
+#
+# @example
+# make clean
+#/
+clean:
+	$(QUIET) -rm -f *.o *.out
+
+.PHONY: clean
diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/benchmark/c/benchmark.length.c b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/benchmark/c/benchmark.length.c
new file mode 100644
index 000000000000..dfe6030755b4
--- /dev/null
+++ b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/benchmark/c/benchmark.length.c
@@ -0,0 +1,213 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*    http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+#include <sys/time.h>
+#include "stdlib/blas/ext/base/snancusumkbn.h"
+#include <math.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+
+#define NAME "snancusumkbn"
+#define ITERATIONS 1000000
+#define REPEATS 3
+#define MIN 1
+#define MAX 6
+
+/**
+* Prints the TAP version.
+*/
+static void print_version( void ) {
+	printf( "TAP version 13\n" );
+}
+
+/**
+* Prints the TAP summary.
+*
+* @param total     total number of tests
+* @param passing   total number of passing tests
+*/
+static void print_summary( int total, int passing ) {
+	printf( "#\n" );
+	printf( "1..%d\n", total ); // TAP plan
+	printf( "# total %d\n", total );
+	printf( "# pass  %d\n", passing );
+	printf( "#\n" );
+	printf( "# ok\n" );
+}
+
+/**
+* Prints benchmarks results.
+*
+* @param iterations  number of iterations
+* @param elapsed     elapsed time in seconds
+*/
+static void print_results( int iterations, float elapsed ) {
+	float rate = (float)iterations / elapsed;
+	printf( "  ---\n" );
+	printf( "  iterations: %d\n", iterations );
+	printf( "  elapsed: %0.9f\n", elapsed );
+	printf( "  rate: %0.9f\n", rate );
+	printf( "  ...\n" );
+}
+
+/**
+* Returns a clock time.
+*
+* @return clock time
+*/
+static float tic( void ) {
+	struct timeval now;
+	gettimeofday( &now, NULL );
+	return (float)now.tv_sec + (float)now.tv_usec / 1.0e6f;
+}
+
+/**
+* Generates a random number on the interval [0,1).
+*
+* @return random number
+*/
+static float rand_float( void ) {
+	int r = rand();
+	return (float)r / ( (float)RAND_MAX + 1.0f );
+}
+
+/**
+* Runs a benchmark.
+*
+* @param iterations   number of iterations
+* @param len          array length
+* @return             elapsed time in seconds
+*/
+static float benchmark1( int iterations, int len ) {
+	float elapsed;
+	float *x;
+	float *y;
+	float t;
+	int i;
+
+	x = (float *)malloc( len * sizeof( float ) );
+	y = (float *)malloc( len * sizeof( float ) );
+	for ( i = 0; i < len; i++ ) {
+		if ( rand_float() < 0.2f ) {
+			x[ i ] = 0.0f / 0.0f; // NaN
+		} else {
+			x[ i ] = ( rand_float() * 20000.0f ) - 10000.0f;
+		}
+		y[ i ] = 0.0f;
+	}
+	t = tic();
+	for ( i = 0; i < iterations; i++ ) {
+		x[ 0 ] += 1.0f;
+		stdlib_strided_snancusumkbn( len, 0.0f, x, 1, y, 1 );
+		if ( y[ 0 ] != y[ 0 ] ) {
+			printf( "should not return NaN\n" );
+			break;
+		}
+	}
+	elapsed = tic() - t;
+	if ( y[ len - 1 ] != y[ len - 1 ] ) {
+		printf( "should not return NaN\n" );
+	}
+	free( x );
+	free( y );
+	return elapsed;
+}
+
+/**
+* Runs a benchmark.
+*
+* @param iterations   number of iterations
+* @param len          array length
+* @return             elapsed time in seconds
+*/
+static float benchmark2( int iterations, int len ) {
+	float elapsed;
+	float *x;
+	float *y;
+	float t;
+	int i;
+
+	x = (float *)malloc( len * sizeof( float ) );
+	y = (float *)malloc( len * sizeof( float ) );
+	for ( i = 0; i < len; i++ ) {
+		if ( rand_float() < 0.2f ) {
+			x[ i ] = 0.0f / 0.0f; // NaN
+		} else {
+			x[ i ] = ( rand_float() * 20000.0f ) - 10000.0f;
+		}
+		y[ i ] = 0.0f;
+	}
+	t = tic();
+	for ( i = 0; i < iterations; i++ ) {
+		x[ 0 ] += 1.0f;
+		stdlib_strided_snancusumkbn_ndarray( len, 0.0f, x, 1, 0, y, 1, 0 );
+		if ( y[ 0 ] != y[ 0 ] ) {
+			printf( "should not return NaN\n" );
+			break;
+		}
+	}
+	elapsed = tic() - t;
+	if ( y[ len - 1 ] != y[ len - 1 ] ) {
+		printf( "should not return NaN\n" );
+	}
+	free( x );
+	free( y );
+	return elapsed;
+}
+
+/**
+* Main execution sequence.
+*/
+int main( void ) {
+	float elapsed;
+	int count;
+	int iter;
+	int len;
+	int i;
+	int j;
+
+	// Use the current time to seed the random number generator:
+	srand( time( NULL ) );
+
+	print_version();
+	count = 0;
+	for ( i = MIN; i <= MAX; i++ ) {
+		len = pow( 10, i );
+		iter = ITERATIONS / pow( 10, i - 1 );
+		for ( j = 0; j < REPEATS; j++ ) {
+			count += 1;
+			printf( "# c::%s:len=%d\n", NAME, len );
+			elapsed = benchmark1( iter, len );
+			print_results( iter, elapsed );
+			printf( "ok %d benchmark finished\n", count );
+		}
+	}
+	for ( i = MIN; i <= MAX; i++ ) {
+		len = pow( 10, i );
+		iter = ITERATIONS / pow( 10, i - 1 );
+		for ( j = 0; j < REPEATS; j++ ) {
+			count += 1;
+			printf( "# c::%s:ndarray:len=%d\n", NAME, len );
+			elapsed = benchmark2( iter, len );
+			print_results( iter, elapsed );
+			printf( "ok %d benchmark finished\n", count );
+		}
+	}
+	print_summary( count, count );
+}
diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/binding.gyp b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/binding.gyp
new file mode 100644
index 000000000000..68a1ca11d160
--- /dev/null
+++ b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/binding.gyp
@@ -0,0 +1,170 @@
+# @license Apache-2.0
+#
+# Copyright (c) 2025 The Stdlib Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# A `.gyp` file for building a Node.js native add-on.
+#
+# [1]: https://gyp.gsrc.io/docs/InputFormatReference.md
+# [2]: https://gyp.gsrc.io/docs/UserDocumentation.md
+{
+  # List of files to include in this file:
+  'includes': [
+    './include.gypi',
+  ],
+
+  # Define variables to be used throughout the configuration for all targets:
+  'variables': {
+    # Target name should match the add-on export name:
+    'addon_target_name%': 'addon',
+
+    # Set variables based on the host OS:
+    'conditions': [
+      [
+        'OS=="win"',
+        {
+          # Define the object file suffix:
+          'obj': 'obj',
+        },
+        {
+          # Define the object file suffix:
+          'obj': 'o',
+        }
+      ], # end condition (OS=="win")
+    ], # end conditions
+  }, # end variables
+
+  # Define compile targets:
+  'targets': [
+
+    # Target to generate an add-on:
+    {
+      # The target name should match the add-on export name:
+      'target_name': '<(addon_target_name)',
+
+      # Define dependencies:
+      'dependencies': [],
+
+      # Define directories which contain relevant include headers:
+      'include_dirs': [
+        # Local include directory:
+        '<@(include_dirs)',
+      ],
+
+      # List of source files:
+      'sources': [
+        '<@(src_files)',
+      ],
+
+      # Settings which should be applied when a target's object files are used as linker input:
+      'link_settings': {
+        # Define libraries:
+        'libraries': [
+          '<@(libraries)',
+        ],
+
+        # Define library directories:
+        'library_dirs': [
+          '<@(library_dirs)',
+        ],
+      },
+
+      # C/C++ compiler flags:
+      'cflags': [
+        # Enable commonly used warning options:
+        '-Wall',
+
+        # Aggressive optimization:
+        '-O3',
+      ],
+
+      # C specific compiler flags:
+      'cflags_c': [
+        # Specify the C standard to which a program is expected to conform:
+        '-std=c99',
+      ],
+
+      # C++ specific compiler flags:
+      'cflags_cpp': [
+        # Specify the C++ standard to which a program is expected to conform:
+        '-std=c++11',
+      ],
+
+      # Linker flags:
+      'ldflags': [],
+
+      # Apply conditions based on the host OS:
+      'conditions': [
+        [
+          'OS=="mac"',
+          {
+            # Linker flags:
+            'ldflags': [
+              '-undefined dynamic_lookup',
+              '-Wl,-no-pie',
+              '-Wl,-search_paths_first',
+            ],
+          },
+        ], # end condition (OS=="mac")
+        [
+          'OS!="win"',
+          {
+            # C/C++ flags:
+            'cflags': [
+              # Generate platform-independent code:
+              '-fPIC',
+            ],
+          },
+        ], # end condition (OS!="win")
+      ], # end conditions
+    }, # end target <(addon_target_name)
+
+    # Target to copy a generated add-on to a standard location:
+    {
+      'target_name': 'copy_addon',
+
+      # Declare that the output of this target is not linked:
+      'type': 'none',
+
+      # Define dependencies:
+      'dependencies': [
+        # Require that the add-on be generated before building this target:
+        '<(addon_target_name)',
+      ],
+
+      # Define a list of actions:
+      'actions': [
+        {
+          'action_name': 'copy_addon',
+          'message': 'Copying addon...',
+
+          # Explicitly list the inputs in the command-line invocation below:
+          'inputs': [],
+
+          # Declare the expected outputs:
+          'outputs': [
+            '<(addon_output_dir)/<(addon_target_name).node',
+          ],
+
+          # Define the command-line invocation:
+          'action': [
+            'cp',
+            '<(PRODUCT_DIR)/<(addon_target_name).node',
+            '<(addon_output_dir)/<(addon_target_name).node',
+          ],
+        },
+      ], # end actions
+    }, # end target copy_addon
+  ], # end targets
+}
diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/docs/repl.txt b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/docs/repl.txt
new file mode 100644
index 000000000000..f8488b0d626b
--- /dev/null
+++ b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/docs/repl.txt
@@ -0,0 +1,121 @@
+
+{{alias}}( N, sum, x, strideX, y, strideY )
+    Computes the cumulative sum of single-precision floating-point strided array
+    elements ignoring `NaN` values and using an improved Kahan–Babuška
+    algorithm.
+
+    The `N` and stride parameters determine which elements in the strided arrays
+    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 `y` unchanged.
+
+    Parameters
+    ----------
+    N: integer
+        Number of indexed elements.
+
+    sum: number
+        Initial sum.
+
+    x: Float32Array
+        Input array.
+
+    strideX: integer
+        Stride length for `x`.
+
+    y: Float32Array
+        Output array.
+
+    strideY: integer
+        Stride length for `y`.
+
+    Returns
+    -------
+    out: Float32Array
+        Output array.
+
+    Examples
+    --------
+    // Standard Usage:
+    > var x = new {{alias:@stdlib/array/float32}}( [ 1.0, NaN, 2.0 ] );
+    > var y = new {{alias:@stdlib/array/float32}}( x.length );
+    > {{alias}}( x.length, 0.0, x, 1, y, 1 )
+    <Float32Array>[ 1.0, 1.0, 3.0 ]
+
+    // Using `N` and stride parameters:
+    > x = new {{alias:@stdlib/array/float32}}( [ -2.0, 1.0, 1.0, NaN, 2.0, -1.0 ] );
+    > y = new {{alias:@stdlib/array/float32}}( x.length );
+    > {{alias}}( 3, 0.0, x, 2, y, 2 )
+    <Float32Array>[ -2.0, 0.0, -1.0, 0.0, 1.0, 0.0 ]
+
+    // Using view offsets:
+    > var x0 = new {{alias:@stdlib/array/float32}}( [ 1.0, -2.0, 3.0, NaN, 5.0, -1.0 ] );
+    > var y0 = new {{alias:@stdlib/array/float32}}( x0.length );
+    > var x1 = new {{alias:@stdlib/array/float32}}( x0.buffer, x0.BYTES_PER_ELEMENT*1 );
+    > var y1 = new {{alias:@stdlib/array/float32}}( y0.buffer, y0.BYTES_PER_ELEMENT*3 );
+    > {{alias}}( 3, 0.0, x1, 2, y1, 1 )
+    <Float32Array>[ -2.0, -2.0, -3.0 ]
+    > y0
+    <Float32Array>[ 0.0, 0.0, 0.0, -2.0, -2.0, -3.0 ]
+
+
+{{alias}}.ndarray( N, sum, x, strideX, offsetX, y, strideY, offsetY )
+    Computes the cumulative sum of single-precision floating-point strided array
+    elements ignoring `NaN` values and using an improved Kahan–Babuška algorithm
+    and alternative indexing semantics.
+
+    While typed array views mandate a view offset based on the underlying
+    buffer, the offset parameters support indexing semantics based on starting
+    indices.
+
+    Parameters
+    ----------
+    N: integer
+        Number of indexed elements.
+
+    sum: number
+        Initial sum.
+
+    x: Float32Array
+        Input array.
+
+    strideX: integer
+        Stride length for `x`.
+
+    offsetX: integer
+        Starting index for `x`.
+
+    y: Float32Array
+        Output array.
+
+    strideY: integer
+        Stride length for `y`.
+
+    offsetY: integer
+        Starting index for `y`.
+
+    Returns
+    -------
+    out: Float32Array
+        Output array.
+
+    Examples
+    --------
+    // Standard Usage:
+    > var x = new {{alias:@stdlib/array/float32}}( [ 1.0, -2.0, NaN ] );
+    > var y = new {{alias:@stdlib/array/float32}}( x.length );
+    > {{alias}}.ndarray( x.length, 0.0, x, 1, 0, y, 1, 0 )
+    <Float32Array>[ 1.0, -1.0, -1.0 ]
+
+    // Advanced indexing:
+    > x = new {{alias:@stdlib/array/float32}}( [ NaN, -2.0, 3.0, 2.0, 5.0, -1.0 ] );
+    > y = new {{alias:@stdlib/array/float32}}( x.length );
+    > {{alias}}.ndarray( 3, 0.0, x, 2, 1, y, -1, y.length-1 )
+    <Float32Array>[ 0.0, 0.0, 0.0, -1.0, 0.0, -2.0 ]
+
+    See Also
+    --------
+
diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/docs/types/index.d.ts b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/docs/types/index.d.ts
new file mode 100644
index 000000000000..981167bcdbb2
--- /dev/null
+++ b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/docs/types/index.d.ts
@@ -0,0 +1,106 @@
+/*
+* @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
+
+/**
+* Interface describing `snancusumkbn`.
+*/
+interface Routine {
+	/**
+	* Computes the cumulative sum of single-precision floating-point strided array elements ignoring `NaN` values and using an improved Kahan–Babuška algorithm.
+	*
+	* @param N - number of indexed elements
+	* @param sum - initial sum
+	* @param x - input array
+	* @param strideX - stride length for `x`
+	* @param y - output array
+	* @param strideY - stride length for `y`
+	* @returns output array
+	*
+	* @example
+	* var Float32Array = require( '@stdlib/array/float32' );
+	*
+	* var x = new Float32Array( [ 1.0, NaN, 2.0 ] );
+	* var y = new Float32Array( x.length );
+	*
+	* snancusumkbn( x.length, 0.0, x, 1, y, 1 );
+	* // y => <Float32Array>[ 1.0, 1.0, 3.0 ]
+	*/
+	( N: number, sum: number, x: Float32Array, strideX: number, y: Float32Array, strideY: number ): Float32Array;
+
+	/**
+	* Computes the cumulative sum of single-precision floating-point strided array elements ignoring `NaN` values and using an improved Kahan–Babuška algorithm and alternative indexing semantics.
+	*
+	* @param N - number of indexed elements
+	* @param sum - initial sum
+	* @param x - input array
+	* @param strideX - stride length for `x`
+	* @param offsetX - starting index for `x`
+	* @param y - output array
+	* @param strideY - stride length for `y`
+	* @param offsetY - starting index for `y`
+	* @returns output array
+	*
+	* @example
+	* var Float32Array = require( '@stdlib/array/float32' );
+	*
+	* var x = new Float32Array( [ 1.0, -2.0, NaN ] );
+	* var y = new Float32Array( x.length );
+	*
+	* snancusumkbn.ndarray( x.length, 0.0, x, 1, 0, y, 1, 0 );
+	* // y => <Float32Array>[ 1.0, -1.0, -1.0 ]
+	*/
+	ndarray( N: number, sum: number, x: Float32Array, strideX: number, offsetX: number, y: Float32Array, strideY: number, offsetY: number ): Float32Array;
+}
+
+/**
+* Computes the cumulative sum of single-precision floating-point strided array elements ignoring `NaN` values and using an improved Kahan–Babuška algorithm.
+*
+* @param N - number of indexed elements
+* @param sum - initial sum
+* @param x - input array
+* @param strideX - stride length for `x`
+* @param y - output array
+* @param strideY - stride length for `y`
+* @returns output array
+*
+* @example
+* var Float32Array = require( '@stdlib/array/float32' );
+*
+* var x = new Float32Array( [ 1.0, -2.0, NaN ] );
+* var y = new Float32Array( x.length );
+*
+* snancusumkbn( x.length, 0.0, x, 1, y, 1 );
+* // y => <Float32Array>[ 1.0, -1.0, -1.0 ]
+*
+* @example
+* var Float32Array = require( '@stdlib/array/float32' );
+*
+* var x = new Float32Array( [ 1.0, -2.0, NaN ] );
+* var y = new Float32Array( x.length );
+*
+* snancusumkbn.ndarray( x.length, 0.0, x, 1, 0, y, 1, 0 );
+* // y => <Float32Array>[ 1.0, -1.0, -1.0 ]
+*/
+declare var snancusumkbn: Routine;
+
+
+// EXPORTS //
+
+export = snancusumkbn;
diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/docs/types/test.ts b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/docs/types/test.ts
new file mode 100644
index 000000000000..0096e1b5b350
--- /dev/null
+++ b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/docs/types/test.ts
@@ -0,0 +1,280 @@
+/*
+* @license Apache-2.0
+*
+* Copyright (c) 2025 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*    http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+import snancusumkbn = require( './index' );
+
+
+// TESTS //
+
+// The function returns a Float32Array...
+{
+	const x = new Float32Array( 10 );
+	const y = new Float32Array( 10 );
+
+	snancusumkbn( x.length, 0.0, x, 1, y, 1 ); // $ExpectType Float32Array
+}
+
+// The compiler throws an error if the function is provided a first argument which is not a number...
+{
+	const x = new Float32Array( 10 );
+	const y = new Float32Array( 10 );
+
+	snancusumkbn( '10', 0.0, x, 1, y, 1 ); // $ExpectError
+	snancusumkbn( true, 0.0, x, 1, y, 1 ); // $ExpectError
+	snancusumkbn( false, 0.0, x, 1, y, 1 ); // $ExpectError
+	snancusumkbn( null, 0.0, x, 1, y, 1 ); // $ExpectError
+	snancusumkbn( undefined, 0.0, x, 1, y, 1 ); // $ExpectError
+	snancusumkbn( [], 0.0, x, 1, y, 1 ); // $ExpectError
+	snancusumkbn( {}, 0.0, x, 1, y, 1 ); // $ExpectError
+	snancusumkbn( ( x: number ): number => x, 0.0, x, 1, y, 1 ); // $ExpectError
+}
+
+// The compiler throws an error if the function is provided a second argument which is not a number...
+{
+	const x = new Float32Array( 10 );
+	const y = new Float32Array( 10 );
+
+	snancusumkbn( x.length, '10', x, 1, y, 1 ); // $ExpectError
+	snancusumkbn( x.length, true, x, 1, y, 1 ); // $ExpectError
+	snancusumkbn( x.length, false, x, 1, y, 1 ); // $ExpectError
+	snancusumkbn( x.length, null, x, 1, y, 1 ); // $ExpectError
+	snancusumkbn( x.length, undefined, x, 1, y, 1 ); // $ExpectError
+	snancusumkbn( x.length, [], x, 1, y, 1 ); // $ExpectError
+	snancusumkbn( x.length, {}, x, 1, y, 1 ); // $ExpectError
+	snancusumkbn( x.length, ( x: number ): number => x, x, 1, y, 1 ); // $ExpectError
+}
+
+// The compiler throws an error if the function is provided a third argument which is not a Float32Array...
+{
+	const x = new Float32Array( 10 );
+	const y = new Float32Array( 10 );
+
+	snancusumkbn( x.length, 0.0, 10, 1, y, 1 ); // $ExpectError
+	snancusumkbn( x.length, 0.0, '10', 1, y, 1 ); // $ExpectError
+	snancusumkbn( x.length, 0.0, true, 1, y, 1 ); // $ExpectError
+	snancusumkbn( x.length, 0.0, false, 1, y, 1 ); // $ExpectError
+	snancusumkbn( x.length, 0.0, null, 1, y, 1 ); // $ExpectError
+	snancusumkbn( x.length, 0.0, undefined, 1, y, 1 ); // $ExpectError
+	snancusumkbn( x.length, 0.0, [ '1' ], 1, y, 1 ); // $ExpectError
+	snancusumkbn( x.length, 0.0, {}, 1, y, 1 ); // $ExpectError
+	snancusumkbn( x.length, 0.0, ( x: number ): number => x, 1, y, 1 ); // $ExpectError
+}
+
+// The compiler throws an error if the function is provided a fourth argument which is not a number...
+{
+	const x = new Float32Array( 10 );
+	const y = new Float32Array( 10 );
+
+	snancusumkbn( x.length, 0.0, x, '10', y, 1 ); // $ExpectError
+	snancusumkbn( x.length, 0.0, x, true, y, 1 ); // $ExpectError
+	snancusumkbn( x.length, 0.0, x, false, y, 1 ); // $ExpectError
+	snancusumkbn( x.length, 0.0, x, null, y, 1 ); // $ExpectError
+	snancusumkbn( x.length, 0.0, x, undefined, y, 1 ); // $ExpectError
+	snancusumkbn( x.length, 0.0, x, [], y, 1 ); // $ExpectError
+	snancusumkbn( x.length, 0.0, x, {}, y, 1 ); // $ExpectError
+	snancusumkbn( x.length, 0.0, x, ( x: number ): number => x, y, 1 ); // $ExpectError
+}
+
+// The compiler throws an error if the function is provided a fifth argument which is not a Float32Array...
+{
+	const x = new Float32Array( 10 );
+
+	snancusumkbn( x.length, 0.0, x, 1, 10, 1 ); // $ExpectError
+	snancusumkbn( x.length, 0.0, x, 1, '10', 1 ); // $ExpectError
+	snancusumkbn( x.length, 0.0, x, 1, true, 1 ); // $ExpectError
+	snancusumkbn( x.length, 0.0, x, 1, false, 1 ); // $ExpectError
+	snancusumkbn( x.length, 0.0, x, 1, null, 1 ); // $ExpectError
+	snancusumkbn( x.length, 0.0, x, 1, undefined, 1 ); // $ExpectError
+	snancusumkbn( x.length, 0.0, x, 1, [ '1' ], 1 ); // $ExpectError
+	snancusumkbn( x.length, 0.0, x, 1, {}, 1 ); // $ExpectError
+	snancusumkbn( x.length, 0.0, x, 1, ( x: number ): number => x, 1 ); // $ExpectError
+}
+
+// The compiler throws an error if the function is provided a sixth argument which is not a number...
+{
+	const x = new Float32Array( 10 );
+	const y = new Float32Array( 10 );
+
+	snancusumkbn( x.length, 0.0, x, 1, y, '10' ); // $ExpectError
+	snancusumkbn( x.length, 0.0, x, 1, y, true ); // $ExpectError
+	snancusumkbn( x.length, 0.0, x, 1, y, false ); // $ExpectError
+	snancusumkbn( x.length, 0.0, x, 1, y, null ); // $ExpectError
+	snancusumkbn( x.length, 0.0, x, 1, y, undefined ); // $ExpectError
+	snancusumkbn( x.length, 0.0, x, 1, y, [] ); // $ExpectError
+	snancusumkbn( x.length, 0.0, x, 1, y, {} ); // $ExpectError
+	snancusumkbn( x.length, 0.0, x, 1, y, ( x: number ): number => x ); // $ExpectError
+}
+
+// The compiler throws an error if the function is provided an unsupported number of arguments...
+{
+	const x = new Float32Array( 10 );
+	const y = new Float32Array( 10 );
+
+	snancusumkbn(); // $ExpectError
+	snancusumkbn( x.length ); // $ExpectError
+	snancusumkbn( x.length, 0.0 ); // $ExpectError
+	snancusumkbn( x.length, 0.0, x ); // $ExpectError
+	snancusumkbn( x.length, 0.0, x, 1 ); // $ExpectError
+	snancusumkbn( x.length, 0.0, x, 1, y ); // $ExpectError
+	snancusumkbn( x.length, 0.0, x, 1, y, 1, 10 ); // $ExpectError
+}
+
+// Attached to main export is an `ndarray` method which returns a Float32Array...
+{
+	const x = new Float32Array( 10 );
+	const y = new Float32Array( 10 );
+
+	snancusumkbn.ndarray( x.length, 0.0, x, 1, 0, y, 1, 0 ); // $ExpectType Float32Array
+}
+
+// The compiler throws an error if the `ndarray` method is provided a first argument which is not a number...
+{
+	const x = new Float32Array( 10 );
+	const y = new Float32Array( 10 );
+
+	snancusumkbn.ndarray( '10', 0.0, x, 1, 0, y, 1, 0 ); // $ExpectError
+	snancusumkbn.ndarray( true, 0.0, x, 1, 0, y, 1, 0 ); // $ExpectError
+	snancusumkbn.ndarray( false, 0.0, x, 1, 0, y, 1, 0 ); // $ExpectError
+	snancusumkbn.ndarray( null, 0.0, x, 1, 0, y, 1, 0 ); // $ExpectError
+	snancusumkbn.ndarray( undefined, 0.0, x, 1, 0, y, 1, 0 ); // $ExpectError
+	snancusumkbn.ndarray( [], 0.0, x, 1, 0, y, 1, 0 ); // $ExpectError
+	snancusumkbn.ndarray( {}, 0.0, x, 1, 0, y, 1, 0 ); // $ExpectError
+	snancusumkbn.ndarray( ( x: number ): number => x, 0.0, x, 1, 0, y, 1, 0 ); // $ExpectError
+}
+
+// The compiler throws an error if the `ndarray` method is provided a second argument which is not a number...
+{
+	const x = new Float32Array( 10 );
+	const y = new Float32Array( 10 );
+
+	snancusumkbn.ndarray( x.length, '10', x, 1, 0, y, 1, 0 ); // $ExpectError
+	snancusumkbn.ndarray( x.length, true, x, 1, 0, y, 1, 0 ); // $ExpectError
+	snancusumkbn.ndarray( x.length, false, x, 1, 0, y, 1, 0 ); // $ExpectError
+	snancusumkbn.ndarray( x.length, null, x, 1, 0, y, 1, 0 ); // $ExpectError
+	snancusumkbn.ndarray( x.length, undefined, x, 1, 0, y, 1, 0 ); // $ExpectError
+	snancusumkbn.ndarray( x.length, [], x, 1, 0, y, 1, 0 ); // $ExpectError
+	snancusumkbn.ndarray( x.length, {}, x, 1, 0, y, 1, 0 ); // $ExpectError
+	snancusumkbn.ndarray( x.length, ( x: number ): number => x, x, 1, 0, y, 1, 0 ); // $ExpectError
+}
+
+// The compiler throws an error if the `ndarray` method is provided a third argument which is not a Float32Array...
+{
+	const x = new Float32Array( 10 );
+	const y = new Float32Array( 10 );
+
+	snancusumkbn.ndarray( x.length, 0.0, 10, 1, 0, y, 1, 0 ); // $ExpectError
+	snancusumkbn.ndarray( x.length, 0.0, '10', 1, 0, y, 1, 0 ); // $ExpectError
+	snancusumkbn.ndarray( x.length, 0.0, true, 1, 0, y, 1, 0 ); // $ExpectError
+	snancusumkbn.ndarray( x.length, 0.0, false, 1, 0, y, 1, 0 ); // $ExpectError
+	snancusumkbn.ndarray( x.length, 0.0, null, 1, 0, y, 1, 0 ); // $ExpectError
+	snancusumkbn.ndarray( x.length, 0.0, undefined, 1, 0, y, 1, 0 ); // $ExpectError
+	snancusumkbn.ndarray( x.length, 0.0, [ '1' ], 1, 0, y, 1, 0 ); // $ExpectError
+	snancusumkbn.ndarray( x.length, 0.0, {}, 1, 0, y, 1, 0 ); // $ExpectError
+	snancusumkbn.ndarray( x.length, 0.0, ( x: number ): number => x, 1, 0, y, 1, 0 ); // $ExpectError
+}
+
+// The compiler throws an error if the `ndarray` method is provided a fourth argument which is not a number...
+{
+	const x = new Float32Array( 10 );
+	const y = new Float32Array( 10 );
+
+	snancusumkbn.ndarray( x.length, 0.0, x, '10', 0, y, 1, 0 ); // $ExpectError
+	snancusumkbn.ndarray( x.length, 0.0, x, true, 0, y, 1, 0 ); // $ExpectError
+	snancusumkbn.ndarray( x.length, 0.0, x, false, 0, y, 1, 0 ); // $ExpectError
+	snancusumkbn.ndarray( x.length, 0.0, x, null, 0, y, 1, 0 ); // $ExpectError
+	snancusumkbn.ndarray( x.length, 0.0, x, undefined, 0, y, 1, 0 ); // $ExpectError
+	snancusumkbn.ndarray( x.length, 0.0, x, [], 0, y, 1, 0 ); // $ExpectError
+	snancusumkbn.ndarray( x.length, 0.0, x, {}, 0, y, 1, 0 ); // $ExpectError
+	snancusumkbn.ndarray( x.length, 0.0, x, ( x: number ): number => x, 0, y, 1, 0 ); // $ExpectError
+}
+
+// The compiler throws an error if the `ndarray` method is provided a fifth argument which is not a number...
+{
+	const x = new Float32Array( 10 );
+	const y = new Float32Array( 10 );
+
+	snancusumkbn.ndarray( x.length, 0.0, x, 1, '10', y, 1, 0 ); // $ExpectError
+	snancusumkbn.ndarray( x.length, 0.0, x, 1, true, y, 1, 0 ); // $ExpectError
+	snancusumkbn.ndarray( x.length, 0.0, x, 1, false, y, 1, 0 ); // $ExpectError
+	snancusumkbn.ndarray( x.length, 0.0, x, 1, null, y, 1, 0 ); // $ExpectError
+	snancusumkbn.ndarray( x.length, 0.0, x, 1, undefined, y, 1, 0 ); // $ExpectError
+	snancusumkbn.ndarray( x.length, 0.0, x, 1, [], y, 1, 0 ); // $ExpectError
+	snancusumkbn.ndarray( x.length, 0.0, x, 1, {}, y, 1, 0 ); // $ExpectError
+	snancusumkbn.ndarray( x.length, 0.0, x, 1, ( x: number ): number => x, y, 1, 0 ); // $ExpectError
+}
+
+// The compiler throws an error if the `ndarray` method is provided a sixth argument which is not a Float32Array...
+{
+	const x = new Float32Array( 10 );
+
+	snancusumkbn.ndarray( x.length, 0.0, x, 1, 0, 10, 1, 0 ); // $ExpectError
+	snancusumkbn.ndarray( x.length, 0.0, x, 1, 0, '10', 1, 0 ); // $ExpectError
+	snancusumkbn.ndarray( x.length, 0.0, x, 1, 0, true, 1, 0 ); // $ExpectError
+	snancusumkbn.ndarray( x.length, 0.0, x, 1, 0, false, 1, 0 ); // $ExpectError
+	snancusumkbn.ndarray( x.length, 0.0, x, 1, 0, null, 1, 0 ); // $ExpectError
+	snancusumkbn.ndarray( x.length, 0.0, x, 1, 0, undefined, 1, 0 ); // $ExpectError
+	snancusumkbn.ndarray( x.length, 0.0, x, 1, 0, [ '1' ], 1, 0 ); // $ExpectError
+	snancusumkbn.ndarray( x.length, 0.0, x, 1, 0, {}, 1, 0 ); // $ExpectError
+	snancusumkbn.ndarray( x.length, 0.0, x, 1, 0, ( x: number ): number => x, 1, 0 ); // $ExpectError
+}
+
+// The compiler throws an error if the `ndarray` method is provided a seventh argument which is not a number...
+{
+	const x = new Float32Array( 10 );
+	const y = new Float32Array( 10 );
+
+	snancusumkbn.ndarray( x.length, 0.0, x, 1, 0, y, '10', 0 ); // $ExpectError
+	snancusumkbn.ndarray( x.length, 0.0, x, 1, 0, y, true, 0 ); // $ExpectError
+	snancusumkbn.ndarray( x.length, 0.0, x, 1, 0, y, false, 0 ); // $ExpectError
+	snancusumkbn.ndarray( x.length, 0.0, x, 1, 0, y, null, 0 ); // $ExpectError
+	snancusumkbn.ndarray( x.length, 0.0, x, 1, 0, y, undefined, 0 ); // $ExpectError
+	snancusumkbn.ndarray( x.length, 0.0, x, 1, 0, y, [], 0 ); // $ExpectError
+	snancusumkbn.ndarray( x.length, 0.0, x, 1, 0, y, {}, 0 ); // $ExpectError
+	snancusumkbn.ndarray( x.length, 0.0, x, 1, 0, y, ( x: number ): number => x, 0 ); // $ExpectError
+}
+
+// The compiler throws an error if the `ndarray` method is provided an eighth argument which is not a number...
+{
+	const x = new Float32Array( 10 );
+	const y = new Float32Array( 10 );
+
+	snancusumkbn.ndarray( x.length, 0.0, x, 1, 0, y, 1, '10' ); // $ExpectError
+	snancusumkbn.ndarray( x.length, 0.0, x, 1, 0, y, 1, true ); // $ExpectError
+	snancusumkbn.ndarray( x.length, 0.0, x, 1, 0, y, 1, false ); // $ExpectError
+	snancusumkbn.ndarray( x.length, 0.0, x, 1, 0, y, 1, null ); // $ExpectError
+	snancusumkbn.ndarray( x.length, 0.0, x, 1, 0, y, 1, undefined ); // $ExpectError
+	snancusumkbn.ndarray( x.length, 0.0, x, 1, 0, y, 1, [] ); // $ExpectError
+	snancusumkbn.ndarray( x.length, 0.0, x, 1, 0, y, 1, {} ); // $ExpectError
+	snancusumkbn.ndarray( x.length, 0.0, x, 1, 0, y, 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 Float32Array( 10 );
+	const y = new Float32Array( 10 );
+
+	snancusumkbn.ndarray(); // $ExpectError
+	snancusumkbn.ndarray( x.length ); // $ExpectError
+	snancusumkbn.ndarray( x.length, 0.0 ); // $ExpectError
+	snancusumkbn.ndarray( x.length, 0.0, x ); // $ExpectError
+	snancusumkbn.ndarray( x.length, 0.0, x, 1 ); // $ExpectError
+	snancusumkbn.ndarray( x.length, 0.0, x, 1, 0 ); // $ExpectError
+	snancusumkbn.ndarray( x.length, 0.0, x, 1, 0, y ); // $ExpectError
+	snancusumkbn.ndarray( x.length, 0.0, x, 1, 0, y, 1 ); // $ExpectError
+	snancusumkbn.ndarray( x.length, 0.0, x, 1, 0, y, 1, 0, 10 ); // $ExpectError
+}
diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/examples/c/Makefile b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/examples/c/Makefile
new file mode 100644
index 000000000000..25ced822f96a
--- /dev/null
+++ b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/examples/c/Makefile
@@ -0,0 +1,146 @@
+#/
+# @license Apache-2.0
+#
+# Copyright (c) 2025 The Stdlib Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#/
+
+# VARIABLES #
+
+ifndef VERBOSE
+	QUIET := @
+else
+	QUIET :=
+endif
+
+# Determine the OS ([1][1], [2][2]).
+#
+# [1]: https://en.wikipedia.org/wiki/Uname#Examples
+# [2]: http://stackoverflow.com/a/27776822/2225624
+OS ?= $(shell uname)
+ifneq (, $(findstring MINGW,$(OS)))
+	OS := WINNT
+else
+ifneq (, $(findstring MSYS,$(OS)))
+	OS := WINNT
+else
+ifneq (, $(findstring CYGWIN,$(OS)))
+	OS := WINNT
+else
+ifneq (, $(findstring Windows_NT,$(OS)))
+	OS := WINNT
+endif
+endif
+endif
+endif
+
+# Define the program used for compiling C source files:
+ifdef C_COMPILER
+	CC := $(C_COMPILER)
+else
+	CC := gcc
+endif
+
+# Define the command-line options when compiling C files:
+CFLAGS ?= \
+	-std=c99 \
+	-O3 \
+	-Wall \
+	-pedantic
+
+# Determine whether to generate position independent code ([1][1], [2][2]).
+#
+# [1]: https://gcc.gnu.org/onlinedocs/gcc/Code-Gen-Options.html#Code-Gen-Options
+# [2]: http://stackoverflow.com/questions/5311515/gcc-fpic-option
+ifeq ($(OS), WINNT)
+	fPIC ?=
+else
+	fPIC ?= -fPIC
+endif
+
+# List of includes (e.g., `-I /foo/bar -I /beep/boop/include`):
+INCLUDE ?=
+
+# List of source files:
+SOURCE_FILES ?=
+
+# List of libraries (e.g., `-lopenblas -lpthread`):
+LIBRARIES ?=
+
+# List of library paths (e.g., `-L /foo/bar -L /beep/boop`):
+LIBPATH ?=
+
+# List of C targets:
+c_targets := example.out
+
+
+# RULES #
+
+#/
+# Compiles source files.
+#
+# @param {string} [C_COMPILER] - C compiler (e.g., `gcc`)
+# @param {string} [CFLAGS] - C compiler options
+# @param {(string|void)} [fPIC] - compiler flag determining whether to generate position independent code (e.g., `-fPIC`)
+# @param {string} [INCLUDE] - list of includes (e.g., `-I /foo/bar -I /beep/boop/include`)
+# @param {string} [SOURCE_FILES] - list of source files
+# @param {string} [LIBPATH] - list of library paths (e.g., `-L /foo/bar -L /beep/boop`)
+# @param {string} [LIBRARIES] - list of libraries (e.g., `-lopenblas -lpthread`)
+#
+# @example
+# make
+#
+# @example
+# make all
+#/
+all: $(c_targets)
+
+.PHONY: all
+
+#/
+# Compiles C source files.
+#
+# @private
+# @param {string} CC - C compiler (e.g., `gcc`)
+# @param {string} CFLAGS - C compiler options
+# @param {(string|void)} fPIC - compiler flag determining whether to generate position independent code (e.g., `-fPIC`)
+# @param {string} INCLUDE - list of includes (e.g., `-I /foo/bar`)
+# @param {string} SOURCE_FILES - list of source files
+# @param {string} LIBPATH - list of library paths (e.g., `-L /foo/bar`)
+# @param {string} LIBRARIES - list of libraries (e.g., `-lopenblas`)
+#/
+$(c_targets): %.out: %.c
+	$(QUIET) $(CC) $(CFLAGS) $(fPIC) $(INCLUDE) -o $@ $(SOURCE_FILES) $< $(LIBPATH) -lm $(LIBRARIES)
+
+#/
+# Runs compiled examples.
+#
+# @example
+# make run
+#/
+run: $(c_targets)
+	$(QUIET) ./$<
+
+.PHONY: run
+
+#/
+# Removes generated files.
+#
+# @example
+# make clean
+#/
+clean:
+	$(QUIET) -rm -f *.o *.out
+
+.PHONY: clean
diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/examples/c/example.c b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/examples/c/example.c
new file mode 100644
index 000000000000..602bdb365b3b
--- /dev/null
+++ b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/examples/c/example.c
@@ -0,0 +1,41 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*    http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+#include "stdlib/blas/ext/base/snancusumkbn.h"
+#include <stdio.h>
+
+int main( void ) {
+	// Create strided arrays:
+	const float x[] = { 1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 0.0f / 0.0f, 0.0f / 0.0f, 8.0f };
+	float y[] = { 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f };
+
+	// Specify the number of elements:
+	const int N = 4;
+
+	// Specify stride lengths:
+	const int strideX = 2;
+	const int strideY = -2;
+
+	// Compute the cumulative sum:
+	stdlib_strided_snancusumkbn( N, 0.0f, x, strideX, y, strideY );
+
+	// Print the result:
+	for ( int i = 0; i < 8; i++ ) {
+		printf( "y[ %d ] = %f\n", i, y[ i ] );
+	}
+}
diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/examples/index.js b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/examples/index.js
new file mode 100644
index 000000000000..b19d8cbbef62
--- /dev/null
+++ b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/examples/index.js
@@ -0,0 +1,41 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*    http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+'use strict';
+
+var discreteUniform = require( '@stdlib/random/base/discrete-uniform' );
+var bernoulli = require( '@stdlib/random/base/bernoulli' );
+var filledarrayBy = require( '@stdlib/array/filled-by' );
+var zeros = require( '@stdlib/array/zeros' );
+var snancusumkbn = require( './../lib' );
+
+function rand() {
+	if ( bernoulli( 0.7 ) > 0 ) {
+		return discreteUniform( 0, 100 );
+	}
+	return NaN;
+}
+
+var x = filledarrayBy( 10, 'float32', rand );
+console.log( x );
+
+var y = zeros( x.length, 'float32' );
+console.log( y );
+
+snancusumkbn( x.length, 0.0, x, 1, y, -1 );
+console.log( y );
diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/include.gypi b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/include.gypi
new file mode 100644
index 000000000000..ecfaf82a3279
--- /dev/null
+++ b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/include.gypi
@@ -0,0 +1,53 @@
+# @license Apache-2.0
+#
+# Copyright (c) 2025 The Stdlib Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# A GYP include file for building a Node.js native add-on.
+#
+# Main documentation:
+#
+# [1]: https://gyp.gsrc.io/docs/InputFormatReference.md
+# [2]: https://gyp.gsrc.io/docs/UserDocumentation.md
+{
+  # Define variables to be used throughout the configuration for all targets:
+  'variables': {
+    # Source directory:
+    'src_dir': './src',
+
+    # Include directories:
+    'include_dirs': [
+      '<!@(node -e "var arr = require(\'@stdlib/utils/library-manifest\')(\'./manifest.json\',{},{\'basedir\':process.cwd(),\'paths\':\'posix\'}).include; for ( var i = 0; i < arr.length; i++ ) { console.log( arr[ i ] ); }")',
+    ],
+
+    # Add-on destination directory:
+    'addon_output_dir': './src',
+
+    # Source files:
+    'src_files': [
+      '<(src_dir)/addon.c',
+      '<!@(node -e "var arr = require(\'@stdlib/utils/library-manifest\')(\'./manifest.json\',{},{\'basedir\':process.cwd(),\'paths\':\'posix\'}).src; for ( var i = 0; i < arr.length; i++ ) { console.log( arr[ i ] ); }")',
+    ],
+
+    # Library dependencies:
+    'libraries': [
+      '<!@(node -e "var arr = require(\'@stdlib/utils/library-manifest\')(\'./manifest.json\',{},{\'basedir\':process.cwd(),\'paths\':\'posix\'}).libraries; for ( var i = 0; i < arr.length; i++ ) { console.log( arr[ i ] ); }")',
+    ],
+
+    # Library directories:
+    'library_dirs': [
+      '<!@(node -e "var arr = require(\'@stdlib/utils/library-manifest\')(\'./manifest.json\',{},{\'basedir\':process.cwd(),\'paths\':\'posix\'}).libpath; for ( var i = 0; i < arr.length; i++ ) { console.log( arr[ i ] ); }")',
+    ],
+  }, # end variables
+}
diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/include/stdlib/blas/ext/base/snancusumkbn.h b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/include/stdlib/blas/ext/base/snancusumkbn.h
new file mode 100644
index 000000000000..fe2b89c86a2a
--- /dev/null
+++ b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/include/stdlib/blas/ext/base/snancusumkbn.h
@@ -0,0 +1,45 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*    http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+#ifndef STDLIB_BLAS_EXT_BASE_SNANCUSUMKBN_H
+#define STDLIB_BLAS_EXT_BASE_SNANCUSUMKBN_H
+
+#include "stdlib/blas/base/shared.h"
+
+/*
+* If C++, prevent name mangling so that the compiler emits a binary file having undecorated names, thus mirroring the behavior of a C compiler.
+*/
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+* Computes the cumulative sum of single-precision floating-point strided array elements ignoring `NaN` values and using an improved Kahan–Babuška algorithm.
+*/
+void API_SUFFIX( stdlib_strided_snancusumkbn )( const CBLAS_INT N, const float sum, const float *X, const CBLAS_INT strideX, float *Y, const CBLAS_INT strideY );
+
+/**
+* Computes the cumulative sum of single-precision floating-point strided array elements ignoring `NaN` values and using an improved Kahan–Babuška algorithm and alternative indexing semantics.
+*/
+void API_SUFFIX( stdlib_strided_snancusumkbn_ndarray )( const CBLAS_INT N, const float sum, const float *X, const CBLAS_INT strideX, const CBLAS_INT offsetX, float *Y, const CBLAS_INT strideY, const CBLAS_INT offsetY );
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // !STDLIB_BLAS_EXT_BASE_SNANCUSUMKBN_H
diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/lib/index.js b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/lib/index.js
new file mode 100644
index 000000000000..066ff94623ae
--- /dev/null
+++ b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/lib/index.js
@@ -0,0 +1,70 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*    http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+'use strict';
+
+/**
+* Compute the cumulative sum of single-precision floating-point strided array elements ignoring `NaN` values and using an improved Kahan–Babuška algorithm.
+*
+* @module @stdlib/blas/ext/base/snancusumkbn
+*
+* @example
+* var Float32Array = require( '@stdlib/array/float32' );
+* var snancusumkbn = require( '@stdlib/blas/ext/base/snancusumkbn' );
+*
+* var x = new Float32Array( [ 1.0, -2.0, NaN ] );
+* var y = new Float32Array( x.length );
+*
+* snancusumkbn( 3, 0.0, x, 1, y, 1 );
+* // y => <Float32Array>[ 1.0, -1.0, -1.0 ]
+*
+* @example
+* var Float32Array = require( '@stdlib/array/float32' );
+* var snancusumkbn = require( '@stdlib/blas/ext/base/snancusumkbn' );
+*
+* var x = new Float32Array( [ 2.0, 1.0, 2.0, -2.0, -2.0, NaN, 3.0, NaN ] );
+* var y = new Float32Array( x.length );
+*
+* snancusumkbn.ndarray( 4, 0.0, x, 2, 1, y, 1, 0 );
+* // y => <Float32Array>[ 1.0, -1.0, -1.0, -1.0, 0.0, 0.0, 0.0, 0.0 ]
+*/
+
+// MODULES //
+
+var join = require( 'path' ).join;
+var tryRequire = require( '@stdlib/utils/try-require' );
+var isError = require( '@stdlib/assert/is-error' );
+var main = require( './main.js' );
+
+
+// MAIN //
+
+var snancusumkbn;
+var tmp = tryRequire( join( __dirname, './native.js' ) );
+if ( isError( tmp ) ) {
+	snancusumkbn = main;
+} else {
+	snancusumkbn = tmp;
+}
+
+
+// EXPORTS //
+
+module.exports = snancusumkbn;
+
+// exports: { "ndarray": "snancusumkbn.ndarray" }
diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/lib/main.js b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/lib/main.js
new file mode 100644
index 000000000000..154bf71a2416
--- /dev/null
+++ b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/lib/main.js
@@ -0,0 +1,35 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*    http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+'use strict';
+
+// MODULES //
+
+var setReadOnly = require( '@stdlib/utils/define-nonenumerable-read-only-property' );
+var snancusumkbn = require( '@stdlib/blas/ext/base/snancusumkbn/lib/snancusumkbn.js' );
+var ndarray = require( './ndarray.js' );
+
+
+// MAIN //
+
+setReadOnly( snancusumkbn, 'ndarray', ndarray );
+
+
+// EXPORTS //
+
+module.exports = snancusumkbn;
diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/lib/native.js b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/lib/native.js
new file mode 100644
index 000000000000..81faffe49cb7
--- /dev/null
+++ b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/lib/native.js
@@ -0,0 +1,35 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*    http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+'use strict';
+
+// MODULES //
+
+var setReadOnly = require( '@stdlib/utils/define-nonenumerable-read-only-property' );
+var snancusumkbn = require( './snancusumkbn.native.js' );
+var ndarray = require( './ndarray.native.js' );
+
+
+// MAIN //
+
+setReadOnly( snancusumkbn, 'ndarray', ndarray );
+
+
+// EXPORTS //
+
+module.exports = snancusumkbn;
diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/lib/ndarray.js b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/lib/ndarray.js
new file mode 100644
index 000000000000..4bdc924c5f8f
--- /dev/null
+++ b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/lib/ndarray.js
@@ -0,0 +1,114 @@
+/**
+* @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 isnanf = require( '@stdlib/math/base/assert/is-nanf' );
+var absf = require( '@stdlib/math/base/special/absf' );
+
+
+// MAIN //
+
+/**
+* Computes the cumulative sum of single-precision floating-point strided array elements ignoring `NaN` values and using an improved Kahan–Babuška algorithm.
+*
+* @param {PositiveInteger} N - number of indexed elements
+* @param {number} sum - initial sum
+* @param {Float32Array} x - input array
+* @param {integer} strideX - stride length for `x`
+* @param {NonNegativeInteger} offsetX - starting index for `x`
+* @param {Float32Array} y - output array
+* @param {integer} strideY - stride length `y`
+* @param {NonNegativeInteger} offsetY - starting index for `y`
+* @returns {Float32Array} output array
+*
+* @example
+* var Float32Array = require( '@stdlib/array/float32' );
+*
+* var x = new Float32Array( [ 2.0, 1.0, 2.0, -2.0, -2.0, 2.0, NaN, NaN ] );
+* var y = new Float32Array( x.length );
+*
+* var v = snancusumkbn( 4, 0.0, x, 2, 1, y, 1, 0 );
+* // returns <Float32Array>[ 1.0, -1.0, 1.0, 1.0, 0.0, 0.0, 0.0, 0.0 ]
+*/
+function snancusumkbn( N, sum, x, strideX, offsetX, y, strideY, offsetY ) {
+	var ix;
+	var iy;
+	var s;
+	var v;
+	var t;
+	var c;
+	var i;
+
+	if ( N <= 0 ) {
+		return y;
+	}
+	ix = offsetX;
+	iy = offsetY;
+	s = sum;
+
+	// In order to preserve the sign of zero which can be lost during compensated summation below, find the first non-zero element...
+	if ( s === 0.0 ) {
+		for ( i = 0; i < N; i++ ) {
+			v = x[ ix ];
+			if ( isnanf( v ) ) {
+				y[ iy ] = s;
+				ix += strideX;
+				iy += strideY;
+				continue;
+			}
+			if ( v !== 0.0 ) {
+				break;
+			}
+			s += v;
+			y[ iy ] = s;
+			ix += strideX;
+			iy += strideY;
+		}
+	} else {
+		i = 0;
+	}
+	c = 0.0;
+	for ( ; i < N; i++ ) {
+		v = x[ ix ];
+		if ( isnanf( v ) ) {
+			y[ iy ] = s + c;
+			ix += strideX;
+			iy += strideY;
+			continue;
+		}
+		t = s + v;
+		if ( absf( s ) >= absf( v ) ) {
+			c += (s-t) + v;
+		} else {
+			c += (v-t) + s;
+		}
+		s = t;
+		y[ iy ] = s + c;
+		ix += strideX;
+		iy += strideY;
+	}
+	return y;
+}
+
+
+// EXPORTS //
+
+module.exports = snancusumkbn;
diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/lib/ndarray.native.js b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/lib/ndarray.native.js
new file mode 100644
index 000000000000..0d8bb4549eb3
--- /dev/null
+++ b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/lib/ndarray.native.js
@@ -0,0 +1,58 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*    http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+'use strict';
+
+// MODULES //
+
+var addon = require( './../src/addon.node' );
+
+
+// MAIN //
+
+/**
+* Computes the cumulative sum of single-precision floating-point strided array elements ignoring `NaN` values and using an improved Kahan–Babuška algorithm.
+*
+* @param {PositiveInteger} N - number of indexed elements
+* @param {number} sum - initial sum
+* @param {Float32Array} x - input array
+* @param {integer} strideX - stride length for `x`
+* @param {NonNegativeInteger} offsetX - starting index for `x`
+* @param {Float32Array} y - output array
+* @param {integer} strideY - stride length for `y`
+* @param {NonNegativeInteger} offsetY - starting index for `y`
+* @returns {Float32Array} output array
+*
+* @example
+* var Float32Array = require( '@stdlib/array/float32' );
+*
+* var x = new Float32Array( [ 2.0, 1.0, 2.0, -2.0, -2.0, 2.0, NaN, NaN ] );
+* var y = new Float32Array( x.length );
+*
+* var v = snancusumkbn( 4, 0.0, x, 2, 1, y, 1, 0 );
+* // returns <Float32Array>[ 1.0, -1.0, 1.0, 1.0, 0.0, 0.0, 0.0, 0.0 ]
+*/
+function snancusumkbn( N, sum, x, strideX, offsetX, y, strideY, offsetY ) {
+	addon.ndarray( N, sum, x, strideX, offsetX, y, strideY, offsetY );
+	return y;
+}
+
+
+// EXPORTS //
+
+module.exports = snancusumkbn;
diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/lib/snancusumkbn.js b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/lib/snancusumkbn.js
new file mode 100644
index 000000000000..03225d68cc34
--- /dev/null
+++ b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/lib/snancusumkbn.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';
+
+// MODULES //
+
+var stride2offset = require( '@stdlib/strided/base/stride2offset' );
+var ndarray = require( '@stdlib/blas/ext/base/snancusumkbn/lib/ndarray.js' );
+
+
+// MAIN //
+
+/**
+* Computes the cumulative sum of single-precision floating-point strided array elements ignoring `NaN` values and using an improved Kahan–Babuška algorithm.
+*
+* ## Method
+*
+* -   This implementation uses an "improved Kahan–Babuška algorithm", as described by Neumaier (1974).
+*
+* ## References
+*
+* -   Neumaier, Arnold. 1974. "Rounding Error Analysis of Some Methods for Summing Finite Sums." _Zeitschrift Für Angewandte Mathematik Und Mechanik_ 54 (1): 39–51. doi:[10.1002/zamm.19740540106](https://doi.org/10.1002/zamm.19740540106).
+*
+* @param {PositiveInteger} N - number of indexed elements
+* @param {number} sum - initial sum
+* @param {Float32Array} x - input array
+* @param {integer} strideX - stride length for `x`
+* @param {Float32Array} y - output array
+* @param {integer} strideY - stride length for `y`
+* @returns {Float32Array} output array
+*
+* @example
+* var Float32Array = require( '@stdlib/array/float32' );
+*
+* var x = new Float32Array( [ 1.0, -2.0, NaN ] );
+* var y = new Float32Array( x.length );
+*
+* var v = snancusumkbn( 3, 0.0, x, 1, y, 1 );
+* // returns <Float32Array>[ 1.0, -1.0, -1.0 ]
+*/
+function snancusumkbn( N, sum, x, strideX, y, strideY ) {
+	ndarray( N, sum, x, strideX, stride2offset( N, strideX ), y, strideY, stride2offset( N, strideY ) ); // eslint-disable-line max-len
+	return y;
+}
+
+
+// EXPORTS //
+
+module.exports = snancusumkbn;
diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/lib/snancusumkbn.native.js b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/lib/snancusumkbn.native.js
new file mode 100644
index 000000000000..c18f35555c3b
--- /dev/null
+++ b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/lib/snancusumkbn.native.js
@@ -0,0 +1,56 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*    http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+'use strict';
+
+// MODULES //
+
+var addon = require( './../src/addon.node' );
+
+
+// MAIN //
+
+/**
+* Computes the cumulative sum of single-precision floating-point strided array elements ignoring `NaN` values and using an improved Kahan–Babuška algorithm.
+*
+* @param {PositiveInteger} N - number of indexed elements
+* @param {number} sum - initial sum
+* @param {Float32Array} x - input array
+* @param {integer} strideX - stride length for `x`
+* @param {Float32Array} y - output array
+* @param {integer} strideY - stride length for `y`
+* @returns {Float32Array} output array
+*
+* @example
+* var Float32Array = require( '@stdlib/array/float32' );
+*
+* var x = new Float32Array( [ 1.0, -2.0, NaN ] );
+* var y = new Float32Array( x.length );
+*
+* var v = snancusumkbn( 3, 0.0, x, 1, y, 1 );
+* // returns <Float32Array>[ 1.0, -1.0, -1.0 ]
+*/
+function snancusumkbn( N, sum, x, strideX, y, strideY ) {
+	addon( N, sum, x, strideX, y, strideY );
+	return y;
+}
+
+
+// EXPORTS //
+
+module.exports = snancusumkbn;
diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/manifest.json b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/manifest.json
new file mode 100644
index 000000000000..dd379d1d4144
--- /dev/null
+++ b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/manifest.json
@@ -0,0 +1,85 @@
+{
+  "options": {
+    "task": "build"
+  },
+  "fields": [
+    {
+      "field": "src",
+      "resolve": true,
+      "relative": true
+    },
+    {
+      "field": "include",
+      "resolve": true,
+      "relative": true
+    },
+    {
+      "field": "libraries",
+      "resolve": false,
+      "relative": false
+    },
+    {
+      "field": "libpath",
+      "resolve": true,
+      "relative": false
+    }
+  ],
+  "confs": [
+    {
+      "task": "build",
+      "src": [
+        "./src/main.c"
+      ],
+      "include": [
+        "./include"
+      ],
+      "libraries": [],
+      "libpath": [],
+      "dependencies": [
+        "@stdlib/math/base/special/absf",
+        "@stdlib/math/base/assert/is-nanf",
+        "@stdlib/blas/base/shared",
+        "@stdlib/strided/base/stride2offset",
+        "@stdlib/napi/argv",
+        "@stdlib/napi/argv-int64",
+        "@stdlib/napi/argv-float",
+        "@stdlib/napi/argv-strided-float32array",
+        "@stdlib/napi/export"
+      ]
+    },
+    {
+      "task": "benchmark",
+      "src": [
+        "./src/main.c"
+      ],
+      "include": [
+        "./include"
+      ],
+      "libraries": [],
+      "libpath": [],
+      "dependencies": [
+        "@stdlib/math/base/special/absf",
+        "@stdlib/math/base/assert/is-nanf",
+        "@stdlib/blas/base/shared",
+        "@stdlib/strided/base/stride2offset"
+      ]
+    },
+    {
+      "task": "examples",
+      "src": [
+        "./src/main.c"
+      ],
+      "include": [
+        "./include"
+      ],
+      "libraries": [],
+      "libpath": [],
+      "dependencies": [
+        "@stdlib/math/base/special/absf",
+        "@stdlib/math/base/assert/is-nanf",
+        "@stdlib/blas/base/shared",
+        "@stdlib/strided/base/stride2offset"
+      ]
+    }
+  ]
+}
diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/package.json b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/package.json
new file mode 100644
index 000000000000..0ae6f5809535
--- /dev/null
+++ b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/package.json
@@ -0,0 +1,83 @@
+{
+  "name": "@stdlib/blas/ext/base/snancusumkbn",
+  "version": "0.0.0",
+  "description": "Calculate the cumulative sum of single-precision floating-point strided array elements ignoring NaN values and using an improved 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/main.js",
+  "gypfile": true,
+  "directories": {
+    "benchmark": "./benchmark",
+    "doc": "./docs",
+    "example": "./examples",
+    "include": "./include",
+    "lib": "./lib",
+    "src": "./src",
+    "test": "./test"
+  },
+  "types": "./docs/types",
+  "scripts": {},
+  "homepage": "https://github.com/stdlib-js/stdlib",
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/stdlib-js/stdlib.git"
+  },
+  "bugs": {
+    "url": "https://github.com/stdlib-js/stdlib/issues"
+  },
+  "dependencies": {},
+  "devDependencies": {},
+  "engines": {
+    "node": ">=0.10.0",
+    "npm": ">2.7.0"
+  },
+  "os": [
+    "aix",
+    "darwin",
+    "freebsd",
+    "linux",
+    "macos",
+    "openbsd",
+    "sunos",
+    "win32",
+    "windows"
+  ],
+  "keywords": [
+    "stdlib",
+    "stdmath",
+    "statistics",
+    "stats",
+    "mathematics",
+    "math",
+    "blas",
+    "extended",
+    "sum",
+    "total",
+    "summation",
+    "cumulative",
+    "accumulate",
+    "kbn",
+    "kahan",
+    "compensated",
+    "strided",
+    "strided array",
+    "typed",
+    "array",
+    "float32",
+    "single",
+    "float32array"
+  ],
+  "__stdlib__": {
+    "wasm": false
+  }
+}
diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/src/Makefile b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/src/Makefile
new file mode 100644
index 000000000000..7733b6180cb4
--- /dev/null
+++ b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/src/Makefile
@@ -0,0 +1,70 @@
+#/
+# @license Apache-2.0
+#
+# Copyright (c) 2025 The Stdlib Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#/
+
+# VARIABLES #
+
+ifndef VERBOSE
+	QUIET := @
+else
+	QUIET :=
+endif
+
+# Determine the OS ([1][1], [2][2]).
+#
+# [1]: https://en.wikipedia.org/wiki/Uname#Examples
+# [2]: http://stackoverflow.com/a/27776822/2225624
+OS ?= $(shell uname)
+ifneq (, $(findstring MINGW,$(OS)))
+	OS := WINNT
+else
+ifneq (, $(findstring MSYS,$(OS)))
+	OS := WINNT
+else
+ifneq (, $(findstring CYGWIN,$(OS)))
+	OS := WINNT
+else
+ifneq (, $(findstring Windows_NT,$(OS)))
+	OS := WINNT
+endif
+endif
+endif
+endif
+
+
+# RULES #
+
+#/
+# Removes generated files for building an add-on.
+#
+# @example
+# make clean-addon
+#/
+clean-addon:
+	$(QUIET) -rm -f *.o *.node
+
+.PHONY: clean-addon
+
+#/
+# Removes generated files.
+#
+# @example
+# make clean
+#/
+clean: clean-addon
+
+.PHONY: clean
diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/src/addon.c b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/src/addon.c
new file mode 100644
index 000000000000..5e6f0b28c9dd
--- /dev/null
+++ b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/src/addon.c
@@ -0,0 +1,68 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*    http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+#include <node_api.h>
+#include "stdlib/blas/base/shared.h"
+#include "stdlib/blas/ext/base/snancusumkbn.h"
+#include "stdlib/napi/argv.h"
+#include "stdlib/napi/argv_float.h"
+#include "stdlib/napi/argv_int32.h"
+#include "stdlib/napi/argv_strided_float32array.h"
+#include "stdlib/napi/export.h"
+
+/**
+* Receives JavaScript callback invocation data.
+*
+* @param env    environment under which the function is invoked
+* @param info   callback data
+* @return       Node-API value
+*/
+static napi_value addon( napi_env env, napi_callback_info info ) {
+	STDLIB_NAPI_ARGV( env, info, argv, argc, 6 );
+	STDLIB_NAPI_ARGV_INT32( env, N, argv, 0 );
+	STDLIB_NAPI_ARGV_FLOAT( env, sum, argv, 1 );
+	STDLIB_NAPI_ARGV_INT32( env, strideX, argv, 3 );
+	STDLIB_NAPI_ARGV_INT32( env, strideY, argv, 5 );
+	STDLIB_NAPI_ARGV_STRIDED_FLOAT32ARRAY( env, X, N, strideX, argv, 2 );
+	STDLIB_NAPI_ARGV_STRIDED_FLOAT32ARRAY( env, Y, N, strideY, argv, 4 );
+	API_SUFFIX( stdlib_strided_snancusumkbn )( N, sum, X, strideX, Y, strideY );
+	return NULL;
+}
+
+/**
+* Receives JavaScript callback invocation data.
+*
+* @param env    environment under which the function is invoked
+* @param info   callback data
+* @return       Node-API value
+*/
+static napi_value addon_method( napi_env env, napi_callback_info info ) {
+	STDLIB_NAPI_ARGV( env, info, argv, argc, 8 );
+	STDLIB_NAPI_ARGV_INT32( env, N, argv, 0 );
+	STDLIB_NAPI_ARGV_FLOAT( env, sum, argv, 1 );
+	STDLIB_NAPI_ARGV_INT32( env, strideX, argv, 3 );
+	STDLIB_NAPI_ARGV_INT32( env, offsetX, argv, 4 );
+	STDLIB_NAPI_ARGV_INT32( env, strideY, argv, 6 );
+	STDLIB_NAPI_ARGV_INT32( env, offsetY, argv, 7 );
+	STDLIB_NAPI_ARGV_STRIDED_FLOAT32ARRAY( env, X, N, strideX, argv, 2 );
+	STDLIB_NAPI_ARGV_STRIDED_FLOAT32ARRAY( env, Y, N, strideY, argv, 5 );
+	API_SUFFIX( stdlib_strided_snancusumkbn_ndarray )( N, sum, X, strideX, offsetX, Y, strideY, offsetY );
+	return NULL;
+}
+
+STDLIB_NAPI_MODULE_EXPORT_FCN_WITH_METHOD( addon, "ndarray", addon_method )
diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/src/main.c b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/src/main.c
new file mode 100644
index 000000000000..a4e9ab0ec9f2
--- /dev/null
+++ b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/src/main.c
@@ -0,0 +1,127 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*    http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+#include "stdlib/blas/base/shared.h"
+#include "stdlib/blas/ext/base/snancusumkbn.h"
+#include "stdlib/math/base/assert/is_nanf.h"
+#include "stdlib/math/base/special/absf.h"
+#include "stdlib/strided/base/stride2offset.h"
+
+/**
+* Computes the cumulative sum of single-precision floating-point strided array elements ignoring `NaN` values and using an improved Kahan–Babuška algorithm.
+*
+* ## Method
+*
+* -   This implementation uses an "improved Kahan–Babuška algorithm", as described by Neumaier (1974).
+*
+* ## References
+*
+* -   Neumaier, Arnold. 1974. "Rounding Error Analysis of Some Methods for Summing Finite Sums." _Zeitschrift Für Angewandte Mathematik Und Mechanik_ 54 (1): 39–51. doi:[10.1002/zamm.19740540106](https://doi.org/10.1002/zamm.19740540106).
+*
+* @param N        number of indexed elements
+* @param sum      initial sum
+* @param X        input array
+* @param strideX  stride length for X
+* @param Y        output array
+* @param strideY  stride length for Y
+*/
+void API_SUFFIX( stdlib_strided_snancusumkbn )( const CBLAS_INT N, const float sum, const float *X, const CBLAS_INT strideX, float *Y, const CBLAS_INT strideY ) {
+	const CBLAS_INT ox = stdlib_strided_stride2offset( N, strideX );
+	const CBLAS_INT oy = stdlib_strided_stride2offset( N, strideY );
+	API_SUFFIX( stdlib_strided_snancusumkbn_ndarray )( N, sum, X, strideX, ox, Y, strideY, oy );
+}
+
+/**
+* Computes the cumulative sum of single-precision floating-point strided array elements ignoring `NaN` values and using an improved Kahan–Babuška algorithm and alternative indexing semantics.
+*
+* ## Method
+*
+* -   This implementation uses an "improved Kahan–Babuška algorithm", as described by Neumaier (1974).
+*
+* ## References
+*
+* -   Neumaier, Arnold. 1974. "Rounding Error Analysis of Some Methods for Summing Finite Sums." _Zeitschrift Für Angewandte Mathematik Und Mechanik_ 54 (1): 39–51. doi:[10.1002/zamm.19740540106](https://doi.org/10.1002/zamm.19740540106).
+*
+* @param N        number of indexed elements
+* @param sum      initial sum
+* @param X        input array
+* @param strideX  stride length for X
+* @param offsetX  starting index for X
+* @param Y        output array
+* @param strideY  stride length for Y
+* @param offsetY  starting index for Y
+*/
+void API_SUFFIX( stdlib_strided_snancusumkbn_ndarray )( const CBLAS_INT N, const float sum, const float *X, const CBLAS_INT strideX, const CBLAS_INT offsetX, float *Y, const CBLAS_INT strideY, const CBLAS_INT offsetY ) {
+	CBLAS_INT ix;
+	CBLAS_INT iy;
+	CBLAS_INT i;
+	float s;
+	float v;
+	float t;
+	float c;
+
+	if ( N <= 0 ) {
+		return;
+	}
+	ix = offsetX;
+	iy = offsetY;
+	s = sum;
+
+	// In order to preserve the sign of zero which can be lost during compensated summation below, find the first non-zero element...
+	if ( s == 0.0f ) {
+		for ( i = 0; i < N; i++ ) {
+			v = X[ ix ];
+			if ( stdlib_base_is_nanf( v ) ) {
+				Y[ iy ] = s;
+				ix += strideX;
+				iy += strideY;
+				continue;
+			}
+			if ( v != 0.0f ) {
+				break;
+			}
+			s += v;
+			Y[ iy ] = s;
+			ix += strideX;
+			iy += strideY;
+		}
+	} else {
+		i = 0;
+	}
+	c = 0.0f;
+	for ( ; i < N; i++ ) {
+		v = X[ ix ];
+		if ( stdlib_base_is_nanf( v ) ) {
+			Y[ iy ] = s + c;
+			ix += strideX;
+			iy += strideY;
+			continue;
+		}
+		t = s + v;
+		if ( stdlib_base_absf( s ) >= stdlib_base_absf( v ) ) {
+			c += ( s - t ) + v;
+		} else {
+			c += ( v - t ) + s;
+		}
+		s = t;
+		Y[ iy ] = s + c;
+		ix += strideX;
+		iy += strideY;
+	}
+	return;
+}
diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/test/test.js b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/test/test.js
new file mode 100644
index 000000000000..bbc4fec76d8b
--- /dev/null
+++ b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/test/test.js
@@ -0,0 +1,82 @@
+/**
+* @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 proxyquire = require( 'proxyquire' );
+var IS_BROWSER = require( '@stdlib/assert/is-browser' );
+var snancusumkbn = require( './../lib' );
+
+
+// VARIABLES //
+
+var opts = {
+	'skip': IS_BROWSER
+};
+
+
+// TESTS //
+
+tape( 'main export is a function', function test( t ) {
+	t.ok( true, __filename );
+	t.strictEqual( typeof snancusumkbn, 'function', 'main export is a function' );
+	t.end();
+});
+
+tape( 'attached to the main export is a method providing an ndarray interface', function test( t ) {
+	t.strictEqual( typeof snancusumkbn.ndarray, 'function', 'method is a function' );
+	t.end();
+});
+
+tape( 'if a native implementation is available, the main export is the native implementation', opts, function test( t ) {
+	var snancusumkbn = proxyquire( './../lib', {
+		'@stdlib/utils/try-require': tryRequire
+	});
+
+	t.strictEqual( snancusumkbn, mock, 'returns expected value' );
+	t.end();
+
+	function tryRequire() {
+		return mock;
+	}
+
+	function mock() {
+		// Mock...
+	}
+});
+
+tape( 'if a native implementation is not available, the main export is a JavaScript implementation', opts, function test( t ) {
+	var snancusumkbn;
+	var main;
+
+	main = require( './../lib/snancusumkbn.js' );
+
+	snancusumkbn = proxyquire( './../lib', {
+		'@stdlib/utils/try-require': tryRequire
+	});
+
+	t.strictEqual( snancusumkbn, main, 'returns expected value' );
+	t.end();
+
+	function tryRequire() {
+		return new Error( 'Cannot find module' );
+	}
+});
diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/test/test.ndarray.js b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/test/test.ndarray.js
new file mode 100644
index 000000000000..d610d24deb92
--- /dev/null
+++ b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/test/test.ndarray.js
@@ -0,0 +1,357 @@
+/**
+* @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 Float32Array = require( '@stdlib/array/float32' );
+var isSameFloat32Array = require( '@stdlib/assert/is-same-float32array' );
+var snancusumkbn = require( './../lib/ndarray.js' );
+
+
+// TESTS //
+
+tape( 'main export is a function', function test( t ) {
+	t.ok( true, __filename );
+	t.strictEqual( typeof snancusumkbn, 'function', 'main export is a function' );
+	t.end();
+});
+
+tape( 'the function has an arity of 8', function test( t ) {
+	t.strictEqual( snancusumkbn.length, 8, 'returns expected value' );
+	t.end();
+});
+
+tape( 'the function calculates the cumulative sum (ignoring NaN values)', function test( t ) {
+	var expected;
+	var x;
+	var y;
+	var i;
+
+	x = new Float32Array( [ 1.0, 2.0, NaN, NaN, 5.0 ] );
+	y = new Float32Array( x.length );
+
+	snancusumkbn( x.length, 0.0, x, 1, 0, y, 1, 0 );
+	expected = new Float32Array([
+		1.0,
+		3.0,
+		3.0,
+		3.0,
+		8.0
+	]);
+	t.deepEqual( y, expected, 'returns expected value' );
+
+	x = new Float32Array( [ 1.0, 2.0, NaN, NaN, 5.0 ] );
+	y = new Float32Array( x.length );
+
+	snancusumkbn( x.length, 10.0, x, 1, 0, y, 1, 0 );
+	expected = new Float32Array([
+		11.0,
+		13.0,
+		13.0,
+		13.0,
+		18.0
+	]);
+	t.deepEqual( y, expected, 'returns expected value' );
+
+	x = new Float32Array( [ NaN, NaN ] );
+	y = new Float32Array( x.length );
+	snancusumkbn( x.length, 0.0, x, 1, 0, y, 1, 0 );
+	expected = new Float32Array([
+		0.0,
+		0.0
+	]);
+	t.deepEqual( y, expected, 'returns expected value' );
+
+	x = new Float32Array( [ 1.0, NaN, 3.0, NaN ] );
+	y = new Float32Array( x.length );
+	snancusumkbn( x.length, 0.0, x, 1, 0, y, 1, 0 );
+
+	expected = new Float32Array([
+		1.0,
+		1.0,
+		4.0,
+		4.0
+	]);
+	t.deepEqual( y, expected, 'returns expected value' );
+
+	x = new Float32Array( [ 1.0, 1.0e38, NaN, -1.0e38 ] );
+	y = new Float32Array( x.length );
+	snancusumkbn( x.length, 0.0, x, 1, 0, y, 1, 0 );
+
+	expected = new Float32Array([
+		1.0,
+		1.0e38,
+		1.0e38,
+		1.0
+	]);
+	t.deepEqual( y, expected, 'returns expected value' );
+
+	x = new Float32Array( 1e3 );
+	y = new Float32Array( x.length );
+	expected = new Float32Array( x.length );
+	for ( i = 0; i < x.length; i++ ) {
+		x[ i ] = i + 1;
+		if ( i === 0 ) {
+			expected[ i ] += x[ i ];
+		} else {
+			expected[ i ] += expected[ i-1 ] + x[ i ];
+		}
+	}
+	snancusumkbn( x.length, 0.0, x, 1, 0, y, 1, 0 );
+	t.deepEqual( y, expected, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function preserves the sign of zero', function test( t ) {
+	var expected;
+	var x;
+	var y;
+
+	x = new Float32Array( [ -0.0, -0.0, -0.0, 0.0, 1.0 ] );
+	y = new Float32Array( x.length );
+
+	snancusumkbn( x.length, -0.0, x, 1, 0, y, 1, 0 );
+	expected = new Float32Array([
+		-0.0,
+		-0.0,
+		-0.0,
+		0.0,
+		1.0
+	]);
+	t.strictEqual( isSameFloat32Array( y, expected ), true, 'returns expected value' );
+	t.end();
+});
+
+tape( 'the function returns a reference to the output array', function test( t ) {
+	var out;
+	var x;
+	var y;
+
+	x = new Float32Array( [ 1.0, 2.0, 3.0, 4.0, 5.0 ] );
+	y = new Float32Array( [ 0.0, 0.0, 0.0, 0.0, 0.0 ] );
+
+	out = snancusumkbn( x.length, 0.0, x, 1, 0, y, 1, 0 );
+
+	t.strictEqual( out, y, 'same reference' );
+	t.end();
+});
+
+tape( 'if provided an `N` parameter less than or equal to `0`, the function returns `y` unchanged', function test( t ) {
+	var expected;
+	var x;
+	var y;
+
+	x = new Float32Array( [ 1.0, 2.0, 3.0, 4.0, 5.0 ] );
+	y = new Float32Array( [ 6.0, 7.0, 8.0, 9.0, 10.0 ] );
+
+	expected = new Float32Array( [ 6.0, 7.0, 8.0, 9.0, 10.0 ] );
+
+	snancusumkbn( -1, 0.0, x, 1, 0, y, 1, 0 );
+	t.deepEqual( y, expected, 'returns `y` unchanged' );
+
+	snancusumkbn( 0, 0.0, x, 1, 0, y, 1, 0 );
+	t.deepEqual( y, expected, 'returns `y` unchanged' );
+
+	t.end();
+});
+
+tape( 'the function supports an `x` stride', function test( t ) {
+	var expected;
+	var x;
+	var y;
+
+	x = new Float32Array([
+		1.0, // 0
+		2.0,
+		NaN, // 1
+		NaN,
+		5.0  // 2
+	]);
+	y = new Float32Array([
+		0.0, // 0
+		0.0, // 1
+		0.0, // 2
+		0.0,
+		0.0
+	]);
+
+	snancusumkbn( 3, 0.0, x, 2, 0, y, 1, 0 );
+
+	expected = new Float32Array( [ 1.0, 1.0, 6.0, 0.0, 0.0 ] );
+
+	t.deepEqual( y, expected, 'returns expected value' );
+	t.end();
+});
+
+tape( 'the function supports a `y` stride', function test( t ) {
+	var expected;
+	var x;
+	var y;
+
+	x = new Float32Array([
+		1.0, // 0
+		2.0, // 1
+		NaN, // 2
+		4.0,
+		5.0
+	]);
+	y = new Float32Array([
+		0.0, // 0
+		0.0,
+		0.0, // 1
+		0.0,
+		0.0  // 2
+	]);
+
+	snancusumkbn( 3, 0.0, x, 1, 0, y, 2, 0 );
+
+	expected = new Float32Array( [ 1.0, 0.0, 3.0, 0.0, 3.0 ] );
+
+	t.deepEqual( y, expected, 'returns expected value' );
+	t.end();
+});
+
+tape( 'the function supports negative strides', function test( t ) {
+	var expected;
+	var x;
+	var y;
+
+	x = new Float32Array([
+		NaN, // 2
+		NaN,
+		3.0, // 1
+		4.0,
+		5.0  // 0
+	]);
+	y = new Float32Array([
+		0.0, // 2
+		0.0, // 1
+		0.0, // 0
+		0.0,
+		0.0
+	]);
+
+	snancusumkbn( 3, 0.0, x, -2, x.length-1, y, -1, 2 );
+
+	expected = new Float32Array( [ 8.0, 8.0, 5.0, 0.0, 0.0 ] );
+
+	t.deepEqual( y, expected, 'returns expected value' );
+	t.end();
+});
+
+tape( 'the function supports an `x` offset', function test( t ) {
+	var expected;
+	var x;
+	var y;
+
+	x = new Float32Array([
+		2.0,
+		NaN,  // 0
+		NaN,
+		-2.0, // 1
+		-2.0,
+		2.0,  // 2
+		3.0,
+		4.0   // 3
+	]);
+	y = new Float32Array([
+		0.0, // 0
+		0.0, // 1
+		0.0, // 2
+		0.0, // 3
+		0.0,
+		0.0,
+		0.0,
+		0.0
+	]);
+
+	snancusumkbn( 4, 0.0, x, 2, 1, y, 1, 0 );
+
+	expected = new Float32Array( [ 0.0, -2.0, 0.0, 4.0, 0.0, 0.0, 0.0, 0.0 ] );
+
+	t.deepEqual( y, expected, 'returns expected value' );
+	t.end();
+});
+
+tape( 'the function supports a `y` offset', function test( t ) {
+	var expected;
+	var x;
+	var y;
+
+	x = new Float32Array([
+		2.0,  // 0
+		1.0,  // 1
+		2.0,  // 2
+		NaN, // 3
+		NaN,
+		2.0,
+		3.0,
+		4.0
+	]);
+	y = new Float32Array([
+		0.0,
+		0.0, // 0
+		0.0,
+		0.0, // 1
+		0.0,
+		0.0, // 2
+		0.0,
+		0.0  // 3
+	]);
+
+	snancusumkbn( 4, 0.0, x, 1, 0, y, 2, 1 );
+
+	expected = new Float32Array( [ 0.0, 2.0, 0.0, 3.0, 0.0, 5.0, 0.0, 5.0 ] );
+
+	t.deepEqual( y, expected, 'returns expected value' );
+	t.end();
+});
+
+tape( 'the function supports complex access patterns', function test( t ) {
+	var expected;
+	var x;
+	var y;
+
+	x = new Float32Array([
+		1.0, // 0
+		2.0,
+		3.0, // 1
+		4.0,
+		NaN, // 2
+		NaN
+	]);
+	y = new Float32Array([
+		0.0,  // 2
+		0.0,  // 1
+		0.0,  // 0
+		0.0,
+		0.0,
+		0.0
+	]);
+
+	snancusumkbn( 3, 0.0, x, 2, 0, y, -1, 2 );
+
+	expected = new Float32Array( [ 4.0, 4.0, 1.0, 0.0, 0.0, 0.0 ] );
+
+	t.deepEqual( y, expected, 'returns expected value' );
+	t.end();
+});
diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/test/test.ndarray.native.js b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/test/test.ndarray.native.js
new file mode 100644
index 000000000000..e5da3a6a0913
--- /dev/null
+++ b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/test/test.ndarray.native.js
@@ -0,0 +1,366 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*    http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+'use strict';
+
+// MODULES //
+
+var resolve = require( 'path' ).resolve;
+var tape = require( 'tape' );
+var Float32Array = require( '@stdlib/array/float32' );
+var isSameFloat32Array = require( '@stdlib/assert/is-same-float32array' );
+var tryRequire = require( '@stdlib/utils/try-require' );
+
+
+// VARIABLES //
+
+var snancusumkbn = tryRequire( resolve( __dirname, './../lib/ndarray.native.js' ) );
+var opts = {
+	'skip': ( snancusumkbn instanceof Error )
+};
+
+
+// TESTS //
+
+tape( 'main export is a function', opts, function test( t ) {
+	t.ok( true, __filename );
+	t.strictEqual( typeof snancusumkbn, 'function', 'main export is a function' );
+	t.end();
+});
+
+tape( 'the function has an arity of 8', opts, function test( t ) {
+	t.strictEqual( snancusumkbn.length, 8, 'returns expected value' );
+	t.end();
+});
+
+tape( 'the function calculates the cumulative sum (ignoring NaN values)', opts, function test( t ) {
+	var expected;
+	var x;
+	var y;
+	var i;
+
+	x = new Float32Array( [ 1.0, 2.0, NaN, NaN, 5.0 ] );
+	y = new Float32Array( x.length );
+
+	snancusumkbn( x.length, 0.0, x, 1, 0, y, 1, 0 );
+	expected = new Float32Array([
+		1.0,
+		3.0,
+		3.0,
+		3.0,
+		8.0
+	]);
+	t.deepEqual( y, expected, 'returns expected value' );
+
+	x = new Float32Array( [ 1.0, 2.0, NaN, NaN, 5.0 ] );
+	y = new Float32Array( x.length );
+
+	snancusumkbn( x.length, 10.0, x, 1, 0, y, 1, 0 );
+	expected = new Float32Array([
+		11.0,
+		13.0,
+		13.0,
+		13.0,
+		18.0
+	]);
+	t.deepEqual( y, expected, 'returns expected value' );
+
+	x = new Float32Array( [ NaN, NaN ] );
+	y = new Float32Array( x.length );
+	snancusumkbn( x.length, 0.0, x, 1, 0, y, 1, 0 );
+	expected = new Float32Array([
+		0.0,
+		0.0
+	]);
+	t.deepEqual( y, expected, 'returns expected value' );
+
+	x = new Float32Array( [ 1.0, NaN, 3.0, NaN ] );
+	y = new Float32Array( x.length );
+	snancusumkbn( x.length, 0.0, x, 1, 0, y, 1, 0 );
+
+	expected = new Float32Array([
+		1.0,
+		1.0,
+		4.0,
+		4.0
+	]);
+	t.deepEqual( y, expected, 'returns expected value' );
+
+	x = new Float32Array( [ 1.0, 1.0e38, NaN, -1.0e38 ] );
+	y = new Float32Array( x.length );
+	snancusumkbn( x.length, 0.0, x, 1, 0, y, 1, 0 );
+
+	expected = new Float32Array([
+		1.0,
+		1.0e38,
+		1.0e38,
+		1.0
+	]);
+	t.deepEqual( y, expected, 'returns expected value' );
+
+	x = new Float32Array( 1e3 );
+	y = new Float32Array( x.length );
+	expected = new Float32Array( x.length );
+	for ( i = 0; i < x.length; i++ ) {
+		x[ i ] = i + 1;
+		if ( i === 0 ) {
+			expected[ i ] += x[ i ];
+		} else {
+			expected[ i ] += expected[ i-1 ] + x[ i ];
+		}
+	}
+	snancusumkbn( x.length, 0.0, x, 1, 0, y, 1, 0 );
+	t.deepEqual( y, expected, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function preserves the sign of zero', opts, function test( t ) {
+	var expected;
+	var x;
+	var y;
+
+	x = new Float32Array( [ -0.0, -0.0, -0.0, 0.0, 1.0 ] );
+	y = new Float32Array( x.length );
+
+	snancusumkbn( x.length, -0.0, x, 1, 0, y, 1, 0 );
+	expected = new Float32Array([
+		-0.0,
+		-0.0,
+		-0.0,
+		0.0,
+		1.0
+	]);
+	t.strictEqual( isSameFloat32Array( y, expected ), true, 'returns expected value' );
+	t.end();
+});
+
+tape( 'the function returns a reference to the output array', opts, function test( t ) {
+	var out;
+	var x;
+	var y;
+
+	x = new Float32Array( [ 1.0, 2.0, 3.0, 4.0, 5.0 ] );
+	y = new Float32Array( [ 0.0, 0.0, 0.0, 0.0, 0.0 ] );
+
+	out = snancusumkbn( x.length, 0.0, x, 1, 0, y, 1, 0 );
+
+	t.strictEqual( out, y, 'same reference' );
+	t.end();
+});
+
+tape( 'if provided an `N` parameter less than or equal to `0`, the function returns `y` unchanged', opts, function test( t ) {
+	var expected;
+	var x;
+	var y;
+
+	x = new Float32Array( [ 1.0, 2.0, 3.0, 4.0, 5.0 ] );
+	y = new Float32Array( [ 6.0, 7.0, 8.0, 9.0, 10.0 ] );
+
+	expected = new Float32Array( [ 6.0, 7.0, 8.0, 9.0, 10.0 ] );
+
+	snancusumkbn( -1, 0.0, x, 1, 0, y, 1, 0 );
+	t.deepEqual( y, expected, 'returns `y` unchanged' );
+
+	snancusumkbn( 0, 0.0, x, 1, 0, y, 1, 0 );
+	t.deepEqual( y, expected, 'returns `y` unchanged' );
+
+	t.end();
+});
+
+tape( 'the function supports an `x` stride', opts, function test( t ) {
+	var expected;
+	var x;
+	var y;
+
+	x = new Float32Array([
+		1.0, // 0
+		2.0,
+		NaN, // 1
+		NaN,
+		5.0  // 2
+	]);
+	y = new Float32Array([
+		0.0, // 0
+		0.0, // 1
+		0.0, // 2
+		0.0,
+		0.0
+	]);
+
+	snancusumkbn( 3, 0.0, x, 2, 0, y, 1, 0 );
+
+	expected = new Float32Array( [ 1.0, 1.0, 6.0, 0.0, 0.0 ] );
+
+	t.deepEqual( y, expected, 'returns expected value' );
+	t.end();
+});
+
+tape( 'the function supports a `y` stride', opts, function test( t ) {
+	var expected;
+	var x;
+	var y;
+
+	x = new Float32Array([
+		1.0, // 0
+		2.0, // 1
+		NaN, // 2
+		4.0,
+		5.0
+	]);
+	y = new Float32Array([
+		0.0, // 0
+		0.0,
+		0.0, // 1
+		0.0,
+		0.0  // 2
+	]);
+
+	snancusumkbn( 3, 0.0, x, 1, 0, y, 2, 0 );
+
+	expected = new Float32Array( [ 1.0, 0.0, 3.0, 0.0, 3.0 ] );
+
+	t.deepEqual( y, expected, 'returns expected value' );
+	t.end();
+});
+
+tape( 'the function supports negative strides', opts, function test( t ) {
+	var expected;
+	var x;
+	var y;
+
+	x = new Float32Array([
+		NaN, // 2
+		NaN,
+		3.0, // 1
+		4.0,
+		5.0  // 0
+	]);
+	y = new Float32Array([
+		0.0, // 2
+		0.0, // 1
+		0.0, // 0
+		0.0,
+		0.0
+	]);
+
+	snancusumkbn( 3, 0.0, x, -2, x.length-1, y, -1, 2 );
+
+	expected = new Float32Array( [ 8.0, 8.0, 5.0, 0.0, 0.0 ] );
+
+	t.deepEqual( y, expected, 'returns expected value' );
+	t.end();
+});
+
+tape( 'the function supports an `x` offset', opts, function test( t ) {
+	var expected;
+	var x;
+	var y;
+
+	x = new Float32Array([
+		2.0,
+		1.0,  // 0
+		2.0,
+		-2.0, // 1
+		-2.0,
+		2.0,  // 2
+		3.0,
+		NaN   // 3
+	]);
+	y = new Float32Array([
+		0.0, // 0
+		0.0, // 1
+		0.0, // 2
+		0.0, // 3
+		0.0,
+		0.0,
+		0.0,
+		0.0
+	]);
+
+	snancusumkbn( 4, 0.0, x, 2, 1, y, 1, 0 );
+
+	expected = new Float32Array( [ 1.0, -1.0, 1.0, 1.0, 0.0, 0.0, 0.0, 0.0 ] );
+
+	t.deepEqual( y, expected, 'returns expected value' );
+	t.end();
+});
+
+tape( 'the function supports a `y` offset', opts, function test( t ) {
+	var expected;
+	var x;
+	var y;
+
+	x = new Float32Array([
+		2.0,  // 0
+		1.0,  // 1
+		2.0,  // 2
+		NaN, // 3
+		-2.0,
+		2.0,
+		3.0,
+		4.0
+	]);
+	y = new Float32Array([
+		0.0,
+		0.0, // 0
+		0.0,
+		0.0, // 1
+		0.0,
+		0.0, // 2
+		0.0,
+		0.0  // 3
+	]);
+
+	snancusumkbn( 4, 0.0, x, 1, 0, y, 2, 1 );
+
+	expected = new Float32Array( [ 0.0, 2.0, 0.0, 3.0, 0.0, 5.0, 0.0, 5.0 ] );
+
+	t.deepEqual( y, expected, 'returns expected value' );
+	t.end();
+});
+
+tape( 'the function supports complex access patterns', opts, function test( t ) {
+	var expected;
+	var x;
+	var y;
+
+	x = new Float32Array([
+		1.0, // 0
+		2.0,
+		3.0, // 1
+		4.0,
+		5.0, // 2
+		NaN
+	]);
+	y = new Float32Array([
+		0.0,  // 2
+		0.0,  // 1
+		0.0,  // 0
+		0.0,
+		0.0,
+		0.0
+	]);
+
+	snancusumkbn( 3, 0.0, x, 2, 0, y, -1, 2 );
+
+	expected = new Float32Array( [ 9.0, 4.0, 1.0, 0.0, 0.0, 0.0 ] );
+
+	t.deepEqual( y, expected, 'returns expected value' );
+	t.end();
+});
diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/test/test.snancusumkbn.js b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/test/test.snancusumkbn.js
new file mode 100644
index 000000000000..16e473947228
--- /dev/null
+++ b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/test/test.snancusumkbn.js
@@ -0,0 +1,304 @@
+/**
+* @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 Float32Array = require( '@stdlib/array/float32' );
+var snancusumkbn = require( './../lib/snancusumkbn.js' );
+
+
+// TESTS //
+
+tape( 'main export is a function', function test( t ) {
+	t.ok( true, __filename );
+	t.strictEqual( typeof snancusumkbn, 'function', 'main export is a function' );
+	t.end();
+});
+
+tape( 'the function has an arity of 6', function test( t ) {
+	t.strictEqual( snancusumkbn.length, 6, 'returns expected value' );
+	t.end();
+});
+
+tape( 'the function computes the cumulative sum (ignoring NaN values)', function test( t ) {
+	var expected;
+	var x;
+	var y;
+	var i;
+
+	x = new Float32Array( [ 1.0, 2.0, NaN, 4.0, NaN ] );
+	y = new Float32Array( x.length );
+
+	snancusumkbn( x.length, 0.0, x, 1, y, 1 );
+	expected = new Float32Array([
+		1.0,
+		3.0,
+		3.0,
+		7.0,
+		7.0
+	]);
+	t.deepEqual( y, expected, 'returns expected value' );
+
+	x = new Float32Array( [ 1.0, 2.0, NaN, NaN, 5.0 ] );
+	y = new Float32Array( x.length );
+
+	snancusumkbn( x.length, 10.0, x, 1, y, 1 );
+	expected = new Float32Array([
+		11.0,
+		13.0,
+		13.0,
+		13.0,
+		18.0
+	]);
+	t.deepEqual( y, expected, 'returns expected value' );
+
+	x = new Float32Array( [ NaN, NaN ] );
+	y = new Float32Array( x.length );
+	snancusumkbn( x.length, 0.0, x, 1, y, 1 );
+	expected = new Float32Array([
+		0.0,
+		0.0
+	]);
+	t.deepEqual( y, expected, 'returns expected value' );
+
+	x = new Float32Array( [ 1.0, NaN, 3.0, NaN ] );
+	y = new Float32Array( x.length );
+	snancusumkbn( x.length, 0.0, x, 1, y, 1 );
+
+	expected = new Float32Array([
+		1.0,
+		1.0,
+		4.0,
+		4.0
+	]);
+	t.deepEqual( y, expected, 'returns expected value' );
+
+	x = new Float32Array( [ 1.0, 1.0e38, NaN, -1.0e38 ] );
+	y = new Float32Array( x.length );
+	snancusumkbn( x.length, 0.0, x, 1, y, 1 );
+
+	expected = new Float32Array([
+		1.0,
+		1.0e38,
+		1.0e38,
+		1.0
+	]);
+	t.deepEqual( y, expected, 'returns expected value' );
+
+	x = new Float32Array( 1e3 );
+	y = new Float32Array( x.length );
+	expected = new Float32Array( x.length );
+	for ( i = 0; i < x.length; i++ ) {
+		x[ i ] = i + 1;
+		if ( i === 0 ) {
+			expected[ i ] += x[ i ];
+		} else {
+			expected[ i ] += expected[ i-1 ] + x[ i ];
+		}
+	}
+	snancusumkbn( x.length, 0.0, x, 1, y, 1 );
+	t.deepEqual( y, expected, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function returns a reference to the output array', function test( t ) {
+	var out;
+	var x;
+	var y;
+
+	x = new Float32Array( [ 1.0, 2.0, 3.0, 4.0, 5.0 ] );
+	y = new Float32Array( [ 0.0, 0.0, 0.0, 0.0, 0.0 ] );
+
+	out = snancusumkbn( x.length, 0.0, x, 1, y, 1 );
+
+	t.strictEqual( out, y, 'same reference' );
+	t.end();
+});
+
+tape( 'if provided an `N` parameter less than or equal to `0`, the function returns `y` unchanged', function test( t ) {
+	var expected;
+	var x;
+	var y;
+
+	x = new Float32Array( [ 1.0, 2.0, 3.0, 4.0, 5.0 ] );
+	y = new Float32Array( [ 6.0, 7.0, 8.0, 9.0, 10.0 ] );
+
+	expected = new Float32Array( [ 6.0, 7.0, 8.0, 9.0, 10.0 ] );
+
+	snancusumkbn( -1, 0.0, x, 1, y, 1 );
+	t.deepEqual( y, expected, 'returns `y` unchanged' );
+
+	snancusumkbn( 0, 0.0, x, 1, y, 1 );
+	t.deepEqual( y, expected, 'returns `y` unchanged' );
+
+	t.end();
+});
+
+tape( 'the function supports an `x` stride', function test( t ) {
+	var expected;
+	var x;
+	var y;
+
+	x = new Float32Array([
+		1.0, // 0
+		2.0,
+		NaN, // 1
+		4.0,
+		5.0  // 2
+	]);
+	y = new Float32Array([
+		0.0, // 0
+		0.0, // 1
+		0.0, // 2
+		0.0,
+		0.0
+	]);
+
+	snancusumkbn( 3, 0.0, x, 2, y, 1 );
+
+	expected = new Float32Array( [ 1.0, 1.0, 6.0, 0.0, 0.0 ] );
+
+	t.deepEqual( y, expected, 'returns expected value' );
+	t.end();
+});
+
+tape( 'the function supports a `y` stride', function test( t ) {
+	var expected;
+	var x;
+	var y;
+
+	x = new Float32Array([
+		1.0, // 0
+		2.0, // 1
+		NaN, // 2
+		NaN,
+		5.0
+	]);
+	y = new Float32Array([
+		0.0, // 0
+		0.0,
+		0.0, // 1
+		0.0,
+		0.0  // 2
+	]);
+
+	snancusumkbn( 3, 0.0, x, 1, y, 2 );
+
+	expected = new Float32Array( [ 1.0, 0.0, 3.0, 0.0, 3.0 ] );
+
+	t.deepEqual( y, expected, 'returns expected value' );
+	t.end();
+});
+
+tape( 'the function supports negative strides', function test( t ) {
+	var expected;
+	var x;
+	var y;
+
+	x = new Float32Array([
+		NaN, // 2
+		2.0,
+		3.0, // 1
+		4.0,
+		5.0  // 0
+	]);
+	y = new Float32Array([
+		0.0, // 2
+		0.0, // 1
+		0.0, // 0
+		0.0,
+		0.0
+	]);
+
+	snancusumkbn( 3, 0.0, x, -2, y, -1 );
+
+	expected = new Float32Array( [ 8.0, 8.0, 5.0, 0.0, 0.0 ] );
+
+	t.deepEqual( y, expected, 'returns expected value' );
+	t.end();
+});
+
+tape( 'the function supports complex access patterns', function test( t ) {
+	var expected;
+	var x;
+	var y;
+
+	x = new Float32Array([
+		1.0, // 0
+		2.0,
+		NaN, // 1
+		NaN,
+		5.0, // 2
+		6.0
+	]);
+	y = new Float32Array([
+		0.0,  // 2
+		0.0,  // 1
+		0.0,  // 0
+		0.0,
+		0.0,
+		0.0
+	]);
+
+	snancusumkbn( 3, 0.0, x, 2, y, -1 );
+
+	expected = new Float32Array( [ 6.0, 1.0, 1.0, 0.0, 0.0, 0.0 ] );
+
+	t.deepEqual( y, expected, 'returns expected value' );
+	t.end();
+});
+
+tape( 'the function supports view offsets', function test( t ) {
+	var expected;
+	var x0;
+	var y0;
+	var x1;
+	var y1;
+
+	// Initial arrays...
+	x0 = new Float32Array([
+		1.0,
+		NaN, // 2
+		NaN,
+		4.0, // 1
+		5.0,
+		6.0  // 0
+	]);
+	y0 = new Float32Array([
+		0.0,
+		0.0,
+		0.0,
+		0.0, // 0
+		0.0, // 1
+		0.0  // 2
+	]);
+
+	// Create offset views...
+	x1 = new Float32Array( x0.buffer, x0.BYTES_PER_ELEMENT*1 ); // begin at 2nd element
+	y1 = new Float32Array( y0.buffer, y0.BYTES_PER_ELEMENT*3 ); // begin at 4th element
+
+	snancusumkbn( 3, 0.0, x1, -2, y1, 1 );
+	expected = new Float32Array( [ 0.0, 0.0, 0.0, 6.0, 10.0, 10.0 ] );
+
+	t.deepEqual( y0, expected, 'returns expected value' );
+	t.end();
+});
diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/test/test.snancusumkbn.native.js b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/test/test.snancusumkbn.native.js
new file mode 100644
index 000000000000..4e02c12c3377
--- /dev/null
+++ b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/test/test.snancusumkbn.native.js
@@ -0,0 +1,313 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*    http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+'use strict';
+
+// MODULES //
+
+var resolve = require( 'path' ).resolve;
+var tape = require( 'tape' );
+var Float32Array = require( '@stdlib/array/float32' );
+var tryRequire = require( '@stdlib/utils/try-require' );
+
+
+// VARIABLES //
+
+var snancusumkbn = tryRequire( resolve( __dirname, './../lib/snancusumkbn.native.js' ) );
+var opts = {
+	'skip': ( snancusumkbn instanceof Error )
+};
+
+
+// TESTS //
+
+tape( 'main export is a function', opts, function test( t ) {
+	t.ok( true, __filename );
+	t.strictEqual( typeof snancusumkbn, 'function', 'main export is a function' );
+	t.end();
+});
+
+tape( 'the function has an arity of 6', opts, function test( t ) {
+	t.strictEqual( snancusumkbn.length, 6, 'returns expected value' );
+	t.end();
+});
+
+tape( 'the function computes the cumulative sum (ignoring NaN values)', opts, function test( t ) {
+	var expected;
+	var x;
+	var y;
+	var i;
+
+	x = new Float32Array( [ 1.0, 2.0, NaN, NaN, 5.0 ] );
+	y = new Float32Array( x.length );
+
+	snancusumkbn( x.length, 0.0, x, 1, y, 1 );
+	expected = new Float32Array([
+		1.0,
+		3.0,
+		3.0,
+		3.0,
+		8.0
+	]);
+	t.deepEqual( y, expected, 'returns expected value' );
+
+	x = new Float32Array( [ 1.0, 2.0, NaN, NaN, 5.0 ] );
+	y = new Float32Array( x.length );
+
+	snancusumkbn( x.length, 10.0, x, 1, y, 1 );
+	expected = new Float32Array([
+		11.0,
+		13.0,
+		13.0,
+		13.0,
+		18.0
+	]);
+	t.deepEqual( y, expected, 'returns expected value' );
+
+	x = new Float32Array( [ NaN, NaN ] );
+	y = new Float32Array( x.length );
+	snancusumkbn( x.length, 0.0, x, 1, y, 1 );
+	expected = new Float32Array([
+		0.0,
+		0.0
+	]);
+	t.deepEqual( y, expected, 'returns expected value' );
+
+	x = new Float32Array( [ 1.0, NaN, 3.0, NaN ] );
+	y = new Float32Array( x.length );
+	snancusumkbn( x.length, 0.0, x, 1, y, 1 );
+
+	expected = new Float32Array([
+		1.0,
+		1.0,
+		4.0,
+		4.0
+	]);
+	t.deepEqual( y, expected, 'returns expected value' );
+
+	x = new Float32Array( [ 1.0, 1.0e38, NaN, -1.0e38 ] );
+	y = new Float32Array( x.length );
+	snancusumkbn( x.length, 0.0, x, 1, y, 1 );
+
+	expected = new Float32Array([
+		1.0,
+		1.0e38,
+		1.0e38,
+		1.0
+	]);
+	t.deepEqual( y, expected, 'returns expected value' );
+
+	x = new Float32Array( 1e3 );
+	y = new Float32Array( x.length );
+	expected = new Float32Array( x.length );
+	for ( i = 0; i < x.length; i++ ) {
+		x[ i ] = i + 1;
+		if ( i === 0 ) {
+			expected[ i ] += x[ i ];
+		} else {
+			expected[ i ] += expected[ i-1 ] + x[ i ];
+		}
+	}
+	snancusumkbn( x.length, 0.0, x, 1, y, 1 );
+	t.deepEqual( y, expected, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function returns a reference to the output array', opts, function test( t ) {
+	var out;
+	var x;
+	var y;
+
+	x = new Float32Array( [ 1.0, 2.0, 3.0, 4.0, 5.0 ] );
+	y = new Float32Array( [ 0.0, 0.0, 0.0, 0.0, 0.0 ] );
+
+	out = snancusumkbn( x.length, 0.0, x, 1, y, 1 );
+
+	t.strictEqual( out, y, 'same reference' );
+	t.end();
+});
+
+tape( 'if provided an `N` parameter less than or equal to `0`, the function returns `y` unchanged', opts, function test( t ) {
+	var expected;
+	var x;
+	var y;
+
+	x = new Float32Array( [ 1.0, 2.0, 3.0, 4.0, 5.0 ] );
+	y = new Float32Array( [ 6.0, 7.0, 8.0, 9.0, 10.0 ] );
+
+	expected = new Float32Array( [ 6.0, 7.0, 8.0, 9.0, 10.0 ] );
+
+	snancusumkbn( -1, 0.0, x, 1, y, 1 );
+	t.deepEqual( y, expected, 'returns `y` unchanged' );
+
+	snancusumkbn( 0, 0.0, x, 1, y, 1 );
+	t.deepEqual( y, expected, 'returns `y` unchanged' );
+
+	t.end();
+});
+
+tape( 'the function supports an `x` stride', opts, function test( t ) {
+	var expected;
+	var x;
+	var y;
+
+	x = new Float32Array([
+		NaN, // 0
+		2.0,
+		NaN, // 1
+		4.0,
+		5.0  // 2
+	]);
+	y = new Float32Array([
+		0.0, // 0
+		0.0, // 1
+		0.0, // 2
+		0.0,
+		0.0
+	]);
+
+	snancusumkbn( 3, 0.0, x, 2, y, 1 );
+
+	expected = new Float32Array( [ 0.0, 0.0, 5.0, 0.0, 0.0 ] );
+
+	t.deepEqual( y, expected, 'returns expected value' );
+	t.end();
+});
+
+tape( 'the function supports a `y` stride', opts, function test( t ) {
+	var expected;
+	var x;
+	var y;
+
+	x = new Float32Array([
+		1.0, // 0
+		2.0, // 1
+		NaN, // 2
+		4.0,
+		5.0
+	]);
+	y = new Float32Array([
+		0.0, // 0
+		0.0,
+		0.0, // 1
+		0.0,
+		0.0  // 2
+	]);
+
+	snancusumkbn( 3, 0.0, x, 1, y, 2 );
+
+	expected = new Float32Array( [ 1.0, 0.0, 3.0, 0.0, 3.0 ] );
+
+	t.deepEqual( y, expected, 'returns expected value' );
+	t.end();
+});
+
+tape( 'the function supports negative strides', opts, function test( t ) {
+	var expected;
+	var x;
+	var y;
+
+	x = new Float32Array([
+		NaN, // 2
+		2.0,
+		3.0, // 1
+		4.0,
+		5.0  // 0
+	]);
+	y = new Float32Array([
+		0.0, // 2
+		0.0, // 1
+		0.0, // 0
+		0.0,
+		0.0
+	]);
+
+	snancusumkbn( 3, 0.0, x, -2, y, -1 );
+
+	expected = new Float32Array( [ 8.0, 8.0, 5.0, 0.0, 0.0 ] );
+
+	t.deepEqual( y, expected, 'returns expected value' );
+	t.end();
+});
+
+tape( 'the function supports complex access patterns', opts, function test( t ) {
+	var expected;
+	var x;
+	var y;
+
+	x = new Float32Array([
+		1.0, // 0
+		2.0,
+		NaN, // 1
+		NaN,
+		5.0, // 2
+		6.0
+	]);
+	y = new Float32Array([
+		0.0,  // 2
+		0.0,  // 1
+		0.0,  // 0
+		0.0,
+		0.0,
+		0.0
+	]);
+
+	snancusumkbn( 3, 0.0, x, 2, y, -1 );
+
+	expected = new Float32Array( [ 6.0, 1.0, 1.0, 0.0, 0.0, 0.0 ] );
+
+	t.deepEqual( y, expected, 'returns expected value' );
+	t.end();
+});
+
+tape( 'the function supports view offsets', opts, function test( t ) {
+	var expected;
+	var x0;
+	var y0;
+	var x1;
+	var y1;
+
+	// Initial arrays...
+	x0 = new Float32Array([
+		1.0,
+		NaN, // 2
+		3.0,
+		4.0, // 1
+		5.0,
+		6.0  // 0
+	]);
+	y0 = new Float32Array([
+		0.0,
+		0.0,
+		0.0,
+		0.0, // 0
+		0.0, // 1
+		0.0  // 2
+	]);
+
+	// Create offset views...
+	x1 = new Float32Array( x0.buffer, x0.BYTES_PER_ELEMENT*1 ); // begin at 2nd element
+	y1 = new Float32Array( y0.buffer, y0.BYTES_PER_ELEMENT*3 ); // begin at 4th element
+
+	snancusumkbn( 3, 0.0, x1, -2, y1, 1 );
+	expected = new Float32Array( [ 0.0, 0.0, 0.0, 6.0, 10.0, 10.0 ] );
+
+	t.deepEqual( y0, expected, 'returns expected value' );
+	t.end();
+});

From e884e84e07f1c59da1006c014a52efc391f0ed0e Mon Sep 17 00:00:00 2001
From: kaustubh <kaustubh.mp007@gmail.com>
Date: Sat, 27 Dec 2025 17:45:03 +0530
Subject: [PATCH 02/10] Configured Paths

---
 lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/lib/main.js | 2 +-
 .../@stdlib/blas/ext/base/snancusumkbn/lib/snancusumkbn.js      | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/lib/main.js b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/lib/main.js
index 154bf71a2416..bdf1c63c81ce 100644
--- a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/lib/main.js
+++ b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/lib/main.js
@@ -21,7 +21,7 @@
 // MODULES //
 
 var setReadOnly = require( '@stdlib/utils/define-nonenumerable-read-only-property' );
-var snancusumkbn = require( '@stdlib/blas/ext/base/snancusumkbn/lib/snancusumkbn.js' );
+var snancusumkbn = require( './snancusumkbn.js' );
 var ndarray = require( './ndarray.js' );
 
 
diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/lib/snancusumkbn.js b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/lib/snancusumkbn.js
index 03225d68cc34..56b9dc33e226 100644
--- a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/lib/snancusumkbn.js
+++ b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/lib/snancusumkbn.js
@@ -21,7 +21,7 @@
 // MODULES //
 
 var stride2offset = require( '@stdlib/strided/base/stride2offset' );
-var ndarray = require( '@stdlib/blas/ext/base/snancusumkbn/lib/ndarray.js' );
+var ndarray = require( './ndarray.js' );
 
 
 // MAIN //

From 180049f3baa63c1622a767a36d68d35f1c958745 Mon Sep 17 00:00:00 2001
From: kaustubh <kaustubh.mp007@gmail.com>
Date: Sat, 27 Dec 2025 19:52:37 +0530
Subject: [PATCH 03/10] added f32 implementation

---
 .../blas/ext/base/snancusumkbn/lib/ndarray.js       | 13 +++++++------
 1 file changed, 7 insertions(+), 6 deletions(-)

diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/lib/ndarray.js b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/lib/ndarray.js
index 4bdc924c5f8f..b2103738b738 100644
--- a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/lib/ndarray.js
+++ b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/lib/ndarray.js
@@ -20,6 +20,7 @@
 
 // MODULES //
 
+var f32 = require( '@stdlib/number/float64/base/to-float32' );
 var isnanf = require( '@stdlib/math/base/assert/is-nanf' );
 var absf = require( '@stdlib/math/base/special/absf' );
 
@@ -77,7 +78,7 @@ function snancusumkbn( N, sum, x, strideX, offsetX, y, strideY, offsetY ) {
 			if ( v !== 0.0 ) {
 				break;
 			}
-			s += v;
+			s = f32( s + v );
 			y[ iy ] = s;
 			ix += strideX;
 			iy += strideY;
@@ -89,19 +90,19 @@ function snancusumkbn( N, sum, x, strideX, offsetX, y, strideY, offsetY ) {
 	for ( ; i < N; i++ ) {
 		v = x[ ix ];
 		if ( isnanf( v ) ) {
-			y[ iy ] = s + c;
+			y[ iy ] = f32( s + c );
 			ix += strideX;
 			iy += strideY;
 			continue;
 		}
-		t = s + v;
+		t = f32( s + v );
 		if ( absf( s ) >= absf( v ) ) {
-			c += (s-t) + v;
+			c = f32( c + f32( f32( s - t ) + v ) );
 		} else {
-			c += (v-t) + s;
+			c = f32( c + f32( f32( v - t ) + s ) );
 		}
 		s = t;
-		y[ iy ] = s + c;
+		y[ iy ] = f32( s + c );
 		ix += strideX;
 		iy += strideY;
 	}

From 051ca067b5455d47819cac723422e350f806151f Mon Sep 17 00:00:00 2001
From: kaustubh <kaustubh.mp007@gmail.com>
Date: Sat, 27 Dec 2025 20:34:32 +0530
Subject: [PATCH 04/10] Use  instead of string concatenation

---
 .../@stdlib/blas/ext/base/snancusumkbn/benchmark/benchmark.js  | 3 ++-
 .../blas/ext/base/snancusumkbn/benchmark/benchmark.native.js   | 3 ++-
 .../blas/ext/base/snancusumkbn/benchmark/benchmark.ndarray.js  | 3 ++-
 .../base/snancusumkbn/benchmark/benchmark.ndarray.native.js    | 3 ++-
 4 files changed, 8 insertions(+), 4 deletions(-)

diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/benchmark/benchmark.js b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/benchmark/benchmark.js
index 778ad2137e4b..32ad54719e82 100644
--- a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/benchmark/benchmark.js
+++ b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/benchmark/benchmark.js
@@ -27,6 +27,7 @@ var filledarrayBy = require( '@stdlib/array/filled-by' );
 var zeros = require( '@stdlib/array/zeros' );
 var isnanf = require( '@stdlib/math/base/assert/is-nanf' );
 var pow = require( '@stdlib/math/base/special/pow' );
+var format = require( '@stdlib/string/format' );
 var pkg = require( './../package.json' ).name;
 var snancusumkbn = require( './../lib/snancusumkbn.js' );
 
@@ -107,7 +108,7 @@ function main() {
 	for ( i = min; i <= max; i++ ) {
 		len = pow( 10, i );
 		f = createBenchmark( len );
-		bench( pkg+':len='+len, f );
+		bench( format( '%s:len=%d', pkg, len ), f );
 	}
 }
 
diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/benchmark/benchmark.native.js b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/benchmark/benchmark.native.js
index 1f450baa6464..b08b799fe44f 100644
--- a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/benchmark/benchmark.native.js
+++ b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/benchmark/benchmark.native.js
@@ -28,6 +28,7 @@ var filledarrayBy = require( '@stdlib/array/filled-by' );
 var zeros = require( '@stdlib/array/zeros' );
 var isnanf = require( '@stdlib/math/base/assert/is-nanf' );
 var pow = require( '@stdlib/math/base/special/pow' );
+var format = require( '@stdlib/string/format' );
 var tryRequire = require( '@stdlib/utils/try-require' );
 var pkg = require( './../package.json' ).name;
 
@@ -112,7 +113,7 @@ function main() {
 	for ( i = min; i <= max; i++ ) {
 		len = pow( 10, i );
 		f = createBenchmark( len );
-		bench( pkg+'::native:len='+len, opts, f );
+		bench( format( '%s::native:len=%d', pkg, len ), opts, f );
 	}
 }
 
diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/benchmark/benchmark.ndarray.js b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/benchmark/benchmark.ndarray.js
index 657c033b19d8..8b511c2dc0a3 100644
--- a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/benchmark/benchmark.ndarray.js
+++ b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/benchmark/benchmark.ndarray.js
@@ -27,6 +27,7 @@ var filledarrayBy = require( '@stdlib/array/filled-by' );
 var zeros = require( '@stdlib/array/zeros' );
 var isnanf = require( '@stdlib/math/base/assert/is-nanf' );
 var pow = require( '@stdlib/math/base/special/pow' );
+var format = require( '@stdlib/string/format' );
 var pkg = require( './../package.json' ).name;
 var snancusumkbn = require( './../lib/ndarray.js' );
 
@@ -107,7 +108,7 @@ function main() {
 	for ( i = min; i <= max; i++ ) {
 		len = pow( 10, i );
 		f = createBenchmark( len );
-		bench( pkg+':ndarray:len='+len, f );
+		bench( format( '%s:ndarray:len=%d', pkg, len ), f );
 	}
 }
 
diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/benchmark/benchmark.ndarray.native.js b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/benchmark/benchmark.ndarray.native.js
index 9eba60dc5a6c..76a972243f0f 100644
--- a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/benchmark/benchmark.ndarray.native.js
+++ b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/benchmark/benchmark.ndarray.native.js
@@ -28,6 +28,7 @@ var filledarrayBy = require( '@stdlib/array/filled-by' );
 var zeros = require( '@stdlib/array/zeros' );
 var isnanf = require( '@stdlib/math/base/assert/is-nanf' );
 var pow = require( '@stdlib/math/base/special/pow' );
+var format = require( '@stdlib/string/format' );
 var tryRequire = require( '@stdlib/utils/try-require' );
 var pkg = require( './../package.json' ).name;
 
@@ -112,7 +113,7 @@ function main() {
 	for ( i = min; i <= max; i++ ) {
 		len = pow( 10, i );
 		f = createBenchmark( len );
-		bench( pkg+'::native:ndarray:len='+len, opts, f );
+		bench( format( '%s::native:ndarray:len=%d', pkg, len ), opts, f );
 	}
 }
 

From ddfc9f1ab12c8129b1737f286f59fb3b3f5ffeb4 Mon Sep 17 00:00:00 2001
From: kaustubh <kaustubh.mp007@gmail.com>
Date: Tue, 30 Dec 2025 11:19:42 +0530
Subject: [PATCH 05/10] fixed addon.c

---
 .../blas/ext/base/snancusumkbn/src/addon.c     | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/src/addon.c b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/src/addon.c
index 5e6f0b28c9dd..6a70d26c6595 100644
--- a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/src/addon.c
+++ b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/src/addon.c
@@ -21,7 +21,7 @@
 #include "stdlib/blas/ext/base/snancusumkbn.h"
 #include "stdlib/napi/argv.h"
 #include "stdlib/napi/argv_float.h"
-#include "stdlib/napi/argv_int32.h"
+#include "stdlib/napi/argv_int64.h"
 #include "stdlib/napi/argv_strided_float32array.h"
 #include "stdlib/napi/export.h"
 
@@ -34,10 +34,10 @@
 */
 static napi_value addon( napi_env env, napi_callback_info info ) {
 	STDLIB_NAPI_ARGV( env, info, argv, argc, 6 );
-	STDLIB_NAPI_ARGV_INT32( env, N, argv, 0 );
+	STDLIB_NAPI_ARGV_INT64( env, N, argv, 0 );
 	STDLIB_NAPI_ARGV_FLOAT( env, sum, argv, 1 );
-	STDLIB_NAPI_ARGV_INT32( env, strideX, argv, 3 );
-	STDLIB_NAPI_ARGV_INT32( env, strideY, argv, 5 );
+	STDLIB_NAPI_ARGV_INT64( env, strideX, argv, 3 );
+	STDLIB_NAPI_ARGV_INT64( env, strideY, argv, 5 );
 	STDLIB_NAPI_ARGV_STRIDED_FLOAT32ARRAY( env, X, N, strideX, argv, 2 );
 	STDLIB_NAPI_ARGV_STRIDED_FLOAT32ARRAY( env, Y, N, strideY, argv, 4 );
 	API_SUFFIX( stdlib_strided_snancusumkbn )( N, sum, X, strideX, Y, strideY );
@@ -53,12 +53,12 @@ static napi_value addon( napi_env env, napi_callback_info info ) {
 */
 static napi_value addon_method( napi_env env, napi_callback_info info ) {
 	STDLIB_NAPI_ARGV( env, info, argv, argc, 8 );
-	STDLIB_NAPI_ARGV_INT32( env, N, argv, 0 );
+	STDLIB_NAPI_ARGV_INT64( env, N, argv, 0 );
 	STDLIB_NAPI_ARGV_FLOAT( env, sum, argv, 1 );
-	STDLIB_NAPI_ARGV_INT32( env, strideX, argv, 3 );
-	STDLIB_NAPI_ARGV_INT32( env, offsetX, argv, 4 );
-	STDLIB_NAPI_ARGV_INT32( env, strideY, argv, 6 );
-	STDLIB_NAPI_ARGV_INT32( env, offsetY, argv, 7 );
+	STDLIB_NAPI_ARGV_INT64( env, strideX, argv, 3 );
+	STDLIB_NAPI_ARGV_INT64( env, offsetX, argv, 4 );
+	STDLIB_NAPI_ARGV_INT64( env, strideY, argv, 6 );
+	STDLIB_NAPI_ARGV_INT64( env, offsetY, argv, 7 );
 	STDLIB_NAPI_ARGV_STRIDED_FLOAT32ARRAY( env, X, N, strideX, argv, 2 );
 	STDLIB_NAPI_ARGV_STRIDED_FLOAT32ARRAY( env, Y, N, strideY, argv, 5 );
 	API_SUFFIX( stdlib_strided_snancusumkbn_ndarray )( N, sum, X, strideX, offsetX, Y, strideY, offsetY );

From a4d8602a0d87521c2e0b0c23035b235b14724e39 Mon Sep 17 00:00:00 2001
From: kaustubh <kaustubh.mp007@gmail.com>
Date: Sun, 11 Jan 2026 12:56:07 +0530
Subject: [PATCH 06/10] Update JSDoc comment

---
 .../blas/ext/base/snancusumkbn/benchmark/benchmark.js       | 6 ++++++
 .../ext/base/snancusumkbn/benchmark/benchmark.native.js     | 6 ++++++
 .../ext/base/snancusumkbn/benchmark/benchmark.ndarray.js    | 6 ++++++
 .../base/snancusumkbn/benchmark/benchmark.ndarray.native.js | 6 ++++++
 4 files changed, 24 insertions(+)

diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/benchmark/benchmark.js b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/benchmark/benchmark.js
index 32ad54719e82..d915be47408e 100644
--- a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/benchmark/benchmark.js
+++ b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/benchmark/benchmark.js
@@ -66,6 +66,12 @@ function createBenchmark( len ) {
 	var y = zeros( len, options.dtype );
 	return benchmark;
 
+	/**
+	* Benchmark function.
+	*
+	* @private
+	* @param {Benchmark} b - benchmark instance
+	*/
 	function benchmark( b ) {
 		var v;
 		var i;
diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/benchmark/benchmark.native.js b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/benchmark/benchmark.native.js
index b08b799fe44f..1e637bec6db9 100644
--- a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/benchmark/benchmark.native.js
+++ b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/benchmark/benchmark.native.js
@@ -71,6 +71,12 @@ function createBenchmark( len ) {
 	var y = zeros( len, options.dtype );
 	return benchmark;
 
+	/**
+	* Benchmark function.
+	*
+	* @private
+	* @param {Benchmark} b - benchmark instance
+	*/
 	function benchmark( b ) {
 		var v;
 		var i;
diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/benchmark/benchmark.ndarray.js b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/benchmark/benchmark.ndarray.js
index 8b511c2dc0a3..3fa53bb8bd19 100644
--- a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/benchmark/benchmark.ndarray.js
+++ b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/benchmark/benchmark.ndarray.js
@@ -66,6 +66,12 @@ function createBenchmark( len ) {
 	var y = zeros( len, options.dtype );
 	return benchmark;
 
+	/**
+	* Benchmark function.
+	*
+	* @private
+	* @param {Benchmark} b - benchmark instance
+	*/
 	function benchmark( b ) {
 		var v;
 		var i;
diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/benchmark/benchmark.ndarray.native.js b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/benchmark/benchmark.ndarray.native.js
index 76a972243f0f..f0f8a7a81f45 100644
--- a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/benchmark/benchmark.ndarray.native.js
+++ b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/benchmark/benchmark.ndarray.native.js
@@ -71,6 +71,12 @@ function createBenchmark( len ) {
 	var y = zeros( len, options.dtype );
 	return benchmark;
 
+	/**
+	* Benchmark function.
+	*
+	* @private
+	* @param {Benchmark} b - benchmark instance
+	*/
 	function benchmark( b ) {
 		var v;
 		var i;

From 632d08f5c3f20082267ff52447a705a629457901 Mon Sep 17 00:00:00 2001
From: kaustubh <kaustubh.mp007@gmail.com>
Date: Sun, 11 Jan 2026 13:06:12 +0530
Subject: [PATCH 07/10] update copyright years

---
 .../@stdlib/blas/ext/base/snancusumkbn/benchmark/benchmark.js   | 2 +-
 .../blas/ext/base/snancusumkbn/benchmark/benchmark.native.js    | 2 +-
 .../blas/ext/base/snancusumkbn/benchmark/benchmark.ndarray.js   | 2 +-
 .../ext/base/snancusumkbn/benchmark/benchmark.ndarray.native.js | 2 +-
 4 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/benchmark/benchmark.js b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/benchmark/benchmark.js
index d915be47408e..5a350e7a6ca1 100644
--- a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/benchmark/benchmark.js
+++ b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/benchmark/benchmark.js
@@ -1,7 +1,7 @@
 /**
 * @license Apache-2.0
 *
-* Copyright (c) 2025 The Stdlib Authors.
+* Copyright (c) 2026 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.
diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/benchmark/benchmark.native.js b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/benchmark/benchmark.native.js
index 1e637bec6db9..7beb37265df6 100644
--- a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/benchmark/benchmark.native.js
+++ b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/benchmark/benchmark.native.js
@@ -1,7 +1,7 @@
 /**
 * @license Apache-2.0
 *
-* Copyright (c) 2025 The Stdlib Authors.
+* Copyright (c) 2026 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.
diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/benchmark/benchmark.ndarray.js b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/benchmark/benchmark.ndarray.js
index 3fa53bb8bd19..c5c97fb2f129 100644
--- a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/benchmark/benchmark.ndarray.js
+++ b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/benchmark/benchmark.ndarray.js
@@ -1,7 +1,7 @@
 /**
 * @license Apache-2.0
 *
-* Copyright (c) 2025 The Stdlib Authors.
+* Copyright (c) 2026 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.
diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/benchmark/benchmark.ndarray.native.js b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/benchmark/benchmark.ndarray.native.js
index f0f8a7a81f45..cd84f3800df1 100644
--- a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/benchmark/benchmark.ndarray.native.js
+++ b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/benchmark/benchmark.ndarray.native.js
@@ -1,7 +1,7 @@
 /**
 * @license Apache-2.0
 *
-* Copyright (c) 2025 The Stdlib Authors.
+* Copyright (c) 2026 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.

From ba9e1770e586d88a15e88f54085604d2cc228283 Mon Sep 17 00:00:00 2001
From: stdlib-bot <82920195+stdlib-bot@users.noreply.github.com>
Date: Sun, 11 Jan 2026 10:08:41 +0000
Subject: [PATCH 08/10] chore: update copyright years

---
 lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/README.md   | 2 +-
 .../@stdlib/blas/ext/base/snancusumkbn/benchmark/c/Makefile     | 2 +-
 .../blas/ext/base/snancusumkbn/benchmark/c/benchmark.length.c   | 2 +-
 lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/binding.gyp | 2 +-
 .../@stdlib/blas/ext/base/snancusumkbn/docs/types/index.d.ts    | 2 +-
 .../@stdlib/blas/ext/base/snancusumkbn/docs/types/test.ts       | 2 +-
 .../@stdlib/blas/ext/base/snancusumkbn/examples/c/Makefile      | 2 +-
 .../@stdlib/blas/ext/base/snancusumkbn/examples/c/example.c     | 2 +-
 .../@stdlib/blas/ext/base/snancusumkbn/examples/index.js        | 2 +-
 .../@stdlib/blas/ext/base/snancusumkbn/include.gypi             | 2 +-
 .../snancusumkbn/include/stdlib/blas/ext/base/snancusumkbn.h    | 2 +-
 .../@stdlib/blas/ext/base/snancusumkbn/lib/index.js             | 2 +-
 lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/lib/main.js | 2 +-
 .../@stdlib/blas/ext/base/snancusumkbn/lib/native.js            | 2 +-
 .../@stdlib/blas/ext/base/snancusumkbn/lib/ndarray.js           | 2 +-
 .../@stdlib/blas/ext/base/snancusumkbn/lib/ndarray.native.js    | 2 +-
 .../@stdlib/blas/ext/base/snancusumkbn/lib/snancusumkbn.js      | 2 +-
 .../blas/ext/base/snancusumkbn/lib/snancusumkbn.native.js       | 2 +-
 .../@stdlib/blas/ext/base/snancusumkbn/src/Makefile             | 2 +-
 lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/src/addon.c | 2 +-
 lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/src/main.c  | 2 +-
 .../@stdlib/blas/ext/base/snancusumkbn/test/test.js             | 2 +-
 .../@stdlib/blas/ext/base/snancusumkbn/test/test.ndarray.js     | 2 +-
 .../blas/ext/base/snancusumkbn/test/test.ndarray.native.js      | 2 +-
 .../blas/ext/base/snancusumkbn/test/test.snancusumkbn.js        | 2 +-
 .../blas/ext/base/snancusumkbn/test/test.snancusumkbn.native.js | 2 +-
 26 files changed, 26 insertions(+), 26 deletions(-)

diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/README.md b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/README.md
index 27b1db49f968..a602812efd47 100644
--- a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/README.md
+++ b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/README.md
@@ -2,7 +2,7 @@
 
 @license Apache-2.0
 
-Copyright (c) 2025 The Stdlib Authors.
+Copyright (c) 2026 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.
diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/benchmark/c/Makefile b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/benchmark/c/Makefile
index cce2c865d7ad..0756dc7da20a 100644
--- a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/benchmark/c/Makefile
+++ b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/benchmark/c/Makefile
@@ -1,7 +1,7 @@
 #/
 # @license Apache-2.0
 #
-# Copyright (c) 2025 The Stdlib Authors.
+# Copyright (c) 2026 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.
diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/benchmark/c/benchmark.length.c b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/benchmark/c/benchmark.length.c
index dfe6030755b4..d03a45f8bafa 100644
--- a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/benchmark/c/benchmark.length.c
+++ b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/benchmark/c/benchmark.length.c
@@ -1,7 +1,7 @@
 /**
 * @license Apache-2.0
 *
-* Copyright (c) 2025 The Stdlib Authors.
+* Copyright (c) 2026 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.
diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/binding.gyp b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/binding.gyp
index 68a1ca11d160..0d6508a12e99 100644
--- a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/binding.gyp
+++ b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/binding.gyp
@@ -1,6 +1,6 @@
 # @license Apache-2.0
 #
-# Copyright (c) 2025 The Stdlib Authors.
+# Copyright (c) 2026 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.
diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/docs/types/index.d.ts b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/docs/types/index.d.ts
index 981167bcdbb2..1ee1e99e5083 100644
--- a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/docs/types/index.d.ts
+++ b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/docs/types/index.d.ts
@@ -1,7 +1,7 @@
 /*
 * @license Apache-2.0
 *
-* Copyright (c) 2025 The Stdlib Authors.
+* Copyright (c) 2026 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.
diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/docs/types/test.ts b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/docs/types/test.ts
index 0096e1b5b350..017931a03012 100644
--- a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/docs/types/test.ts
+++ b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/docs/types/test.ts
@@ -1,7 +1,7 @@
 /*
 * @license Apache-2.0
 *
-* Copyright (c) 2025 The Stdlib Authors.
+* Copyright (c) 2026 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.
diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/examples/c/Makefile b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/examples/c/Makefile
index 25ced822f96a..c8f8e9a1517b 100644
--- a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/examples/c/Makefile
+++ b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/examples/c/Makefile
@@ -1,7 +1,7 @@
 #/
 # @license Apache-2.0
 #
-# Copyright (c) 2025 The Stdlib Authors.
+# Copyright (c) 2026 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.
diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/examples/c/example.c b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/examples/c/example.c
index 602bdb365b3b..510c75380c07 100644
--- a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/examples/c/example.c
+++ b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/examples/c/example.c
@@ -1,7 +1,7 @@
 /**
 * @license Apache-2.0
 *
-* Copyright (c) 2025 The Stdlib Authors.
+* Copyright (c) 2026 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.
diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/examples/index.js b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/examples/index.js
index b19d8cbbef62..f0638b6e8a92 100644
--- a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/examples/index.js
+++ b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/examples/index.js
@@ -1,7 +1,7 @@
 /**
 * @license Apache-2.0
 *
-* Copyright (c) 2025 The Stdlib Authors.
+* Copyright (c) 2026 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.
diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/include.gypi b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/include.gypi
index ecfaf82a3279..bee8d41a2caf 100644
--- a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/include.gypi
+++ b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/include.gypi
@@ -1,6 +1,6 @@
 # @license Apache-2.0
 #
-# Copyright (c) 2025 The Stdlib Authors.
+# Copyright (c) 2026 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.
diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/include/stdlib/blas/ext/base/snancusumkbn.h b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/include/stdlib/blas/ext/base/snancusumkbn.h
index fe2b89c86a2a..2145f917e814 100644
--- a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/include/stdlib/blas/ext/base/snancusumkbn.h
+++ b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/include/stdlib/blas/ext/base/snancusumkbn.h
@@ -1,7 +1,7 @@
 /**
 * @license Apache-2.0
 *
-* Copyright (c) 2025 The Stdlib Authors.
+* Copyright (c) 2026 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.
diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/lib/index.js b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/lib/index.js
index 066ff94623ae..c553a5263870 100644
--- a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/lib/index.js
+++ b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/lib/index.js
@@ -1,7 +1,7 @@
 /**
 * @license Apache-2.0
 *
-* Copyright (c) 2025 The Stdlib Authors.
+* Copyright (c) 2026 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.
diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/lib/main.js b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/lib/main.js
index bdf1c63c81ce..040b964b7524 100644
--- a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/lib/main.js
+++ b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/lib/main.js
@@ -1,7 +1,7 @@
 /**
 * @license Apache-2.0
 *
-* Copyright (c) 2025 The Stdlib Authors.
+* Copyright (c) 2026 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.
diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/lib/native.js b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/lib/native.js
index 81faffe49cb7..7859fd4d5a2c 100644
--- a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/lib/native.js
+++ b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/lib/native.js
@@ -1,7 +1,7 @@
 /**
 * @license Apache-2.0
 *
-* Copyright (c) 2025 The Stdlib Authors.
+* Copyright (c) 2026 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.
diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/lib/ndarray.js b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/lib/ndarray.js
index b2103738b738..2b215ae2ed67 100644
--- a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/lib/ndarray.js
+++ b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/lib/ndarray.js
@@ -1,7 +1,7 @@
 /**
 * @license Apache-2.0
 *
-* Copyright (c) 2025 The Stdlib Authors.
+* Copyright (c) 2026 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.
diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/lib/ndarray.native.js b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/lib/ndarray.native.js
index 0d8bb4549eb3..77ac76195023 100644
--- a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/lib/ndarray.native.js
+++ b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/lib/ndarray.native.js
@@ -1,7 +1,7 @@
 /**
 * @license Apache-2.0
 *
-* Copyright (c) 2025 The Stdlib Authors.
+* Copyright (c) 2026 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.
diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/lib/snancusumkbn.js b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/lib/snancusumkbn.js
index 56b9dc33e226..715410b396ef 100644
--- a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/lib/snancusumkbn.js
+++ b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/lib/snancusumkbn.js
@@ -1,7 +1,7 @@
 /**
 * @license Apache-2.0
 *
-* Copyright (c) 2025 The Stdlib Authors.
+* Copyright (c) 2026 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.
diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/lib/snancusumkbn.native.js b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/lib/snancusumkbn.native.js
index c18f35555c3b..6a56bd61e4de 100644
--- a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/lib/snancusumkbn.native.js
+++ b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/lib/snancusumkbn.native.js
@@ -1,7 +1,7 @@
 /**
 * @license Apache-2.0
 *
-* Copyright (c) 2025 The Stdlib Authors.
+* Copyright (c) 2026 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.
diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/src/Makefile b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/src/Makefile
index 7733b6180cb4..2caf905cedbe 100644
--- a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/src/Makefile
+++ b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/src/Makefile
@@ -1,7 +1,7 @@
 #/
 # @license Apache-2.0
 #
-# Copyright (c) 2025 The Stdlib Authors.
+# Copyright (c) 2026 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.
diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/src/addon.c b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/src/addon.c
index 6a70d26c6595..060f0b26d57d 100644
--- a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/src/addon.c
+++ b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/src/addon.c
@@ -1,7 +1,7 @@
 /**
 * @license Apache-2.0
 *
-* Copyright (c) 2025 The Stdlib Authors.
+* Copyright (c) 2026 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.
diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/src/main.c b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/src/main.c
index a4e9ab0ec9f2..3222e8c23107 100644
--- a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/src/main.c
+++ b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/src/main.c
@@ -1,7 +1,7 @@
 /**
 * @license Apache-2.0
 *
-* Copyright (c) 2025 The Stdlib Authors.
+* Copyright (c) 2026 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.
diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/test/test.js b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/test/test.js
index bbc4fec76d8b..262b400cf61a 100644
--- a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/test/test.js
+++ b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/test/test.js
@@ -1,7 +1,7 @@
 /**
 * @license Apache-2.0
 *
-* Copyright (c) 2025 The Stdlib Authors.
+* Copyright (c) 2026 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.
diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/test/test.ndarray.js b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/test/test.ndarray.js
index d610d24deb92..05d5c3abd7d4 100644
--- a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/test/test.ndarray.js
+++ b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/test/test.ndarray.js
@@ -1,7 +1,7 @@
 /**
 * @license Apache-2.0
 *
-* Copyright (c) 2025 The Stdlib Authors.
+* Copyright (c) 2026 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.
diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/test/test.ndarray.native.js b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/test/test.ndarray.native.js
index e5da3a6a0913..47281c71f8c8 100644
--- a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/test/test.ndarray.native.js
+++ b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/test/test.ndarray.native.js
@@ -1,7 +1,7 @@
 /**
 * @license Apache-2.0
 *
-* Copyright (c) 2025 The Stdlib Authors.
+* Copyright (c) 2026 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.
diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/test/test.snancusumkbn.js b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/test/test.snancusumkbn.js
index 16e473947228..33028555eea7 100644
--- a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/test/test.snancusumkbn.js
+++ b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/test/test.snancusumkbn.js
@@ -1,7 +1,7 @@
 /**
 * @license Apache-2.0
 *
-* Copyright (c) 2025 The Stdlib Authors.
+* Copyright (c) 2026 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.
diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/test/test.snancusumkbn.native.js b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/test/test.snancusumkbn.native.js
index 4e02c12c3377..4dc306765b3b 100644
--- a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/test/test.snancusumkbn.native.js
+++ b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/test/test.snancusumkbn.native.js
@@ -1,7 +1,7 @@
 /**
 * @license Apache-2.0
 *
-* Copyright (c) 2025 The Stdlib Authors.
+* Copyright (c) 2026 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.

From 99d8139182a84889874d03b45dd073b9903d51cf Mon Sep 17 00:00:00 2001
From: kaustubh <kaustubh.mp007@gmail.com>
Date: Sun, 25 Jan 2026 13:17:53 +0530
Subject: [PATCH 09/10] Fixed Spacing

---
 .../include/stdlib/blas/ext/base/snancusumkbn.h             | 4 ++--
 .../@stdlib/blas/ext/base/snancusumkbn/src/addon.c          | 6 +++---
 .../@stdlib/blas/ext/base/snancusumkbn/src/main.c           | 6 +++---
 3 files changed, 8 insertions(+), 8 deletions(-)

diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/include/stdlib/blas/ext/base/snancusumkbn.h b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/include/stdlib/blas/ext/base/snancusumkbn.h
index 2145f917e814..3f9a64609114 100644
--- a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/include/stdlib/blas/ext/base/snancusumkbn.h
+++ b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/include/stdlib/blas/ext/base/snancusumkbn.h
@@ -31,12 +31,12 @@ extern "C" {
 /**
 * Computes the cumulative sum of single-precision floating-point strided array elements ignoring `NaN` values and using an improved Kahan–Babuška algorithm.
 */
-void API_SUFFIX( stdlib_strided_snancusumkbn )( const CBLAS_INT N, const float sum, const float *X, const CBLAS_INT strideX, float *Y, const CBLAS_INT strideY );
+void API_SUFFIX(stdlib_strided_snancusumkbn)( const CBLAS_INT N, const float sum, const float *X, const CBLAS_INT strideX, float *Y, const CBLAS_INT strideY );
 
 /**
 * Computes the cumulative sum of single-precision floating-point strided array elements ignoring `NaN` values and using an improved Kahan–Babuška algorithm and alternative indexing semantics.
 */
-void API_SUFFIX( stdlib_strided_snancusumkbn_ndarray )( const CBLAS_INT N, const float sum, const float *X, const CBLAS_INT strideX, const CBLAS_INT offsetX, float *Y, const CBLAS_INT strideY, const CBLAS_INT offsetY );
+void API_SUFFIX(stdlib_strided_snancusumkbn_ndarray)( const CBLAS_INT N, const float sum, const float *X, const CBLAS_INT strideX, const CBLAS_INT offsetX, float *Y, const CBLAS_INT strideY, const CBLAS_INT offsetY );
 
 #ifdef __cplusplus
 }
diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/src/addon.c b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/src/addon.c
index 060f0b26d57d..f59c7b806548 100644
--- a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/src/addon.c
+++ b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/src/addon.c
@@ -16,14 +16,14 @@
 * limitations under the License.
 */
 
-#include <node_api.h>
-#include "stdlib/blas/base/shared.h"
 #include "stdlib/blas/ext/base/snancusumkbn.h"
+#include "stdlib/blas/base/shared.h"
+#include "stdlib/napi/export.h"
 #include "stdlib/napi/argv.h"
 #include "stdlib/napi/argv_float.h"
 #include "stdlib/napi/argv_int64.h"
 #include "stdlib/napi/argv_strided_float32array.h"
-#include "stdlib/napi/export.h"
+#include <node_api.h>
 
 /**
 * Receives JavaScript callback invocation data.
diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/src/main.c b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/src/main.c
index 3222e8c23107..07592cc89db2 100644
--- a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/src/main.c
+++ b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/src/main.c
@@ -40,10 +40,10 @@
 * @param Y        output array
 * @param strideY  stride length for Y
 */
-void API_SUFFIX( stdlib_strided_snancusumkbn )( const CBLAS_INT N, const float sum, const float *X, const CBLAS_INT strideX, float *Y, const CBLAS_INT strideY ) {
+void API_SUFFIX(stdlib_strided_snancusumkbn)( const CBLAS_INT N, const float sum, const float *X, const CBLAS_INT strideX, float *Y, const CBLAS_INT strideY ) {
 	const CBLAS_INT ox = stdlib_strided_stride2offset( N, strideX );
 	const CBLAS_INT oy = stdlib_strided_stride2offset( N, strideY );
-	API_SUFFIX( stdlib_strided_snancusumkbn_ndarray )( N, sum, X, strideX, ox, Y, strideY, oy );
+	API_SUFFIX(stdlib_strided_snancusumkbn_ndarray)( N, sum, X, strideX, ox, Y, strideY, oy );
 }
 
 /**
@@ -66,7 +66,7 @@ void API_SUFFIX( stdlib_strided_snancusumkbn )( const CBLAS_INT N, const float s
 * @param strideY  stride length for Y
 * @param offsetY  starting index for Y
 */
-void API_SUFFIX( stdlib_strided_snancusumkbn_ndarray )( const CBLAS_INT N, const float sum, const float *X, const CBLAS_INT strideX, const CBLAS_INT offsetX, float *Y, const CBLAS_INT strideY, const CBLAS_INT offsetY ) {
+void API_SUFFIX(stdlib_strided_snancusumkbn_ndarray)( const CBLAS_INT N, const float sum, const float *X, const CBLAS_INT strideX, const CBLAS_INT offsetX, float *Y, const CBLAS_INT strideY, const CBLAS_INT offsetY ) {
 	CBLAS_INT ix;
 	CBLAS_INT iy;
 	CBLAS_INT i;

From 75650e776bf6f0f5a95610f5c735e30bbb79a2b0 Mon Sep 17 00:00:00 2001
From: kaustubh <kaustubh.mp007@gmail.com>
Date: Sun, 25 Jan 2026 13:18:58 +0530
Subject: [PATCH 10/10] Fixed Spacing

---
 .../@stdlib/blas/ext/base/snancusumkbn/src/addon.c            | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/src/addon.c b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/src/addon.c
index f59c7b806548..c4a816a68d6d 100644
--- a/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/src/addon.c
+++ b/lib/node_modules/@stdlib/blas/ext/base/snancusumkbn/src/addon.c
@@ -61,8 +61,8 @@ static napi_value addon_method( napi_env env, napi_callback_info info ) {
 	STDLIB_NAPI_ARGV_INT64( env, offsetY, argv, 7 );
 	STDLIB_NAPI_ARGV_STRIDED_FLOAT32ARRAY( env, X, N, strideX, argv, 2 );
 	STDLIB_NAPI_ARGV_STRIDED_FLOAT32ARRAY( env, Y, N, strideY, argv, 5 );
-	API_SUFFIX( stdlib_strided_snancusumkbn_ndarray )( N, sum, X, strideX, offsetX, Y, strideY, offsetY );
+	API_SUFFIX(stdlib_strided_snancusumkbn_ndarray)( N, sum, X, strideX, offsetX, Y, strideY, offsetY );
 	return NULL;
 }
 
-STDLIB_NAPI_MODULE_EXPORT_FCN_WITH_METHOD( addon, "ndarray", addon_method )
+STDLIB_NAPI_MODULE_EXPORT_FCN_WITH_METHOD( addon, "ndarray", addon_method );