From 2232c761785c99148d10689e1ab53b604cc5d521 Mon Sep 17 00:00:00 2001
From: JoyBoy <144602492+0PrashantYadav0@users.noreply.github.com>
Date: Wed, 2 Jul 2025 16:15:31 +0530
Subject: [PATCH 1/2] feat: wasm implementation for stats/strided/dsmeanwd
---
type: pre_commit_static_analysis_report
description: Results of running static analysis checks when committing changes.
report:
- task: lint_filenames
status: passed
- task: lint_editorconfig
status: passed
- task: lint_markdown
status: passed
- task: lint_package_json
status: passed
- task: lint_repl_help
status: passed
- task: lint_javascript_src
status: passed
- task: lint_javascript_cli
status: na
- task: lint_javascript_examples
status: passed
- task: lint_javascript_tests
status: passed
- task: lint_javascript_benchmarks
status: passed
- task: lint_python
status: na
- task: lint_r
status: na
- task: lint_c_src
status: na
- task: lint_c_examples
status: na
- task: lint_c_benchmarks
status: na
- task: lint_c_tests_fixtures
status: na
- task: lint_shell
status: na
- task: lint_typescript_declarations
status: passed
- task: lint_typescript_tests
status: passed
- task: lint_license_headers
status: passed
---
---
.../stats/strided/dsmeanwd/manifest.json | 2 +-
.../stats/strided/wasm/dsmeanwd/README.md | 296 +++++++++++
.../wasm/dsmeanwd/benchmark/benchmark.js | 106 ++++
.../dsmeanwd/benchmark/benchmark.module.js | 66 +++
.../benchmark/benchmark.module.main.js | 130 +++++
.../benchmark/benchmark.module.ndarray.js | 130 +++++
.../dsmeanwd/benchmark/benchmark.ndarray.js | 106 ++++
.../stats/strided/wasm/dsmeanwd/docs/repl.txt | 502 ++++++++++++++++++
.../wasm/dsmeanwd/docs/types/index.d.ts | 316 +++++++++++
.../strided/wasm/dsmeanwd/docs/types/test.ts | 347 ++++++++++++
.../strided/wasm/dsmeanwd/examples/index.js | 43 ++
.../dsmeanwd/examples/little_endian_arrays.js | 65 +++
.../strided/wasm/dsmeanwd/examples/module.js | 63 +++
.../wasm/dsmeanwd/lib/binary.browser.js | 33 ++
.../stats/strided/wasm/dsmeanwd/lib/binary.js | 34 ++
.../stats/strided/wasm/dsmeanwd/lib/index.js | 100 ++++
.../stats/strided/wasm/dsmeanwd/lib/main.js | 60 +++
.../stats/strided/wasm/dsmeanwd/lib/module.js | 198 +++++++
.../strided/wasm/dsmeanwd/lib/routine.js | 166 ++++++
.../stats/strided/wasm/dsmeanwd/manifest.json | 36 ++
.../stats/strided/wasm/dsmeanwd/package.json | 82 +++
.../strided/wasm/dsmeanwd/scripts/build.js | 66 +++
.../wasm/dsmeanwd/scripts/template.txt | 33 ++
.../stats/strided/wasm/dsmeanwd/src/Makefile | 265 +++++++++
.../strided/wasm/dsmeanwd/src/exports.json | 4 +
.../stats/strided/wasm/dsmeanwd/src/main.wasm | Bin 0 -> 293 bytes
.../stats/strided/wasm/dsmeanwd/src/main.wat | 100 ++++
.../stats/strided/wasm/dsmeanwd/test/test.js | 53 ++
.../strided/wasm/dsmeanwd/test/test.main.js | 165 ++++++
.../strided/wasm/dsmeanwd/test/test.module.js | 154 ++++++
.../wasm/dsmeanwd/test/test.module.main.js | 234 ++++++++
.../wasm/dsmeanwd/test/test.module.ndarray.js | 234 ++++++++
.../wasm/dsmeanwd/test/test.ndarray.js | 161 ++++++
.../wasm/dsmeanwd/test/test.routine.js | 71 +++
34 files changed, 4420 insertions(+), 1 deletion(-)
create mode 100644 lib/node_modules/@stdlib/stats/strided/wasm/dsmeanwd/README.md
create mode 100644 lib/node_modules/@stdlib/stats/strided/wasm/dsmeanwd/benchmark/benchmark.js
create mode 100644 lib/node_modules/@stdlib/stats/strided/wasm/dsmeanwd/benchmark/benchmark.module.js
create mode 100644 lib/node_modules/@stdlib/stats/strided/wasm/dsmeanwd/benchmark/benchmark.module.main.js
create mode 100644 lib/node_modules/@stdlib/stats/strided/wasm/dsmeanwd/benchmark/benchmark.module.ndarray.js
create mode 100644 lib/node_modules/@stdlib/stats/strided/wasm/dsmeanwd/benchmark/benchmark.ndarray.js
create mode 100644 lib/node_modules/@stdlib/stats/strided/wasm/dsmeanwd/docs/repl.txt
create mode 100644 lib/node_modules/@stdlib/stats/strided/wasm/dsmeanwd/docs/types/index.d.ts
create mode 100644 lib/node_modules/@stdlib/stats/strided/wasm/dsmeanwd/docs/types/test.ts
create mode 100644 lib/node_modules/@stdlib/stats/strided/wasm/dsmeanwd/examples/index.js
create mode 100644 lib/node_modules/@stdlib/stats/strided/wasm/dsmeanwd/examples/little_endian_arrays.js
create mode 100644 lib/node_modules/@stdlib/stats/strided/wasm/dsmeanwd/examples/module.js
create mode 100644 lib/node_modules/@stdlib/stats/strided/wasm/dsmeanwd/lib/binary.browser.js
create mode 100644 lib/node_modules/@stdlib/stats/strided/wasm/dsmeanwd/lib/binary.js
create mode 100644 lib/node_modules/@stdlib/stats/strided/wasm/dsmeanwd/lib/index.js
create mode 100644 lib/node_modules/@stdlib/stats/strided/wasm/dsmeanwd/lib/main.js
create mode 100644 lib/node_modules/@stdlib/stats/strided/wasm/dsmeanwd/lib/module.js
create mode 100644 lib/node_modules/@stdlib/stats/strided/wasm/dsmeanwd/lib/routine.js
create mode 100644 lib/node_modules/@stdlib/stats/strided/wasm/dsmeanwd/manifest.json
create mode 100644 lib/node_modules/@stdlib/stats/strided/wasm/dsmeanwd/package.json
create mode 100644 lib/node_modules/@stdlib/stats/strided/wasm/dsmeanwd/scripts/build.js
create mode 100644 lib/node_modules/@stdlib/stats/strided/wasm/dsmeanwd/scripts/template.txt
create mode 100644 lib/node_modules/@stdlib/stats/strided/wasm/dsmeanwd/src/Makefile
create mode 100644 lib/node_modules/@stdlib/stats/strided/wasm/dsmeanwd/src/exports.json
create mode 100755 lib/node_modules/@stdlib/stats/strided/wasm/dsmeanwd/src/main.wasm
create mode 100644 lib/node_modules/@stdlib/stats/strided/wasm/dsmeanwd/src/main.wat
create mode 100644 lib/node_modules/@stdlib/stats/strided/wasm/dsmeanwd/test/test.js
create mode 100644 lib/node_modules/@stdlib/stats/strided/wasm/dsmeanwd/test/test.main.js
create mode 100644 lib/node_modules/@stdlib/stats/strided/wasm/dsmeanwd/test/test.module.js
create mode 100644 lib/node_modules/@stdlib/stats/strided/wasm/dsmeanwd/test/test.module.main.js
create mode 100644 lib/node_modules/@stdlib/stats/strided/wasm/dsmeanwd/test/test.module.ndarray.js
create mode 100644 lib/node_modules/@stdlib/stats/strided/wasm/dsmeanwd/test/test.ndarray.js
create mode 100644 lib/node_modules/@stdlib/stats/strided/wasm/dsmeanwd/test/test.routine.js
diff --git a/lib/node_modules/@stdlib/stats/strided/dsmeanwd/manifest.json b/lib/node_modules/@stdlib/stats/strided/dsmeanwd/manifest.json
index 7a0fdb1d890b..c4885c62aedf 100644
--- a/lib/node_modules/@stdlib/stats/strided/dsmeanwd/manifest.json
+++ b/lib/node_modules/@stdlib/stats/strided/dsmeanwd/manifest.json
@@ -80,7 +80,7 @@
]
},
{
- "task": "",
+ "task": "build",
"wasm": true,
"src": [
"./src/main.c"
diff --git a/lib/node_modules/@stdlib/stats/strided/wasm/dsmeanwd/README.md b/lib/node_modules/@stdlib/stats/strided/wasm/dsmeanwd/README.md
new file mode 100644
index 000000000000..dc6f9155e092
--- /dev/null
+++ b/lib/node_modules/@stdlib/stats/strided/wasm/dsmeanwd/README.md
@@ -0,0 +1,296 @@
+
+
+# dsmeanwd
+
+> Calculate the [arithmetic mean][arithmetic-mean] of a single-precision floating-point strided array using Welford's algorithm with extended accumulation and returning an extended precision result.
+
+
+
+## Usage
+
+```javascript
+var dsmeanwd = require( '@stdlib/stats/strided/wasm/dsmeanwd' );
+```
+
+#### dsmeanwd.main( N, x, strideX )
+
+Computes the [arithmetic mean][arithmetic-mean] of a single-precision floating-point strided array `x` using Welford's algorithm with extended accumulation and returning an extended precision result.
+
+```javascript
+var Float32Array = require( '@stdlib/array/float32' );
+
+var x = new Float32Array( [ 1.0, -2.0, 2.0 ] );
+
+var y = dsmeanwd.main( x.length, x, 1 );
+// returns ~0.3333
+```
+
+The function has the following parameters:
+
+- **N**: number of indexed elements.
+- **x**: input [`Float32Array`][@stdlib/array/float32].
+- **strideX**: stride length for `x`.
+
+The `N` and stride parameters determine which elements in the strided array are accessed at runtime. For example, to access every other element in `x`,
+
+```javascript
+var Float32Array = require( '@stdlib/array/float32' );
+
+var x = new Float32Array( [ 1.0, 2.0, 2.0, -7.0, -2.0, 3.0, 4.0, 2.0 ] );
+
+var y = dsmeanwd.main( 4, x, 2 );
+// returns 1.25
+```
+
+Note that indexing is relative to the first index. To introduce an offset, use [`typed array`][mdn-typed-array] views.
+
+
+
+```javascript
+var Float32Array = require( '@stdlib/array/float32' );
+
+var x0 = new Float32Array( [ 2.0, 1.0, 2.0, -2.0, -2.0, 2.0, 3.0, 4.0 ] );
+var x1 = new Float32Array( x0.buffer, x0.BYTES_PER_ELEMENT*1 ); // start at 2nd element
+
+var y = dsmeanwd.main( 4, x1, 2 );
+// returns 1.25
+```
+
+#### dsmeanwd.ndarray( N, x, strideX, offsetX )
+
+Computes the [arithmetic mean][arithmetic-mean] of a single-precision floating-point strided array using Welford's algorithm with extended accumulation and alternative indexing semantics and returning an extended precision result.
+
+```javascript
+var Float32Array = require( '@stdlib/array/float32' );
+
+var x = new Float32Array( [ 1.0, -2.0, 2.0 ] );
+
+var y = dsmeanwd.ndarray( x.length, x, 1, 0 );
+// returns ~0.3333
+```
+
+The function has the following additional parameters:
+
+- **offsetX**: starting index for `x`.
+
+While [`typed array`][mdn-typed-array] views mandate a view offset based on the underlying buffer, the offset parameter supports indexing semantics based on a starting index. For example, to access every other element starting from the second element:
+
+```javascript
+var Float32Array = require( '@stdlib/array/float32' );
+
+var x = new Float32Array( [ 2.0, 1.0, 2.0, -2.0, -2.0, 2.0, 3.0, 4.0 ] );
+
+var y = dsmeanwd.ndarray( 4, x, 2, 1 );
+// returns 1.25
+```
+
+* * *
+
+### Module
+
+#### dsmeanwd.Module( memory )
+
+Returns a new WebAssembly [module wrapper][@stdlib/wasm/module-wrapper] instance which uses the provided WebAssembly [memory][@stdlib/wasm/memory] instance as its underlying memory.
+
+
+
+```javascript
+var Memory = require( '@stdlib/wasm/memory' );
+
+// Create a new memory instance with an initial size of 10 pages (640KiB) and a maximum size of 100 pages (6.4MiB):
+var mem = new Memory({
+ 'initial': 10,
+ 'maximum': 100
+});
+
+// Create a new routine:
+var mod = new dsmeanwd.Module( mem );
+// returns
+
+// Initialize the routine:
+mod.initializeSync();
+```
+
+#### dsmeanwd.Module.prototype.main( N, xp, sx )
+
+Computes the [arithmetic mean][arithmetic-mean] of a single-precision floating-point strided array `x` using Welford's algorithm with extended accumulation and returning an extended precision result.
+
+
+
+```javascript
+var Memory = require( '@stdlib/wasm/memory' );
+var oneTo = require( '@stdlib/array/one-to' );
+var zeros = require( '@stdlib/array/zeros' );
+
+// Create a new memory instance with an initial size of 10 pages (640KiB) and a maximum size of 100 pages (6.4MiB):
+var mem = new Memory({
+ 'initial': 10,
+ 'maximum': 100
+});
+
+// Create a new routine:
+var mod = new dsmeanwd.Module( mem );
+// returns
+
+// Initialize the routine:
+mod.initializeSync();
+
+// Define a vector data type:
+var dtype = 'float32';
+
+// Specify a vector length:
+var N = 3;
+
+// Define a pointer (i.e., byte offset) for storing the input vector:
+var xptr = 0;
+
+// Write vector values to module memory:
+mod.write( xptr, oneTo( N, dtype ) );
+
+// Perform computation:
+var y = mod.main( N, xptr, 1 );
+// returns 2.0
+```
+
+The function has the following parameters:
+
+- **N**: number of indexed elements.
+- **xp**: input [`Float32Array`][@stdlib/array/float32] pointer (i.e., byte offset).
+- **sx**: stride length for `x`.
+
+#### dsmeanwd.Module.prototype.ndarray( N, alpha, xp, sx, ox )
+
+Computes the [arithmetic mean][arithmetic-mean] of a single-precision floating-point strided array using Welford's algorithm with extended accumulation and alternative indexing semantics and returning an extended precision result.
+
+
+
+```javascript
+var dsmeanwd = require( '@stdlib/stats/strided/wasm/dsmeanwd' );
+var Memory = require( '@stdlib/wasm/memory' );
+var oneTo = require( '@stdlib/array/one-to' );
+var zeros = require( '@stdlib/array/zeros' );
+
+// Create a new memory instance with an initial size of 10 pages (640KiB) and a maximum size of 100 pages (6.4MiB):
+var mem = new Memory({
+ 'initial': 10,
+ 'maximum': 100
+});
+
+// Create a new routine:
+var mod = new dsmeanwd.Module( mem );
+// returns
+
+// Initialize the routine:
+mod.initializeSync();
+
+// Define a vector data type:
+var dtype = 'float32';
+
+// Specify a vector length:
+var N = 3;
+
+// Define a pointer (i.e., byte offset) for storing the input vector:
+var xptr = 0;
+
+// Write vector values to module memory:
+mod.write( xptr, oneTo( N, dtype ) );
+
+// Perform computation:
+var y = mod.ndarray( N, xptr, 1, 0 );
+// returns 2.0
+```
+
+The function has the following additional parameters:
+
+- **ox**: starting index for `x`.
+
+
+
+
+
+
+
+* * *
+
+## Notes
+
+- If `N <= 0`, both `main` and `ndarray` methods return `0.0`.
+- This package implements routines using WebAssembly. When provided arrays which are not allocated on a `dsmeanwd` module memory instance, data must be explicitly copied to module memory prior to computation. Data movement may entail a performance cost, and, thus, if you are using arrays external to module memory, you should prefer using [`@stdlib/stats/strided/dsmeanwd`][@stdlib/stats/strided/dsmeanwd]. However, if working with arrays which are allocated and explicitly managed on module memory, you can achieve better performance when compared to the pure JavaScript implementations found in [`@stdlib/stats/strided/dsmeanwd`][@stdlib/stats/strided/dsmeanwd]. Beware that such performance gains may come at the cost of additional complexity when having to perform manual memory management. Choosing between implementations depends heavily on the particular needs and constraints of your application, with no one choice universally better than the other.
+
+
+
+
+
+
+
+* * *
+
+## Examples
+
+
+
+```javascript
+var discreteUniform = require( '@stdlib/random/array/discrete-uniform' );
+var dsmeanwd = require( '@stdlib/stats/strided/wasm/dsmeanwd' );
+
+var opts = {
+ 'dtype': 'float32'
+};
+var x = discreteUniform( 10, 0, 100, opts );
+console.log( x );
+
+var y = dsmeanwd.ndarray( x.length, x, 1, 0 );
+console.log( y );
+```
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+[arithmetic-mean]: https://en.wikipedia.org/wiki/Arithmetic_mean
+
+[@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
+
+[@stdlib/wasm/memory]: https://github.com/stdlib-js/stdlib/tree/develop/lib/node_modules/%40stdlib/wasm/memory
+
+[@stdlib/wasm/module-wrapper]: https://github.com/stdlib-js/stdlib/tree/develop/lib/node_modules/%40stdlib/wasm/module-wrapper
+
+[@stdlib/stats/strided/dsmeanwd]: https://github.com/stdlib-js/stdlib/tree/develop/lib/node_modules/%40stdlib/stats/strided/dsmeanwd
+
+
+
+
+
+
diff --git a/lib/node_modules/@stdlib/stats/strided/wasm/dsmeanwd/benchmark/benchmark.js b/lib/node_modules/@stdlib/stats/strided/wasm/dsmeanwd/benchmark/benchmark.js
new file mode 100644
index 000000000000..9cf1ef7f9b3d
--- /dev/null
+++ b/lib/node_modules/@stdlib/stats/strided/wasm/dsmeanwd/benchmark/benchmark.js
@@ -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.
+*/
+
+'use strict';
+
+// MODULES //
+
+var bench = require( '@stdlib/bench' );
+var hasWebAssemblySupport = require( '@stdlib/assert/has-wasm-support' );
+var uniform = require( '@stdlib/random/array/uniform' );
+var isnanf = require( '@stdlib/math/base/assert/is-nanf' );
+var pow = require( '@stdlib/math/base/special/pow' );
+var pkg = require( './../package.json' ).name;
+var dsmeanwd = require( './../lib' );
+
+
+// VARIABLES //
+
+var opts = {
+ 'skip': !hasWebAssemblySupport()
+};
+var options = {
+ 'dtype': 'float32'
+};
+
+
+// FUNCTIONS //
+
+/**
+* Creates a benchmark function.
+*
+* @private
+* @param {PositiveInteger} len - array length
+* @returns {Function} benchmark function
+*/
+function createBenchmark( len ) {
+ var x = uniform( len, -10.0, 10.0, options );
+ return benchmark;
+
+ /**
+ * Benchmark function.
+ *
+ * @private
+ * @param {Benchmark} b - benchmark instance
+ */
+ function benchmark( b ) {
+ var v;
+ var i;
+
+ b.tic();
+ for ( i = 0; i < b.iterations; i++ ) {
+ v = dsmeanwd.main( x.length, x, 1 );
+ if ( isnanf( v ) ) {
+ b.fail( 'should not return NaN' );
+ }
+ }
+ b.toc();
+ if ( isnanf( v ) ) {
+ b.fail( 'should not return NaN' );
+ }
+ b.pass( 'benchmark finished' );
+ b.end();
+ }
+}
+
+
+// MAIN //
+
+/**
+* Main execution sequence.
+*
+* @private
+*/
+function main() {
+ var len;
+ var min;
+ var max;
+ var f;
+ var i;
+
+ min = 1; // 10^min
+ max = 6; // 10^max
+
+ for ( i = min; i <= max; i++ ) {
+ len = pow( 10, i );
+ f = createBenchmark( len );
+ bench( pkg+':len='+len, opts, f );
+ }
+}
+
+main();
diff --git a/lib/node_modules/@stdlib/stats/strided/wasm/dsmeanwd/benchmark/benchmark.module.js b/lib/node_modules/@stdlib/stats/strided/wasm/dsmeanwd/benchmark/benchmark.module.js
new file mode 100644
index 000000000000..9a293d954d23
--- /dev/null
+++ b/lib/node_modules/@stdlib/stats/strided/wasm/dsmeanwd/benchmark/benchmark.module.js
@@ -0,0 +1,66 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+'use strict';
+
+// MODULES //
+
+var bench = require( '@stdlib/bench' );
+var hasWebAssemblySupport = require( '@stdlib/assert/has-wasm-support' );
+var Memory = require( '@stdlib/wasm/memory' );
+var pkg = require( './../package.json' ).name;
+var dsmeanwd = require( './../lib' );
+
+
+// VARIABLES //
+
+var opts = {
+ 'skip': !hasWebAssemblySupport()
+};
+
+
+// MAIN //
+
+bench( pkg+':Module:constructor', opts, function benchmark( b ) {
+ var values;
+ var o;
+ var v;
+ var i;
+
+ o = {
+ 'initial': 0
+ };
+ values = [
+ new Memory( o ),
+ new Memory( o )
+ ];
+
+ b.tic();
+ for ( i = 0; i < b.iterations; i++ ) {
+ v = new dsmeanwd.Module( values[ i%values.length ] );
+ if ( typeof v !== 'object' ) {
+ b.fail( 'should return an object' );
+ }
+ }
+ b.toc();
+ if ( typeof v !== 'object' ) {
+ b.fail( 'should return an object' );
+ }
+ b.pass( 'benchmark finished' );
+ b.end();
+});
diff --git a/lib/node_modules/@stdlib/stats/strided/wasm/dsmeanwd/benchmark/benchmark.module.main.js b/lib/node_modules/@stdlib/stats/strided/wasm/dsmeanwd/benchmark/benchmark.module.main.js
new file mode 100644
index 000000000000..35d81572216e
--- /dev/null
+++ b/lib/node_modules/@stdlib/stats/strided/wasm/dsmeanwd/benchmark/benchmark.module.main.js
@@ -0,0 +1,130 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+'use strict';
+
+// MODULES //
+
+var bench = require( '@stdlib/bench' );
+var hasWebAssemblySupport = require( '@stdlib/assert/has-wasm-support' );
+var Memory = require( '@stdlib/wasm/memory' );
+var bytesPerElement = require( '@stdlib/ndarray/base/bytes-per-element' );
+var uniform = require( '@stdlib/random/array/uniform' );
+var isnanf = require( '@stdlib/math/base/assert/is-nanf' );
+var pow = require( '@stdlib/math/base/special/pow' );
+var pkg = require( './../package.json' ).name;
+var dsmeanwd = require( './../lib' );
+
+
+// VARIABLES //
+
+var opts = {
+ 'skip': !hasWebAssemblySupport()
+};
+var options = {
+ 'dtype': 'float32'
+};
+
+
+// FUNCTIONS //
+
+/**
+* Creates a benchmark function.
+*
+* @private
+* @param {PositiveInteger} len - array length
+* @returns {Function} benchmark function
+*/
+function createBenchmark( len ) {
+ return benchmark;
+
+ /**
+ * Benchmark function.
+ *
+ * @private
+ * @param {Benchmark} b - benchmark instance
+ */
+ function benchmark( b ) {
+ var xptr;
+ var mod;
+ var mem;
+ var nb;
+ var v;
+ var i;
+
+ // Create a new routine interface:
+ mem = new Memory({
+ 'initial': 0
+ });
+ mod = new dsmeanwd.Module( mem );
+
+ // Initialize the module:
+ mod.initializeSync(); // eslint-disable-line node/no-sync
+
+ // Reallocate the underlying memory to allow storing a vector:
+ nb = bytesPerElement( options.dtype );
+ mod.realloc( len*nb );
+
+ // Define a pointer (i.e., byte offset) to the first vector element:
+ xptr = 0;
+
+ // Write random values to module memory:
+ mod.write( xptr, uniform( len, -10.0, 10.0, options ) );
+
+ b.tic();
+ for ( i = 0; i < b.iterations; i++ ) {
+ v = mod.main( len, xptr, 1 );
+ if ( isnanf( v ) ) {
+ b.fail( 'should not return NaN' );
+ }
+ }
+ b.toc();
+ if ( isnanf( v ) ) {
+ b.fail( 'should not return NaN' );
+ }
+ b.pass( 'benchmark finished' );
+ b.end();
+ }
+}
+
+
+// MAIN //
+
+/**
+* Main execution sequence.
+*
+* @private
+*/
+function main() {
+ var len;
+ var min;
+ var max;
+ var f;
+ var i;
+
+ min = 1; // 10^min
+ max = 6; // 10^max
+
+ for ( i = min; i <= max; i++ ) {
+ len = pow( 10, i );
+ f = createBenchmark( len );
+ bench( pkg+'::module,pointers:len='+len, opts, f );
+ }
+}
+
+main();
diff --git a/lib/node_modules/@stdlib/stats/strided/wasm/dsmeanwd/benchmark/benchmark.module.ndarray.js b/lib/node_modules/@stdlib/stats/strided/wasm/dsmeanwd/benchmark/benchmark.module.ndarray.js
new file mode 100644
index 000000000000..fdaa8ff6c626
--- /dev/null
+++ b/lib/node_modules/@stdlib/stats/strided/wasm/dsmeanwd/benchmark/benchmark.module.ndarray.js
@@ -0,0 +1,130 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+'use strict';
+
+// MODULES //
+
+var bench = require( '@stdlib/bench' );
+var hasWebAssemblySupport = require( '@stdlib/assert/has-wasm-support' );
+var Memory = require( '@stdlib/wasm/memory' );
+var bytesPerElement = require( '@stdlib/ndarray/base/bytes-per-element' );
+var uniform = require( '@stdlib/random/array/uniform' );
+var isnanf = require( '@stdlib/math/base/assert/is-nanf' );
+var pow = require( '@stdlib/math/base/special/pow' );
+var pkg = require( './../package.json' ).name;
+var dsmeanwd = require( './../lib' );
+
+
+// VARIABLES //
+
+var opts = {
+ 'skip': !hasWebAssemblySupport()
+};
+var options = {
+ 'dtype': 'float32'
+};
+
+
+// FUNCTIONS //
+
+/**
+* Creates a benchmark function.
+*
+* @private
+* @param {PositiveInteger} len - array length
+* @returns {Function} benchmark function
+*/
+function createBenchmark( len ) {
+ return benchmark;
+
+ /**
+ * Benchmark function.
+ *
+ * @private
+ * @param {Benchmark} b - benchmark instance
+ */
+ function benchmark( b ) {
+ var xptr;
+ var mod;
+ var mem;
+ var nb;
+ var v;
+ var i;
+
+ // Create a new routine interface:
+ mem = new Memory({
+ 'initial': 0
+ });
+ mod = new dsmeanwd.Module( mem );
+
+ // Initialize the module:
+ mod.initializeSync(); // eslint-disable-line node/no-sync
+
+ // Reallocate the underlying memory to allow storing a vector:
+ nb = bytesPerElement( options.dtype );
+ mod.realloc( len*nb );
+
+ // Define a pointer (i.e., byte offset) to the first vector element:
+ xptr = 0;
+
+ // Write random values to module memory:
+ mod.write( xptr, uniform( len, -10.0, 10.0, options ) );
+
+ b.tic();
+ for ( i = 0; i < b.iterations; i++ ) {
+ v = mod.ndarray( len, xptr, 1, 0 );
+ if ( isnanf( v ) ) {
+ b.fail( 'should not return NaN' );
+ }
+ }
+ b.toc();
+ if ( isnanf( v ) ) {
+ b.fail( 'should not return NaN' );
+ }
+ b.pass( 'benchmark finished' );
+ b.end();
+ }
+}
+
+
+// MAIN //
+
+/**
+* Main execution sequence.
+*
+* @private
+*/
+function main() {
+ var len;
+ var min;
+ var max;
+ var f;
+ var i;
+
+ min = 1; // 10^min
+ max = 6; // 10^max
+
+ for ( i = min; i <= max; i++ ) {
+ len = pow( 10, i );
+ f = createBenchmark( len );
+ bench( pkg+'::module,pointers:ndarray:len='+len, opts, f );
+ }
+}
+
+main();
diff --git a/lib/node_modules/@stdlib/stats/strided/wasm/dsmeanwd/benchmark/benchmark.ndarray.js b/lib/node_modules/@stdlib/stats/strided/wasm/dsmeanwd/benchmark/benchmark.ndarray.js
new file mode 100644
index 000000000000..ac88548060ea
--- /dev/null
+++ b/lib/node_modules/@stdlib/stats/strided/wasm/dsmeanwd/benchmark/benchmark.ndarray.js
@@ -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.
+*/
+
+'use strict';
+
+// MODULES //
+
+var bench = require( '@stdlib/bench' );
+var hasWebAssemblySupport = require( '@stdlib/assert/has-wasm-support' );
+var uniform = require( '@stdlib/random/array/uniform' );
+var isnanf = require( '@stdlib/math/base/assert/is-nanf' );
+var pow = require( '@stdlib/math/base/special/pow' );
+var pkg = require( './../package.json' ).name;
+var dsmeanwd = require( './../lib' );
+
+
+// VARIABLES //
+
+var opts = {
+ 'skip': !hasWebAssemblySupport()
+};
+var options = {
+ 'dtype': 'float32'
+};
+
+
+// FUNCTIONS //
+
+/**
+* Creates a benchmark function.
+*
+* @private
+* @param {PositiveInteger} len - array length
+* @returns {Function} benchmark function
+*/
+function createBenchmark( len ) {
+ var x = uniform( len, -10.0, 10.0, options );
+ return benchmark;
+
+ /**
+ * Benchmark function.
+ *
+ * @private
+ * @param {Benchmark} b - benchmark instance
+ */
+ function benchmark( b ) {
+ var v;
+ var i;
+
+ b.tic();
+ for ( i = 0; i < b.iterations; i++ ) {
+ v = dsmeanwd.ndarray( x.length, x, 1, 0 );
+ if ( isnanf( v ) ) {
+ b.fail( 'should not return NaN' );
+ }
+ }
+ b.toc();
+ if ( isnanf( v ) ) {
+ b.fail( 'should not return NaN' );
+ }
+ b.pass( 'benchmark finished' );
+ b.end();
+ }
+}
+
+
+// MAIN //
+
+/**
+* Main execution sequence.
+*
+* @private
+*/
+function main() {
+ var len;
+ var min;
+ var max;
+ var f;
+ var i;
+
+ min = 1; // 10^min
+ max = 6; // 10^max
+
+ for ( i = min; i <= max; i++ ) {
+ len = pow( 10, i );
+ f = createBenchmark( len );
+ bench( pkg+':ndarray:len='+len, opts, f );
+ }
+}
+
+main();
diff --git a/lib/node_modules/@stdlib/stats/strided/wasm/dsmeanwd/docs/repl.txt b/lib/node_modules/@stdlib/stats/strided/wasm/dsmeanwd/docs/repl.txt
new file mode 100644
index 000000000000..0f423382db5a
--- /dev/null
+++ b/lib/node_modules/@stdlib/stats/strided/wasm/dsmeanwd/docs/repl.txt
@@ -0,0 +1,502 @@
+
+{{alias}}.main( N, x, strideX )
+ Computes the arithmetic mean of a single-precision floating-point strided
+ array using Welford's algorithm with extended accumulation and returning an
+ extended precision result.
+
+ The `N` and stride parameters determine which elements in the strided array
+ are accessed at runtime.
+
+ Indexing is relative to the first index. To introduce an offset, use a typed
+ array view.
+
+ If `N <= 0`, the function returns `0.0`.
+
+ Parameters
+ ----------
+ N: integer
+ Number of indexed elements.
+
+ x: Float32Array
+ Input array.
+
+ strideX: integer
+ Stride length.
+
+ Returns
+ -------
+ out: number
+ The arithmetic mean.
+
+ Examples
+ --------
+ // Standard Usage:
+ > var x = new {{alias:@stdlib/array/float32}}( [ 1.0, -2.0, 2.0 ] );
+ > {{alias}}.main( x.length, x, 1 )
+ ~0.3333
+
+ // Using `N` and stride parameters:
+ > x = new {{alias:@stdlib/array/float32}}( [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0 ] );
+ > {{alias}}.main( 3, x, 2 )
+ 3
+
+ // Using view offsets:
+ > var x0 = new {{alias:@stdlib/array/float32}}( [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0 ] );
+ > var x1 = new {{alias:@stdlib/array/float32}}( x0.buffer, x0.BYTES_PER_ELEMENT*1 );
+ > {{alias}}.main( 3, x1, 2)
+ ~-0.3333
+
+
+{{alias}}.ndarray( N, x, strideX, offsetX )
+ Computes the arithmetic mean of a single-precision floating-point strided
+ array using Welford's algorithm with extended accumulation and alternative
+ indexing semantics and returning an extended precision result.
+
+ While typed array views mandate a view offset based on the underlying
+ buffer, the offset parameter supports indexing semantics based on a starting
+ index.
+
+ Parameters
+ ----------
+ N: integer
+ Number of indexed elements.
+
+ x: Float32Array
+ Input array.
+
+ strideX: integer
+ Stride length.
+
+ offsetX: integer
+ Starting index.
+
+ Returns
+ -------
+ out: number
+ The arithmetic mean.
+
+ Examples
+ --------
+ // Standard Usage:
+ > var x = new {{alias:@stdlib/array/float32}}( [ 1.0, -2.0, 2.0 ] );
+ > {{alias}}.ndarray( x.length, x, 1, 0 )
+ ~0.3333
+
+ // Using offset parameter:
+ > x = new {{alias:@stdlib/array/float32}}( [ 1.0, -2.0, 3.0, 2.0, 5.0, -1.0 ] );
+ > {{alias}}.ndarray( 3, x, 2, 1 )
+ ~-0.3333
+
+
+{{alias}}.Module( memory )
+ Returns a new WebAssembly module wrapper which uses the provided WebAssembly
+ memory instance as its underlying memory.
+
+ Parameters
+ ----------
+ memory: Memory
+ WebAssembly memory instance.
+
+ Returns
+ -------
+ mod: Module
+ WebAssembly module wrapper.
+
+ Examples
+ --------
+ // Create a new memory instance:
+ > var mem = new {{alias:@stdlib/wasm/memory}}( { 'initial': 0 } );
+
+ // Create a new routine:
+ > var mod = new {{alias}}.Module( mem );
+
+ // Initialize the routine:
+ > mod.initializeSync();
+
+
+{{alias}}.Module.prototype.binary
+ Read-only property which returns WebAssembly binary code.
+
+ Returns
+ -------
+ out: Uint8Array
+ WebAssembly binary code.
+
+ Examples
+ --------
+ > var mem = new {{alias:@stdlib/wasm/memory}}( { 'initial': 0 } );
+ > var mod = new {{alias}}.Module( mem );
+ > mod.initializeSync();
+ > mod.binary
+
+
+
+{{alias}}.Module.prototype.memory
+ Read-only property which returns WebAssembly memory.
+
+ Returns
+ -------
+ mem: Memory|null
+ WebAssembly memory.
+
+ Examples
+ --------
+ > var mem = new {{alias:@stdlib/wasm/memory}}( { 'initial': 0 } );
+ > var mod = new {{alias}}.Module( mem );
+ > mod.initializeSync();
+ > mod.memory
+
+
+
+{{alias}}.Module.prototype.buffer
+ Read-only property which returns a WebAssembly memory buffer as a
+ Uint8Array.
+
+ Returns
+ -------
+ buf: Uint8Array|null
+ WebAssembly memory buffer.
+
+ Examples
+ --------
+ > var mem = new {{alias:@stdlib/wasm/memory}}( { 'initial': 0 } );
+ > var mod = new {{alias}}.Module( mem );
+ > mod.initializeSync();
+ > mod.buffer
+
+
+
+{{alias}}.Module.prototype.view
+ Read-only property which returns a WebAsssembly memory buffer as a DataView.
+
+ Returns
+ -------
+ view: DataView|null
+ WebAssembly memory view.
+
+ Examples
+ --------
+ > var mem = new {{alias:@stdlib/wasm/memory}}( { 'initial': 0 } );
+ > var mod = new {{alias}}.Module( mem );
+ > mod.initializeSync();
+ > mod.view
+
+
+
+{{alias}}.Module.prototype.exports
+ Read-only property which returns "raw" WebAssembly module exports.
+
+ Returns
+ -------
+ out: Object|null
+ WebAssembly module exports.
+
+ Examples
+ --------
+ > var mem = new {{alias:@stdlib/wasm/memory}}( { 'initial': 0 } );
+ > var mod = new {{alias}}.Module( mem );
+ > mod.initializeSync();
+ > mod.exports
+ {...}
+
+
+{{alias}}.Module.prototype.initialize()
+ Asynchronously initializes a WebAssembly module instance.
+
+ Returns
+ -------
+ p: Promise
+ Promise which resolves upon initializing a WebAssembly module instance.
+
+ Examples
+ --------
+ > var mem = new {{alias:@stdlib/wasm/memory}}( { 'initial': 0 } );
+ > var mod = new {{alias}}.Module( mem );
+ > mod.initialize();
+
+
+{{alias}}.Module.prototype.initializeAsync( clbk )
+ Asynchronously initializes a WebAssembly module instance.
+
+ Parameters
+ ----------
+ clbk: Function
+ Callback to invoke upon initializing a WebAssembly module instance.
+
+ Examples
+ --------
+ > var mem = new {{alias:@stdlib/wasm/memory}}( { 'initial': 0 } );
+ > var mod = new {{alias}}.Module( mem );
+ > function clbk() { console.log( 'done' ) };
+ > mod.initializeAsync( clbk );
+
+
+{{alias}}.Module.prototype.initializeSync()
+ Synchronously initializes a WebAssembly module instance.
+
+ In web browsers, JavaScript engines may raise an exception when attempting
+ to synchronously compile large WebAssembly binaries due to concerns about
+ blocking the main thread. Hence, to initialize WebAssembly modules having
+ large binaries (e.g., >4KiB), consider using asynchronous initialization
+ methods in browser contexts.
+
+ Returns
+ -------
+ mod: Module
+ Module wrapper instance.
+
+ Examples
+ --------
+ > var mem = new {{alias:@stdlib/wasm/memory}}( { 'initial': 0 } );
+ > var mod = new {{alias}}.Module( mem );
+ > mod.initializeSync();
+
+
+{{alias}}.Module.prototype.realloc( nbytes )
+ Reallocates the underlying WebAssembly memory instance to a specified number
+ of bytes.
+
+ WebAssembly memory can only *grow*, not shrink. Hence, if provided a number
+ of bytes which is less than or equal to the size of the current memory, the
+ function does nothing.
+
+ When non-shared memory is resized, the underlying the `ArrayBuffer` is
+ detached, consequently invalidating any associated typed array views. Before
+ resizing non-shared memory, ensure that associated typed array views no
+ longer need byte access and can be garbage collected.
+
+ Parameters
+ ----------
+ nbytes: integer
+ Memory size (in bytes).
+
+ Returns
+ -------
+ bool: boolean
+ Boolean indicating whether the resize operation was successful.
+
+ Examples
+ --------
+ > var mem = new {{alias:@stdlib/wasm/memory}}( { 'initial': 0 } );
+ > var mod = new {{alias}}.Module( mem );
+ > mod.initializeSync();
+ > mod.realloc( 100 )
+
+
+
+{{alias}}.Module.prototype.hasCapacity( byteOffset, values )
+ Returns a boolean indicating whether the underlying WebAssembly memory
+ instance has the capacity to store a provided list of values starting from a
+ specified byte offset.
+
+ Parameters
+ ----------
+ byteOffset: integer
+ Byte offset at which to start writing values.
+
+ values: ArrayLikeObject
+ Input array containing values to write.
+
+ Returns
+ -------
+ bool: boolean
+ Boolean indicating whether the underlying WebAssembly memory instance
+ has enough capacity.
+
+ Examples
+ --------
+ > var mem = new {{alias:@stdlib/wasm/memory}}( { 'initial': 0 } );
+ > var mod = new {{alias}}.Module( mem );
+ > mod.initializeSync();
+ > mod.realloc( 100 );
+ > mod.hasCapacity( 0, [ 1, 2, 3, 4 ] )
+ true
+
+
+{{alias}}.Module.prototype.isView( values )
+ Returns a boolean indicating whether a provided list of values is a view of
+ the underlying memory of the WebAssembly module.
+
+ Parameters
+ ----------
+ values: ArrayLikeObject
+ Input array.
+
+ Returns
+ -------
+ bool: boolean
+ Boolean indicating whether the list is a memory view.
+
+ Examples
+ --------
+ > var mem = new {{alias:@stdlib/wasm/memory}}( { 'initial': 0 } );
+ > var mod = new {{alias}}.Module( mem );
+ > mod.initializeSync();
+ > mod.realloc( 100 );
+ > mod.isView( [ 1, 2, 3, 4 ] )
+ false
+
+
+{{alias}}.Module.prototype.write( byteOffset, values )
+ Writes values to the underlying WebAssembly memory instance.
+
+ The function infers element size (i.e., number of bytes per element) from
+ the data type of the input array. For example, if provided a Float32Array,
+ the function writes each element as a single-precision floating-point number
+ to the underlying WebAssembly memory instance.
+
+ In order to write elements as a different data type, you need to perform an
+ explicit cast *before* calling this method. For example, in order to write
+ single-precision floating-point numbers contained in a Float32Array as
+ signed 32-bit integers, you must first convert the Float32Array to an
+ Int32Array before passing the values to this method.
+
+ If provided an array having an unknown or "generic" data type, elements are
+ written as single-precision floating-point numbers.
+
+ Parameters
+ ----------
+ byteOffset: integer
+ Byte offset at which to start writing values.
+
+ values: ArrayLikeObject
+ Input array containing values to write.
+
+ Returns
+ -------
+ mod: Module
+ Module wrapper instance.
+
+ Examples
+ --------
+ > var mem = new {{alias:@stdlib/wasm/memory}}( { 'initial': 0 } );
+ > var mod = new {{alias}}.Module( mem );
+ > mod.initializeSync();
+ > mod.realloc( 100 );
+ > mod.write( 0, [ 1, 2, 3, 4 ] );
+
+
+{{alias}}.Module.prototype.read( byteOffset, out )
+ Reads values from the underlying WebAssembly memory instance.
+
+ The function infers element size (i.e., number of bytes per element) from
+ the data type of the output array. For example, if provided a Float32Array,
+ the function reads each element as a single-precision floating-point number
+ from the underlying WebAssembly memory instance.
+
+ In order to read elements as a different data type, you need to perform an
+ explicit cast *after* calling this method. For example, in order to read
+ single-precision floating-point numbers contained in a Float32Array as
+ signed 32-bit integers, you must convert the Float32Array to an Int32Array
+ after reading memory values using this method.
+
+ If provided an output array having an unknown or "generic" data type,
+ elements are read as single-precision floating-point numbers.
+
+ Parameters
+ ----------
+ byteOffset: integer
+ Byte offset at which to start reading values.
+
+ out: ArrayLikeObject
+ Output array for storing read values.
+
+ Returns
+ -------
+ mod: Module
+ Module wrapper instance.
+
+ Examples
+ --------
+ > var mem = new {{alias:@stdlib/wasm/memory}}( { 'initial': 0 } );
+ > var mod = new {{alias}}.Module( mem );
+ > mod.initializeSync();
+ > mod.realloc( 100 );
+ > mod.write( 0, [ 1, 2, 3, 4 ] );
+ > var out = [ 0, 0, 0, 0 ];
+ > mod.read( 0, out );
+ > out
+ [ 1, 2, 3, 4 ]
+
+
+{{alias}}.Module.prototype.main( N, xp, sx )
+ Computes the arithmetic mean of a single-precision floating-point strided
+ array using Welford's algorithm with extended accumulation and returning an
+ extended precision result.
+
+ Parameters
+ ----------
+ N: integer
+ Number of indexed elements.
+
+ xp: integer
+ Input array pointer (i.e., byte offset).
+
+ sx: integer
+ Stride length.
+
+ Returns
+ -------
+ out: number
+ The arithmetic mean.
+
+ Examples
+ --------
+ > var mem = new {{alias:@stdlib/wasm/memory}}( { 'initial': 1 } );
+ > var mod = new {{alias}}.Module( mem );
+ > mod.initializeSync();
+
+ // Define a "pointer" (i.e., byte offset) into module memory:
+ > var xptr = 0;
+
+ // Write data to module memory:
+ > mod.write( xptr, {{alias:@stdlib/array/one-to}}( 3, 'float32' ) );
+
+ // Perform computation:
+ > var s = mod.main( 3, xptr, 1 )
+ 2.0
+
+
+{{alias}}.Module.prototype.ndarray( N, xp, sx, ox )
+ Computes the arithmetic mean of a single-precision floating-point strided
+ array using Welford's algorithm with extended accumulation and alternative
+ indexing semantics and returning an extended precision result.
+
+ Parameters
+ ----------
+ N: integer
+ Number of indexed elements.
+
+ xp: integer
+ Input array pointer (i.e., byte offset).
+
+ sx: integer
+ Stride length.
+
+ ox: integer
+ Starting index.
+
+ Returns
+ -------
+ out: number
+ The arithmetic mean.
+
+ Examples
+ --------
+ > var mem = new {{alias:@stdlib/wasm/memory}}( { 'initial': 1 } );
+ > var mod = new {{alias}}.Module( mem );
+ > mod.initializeSync();
+
+ // Define a "pointer" (i.e., byte offset) into module memory:
+ > var xptr = 0;
+
+ // Write data to module memory:
+ > mod.write( xptr, {{alias:@stdlib/array/one-to}}( 3, 'float32' ) );
+
+ // Perform computation:
+ > var s = mod.ndarray( 3, xptr, 1, 0 )
+ 2.0
+
+ See Also
+ --------
+
diff --git a/lib/node_modules/@stdlib/stats/strided/wasm/dsmeanwd/docs/types/index.d.ts b/lib/node_modules/@stdlib/stats/strided/wasm/dsmeanwd/docs/types/index.d.ts
new file mode 100644
index 000000000000..2e79225bbbfc
--- /dev/null
+++ b/lib/node_modules/@stdlib/stats/strided/wasm/dsmeanwd/docs/types/index.d.ts
@@ -0,0 +1,316 @@
+/*
+* @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
+
+///
+
+import { ModuleWrapper, Memory } from '@stdlib/types/wasm';
+
+/**
+* Interface defining a module constructor which is both "newable" and "callable".
+*/
+interface ModuleConstructor {
+ /**
+ * Returns a new WebAssembly module wrapper instance which uses the provided WebAssembly memory instance as its underlying memory.
+ *
+ * @param mem - WebAssembly memory instance
+ * @returns module wrapper instance
+ *
+ * @example
+ * var Memory = require( '@stdlib/wasm/memory' );
+ * var oneTo = require( '@stdlib/array/one-to' );
+ *
+ * // Create a new memory instance with an initial size of 10 pages (640KiB) and a maximum size of 100 pages (6.4MiB):
+ * var mem = new Memory({
+ * 'initial': 10,
+ * 'maximum': 100
+ * });
+ *
+ * // Create a new routine:
+ * var mod = new dsmeanwd.Module( mem );
+ * // returns
+ *
+ * // Initialize the routine:
+ * mod.initializeSync();
+ *
+ * // Define a vector data type:
+ * var dtype = 'float32';
+ *
+ * // Specify a vector length:
+ * var N = 3;
+ *
+ * // Define a pointer (i.e., byte offset) to the first vector element:
+ * var xptr = 0;
+ *
+ * // Write vector values to module memory:
+ * mod.write( xptr, oneTo( N, dtype ) );
+ *
+ * // Perform computation:
+ * var y = mod.main( N, xptr, 1 );
+ * // returns 2.0
+ */
+ new( mem: Memory ): Module; // newable
+
+ /**
+ * Returns a new WebAssembly module wrapper instance which uses the provided WebAssembly memory instance as its underlying memory.
+ *
+ * @param mem - WebAssembly memory instance
+ * @returns module wrapper instance
+ *
+ * @example
+ * var Memory = require( '@stdlib/wasm/memory' );
+ * var oneTo = require( '@stdlib/array/one-to' );
+ *
+ * // Create a new memory instance with an initial size of 10 pages (640KiB) and a maximum size of 100 pages (6.4MiB):
+ * var mem = new Memory({
+ * 'initial': 10,
+ * 'maximum': 100
+ * });
+ *
+ * // Create a new routine:
+ * var mod = dsmeanwd.Module( mem );
+ * // returns
+ *
+ * // Initialize the routine:
+ * mod.initializeSync();
+ *
+ * // Define a vector data type:
+ * var dtype = 'float32';
+ *
+ * // Specify a vector length:
+ * var N = 3;
+ *
+ * // Define a pointer (i.e., byte offset) to the first vector element:
+ * var xptr = 0;
+ *
+ * // Write vector values to module memory:
+ * mod.write( xptr, oneTo( N, dtype ) );
+ *
+ * // Perform computation:
+ * var y = mod.main( N, xptr, 1 );
+ * // returns 2.0
+ */
+ ( mem: Memory ): Module; // callable
+}
+
+/**
+* Interface describing a `dsmeanwd` WebAssembly module.
+*/
+interface Module extends ModuleWrapper {
+ /**
+ * Computes the arithmetic mean of a single-precision floating-point strided array using Welford's algorithm with extended accumulation and returning an extended precision result.
+ *
+ * @param N - number of indexed elements
+ * @param xptr - input array pointer (i.e., byte offset)
+ * @param strideX - stride length
+ * @returns arithmetic mean
+ *
+ * @example
+ * var Memory = require( '@stdlib/wasm/memory' );
+ * var oneTo = require( '@stdlib/array/one-to' );
+ *
+ * // Create a new memory instance with an initial size of 10 pages (640KiB) and a maximum size of 100 pages (6.4MiB):
+ * var mem = new Memory({
+ * 'initial': 10,
+ * 'maximum': 100
+ * });
+ *
+ * // Create a new routine:
+ * var mod = new dsmeanwd.Module( mem );
+ * // returns
+ *
+ * // Initialize the routine:
+ * mod.initializeSync();
+ *
+ * // Define a vector data type:
+ * var dtype = 'float32';
+ *
+ * // Specify a vector length:
+ * var N = 3;
+ *
+ * // Define a pointer (i.e., byte offset) to the first vector element:
+ * var xptr = 0;
+ *
+ * // Write vector values to module memory:
+ * mod.write( xptr, oneTo( N, dtype ) );
+ *
+ * // Perform computation:
+ * var y = mod.main( N, xptr, 1 );
+ * // returns 2.0
+ */
+ main( N: number, xptr: number, strideX: number ): number;
+
+ /**
+ * Computes the arithmetic mean of a single-precision floating-point strided array using Welford's algorithm with extended accumulation and alternative indexing semantics and returning an extended precision result.
+ *
+ * @param N - number of indexed elements
+ * @param xptr - input array pointer (i.e., byte offset)
+ * @param strideX - stride length
+ * @param offsetX - starting index
+ * @returns arithmetic mean
+ *
+ * @example
+ * var Memory = require( '@stdlib/wasm/memory' );
+ * var oneTo = require( '@stdlib/array/one-to' );
+ *
+ * // Create a new memory instance with an initial size of 10 pages (640KiB) and a maximum size of 100 pages (6.4MiB):
+ * var mem = new Memory({
+ * 'initial': 10,
+ * 'maximum': 100
+ * });
+ *
+ * // Create a new routine:
+ * var mod = new dsmeanwd.Module( mem );
+ * // returns
+ *
+ * // Initialize the routine:
+ * mod.initializeSync();
+ *
+ * // Define a vector data type:
+ * var dtype = 'float32';
+ *
+ * // Specify a vector length:
+ * var N = 3;
+ *
+ * // Define a pointer (i.e., byte offset) to the first vector element:
+ * var xptr = 0;
+ *
+ * // Write vector values to module memory:
+ * mod.write( xptr, oneTo( N, dtype ) );
+ *
+ * // Perform computation:
+ * var y = mod.ndarray( N, xptr, 1, 0 );
+ * // returns 2.0
+ */
+ ndarray( N: number, xptr: number, strideX: number, offsetX: number ): number;
+}
+
+/**
+* Interface describing `dsmeanwd`.
+*/
+interface Routine extends ModuleWrapper {
+ /**
+ * Computes the arithmetic mean of a single-precision floating-point strided array using Welford's algorithm with extended accumulation and returning an extended precision result.
+ *
+ * @param N - number of indexed elements
+ * @param x - input array
+ * @param strideX - stride length
+ * @returns arithmetic mean
+ *
+ * @example
+ * var Float32Array = require( '@stdlib/array/float32' );
+ *
+ * var x = new Float32Array( [ 1.0, -2.0, 2.0 ] );
+ *
+ * var y = dsmeanwd.main( 3, x, 1 );
+ * // returns ~0.3333
+ */
+ main( N: number, x: Float32Array, strideX: number ): number;
+
+ /**
+ * Computes the arithmetic mean of a single-precision floating-point strided array using Welford's algorithm with extended accumulation and alternative indexing semantics and returning an extended precision result.
+ *
+ * @param N - number of indexed elements
+ * @param x - input array
+ * @param strideX - stride length
+ * @param offsetX - starting index
+ * @returns arithmetic mean
+ *
+ * @example
+ * var Float32Array = require( '@stdlib/array/float32' );
+ *
+ * var x = new Float32Array( [ 2.0, 1.0, 2.0, -2.0, -2.0, 2.0, 3.0, 4.0 ] );
+ *
+ * var out = dsmeanwd.ndarray( 4, x, 2, 1 );
+ * // returns 1.25
+ */
+ ndarray( N: number, x: Float32Array, strideX: number, offsetX: number ): number;
+
+ /**
+ * Returns a new WebAssembly module wrapper instance which uses the provided WebAssembly memory instance as its underlying memory.
+ *
+ * @param mem - WebAssembly memory instance
+ * @returns module wrapper instance
+ *
+ * @example
+ * var Memory = require( '@stdlib/wasm/memory' );
+ * var oneTo = require( '@stdlib/array/one-to' );
+ *
+ * // Create a new memory instance with an initial size of 10 pages (640KiB) and a maximum size of 100 pages (6.4MiB):
+ * var mem = new Memory({
+ * 'initial': 10,
+ * 'maximum': 100
+ * });
+ *
+ * // Create a new routine:
+ * var mod = new dsmeanwd.Module( mem );
+ * // returns
+ *
+ * // Initialize the routine:
+ * mod.initializeSync();
+ *
+ * // Define a vector data type:
+ * var dtype = 'float32';
+ *
+ * // Specify a vector length:
+ * var N = 3;
+ *
+ * // Define a pointer (i.e., byte offset) to the first vector element:
+ * var xptr = 0;
+ *
+ * // Write vector values to module memory:
+ * mod.write( xptr, oneTo( N, dtype ) );
+ *
+ * // Perform computation:
+ * var y = mod.main( N, xptr, 1 );
+ * // returns 2.0
+ */
+ Module: ModuleConstructor;
+}
+
+/**
+* Computes the arithmetic mean of a single-precision floating-point strided array using Welford's algorithm with extended accumulation and returning an extended precision result.
+*
+* @param N - number of indexed elements
+* @param x - input array
+* @param strideX - stride length
+* @returns arithmetic mean
+*
+* @example
+* var Float32Array = require( '@stdlib/array/float32' );
+*
+* var x = new Float32Array( [ 1.0, -2.0, 2.0 ] );
+*
+* var y = dsmeanwd.main( 3, x, 1 );
+* // returns ~0.3333
+*
+* @example
+* var Float32Array = require( '@stdlib/array/float32' );
+*
+* var x = new Float32Array( [ 2.0, 1.0, 2.0, -2.0, -2.0, 2.0, 3.0, 4.0 ] );
+*
+* var y = dsmeanwd.ndarray( 4, x, 2, 1 );
+* // returns 1.25
+*/
+declare var dsmeanwd: Routine;
+
+
+// EXPORTS //
+
+export = dsmeanwd;
diff --git a/lib/node_modules/@stdlib/stats/strided/wasm/dsmeanwd/docs/types/test.ts b/lib/node_modules/@stdlib/stats/strided/wasm/dsmeanwd/docs/types/test.ts
new file mode 100644
index 000000000000..eaac32f5531a
--- /dev/null
+++ b/lib/node_modules/@stdlib/stats/strided/wasm/dsmeanwd/docs/types/test.ts
@@ -0,0 +1,347 @@
+/*
+* @license Apache-2.0
+*
+* Copyright (c) 2025 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+/* eslint-disable space-in-parens */
+
+import Memory = require( '@stdlib/wasm/memory' );
+import dsmeanwd = require( './index' );
+
+
+// TESTS //
+
+// Attached to the main export is a `main` method which returns a number...
+{
+ const x = new Float32Array( 10 );
+
+ dsmeanwd.main( x.length, x, 1 ); // $ExpectType number
+}
+
+// The compiler throws an error if the `main` method is provided a first argument which is not a number...
+{
+ const x = new Float32Array( 10 );
+
+ dsmeanwd.main( '10', x, 1 ); // $ExpectError
+ dsmeanwd.main( true, x, 1 ); // $ExpectError
+ dsmeanwd.main( false, x, 1 ); // $ExpectError
+ dsmeanwd.main( null, x, 1 ); // $ExpectError
+ dsmeanwd.main( undefined, x, 1 ); // $ExpectError
+ dsmeanwd.main( [], x, 1 ); // $ExpectError
+ dsmeanwd.main( {}, x, 1 ); // $ExpectError
+ dsmeanwd.main( ( x: number ): number => x, x, 1 ); // $ExpectError
+}
+
+// The compiler throws an error if the `main` method is provided a second argument which is not a Float32Array...
+{
+ const x = new Float32Array( 10 );
+
+ dsmeanwd.main( x.length, 10, 1 ); // $ExpectError
+ dsmeanwd.main( x.length, '10', 1 ); // $ExpectError
+ dsmeanwd.main( x.length, true, 1 ); // $ExpectError
+ dsmeanwd.main( x.length, false, 1 ); // $ExpectError
+ dsmeanwd.main( x.length, null, 1 ); // $ExpectError
+ dsmeanwd.main( x.length, undefined, 1 ); // $ExpectError
+ dsmeanwd.main( x.length, [], 1 ); // $ExpectError
+ dsmeanwd.main( x.length, {}, 1 ); // $ExpectError
+ dsmeanwd.main( x.length, ( x: number ): number => x, 1 ); // $ExpectError
+}
+
+// The compiler throws an error if the `main` method is provided a third argument which is not a number...
+{
+ const x = new Float32Array( 10 );
+
+ dsmeanwd.main( x.length, x, '10' ); // $ExpectError
+ dsmeanwd.main( x.length, x, true ); // $ExpectError
+ dsmeanwd.main( x.length, x, false ); // $ExpectError
+ dsmeanwd.main( x.length, x, null ); // $ExpectError
+ dsmeanwd.main( x.length, x, undefined ); // $ExpectError
+ dsmeanwd.main( x.length, x, [] ); // $ExpectError
+ dsmeanwd.main( x.length, x, {} ); // $ExpectError
+ dsmeanwd.main( x.length, x, ( x: number ): number => x ); // $ExpectError
+}
+
+// The compiler throws an error if the `main` method is provided an unsupported number of arguments...
+{
+ const x = new Float32Array( 10 );
+
+ dsmeanwd.main(); // $ExpectError
+ dsmeanwd.main( x.length ); // $ExpectError
+ dsmeanwd.main( x.length, x ); // $ExpectError
+ dsmeanwd.main( x.length, x, 1, 10 ); // $ExpectError
+}
+
+// Attached to main export is an `ndarray` method which returns a number...
+{
+ const x = new Float32Array( 10 );
+
+ dsmeanwd.ndarray( x.length, x, 1, 0 ); // $ExpectType number
+}
+
+// The compiler throws an error if the `ndarray` method is provided a first argument which is not a number...
+{
+ const x = new Float32Array( 10 );
+
+ dsmeanwd.ndarray( '10', x, 1, 0 ); // $ExpectError
+ dsmeanwd.ndarray( true, x, 1, 0 ); // $ExpectError
+ dsmeanwd.ndarray( false, x, 1, 0 ); // $ExpectError
+ dsmeanwd.ndarray( null, x, 1, 0 ); // $ExpectError
+ dsmeanwd.ndarray( undefined, x, 1, 0 ); // $ExpectError
+ dsmeanwd.ndarray( [], x, 1, 0 ); // $ExpectError
+ dsmeanwd.ndarray( {}, x, 1, 0 ); // $ExpectError
+ dsmeanwd.ndarray( ( x: number ): number => x, x, 1, 0 ); // $ExpectError
+}
+
+// The compiler throws an error if the `ndarray` method is provided a second argument which is not a Float32Array...
+{
+ const x = new Float32Array( 10 );
+
+ dsmeanwd.ndarray( x.length, 10, 1, 0 ); // $ExpectError
+ dsmeanwd.ndarray( x.length, '10', 1, 0 ); // $ExpectError
+ dsmeanwd.ndarray( x.length, true, 1, 0 ); // $ExpectError
+ dsmeanwd.ndarray( x.length, false, 1, 0 ); // $ExpectError
+ dsmeanwd.ndarray( x.length, null, 1, 0 ); // $ExpectError
+ dsmeanwd.ndarray( x.length, undefined, 1, 0 ); // $ExpectError
+ dsmeanwd.ndarray( x.length, [], 1, 0 ); // $ExpectError
+ dsmeanwd.ndarray( x.length, {}, 1, 0 ); // $ExpectError
+ dsmeanwd.ndarray( x.length, ( x: number ): number => x, 1, 0 ); // $ExpectError
+}
+
+// The compiler throws an error if the `ndarray` method is provided a third argument which is not a number...
+{
+ const x = new Float32Array( 10 );
+
+ dsmeanwd.ndarray( x.length, x, '10', 0 ); // $ExpectError
+ dsmeanwd.ndarray( x.length, x, true, 0 ); // $ExpectError
+ dsmeanwd.ndarray( x.length, x, false, 0 ); // $ExpectError
+ dsmeanwd.ndarray( x.length, x, null, 0 ); // $ExpectError
+ dsmeanwd.ndarray( x.length, x, undefined, 0 ); // $ExpectError
+ dsmeanwd.ndarray( x.length, x, [], 0 ); // $ExpectError
+ dsmeanwd.ndarray( x.length, x, {}, 0 ); // $ExpectError
+ dsmeanwd.ndarray( x.length, x, ( x: number ): number => x, 0 ); // $ExpectError
+}
+
+// The compiler throws an error if the `ndarray` method is provided a fourth argument which is not a number...
+{
+ const x = new Float32Array( 10 );
+
+ dsmeanwd.ndarray( x.length, x, 1, '10' ); // $ExpectError
+ dsmeanwd.ndarray( x.length, x, 1, true ); // $ExpectError
+ dsmeanwd.ndarray( x.length, x, 1, false ); // $ExpectError
+ dsmeanwd.ndarray( x.length, x, 1, null ); // $ExpectError
+ dsmeanwd.ndarray( x.length, x, 1, undefined ); // $ExpectError
+ dsmeanwd.ndarray( x.length, x, 1, [] ); // $ExpectError
+ dsmeanwd.ndarray( x.length, x, 1, {} ); // $ExpectError
+ dsmeanwd.ndarray( x.length, x, 1, ( x: number ): number => x ); // $ExpectError
+}
+
+// The compiler throws an error if the `ndarray` method is provided an unsupported number of arguments...
+{
+ const x = new Float32Array( 10 );
+
+ dsmeanwd.ndarray(); // $ExpectError
+ dsmeanwd.ndarray( x.length ); // $ExpectError
+ dsmeanwd.ndarray( x.length, x ); // $ExpectError
+ dsmeanwd.ndarray( x.length, x, 1 ); // $ExpectError
+ dsmeanwd.ndarray( x.length, x, 1, 0, 10 ); // $ExpectError
+}
+
+// Attached to the main export is a `Module` constructor which returns a module...
+{
+ const mem = new Memory({
+ 'initial': 0
+ });
+
+ dsmeanwd.Module( mem ); // $ExpectType Module
+}
+
+// The compiler throws an error if the `Module` constructor is not provided a WebAssembly memory instance...
+{
+ dsmeanwd.Module( '10' ); // $ExpectError
+ dsmeanwd.Module( true ); // $ExpectError
+ dsmeanwd.Module( false ); // $ExpectError
+ dsmeanwd.Module( null ); // $ExpectError
+ dsmeanwd.Module( undefined ); // $ExpectError
+ dsmeanwd.Module( [] ); // $ExpectError
+ dsmeanwd.Module( {} ); // $ExpectError
+ dsmeanwd.Module( ( x: number ): number => x ); // $ExpectError
+}
+
+// The `Module` constructor returns a module instance having a `main` method which returns a number...
+{
+ const mem = new Memory({
+ 'initial': 1
+ });
+ const mod = dsmeanwd.Module( mem );
+
+ mod.main( 10, 0, 1 ); // $ExpectType number
+}
+
+// The compiler throws an error if the `main` method of a module instance is provided a first argument which is not a number...
+{
+ const mem = new Memory({
+ 'initial': 1
+ });
+ const mod = dsmeanwd.Module( mem );
+
+ mod.main( '10', 0, 1 ); // $ExpectError
+ mod.main( true, 0, 1 ); // $ExpectError
+ mod.main( false, 0, 1 ); // $ExpectError
+ mod.main( null, 0, 1 ); // $ExpectError
+ mod.main( undefined, 0, 1 ); // $ExpectError
+ mod.main( [], 0, 1 ); // $ExpectError
+ mod.main( {}, 0, 1 ); // $ExpectError
+ mod.main( ( x: number ): number => x, 0, 1 ); // $ExpectError
+}
+
+// The compiler throws an error if the `main` method of a module instance is provided a second argument which is not a number...
+{
+ const mem = new Memory({
+ 'initial': 1
+ });
+ const mod = dsmeanwd.Module( mem );
+
+ mod.main( 10, '10', 1 ); // $ExpectError
+ mod.main( 10, true, 1 ); // $ExpectError
+ mod.main( 10, false, 1 ); // $ExpectError
+ mod.main( 10, null, 1 ); // $ExpectError
+ mod.main( 10, undefined, 1 ); // $ExpectError
+ mod.main( 10, [], 1 ); // $ExpectError
+ mod.main( 10, {}, 1 ); // $ExpectError
+ mod.main( 10, ( x: number ): number => x, 1 ); // $ExpectError
+}
+
+// The compiler throws an error if the `main` method of a module instance is provided a third argument which is not a number...
+{
+ const mem = new Memory({
+ 'initial': 1
+ });
+ const mod = dsmeanwd.Module( mem );
+
+ mod.main( 10, 0, '10' ); // $ExpectError
+ mod.main( 10, 0, true ); // $ExpectError
+ mod.main( 10, 0, false ); // $ExpectError
+ mod.main( 10, 0, null ); // $ExpectError
+ mod.main( 10, 0, undefined ); // $ExpectError
+ mod.main( 10, 0, [] ); // $ExpectError
+ mod.main( 10, 0, {} ); // $ExpectError
+ mod.main( 10, 0, ( x: number ): number => x ); // $ExpectError
+}
+
+// The compiler throws an error if the `main` method of a module instance is provided an unsupported number of arguments...
+{
+ const mem = new Memory({
+ 'initial': 1
+ });
+ const mod = dsmeanwd.Module( mem );
+
+ mod.main(); // $ExpectError
+ mod.main( 10 ); // $ExpectError
+ mod.main( 10, 0 ); // $ExpectError
+ mod.main( 10, 0, 1, 5 ); // $ExpectError
+}
+
+// The `Module` constructor returns a module instance having an `ndarray` method which returns a number...
+{
+ const mem = new Memory({
+ 'initial': 1
+ });
+ const mod = dsmeanwd.Module( mem );
+
+ mod.ndarray( 10, 0, 1, 0 ); // $ExpectType number
+}
+
+// The compiler throws an error if the `ndarray` method of a module instance is provided a first argument which is not a number...
+{
+ const mem = new Memory({
+ 'initial': 1
+ });
+ const mod = dsmeanwd.Module( mem );
+
+ mod.ndarray( '10', 0, 1, 0 ); // $ExpectError
+ mod.ndarray( true, 0, 1, 0 ); // $ExpectError
+ mod.ndarray( false, 0, 1, 0 ); // $ExpectError
+ mod.ndarray( null, 0, 1, 0 ); // $ExpectError
+ mod.ndarray( undefined, 0, 1, 0 ); // $ExpectError
+ mod.ndarray( [], 0, 1, 0 ); // $ExpectError
+ mod.ndarray( {}, 0, 1, 0 ); // $ExpectError
+ mod.ndarray( ( x: number ): number => x, 0, 1, 0 ); // $ExpectError
+}
+
+// The compiler throws an error if the `ndarray` method of a module instance is provided a second argument which is not a number...
+{
+ const mem = new Memory({
+ 'initial': 1
+ });
+ const mod = dsmeanwd.Module( mem );
+
+ mod.ndarray( 10, '10', 1, 0 ); // $ExpectError
+ mod.ndarray( 10, true, 1, 0 ); // $ExpectError
+ mod.ndarray( 10, false, 1, 0 ); // $ExpectError
+ mod.ndarray( 10, null, 1, 0 ); // $ExpectError
+ mod.ndarray( 10, undefined, 1, 0 ); // $ExpectError
+ mod.ndarray( 10, [], 1, 0 ); // $ExpectError
+ mod.ndarray( 10, {}, 1, 0 ); // $ExpectError
+ mod.ndarray( 10, ( x: number ): number => x, 1, 0 ); // $ExpectError
+}
+
+// The compiler throws an error if the `ndarray` method of a module instance is provided a third argument which is not a number...
+{
+ const mem = new Memory({
+ 'initial': 1
+ });
+ const mod = dsmeanwd.Module( mem );
+
+ mod.ndarray( 10, 0, '10', 0 ); // $ExpectError
+ mod.ndarray( 10, 0, true, 0 ); // $ExpectError
+ mod.ndarray( 10, 0, false, 0 ); // $ExpectError
+ mod.ndarray( 10, 0, null, 0 ); // $ExpectError
+ mod.ndarray( 10, 0, undefined, 0 ); // $ExpectError
+ mod.ndarray( 10, 0, [], 0 ); // $ExpectError
+ mod.ndarray( 10, 0, {}, 0 ); // $ExpectError
+ mod.ndarray( 10, 0, ( x: number ): number => x, 0 ); // $ExpectError
+}
+
+// The compiler throws an error if the `ndarray` method of a module instance is provided a fourth argument which is not a number...
+{
+ const mem = new Memory({
+ 'initial': 1
+ });
+ const mod = dsmeanwd.Module( mem );
+
+ mod.ndarray( 10, 0, 1, '10' ); // $ExpectError
+ mod.ndarray( 10, 0, 1, true ); // $ExpectError
+ mod.ndarray( 10, 0, 1, false ); // $ExpectError
+ mod.ndarray( 10, 0, 1, null ); // $ExpectError
+ mod.ndarray( 10, 0, 1, undefined ); // $ExpectError
+ mod.ndarray( 10, 0, 1, [] ); // $ExpectError
+ mod.ndarray( 10, 0, 1, {} ); // $ExpectError
+ mod.ndarray( 10, 0, 1, ( x: number ): number => x ); // $ExpectError
+}
+
+// The compiler throws an error if the `ndarray` method of a module instance is provided an unsupported number of arguments...
+{
+ const mem = new Memory({
+ 'initial': 1
+ });
+ const mod = dsmeanwd.Module( mem );
+
+ mod.ndarray(); // $ExpectError
+ mod.ndarray( 10 ); // $ExpectError
+ mod.ndarray( 10, 0 ); // $ExpectError
+ mod.ndarray( 10, 0, 1 ); // $ExpectError
+ mod.ndarray( 10, 0, 1, 0, 10 ); // $ExpectError
+}
diff --git a/lib/node_modules/@stdlib/stats/strided/wasm/dsmeanwd/examples/index.js b/lib/node_modules/@stdlib/stats/strided/wasm/dsmeanwd/examples/index.js
new file mode 100644
index 000000000000..61ce6a3bfda4
--- /dev/null
+++ b/lib/node_modules/@stdlib/stats/strided/wasm/dsmeanwd/examples/index.js
@@ -0,0 +1,43 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+'use strict';
+
+var hasWebAssemblySupport = require( '@stdlib/assert/has-wasm-support' );
+var oneTo = require( '@stdlib/array/one-to' );
+var dsmeanwd = require( './../lib' );
+
+function main() {
+ if ( !hasWebAssemblySupport() ) {
+ console.error( 'Environment does not support WebAssembly.' );
+ return;
+ }
+ // Specify a vector length:
+ var N = 3;
+
+ // Create an input array:
+ var x = oneTo( N, 'float32' );
+
+ // Perform computation:
+ var v = dsmeanwd.ndarray( N, x, 1, 0 );
+
+ // Print the result:
+ console.log( v );
+}
+
+main();
diff --git a/lib/node_modules/@stdlib/stats/strided/wasm/dsmeanwd/examples/little_endian_arrays.js b/lib/node_modules/@stdlib/stats/strided/wasm/dsmeanwd/examples/little_endian_arrays.js
new file mode 100644
index 000000000000..d6075c31a14f
--- /dev/null
+++ b/lib/node_modules/@stdlib/stats/strided/wasm/dsmeanwd/examples/little_endian_arrays.js
@@ -0,0 +1,65 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+'use strict';
+
+var hasWebAssemblySupport = require( '@stdlib/assert/has-wasm-support' );
+var Memory = require( '@stdlib/wasm/memory' );
+var discreteUniform = require( '@stdlib/random/base/discrete-uniform' ).factory;
+var gfillBy = require( '@stdlib/blas/ext/base/gfill-by' );
+var Float32ArrayLE = require( '@stdlib/array/little-endian-float32' );
+var dsmeanwd = require( './../lib' );
+
+function main() {
+ if ( !hasWebAssemblySupport() ) {
+ console.error( 'Environment does not support WebAssembly.' );
+ return;
+ }
+ // Create a new memory instance with an initial size of 10 pages (640KiB) and a maximum size of 100 pages (6.4MiB):
+ var mem = new Memory({
+ 'initial': 10,
+ 'maximum': 100
+ });
+
+ // Create a new routine:
+ var mod = new dsmeanwd.Module( mem );
+ // returns
+
+ // Initialize the routine:
+ mod.initializeSync(); // eslint-disable-line node/no-sync
+
+ // Specify a vector length:
+ var N = 3;
+
+ // Define a pointer (i.e., byte offset) for storing the input vector:
+ var xptr = 0;
+
+ // Create a typed array view over module memory:
+ var x = new Float32ArrayLE( mod.memory.buffer, xptr, N );
+
+ // Write values to module memory:
+ gfillBy( N, x, 1, discreteUniform( -10.0, 10.0 ) );
+
+ // Perform computation:
+ var v = mod.ndarray( N, xptr, 1, 0 );
+
+ // Print the result:
+ console.log( v );
+}
+
+main();
diff --git a/lib/node_modules/@stdlib/stats/strided/wasm/dsmeanwd/examples/module.js b/lib/node_modules/@stdlib/stats/strided/wasm/dsmeanwd/examples/module.js
new file mode 100644
index 000000000000..31750c37ae31
--- /dev/null
+++ b/lib/node_modules/@stdlib/stats/strided/wasm/dsmeanwd/examples/module.js
@@ -0,0 +1,63 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+'use strict';
+
+var hasWebAssemblySupport = require( '@stdlib/assert/has-wasm-support' );
+var Memory = require( '@stdlib/wasm/memory' );
+var oneTo = require( '@stdlib/array/one-to' );
+var dsmeanwd = require( './../lib' );
+
+function main() {
+ if ( !hasWebAssemblySupport() ) {
+ console.error( 'Environment does not support WebAssembly.' );
+ return;
+ }
+ // Create a new memory instance with an initial size of 10 pages (640KiB) and a maximum size of 100 pages (6.4MiB):
+ var mem = new Memory({
+ 'initial': 10,
+ 'maximum': 100
+ });
+
+ // Create a new routine:
+ var mod = new dsmeanwd.Module( mem );
+ // returns
+
+ // Initialize the routine:
+ mod.initializeSync(); // eslint-disable-line node/no-sync
+
+ // Define a vector data type:
+ var dtype = 'float32';
+
+ // Specify a vector length:
+ var N = 3;
+
+ // Define a pointer (i.e., byte offset) for storing the input vector:
+ var xptr = 0;
+
+ // Write vector values to module memory:
+ mod.write( xptr, oneTo( N, dtype ) );
+
+ // Perform computation:
+ var v = mod.ndarray( N, xptr, 1, 0 );
+
+ // Print the result:
+ console.log( v );
+}
+
+main();
diff --git a/lib/node_modules/@stdlib/stats/strided/wasm/dsmeanwd/lib/binary.browser.js b/lib/node_modules/@stdlib/stats/strided/wasm/dsmeanwd/lib/binary.browser.js
new file mode 100644
index 000000000000..fd51b63d82ce
--- /dev/null
+++ b/lib/node_modules/@stdlib/stats/strided/wasm/dsmeanwd/lib/binary.browser.js
@@ -0,0 +1,33 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+'use strict';
+
+// MODULES //
+
+var base64ToUint8Array = require( '@stdlib/string/base/base64-to-uint8array' );
+
+
+// MAIN //
+
+var wasm = base64ToUint8Array( 'AGFzbQEAAAAADwhkeWxpbmsuMAEEAAAAAAETA2AAAGADf39/AXxgBH9/f38BfAIPAQNlbnYGbWVtb3J5AgAAAwQDAAECB1EDEV9fd2FzbV9jYWxsX2N0b3JzAAAXc3RkbGliX3N0cmlkZWRfZHNtZWFud2QAAR9zdGRsaWJfc3RyaWRlZF9kc21lYW53ZF9uZGFycmF5AAIKigEDAwABCxoAIAAgASACQQEgAGsgAmxBACACQQBMGxACC2kCAXwBfyAAQQBMBEBEAAAAAAAA+H8PCwJAIAJFIABBAUZyRQRAA0AgACAFRg0CIAQgASADQQJ0aioCALsgBKEgBUEBaiIFuKOgIQQgAiADaiEDDAALAAsgASADQQJ0aioCALshBAsgBAs=' );
+
+
+// EXPORTS //
+
+module.exports = wasm;
diff --git a/lib/node_modules/@stdlib/stats/strided/wasm/dsmeanwd/lib/binary.js b/lib/node_modules/@stdlib/stats/strided/wasm/dsmeanwd/lib/binary.js
new file mode 100644
index 000000000000..2b83fe651780
--- /dev/null
+++ b/lib/node_modules/@stdlib/stats/strided/wasm/dsmeanwd/lib/binary.js
@@ -0,0 +1,34 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+'use strict';
+
+// MODULES //
+
+var resolve = require( 'path' ).resolve;
+var readWASM = require( '@stdlib/fs/read-wasm' ).sync;
+
+
+// MAIN //
+
+var wasm = readWASM( resolve( __dirname, '..', 'src', 'main.wasm' ) );
+
+
+// EXPORTS //
+
+module.exports = wasm;
diff --git a/lib/node_modules/@stdlib/stats/strided/wasm/dsmeanwd/lib/index.js b/lib/node_modules/@stdlib/stats/strided/wasm/dsmeanwd/lib/index.js
new file mode 100644
index 000000000000..cf8e999eee38
--- /dev/null
+++ b/lib/node_modules/@stdlib/stats/strided/wasm/dsmeanwd/lib/index.js
@@ -0,0 +1,100 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+'use strict';
+
+/**
+* WebAssembly routine to compute the arithmetic mean of a single-precision floating-point strided array using Welford's algorithm with extended accumulation and returning an extended precision result.
+*
+* @module @stdlib/stats/strided/wasm/dsmeanwd
+*
+* @example
+* var Float32Array = require( '@stdlib/array/float32' );
+* var dsmeanwd = require( '@stdlib/stats/strided/wasm/dsmeanwd' );
+*
+* // Define a strided array:
+* var x = new Float32Array( [ 1.0, -2.0, 2.0 ] );
+*
+* // Perform operation:
+* var v = dsmeanwd.main( x.length, x, 1 );
+* // returns ~0.3333
+*
+* @example
+* var Float32Array = require( '@stdlib/array/float32' );
+* var dsmeanwd = require( '@stdlib/stats/strided/wasm/dsmeanwd' );
+*
+* // Define a strided array:
+* var x = new Float32Array( [ 2.0, 1.0, 2.0, -2.0, -2.0, 2.0, 3.0, 4.0 ] );
+*
+* // Perform operation:
+* var v = dsmeanwd.ndarray( 4, x, 2, 1 );
+* // returns 1.25
+*
+* @example
+* var Memory = require( '@stdlib/wasm/memory' );
+* var oneTo = require( '@stdlib/array/one-to' );
+* var zeros = require( '@stdlib/array/zeros' );
+* var dsmeanwd = require( '@stdlib/stats/strided/wasm/dsmeanwd' );
+*
+* // Create a new memory instance with an initial size of 10 pages (640KiB) and a maximum size of 100 pages (6.4MiB):
+* var mem = new Memory({
+* 'initial': 10,
+* 'maximum': 100
+* });
+*
+* // Create a new routine:
+* var mod = new dsmeanwd.Module( mem );
+* // returns
+*
+* // Initialize the routine:
+* mod.initializeSync();
+*
+* // Define a vector data type:
+* var dtype = 'float32';
+*
+* // Specify a vector length:
+* var N = 3;
+*
+* // Define a pointer (i.e., byte offset) for storing the input vector:
+* var xptr = 0;
+*
+* // Write vector values to module memory:
+* mod.write( xptr, oneTo( N, dtype ) );
+*
+* // Perform computation:
+* var v = mod.main( 3, xptr, 1 );
+* // returns 2.0
+*/
+
+// MODULES //
+
+var setReadOnly = require( '@stdlib/utils/define-nonenumerable-read-only-property' );
+var main = require( './main.js' );
+var Module = require( './module.js' );
+
+
+// MAIN //
+
+setReadOnly( main, 'Module', Module );
+
+
+// EXPORTS //
+
+module.exports = main;
+
+// exports: { "Module": "main.Module" }
diff --git a/lib/node_modules/@stdlib/stats/strided/wasm/dsmeanwd/lib/main.js b/lib/node_modules/@stdlib/stats/strided/wasm/dsmeanwd/lib/main.js
new file mode 100644
index 000000000000..c70bc01fbd95
--- /dev/null
+++ b/lib/node_modules/@stdlib/stats/strided/wasm/dsmeanwd/lib/main.js
@@ -0,0 +1,60 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+'use strict';
+
+// MODULES //
+
+var Routine = require( './routine.js' );
+
+
+// MAIN //
+
+/**
+* WebAssembly routine to compute the arithmetic mean of a single-precision floating-point strided array using Welford's algorithm with extended accumulation and returning an extended precision result.
+*
+* @name dsmeanwd
+* @type {Routine}
+*
+* @example
+* var Float32Array = require( '@stdlib/array/float32' );
+*
+* // Define a strided array:
+* var x = new Float32Array( [ 1.0, -2.0, 2.0 ] );
+*
+* // Perform operation:
+* var v = dsmeanwd.main( 3, x, 1 );
+* // returns ~0.3333
+*
+* @example
+* var Float32Array = require( '@stdlib/array/float32' );
+*
+* // Define a strided array:
+* var x = new Float32Array( [ 2.0, 1.0, 2.0, -2.0, -2.0, 2.0, 3.0, 4.0 ] );
+*
+* // Perform operation:
+* var v = dsmeanwd.ndarray( 4, x, 2, 1 );
+* // returns 1.25
+*/
+var dsmeanwd = new Routine();
+dsmeanwd.initializeSync(); // eslint-disable-line node/no-sync
+
+
+// EXPORTS //
+
+module.exports = dsmeanwd;
diff --git a/lib/node_modules/@stdlib/stats/strided/wasm/dsmeanwd/lib/module.js b/lib/node_modules/@stdlib/stats/strided/wasm/dsmeanwd/lib/module.js
new file mode 100644
index 000000000000..85d133487c2c
--- /dev/null
+++ b/lib/node_modules/@stdlib/stats/strided/wasm/dsmeanwd/lib/module.js
@@ -0,0 +1,198 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+/* eslint-disable no-restricted-syntax, no-invalid-this */
+
+'use strict';
+
+// MODULES //
+
+var isWebAssemblyMemory = require( '@stdlib/assert/is-wasm-memory' );
+var setReadOnly = require( '@stdlib/utils/define-nonenumerable-read-only-property' );
+var inherits = require( '@stdlib/utils/inherit' );
+var WasmModule = require( '@stdlib/wasm/module-wrapper' );
+var format = require( '@stdlib/string/format' );
+var wasmBinary = require( './binary.js' );
+
+
+// MAIN //
+
+/**
+* WebAssembly module wrapper constructor.
+*
+* @constructor
+* @param {Object} memory - WebAssembly memory instance
+* @throws {TypeError} must provide a WebAssembly memory instance
+* @returns {Module} module instance
+*
+* @example
+* var Memory = require( '@stdlib/wasm/memory' );
+* var oneTo = require( '@stdlib/array/one-to' );
+*
+* // Create a new memory instance with an initial size of 10 pages (640KiB) and a maximum size of 100 pages (6.4MiB):
+* var mem = new Memory({
+* 'initial': 10,
+* 'maximum': 100
+* });
+*
+* // Create a new routine:
+* var dsmeanwd = new Module( mem );
+* // returns
+*
+* // Initialize the routine:
+* dsmeanwd.initializeSync();
+*
+* // Define a vector data type:
+* var dtype = 'float32';
+*
+* // Specify a vector length:
+* var N = 3;
+*
+* // Define a pointer (i.e., byte offset) for storing the input vector:
+* var xptr = 0;
+*
+* // Write vector values to module memory:
+* dsmeanwd.write( xptr, oneTo( N, dtype ) );
+*
+* // Perform computation:
+* var v = dsmeanwd.main( N, xptr, 1 );
+* // returns 2.0
+*/
+function Module( memory ) {
+ if ( !( this instanceof Module ) ) {
+ return new Module( memory );
+ }
+ if ( !isWebAssemblyMemory( memory ) ) {
+ throw new TypeError( format( 'invalid argument. Must provide a WebAssembly memory instance. Value: `%s`.', memory ) );
+ }
+ // Call the parent constructor:
+ WasmModule.call( this, wasmBinary, memory, {
+ 'env': {
+ 'memory': memory
+ }
+ });
+
+ return this;
+}
+
+// Inherit from the parent constructor:
+inherits( Module, WasmModule );
+
+/**
+* Computes the arithmetic mean of a single-precision floating-point strided array using Welford's algorithm with extended accumulation and returning an extended precision result.
+*
+* @name main
+* @memberof Module.prototype
+* @readonly
+* @type {Function}
+* @param {PositiveInteger} N - number of indexed elements
+* @param {Float32Array} x - input array
+* @param {integer} strideX - stride length
+* @returns {number} arithmetic mean
+*
+* @example
+* var Memory = require( '@stdlib/wasm/memory' );
+* var oneTo = require( '@stdlib/array/one-to' );
+*
+* // Create a new memory instance with an initial size of 10 pages (640KiB) and a maximum size of 100 pages (6.4MiB):
+* var mem = new Memory({
+* 'initial': 10,
+* 'maximum': 100
+* });
+*
+* // Create a new routine:
+* var dsmeanwd = new Module( mem );
+* // returns
+*
+* // Initialize the routine:
+* dsmeanwd.initializeSync();
+*
+* // Define a vector data type:
+* var dtype = 'float32';
+*
+* // Specify a vector length:
+* var N = 3;
+*
+* // Define a pointer (i.e., byte offset) for storing the input vector:
+* var xptr = 0;
+*
+* // Write vector values to module memory:
+* dsmeanwd.write( xptr, oneTo( N, dtype ) );
+*
+* // Perform computation:
+* var v = dsmeanwd.main( N, xptr, 1 );
+* // returns 2.0
+*/
+setReadOnly( Module.prototype, 'main', function dsmeanwd( N, xptr, strideX ) {
+ return this._instance.exports.stdlib_strided_dsmeanwd( N, xptr, strideX );
+});
+
+/**
+* Computes the arithmetic mean of a single-precision floating-point strided array using Welford's algorithm with extended accumulation and alternative indexing semantics and returning an extended precision result.
+*
+* @name ndarray
+* @memberof Module.prototype
+* @readonly
+* @type {Function}
+* @param {PositiveInteger} N - number of indexed elements
+* @param {Float32Array} x - input array
+* @param {integer} strideX - stride length
+* @param {NonNegativeInteger} offsetX - starting index
+* @returns {number} arithmetic mean
+*
+* @example
+* var Memory = require( '@stdlib/wasm/memory' );
+* var oneTo = require( '@stdlib/array/one-to' );
+*
+* // Create a new memory instance with an initial size of 10 pages (640KiB) and a maximum size of 100 pages (6.4MiB):
+* var mem = new Memory({
+* 'initial': 10,
+* 'maximum': 100
+* });
+*
+* // Create a new routine:
+* var dsmeanwd = new Module( mem );
+* // returns
+*
+* // Initialize the routine:
+* dsmeanwd.initializeSync();
+*
+* // Define a vector data type:
+* var dtype = 'float32';
+*
+* // Specify a vector length:
+* var N = 3;
+*
+* // Define a pointer (i.e., byte offset) for storing the input vector:
+* var xptr = 0;
+*
+* // Write vector values to module memory:
+* dsmeanwd.write( xptr, oneTo( N, dtype ) );
+*
+* // Perform computation:
+* var sum = dsmeanwd.ndarray( N, xptr, 1, 0 );
+* // returns 2.0
+*/
+setReadOnly( Module.prototype, 'ndarray', function dsmeanwd( N, xptr, strideX, offsetX ) {
+ return this._instance.exports.stdlib_strided_dsmeanwd_ndarray( N, xptr, strideX, offsetX ); // eslint-disable-line max-len
+});
+
+
+// EXPORTS //
+
+module.exports = Module;
diff --git a/lib/node_modules/@stdlib/stats/strided/wasm/dsmeanwd/lib/routine.js b/lib/node_modules/@stdlib/stats/strided/wasm/dsmeanwd/lib/routine.js
new file mode 100644
index 000000000000..594d1f1f994c
--- /dev/null
+++ b/lib/node_modules/@stdlib/stats/strided/wasm/dsmeanwd/lib/routine.js
@@ -0,0 +1,166 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+/* eslint-disable max-len, no-restricted-syntax, no-invalid-this */
+
+'use strict';
+
+// MODULES //
+
+var setReadOnly = require( '@stdlib/utils/define-nonenumerable-read-only-property' );
+var inherits = require( '@stdlib/utils/inherit' );
+var stride2offset = require( '@stdlib/strided/base/stride2offset' );
+var Memory = require( '@stdlib/wasm/memory' );
+var arrays2ptrs = require( '@stdlib/wasm/base/arrays2ptrs' );
+var strided2object = require( '@stdlib/wasm/base/strided2object' );
+var Module = require( './module.js' );
+
+
+// MAIN //
+
+/**
+* Routine constructor.
+*
+* @private
+* @constructor
+* @returns {Routine} routine instance
+*
+* @example
+* var Float32Array = require( '@stdlib/array/float32' );
+*
+* // Create a new routine:
+* var dsmeanwd = new Routine();
+*
+* // Initialize the module:
+* dsmeanwd.initializeSync();
+*
+* // Define a strided array:
+* var x = new Float32Array( [ 1.0, -2.0, 2.0 ] );
+*
+* // Perform operation:
+* var v = dsmeanwd.main( 3, x, 1 );
+* // returns ~0.3333
+*
+* @example
+* var Float32Array = require( '@stdlib/array/float32' );
+*
+* // Create a new routine:
+* var dsmeanwd = new Routine();
+*
+* // Initialize the module:
+* dsmeanwd.initializeSync();
+*
+* // Define a strided array:
+* var x = new Float32Array( [ 2.0, 1.0, 2.0, -2.0, -2.0, 2.0, 3.0, 4.0 ] );
+*
+* // Perform operation:
+* var sum = dsmeanwd.ndarray( 4, x, 2, 1 );
+* // returns 1.25
+*/
+function Routine() {
+ if ( !( this instanceof Routine ) ) {
+ return new Routine();
+ }
+ Module.call( this, new Memory({
+ 'initial': 0
+ }));
+ return this;
+}
+
+// Inherit from the parent constructor:
+inherits( Routine, Module );
+
+/**
+* Computes the arithmetic mean of a single-precision floating-point strided array using Welford's algorithm with extended accumulation and returning an extended precision result.
+*
+* @name main
+* @memberof Routine.prototype
+* @readonly
+* @type {Function}
+* @param {PositiveInteger} N - number of indexed elements
+* @param {Float32Array} x - input array
+* @param {integer} strideX - stride length
+* @returns {number} arithmetic mean
+*
+* @example
+* var Float32Array = require( '@stdlib/array/float32' );
+*
+* // Create a new routine:
+* var dsmeanwd = new Routine();
+*
+* // Initialize the module:
+* dsmeanwd.initializeSync();
+*
+* // Define a strided array:
+* var x = new Float32Array( [ 1.0, -2.0, 2.0 ] );
+*
+* // Perform operation:
+* var v = dsmeanwd.main( 3, x, 1 );
+* // returns ~0.3333
+*/
+setReadOnly( Routine.prototype, 'main', function dsmeanwd( N, x, strideX ) {
+ return this.ndarray( N, x, strideX, stride2offset( N, strideX ) );
+});
+
+/**
+* Computes the arithmetic mean of a single-precision floating-point strided array using Welford's algorithm with extended accumulation and alternative indexing semantics and returning an extended precision result.
+*
+* @name ndarray
+* @memberof Routine.prototype
+* @readonly
+* @type {Function}
+* @param {PositiveInteger} N - number of indexed elements
+* @param {Float32Array} x - input array
+* @param {integer} strideX - stride length
+* @param {NonNegativeInteger} offsetX - starting index
+* @returns {number} arithmetic mean
+*
+* @example
+* var Float32Array = require( '@stdlib/array/float32' );
+*
+* // Create a new routine:
+* var dsmeanwd = new Routine();
+*
+* // Initialize the module:
+* dsmeanwd.initializeSync();
+*
+* // Define a strided array:
+* var x = new Float32Array( [ 2.0, 1.0, 2.0, -2.0, -2.0, 2.0, 3.0, 4.0 ] );
+*
+* // Perform operation:
+* var v = dsmeanwd.ndarray( 4, x, 2, 1 );
+* // returns 1.25
+*/
+setReadOnly( Routine.prototype, 'ndarray', function dsmeanwd( N, x, strideX, offsetX ) {
+ var ptrs;
+ var p0;
+
+ // Convert the input arrays to "pointers" in the module's memory:
+ ptrs = arrays2ptrs( this, [
+ strided2object( N, x, strideX, offsetX )
+ ]);
+ p0 = ptrs[ 0 ];
+
+ // Perform computation by calling the corresponding parent method:
+ return Module.prototype.ndarray.call( this, N, p0.ptr, p0.stride, p0.offset );
+});
+
+
+// EXPORTS //
+
+module.exports = Routine;
diff --git a/lib/node_modules/@stdlib/stats/strided/wasm/dsmeanwd/manifest.json b/lib/node_modules/@stdlib/stats/strided/wasm/dsmeanwd/manifest.json
new file mode 100644
index 000000000000..91236741951c
--- /dev/null
+++ b/lib/node_modules/@stdlib/stats/strided/wasm/dsmeanwd/manifest.json
@@ -0,0 +1,36 @@
+{
+ "options": {},
+ "fields": [
+ {
+ "field": "src",
+ "resolve": true,
+ "relative": true
+ },
+ {
+ "field": "include",
+ "resolve": true,
+ "relative": true
+ },
+ {
+ "field": "libraries",
+ "resolve": false,
+ "relative": false
+ },
+ {
+ "field": "libpath",
+ "resolve": true,
+ "relative": false
+ }
+ ],
+ "confs": [
+ {
+ "src": [],
+ "include": [],
+ "libraries": [],
+ "libpath": [],
+ "dependencies": [
+ "@stdlib/stats/strided/dsmeanwd"
+ ]
+ }
+ ]
+}
diff --git a/lib/node_modules/@stdlib/stats/strided/wasm/dsmeanwd/package.json b/lib/node_modules/@stdlib/stats/strided/wasm/dsmeanwd/package.json
new file mode 100644
index 000000000000..eb7b01253753
--- /dev/null
+++ b/lib/node_modules/@stdlib/stats/strided/wasm/dsmeanwd/package.json
@@ -0,0 +1,82 @@
+{
+ "name": "@stdlib/stats/strided/wasm/dsmeanwd",
+ "version": "0.0.0",
+ "description": "Calculate the arithmetic mean of a single-precision floating-point strided array using Welford's algorithm with extended accumulation and returning an extended precision result.",
+ "license": "Apache-2.0",
+ "author": {
+ "name": "The Stdlib Authors",
+ "url": "https://github.com/stdlib-js/stdlib/graphs/contributors"
+ },
+ "contributors": [
+ {
+ "name": "The Stdlib Authors",
+ "url": "https://github.com/stdlib-js/stdlib/graphs/contributors"
+ }
+ ],
+ "main": "./lib",
+ "browser": {
+ "./lib/binary.js": "./lib/binary.browser.js"
+ },
+ "directories": {
+ "benchmark": "./benchmark",
+ "doc": "./docs",
+ "example": "./examples",
+ "lib": "./lib",
+ "scripts": "./scripts",
+ "src": "./src",
+ "test": "./test"
+ },
+ "types": "./docs/types",
+ "scripts": {},
+ "homepage": "https://github.com/stdlib-js/stdlib",
+ "repository": {
+ "type": "git",
+ "url": "git://github.com/stdlib-js/stdlib.git"
+ },
+ "bugs": {
+ "url": "https://github.com/stdlib-js/stdlib/issues"
+ },
+ "dependencies": {},
+ "devDependencies": {},
+ "engines": {
+ "node": ">=0.10.0",
+ "npm": ">2.7.0"
+ },
+ "os": [
+ "aix",
+ "darwin",
+ "freebsd",
+ "linux",
+ "macos",
+ "openbsd",
+ "sunos",
+ "win32",
+ "windows"
+ ],
+ "keywords": [
+ "stdlib",
+ "stdmath",
+ "statistics",
+ "stats",
+ "mathematics",
+ "math",
+ "average",
+ "avg",
+ "mean",
+ "arithmetic mean",
+ "central tendency",
+ "welford",
+ "strided",
+ "strided array",
+ "typed",
+ "array",
+ "float32",
+ "float",
+ "float32array",
+ "webassembly",
+ "wasm"
+ ],
+ "__stdlib__": {
+ "wasm": true
+ }
+}
diff --git a/lib/node_modules/@stdlib/stats/strided/wasm/dsmeanwd/scripts/build.js b/lib/node_modules/@stdlib/stats/strided/wasm/dsmeanwd/scripts/build.js
new file mode 100644
index 000000000000..66bf9650b6d6
--- /dev/null
+++ b/lib/node_modules/@stdlib/stats/strided/wasm/dsmeanwd/scripts/build.js
@@ -0,0 +1,66 @@
+#!/usr/bin/env node
+
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+'use strict';
+
+// MODULES //
+
+var resolve = require( 'path' ).resolve;
+var readFile = require( '@stdlib/fs/read-file' ).sync;
+var writeFile = require( '@stdlib/fs/write-file' ).sync;
+var replace = require( '@stdlib/string/replace' );
+var currentYear = require( '@stdlib/time/current-year' );
+
+
+// VARIABLES //
+
+var wpath = resolve( __dirname, '..', 'src', 'main.wasm' );
+var tpath = resolve( __dirname, 'template.txt' );
+var opath = resolve( __dirname, '..', 'lib', 'binary.browser.js' );
+
+var opts = {
+ 'encoding': 'utf8'
+};
+
+var PLACEHOLDER = '{{WASM_BASE64}}';
+var YEAR = '{{YEAR}}';
+
+
+// MAIN //
+
+/**
+* Main execution sequence.
+*
+* @private
+*/
+function main() {
+ var wasm;
+ var tmpl;
+
+ wasm = readFile( wpath );
+ tmpl = readFile( tpath, opts );
+
+ tmpl = replace( tmpl, YEAR, currentYear().toString() );
+ tmpl = replace( tmpl, PLACEHOLDER, wasm.toString( 'base64' ) );
+
+ writeFile( opath, tmpl, opts );
+}
+
+main();
diff --git a/lib/node_modules/@stdlib/stats/strided/wasm/dsmeanwd/scripts/template.txt b/lib/node_modules/@stdlib/stats/strided/wasm/dsmeanwd/scripts/template.txt
new file mode 100644
index 000000000000..f66cdb9735b1
--- /dev/null
+++ b/lib/node_modules/@stdlib/stats/strided/wasm/dsmeanwd/scripts/template.txt
@@ -0,0 +1,33 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) {{YEAR}} The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+'use strict';
+
+// MODULES //
+
+var base64ToUint8Array = require( '@stdlib/string/base/base64-to-uint8array' );
+
+
+// MAIN //
+
+var wasm = base64ToUint8Array( '{{WASM_BASE64}}' );
+
+
+// EXPORTS //
+
+module.exports = wasm;
diff --git a/lib/node_modules/@stdlib/stats/strided/wasm/dsmeanwd/src/Makefile b/lib/node_modules/@stdlib/stats/strided/wasm/dsmeanwd/src/Makefile
new file mode 100644
index 000000000000..8bbca210b248
--- /dev/null
+++ b/lib/node_modules/@stdlib/stats/strided/wasm/dsmeanwd/src/Makefile
@@ -0,0 +1,265 @@
+#/
+# @license Apache-2.0
+#
+# Copyright (c) 2025 The Stdlib Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#/
+
+#/
+# To compile targets listed in this Makefile, use top-level project `make`
+# commands rather than commands listed in this Makefile. The top-level project
+# `make` commands will ensure that various environment variables and flags are
+# appropriately set.
+#/
+
+# VARIABLES #
+
+ifndef VERBOSE
+ QUIET := @
+else
+ QUIET :=
+endif
+
+# Determine the OS ([1][1], [2][2]).
+#
+# [1]: https://en.wikipedia.org/wiki/Uname#Examples
+# [2]: http://stackoverflow.com/a/27776822/2225624
+OS ?= $(shell uname)
+ifneq (, $(findstring MINGW,$(OS)))
+ OS := WINNT
+else
+ifneq (, $(findstring MSYS,$(OS)))
+ OS := WINNT
+else
+ifneq (, $(findstring CYGWIN,$(OS)))
+ OS := WINNT
+else
+ifneq (, $(findstring Windows_NT,$(OS)))
+ OS := WINNT
+endif
+endif
+endif
+endif
+
+# Define the program used for compiling C source files to WebAssembly:
+ifdef EMCC_COMPILER
+ EMCC := $(EMCC_COMPILER)
+else
+ EMCC := emcc
+endif
+
+# Define the program used for compiling WebAssembly files to the WebAssembly text format:
+ifdef WASM2WAT
+ WASM_TO_WAT := $(WASM2WAT)
+else
+ WASM_TO_WAT := wasm2wat
+endif
+
+# Define the program used for compiling WebAssembly files to JavaScript:
+ifdef WASM2JS
+ WASM_TO_JS := $(WASM2JS)
+else
+ WASM_TO_JS := wasm2js
+endif
+
+# Define the path to the Node.js executable:
+ifdef NODE
+ NODEJS := $(NODE)
+else
+ NODEJS := node
+endif
+
+# Define the integer size:
+ifdef CBLAS_INT
+ INT_TYPE := $(CBLAS_INT)
+else
+ INT_TYPE := int32_t
+endif
+
+# Define the command-line options when compiling C files:
+CFLAGS ?= \
+ -std=c99 \
+ -O3 \
+ -flto \
+ -Wall \
+ -pedantic \
+ -D CBLAS_INT=$(INT_TYPE)
+
+# Define the command-line options when compiling C files to WebAssembly and asm.js:
+EMCCFLAGS ?= $(CFLAGS)
+
+# Define shared `emcc` flags:
+EMCC_SHARED_FLAGS := \
+ -Oz \
+ -fwasm-exceptions \
+ -s SUPPORT_LONGJMP=1 \
+ -s SIDE_MODULE=2 \
+ -s EXPORTED_FUNCTIONS="$(shell cat exports.json | tr -d ' \t\n' | sed s/\"/\'/g)"
+
+# Define WebAssembly `emcc` flags:
+EMCC_WASM_FLAGS := $(EMCC_SHARED_FLAGS) \
+ -s WASM=1 \
+ -s WASM_BIGINT=0
+
+# List of includes (e.g., `-I /foo/bar -I /beep/boop/include`):
+INCLUDE ?=
+
+# List of source files:
+SOURCE_FILES ?=
+
+# List of libraries (e.g., `-lopenblas -lpthread`):
+LIBRARIES ?=
+
+# List of library paths (e.g., `-L /foo/bar -L /beep/boop`):
+LIBPATH ?=
+
+# List of WebAssembly targets:
+wasm_targets := main.wasm
+
+# List of WebAssembly WAT targets:
+wat_targets :=
+
+# List of WebAssembly JavaScript targets:
+wasm_js_targets := main.wasm.js
+
+# List of other JavaScript targets:
+browser_js_targets := ./../lib/binary.browser.js
+
+
+# RULES #
+
+#/
+# Compiles source files.
+#
+# @param {string} [EMCC_COMPILER] - EMCC compiler (e.g., `emcc`)
+# @param {string} [EMCCFLAGS] - EMCC compiler options
+# @param {string} [WASM2WAT] - WebAssembly text format compiler (e.g., `wasm2wat`)
+# @param {string} [WASM2JS] - WebAssembly JavaScript compiler (e.g., `wasm2js`)
+# @param {string} [INCLUDE] - list of includes (e.g., `-I /foo/bar -I /beep/boop/include`)
+# @param {string} [SOURCE_FILES] - list of source files
+# @param {string} [LIBPATH] - list of library paths (e.g., `-L /foo/bar -L /beep/boop`)
+# @param {string} [LIBRARIES] - list of libraries (e.g., `-lopenblas -lpthread`)
+#
+# @example
+# make
+#
+# @example
+# make all
+#/
+all: wasm
+
+.PHONY: all
+
+#/
+# Compiles source files to WebAssembly.
+#
+# @param {string} [EMCC_COMPILER] - EMCC compiler (e.g., `emcc`)
+# @param {string} [EMCCFLAGS] - EMCC compiler options
+# @param {string} [WASM2WAT] - WebAssembly text format compiler (e.g., `wasm2wat`)
+# @param {string} [WASM2JS] - WebAssembly JavaScript compiler (e.g., `wasm2js`)
+# @param {string} [INCLUDE] - list of includes (e.g., `-I /foo/bar -I /beep/boop/include`)
+# @param {string} [SOURCE_FILES] - list of source files
+# @param {string} [LIBPATH] - list of library paths (e.g., `-L /foo/bar -L /beep/boop`)
+# @param {string} [LIBRARIES] - list of libraries (e.g., `-lopenblas -lpthread`)
+#
+# @example
+# make wasm
+#/
+wasm: $(wasm_targets) main.wat $(browser_js_targets)
+
+.PHONY: wasm
+
+#/
+# Compiles C source files to WebAssembly binaries.
+#
+# @private
+# @param {string} EMCC - EMCC compiler (e.g., `emcc`)
+# @param {string} EMCCFLAGS - EMCC compiler options
+# @param {string} INCLUDE - list of includes (e.g., `-I /foo/bar`)
+# @param {string} SOURCE_FILES - list of source files
+# @param {string} LIBPATH - list of library paths (e.g., `-L /foo/bar`)
+# @param {string} LIBRARIES - list of libraries (e.g., `-lopenblas`)
+#/
+$(wasm_targets):
+ $(QUIET) $(EMCC) $(EMCCFLAGS) $(EMCC_WASM_FLAGS) $(INCLUDE) -o $@ $(SOURCE_FILES) $< $(LIBPATH) $(LIBRARIES)
+
+#/
+# Compiles WebAssembly binary files to the WebAssembly text format.
+#
+# @private
+# @param {string} WASM2WAT - WAT compiler (e.g., `wasm2wat`)
+#/
+main.wat: main.wasm
+ $(QUIET) $(WASM_TO_WAT) -o $@ $<
+ $(QUIET) ( \
+ printf ';; @license Apache-2.0\n' ; \
+ printf ';;\n' ; \
+ printf ';; Copyright (c) %s The Stdlib Authors.\n' "$(shell date +%Y)" ; \
+ printf ';;\n' ; \
+ printf ';; Licensed under the Apache License, Version 2.0 (the \"License\");\n' ; \
+ printf ';; you may not use this file except in compliance with the License.\n' ; \
+ printf ';; You may obtain a copy of the License at\n' ; \
+ printf ';;\n' ; \
+ printf ';; http://www.apache.org/licenses/LICENSE-2.0\n' ; \
+ printf ';;\n' ; \
+ printf ';; Unless required by applicable law or agreed to in writing, software\n' ; \
+ printf ';; distributed under the License is distributed on an \"AS IS\" BASIS,\n' ; \
+ printf ';; WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n' ; \
+ printf ';; See the License for the specific language governing permissions and\n' ; \
+ printf ';; limitations under the License.\n' ; \
+ printf '\n' ; \
+ cat $@ \
+ ) > $@.tmp && mv $@.tmp $@
+
+$(wat_targets): %.wat: %.wasm
+ $(QUIET) $(WASM_TO_WAT) -o $@ $<
+
+#/
+# Compiles WebAssembly binary files to JavaScript.
+#
+# @private
+# @param {string} WASM2JS - JavaScript compiler (e.g., `wasm2js`)
+#/
+$(wasm_js_targets): %.wasm.js: %.wasm
+ $(QUIET) $(WASM_TO_JS) -o $@ $(wasm_targets)
+
+#/
+# Generates an inline WebAssembly build for use in bundlers.
+#
+# @private
+# @param {string} NODE - Node.js executable
+#/
+$(browser_js_targets): $(wasm_targets)
+ $(QUIET) $(NODEJS) ./../scripts/build.js
+
+#/
+# Removes generated WebAssembly files.
+#
+# @example
+# make clean-wasm
+#/
+clean-wasm:
+ $(QUIET) -rm -f *.wasm *.wat *.wasm.js $(browser_js_targets)
+
+.PHONY: clean-wasm
+
+#/
+# Removes generated files.
+#
+# @example
+# make clean
+#/
+clean: clean-wasm
+
+.PHONY: clean
diff --git a/lib/node_modules/@stdlib/stats/strided/wasm/dsmeanwd/src/exports.json b/lib/node_modules/@stdlib/stats/strided/wasm/dsmeanwd/src/exports.json
new file mode 100644
index 000000000000..31399fc0c723
--- /dev/null
+++ b/lib/node_modules/@stdlib/stats/strided/wasm/dsmeanwd/src/exports.json
@@ -0,0 +1,4 @@
+[
+ "_stdlib_strided_dsmeanwd",
+ "_stdlib_strided_dsmeanwd_ndarray"
+]
diff --git a/lib/node_modules/@stdlib/stats/strided/wasm/dsmeanwd/src/main.wasm b/lib/node_modules/@stdlib/stats/strided/wasm/dsmeanwd/src/main.wasm
new file mode 100755
index 0000000000000000000000000000000000000000..a48a5b393a4c35be3e7f124c83ce9857c8c3ca8b
GIT binary patch
literal 293
zcmZ{cy-LJD6ov24M8#2}SO{8pV`(8iLIUnqHa@{5?xaX|l7*Sz5?Gktr%-$e!56c1
zw6gIu=bU>FA2eY=NXifF?7DG%dxz?$;~CcgHOClnSF2>nDMxO{=e?mFHhv}mRt!k{
zk9=y(HlfU_an7u!jSm3lVY04!GGX$aZLP6kXq$0s0k8h~n9(-gH#5-T3vxp13lI<#
zs!(7p
Date: Sun, 6 Jul 2025 19:43:07 +0530
Subject: [PATCH 2/2] chore: updated makefile
---
type: pre_commit_static_analysis_report
description: Results of running static analysis checks when committing changes.
report:
- task: lint_filenames
status: passed
- task: lint_editorconfig
status: passed
- task: lint_markdown
status: na
- task: lint_package_json
status: na
- task: lint_repl_help
status: na
- task: lint_javascript_src
status: na
- task: lint_javascript_cli
status: na
- task: lint_javascript_examples
status: na
- task: lint_javascript_tests
status: na
- task: lint_javascript_benchmarks
status: na
- task: lint_python
status: na
- task: lint_r
status: na
- task: lint_c_src
status: na
- task: lint_c_examples
status: na
- task: lint_c_benchmarks
status: na
- task: lint_c_tests_fixtures
status: na
- task: lint_shell
status: na
- task: lint_typescript_declarations
status: na
- task: lint_typescript_tests
status: na
- task: lint_license_headers
status: passed
---
---
.../stats/strided/wasm/dsmeanwd/src/Makefile | 28 ++-----------------
1 file changed, 3 insertions(+), 25 deletions(-)
diff --git a/lib/node_modules/@stdlib/stats/strided/wasm/dsmeanwd/src/Makefile b/lib/node_modules/@stdlib/stats/strided/wasm/dsmeanwd/src/Makefile
index 8bbca210b248..1b1f35347760 100644
--- a/lib/node_modules/@stdlib/stats/strided/wasm/dsmeanwd/src/Makefile
+++ b/lib/node_modules/@stdlib/stats/strided/wasm/dsmeanwd/src/Makefile
@@ -128,7 +128,7 @@ LIBPATH ?=
wasm_targets := main.wasm
# List of WebAssembly WAT targets:
-wat_targets :=
+wat_targets := main.wat
# List of WebAssembly JavaScript targets:
wasm_js_targets := main.wasm.js
@@ -176,7 +176,7 @@ all: wasm
# @example
# make wasm
#/
-wasm: $(wasm_targets) main.wat $(browser_js_targets)
+wasm: $(wasm_targets) $(wat_targets) $(browser_js_targets)
.PHONY: wasm
@@ -200,30 +200,8 @@ $(wasm_targets):
# @private
# @param {string} WASM2WAT - WAT compiler (e.g., `wasm2wat`)
#/
-main.wat: main.wasm
- $(QUIET) $(WASM_TO_WAT) -o $@ $<
- $(QUIET) ( \
- printf ';; @license Apache-2.0\n' ; \
- printf ';;\n' ; \
- printf ';; Copyright (c) %s The Stdlib Authors.\n' "$(shell date +%Y)" ; \
- printf ';;\n' ; \
- printf ';; Licensed under the Apache License, Version 2.0 (the \"License\");\n' ; \
- printf ';; you may not use this file except in compliance with the License.\n' ; \
- printf ';; You may obtain a copy of the License at\n' ; \
- printf ';;\n' ; \
- printf ';; http://www.apache.org/licenses/LICENSE-2.0\n' ; \
- printf ';;\n' ; \
- printf ';; Unless required by applicable law or agreed to in writing, software\n' ; \
- printf ';; distributed under the License is distributed on an \"AS IS\" BASIS,\n' ; \
- printf ';; WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n' ; \
- printf ';; See the License for the specific language governing permissions and\n' ; \
- printf ';; limitations under the License.\n' ; \
- printf '\n' ; \
- cat $@ \
- ) > $@.tmp && mv $@.tmp $@
-
$(wat_targets): %.wat: %.wasm
- $(QUIET) $(WASM_TO_WAT) -o $@ $<
+ $(QUIET) $(WASM_TO_WAT) -o $@ $(wasm_targets)
#/
# Compiles WebAssembly binary files to JavaScript.