diff --git a/lib/node_modules/@stdlib/stats/nanmeanwd/README.md b/lib/node_modules/@stdlib/stats/nanmeanwd/README.md
new file mode 100644
index 000000000000..52503c9a8cab
--- /dev/null
+++ b/lib/node_modules/@stdlib/stats/nanmeanwd/README.md
@@ -0,0 +1,314 @@
+
+
+# nanmeanwd
+
+> Compute the [arithmetic mean][arithmetic-mean] along one or more [ndarray][@stdlib/ndarray/ctor] dimensions, ignoring `NaN` values and using Welford's algorithm.
+
+
+
+The [arithmetic mean][arithmetic-mean] is defined as
+
+
+
+```math
+\mu = \frac{1}{n} \sum_{i=0}^{n-1} x_i
+```
+
+
+
+
+
+
+
+
+
+
+
+## Usage
+
+```javascript
+var nanmeanwd = require( '@stdlib/stats/nanmeanwd' );
+```
+
+#### nanmeanwd( x\[, options] )
+
+Computes the [arithmetic mean][arithmetic-mean] along one or more [ndarray][@stdlib/ndarray/ctor] dimensions, ignoring `NaN` values and using Welford's algorithm.
+
+```javascript
+var array = require( '@stdlib/ndarray/array' );
+
+var x = array( [ 1.0, NaN, -2.0, 4.0 ] );
+
+var y = nanmeanwd( x );
+// returns
+
+var v = y.get();
+// returns 1.0
+```
+
+The function has the following parameters:
+
+- **x**: input [ndarray][@stdlib/ndarray/ctor]. Must have a real-valued or "generic" [data type][@stdlib/ndarray/dtypes].
+- **options**: function options (_optional_).
+
+The function accepts the following options:
+
+- **dims**: list of dimensions over which to perform a reduction. If not provided, the function performs a reduction over all elements in a provided input [ndarray][@stdlib/ndarray/ctor].
+- **dtype**: output ndarray [data type][@stdlib/ndarray/dtypes]. Must be a real-valued floating-point or "generic" [data type][@stdlib/ndarray/dtypes].
+- **keepdims**: boolean indicating whether the reduced dimensions should be included in the returned [ndarray][@stdlib/ndarray/ctor] as singleton dimensions. Default: `false`.
+
+By default, the function performs a reduction over all elements in a provided input [ndarray][@stdlib/ndarray/ctor]. To perform a reduction over specific dimensions, provide a `dims` option.
+
+```javascript
+var ndarray2array = require( '@stdlib/ndarray/to-array' );
+var array = require( '@stdlib/ndarray/array' );
+
+var x = array( [ 1.0, NaN, -2.0, 4.0 ], {
+ 'shape': [ 2, 2 ],
+ 'order': 'row-major'
+});
+var v = ndarray2array( x );
+// returns [ [ 1.0, NaN ], [ -2.0, 4.0 ] ]
+
+var y = nanmeanwd( x, {
+ 'dims': [ 0 ]
+});
+// returns
+
+v = ndarray2array( y );
+// returns [ -0.5, 4.0 ]
+
+y = nanmeanwd( x, {
+ 'dims': [ 1 ]
+});
+// returns
+
+v = ndarray2array( y );
+// returns [ 1.0, 1.0 ]
+
+y = nanmeanwd( x, {
+ 'dims': [ 0, 1 ]
+});
+// returns
+
+v = y.get();
+// returns 1.0
+```
+
+By default, the function excludes reduced dimensions from the output [ndarray][@stdlib/ndarray/ctor]. To include the reduced dimensions as singleton dimensions, set the `keepdims` option to `true`.
+
+```javascript
+var ndarray2array = require( '@stdlib/ndarray/to-array' );
+var array = require( '@stdlib/ndarray/array' );
+
+var x = array( [ 1.0, NaN, -2.0, 4.0 ], {
+ 'shape': [ 2, 2 ],
+ 'order': 'row-major'
+});
+
+var v = ndarray2array( x );
+// returns [ [ 1.0, NaN ], [ -2.0, 4.0 ] ]
+
+var y = nanmeanwd( x, {
+ 'dims': [ 0 ],
+ 'keepdims': true
+});
+// returns
+
+v = ndarray2array( y );
+// returns [ [ -0.5, 4.0 ] ]
+
+y = nanmeanwd( x, {
+ 'dims': [ 1 ],
+ 'keepdims': true
+});
+// returns
+
+v = ndarray2array( y );
+// returns [ [ 1.0 ], [ 1.0 ] ]
+
+y = nanmeanwd( x, {
+ 'dims': [ 0, 1 ],
+ 'keepdims': true
+});
+// returns
+
+v = ndarray2array( y );
+// returns [ [ 1.0 ] ]
+```
+
+By default, the function returns an [ndarray][@stdlib/ndarray/ctor] having a [data type][@stdlib/ndarray/dtypes] determined by the function's output data type [policy][@stdlib/ndarray/output-dtype-policies]. To override the default behavior, set the `dtype` option.
+
+```javascript
+var getDType = require( '@stdlib/ndarray/dtype' );
+var array = require( '@stdlib/ndarray/array' );
+
+var x = array( [ 1.0, NaN, -2.0, 4.0 ], {
+ 'dtype': 'generic'
+});
+
+var y = nanmeanwd( x, {
+ 'dtype': 'float64'
+});
+// returns
+
+var dt = String( getDType( y ) );
+// returns 'float64'
+```
+
+#### nanmeanwd.assign( x, out\[, options] )
+
+Computes the [arithmetic mean][arithmetic-mean] along one or more [ndarray][@stdlib/ndarray/ctor] dimensions, ignoring `NaN` values and using Welford's algorithm, and assigns results to a provided output [ndarray][@stdlib/ndarray/ctor].
+
+```javascript
+var array = require( '@stdlib/ndarray/array' );
+var zeros = require( '@stdlib/ndarray/zeros' );
+
+var x = array( [ 1.0, NaN, -2.0, 4.0 ] );
+var y = zeros( [] );
+
+var out = nanmeanwd.assign( x, y );
+// returns
+
+var v = out.get();
+// returns 1.0
+
+var bool = ( out === y );
+// returns true
+```
+
+The method has the following parameters:
+
+- **x**: input [ndarray][@stdlib/ndarray/ctor]. Must have a real-valued or generic [data type][@stdlib/ndarray/dtypes].
+- **out**: output [ndarray][@stdlib/ndarray/ctor].
+- **options**: function options (_optional_).
+
+The method accepts the following options:
+
+- **dims**: list of dimensions over which to perform a reduction. If not provided, the function performs a reduction over all elements in a provided input [ndarray][@stdlib/ndarray/ctor].
+
+
+
+
+
+
+
+## Notes
+
+- This implementation uses Welford's algorithm for computing the arithmetic mean. Welford's algorithm can provide improved numerical stability compared to naive summation approaches and can be particularly beneficial when wanting to minimize the accumulation of floating-point errors when dealing with values of varying magnitudes.
+- Setting the `keepdims` option to `true` can be useful when wanting to ensure that the output [ndarray][@stdlib/ndarray/ctor] is [broadcast-compatible][@stdlib/ndarray/base/broadcast-shapes] with ndarrays having the same shape as the input [ndarray][@stdlib/ndarray/ctor].
+- The output data type [policy][@stdlib/ndarray/output-dtype-policies] only applies to the main function and specifies that, by default, the function must return an [ndarray][@stdlib/ndarray/ctor] having a real-valued floating-point or "generic" [data type][@stdlib/ndarray/dtypes]. For the `assign` method, the output [ndarray][@stdlib/ndarray/ctor] is allowed to have any supported output [data type][@stdlib/ndarray/dtypes].
+
+
+
+
+
+
+
+## Examples
+
+
+
+```javascript
+var uniform = require( '@stdlib/random/base/uniform' );
+var filledarrayBy = require( '@stdlib/array/filled-by' );
+var bernoulli = require( '@stdlib/random/base/bernoulli' );
+var getDType = require( '@stdlib/ndarray/dtype' );
+var ndarray2array = require( '@stdlib/ndarray/to-array' );
+var ndarray = require( '@stdlib/ndarray/ctor' );
+var nanmeanwd = require( '@stdlib/stats/nanmeanwd' );
+
+function rand() {
+ if ( bernoulli( 0.8 ) < 1 ) {
+ return NaN;
+ }
+ return uniform( 0.0, 20.0 );
+}
+
+// Generate an array of random numbers:
+var xbuf = filledarrayBy( 25, 'generic', rand );
+
+// Wrap in an ndarray:
+var x = new ndarray( 'generic', xbuf, [ 5, 5 ], [ 5, 1 ], 0, 'row-major' );
+console.log( ndarray2array( x ) );
+
+// Perform a reduction:
+var y = nanmeanwd( x, {
+ 'dims': [ 0 ]
+});
+
+// Resolve the output array data type:
+var dt = getDType( y );
+console.log( dt );
+
+// Print the results:
+console.log( ndarray2array( y ) );
+```
+
+
+
+
+
+* * *
+
+
+
+## References
+
+- Welford, B. P. 1962. "Note on a Method for Calculating Corrected Sums of Squares and Products." _Technometrics_ 4 (3). Taylor & Francis: 419–20. doi:[10.1080/00401706.1962.10490022][@welford:1962a].
+- van Reeken, A. J. 1968. "Letters to the Editor: Dealing with Neely's Algorithms." _Communications of the ACM_ 11 (3): 149–50. doi:[10.1145/362929.362961][@vanreeken:1968a].
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+[@stdlib/ndarray/ctor]: https://github.com/stdlib-js/stdlib/tree/develop/lib/node_modules/%40stdlib/ndarray/ctor
+
+[@stdlib/ndarray/dtypes]: https://github.com/stdlib-js/stdlib/tree/develop/lib/node_modules/%40stdlib/ndarray/dtypes
+
+[@stdlib/ndarray/output-dtype-policies]: https://github.com/stdlib-js/stdlib/tree/develop/lib/node_modules/%40stdlib/ndarray/output-dtype-policies
+
+[@stdlib/ndarray/base/broadcast-shapes]: https://github.com/stdlib-js/stdlib/tree/develop/lib/node_modules/%40stdlib/ndarray/base/broadcast-shapes
+
+[arithmetic-mean]: https://en.wikipedia.org/wiki/Arithmetic_mean
+
+[@welford:1962a]: https://doi.org/10.1080/00401706.1962.10490022
+
+[@vanreeken:1968a]: https://doi.org/10.1145/362929.362961
+
+
+
+
diff --git a/lib/node_modules/@stdlib/stats/nanmeanwd/benchmark/benchmark.assign.js b/lib/node_modules/@stdlib/stats/nanmeanwd/benchmark/benchmark.assign.js
new file mode 100644
index 000000000000..96970bcc0efb
--- /dev/null
+++ b/lib/node_modules/@stdlib/stats/nanmeanwd/benchmark/benchmark.assign.js
@@ -0,0 +1,126 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+'use strict';
+
+// MODULES //
+
+var bench = require( '@stdlib/bench' );
+var isnan = require( '@stdlib/math/base/assert/is-nan' );
+var pow = require( '@stdlib/math/base/special/pow' );
+var uniform = require( '@stdlib/random/base/uniform' );
+var bernoulli = require( '@stdlib/random/base/bernoulli' );
+var filledarrayBy = require( '@stdlib/array/filled-by' );
+var zeros = require( '@stdlib/array/zeros' );
+var ndarray = require( '@stdlib/ndarray/base/ctor' );
+var pkg = require( './../package.json' ).name;
+var nanmeanwd = require( './../lib' );
+
+
+// VARIABLES //
+
+var options = {
+ 'dtype': 'float64'
+};
+
+
+// FUNCTIONS //
+
+/**
+* Returns a random number.
+*
+* @private
+* @returns {number} random number
+*/
+function rand() {
+ if ( bernoulli( 0.8 ) < 1 ) {
+ return NaN;
+ }
+ return uniform( -50.0, 50.0 );
+}
+
+/**
+* Creates a benchmark function.
+*
+* @private
+* @param {PositiveInteger} len - array length
+* @returns {Function} benchmark function
+*/
+function createBenchmark( len ) {
+ var out;
+ var x;
+
+ x = filledarrayBy( len, options.dtype, rand );
+ x = new ndarray( options.dtype, x, [ len ], [ 1 ], 0, 'row-major' );
+
+ out = new ndarray( options.dtype, zeros( 1, options.dtype ), [], [ 0 ], 0, 'row-major' );
+
+ return benchmark;
+
+ /**
+ * Benchmark function.
+ *
+ * @private
+ * @param {Benchmark} b - benchmark instance
+ */
+ function benchmark( b ) {
+ var o;
+ var i;
+
+ b.tic();
+ for ( i = 0; i < b.iterations; i++ ) {
+ o = nanmeanwd.assign( x, out );
+ if ( typeof o !== 'object' ) {
+ b.fail( 'should return an ndarray' );
+ }
+ }
+ b.toc();
+ if ( isnan( o.get() ) ) {
+ b.fail( 'should not return NaN' );
+ }
+ b.pass( 'benchmark finished' );
+ b.end();
+ }
+}
+
+
+// MAIN //
+
+/**
+* Main execution sequence.
+*
+* @private
+*/
+function main() {
+ var len;
+ var min;
+ var max;
+ var f;
+ var i;
+
+ min = 1; // 10^min
+ max = 6; // 10^max
+
+ for ( i = min; i <= max; i++ ) {
+ len = pow( 10, i );
+ f = createBenchmark( len );
+ bench( pkg+':assign:dtype='+options.dtype+',len='+len, f );
+ }
+}
+
+main();
diff --git a/lib/node_modules/@stdlib/stats/nanmeanwd/benchmark/benchmark.js b/lib/node_modules/@stdlib/stats/nanmeanwd/benchmark/benchmark.js
new file mode 100644
index 000000000000..146af80ac0fc
--- /dev/null
+++ b/lib/node_modules/@stdlib/stats/nanmeanwd/benchmark/benchmark.js
@@ -0,0 +1,120 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+'use strict';
+
+// MODULES //
+
+var bench = require( '@stdlib/bench' );
+var isnan = require( '@stdlib/math/base/assert/is-nan' );
+var pow = require( '@stdlib/math/base/special/pow' );
+var uniform = require( '@stdlib/random/base/uniform' );
+var bernoulli = require( '@stdlib/random/base/bernoulli' );
+var filledarrayBy = require( '@stdlib/array/filled-by' );
+var ndarray = require( '@stdlib/ndarray/base/ctor' );
+var pkg = require( './../package.json' ).name;
+var nanmeanwd = require( './../lib' );
+
+
+// VARIABLES //
+
+var options = {
+ 'dtype': 'float64'
+};
+
+
+// FUNCTIONS //
+
+/**
+* Returns a random number.
+*
+* @private
+* @returns {number} random number
+*/
+function rand() {
+ if ( bernoulli( 0.8 ) < 1 ) {
+ return NaN;
+ }
+ return uniform( -50.0, 50.0 );
+}
+
+/**
+* Creates a benchmark function.
+*
+* @private
+* @param {PositiveInteger} len - array length
+* @returns {Function} benchmark function
+*/
+function createBenchmark( len ) {
+ var x = filledarrayBy( len, options.dtype, rand );
+ x = new ndarray( options.dtype, x, [ len ], [ 1 ], 0, 'row-major' );
+
+ return benchmark;
+
+ /**
+ * Benchmark function.
+ *
+ * @private
+ * @param {Benchmark} b - benchmark instance
+ */
+ function benchmark( b ) {
+ var o;
+ var i;
+
+ b.tic();
+ for ( i = 0; i < b.iterations; i++ ) {
+ o = nanmeanwd( x );
+ if ( typeof o !== 'object' ) {
+ b.fail( 'should return an ndarray' );
+ }
+ }
+ b.toc();
+ if ( isnan( o.get() ) ) {
+ b.fail( 'should not return NaN' );
+ }
+ b.pass( 'benchmark finished' );
+ b.end();
+ }
+}
+
+
+// MAIN //
+
+/**
+* Main execution sequence.
+*
+* @private
+*/
+function main() {
+ var len;
+ var min;
+ var max;
+ var f;
+ var i;
+
+ min = 1; // 10^min
+ max = 6; // 10^max
+
+ for ( i = min; i <= max; i++ ) {
+ len = pow( 10, i );
+ f = createBenchmark( len );
+ bench( pkg+':dtype='+options.dtype+',len='+len, f );
+ }
+}
+
+main();
diff --git a/lib/node_modules/@stdlib/stats/nanmeanwd/docs/repl.txt b/lib/node_modules/@stdlib/stats/nanmeanwd/docs/repl.txt
new file mode 100644
index 000000000000..461e89b3b5a9
--- /dev/null
+++ b/lib/node_modules/@stdlib/stats/nanmeanwd/docs/repl.txt
@@ -0,0 +1,79 @@
+
+{{alias}}( x[, options] )
+ Computes the arithmetic mean along one or more ndarray dimensions, using
+ Welford's algorithm and ignoring NaN values.
+
+ Parameters
+ ----------
+ x: ndarray
+ Input array. Must have a real-valued or "generic" data type.
+
+ options: Object (optional)
+ Function options.
+
+ options.dtype: string (optional)
+ Output array data type. Must be a real-valued floating-point or
+ "generic" data type.
+
+ options.dims: Array (optional)
+ List of dimensions over which to perform a reduction. If not provided,
+ the function performs a reduction over all elements in a provided input
+ ndarray.
+
+ options.keepdims: boolean (optional)
+ Boolean indicating whether the reduced dimensions should be included in
+ the returned ndarray as singleton dimensions. Default: false.
+
+ Returns
+ -------
+ out: ndarray
+ Output array.
+
+ Examples
+ --------
+ > var x = {{alias:@stdlib/ndarray/array}}( [ 1.0, NaN, -2.0, 4.0 ] );
+ > var y = {{alias}}( x );
+ > var v = y.get()
+ 1.0
+
+
+{{alias}}.assign( x, out[, options] )
+ Computes the arithmetic mean along one or more ndarray dimensions, using
+ Welford's algorithm and ignoring NaN values, and assigns results to a
+ provided output ndarray.
+
+ Parameters
+ ----------
+ x: ndarray
+ Input array. Must have a real-valued or "generic" data type.
+
+ out: ndarray
+ Output array.
+
+ options: Object (optional)
+ Function options.
+
+ options.dims: Array (optional)
+ List of dimensions over which to perform a reduction. If not provided,
+ the function performs a reduction over all elements in a provided input
+ ndarray.
+
+ Returns
+ -------
+ out: ndarray
+ Output array.
+
+ Examples
+ --------
+ > var x = {{alias:@stdlib/ndarray/array}}( [ 1.0, NaN, -2.0, 4.0 ] );
+ > var out = {{alias:@stdlib/ndarray/zeros}}( [] );
+ > var y = {{alias}}.assign( x, out )
+
+ > var bool = ( out === y )
+ true
+ > var v = out.get()
+ 1.0
+
+ See Also
+ --------
+
diff --git a/lib/node_modules/@stdlib/stats/nanmeanwd/docs/types/index.d.ts b/lib/node_modules/@stdlib/stats/nanmeanwd/docs/types/index.d.ts
new file mode 100644
index 000000000000..b88148339a8d
--- /dev/null
+++ b/lib/node_modules/@stdlib/stats/nanmeanwd/docs/types/index.d.ts
@@ -0,0 +1,151 @@
+/*
+* @license Apache-2.0
+*
+* Copyright (c) 2025 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+// TypeScript Version: 4.1
+
+///
+
+import { ArrayLike } from '@stdlib/types/array';
+import { RealFloatingPointAndGenericDataType as DataType, typedndarray } from '@stdlib/types/ndarray';
+
+/**
+* Input array.
+*/
+type InputArray = typedndarray;
+
+/**
+* Output array.
+*/
+type OutputArray = typedndarray;
+
+/**
+* Interface defining "base" options.
+*/
+interface BaseOptions {
+ /**
+ * List of dimensions over which to perform a reduction.
+ */
+ dims?: ArrayLike;
+}
+
+/**
+* Interface defining options.
+*/
+interface Options extends BaseOptions {
+ /**
+ * Output array data type.
+ */
+ dtype?: DataType;
+
+ /**
+ * Boolean indicating whether the reduced dimensions should be included in the returned array as singleton dimensions. Default: `false`.
+ */
+ keepdims?: boolean;
+}
+
+/**
+* Interface for performing a reduction on an ndarray.
+*/
+interface Unary {
+ /**
+ * Computes the arithmetic mean along one or more ndarray dimensions, ignoring `NaN` values and using Welford's algorithm.
+ *
+ * @param x - input ndarray
+ * @param options - function options
+ * @returns output ndarray
+ *
+ * @example
+ * var array = require( '@stdlib/ndarray/array' );
+ *
+ * var x = array( [ 1.0, NaN, -2.0, 4.0 ] );
+ *
+ * var y = nanmeanwd( x );
+ * // returns
+ *
+ * var v = y.get();
+ * // returns 1.0
+ */
+ ( x: InputArray, options?: Options ): OutputArray; // NOTE: we lose type specificity here, but retaining specificity would likely be difficult and/or tedious to completely enumerate, as the output ndarray data type is dependent on how `x` interacts with output data type policy and whether that policy has been overridden by `options.dtype`.
+
+ /**
+ * Computes the arithmetic mean along one or more ndarray dimensions, ignoring `NaN` values and using Welford's algorithm, and assigns results to a provided output ndarray.
+ *
+ * @param x - input ndarray
+ * @param out - output ndarray
+ * @param options - function options
+ * @returns output ndarray
+ *
+ * @example
+ * var array = require( '@stdlib/ndarray/array' );
+ * var zeros = require( '@stdlib/ndarray/zeros' );
+ *
+ * var x = array( [ 1.0, NaN, -2.0, 4.0 ] );
+ * var y = zeros( [] );
+ *
+ * var out = nanmeanwd.assign( x, y );
+ * // returns
+ *
+ * var v = out.get();
+ * // returns 1.0
+ *
+ * var bool = ( out === y );
+ * // returns true
+ */
+ assign = OutputArray>( x: InputArray, out: U, options?: BaseOptions ): U;
+}
+
+/**
+* Computes the arithmetic mean along one or more ndarray dimensions, ignoring `NaN` values and using Welford's algorithm.
+*
+* @param x - input ndarray
+* @param options - function options
+* @returns output ndarray
+*
+* @example
+* var array = require( '@stdlib/ndarray/array' );
+*
+* var x = array( [ 1.0, NaN, -2.0, 4.0 ] );
+*
+* var y = nanmeanwd( x );
+* // returns
+*
+* var v = y.get();
+* // returns 1.0
+*
+* @example
+* var array = require( '@stdlib/ndarray/array' );
+* var zeros = require( '@stdlib/ndarray/zeros' );
+*
+* var x = array( [ 1.0, NaN, -2.0, 4.0 ] );
+* var y = zeros( [] );
+*
+* var out = nanmeanwd.assign( x, y );
+* // returns
+*
+* var v = out.get();
+* // returns 1.0
+*
+* var bool = ( out === y );
+* // returns true
+*/
+declare const nanmeanwd: Unary;
+
+
+// EXPORTS //
+
+export = nanmeanwd;
diff --git a/lib/node_modules/@stdlib/stats/nanmeanwd/docs/types/test.ts b/lib/node_modules/@stdlib/stats/nanmeanwd/docs/types/test.ts
new file mode 100644
index 000000000000..e8c7d902ba05
--- /dev/null
+++ b/lib/node_modules/@stdlib/stats/nanmeanwd/docs/types/test.ts
@@ -0,0 +1,225 @@
+/*
+* @license Apache-2.0
+*
+* Copyright (c) 2025 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+/* eslint-disable space-in-parens */
+
+///
+
+import zeros = require( '@stdlib/ndarray/zeros' );
+import nanmeanwd = require( './index' );
+
+
+// TESTS //
+
+// The function returns an ndarray...
+{
+ const x = zeros( [ 2, 2 ], {
+ 'dtype': 'float64'
+ });
+
+ nanmeanwd( x ); // $ExpectType OutputArray
+ nanmeanwd( x, {} ); // $ExpectType OutputArray
+}
+
+// The compiler throws an error if the function is provided a first argument which is not an ndarray...
+{
+ nanmeanwd( '5' ); // $ExpectError
+ nanmeanwd( 5 ); // $ExpectError
+ nanmeanwd( true ); // $ExpectError
+ nanmeanwd( false ); // $ExpectError
+ nanmeanwd( null ); // $ExpectError
+ nanmeanwd( void 0 ); // $ExpectError
+ nanmeanwd( {} ); // $ExpectError
+ nanmeanwd( ( x: number ): number => x ); // $ExpectError
+
+ nanmeanwd( '5', {} ); // $ExpectError
+ nanmeanwd( 5, {} ); // $ExpectError
+ nanmeanwd( true, {} ); // $ExpectError
+ nanmeanwd( false, {} ); // $ExpectError
+ nanmeanwd( null, {} ); // $ExpectError
+ nanmeanwd( void 0, {} ); // $ExpectError
+ nanmeanwd( {}, {} ); // $ExpectError
+ nanmeanwd( ( x: number ): number => x, {} ); // $ExpectError
+}
+
+// The compiler throws an error if the function is provided a second argument which is not an object...
+{
+ const x = zeros( [ 2, 2 ], {
+ 'dtype': 'float64'
+ });
+
+ nanmeanwd( x, '5' ); // $ExpectError
+ nanmeanwd( x, true ); // $ExpectError
+ nanmeanwd( x, false ); // $ExpectError
+ nanmeanwd( x, null ); // $ExpectError
+ nanmeanwd( x, [] ); // $ExpectError
+ nanmeanwd( x, ( x: number ): number => x ); // $ExpectError
+}
+
+// The compiler throws an error if the function is provided an invalid `dtype` option...
+{
+ const x = zeros( [ 2, 2 ], {
+ 'dtype': 'float64'
+ });
+
+ nanmeanwd( x, { 'dtype': '5' } ); // $ExpectError
+ nanmeanwd( x, { 'dtype': 5 } ); // $ExpectError
+ nanmeanwd( x, { 'dtype': true } ); // $ExpectError
+ nanmeanwd( x, { 'dtype': false } ); // $ExpectError
+ nanmeanwd( x, { 'dtype': null } ); // $ExpectError
+ nanmeanwd( x, { 'dtype': [] } ); // $ExpectError
+ nanmeanwd( x, { 'dtype': {} } ); // $ExpectError
+ nanmeanwd( x, { 'dtype': ( x: number ): number => x } ); // $ExpectError
+}
+
+// The compiler throws an error if the function is provided an invalid `keepdims` option...
+{
+ const x = zeros( [ 2, 2 ], {
+ 'dtype': 'float64'
+ });
+
+ nanmeanwd( x, { 'keepdims': '5' } ); // $ExpectError
+ nanmeanwd( x, { 'keepdims': 5 } ); // $ExpectError
+ nanmeanwd( x, { 'keepdims': null } ); // $ExpectError
+ nanmeanwd( x, { 'keepdims': [] } ); // $ExpectError
+ nanmeanwd( x, { 'keepdims': {} } ); // $ExpectError
+ nanmeanwd( x, { 'keepdims': ( x: number ): number => x } ); // $ExpectError
+}
+
+// The compiler throws an error if the function is provided an invalid `dims` option...
+{
+ const x = zeros( [ 2, 2 ], {
+ 'dtype': 'float64'
+ });
+
+ nanmeanwd( x, { 'dims': '5' } ); // $ExpectError
+ nanmeanwd( x, { 'dims': 5 } ); // $ExpectError
+ nanmeanwd( x, { 'dims': true } ); // $ExpectError
+ nanmeanwd( x, { 'dims': false } ); // $ExpectError
+ nanmeanwd( x, { 'dims': null } ); // $ExpectError
+ nanmeanwd( x, { 'dims': {} } ); // $ExpectError
+ nanmeanwd( x, { 'dims': ( x: number ): number => x } ); // $ExpectError
+}
+
+// The compiler throws an error if the function is provided an unsupported number of arguments...
+{
+ const x = zeros( [ 2, 2 ], {
+ 'dtype': 'float64'
+ });
+
+ nanmeanwd(); // $ExpectError
+ nanmeanwd( x, {}, {} ); // $ExpectError
+}
+
+// Attached to the function is an `assign` method which returns an ndarray...
+{
+ const x = zeros( [ 2, 2 ], {
+ 'dtype': 'float64'
+ });
+
+ nanmeanwd.assign( x, x ); // $ExpectType float64ndarray
+ nanmeanwd.assign( x, x, {} ); // $ExpectType float64ndarray
+}
+
+// The compiler throws an error if the `assign` method is provided a first argument which is not an ndarray...
+{
+ const x = zeros( [ 2, 2 ], {
+ 'dtype': 'float64'
+ });
+
+ nanmeanwd.assign( '5', x ); // $ExpectError
+ nanmeanwd.assign( 5, x ); // $ExpectError
+ nanmeanwd.assign( true, x ); // $ExpectError
+ nanmeanwd.assign( false, x ); // $ExpectError
+ nanmeanwd.assign( null, x ); // $ExpectError
+ nanmeanwd.assign( void 0, x ); // $ExpectError
+ nanmeanwd.assign( {}, x ); // $ExpectError
+ nanmeanwd.assign( ( x: number ): number => x, x ); // $ExpectError
+
+ nanmeanwd.assign( '5', x, {} ); // $ExpectError
+ nanmeanwd.assign( 5, x, {} ); // $ExpectError
+ nanmeanwd.assign( true, x, {} ); // $ExpectError
+ nanmeanwd.assign( false, x, {} ); // $ExpectError
+ nanmeanwd.assign( null, x, {} ); // $ExpectError
+ nanmeanwd.assign( void 0, x, {} ); // $ExpectError
+ nanmeanwd.assign( {}, x, {} ); // $ExpectError
+ nanmeanwd.assign( ( x: number ): number => x, x, {} ); // $ExpectError
+}
+
+// The compiler throws an error if the `assign` method is provided a second argument which is not an ndarray...
+{
+ const x = zeros( [ 2, 2 ], {
+ 'dtype': 'float64'
+ });
+
+ nanmeanwd.assign( x, '5' ); // $ExpectError
+ nanmeanwd.assign( x, 5 ); // $ExpectError
+ nanmeanwd.assign( x, true ); // $ExpectError
+ nanmeanwd.assign( x, false ); // $ExpectError
+ nanmeanwd.assign( x, null ); // $ExpectError
+ nanmeanwd.assign( x, void 0 ); // $ExpectError
+ nanmeanwd.assign( x, ( x: number ): number => x ); // $ExpectError
+
+ nanmeanwd.assign( x, '5', {} ); // $ExpectError
+ nanmeanwd.assign( x, 5, {} ); // $ExpectError
+ nanmeanwd.assign( x, true, {} ); // $ExpectError
+ nanmeanwd.assign( x, false, {} ); // $ExpectError
+ nanmeanwd.assign( x, null, {} ); // $ExpectError
+ nanmeanwd.assign( x, void 0, {} ); // $ExpectError
+ nanmeanwd.assign( x, ( x: number ): number => x, {} ); // $ExpectError
+}
+
+// The compiler throws an error if the `assign` method is provided a third argument which is not an object...
+{
+ const x = zeros( [ 2, 2 ], {
+ 'dtype': 'float64'
+ });
+
+ nanmeanwd.assign( x, x, '5' ); // $ExpectError
+ nanmeanwd.assign( x, x, true ); // $ExpectError
+ nanmeanwd.assign( x, x, false ); // $ExpectError
+ nanmeanwd.assign( x, x, null ); // $ExpectError
+ nanmeanwd.assign( x, x, [] ); // $ExpectError
+ nanmeanwd.assign( x, x, ( x: number ): number => x ); // $ExpectError
+}
+
+// The compiler throws an error if the `assign` method is provided an invalid `dims` option...
+{
+ const x = zeros( [ 2, 2 ], {
+ 'dtype': 'float64'
+ });
+
+ nanmeanwd.assign( x, x, { 'dims': '5' } ); // $ExpectError
+ nanmeanwd.assign( x, x, { 'dims': 5 } ); // $ExpectError
+ nanmeanwd.assign( x, x, { 'dims': true } ); // $ExpectError
+ nanmeanwd.assign( x, x, { 'dims': false } ); // $ExpectError
+ nanmeanwd.assign( x, x, { 'dims': null } ); // $ExpectError
+ nanmeanwd.assign( x, x, { 'dims': {} } ); // $ExpectError
+ nanmeanwd.assign( x, x, { 'dims': ( x: number ): number => x } ); // $ExpectError
+}
+
+// The compiler throws an error if the `assign` method is provided an unsupported number of arguments...
+{
+ const x = zeros( [ 2, 2 ], {
+ 'dtype': 'float64'
+ });
+
+ nanmeanwd.assign(); // $ExpectError
+ nanmeanwd.assign( x ); // $ExpectError
+ nanmeanwd.assign( x, x, {}, {} ); // $ExpectError
+}
diff --git a/lib/node_modules/@stdlib/stats/nanmeanwd/examples/index.js b/lib/node_modules/@stdlib/stats/nanmeanwd/examples/index.js
new file mode 100644
index 000000000000..91cb0732eff3
--- /dev/null
+++ b/lib/node_modules/@stdlib/stats/nanmeanwd/examples/index.js
@@ -0,0 +1,53 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+'use strict';
+
+var uniform = require( '@stdlib/random/base/uniform' );
+var filledarrayBy = require( '@stdlib/array/filled-by' );
+var bernoulli = require( '@stdlib/random/base/bernoulli' );
+var getDType = require( '@stdlib/ndarray/dtype' );
+var ndarray2array = require( '@stdlib/ndarray/to-array' );
+var ndarray = require( '@stdlib/ndarray/ctor' );
+var nanmeanwd = require( './../lib' );
+
+function rand() {
+ if ( bernoulli( 0.8 ) < 1 ) {
+ return NaN;
+ }
+ return uniform( 0.0, 20.0 );
+}
+
+// Generate an array of random numbers:
+var xbuf = filledarrayBy( 25, 'generic', rand );
+
+// Wrap in an ndarray:
+var x = new ndarray( 'generic', xbuf, [ 5, 5 ], [ 5, 1 ], 0, 'row-major' );
+console.log( ndarray2array( x ) );
+
+// Perform a reduction:
+var y = nanmeanwd( x, {
+ 'dims': [ 0 ]
+});
+
+// Resolve the output array data type:
+var dt = getDType( y );
+console.log( dt );
+
+// Print the results:
+console.log( ndarray2array( y ) );
diff --git a/lib/node_modules/@stdlib/stats/nanmeanwd/lib/index.js b/lib/node_modules/@stdlib/stats/nanmeanwd/lib/index.js
new file mode 100644
index 000000000000..7fcdcf87d04e
--- /dev/null
+++ b/lib/node_modules/@stdlib/stats/nanmeanwd/lib/index.js
@@ -0,0 +1,63 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+'use strict';
+
+/**
+* Compute the arithmetic mean along one or more ndarray dimensions, ignoring `NaN` values and using Welford's algorithm.
+*
+* @module @stdlib/stats/nanmeanwd
+*
+* @example
+* var Float64Array = require( '@stdlib/array/float64' );
+* var ndarray = require( '@stdlib/ndarray/ctor' );
+* var nanmeanwd = require( '@stdlib/stats/nanmeanwd' );
+*
+* // Create a data buffer:
+* var xbuf = new Float64Array( [ 1.0, 2.0, NaN, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ] );
+*
+* // Define the shape of the input array:
+* var sh = [ 3, 1, 2 ];
+*
+* // Define the array strides:
+* var sx = [ 4, 4, 1 ];
+*
+* // Define the index offset:
+* var ox = 1;
+*
+* // Create an input ndarray:
+* var x = new ndarray( 'float64', xbuf, sh, sx, ox, 'row-major' );
+*
+* // Perform reduction:
+* var out = nanmeanwd( x );
+* // returns
+*
+* var v = out.get();
+* // returns 7.2
+*/
+
+// MODULES //
+
+var main = require( './main.js' );
+
+
+// EXPORTS //
+
+module.exports = main;
+
+// exports: { "assign": "main.assign" }
diff --git a/lib/node_modules/@stdlib/stats/nanmeanwd/lib/main.js b/lib/node_modules/@stdlib/stats/nanmeanwd/lib/main.js
new file mode 100644
index 000000000000..9ab900820de8
--- /dev/null
+++ b/lib/node_modules/@stdlib/stats/nanmeanwd/lib/main.js
@@ -0,0 +1,101 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+'use strict';
+
+// MODULES //
+
+var dtypes = require( '@stdlib/ndarray/dtypes' );
+var gnanmeanwd = require( '@stdlib/stats/base/ndarray/nanmeanwd' );
+var dnanmeanwd = require( '@stdlib/stats/base/ndarray/dnanmeanwd' );
+var snanmeanwd = require( '@stdlib/stats/base/ndarray/snanmeanwd' );
+var factory = require( '@stdlib/ndarray/base/unary-reduce-strided1d-dispatch-factory' );
+
+
+// VARIABLES //
+
+var idtypes = dtypes( 'real_and_generic' );
+var odtypes = dtypes( 'real_floating_point_and_generic' );
+var policies = {
+ 'output': 'real_floating_point_and_generic',
+ 'casting': 'none'
+};
+var table = {
+ 'types': [
+ 'float64', // input
+ 'float32' // input
+ ],
+ 'fcns': [
+ dnanmeanwd,
+ snanmeanwd
+ ],
+ 'default': gnanmeanwd
+};
+
+
+// MAIN //
+
+/**
+* Computes the arithmetic mean along one or more ndarray dimensions, ignoring `NaN` values and using Welford's algorithm.
+*
+* @name nanmeanwd
+* @type {Function}
+* @param {ndarray} x - input ndarray
+* @param {Options} [options] - function options
+* @param {IntegerArray} [options.dims] - list of dimensions over which to perform a reduction
+* @param {boolean} [options.keepdims=false] - boolean indicating whether the reduced dimensions should be included in the returned ndarray as singleton dimensions
+* @param {string} [options.dtype] - output ndarray data type
+* @throws {TypeError} first argument must be an ndarray-like object
+* @throws {TypeError} options argument must be an object
+* @throws {RangeError} dimension indices must not exceed input ndarray bounds
+* @throws {RangeError} number of dimension indices must not exceed the number of input ndarray dimensions
+* @throws {Error} must provide valid options
+* @returns {ndarray} output ndarray
+*
+* @example
+* var Float64Array = require( '@stdlib/array/float64' );
+* var ndarray = require( '@stdlib/ndarray/ctor' );
+*
+* // Create a data buffer:
+* var xbuf = new Float64Array( [ 1.0, 2.0, NaN, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ] );
+*
+* // Define the shape of the input array:
+* var sh = [ 3, 1, 2 ];
+*
+* // Define the array strides:
+* var sx = [ 4, 4, 1 ];
+*
+* // Define the index offset:
+* var ox = 1;
+*
+* // Create an input ndarray:
+* var x = new ndarray( 'float64', xbuf, sh, sx, ox, 'row-major' );
+*
+* // Perform reduction:
+* var out = nanmeanwd( x );
+* // returns
+*
+* var v = out.get();
+* // returns 7.2
+*/
+var nanmeanwd = factory( table, [ idtypes ], odtypes, policies );
+
+
+// EXPORTS //
+
+module.exports = nanmeanwd;
diff --git a/lib/node_modules/@stdlib/stats/nanmeanwd/package.json b/lib/node_modules/@stdlib/stats/nanmeanwd/package.json
new file mode 100644
index 000000000000..9122a6c37956
--- /dev/null
+++ b/lib/node_modules/@stdlib/stats/nanmeanwd/package.json
@@ -0,0 +1,67 @@
+{
+ "name": "@stdlib/stats/nanmeanwd",
+ "version": "0.0.0",
+ "description": "Compute the arithmetic mean along one or more ndarray dimensions, ignoring `NaN` values and using Welford's algorithm.",
+ "license": "Apache-2.0",
+ "author": {
+ "name": "The Stdlib Authors",
+ "url": "https://github.com/stdlib-js/stdlib/graphs/contributors"
+ },
+ "contributors": [
+ {
+ "name": "The Stdlib Authors",
+ "url": "https://github.com/stdlib-js/stdlib/graphs/contributors"
+ }
+ ],
+ "main": "./lib",
+ "directories": {
+ "benchmark": "./benchmark",
+ "doc": "./docs",
+ "example": "./examples",
+ "lib": "./lib",
+ "test": "./test"
+ },
+ "types": "./docs/types",
+ "scripts": {},
+ "homepage": "https://github.com/stdlib-js/stdlib",
+ "repository": {
+ "type": "git",
+ "url": "git://github.com/stdlib-js/stdlib.git"
+ },
+ "bugs": {
+ "url": "https://github.com/stdlib-js/stdlib/issues"
+ },
+ "dependencies": {},
+ "devDependencies": {},
+ "engines": {
+ "node": ">=0.10.0",
+ "npm": ">2.7.0"
+ },
+ "os": [
+ "aix",
+ "darwin",
+ "freebsd",
+ "linux",
+ "macos",
+ "openbsd",
+ "sunos",
+ "win32",
+ "windows"
+ ],
+ "keywords": [
+ "stdlib",
+ "stdmath",
+ "statistics",
+ "stats",
+ "mathematics",
+ "math",
+ "average",
+ "avg",
+ "mean",
+ "arithmetic mean",
+ "welford",
+ "central tendency",
+ "ndarray"
+ ],
+ "__stdlib__": {}
+}
diff --git a/lib/node_modules/@stdlib/stats/nanmeanwd/test/test.assign.js b/lib/node_modules/@stdlib/stats/nanmeanwd/test/test.assign.js
new file mode 100644
index 000000000000..6968575fddab
--- /dev/null
+++ b/lib/node_modules/@stdlib/stats/nanmeanwd/test/test.assign.js
@@ -0,0 +1,728 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+'use strict';
+
+// MODULES //
+
+var tape = require( 'tape' );
+var isSameValue = require( '@stdlib/assert/is-same-value' );
+var ndarray = require( '@stdlib/ndarray/ctor' );
+var zeros = require( '@stdlib/ndarray/zeros' );
+var empty = require( '@stdlib/ndarray/empty' );
+var emptyLike = require( '@stdlib/ndarray/empty-like' );
+var ndarray2array = require( '@stdlib/ndarray/to-array' );
+var nanmeanwd = require( './../lib' ).assign;
+
+
+// TESTS //
+
+tape( 'main export is a function', function test( t ) {
+ t.ok( true, __filename );
+ t.strictEqual( typeof nanmeanwd, 'function', 'main export is a function' );
+ t.end();
+});
+
+tape( 'the function throws an error if provided a first argument which is not an ndarray-like object', function test( t ) {
+ var values;
+ var out;
+ var i;
+
+ out = zeros( [ 2, 2 ], {
+ 'dtype': 'generic'
+ });
+
+ values = [
+ '5',
+ 5,
+ NaN,
+ true,
+ false,
+ null,
+ void 0,
+ [],
+ {},
+ function noop() {}
+ ];
+ for ( i = 0; i < values.length; i++ ) {
+ t.throws( badValue( values[ i ] ), TypeError, 'throws an error when provided ' + values[ i ] );
+ }
+ t.end();
+
+ function badValue( value ) {
+ return function badValue() {
+ nanmeanwd( value, out );
+ };
+ }
+});
+
+tape( 'the function throws an error if provided a first argument which is not an ndarray-like object (options)', function test( t ) {
+ var values;
+ var out;
+ var i;
+
+ out = zeros( [ 2, 2 ], {
+ 'dtype': 'generic'
+ });
+
+ values = [
+ '5',
+ 5,
+ NaN,
+ true,
+ false,
+ null,
+ void 0,
+ [],
+ {},
+ function noop() {}
+ ];
+ for ( i = 0; i < values.length; i++ ) {
+ t.throws( badValue( values[ i ] ), TypeError, 'throws an error when provided ' + values[ i ] );
+ }
+ t.end();
+
+ function badValue( value ) {
+ return function badValue() {
+ nanmeanwd( value, out, {} );
+ };
+ }
+});
+
+tape( 'the function throws an error if provided a first argument which is not an ndarray-like object having a supported data type', function test( t ) {
+ var values;
+ var out;
+ var i;
+
+ out = zeros( [ 2, 2 ], {
+ 'dtype': 'generic'
+ });
+
+ values = [
+ empty( [ 2, 2 ], {
+ 'dtype': 'bool'
+ })
+ ];
+ for ( i = 0; i < values.length; i++ ) {
+ t.throws( badValue( values[ i ] ), TypeError, 'throws an error when provided ' + values[ i ] );
+ }
+ t.end();
+
+ function badValue( value ) {
+ return function badValue() {
+ nanmeanwd( value, out );
+ };
+ }
+});
+
+tape( 'the function throws an error if provided a first argument which is not an ndarray-like object having a supported data type (options)', function test( t ) {
+ var values;
+ var out;
+ var i;
+
+ out = zeros( [ 2, 2 ], {
+ 'dtype': 'generic'
+ });
+
+ values = [
+ empty( [ 2, 2 ], {
+ 'dtype': 'bool'
+ })
+ ];
+ for ( i = 0; i < values.length; i++ ) {
+ t.throws( badValue( values[ i ] ), TypeError, 'throws an error when provided ' + values[ i ] );
+ }
+ t.end();
+
+ function badValue( value ) {
+ return function badValue() {
+ nanmeanwd( value, out, {} );
+ };
+ }
+});
+
+tape( 'the function throws an error if provided a second argument which is not an ndarray-like object', function test( t ) {
+ var values;
+ var x;
+ var i;
+
+ x = zeros( [ 2, 2 ], {
+ 'dtype': 'generic'
+ });
+
+ values = [
+ '5',
+ 5,
+ NaN,
+ true,
+ false,
+ null,
+ void 0,
+ [],
+ {},
+ function noop() {}
+ ];
+ for ( i = 0; i < values.length; i++ ) {
+ t.throws( badValue( values[ i ] ), TypeError, 'throws an error when provided ' + values[ i ] );
+ }
+ t.end();
+
+ function badValue( value ) {
+ return function badValue() {
+ nanmeanwd( x, value );
+ };
+ }
+});
+
+tape( 'the function throws an error if provided a second argument which is not an ndarray-like object (options)', function test( t ) {
+ var values;
+ var x;
+ var i;
+
+ x = zeros( [ 2, 2 ], {
+ 'dtype': 'generic'
+ });
+
+ values = [
+ '5',
+ 5,
+ NaN,
+ true,
+ false,
+ null,
+ void 0,
+ [],
+ {},
+ function noop() {}
+ ];
+ for ( i = 0; i < values.length; i++ ) {
+ t.throws( badValue( values[ i ] ), TypeError, 'throws an error when provided ' + values[ i ] );
+ }
+ t.end();
+
+ function badValue( value ) {
+ return function badValue() {
+ nanmeanwd( x, value, {} );
+ };
+ }
+});
+
+tape( 'the function throws an error if provided a third argument which is not an object', function test( t ) {
+ var values;
+ var out;
+ var x;
+ var i;
+
+ x = zeros( [ 2, 2 ], {
+ 'dtype': 'generic'
+ });
+ out = zeros( [], {
+ 'dtype': 'generic'
+ });
+
+ values = [
+ '5',
+ 5,
+ NaN,
+ true,
+ false,
+ null,
+ void 0,
+ [],
+ function noop() {}
+ ];
+ for ( i = 0; i < values.length; i++ ) {
+ t.throws( badValue( values[ i ] ), TypeError, 'throws an error when provided ' + values[ i ] );
+ }
+ t.end();
+
+ function badValue( value ) {
+ return function badValue() {
+ nanmeanwd( x, out, value );
+ };
+ }
+});
+
+tape( 'the function throws an error if provided a `dims` option which is not an array-like object of integers', function test( t ) {
+ var values;
+ var out;
+ var x;
+ var i;
+
+ x = zeros( [ 2, 2 ], {
+ 'dtype': 'generic'
+ });
+ out = zeros( [], {
+ 'dtype': 'generic'
+ });
+
+ values = [
+ '5',
+ 5,
+ NaN,
+ true,
+ false,
+ null,
+ void 0,
+ [ 'a' ],
+ {},
+ function noop() {}
+ ];
+ for ( i = 0; i < values.length; i++ ) {
+ t.throws( badValue( values[ i ] ), TypeError, 'throws an error when provided ' + values[ i ] );
+ }
+ t.end();
+
+ function badValue( value ) {
+ return function badValue() {
+ nanmeanwd( x, out, {
+ 'dims': value
+ });
+ };
+ }
+});
+
+tape( 'the function throws an error if provided a `dims` option which contains out-of-bounds indices', function test( t ) {
+ var values;
+ var out;
+ var x;
+ var i;
+
+ x = zeros( [ 2, 2 ], {
+ 'dtype': 'generic'
+ });
+ out = zeros( [ 2 ], {
+ 'dtype': 'generic'
+ });
+
+ values = [
+ [ -10 ],
+ [ 20 ]
+ ];
+ for ( i = 0; i < values.length; i++ ) {
+ t.throws( badValue( values[ i ] ), RangeError, 'throws an error when provided ' + values[ i ] );
+ }
+ t.end();
+
+ function badValue( value ) {
+ return function badValue() {
+ nanmeanwd( x, out, {
+ 'dims': value
+ });
+ };
+ }
+});
+
+tape( 'the function throws an error if provided a `dims` option which contains too many indices', function test( t ) {
+ var values;
+ var out;
+ var x;
+ var i;
+
+ x = zeros( [ 2, 2 ], {
+ 'dtype': 'generic'
+ });
+ out = zeros( [], {
+ 'dtype': 'generic'
+ });
+
+ values = [
+ [ 0, 1, 2 ],
+ [ 0, 1, 2, 3 ]
+ ];
+ for ( i = 0; i < values.length; i++ ) {
+ t.throws( badValue( values[ i ] ), RangeError, 'throws an error when provided ' + values[ i ] );
+ }
+ t.end();
+
+ function badValue( value ) {
+ return function badValue() {
+ nanmeanwd( x, out, {
+ 'dims': value
+ });
+ };
+ }
+});
+
+tape( 'the function throws an error if provided a `dims` option which contains duplicate indices', function test( t ) {
+ var values;
+ var out;
+ var x;
+ var i;
+
+ x = zeros( [ 2, 2 ], {
+ 'dtype': 'generic'
+ });
+ out = zeros( [], {
+ 'dtype': 'generic'
+ });
+
+ values = [
+ [ 0, 0 ],
+ [ 1, 1 ],
+ [ 0, 1, 0 ],
+ [ 1, 0, 1 ]
+ ];
+ for ( i = 0; i < values.length; i++ ) {
+ t.throws( badValue( values[ i ] ), Error, 'throws an error when provided ' + values[ i ] );
+ }
+ t.end();
+
+ function badValue( value ) {
+ return function badValue() {
+ nanmeanwd( x, out, {
+ 'dims': value
+ });
+ };
+ }
+});
+
+tape( 'the function throws an error if provided an output array which has an invalid shape (default)', function test( t ) {
+ var values;
+ var x;
+ var i;
+
+ x = zeros( [ 2, 2 ], {
+ 'dtype': 'generic'
+ });
+
+ values = [
+ [ 2, 2 ],
+ [ 2 ],
+ [ 4, 4 ],
+ [ 4 ],
+ [ 1 ],
+ [ 1, 1 ]
+ ];
+ for ( i = 0; i < values.length; i++ ) {
+ t.throws( badValue( values[ i ] ), Error, 'throws an error when provided ' + values[ i ] );
+ }
+ t.end();
+
+ function badValue( value ) {
+ return function badValue() {
+ var out = zeros( value, {
+ 'dtype': 'generic'
+ });
+ nanmeanwd( x, out );
+ };
+ }
+});
+
+tape( 'the function throws an error if provided an output array which has an invalid shape (all dimensions)', function test( t ) {
+ var values;
+ var x;
+ var i;
+
+ x = zeros( [ 2, 2 ], {
+ 'dtype': 'generic'
+ });
+
+ values = [
+ [ 2, 2 ],
+ [ 2 ],
+ [ 4, 4 ],
+ [ 4 ],
+ [ 1 ],
+ [ 1, 1 ]
+ ];
+ for ( i = 0; i < values.length; i++ ) {
+ t.throws( badValue( values[ i ] ), Error, 'throws an error when provided ' + values[ i ] );
+ }
+ t.end();
+
+ function badValue( value ) {
+ return function badValue() {
+ var out = zeros( value, {
+ 'dtype': 'generic'
+ });
+ nanmeanwd( x, out, {
+ 'dims': [ 0, 1 ]
+ });
+ };
+ }
+});
+
+tape( 'the function throws an error if provided an output array which has an invalid shape (some dimensions)', function test( t ) {
+ var values;
+ var x;
+ var i;
+
+ x = zeros( [ 2, 2 ], {
+ 'dtype': 'generic'
+ });
+
+ values = [
+ [],
+ [ 4, 4 ],
+ [ 4 ],
+ [ 1 ],
+ [ 1, 1 ]
+ ];
+ for ( i = 0; i < values.length; i++ ) {
+ t.throws( badValue( values[ i ] ), Error, 'throws an error when provided ' + values[ i ] );
+ }
+ t.end();
+
+ function badValue( value ) {
+ return function badValue() {
+ var out = zeros( value, {
+ 'dtype': 'generic'
+ });
+ nanmeanwd( x, out, {
+ 'dims': [ 0 ]
+ });
+ };
+ }
+});
+
+tape( 'the function performs a reduction on an ndarray (default, row-major)', function test( t ) {
+ var expected;
+ var actual;
+ var xbuf;
+ var out;
+ var x;
+
+ xbuf = [ 1.0, NaN, -2.0, 4.0 ];
+ x = new ndarray( 'generic', xbuf, [ 2, 2 ], [ 2, 1 ], 0, 'row-major' );
+
+ out = emptyLike( x, {
+ 'shape': []
+ });
+
+ actual = nanmeanwd( x, out );
+ expected = 1.0;
+
+ t.strictEqual( actual, out, 'returns expected value' );
+ t.strictEqual( actual.get(), expected, 'returns expected value' );
+
+ t.end();
+});
+
+tape( 'the function performs a reduction on an ndarray (default, column-major)', function test( t ) {
+ var expected;
+ var actual;
+ var xbuf;
+ var out;
+ var x;
+
+ xbuf = [ 1.0, NaN, -2.0, 4.0 ];
+ x = new ndarray( 'generic', xbuf, [ 2, 2 ], [ 1, 2 ], 0, 'column-major' );
+
+ out = emptyLike( x, {
+ 'shape': []
+ });
+
+ actual = nanmeanwd( x, out );
+ expected = 1.0;
+
+ t.strictEqual( actual, out, 'returns expected value' );
+ t.strictEqual( actual.get(), expected, 'returns expected value' );
+
+ t.end();
+});
+
+tape( 'the function performs a reduction on an ndarray (all dimensions, row-major)', function test( t ) {
+ var expected;
+ var actual;
+ var xbuf;
+ var out;
+ var x;
+
+ xbuf = [ 1.0, NaN, -2.0, 4.0 ];
+ x = new ndarray( 'generic', xbuf, [ 2, 2 ], [ 2, 1 ], 0, 'row-major' );
+
+ out = emptyLike( x, {
+ 'shape': []
+ });
+
+ actual = nanmeanwd( x, out, {
+ 'dims': [ 0, 1 ]
+ });
+ expected = 1.0;
+
+ t.strictEqual( actual, out, 'returns expected value' );
+ t.strictEqual( actual.get(), expected, 'returns expected value' );
+
+ t.end();
+});
+
+tape( 'the function performs a reduction on an ndarray (all dimensions, column-major)', function test( t ) {
+ var expected;
+ var actual;
+ var xbuf;
+ var out;
+ var x;
+
+ xbuf = [ 1.0, NaN, -2.0, 4.0 ];
+ x = new ndarray( 'generic', xbuf, [ 2, 2 ], [ 1, 2 ], 0, 'column-major' );
+
+ out = emptyLike( x, {
+ 'shape': []
+ });
+
+ actual = nanmeanwd( x, out, {
+ 'dims': [ 0, 1 ]
+ });
+ expected = 1.0;
+
+ t.strictEqual( actual, out, 'returns expected value' );
+ t.strictEqual( actual.get(), expected, 'returns expected value' );
+
+ t.end();
+});
+
+tape( 'the function performs a reduction on an ndarray (no dimensions, row-major)', function test( t ) {
+ var expected;
+ var actual;
+ var xbuf;
+ var out;
+ var x;
+
+ xbuf = [ 1.0, NaN, -2.0, 4.0 ];
+ x = new ndarray( 'generic', xbuf, [ 2, 2 ], [ 2, 1 ], 0, 'row-major' );
+
+ out = emptyLike( x, {
+ 'shape': [ 2, 2 ]
+ });
+
+ actual = nanmeanwd( x, out, {
+ 'dims': []
+ });
+ expected = [ [ 1.0, NaN ], [ -2.0, 4.0 ] ];
+
+ t.strictEqual( actual, out, 'returns expected value' );
+
+ actual = ndarray2array( actual );
+ t.strictEqual( isSameValue( actual[ 0 ][ 0 ], expected[ 0 ][ 0 ] ), true, 'returns expected value' );
+ t.strictEqual( isSameValue( actual[ 0 ][ 1 ], expected[ 0 ][ 1 ] ), true, 'returns expected value' );
+ t.strictEqual( isSameValue( actual[ 1 ][ 0 ], expected[ 1 ][ 0 ] ), true, 'returns expected value' );
+ t.strictEqual( isSameValue( actual[ 1 ][ 1 ], expected[ 1 ][ 1 ] ), true, 'returns expected value' );
+
+ t.end();
+});
+
+tape( 'the function performs a reduction on an ndarray (no dimensions, column-major)', function test( t ) {
+ var expected;
+ var actual;
+ var xbuf;
+ var out;
+ var x;
+
+ xbuf = [ 1.0, NaN, -2.0, 4.0 ];
+ x = new ndarray( 'generic', xbuf, [ 2, 2 ], [ 1, 2 ], 0, 'column-major' );
+
+ out = emptyLike( x, {
+ 'shape': [ 2, 2 ]
+ });
+
+ actual = nanmeanwd( x, out, {
+ 'dims': []
+ });
+ expected = [ [ 1.0, -2.0 ], [ NaN, 4.0 ] ];
+
+ t.strictEqual( actual, out, 'returns expected value' );
+
+ actual = ndarray2array( actual );
+ t.strictEqual( isSameValue( actual[ 0 ][ 0 ], expected[ 0 ][ 0 ] ), true, 'returns expected value' );
+ t.strictEqual( isSameValue( actual[ 0 ][ 1 ], expected[ 0 ][ 1 ] ), true, 'returns expected value' );
+ t.strictEqual( isSameValue( actual[ 1 ][ 0 ], expected[ 1 ][ 0 ] ), true, 'returns expected value' );
+ t.strictEqual( isSameValue( actual[ 1 ][ 1 ], expected[ 1 ][ 1 ] ), true, 'returns expected value' );
+
+ t.end();
+});
+
+tape( 'the function supports specifying reduction dimensions (row-major)', function test( t ) {
+ var expected;
+ var actual;
+ var xbuf;
+ var out;
+ var x;
+
+ xbuf = [ 1.0, NaN, -2.0, 4.0 ];
+ x = new ndarray( 'generic', xbuf, [ 2, 2 ], [ 2, 1 ], 0, 'row-major' );
+
+ out = emptyLike( x, {
+ 'shape': [ 2 ]
+ });
+
+ actual = nanmeanwd( x, out, {
+ 'dims': [ 0 ]
+ });
+ expected = [ -0.5, 4.0 ];
+
+ t.strictEqual( actual, out, 'returns expected value' );
+ t.deepEqual( ndarray2array( actual ), expected, 'returns expected value' );
+
+ xbuf = [ 1.0, NaN, -2.0, 4.0 ];
+ x = new ndarray( 'generic', xbuf, [ 2, 2 ], [ 2, 1 ], 0, 'row-major' );
+
+ out = emptyLike( x, {
+ 'shape': [ 2 ]
+ });
+
+ actual = nanmeanwd( x, out, {
+ 'dims': [ 1 ]
+ });
+ expected = [ 1.0, 1.0 ];
+
+ t.strictEqual( actual, out, 'returns expected value' );
+ t.deepEqual( ndarray2array( actual ), expected, 'returns expected value' );
+
+ t.end();
+});
+
+tape( 'the function supports specifying reduction dimensions (column-major)', function test( t ) {
+ var expected;
+ var actual;
+ var xbuf;
+ var out;
+ var x;
+
+ xbuf = [ 1.0, NaN, -2.0, 4.0 ];
+ x = new ndarray( 'generic', xbuf, [ 2, 2 ], [ 1, 2 ], 0, 'column-major' );
+
+ out = emptyLike( x, {
+ 'shape': [ 2 ]
+ });
+
+ actual = nanmeanwd( x, out, {
+ 'dims': [ 0 ]
+ });
+ expected = [ 1.0, 1.0 ];
+
+ t.strictEqual( actual, out, 'returns expected value' );
+ t.deepEqual( ndarray2array( actual ), expected, 'returns expected value' );
+
+ xbuf = [ 1.0, NaN, -2.0, 4.0 ];
+ x = new ndarray( 'generic', xbuf, [ 2, 2 ], [ 1, 2 ], 0, 'column-major' );
+
+ out = emptyLike( x, {
+ 'shape': [ 2 ]
+ });
+
+ actual = nanmeanwd( x, out, {
+ 'dims': [ 1 ]
+ });
+ expected = [ -0.5, 4.0 ];
+
+ t.strictEqual( actual, out, 'returns expected value' );
+ t.deepEqual( ndarray2array( actual ), expected, 'returns expected value' );
+
+ t.end();
+});
diff --git a/lib/node_modules/@stdlib/stats/nanmeanwd/test/test.js b/lib/node_modules/@stdlib/stats/nanmeanwd/test/test.js
new file mode 100644
index 000000000000..1b2a9ad3074e
--- /dev/null
+++ b/lib/node_modules/@stdlib/stats/nanmeanwd/test/test.js
@@ -0,0 +1,39 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+'use strict';
+
+// MODULES //
+
+var tape = require( 'tape' );
+var isMethod = require( '@stdlib/assert/is-method' );
+var nanmeanwd = require( './../lib' );
+
+
+// TESTS //
+
+tape( 'main export is a function', function test( t ) {
+ t.ok( true, __filename );
+ t.strictEqual( typeof nanmeanwd, 'function', 'main export is a function' );
+ t.end();
+});
+
+tape( 'attached to the main export is an `assign` method', function test( t ) {
+ t.strictEqual( isMethod( nanmeanwd, 'assign' ), true, 'returns expected value' );
+ t.end();
+});
diff --git a/lib/node_modules/@stdlib/stats/nanmeanwd/test/test.main.js b/lib/node_modules/@stdlib/stats/nanmeanwd/test/test.main.js
new file mode 100644
index 000000000000..83d596e7bf0b
--- /dev/null
+++ b/lib/node_modules/@stdlib/stats/nanmeanwd/test/test.main.js
@@ -0,0 +1,774 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+'use strict';
+
+// MODULES //
+
+var tape = require( 'tape' );
+var isndarrayLike = require( '@stdlib/assert/is-ndarray-like' );
+var isSameValue = require( '@stdlib/assert/is-same-value' );
+var ndarray = require( '@stdlib/ndarray/ctor' );
+var zeros = require( '@stdlib/ndarray/zeros' );
+var empty = require( '@stdlib/ndarray/empty' );
+var ndarray2array = require( '@stdlib/ndarray/to-array' );
+var getDType = require( '@stdlib/ndarray/dtype' );
+var getShape = require( '@stdlib/ndarray/shape' );
+var getOrder = require( '@stdlib/ndarray/order' );
+var nanmeanwd = require( './../lib' );
+
+
+// TESTS //
+
+tape( 'main export is a function', function test( t ) {
+ t.ok( true, __filename );
+ t.strictEqual( typeof nanmeanwd, 'function', 'main export is a function' );
+ t.end();
+});
+
+tape( 'the function throws an error if provided a first argument which is not an ndarray-like object', function test( t ) {
+ var values;
+ var i;
+
+ values = [
+ '5',
+ 5,
+ NaN,
+ true,
+ false,
+ null,
+ void 0,
+ [],
+ {},
+ function noop() {}
+ ];
+ for ( i = 0; i < values.length; i++ ) {
+ t.throws( badValue( values[ i ] ), TypeError, 'throws an error when provided ' + values[ i ] );
+ }
+ t.end();
+
+ function badValue( value ) {
+ return function badValue() {
+ nanmeanwd( value );
+ };
+ }
+});
+
+tape( 'the function throws an error if provided a first argument which is not an ndarray-like object (options)', function test( t ) {
+ var values;
+ var i;
+
+ values = [
+ '5',
+ 5,
+ NaN,
+ true,
+ false,
+ null,
+ void 0,
+ [],
+ {},
+ function noop() {}
+ ];
+ for ( i = 0; i < values.length; i++ ) {
+ t.throws( badValue( values[ i ] ), TypeError, 'throws an error when provided ' + values[ i ] );
+ }
+ t.end();
+
+ function badValue( value ) {
+ return function badValue() {
+ nanmeanwd( value, {} );
+ };
+ }
+});
+
+tape( 'the function throws an error if provided a first argument which is not an ndarray-like object having a supported data type', function test( t ) {
+ var values;
+ var i;
+
+ values = [
+ empty( [ 2, 2 ], {
+ 'dtype': 'bool'
+ })
+ ];
+ for ( i = 0; i < values.length; i++ ) {
+ t.throws( badValue( values[ i ] ), TypeError, 'throws an error when provided ' + values[ i ] );
+ }
+ t.end();
+
+ function badValue( value ) {
+ return function badValue() {
+ nanmeanwd( value );
+ };
+ }
+});
+
+tape( 'the function throws an error if provided a first argument which is not an ndarray-like object having a supported data type (options)', function test( t ) {
+ var values;
+ var i;
+
+ values = [
+ empty( [ 2, 2 ], {
+ 'dtype': 'bool'
+ })
+ ];
+ for ( i = 0; i < values.length; i++ ) {
+ t.throws( badValue( values[ i ] ), TypeError, 'throws an error when provided ' + values[ i ] );
+ }
+ t.end();
+
+ function badValue( value ) {
+ return function badValue() {
+ nanmeanwd( value, {} );
+ };
+ }
+});
+
+tape( 'the function throws an error if provided a second argument which is not an object', function test( t ) {
+ var values;
+ var x;
+ var i;
+
+ x = zeros( [ 2, 2 ], {
+ 'dtype': 'generic'
+ });
+
+ values = [
+ '5',
+ 5,
+ NaN,
+ true,
+ false,
+ null,
+ void 0,
+ [],
+ function noop() {}
+ ];
+ for ( i = 0; i < values.length; i++ ) {
+ t.throws( badValue( values[ i ] ), TypeError, 'throws an error when provided ' + values[ i ] );
+ }
+ t.end();
+
+ function badValue( value ) {
+ return function badValue() {
+ nanmeanwd( x, value );
+ };
+ }
+});
+
+tape( 'the function throws an error if provided a `dtype` option which is not a supported data type', function test( t ) {
+ var values;
+ var x;
+ var i;
+
+ x = zeros( [ 2, 2 ], {
+ 'dtype': 'generic'
+ });
+
+ values = [
+ 'foo',
+ 'bar',
+ 'beep',
+ 'boop'
+ ];
+ for ( i = 0; i < values.length; i++ ) {
+ t.throws( badValue( values[ i ] ), TypeError, 'throws an error when provided ' + values[ i ] );
+ }
+ t.end();
+
+ function badValue( value ) {
+ return function badValue() {
+ nanmeanwd( x, {
+ 'dtype': value
+ });
+ };
+ }
+});
+
+tape( 'the function throws an error if provided a `keepdims` option which is not a boolean', function test( t ) {
+ var values;
+ var x;
+ var i;
+
+ x = zeros( [ 2, 2 ], {
+ 'dtype': 'generic'
+ });
+
+ values = [
+ '5',
+ 5,
+ NaN,
+ null,
+ void 0,
+ [],
+ {},
+ function noop() {}
+ ];
+ for ( i = 0; i < values.length; i++ ) {
+ t.throws( badValue( values[ i ] ), TypeError, 'throws an error when provided ' + values[ i ] );
+ }
+ t.end();
+
+ function badValue( value ) {
+ return function badValue() {
+ nanmeanwd( x, {
+ 'keepdims': value
+ });
+ };
+ }
+});
+
+tape( 'the function throws an error if provided a `dims` option which is not an array-like object of integers', function test( t ) {
+ var values;
+ var x;
+ var i;
+
+ x = zeros( [ 2, 2 ], {
+ 'dtype': 'generic'
+ });
+
+ values = [
+ '5',
+ 5,
+ NaN,
+ true,
+ false,
+ null,
+ void 0,
+ [ 'a' ],
+ {},
+ function noop() {}
+ ];
+ for ( i = 0; i < values.length; i++ ) {
+ t.throws( badValue( values[ i ] ), TypeError, 'throws an error when provided ' + values[ i ] );
+ }
+ t.end();
+
+ function badValue( value ) {
+ return function badValue() {
+ nanmeanwd( x, {
+ 'dims': value
+ });
+ };
+ }
+});
+
+tape( 'the function throws an error if provided a `dims` option which contains out-of-bounds indices', function test( t ) {
+ var values;
+ var x;
+ var i;
+
+ x = zeros( [ 2, 2 ], {
+ 'dtype': 'generic'
+ });
+
+ values = [
+ [ -10 ],
+ [ 0, 20 ],
+ [ 20 ]
+ ];
+ for ( i = 0; i < values.length; i++ ) {
+ t.throws( badValue( values[ i ] ), RangeError, 'throws an error when provided ' + values[ i ] );
+ }
+ t.end();
+
+ function badValue( value ) {
+ return function badValue() {
+ nanmeanwd( x, {
+ 'dims': value
+ });
+ };
+ }
+});
+
+tape( 'the function throws an error if provided a `dims` option which contains too many indices', function test( t ) {
+ var values;
+ var x;
+ var i;
+
+ x = zeros( [ 2, 2 ], {
+ 'dtype': 'generic'
+ });
+
+ values = [
+ [ 0, 1, 2 ],
+ [ 0, 1, 2, 3 ]
+ ];
+ for ( i = 0; i < values.length; i++ ) {
+ t.throws( badValue( values[ i ] ), RangeError, 'throws an error when provided ' + values[ i ] );
+ }
+ t.end();
+
+ function badValue( value ) {
+ return function badValue() {
+ nanmeanwd( x, {
+ 'dims': value
+ });
+ };
+ }
+});
+
+tape( 'the function throws an error if provided a `dims` option which contains duplicate indices', function test( t ) {
+ var values;
+ var x;
+ var i;
+
+ x = zeros( [ 2, 2 ], {
+ 'dtype': 'generic'
+ });
+
+ values = [
+ [ 0, 0 ],
+ [ 1, 1 ],
+ [ 0, 1, 0 ],
+ [ 1, 0, 1 ]
+ ];
+ for ( i = 0; i < values.length; i++ ) {
+ t.throws( badValue( values[ i ] ), Error, 'throws an error when provided ' + values[ i ] );
+ }
+ t.end();
+
+ function badValue( value ) {
+ return function badValue() {
+ nanmeanwd( x, {
+ 'dims': value
+ });
+ };
+ }
+});
+
+tape( 'the function performs a reduction on an ndarray (default, row-major)', function test( t ) {
+ var expected;
+ var actual;
+ var xbuf;
+ var x;
+
+ xbuf = [ 1.0, NaN, -2.0, 4.0 ];
+ x = new ndarray( 'generic', xbuf, [ 2, 2 ], [ 2, 1 ], 0, 'row-major' );
+
+ actual = nanmeanwd( x );
+ expected = 1.0;
+
+ t.strictEqual( isndarrayLike( actual ), true, 'returns expected value' );
+ t.strictEqual( String( getDType( actual ) ), 'generic', 'returns expected value' );
+ t.deepEqual( getShape( actual ), [], 'returns expected value' );
+ t.strictEqual( getOrder( actual ), getOrder( x ), 'returns expected value' );
+ t.strictEqual( actual.get(), expected, 'returns expected value' );
+
+ t.end();
+});
+
+tape( 'the function performs a reduction on an ndarray (default, column-major)', function test( t ) {
+ var expected;
+ var actual;
+ var xbuf;
+ var x;
+
+ xbuf = [ 1.0, NaN, -2.0, 4.0 ];
+ x = new ndarray( 'generic', xbuf, [ 2, 2 ], [ 1, 2 ], 0, 'column-major' );
+
+ actual = nanmeanwd( x );
+ expected = 1.0;
+
+ t.strictEqual( isndarrayLike( actual ), true, 'returns expected value' );
+ t.strictEqual( String( getDType( actual ) ), 'generic', 'returns expected value' );
+ t.deepEqual( getShape( actual ), [], 'returns expected value' );
+ t.strictEqual( getOrder( actual ), getOrder( x ), 'returns expected value' );
+ t.strictEqual( actual.get(), expected, 'returns expected value' );
+
+ t.end();
+});
+
+tape( 'the function performs a reduction on an ndarray (all dimensions, row-major)', function test( t ) {
+ var expected;
+ var actual;
+ var xbuf;
+ var x;
+
+ xbuf = [ 1.0, NaN, -2.0, 4.0 ];
+ x = new ndarray( 'generic', xbuf, [ 2, 2 ], [ 2, 1 ], 0, 'row-major' );
+
+ actual = nanmeanwd( x, {
+ 'dims': [ 0, 1 ]
+ });
+ expected = 1.0;
+
+ t.strictEqual( isndarrayLike( actual ), true, 'returns expected value' );
+ t.strictEqual( String( getDType( actual ) ), 'generic', 'returns expected value' );
+ t.deepEqual( getShape( actual ), [], 'returns expected value' );
+ t.strictEqual( getOrder( actual ), getOrder( x ), 'returns expected value' );
+ t.strictEqual( actual.get(), expected, 'returns expected value' );
+
+ xbuf = [ 1.0, NaN, -2.0, 4.0 ];
+ x = new ndarray( 'generic', xbuf, [ 2, 2 ], [ 2, 1 ], 0, 'row-major' );
+
+ actual = nanmeanwd( x, {
+ 'dims': [ 0, 1 ],
+ 'keepdims': false
+ });
+ expected = 1.0;
+
+ t.strictEqual( isndarrayLike( actual ), true, 'returns expected value' );
+ t.strictEqual( String( getDType( actual ) ), 'generic', 'returns expected value' );
+ t.deepEqual( getShape( actual ), [], 'returns expected value' );
+ t.strictEqual( getOrder( actual ), getOrder( x ), 'returns expected value' );
+ t.strictEqual( actual.get(), expected, 'returns expected value' );
+
+ xbuf = [ 1.0, NaN, -2.0, 4.0 ];
+ x = new ndarray( 'generic', xbuf, [ 2, 2 ], [ 2, 1 ], 0, 'row-major' );
+
+ actual = nanmeanwd( x, {
+ 'dims': [ 0, 1 ],
+ 'keepdims': true
+ });
+ expected = [ [ 1.0 ] ];
+
+ t.strictEqual( isndarrayLike( actual ), true, 'returns expected value' );
+ t.strictEqual( String( getDType( actual ) ), 'generic', 'returns expected value' );
+ t.deepEqual( getShape( actual ), [ 1, 1 ], 'returns expected value' );
+ t.strictEqual( getOrder( actual ), getOrder( x ), 'returns expected value' );
+ t.deepEqual( ndarray2array( actual ), expected, 'returns expected value' );
+
+ t.end();
+});
+
+tape( 'the function performs a reduction on an ndarray (all dimensions, column-major)', function test( t ) {
+ var expected;
+ var actual;
+ var xbuf;
+ var x;
+
+ xbuf = [ 1.0, NaN, -2.0, 4.0 ];
+ x = new ndarray( 'generic', xbuf, [ 2, 2 ], [ 1, 2 ], 0, 'column-major' );
+
+ actual = nanmeanwd( x, {
+ 'dims': [ 0, 1 ]
+ });
+ expected = 1.0;
+
+ t.strictEqual( isndarrayLike( actual ), true, 'returns expected value' );
+ t.strictEqual( String( getDType( actual ) ), 'generic', 'returns expected value' );
+ t.deepEqual( getShape( actual ), [], 'returns expected value' );
+ t.strictEqual( getOrder( actual ), getOrder( x ), 'returns expected value' );
+ t.strictEqual( actual.get(), expected, 'returns expected value' );
+
+ xbuf = [ 1.0, NaN, -2.0, 4.0 ];
+ x = new ndarray( 'generic', xbuf, [ 2, 2 ], [ 1, 2 ], 0, 'column-major' );
+
+ actual = nanmeanwd( x, {
+ 'dims': [ 0, 1 ],
+ 'keepdims': false
+ });
+ expected = 1.0;
+
+ t.strictEqual( isndarrayLike( actual ), true, 'returns expected value' );
+ t.strictEqual( String( getDType( actual ) ), 'generic', 'returns expected value' );
+ t.deepEqual( getShape( actual ), [], 'returns expected value' );
+ t.strictEqual( getOrder( actual ), getOrder( x ), 'returns expected value' );
+ t.strictEqual( actual.get(), expected, 'returns expected value' );
+
+ xbuf = [ 1.0, NaN, -2.0, 4.0 ];
+ x = new ndarray( 'generic', xbuf, [ 2, 2 ], [ 1, 2 ], 0, 'column-major' );
+
+ actual = nanmeanwd( x, {
+ 'dims': [ 0, 1 ],
+ 'keepdims': true
+ });
+ expected = [ [ 1.0 ] ];
+
+ t.strictEqual( isndarrayLike( actual ), true, 'returns expected value' );
+ t.strictEqual( String( getDType( actual ) ), 'generic', 'returns expected value' );
+ t.deepEqual( getShape( actual ), [ 1, 1 ], 'returns expected value' );
+ t.strictEqual( getOrder( actual ), getOrder( x ), 'returns expected value' );
+ t.deepEqual( ndarray2array( actual ), expected, 'returns expected value' );
+
+ t.end();
+});
+
+tape( 'the function performs a reduction on an ndarray (no dimensions, row-major)', function test( t ) {
+ var expected;
+ var actual;
+ var xbuf;
+ var x;
+
+ xbuf = [ 1.0, NaN, -2.0, 4.0 ];
+ x = new ndarray( 'generic', xbuf, [ 2, 2 ], [ 2, 1 ], 0, 'row-major' );
+
+ actual = nanmeanwd( x, {
+ 'dims': [],
+ 'keepdims': false
+ });
+ expected = [ [ 1.0, NaN ], [ -2.0, 4.0 ] ];
+
+ t.strictEqual( isndarrayLike( actual ), true, 'returns expected value' );
+ t.strictEqual( String( getDType( actual ) ), 'generic', 'returns expected value' );
+ t.deepEqual( getShape( actual ), [ 2, 2 ], 'returns expected value' );
+ t.strictEqual( getOrder( actual ), getOrder( x ), 'returns expected value' );
+
+ actual = ndarray2array( actual );
+ t.strictEqual( isSameValue( actual[ 0 ][ 0 ], expected[ 0 ][ 0 ] ), true, 'returns expected value' );
+ t.strictEqual( isSameValue( actual[ 0 ][ 1 ], expected[ 0 ][ 1 ] ), true, 'returns expected value' );
+ t.strictEqual( isSameValue( actual[ 1 ][ 0 ], expected[ 1 ][ 0 ] ), true, 'returns expected value' );
+ t.strictEqual( isSameValue( actual[ 1 ][ 1 ], expected[ 1 ][ 1 ] ), true, 'returns expected value' );
+
+ xbuf = [ 1.0, NaN, -2.0, 4.0 ];
+ x = new ndarray( 'generic', xbuf, [ 2, 2 ], [ 2, 1 ], 0, 'row-major' );
+
+ actual = nanmeanwd( x, {
+ 'dims': [],
+ 'keepdims': true
+ });
+ expected = [ [ 1.0, NaN ], [ -2.0, 4.0 ] ];
+
+ t.strictEqual( isndarrayLike( actual ), true, 'returns expected value' );
+ t.strictEqual( String( getDType( actual ) ), 'generic', 'returns expected value' );
+ t.deepEqual( getShape( actual ), [ 2, 2 ], 'returns expected value' );
+ t.strictEqual( getOrder( actual ), getOrder( x ), 'returns expected value' );
+
+ actual = ndarray2array( actual );
+ t.strictEqual( isSameValue( actual[ 0 ][ 0 ], expected[ 0 ][ 0 ] ), true, 'returns expected value' );
+ t.strictEqual( isSameValue( actual[ 0 ][ 1 ], expected[ 0 ][ 1 ] ), true, 'returns expected value' );
+ t.strictEqual( isSameValue( actual[ 1 ][ 0 ], expected[ 1 ][ 0 ] ), true, 'returns expected value' );
+ t.strictEqual( isSameValue( actual[ 1 ][ 1 ], expected[ 1 ][ 1 ] ), true, 'returns expected value' );
+
+ t.end();
+});
+
+tape( 'the function performs a reduction on an ndarray (no dimensions, column-major)', function test( t ) {
+ var expected;
+ var actual;
+ var xbuf;
+ var x;
+
+ xbuf = [ 1.0, NaN, -2.0, 4.0 ];
+ x = new ndarray( 'generic', xbuf, [ 2, 2 ], [ 1, 2 ], 0, 'column-major' );
+
+ actual = nanmeanwd( x, {
+ 'dims': [],
+ 'keepdims': false
+ });
+ expected = [ [ 1.0, -2.0 ], [ NaN, 4.0 ] ];
+
+ t.strictEqual( isndarrayLike( actual ), true, 'returns expected value' );
+ t.strictEqual( String( getDType( actual ) ), 'generic', 'returns expected value' );
+ t.deepEqual( getShape( actual ), [ 2, 2 ], 'returns expected value' );
+ t.strictEqual( getOrder( actual ), getOrder( x ), 'returns expected value' );
+
+ actual = ndarray2array( actual );
+ t.strictEqual( isSameValue( actual[ 0 ][ 0 ], expected[ 0 ][ 0 ] ), true, 'returns expected value' );
+ t.strictEqual( isSameValue( actual[ 0 ][ 1 ], expected[ 0 ][ 1 ] ), true, 'returns expected value' );
+ t.strictEqual( isSameValue( actual[ 1 ][ 0 ], expected[ 1 ][ 0 ] ), true, 'returns expected value' );
+ t.strictEqual( isSameValue( actual[ 1 ][ 1 ], expected[ 1 ][ 1 ] ), true, 'returns expected value' );
+
+ xbuf = [ 1.0, NaN, -2.0, 4.0 ];
+ x = new ndarray( 'generic', xbuf, [ 2, 2 ], [ 1, 2 ], 0, 'column-major' );
+
+ actual = nanmeanwd( x, {
+ 'dims': [],
+ 'keepdims': true
+ });
+ expected = [ [ 1.0, -2.0 ], [ NaN, 4.0 ] ];
+
+ t.strictEqual( isndarrayLike( actual ), true, 'returns expected value' );
+ t.strictEqual( String( getDType( actual ) ), 'generic', 'returns expected value' );
+ t.deepEqual( getShape( actual ), [ 2, 2 ], 'returns expected value' );
+ t.strictEqual( getOrder( actual ), getOrder( x ), 'returns expected value' );
+
+ actual = ndarray2array( actual );
+ t.strictEqual( isSameValue( actual[ 0 ][ 0 ], expected[ 0 ][ 0 ] ), true, 'returns expected value' );
+ t.strictEqual( isSameValue( actual[ 0 ][ 1 ], expected[ 0 ][ 1 ] ), true, 'returns expected value' );
+ t.strictEqual( isSameValue( actual[ 1 ][ 0 ], expected[ 1 ][ 0 ] ), true, 'returns expected value' );
+ t.strictEqual( isSameValue( actual[ 1 ][ 1 ], expected[ 1 ][ 1 ] ), true, 'returns expected value' );
+
+ t.end();
+});
+
+tape( 'the function supports specifying reduction dimensions (row-major)', function test( t ) {
+ var expected;
+ var actual;
+ var xbuf;
+ var x;
+
+ xbuf = [ 1.0, NaN, -2.0, 4.0 ];
+ x = new ndarray( 'generic', xbuf, [ 2, 2 ], [ 2, 1 ], 0, 'row-major' );
+
+ actual = nanmeanwd( x, {
+ 'dims': [ 0 ],
+ 'keepdims': false
+ });
+ expected = [ -0.5, 4.0 ];
+
+ t.strictEqual( isndarrayLike( actual ), true, 'returns expected value' );
+ t.strictEqual( String( getDType( actual ) ), 'generic', 'returns expected value' );
+ t.deepEqual( getShape( actual ), [ 2 ], 'returns expected value' );
+ t.strictEqual( getOrder( actual ), getOrder( x ), 'returns expected value' );
+ t.deepEqual( ndarray2array( actual ), expected, 'returns expected value' );
+
+ xbuf = [ 1.0, NaN, -2.0, 4.0 ];
+ x = new ndarray( 'generic', xbuf, [ 2, 2 ], [ 2, 1 ], 0, 'row-major' );
+
+ actual = nanmeanwd( x, {
+ 'dims': [ 0 ],
+ 'keepdims': true
+ });
+ expected = [ [ -0.5, 4.0 ] ];
+
+ t.strictEqual( isndarrayLike( actual ), true, 'returns expected value' );
+ t.strictEqual( String( getDType( actual ) ), 'generic', 'returns expected value' );
+ t.deepEqual( getShape( actual ), [ 1, 2 ], 'returns expected value' );
+ t.strictEqual( getOrder( actual ), getOrder( x ), 'returns expected value' );
+ t.deepEqual( ndarray2array( actual ), expected, 'returns expected value' );
+
+ xbuf = [ 1.0, NaN, -2.0, 4.0 ];
+ x = new ndarray( 'generic', xbuf, [ 2, 2 ], [ 2, 1 ], 0, 'row-major' );
+
+ actual = nanmeanwd( x, {
+ 'dims': [ 1 ],
+ 'keepdims': false
+ });
+ expected = [ 1.0, 1.0 ];
+
+ t.strictEqual( isndarrayLike( actual ), true, 'returns expected value' );
+ t.strictEqual( String( getDType( actual ) ), 'generic', 'returns expected value' );
+ t.deepEqual( getShape( actual ), [ 2 ], 'returns expected value' );
+ t.strictEqual( getOrder( actual ), getOrder( x ), 'returns expected value' );
+ t.deepEqual( ndarray2array( actual ), expected, 'returns expected value' );
+
+ xbuf = [ 1.0, NaN, -2.0, 4.0 ];
+ x = new ndarray( 'generic', xbuf, [ 2, 2 ], [ 2, 1 ], 0, 'row-major' );
+
+ actual = nanmeanwd( x, {
+ 'dims': [ 1 ],
+ 'keepdims': true
+ });
+ expected = [ [ 1.0 ], [ 1.0 ] ];
+
+ t.strictEqual( isndarrayLike( actual ), true, 'returns expected value' );
+ t.strictEqual( String( getDType( actual ) ), 'generic', 'returns expected value' );
+ t.deepEqual( getShape( actual ), [ 2, 1 ], 'returns expected value' );
+ t.strictEqual( getOrder( actual ), getOrder( x ), 'returns expected value' );
+ t.deepEqual( ndarray2array( actual ), expected, 'returns expected value' );
+
+ t.end();
+});
+
+tape( 'the function supports specifying reduction dimensions (column-major)', function test( t ) {
+ var expected;
+ var actual;
+ var xbuf;
+ var x;
+
+ xbuf = [ 1.0, NaN, -2.0, 4.0 ];
+ x = new ndarray( 'generic', xbuf, [ 2, 2 ], [ 1, 2 ], 0, 'column-major' );
+
+ actual = nanmeanwd( x, {
+ 'dims': [ 0 ],
+ 'keepdims': false
+ });
+ expected = [ 1.0, 1.0 ];
+
+ t.strictEqual( isndarrayLike( actual ), true, 'returns expected value' );
+ t.strictEqual( String( getDType( actual ) ), 'generic', 'returns expected value' );
+ t.deepEqual( getShape( actual ), [ 2 ], 'returns expected value' );
+ t.strictEqual( getOrder( actual ), getOrder( x ), 'returns expected value' );
+ t.deepEqual( ndarray2array( actual ), expected, 'returns expected value' );
+
+ xbuf = [ 1.0, NaN, -2.0, 4.0 ];
+ x = new ndarray( 'generic', xbuf, [ 2, 2 ], [ 1, 2 ], 0, 'column-major' );
+
+ actual = nanmeanwd( x, {
+ 'dims': [ 0 ],
+ 'keepdims': true
+ });
+ expected = [ [ 1.0, 1.0 ] ];
+
+ t.strictEqual( isndarrayLike( actual ), true, 'returns expected value' );
+ t.strictEqual( String( getDType( actual ) ), 'generic', 'returns expected value' );
+ t.deepEqual( getShape( actual ), [ 1, 2 ], 'returns expected value' );
+ t.strictEqual( getOrder( actual ), getOrder( x ), 'returns expected value' );
+ t.deepEqual( ndarray2array( actual ), expected, 'returns expected value' );
+
+ xbuf = [ 1.0, NaN, -2.0, 4.0 ];
+ x = new ndarray( 'generic', xbuf, [ 2, 2 ], [ 1, 2 ], 0, 'column-major' );
+
+ actual = nanmeanwd( x, {
+ 'dims': [ 1 ],
+ 'keepdims': false
+ });
+ expected = [ -0.5, 4.0 ];
+
+ t.strictEqual( isndarrayLike( actual ), true, 'returns expected value' );
+ t.strictEqual( String( getDType( actual ) ), 'generic', 'returns expected value' );
+ t.deepEqual( getShape( actual ), [ 2 ], 'returns expected value' );
+ t.strictEqual( getOrder( actual ), getOrder( x ), 'returns expected value' );
+ t.deepEqual( ndarray2array( actual ), expected, 'returns expected value' );
+
+ xbuf = [ 1.0, NaN, -2.0, 4.0 ];
+ x = new ndarray( 'generic', xbuf, [ 2, 2 ], [ 1, 2 ], 0, 'column-major' );
+
+ actual = nanmeanwd( x, {
+ 'dims': [ 1 ],
+ 'keepdims': true
+ });
+ expected = [ [ -0.5 ], [ 4.0 ] ];
+
+ t.strictEqual( isndarrayLike( actual ), true, 'returns expected value' );
+ t.strictEqual( String( getDType( actual ) ), 'generic', 'returns expected value' );
+ t.deepEqual( getShape( actual ), [ 2, 1 ], 'returns expected value' );
+ t.strictEqual( getOrder( actual ), getOrder( x ), 'returns expected value' );
+ t.deepEqual( ndarray2array( actual ), expected, 'returns expected value' );
+
+ t.end();
+});
+
+tape( 'the function supports specifying the output array data type', function test( t ) {
+ var expected;
+ var actual;
+ var xbuf;
+ var x;
+
+ xbuf = [ 1.0, NaN, -2.0, 4.0 ];
+ x = new ndarray( 'generic', xbuf, [ 2, 2 ], [ 2, 1 ], 0, 'row-major' );
+
+ actual = nanmeanwd( x, {
+ 'dtype': 'float64'
+ });
+ expected = 1.0;
+
+ t.strictEqual( isndarrayLike( actual ), true, 'returns expected value' );
+ t.strictEqual( String( getDType( actual ) ), 'float64', 'returns expected value' );
+ t.deepEqual( getShape( actual ), [], 'returns expected value' );
+ t.strictEqual( getOrder( actual ), getOrder( x ), 'returns expected value' );
+ t.strictEqual( actual.get(), expected, 'returns expected value' );
+
+ xbuf = [ 1.0, NaN, -2.0, 4.0 ];
+ x = new ndarray( 'generic', xbuf, [ 2, 2 ], [ 1, 2 ], 0, 'column-major' );
+
+ actual = nanmeanwd( x, {
+ 'dtype': 'float64'
+ });
+ expected = 1.0;
+
+ t.strictEqual( isndarrayLike( actual ), true, 'returns expected value' );
+ t.strictEqual( String( getDType( actual ) ), 'float64', 'returns expected value' );
+ t.deepEqual( getShape( actual ), [], 'returns expected value' );
+ t.strictEqual( getOrder( actual ), getOrder( x ), 'returns expected value' );
+ t.strictEqual( actual.get(), expected, 'returns expected value' );
+
+ t.end();
+});