diff --git a/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d-dispatch/README.md b/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d-dispatch/README.md
new file mode 100644
index 000000000000..a149f70d7abe
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d-dispatch/README.md
@@ -0,0 +1,321 @@
+
+
+
+
+# BinaryStrided1dDispatch
+
+> Constructor for performing a binary reduction on two input ndarrays.
+
+
+
+## Usage
+
+```javascript
+var BinaryStrided1dDispatch = require( '@stdlib/ndarray/base/binary-reduce-strided1d-dispatch' );
+```
+
+#### BinaryStrided1dDispatch( table, idtypes, odtypes, policies )
+
+Constructor for performing a binary reduction on two input ndarrays.
+
+```javascript
+var base = require( '@stdlib/blas/base/ndarray/gdot' );
+
+var table = {
+ 'default': base
+};
+
+var dtypes = [ 'float64', 'float32', 'generic' ];
+var policies = {
+ 'output': 'same',
+ 'casting': 'none'
+};
+
+var binary = new BinaryStrided1dDispatch( table, [ dtypes, dtypes ], dtypes, policies );
+```
+
+The constructor has the following parameters:
+
+- **table**: strided binary reduction function dispatch table. Must have the following properties:
+
+ - **default**: default strided binary reduction function which should be invoked when provided ndarrays have data types which do not have a corresponding specialized implementation.
+
+ A dispatch table may have the following additional properties:
+
+ - **types**: one-dimensional list of ndarray data types describing specialized input ndarray argument signatures. Only the input ndarray argument data types should be specified. Output ndarray and additional input ndarray argument data types should be omitted and are not considered during dispatch. The length of `types` must equal twice the number of strided functions specified by `fcns` (i.e., for every pair of input ndarray data types, there must be a corresponding strided binary reduction function in `fcns`).
+ - **fcns**: list of strided binary reduction functions which are specific to specialized input ndarray argument signatures.
+
+- **idtypes**: list containing lists of supported input data types for each input ndarray argument.
+
+- **odtypes**: list of supported output data types.
+
+- **policies**: dispatch policies. Must have the following properties:
+
+ - **output**: output data type [policy][@stdlib/ndarray/output-dtype-policies].
+ - **casting**: input ndarray casting [policy][@stdlib/ndarray/input-casting-policies].
+
+#### BinaryStrided1dDispatch.prototype.apply( x, y\[, ...args]\[, options] )
+
+Performs a binary reduction on two provided input ndarrays.
+
+```javascript
+var ndarray = require( '@stdlib/ndarray/base/ctor' );
+var base = require( '@stdlib/blas/base/ndarray/gdot' );
+
+var table = {
+ 'default': base
+};
+
+var dtypes = [ 'float64', 'float32', 'generic' ];
+var policies = {
+ 'output': 'same',
+ 'casting': 'none'
+};
+
+var binary = new BinaryStrided1dDispatch( table, [ dtypes, dtypes ], dtypes, policies );
+
+var xbuf = [ 4.0, 2.0, -3.0, 5.0, -1.0 ];
+var x = new ndarray( 'generic', xbuf, [ xbuf.length ], [ 1 ], 0, 'row-major' );
+
+var ybuf = [ 2.0, 6.0, -1.0, -4.0, 8.0 ];
+var y = new ndarray( 'generic', ybuf, [ ybuf.length ], [ 1 ], 0, 'row-major' );
+
+var z = binary.apply( x, y );
+// returns
+
+var v = z.get();
+// returns -5.0
+```
+
+The method has the following parameters:
+
+- **x**: first input ndarray.
+- **y**: second input ndarray.
+- **...args**: additional input ndarray arguments (_optional_).
+- **options**: function options (_optional_).
+
+The method accepts the following options:
+
+- **dims**: list of dimensions over which to perform a binary reduction.
+- **dtype**: output ndarray data type. Setting this option, overrides the output data type policy.
+- **keepdims**: boolean indicating whether the reduced dimensions should be included in the returned ndarray as singleton dimensions. Default: `false`.
+
+By default, the method returns an ndarray having a data type determined by the output data type policy. To override the default behavior, set the `dtype` option.
+
+```javascript
+var ndarray = require( '@stdlib/ndarray/base/ctor' );
+var base = require( '@stdlib/blas/base/ndarray/gdot' );
+var getDType = require( '@stdlib/ndarray/dtype' );
+
+var table = {
+ 'default': base
+};
+
+var dtypes = [ 'float64', 'float32', 'generic' ];
+var policies = {
+ 'output': 'same',
+ 'casting': 'none'
+};
+
+var binary = new BinaryStrided1dDispatch( table, [ dtypes, dtypes ], dtypes, policies );
+
+var xbuf = [ 4.0, 2.0, -3.0, 5.0, -1.0 ];
+var x = new ndarray( 'generic', xbuf, [ xbuf.length ], [ 1 ], 0, 'row-major' );
+
+var ybuf = [ 2.0, 6.0, -1.0, -4.0, 8.0 ];
+var y = new ndarray( 'generic', ybuf, [ ybuf.length ], [ 1 ], 0, 'row-major' );
+
+var z = binary.apply( x, y, {
+ 'dtype': 'float64'
+});
+// returns
+
+var dt = getDType( z );
+// returns 'float64'
+```
+
+#### BinaryStrided1dDispatch.prototype.assign( x, y\[, ...args], out\[, options] )
+
+Performs a binary reduction on two provided input ndarrays and assigns results to a provided output ndarray.
+
+```javascript
+var base = require( '@stdlib/blas/base/ndarray/gdot' );
+var dtypes = require( '@stdlib/ndarray/dtypes' );
+var ndarray = require( '@stdlib/ndarray/base/ctor' );
+
+var idt = dtypes( 'real_and_generic' );
+var odt = idt;
+var policies = {
+ 'output': 'same',
+ 'casting': 'none'
+};
+
+var table = {
+ 'default': base
+};
+var binary = new BinaryStrided1dDispatch( table, [ idt, idt ], odt, policies );
+
+var xbuf = [ 4.0, 2.0, -3.0, 5.0, -1.0 ];
+var x = new ndarray( 'generic', xbuf, [ xbuf.length ], [ 1 ], 0, 'row-major' );
+
+var ybuf = [ 2.0, 6.0, -1.0, -4.0, 8.0 ];
+var y = new ndarray( 'generic', ybuf, [ ybuf.length ], [ 1 ], 0, 'row-major' );
+
+var zbuf = [ 0.0 ];
+var z = new ndarray( 'generic', zbuf, [], [ 0 ], 0, 'row-major' );
+
+var out = binary.assign( x, y, z );
+// returns
+
+var v = out.get();
+// returns -5.0
+
+var bool = ( out === z );
+// returns true
+```
+
+The method has the following parameters:
+
+- **x**: first input ndarray.
+- **x**: second input ndarray.
+- **args**: additional input ndarray arguments (_optional_).
+- **out**: output ndarray.
+- **options**: function options (_optional_).
+
+The method accepts the following options:
+
+- **dims**: list of dimensions over which to perform a binary reduction.
+
+
+
+
+
+
+
+## Notes
+
+- A strided binary reduction function should have the following signature:
+
+ ```text
+ f( arrays )
+ ```
+
+ where
+
+ - **arrays**: array containing two input ndarrays, followed by any additional ndarray arguments.
+
+- The output data type policy only applies to the `apply` method. For the `assign` method, the output ndarray is allowed to have any supported output data type.
+
+
+
+
+
+
+
+## Examples
+
+
+
+```javascript
+var ddot = require( '@stdlib/blas/base/ndarray/ddot' );
+var sdot = require( '@stdlib/blas/base/ndarray/sdot' );
+var base = require( '@stdlib/blas/base/ndarray/gdot' );
+var uniform = require( '@stdlib/random/array/uniform' );
+var dtypes = require( '@stdlib/ndarray/dtypes' );
+var dtype = require( '@stdlib/ndarray/dtype' );
+var ndarray2array = require( '@stdlib/ndarray/to-array' );
+var ndarray = require( '@stdlib/ndarray/ctor' );
+var BinaryStrided1dDispatch = require( '@stdlib/ndarray/base/binary-reduce-strided1d-dispatch' );
+
+// Define the supported input and output data types:
+var idt = dtypes( 'real_and_generic' );
+var odt = dtypes( 'real_and_generic' );
+
+// Define dispatch policies:
+var policies = {
+ 'output': 'same',
+ 'casting': 'none'
+};
+
+// Define a dispatch table:
+var table = {
+ 'types': [
+ 'float64', 'float64', // first and second input
+ 'float32', 'float32' // first and second input
+ ],
+ 'fcns': [
+ ddot,
+ sdot
+ ],
+ 'default': base
+};
+
+// Create an interface for performing a binary reduction:
+var dot = new BinaryStrided1dDispatch( table, [ idt, idt ], odt, policies );
+
+// Generate an arrays of random numbers:
+var xbuf = uniform( 100, -1.0, 1.0, {
+ 'dtype': 'generic'
+});
+var ybuf = uniform( 100, -1.0, 1.0, {
+ 'dtype': 'generic'
+});
+
+// Wrap in an ndarrays:
+var x = new ndarray( 'generic', xbuf, [ 10, 10 ], [ 10, 1 ], 0, 'row-major' );
+var y = new ndarray( 'generic', ybuf, [ 10, 10 ], [ 10, 1 ], 0, 'row-major' );
+
+// Perform a binary reduction:
+var z = dot.apply( x, y, {
+ 'dims': [ 0 ]
+});
+
+// Resolve the output array data type:
+var dt = dtype( z );
+console.log( dt );
+
+// Print the results:
+console.log( ndarray2array( z ) );
+```
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+[@stdlib/ndarray/output-dtype-policies]: https://github.com/stdlib-js/stdlib/tree/develop/lib/node_modules/%40stdlib/ndarray/output-dtype-policies
+
+[@stdlib/ndarray/input-casting-policies]: https://github.com/stdlib-js/stdlib/tree/develop/lib/node_modules/%40stdlib/ndarray/input-casting-policies
+
+
+
+
diff --git a/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d-dispatch/benchmark/benchmark.apply.js b/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d-dispatch/benchmark/benchmark.apply.js
new file mode 100644
index 000000000000..94b270f3f428
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d-dispatch/benchmark/benchmark.apply.js
@@ -0,0 +1,124 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+'use strict';
+
+// MODULES //
+
+var bench = require( '@stdlib/bench' );
+var isnan = require( '@stdlib/math/base/assert/is-nan' );
+var pow = require( '@stdlib/math/base/special/pow' );
+var dtypes = require( '@stdlib/ndarray/dtypes' );
+var uniform = require( '@stdlib/random/array/uniform' );
+var ndarray = require( '@stdlib/ndarray/base/ctor' );
+var gdot = require( '@stdlib/blas/base/ndarray/gdot' );
+var pkg = require( './../package.json' ).name;
+var BinaryStrided1dDispatch = require( './../lib' );
+
+
+// FUNCTIONS //
+
+/**
+* Creates a benchmark function.
+*
+* @private
+* @param {PositiveInteger} len - array length
+* @returns {Function} benchmark function
+*/
+function createBenchmark( len ) {
+ var policies;
+ var binary;
+ var table;
+ var dt;
+ var x;
+ var y;
+
+ table = {
+ 'default': gdot
+ };
+ dt = dtypes( 'real_floating_point' );
+ policies = {
+ 'output': 'same',
+ 'casting': 'none'
+ };
+ binary = new BinaryStrided1dDispatch( table, [ dt, dt ], dt, policies );
+
+ x = uniform( len, -50.0, 50.0, {
+ 'dtype': 'float64'
+ });
+ y = uniform( len, -50.0, 50.0, {
+ 'dtype': 'float64'
+ });
+
+ x = new ndarray( 'float64', x, [ len ], [ 1 ], 0, 'row-major' );
+ y = new ndarray( 'float64', y, [ 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 = binary.apply( x, y );
+ 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+':apply:len='+len, f );
+ }
+}
+
+main();
diff --git a/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d-dispatch/benchmark/benchmark.assign.js b/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d-dispatch/benchmark/benchmark.assign.js
new file mode 100644
index 000000000000..49aa6fbbc55b
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d-dispatch/benchmark/benchmark.assign.js
@@ -0,0 +1,128 @@
+/**
+* @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 dtypes = require( '@stdlib/array/dtypes' );
+var uniform = require( '@stdlib/random/array/uniform' );
+var zeros = require( '@stdlib/array/zeros' );
+var ndarray = require( '@stdlib/ndarray/base/ctor' );
+var gdot = require( '@stdlib/blas/base/ndarray/gdot' );
+var pkg = require( './../package.json' ).name;
+var BinaryStrided1dDispatch = require( './../lib' );
+
+
+// FUNCTIONS //
+
+/**
+* Creates a benchmark function.
+*
+* @private
+* @param {PositiveInteger} len - array length
+* @returns {Function} benchmark function
+*/
+function createBenchmark( len ) {
+ var policies;
+ var binary;
+ var table;
+ var out;
+ var dt;
+ var x;
+ var y;
+
+ table = {
+ 'default': gdot
+ };
+ dt = dtypes( 'real_floating_point' );
+ policies = {
+ 'output': 'same',
+ 'casting': 'none'
+ };
+ binary = new BinaryStrided1dDispatch( table, [ dt, dt ], dt, policies );
+
+ x = uniform( len, -50.0, 50.0, {
+ 'dtype': 'float64'
+ });
+ y = uniform( len, -50.0, 50.0, {
+ 'dtype': 'float64'
+ });
+
+ x = new ndarray( 'float64', x, [ len ], [ 1 ], 0, 'row-major' );
+ y = new ndarray( 'float64', y, [ len ], [ 1 ], 0, 'row-major' );
+
+ out = new ndarray( 'float64', zeros( 1, 'float64' ), [], [ 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 = binary.assign( x, y, 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:len='+len, f );
+ }
+}
+
+main();
diff --git a/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d-dispatch/benchmark/benchmark.js b/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d-dispatch/benchmark/benchmark.js
new file mode 100644
index 000000000000..a55287b6712b
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d-dispatch/benchmark/benchmark.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';
+
+// MODULES //
+
+var bench = require( '@stdlib/bench' );
+var gdot = require( '@stdlib/blas/base/ndarray/gdot' );
+var pkg = require( './../package.json' ).name;
+var BinaryStrided1dDispatch = require( './../lib' );
+
+
+// MAIN //
+
+bench( pkg+'::new', function benchmark( b ) {
+ var policies;
+ var dtypes;
+ var table;
+ var v;
+ var i;
+
+ table = {
+ 'default': gdot
+ };
+ dtypes = [
+ 'float64',
+ 'float32'
+ ];
+ policies = {
+ 'output': 'same',
+ 'casting': 'none'
+ };
+
+ b.tic();
+ for ( i = 0; i < b.iterations; i++ ) {
+ v = new BinaryStrided1dDispatch( table, [ dtypes, dtypes ], dtypes, policies ); // eslint-disable-line max-len
+ if ( typeof v !== 'object' ) {
+ b.fail( 'should return an object' );
+ }
+ }
+ b.toc();
+ if ( !( v instanceof BinaryStrided1dDispatch ) ) {
+ b.fail( 'should return an instance' );
+ }
+ b.pass( 'benchmark finished' );
+ b.end();
+});
+
+bench( pkg+'::no_new', function benchmark( b ) {
+ var policies;
+ var dtypes;
+ var table;
+ var fcn;
+ var v;
+ var i;
+
+ table = {
+ 'default': gdot
+ };
+ dtypes = [
+ 'float64',
+ 'float32'
+ ];
+ policies = {
+ 'output': 'same',
+ 'casting': 'none'
+ };
+
+ fcn = BinaryStrided1dDispatch;
+
+ b.tic();
+ for ( i = 0; i < b.iterations; i++ ) {
+ v = fcn( table, [ dtypes, dtypes ], dtypes, policies );
+ if ( typeof v !== 'object' ) {
+ b.fail( 'should return an object' );
+ }
+ }
+ b.toc();
+ if ( !( v instanceof BinaryStrided1dDispatch ) ) {
+ b.fail( 'should return an instance' );
+ }
+ b.pass( 'benchmark finished' );
+ b.end();
+});
diff --git a/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d-dispatch/docs/repl.txt b/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d-dispatch/docs/repl.txt
new file mode 100644
index 000000000000..b2fde4a1c34d
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d-dispatch/docs/repl.txt
@@ -0,0 +1,169 @@
+
+{{alias}}( table, idtypes, odtypes, policies )
+ Returns an ndarray function interface for performing a binary reduction on
+ two input ndarrays.
+
+ Parameters
+ ----------
+ table: Object
+ Dispatch table containing strided binary reduction functions. The table
+ object must have the following property:
+
+ - default: default strided binary reduction function to invoke when
+ provided ndarrays have data types which do not have a corresponding
+ specialized implementation.
+
+ The table may having the following additional properties:
+
+ - types: one-dimensional list of ndarray data types describing
+ specialized input ndarray argument signatures.
+ - fcns: list of strided binary reduction functions which are specific
+ to specialized input ndarray argument signatures.
+
+ A strided binary reduction function should have the following signature:
+
+ f( arrays )
+
+ where
+
+ - arrays: array containing two input ndarrays, followed by any
+ additional ndarray arguments.
+
+ idtypes: Array>
+ List containing lists of supported input array data types for each
+ input ndarray argument.
+
+ odtypes: Array
+ List of supported output array data types.
+
+ policies: Object
+ Dispatch policies. Must have the following properties:
+
+ - output: output data type policy.
+ - casting: input ndarray casting policy.
+
+ Returns
+ -------
+ out: Object
+ Instance having methods for performing a binary reduction.
+
+ Examples
+ --------
+ > var dts = [ 'float64', 'float32', 'generic' ];
+ > var p = { 'output': 'same', 'casting': 'none' };
+ > var t = { 'default': {{alias:@stdlib/blas/base/ndarray/gdot}} };
+ > var out = new {{alias}}( t, [ dts, dts ], dts, p );
+
+
+{{alias}}.prototype.apply( x, y[, ...args][, options] )
+ Performs a binary reduction on two provided input ndarrays.
+
+ Parameters
+ ----------
+ x: ndarray
+ First input array.
+
+ y: ndarray
+ Second input array.
+
+ args: ...ndarray (optional)
+ Additional ndarray arguments.
+
+ options: Object (optional)
+ Function options.
+
+ options.dtype: string (optional)
+ Output array data type. Setting this option overrides the output data
+ type policy.
+
+ options.dims: Array (optional)
+ List of dimensions over which to perform a binary reduction. If not
+ provided, the function performs a binary reduction over all elements in
+ the two provided input ndarrays.
+
+ 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 dts = [ 'float64', 'float32', 'generic' ];
+ > var p = { 'output': 'same', 'casting': 'none' };
+ > var t = { 'default': {{alias:@stdlib/blas/base/ndarray/gdot}} };
+ > var f = new {{alias}}( t, [ dts, dts ], dts, p );
+ > var xbuf = [ -1.0, 2.0, -3.0, -4.0 ];
+ > var ybuf = [ -1.0, 2.0, -3.0, -4.0 ];
+ > var dt = 'generic';
+ > var sh = [ buf.length ];
+ > var sx = [ 1 ];
+ > var oo = 0;
+ > var ord = 'row-major';
+ > var x = new {{alias:@stdlib/ndarray/ctor}}( dt, xbuf, sh, sx, oo, ord );
+ > var y = new {{alias:@stdlib/ndarray/ctor}}( dt, ybuf, sh, sx, oo, ord );
+ > var z = f.apply( x, y );
+ > var v = z.get()
+ 30.0
+
+
+{{alias}}.prototype.assign( x, y[, ...args], out[, options] )
+ Performs a binary reduction on two provided input ndarrays and assigns
+ results to a provided output ndarray.
+
+ Parameters
+ ----------
+ x: ndarray
+ First input array.
+
+ y: ndarray
+ Second input array.
+
+ args: ...ndarray (optional)
+ Additional ndarray arguments.
+
+ out: ndarray
+ Output array.
+
+ options: Object (optional)
+ Function options.
+
+ options.dims: Array (optional)
+ List of dimensions over which to perform a binary reduction. If not
+ provided, the function performs a binary reduction over all elements
+ in the two provided input ndarrays.
+
+ Returns
+ -------
+ out: ndarray
+ Output array.
+
+ Examples
+ --------
+ > var dts = [ 'float64', 'float32', 'generic' ];
+ > var p = { 'output': 'same', 'casting': 'none' };
+ > var t = { 'default': {{alias:@stdlib/blas/base/ndarray/gdot}} };
+ > var f = new {{alias}}( t, [ dts, dts ], dts, 'same' );
+ > var xbuf = [ -1.0, 2.0, -3.0, -4.0 ];
+ > var ybuf = [ -1.0, 2.0, -3.0, -4.0 ];
+ > var dt = 'generic';
+ > var sh = [ buf.length ];
+ > var sx = [ 1 ];
+ > var oo = 0;
+ > var ord = 'row-major';
+ > var x = new {{alias:@stdlib/ndarray/ctor}}( dt, xbuf, sh, sx, oo, ord );
+ > var y = new {{alias:@stdlib/ndarray/ctor}}( dt, ybuf, sh, sx, oo, ord );
+ > var out = {{alias:@stdlib/ndarray/zeros}}( [], { 'dtype': dt } );
+ > var z = f.assign( x, y, out )
+
+ > var bool = ( out === z )
+ true
+ > var v = out.get()
+ 30.0
+
+ See Also
+ --------
+
diff --git a/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d-dispatch/docs/types/index.d.ts b/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d-dispatch/docs/types/index.d.ts
new file mode 100644
index 000000000000..43d2cfb661c0
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d-dispatch/docs/types/index.d.ts
@@ -0,0 +1,423 @@
+/*
+* @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 { OutputPolicy, InputCastingPolicy, 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 binary 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;
+}
+
+/**
+* Strided binary reduction function.
+*
+* @param arrays - input ndarrays
+* @param options - function options
+* @returns result
+*/
+type Binary = ( arrays: [ typedndarray, typedndarray ], options?: unknown ) => U;
+
+/**
+* Strided binary reduction function.
+*
+* @param arrays - input ndarrays
+* @param options - function options
+* @returns result
+*/
+type BinaryWithAdditionalArrays = ( arrays: [ typedndarray, typedndarray, ...Array> ], options?: unknown ) => U;
+
+/**
+* Base dispatch table.
+*/
+interface BaseDispatchTable {
+ /**
+ * Default strided binary reduction function.
+ */
+ default: Binary | BinaryWithAdditionalArrays;
+}
+
+/**
+* Dispatch table.
+*/
+interface DispatchTable extends BaseDispatchTable {
+ /**
+ * One-dimensional list of ndarray data types describing specialized input ndarray argument signatures.
+ */
+ types: ArrayLike;
+
+ /**
+ * List of strided binary reduction functions which are specific to specialized input ndarray argument signatures.
+ */
+ fcns: ArrayLike | BinaryWithAdditionalArrays>;
+}
+
+/**
+* Dispatch policies.
+*/
+interface Policies {
+ /**
+ * Output data type policy.
+ */
+ output: OutputPolicy;
+
+ /**
+ * Input ndarray casting policy.
+ */
+ casting: InputCastingPolicy;
+}
+
+/**
+* Class for performing a binary reduction on two input ndarrays.
+*/
+declare class BinaryStrided1dDispatch {
+ /**
+ * Constructor for performing a binary reduction on two input ndarrays.
+ *
+ * @param table - dispatch table
+ * @param idtypes - list containing lists of supported input data types for each ndarray argument
+ * @param odtypes - list of supported output data types
+ * @param policies - dispatch policies
+ * @returns instance
+ *
+ * @example
+ * var base = require( '@stdlib/blas/base/ndarray/gdot' );
+ * var dtypes = require( '@stdlib/ndarray/dtypes' );
+ * var ndarray = require( '@stdlib/ndarray/base/ctor' );
+ *
+ * var idt = dtypes( 'real_and_generic' );
+ * var odt = idt;
+ * var policies = {
+ * 'output': 'same',
+ * 'casting': 'none'
+ * };
+ *
+ * var table = {
+ * 'default': base
+ * };
+ * var dot = new BinaryStrided1dDispatch( table, [ idt, idt ], odt, policies );
+ *
+ * var xbuf = [ 4.0, 2.0, -3.0, 5.0, -1.0 ];
+ * var x = new ndarray( 'generic', xbuf, [ xbuf.length ], [ 1 ], 0, 'row-major' );
+ *
+ * var ybuf = [ 2.0, 6.0, -1.0, -4.0, 8.0 ];
+ * var y = new ndarray( 'generic', ybuf, [ ybuf.length ], [ 1 ], 0, 'row-major' );
+ *
+ * var z = dot.apply( x, y );
+ * // returns
+ *
+ * var v = z.get();
+ * // returns -5.0
+ */
+ constructor( table: DispatchTable | BaseDispatchTable, idtypes: ArrayLike>, odtypes: ArrayLike, policies: Policies );
+
+ /**
+ * Performs a binary reduction on two provided input ndarrays.
+ *
+ * @param x - first input ndarray
+ * @param y - second input ndarray
+ * @param args - function options and additional ndarray arguments
+ * @returns output ndarray
+ *
+ * @example
+ * var base = require( '@stdlib/blas/base/ndarray/gdot' );
+ * var dtypes = require( '@stdlib/ndarray/dtypes' );
+ * var ndarray = require( '@stdlib/ndarray/base/ctor' );
+ *
+ * var idt = dtypes( 'real_and_generic' );
+ * var odt = idt;
+ * var policies = {
+ * 'output': 'same',
+ * 'casting': 'none'
+ * };
+ *
+ * var table = {
+ * 'default': base
+ * };
+ * var dot = new BinaryStrided1dDispatch( table, [ idt, idt ], odt, policies );
+ *
+ * var xbuf = [ 4.0, 2.0, -3.0, 5.0, -1.0 ];
+ * var x = new ndarray( 'generic', xbuf, [ xbuf.length ], [ 1 ], 0, 'row-major' );
+ *
+ * var ybuf = [ 2.0, 6.0, -1.0, -4.0, 8.0 ];
+ * var y = new ndarray( 'generic', ybuf, [ ybuf.length ], [ 1 ], 0, 'row-major' );
+ *
+ * var z = dot.apply( x, y );
+ * // returns
+ *
+ * var v = z.get();
+ * // returns -5.0
+ */
+ apply( x: InputArray, y: InputArray, ...args: Array | 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`. In principle, as well, based on the policy, it is possible to know more exactly which `InputArray` types are actually allowed.
+
+ /**
+ * Performs a binary reduction on two provided input ndarrays and assigns results to a provided output ndarray.
+ *
+ * @param x - first input ndarray
+ * @param y - second input ndarray
+ * @param out - output ndarray
+ * @param options - function options
+ * @returns output ndarray
+ *
+ * @example
+ * var base = require( '@stdlib/blas/base/ndarray/gdot' );
+ * var dtypes = require( '@stdlib/ndarray/dtypes' );
+ * var ndarray = require( '@stdlib/ndarray/base/ctor' );
+ *
+ * var idt = dtypes( 'real_and_generic' );
+ * var odt = idt;
+ * var policies = {
+ * 'output': 'same',
+ * 'casting': 'none'
+ * };
+ *
+ * var table = {
+ * 'default': base
+ * };
+ * var dot = new BinaryStrided1dDispatch( table, [ idt, idt ], odt, policies );
+ *
+ * var xbuf = [ 4.0, 2.0, -3.0, 5.0, -1.0 ];
+ * var x = new ndarray( 'generic', xbuf, [ xbuf.length ], [ 1 ], 0, 'row-major' );
+ *
+ * var ybuf = [ 2.0, 6.0, -1.0, -4.0, 8.0 ];
+ * var y = new ndarray( 'generic', ybuf, [ ybuf.length ], [ 1 ], 0, 'row-major' );
+ *
+ * var zbuf = [ 0.0 ];
+ * var z = new ndarray( 'generic', zbuf, [], [ 0 ], 0, 'row-major' );
+ *
+ * var out = dot.assign( x, y, z );
+ * // returns
+ *
+ * var v = out.get();
+ * // returns -5.0
+ *
+ * var bool = ( out === z );
+ * // returns true
+ */
+ assign = OutputArray>( x: InputArray, y: InputArray, out: V, options?: BaseOptions ): V;
+
+ /**
+ * Performs a binary reduction on two provided input ndarrays and assigns results to a provided output ndarray.
+ *
+ * @param x - first input ndarray
+ * @param y - second input ndarray
+ * @param z - additional ndarray argument
+ * @param args - output ndarray, additional ndarray arguments, and function options
+ * @returns output ndarray
+ *
+ * @example
+ * var base = require( '@stdlib/blas/base/ndarray/gdot' );
+ * var dtypes = require( '@stdlib/ndarray/dtypes' );
+ * var ndarray = require( '@stdlib/ndarray/base/ctor' );
+ *
+ * var idt = dtypes( 'real_and_generic' );
+ * var odt = idt;
+ * var policies = {
+ * 'output': 'same',
+ * 'casting': 'none'
+ * };
+ *
+ * var table = {
+ * 'default': base
+ * };
+ * var dot = new BinaryStrided1dDispatch( table, [ idt, idt ], odt, policies );
+ *
+ * var xbuf = [ 4.0, 2.0, -3.0, 5.0, -1.0 ];
+ * var x = new ndarray( 'generic', xbuf, [ xbuf.length ], [ 1 ], 0, 'row-major' );
+ *
+ * var ybuf = [ 2.0, 6.0, -1.0, -4.0, 8.0 ];
+ * var y = new ndarray( 'generic', ybuf, [ ybuf.length ], [ 1 ], 0, 'row-major' );
+ *
+ * var zbuf = [ 0.0 ];
+ * var z = new ndarray( 'generic', zbuf, [], [ 0 ], 0, 'row-major' );
+ *
+ * var out = dot.assign( x, y, z );
+ * // returns
+ *
+ * var v = out.get();
+ * // returns -5.0
+ *
+ * var bool = ( out === z );
+ * // returns true
+ */
+ assign = OutputArray>( x: InputArray, y: InputArray, z: InputArray | V, ...args: Array | V | BaseOptions> ): V;
+}
+
+/**
+* Interface defining a constructor which is both "newable" and "callable".
+*/
+interface BinaryStrided1dDispatchConstructor {
+ /**
+ * Constructor for performing a binary reduction on two input ndarrays.
+ *
+ * @param table - dispatch table
+ * @param idtypes - list containing lists of supported input data types for each ndarray argument
+ * @param odtypes - list of supported output data types
+ * @param policies - dispatch policies
+ * @returns instance
+ *
+ * @example
+ * var base = require( '@stdlib/blas/base/ndarray/gdot' );
+ * var dtypes = require( '@stdlib/ndarray/dtypes' );
+ * var ndarray = require( '@stdlib/ndarray/base/ctor' );
+ *
+ * var idt = dtypes( 'real_and_generic' );
+ * var odt = idt;
+ * var policies = {
+ * 'output': 'same',
+ * 'casting': 'none'
+ * };
+ *
+ * var table = {
+ * 'default': base
+ * };
+ * var dot = new BinaryStrided1dDispatch( table, [ idt, idt ], odt, policies );
+ *
+ * var xbuf = [ 4.0, 2.0, -3.0, 5.0, -1.0 ];
+ * var x = new ndarray( 'generic', xbuf, [ xbuf.length ], [ 1 ], 0, 'row-major' );
+ *
+ * var ybuf = [ 2.0, 6.0, -1.0, -4.0, 8.0 ];
+ * var y = new ndarray( 'generic', ybuf, [ ybuf.length ], [ 1 ], 0, 'row-major' );
+ *
+ * var z = dot.apply( x, y );
+ * // returns
+ *
+ * var v = z.get();
+ * // returns -5.0
+ */
+ new( table: DispatchTable | BaseDispatchTable, idtypes: ArrayLike>, odtypes: ArrayLike, policies: Policies ): BinaryStrided1dDispatch;
+
+ /**
+ * Constructor for performing a binary reduction on two input ndarrays.
+ *
+ * @param table - dispatch table
+ * @param idtypes - list containing lists of supported input data types for each ndarray argument
+ * @param odtypes - list of supported output data types
+ * @param policies - dispatch policies
+ * @returns instance
+ *
+ * @example
+ * var base = require( '@stdlib/blas/base/ndarray/gdot' );
+ * var dtypes = require( '@stdlib/ndarray/dtypes' );
+ * var ndarray = require( '@stdlib/ndarray/base/ctor' );
+ *
+ * var idt = dtypes( 'real_and_generic' );
+ * var odt = idt;
+ * var policies = {
+ * 'output': 'same',
+ * 'casting': 'none'
+ * };
+ *
+ * var table = {
+ * 'default': base
+ * };
+ * var dot = new BinaryStrided1dDispatch( table, [ idt, idt ], odt, policies );
+ *
+ * var xbuf = [ 4.0, 2.0, -3.0, 5.0, -1.0 ];
+ * var x = new ndarray( 'generic', xbuf, [ xbuf.length ], [ 1 ], 0, 'row-major' );
+ *
+ * var ybuf = [ 2.0, 6.0, -1.0, -4.0, 8.0 ];
+ * var y = new ndarray( 'generic', ybuf, [ ybuf.length ], [ 1 ], 0, 'row-major' );
+ *
+ * var z = dot.apply( x, y );
+ * // returns
+ *
+ * var v = z.get();
+ * // returns -5.0
+ */
+ ( table: DispatchTable | BaseDispatchTable, idtypes: ArrayLike>, odtypes: ArrayLike, policies: Policies ): BinaryStrided1dDispatch;
+}
+
+/**
+* Constructor for performing a binary reduction on two input ndarrays.
+*
+* @param table - dispatch table
+* @param idtypes - list containing lists of supported input data types for each ndarray argument
+* @param odtypes - list of supported output data types
+* @param policies - dispatch policies
+* @returns instance
+*
+* @example
+* var base = require( '@stdlib/blas/base/ndarray/gdot' );
+* var dtypes = require( '@stdlib/ndarray/dtypes' );
+* var ndarray = require( '@stdlib/ndarray/base/ctor' );
+*
+* var idt = dtypes( 'real_and_generic' );
+* var odt = idt;
+* var policies = {
+* 'output': 'same',
+* 'casting': 'none'
+* };
+*
+* var table = {
+* 'default': base
+* };
+* var dot = new BinaryStrided1dDispatch( table, [ idt, idt ], odt, policies );
+*
+* var xbuf = [ 4.0, 2.0, -3.0, 5.0, -1.0 ];
+* var x = new ndarray( 'generic', xbuf, [ xbuf.length ], [ 1 ], 0, 'row-major' );
+*
+* var ybuf = [ 2.0, 6.0, -1.0, -4.0, 8.0 ];
+* var y = new ndarray( 'generic', ybuf, [ ybuf.length ], [ 1 ], 0, 'row-major' );
+*
+* var z = dot.apply( x, y );
+* // returns
+*
+* var v = z.get();
+* // returns -5.0
+*/
+declare var ctor: BinaryStrided1dDispatchConstructor;
+
+
+// EXPORTS //
+
+export = ctor;
diff --git a/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d-dispatch/docs/types/test.ts b/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d-dispatch/docs/types/test.ts
new file mode 100644
index 000000000000..d6fb76330e00
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d-dispatch/docs/types/test.ts
@@ -0,0 +1,571 @@
+/*
+* @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 @typescript-eslint/no-unused-expressions, space-in-parens */
+
+///
+
+import { DataType, OutputPolicy, InputCastingPolicy } from '@stdlib/types/ndarray';
+import gdot = require( '@stdlib/blas/base/ndarray/gdot' );
+import zeros = require( '@stdlib/ndarray/zeros' );
+import BinaryStrided1dDispatch = require( './index' );
+
+
+// TESTS //
+
+// The function returns an instance for applying a binary function...
+{
+ const dtypes: Array = [ 'float64', 'float32' ];
+ const table = {
+ 'default': gdot
+ };
+ const policies = {
+ 'output': 'same' as OutputPolicy,
+ 'casting': 'none' as InputCastingPolicy
+ };
+
+ new BinaryStrided1dDispatch( table, [ dtypes, dtypes ], dtypes, policies ); // $ExpectType BinaryStrided1dDispatch
+
+ const binary = BinaryStrided1dDispatch;
+ binary( table, [ dtypes, dtypes ], dtypes, policies ); // $ExpectType BinaryStrided1dDispatch
+}
+
+// The compiler throws an error if the function is provided a first argument which is not a dispatch table...
+{
+ const dtypes: Array = [ 'float64', 'float32' ];
+ const policies = {
+ 'output': 'same' as OutputPolicy,
+ 'casting': 'none' as InputCastingPolicy
+ };
+
+ new BinaryStrided1dDispatch( '5', [ dtypes, dtypes ], dtypes, policies ); // $ExpectError
+ new BinaryStrided1dDispatch( 5, [ dtypes, dtypes ], dtypes, policies ); // $ExpectError
+ new BinaryStrided1dDispatch( true, [ dtypes, dtypes ], dtypes, policies ); // $ExpectError
+ new BinaryStrided1dDispatch( false, [ dtypes, dtypes ], dtypes, policies ); // $ExpectError
+ new BinaryStrided1dDispatch( null, [ dtypes, dtypes ], dtypes, policies ); // $ExpectError
+ new BinaryStrided1dDispatch( void 0, [ dtypes, dtypes ], dtypes, policies ); // $ExpectError
+ new BinaryStrided1dDispatch( 'abc', [ dtypes, dtypes ], dtypes, policies ); // $ExpectError
+ new BinaryStrided1dDispatch( [], [ dtypes, dtypes ], dtypes, policies ); // $ExpectError
+ new BinaryStrided1dDispatch( {}, [ dtypes, dtypes ], dtypes, policies ); // $ExpectError
+ new BinaryStrided1dDispatch( ( x: number, y: number ): number => x + y, [ dtypes, dtypes ], dtypes, policies ); // $ExpectError
+
+ const binary = BinaryStrided1dDispatch;
+ binary( '5', [ dtypes, dtypes ], dtypes, policies ); // $ExpectError
+ binary( 5, [ dtypes, dtypes ], dtypes, policies ); // $ExpectError
+ binary( true, [ dtypes, dtypes ], dtypes, policies ); // $ExpectError
+ binary( false, [ dtypes, dtypes ], dtypes, policies ); // $ExpectError
+ binary( null, [ dtypes, dtypes ], dtypes, policies ); // $ExpectError
+ binary( void 0, [ dtypes, dtypes ], dtypes, policies ); // $ExpectError
+ binary( 'abc', [ dtypes, dtypes ], dtypes, policies ); // $ExpectError
+ binary( [], [ dtypes, dtypes ], dtypes, policies ); // $ExpectError
+ binary( {}, [ dtypes, dtypes ], dtypes, policies ); // $ExpectError
+ binary( ( x: number, y: number ): number => x + y, [ dtypes, dtypes ], dtypes, policies ); // $ExpectError
+}
+
+// The compiler throws an error if the function is provided a second argument which is not a a list of data type lists...
+{
+ const dtypes: Array = [ 'float64', 'float32' ];
+ const table = {
+ 'default': gdot
+ };
+ const policies = {
+ 'output': 'same' as OutputPolicy,
+ 'casting': 'none' as InputCastingPolicy
+ };
+
+ new BinaryStrided1dDispatch( table, '5', dtypes, policies ); // $ExpectError
+ new BinaryStrided1dDispatch( table, 5, dtypes, policies ); // $ExpectError
+ new BinaryStrided1dDispatch( table, true, dtypes, policies ); // $ExpectError
+ new BinaryStrided1dDispatch( table, false, dtypes, policies ); // $ExpectError
+ new BinaryStrided1dDispatch( table, null, dtypes, policies ); // $ExpectError
+ new BinaryStrided1dDispatch( table, void 0, dtypes, policies ); // $ExpectError
+ new BinaryStrided1dDispatch( table, 'abc', dtypes, policies ); // $ExpectError
+ new BinaryStrided1dDispatch( table, {}, dtypes, policies ); // $ExpectError
+ new BinaryStrided1dDispatch( table, ( x: number ): number => x, dtypes, policies ); // $ExpectError
+
+ const binary = BinaryStrided1dDispatch;
+ binary( table, '5', dtypes, policies ); // $ExpectError
+ binary( table, 5, dtypes, policies ); // $ExpectError
+ binary( table, true, dtypes, policies ); // $ExpectError
+ binary( table, false, dtypes, policies ); // $ExpectError
+ binary( table, null, dtypes, policies ); // $ExpectError
+ binary( table, void 0, dtypes, policies ); // $ExpectError
+ binary( table, 'abc', dtypes, policies ); // $ExpectError
+ binary( table, {}, dtypes, policies ); // $ExpectError
+ binary( table, ( x: number ): number => x, dtypes, policies ); // $ExpectError
+}
+
+// The compiler throws an error if the function is provided a third argument which is not a list of data types...
+{
+ const dtypes: Array = [ 'float64', 'float32' ];
+ const table = {
+ 'default': gdot
+ };
+ const policies = {
+ 'output': 'same' as OutputPolicy,
+ 'casting': 'none' as InputCastingPolicy
+ };
+
+ new BinaryStrided1dDispatch( table, [ dtypes, dtypes ], '5', policies ); // $ExpectError
+ new BinaryStrided1dDispatch( table, [ dtypes, dtypes ], 5, policies ); // $ExpectError
+ new BinaryStrided1dDispatch( table, [ dtypes, dtypes ], true, policies ); // $ExpectError
+ new BinaryStrided1dDispatch( table, [ dtypes, dtypes ], false, policies ); // $ExpectError
+ new BinaryStrided1dDispatch( table, [ dtypes, dtypes ], null, policies ); // $ExpectError
+ new BinaryStrided1dDispatch( table, [ dtypes, dtypes ], void 0, policies ); // $ExpectError
+ new BinaryStrided1dDispatch( table, [ dtypes, dtypes ], 'abc', policies ); // $ExpectError
+ new BinaryStrided1dDispatch( table, [ dtypes, dtypes ], {}, policies ); // $ExpectError
+ new BinaryStrided1dDispatch( table, [ dtypes, dtypes ], ( x: number ): number => x, policies ); // $ExpectError
+
+ const binary = BinaryStrided1dDispatch;
+ binary( table, [ dtypes, dtypes ], '5', policies ); // $ExpectError
+ binary( table, [ dtypes, dtypes ], 5, policies ); // $ExpectError
+ binary( table, [ dtypes, dtypes ], true, policies ); // $ExpectError
+ binary( table, [ dtypes, dtypes ], false, policies ); // $ExpectError
+ binary( table, [ dtypes, dtypes ], null, policies ); // $ExpectError
+ binary( table, [ dtypes, dtypes ], void 0, policies ); // $ExpectError
+ binary( table, [ dtypes, dtypes ], 'abc', policies ); // $ExpectError
+ binary( table, [ dtypes, dtypes ], {}, policies ); // $ExpectError
+ binary( table, [ dtypes, dtypes ], ( x: number ): number => x, policies ); // $ExpectError
+}
+
+// The compiler throws an error if the function is provided a fourth argument which is invalid policies object...
+{
+ const dtypes: Array = [ 'float64', 'float32' ];
+ const table = {
+ 'default': gdot
+ };
+
+ new BinaryStrided1dDispatch( table, [ dtypes, dtypes ], dtypes, '5' ); // $ExpectError
+ new BinaryStrided1dDispatch( table, [ dtypes, dtypes ], dtypes, 5 ); // $ExpectError
+ new BinaryStrided1dDispatch( table, [ dtypes, dtypes ], dtypes, true ); // $ExpectError
+ new BinaryStrided1dDispatch( table, [ dtypes, dtypes ], dtypes, false ); // $ExpectError
+ new BinaryStrided1dDispatch( table, [ dtypes, dtypes ], dtypes, null ); // $ExpectError
+ new BinaryStrided1dDispatch( table, [ dtypes, dtypes ], dtypes, void 0 ); // $ExpectError
+ new BinaryStrided1dDispatch( table, [ dtypes, dtypes ], dtypes, 'abc' ); // $ExpectError
+ new BinaryStrided1dDispatch( table, [ dtypes, dtypes ], dtypes, {} ); // $ExpectError
+ new BinaryStrided1dDispatch( table, [ dtypes, dtypes ], dtypes, ( x: number ): number => x ); // $ExpectError
+
+ const binary = BinaryStrided1dDispatch;
+ binary( table, [ dtypes, dtypes ], dtypes, '5' ); // $ExpectError
+ binary( table, [ dtypes, dtypes ], dtypes, 5 ); // $ExpectError
+ binary( table, [ dtypes, dtypes ], dtypes, true ); // $ExpectError
+ binary( table, [ dtypes, dtypes ], dtypes, false ); // $ExpectError
+ binary( table, [ dtypes, dtypes ], dtypes, null ); // $ExpectError
+ binary( table, [ dtypes, dtypes ], dtypes, void 0 ); // $ExpectError
+ binary( table, [ dtypes, dtypes ], dtypes, 'abc' ); // $ExpectError
+ binary( table, [ dtypes, dtypes ], dtypes, {} ); // $ExpectError
+ binary( table, [ dtypes, dtypes ], dtypes, ( x: number ): number => x ); // $ExpectError
+}
+
+// The compiler throws an error if the function is provided an unsupported number of arguments...
+{
+ const dtypes: Array = [ 'float64', 'float32' ];
+ const table = {
+ 'default': gdot
+ };
+ const policies = {
+ 'output': 'same' as OutputPolicy,
+ 'casting': 'none' as InputCastingPolicy
+ };
+
+ new BinaryStrided1dDispatch(); // $ExpectError
+ new BinaryStrided1dDispatch( table ); // $ExpectError
+ new BinaryStrided1dDispatch( table, [ dtypes, dtypes ] ); // $ExpectError
+ new BinaryStrided1dDispatch( table, [ dtypes, dtypes ], dtypes ); // $ExpectError
+ new BinaryStrided1dDispatch( table, [ dtypes, dtypes ], dtypes, policies, {} ); // $ExpectError
+
+ const binary = BinaryStrided1dDispatch;
+ binary(); // $ExpectError
+ binary( table ); // $ExpectError
+ binary( table, [ dtypes, dtypes ] ); // $ExpectError
+ binary( table, [ dtypes, dtypes ], dtypes ); // $ExpectError
+ binary( table, [ dtypes, dtypes ], dtypes, policies, {} ); // $ExpectError
+}
+
+// The function returns an instance having an `apply` method which returns an ndarray...
+{
+ const dtypes: Array = [ 'float64', 'float32' ];
+ const table = {
+ 'default': gdot
+ };
+ const x = zeros( [ 2, 2 ], {
+ 'dtype': 'float64'
+ });
+ const policies = {
+ 'output': 'same' as OutputPolicy,
+ 'casting': 'none' as InputCastingPolicy
+ };
+
+ const f1 = new BinaryStrided1dDispatch( table, [ dtypes, dtypes ], dtypes, policies );
+ f1.apply( x, x ); // $ExpectType OutputArray
+ f1.apply( x, x, {} ); // $ExpectType OutputArray
+
+ const binary = BinaryStrided1dDispatch;
+ const f2 = binary( table, [ dtypes, dtypes ], dtypes, policies );
+ f2.apply( x, x ); // $ExpectType OutputArray
+ f2.apply( x, x, {} ); // $ExpectType OutputArray
+}
+
+// The compiler throws an error if the `apply` method is provided a first argument which is not an ndarray...
+{
+ const dtypes: Array = [ 'float64', 'float32' ];
+ const table = {
+ 'default': gdot
+ };
+ const x = zeros( [ 2, 2 ], {
+ 'dtype': 'float64'
+ });
+ const policies = {
+ 'output': 'same' as OutputPolicy,
+ 'casting': 'none' as InputCastingPolicy
+ };
+
+ const f1 = new BinaryStrided1dDispatch( table, [ dtypes, dtypes ], dtypes, policies );
+ f1.apply( '5', x ); // $ExpectError
+ f1.apply( 5, x ); // $ExpectError
+ f1.apply( true, x ); // $ExpectError
+ f1.apply( false, x ); // $ExpectError
+ f1.apply( null, x ); // $ExpectError
+ f1.apply( void 0, x ); // $ExpectError
+ f1.apply( {}, x ); // $ExpectError
+ f1.apply( ( x: number ): number => x, x ); // $ExpectError
+
+ f1.apply( '5', x, {} ); // $ExpectError
+ f1.apply( 5, x, {} ); // $ExpectError
+ f1.apply( true, x, {} ); // $ExpectError
+ f1.apply( false, x, {} ); // $ExpectError
+ f1.apply( null, x, {} ); // $ExpectError
+ f1.apply( void 0, x, {} ); // $ExpectError
+ f1.apply( {}, x, {} ); // $ExpectError
+ f1.apply( ( x: number ): number => x, x, {} ); // $ExpectError
+}
+
+// The compiler throws an error if the `apply` method is provided a second argument which is not an ndarray...
+{
+ const dtypes: Array = [ 'float64', 'float32' ];
+ const table = {
+ 'default': gdot
+ };
+ const x = zeros( [ 2, 2 ], {
+ 'dtype': 'float64'
+ });
+ const policies = {
+ 'output': 'same' as OutputPolicy,
+ 'casting': 'none' as InputCastingPolicy
+ };
+
+ const f1 = new BinaryStrided1dDispatch( table, [ dtypes, dtypes ], dtypes, policies );
+ f1.apply( x, '5' ); // $ExpectError
+ f1.apply( x, 5 ); // $ExpectError
+ f1.apply( x, true ); // $ExpectError
+ f1.apply( x, false ); // $ExpectError
+ f1.apply( x, null ); // $ExpectError
+ f1.apply( x, void 0 ); // $ExpectError
+ f1.apply( x, {} ); // $ExpectError
+ f1.apply( x, ( x: number ): number => x ); // $ExpectError
+
+ f1.apply( x, '5', {} ); // $ExpectError
+ f1.apply( x, 5, {} ); // $ExpectError
+ f1.apply( x, true, {} ); // $ExpectError
+ f1.apply( x, false, {} ); // $ExpectError
+ f1.apply( x, null, {} ); // $ExpectError
+ f1.apply( x, void 0, {} ); // $ExpectError
+ f1.apply( x, {}, {} ); // $ExpectError
+ f1.apply( x, ( x: number ): number => x, {} ); // $ExpectError
+}
+
+// The compiler throws an error if the `apply` method is provided an invalid third argument...
+{
+ const dtypes: Array = [ 'float64', 'float32' ];
+ const table = {
+ 'default': gdot
+ };
+ const x = zeros( [ 2, 2 ], {
+ 'dtype': 'float64'
+ });
+ const policies = {
+ 'output': 'same' as OutputPolicy,
+ 'casting': 'none' as InputCastingPolicy
+ };
+
+ const f1 = new BinaryStrided1dDispatch( table, [ dtypes, dtypes ], dtypes, policies );
+ f1.apply( x, x, '5' ); // $ExpectError
+ f1.apply( x, x, true ); // $ExpectError
+ f1.apply( x, x, false ); // $ExpectError
+ f1.apply( x, x, null ); // $ExpectError
+ f1.apply( x, x, [] ); // $ExpectError
+ f1.apply( x, x, ( x: number ): number => x ); // $ExpectError
+
+ f1.apply( x, x, '5', {} ); // $ExpectError
+ f1.apply( x, x, true, {} ); // $ExpectError
+ f1.apply( x, x, false, {} ); // $ExpectError
+ f1.apply( x, x, null, {} ); // $ExpectError
+ f1.apply( x, x, [], {} ); // $ExpectError
+ f1.apply( x, x, ( x: number ): number => x, {} ); // $ExpectError
+}
+
+// The compiler throws an error if the `apply` method is provided an invalid `dtype` option...
+{
+ const dtypes: Array = [ 'float64', 'float32' ];
+ const table = {
+ 'default': gdot
+ };
+ const x = zeros( [ 2, 2 ], {
+ 'dtype': 'float64'
+ });
+ const policies = {
+ 'output': 'same' as OutputPolicy,
+ 'casting': 'none' as InputCastingPolicy
+ };
+
+ const f1 = new BinaryStrided1dDispatch( table, [ dtypes, dtypes ], dtypes, policies );
+ f1.apply( x, x, { 'dtype': '5' } ); // $ExpectError
+ f1.apply( x, x, { 'dtype': 5 } ); // $ExpectError
+ f1.apply( x, x, { 'dtype': true } ); // $ExpectError
+ f1.apply( x, x, { 'dtype': false } ); // $ExpectError
+ f1.apply( x, x, { 'dtype': null } ); // $ExpectError
+ f1.apply( x, x, { 'dtype': [] } ); // $ExpectError
+ f1.apply( x, x, { 'dtype': {} } ); // $ExpectError
+ f1.apply( x, x, { 'dtype': ( x: number ): number => x } ); // $ExpectError
+}
+
+// The compiler throws an error if the `apply` method is provided an invalid `keepdims` option...
+{
+ const dtypes: Array = [ 'float64', 'float32' ];
+ const table = {
+ 'default': gdot
+ };
+ const x = zeros( [ 2, 2 ], {
+ 'dtype': 'float64'
+ });
+ const policies = {
+ 'output': 'same' as OutputPolicy,
+ 'casting': 'none' as InputCastingPolicy
+ };
+
+ const f1 = new BinaryStrided1dDispatch( table, [ dtypes, dtypes ], dtypes, policies );
+ f1.apply( x, x, { 'keepdims': '5' } ); // $ExpectError
+ f1.apply( x, x, { 'keepdims': 5 } ); // $ExpectError
+ f1.apply( x, x, { 'keepdims': null } ); // $ExpectError
+ f1.apply( x, x, { 'keepdims': [] } ); // $ExpectError
+ f1.apply( x, x, { 'keepdims': {} } ); // $ExpectError
+ f1.apply( x, x, { 'keepdims': ( x: number ): number => x } ); // $ExpectError
+}
+
+// The compiler throws an error if the `apply` method is provided an invalid `dims` option...
+{
+ const dtypes: Array = [ 'float64', 'float32' ];
+ const table = {
+ 'default': gdot
+ };
+ const x = zeros( [ 2, 2 ], {
+ 'dtype': 'float64'
+ });
+ const policies = {
+ 'output': 'same' as OutputPolicy,
+ 'casting': 'none' as InputCastingPolicy
+ };
+
+ const f1 = new BinaryStrided1dDispatch( table, [ dtypes, dtypes ], dtypes, policies );
+ f1.apply( x, x, { 'dims': '5' } ); // $ExpectError
+ f1.apply( x, x, { 'dims': 5 } ); // $ExpectError
+ f1.apply( x, x, { 'dims': true } ); // $ExpectError
+ f1.apply( x, x, { 'dims': false } ); // $ExpectError
+ f1.apply( x, x, { 'dims': null } ); // $ExpectError
+ f1.apply( x, x, { 'dims': {} } ); // $ExpectError
+ f1.apply( x, x, { 'dims': ( x: number ): number => x } ); // $ExpectError
+}
+
+// The compiler throws an error if the `apply` method is provided an unsupported number of arguments...
+{
+ const dtypes: Array = [ 'float64', 'float32' ];
+ const table = {
+ 'default': gdot
+ };
+ const policies = {
+ 'output': 'same' as OutputPolicy,
+ 'casting': 'none' as InputCastingPolicy
+ };
+
+ const f1 = new BinaryStrided1dDispatch( table, [ dtypes, dtypes ], dtypes, policies );
+ f1.apply(); // $ExpectError
+}
+
+// The function returns an instance having an `assign` method which returns an ndarray...
+{
+ const dtypes: Array = [ 'float64', 'float32' ];
+ const table = {
+ 'default': gdot
+ };
+ const x = zeros( [ 2, 2 ], {
+ 'dtype': 'float64'
+ });
+ const policies = {
+ 'output': 'same' as OutputPolicy,
+ 'casting': 'none' as InputCastingPolicy
+ };
+
+ const f1 = new BinaryStrided1dDispatch( table, [ dtypes, dtypes ], dtypes, policies );
+ f1.assign( x, x, x ); // $ExpectType float64ndarray
+
+ const binary = BinaryStrided1dDispatch;
+ const f2 = binary( table, [ dtypes, dtypes ], dtypes, policies );
+ f2.assign( x, x, x ); // $ExpectType float64ndarray
+}
+
+// The compiler throws an error if the `assign` method is provided a first argument which is not an ndarray...
+{
+ const dtypes: Array = [ 'float64', 'float32' ];
+ const table = {
+ 'default': gdot
+ };
+ const x = zeros( [ 2, 2 ], {
+ 'dtype': 'float64'
+ });
+ const policies = {
+ 'output': 'same' as OutputPolicy,
+ 'casting': 'none' as InputCastingPolicy
+ };
+
+ const f1 = new BinaryStrided1dDispatch( table, [ dtypes, dtypes ], dtypes, policies );
+ f1.assign( '5', x, x ); // $ExpectError
+ f1.assign( 5, x, x ); // $ExpectError
+ f1.assign( true, x, x ); // $ExpectError
+ f1.assign( false, x, x ); // $ExpectError
+ f1.assign( null, x, x ); // $ExpectError
+ f1.assign( void 0, x, x ); // $ExpectError
+ f1.assign( {}, x, x ); // $ExpectError
+ f1.assign( ( x: number ): number => x, x, x ); // $ExpectError
+
+ f1.assign( '5', x, x, {} ); // $ExpectError
+ f1.assign( 5, x, x, {} ); // $ExpectError
+ f1.assign( true, x, x, {} ); // $ExpectError
+ f1.assign( false, x, x, {} ); // $ExpectError
+ f1.assign( null, x, x, {} ); // $ExpectError
+ f1.assign( void 0, x, x, {} ); // $ExpectError
+ f1.assign( {}, x, x, {} ); // $ExpectError
+ f1.assign( ( x: number ): number => x, x, x, {} ); // $ExpectError
+}
+
+// The compiler throws an error if the `assign` method is provided a second argument which is not an ndarray...
+{
+ const dtypes: Array = [ 'float64', 'float32' ];
+ const table = {
+ 'default': gdot
+ };
+ const x = zeros( [ 2, 2 ], {
+ 'dtype': 'float64'
+ });
+ const policies = {
+ 'output': 'same' as OutputPolicy,
+ 'casting': 'none' as InputCastingPolicy
+ };
+
+ const f1 = new BinaryStrided1dDispatch( table, [ dtypes, dtypes ], dtypes, policies );
+ f1.assign( x, '5', x ); // $ExpectError
+ f1.assign( x, 5, x ); // $ExpectError
+ f1.assign( x, true, x ); // $ExpectError
+ f1.assign( x, false, x ); // $ExpectError
+ f1.assign( x, null, x ); // $ExpectError
+ f1.assign( x, void 0, x ); // $ExpectError
+ f1.assign( x, ( x: number ): number => x, x ); // $ExpectError
+
+ f1.assign( x, '5', x, {} ); // $ExpectError
+ f1.assign( x, 5, x, {} ); // $ExpectError
+ f1.assign( x, true, x, {} ); // $ExpectError
+ f1.assign( x, false, x, {} ); // $ExpectError
+ f1.assign( x, null, x, {} ); // $ExpectError
+ f1.assign( x, void 0, x, {} ); // $ExpectError
+ f1.assign( x, ( x: number ): number => x, x, {} ); // $ExpectError
+}
+
+// The compiler throws an error if the `assign` method is provided a third argument which is not an ndarray...
+{
+ const dtypes: Array = [ 'float64', 'float32' ];
+ const table = {
+ 'default': gdot
+ };
+ const x = zeros( [ 2, 2 ], {
+ 'dtype': 'float64'
+ });
+ const policies = {
+ 'output': 'same' as OutputPolicy,
+ 'casting': 'none' as InputCastingPolicy
+ };
+
+ const f1 = new BinaryStrided1dDispatch( table, [ dtypes, dtypes ], dtypes, policies );
+ f1.assign( x, x, '5' ); // $ExpectError
+ f1.assign( x, x, 5 ); // $ExpectError
+ f1.assign( x, x, true ); // $ExpectError
+ f1.assign( x, x, false ); // $ExpectError
+ f1.assign( x, x, null ); // $ExpectError
+ f1.assign( x, x, void 0 ); // $ExpectError
+ f1.assign( x, x, ( x: number ): number => x ); // $ExpectError
+
+ f1.assign( x, x, '5', {} ); // $ExpectError
+ f1.assign( x, x, 5, {} ); // $ExpectError
+ f1.assign( x, x, true, {} ); // $ExpectError
+ f1.assign( x, x, false, {} ); // $ExpectError
+ f1.assign( x, x, null, {} ); // $ExpectError
+ f1.assign( x, x, void 0, {} ); // $ExpectError
+ f1.assign( x, x, ( x: number ): number => x, {} ); // $ExpectError
+}
+
+// The compiler throws an error if the `assign` method is provided an invalid `dims` option...
+{
+ const dtypes: Array = [ 'float64', 'float32' ];
+ const table = {
+ 'default': gdot
+ };
+ const x = zeros( [ 2, 2 ], {
+ 'dtype': 'float64'
+ });
+ const policies = {
+ 'output': 'same' as OutputPolicy,
+ 'casting': 'none' as InputCastingPolicy
+ };
+
+ const f1 = new BinaryStrided1dDispatch( table, [ dtypes, dtypes ], dtypes, policies );
+ f1.assign( x, x, x, { 'dims': '5' } ); // $ExpectError
+ f1.assign( x, x, x, { 'dims': 5 } ); // $ExpectError
+ f1.assign( x, x, x, { 'dims': true } ); // $ExpectError
+ f1.assign( x, x, x, { 'dims': false } ); // $ExpectError
+ f1.assign( x, x, x, { 'dims': null } ); // $ExpectError
+ f1.assign( x, x, x, { 'dims': {} } ); // $ExpectError
+ f1.assign( x, 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 dtypes: Array = [ 'float64', 'float32' ];
+ const table = {
+ 'default': gdot
+ };
+ const x = zeros( [ 2, 2 ], {
+ 'dtype': 'float64'
+ });
+ const policies = {
+ 'output': 'same' as OutputPolicy,
+ 'casting': 'none' as InputCastingPolicy
+ };
+
+ const f1 = new BinaryStrided1dDispatch( table, [ dtypes, dtypes ], dtypes, policies );
+ f1.assign(); // $ExpectError
+ f1.assign( x ); // $ExpectError
+ f1.assign( x, x ); // $ExpectError
+}
diff --git a/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d-dispatch/examples/index.js b/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d-dispatch/examples/index.js
new file mode 100644
index 000000000000..31d21653c9c7
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d-dispatch/examples/index.js
@@ -0,0 +1,81 @@
+/**
+* @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 array-element-newline */
+
+'use strict';
+
+var ddot = require( '@stdlib/blas/base/ndarray/ddot' );
+var sdot = require( '@stdlib/blas/base/ndarray/sdot' );
+var base = require( '@stdlib/blas/base/ndarray/gdot' );
+var uniform = require( '@stdlib/random/array/uniform' );
+var dtypes = require( '@stdlib/ndarray/dtypes' );
+var dtype = require( '@stdlib/ndarray/dtype' );
+var ndarray2array = require( '@stdlib/ndarray/to-array' );
+var ndarray = require( '@stdlib/ndarray/ctor' );
+var BinaryStrided1dDispatch = require( './../lib' );
+
+// Define the supported input and output data types:
+var idt = dtypes( 'real_and_generic' );
+var odt = dtypes( 'real_and_generic' );
+
+// Define dispatch policies:
+var policies = {
+ 'output': 'same',
+ 'casting': 'none'
+};
+
+// Define a dispatch table:
+var table = {
+ 'types': [
+ 'float64', 'float64', // first and second input
+ 'float32', 'float32' // first and second input
+ ],
+ 'fcns': [
+ ddot,
+ sdot
+ ],
+ 'default': base
+};
+
+// Create an interface for performing a binary reduction:
+var dot = new BinaryStrided1dDispatch( table, [ idt, idt ], odt, policies );
+
+// Generate an arrays of random numbers:
+var xbuf = uniform( 100, -1.0, 1.0, {
+ 'dtype': 'generic'
+});
+var ybuf = uniform( 100, -1.0, 1.0, {
+ 'dtype': 'generic'
+});
+
+// Wrap in an ndarrays:
+var x = new ndarray( 'generic', xbuf, [ 10, 10 ], [ 10, 1 ], 0, 'row-major' );
+var y = new ndarray( 'generic', ybuf, [ 10, 10 ], [ 10, 1 ], 0, 'row-major' );
+
+// Perform a binary reduction:
+var z = dot.apply( x, y, {
+ 'dims': [ 0 ]
+});
+
+// Resolve the output array data type:
+var dt = dtype( z );
+console.log( dt );
+
+// Print the results:
+console.log( ndarray2array( z ) );
diff --git a/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d-dispatch/lib/defaults.json b/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d-dispatch/lib/defaults.json
new file mode 100644
index 000000000000..08433b373a0e
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d-dispatch/lib/defaults.json
@@ -0,0 +1,4 @@
+{
+ "dims": null,
+ "keepdims": false
+}
diff --git a/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d-dispatch/lib/index.js b/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d-dispatch/lib/index.js
new file mode 100644
index 000000000000..846909018e71
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d-dispatch/lib/index.js
@@ -0,0 +1,64 @@
+/**
+* @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';
+
+/**
+* Constructor for performing a binary reduction on two input ndarrays.
+*
+* @module @stdlib/ndarray/base/binary-reduce-strided1d-dispatch
+*
+* @example
+* var base = require( '@stdlib/blas/base/ndarray/gdot' );
+* var dtypes = require( '@stdlib/ndarray/dtypes' );
+* var ndarray = require( '@stdlib/ndarray/base/ctor' );
+* var BinaryStrided1dDispatch = require( '@stdlib/ndarray/base/binary-reduce-strided1d-dispatch' );
+*
+* var idt = dtypes( 'real_and_generic' );
+* var odt = idt;
+* var policies = {
+* 'output': 'same',
+* 'casting': 'none'
+* };
+*
+* var table = {
+* 'default': base
+* };
+* var dot = new BinaryStrided1dDispatch( table, [ idt, idt ], odt, policies );
+*
+* var xbuf = [ 4.0, 2.0, -3.0, 5.0, -1.0 ];
+* var x = new ndarray( 'generic', xbuf, [ xbuf.length ], [ 1 ], 0, 'row-major' );
+*
+* var ybuf = [ 2.0, 6.0, -1.0, -4.0, 8.0 ];
+* var y = new ndarray( 'generic', ybuf, [ ybuf.length ], [ 1 ], 0, 'row-major' );
+*
+* var z = dot.apply( x, y );
+* // returns
+*
+* var v = z.get();
+* // returns -5.0
+*/
+
+// MODULES //
+
+var main = require( './main.js' );
+
+
+// EXPORTS //
+
+module.exports = main;
diff --git a/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d-dispatch/lib/index_of_types.js b/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d-dispatch/lib/index_of_types.js
new file mode 100644
index 000000000000..fb5ca21cfc31
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d-dispatch/lib/index_of_types.js
@@ -0,0 +1,108 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+'use strict';
+
+// MAIN //
+
+/**
+* Returns the first row index at which a given one-dimensional array of types can be found in a two-dimensional reference array of types (or `-1` if not found).
+*
+* ## Notes
+*
+* - The intended use case for this function is for type dispatch (i.e., given a set of array data types, find a matching interface according the interface's accepted array data types).
+* - The function assumes that `x` is stored in row-major order.
+* - The function assumes that the number of indexed elements in `y` equals the number of columns in `x`.
+* - The function returns a row index. To convert to a linear index, multiply `strideX1` by the return value.
+*
+* @private
+* @param {NonNegativeInteger} N - number of rows in `x` (size of first dimension)
+* @param {NonNegativeInteger} M - number of columns in `x` (size of second dimension)
+* @param {ArrayLikeObject} x - input two-dimensional reference array
+* @param {integer} strideX1 - `x` stride length along first dimension
+* @param {integer} strideX2 - `x` stride length along second dimension
+* @param {NonNegativeInteger} offsetX - `x` starting index
+* @param {ArrayLikeObject} y - search array
+* @param {integer} strideY - `y` stride length
+* @param {NonNegativeInteger} offsetY - `y` starting index
+* @returns {integer} row index (if found) and `-1` otherwise
+*
+* @example
+* // Define a reference array to search:
+* var types = [
+* 'float64', 'float64', 'float64',
+* 'float32', 'float32', 'float32',
+* 'uint32', 'uint32', 'float64',
+* 'int32', 'int32', 'float64',
+* 'uint16', 'uint16', 'float64',
+* 'int16', 'int16', 'float64',
+* 'uint8', 'uint8', 'float64',
+* 'int8', 'int8', 'float64'
+* ];
+*
+* // Define reference array dimensions:
+* var N = 8; // rows
+* var M = 3; // columns
+*
+* // Define a search array:
+* var y1 = [
+* 'float32', 'float32', 'float32',
+* ];
+*
+* // Find the list of types:
+* var r1 = indexOfTypes( N, M, types, M, 1, 0, y1, 1, 0 );
+* // returns 1
+*
+// Define a search array:
+* var y2 = [
+* 'float32', 'float32', 'float64',
+* ];
+*
+* // Find the list of types:
+* var r2 = indexOfTypes( N, M, types, M, 1, 0, y2, 1, 0 );
+* // returns -1
+*/
+function indexOfTypes( N, M, x, strideX1, strideX2, offsetX, y, strideY, offsetY ) { // eslint-disable-line max-len
+ var ix;
+ var iy;
+ var i;
+ var j;
+
+ // Search for the first row which matches `y`...
+ ix = offsetX;
+ for ( i = 0; i < N; i++ ) {
+ iy = offsetY;
+ for ( j = 0; j < M; j++ ) {
+ if ( x[ ix+(j*strideX2) ] !== y[ iy ] ) {
+ break;
+ }
+ iy += strideY;
+ }
+ // If we successfully iterated over all columns, then that means we've found a match...
+ if ( j === M ) {
+ return i;
+ }
+ ix += strideX1;
+ }
+ return -1;
+}
+
+
+// EXPORTS //
+
+module.exports = indexOfTypes;
diff --git a/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d-dispatch/lib/main.js b/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d-dispatch/lib/main.js
new file mode 100644
index 000000000000..97929275c8dc
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d-dispatch/lib/main.js
@@ -0,0 +1,604 @@
+/**
+* @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, max-lines, id-length, no-warning-comments */
+
+'use strict';
+
+// MODULES //
+
+var setReadOnly = require( '@stdlib/utils/define-nonenumerable-read-only-property' );
+var hasProp = require( '@stdlib/assert/has-property' );
+var isndarrayLike = require( '@stdlib/assert/is-ndarray-like' );
+var isObject = require( '@stdlib/assert/is-object' );
+var isFunction = require( '@stdlib/assert/is-function' );
+var isCollection = require( '@stdlib/assert/is-collection' );
+var isEmptyCollection = require( '@stdlib/assert/is-empty-collection' );
+var isFunctionArray = require( '@stdlib/assert/is-function-array' );
+var isDataType = require( '@stdlib/ndarray/base/assert/is-data-type' );
+var isOutputDataTypePolicy = require( '@stdlib/ndarray/base/assert/is-output-data-type-policy' );
+var isInputCastingPolicy = require( '@stdlib/ndarray/base/assert/is-input-casting-policy' );
+var contains = require( '@stdlib/array/base/assert/contains' );
+var binaryReduceStrided1d = require( '@stdlib/ndarray/base/binary-reduce-strided1d' );
+var binaryOutputDataType = require( '@stdlib/ndarray/base/binary-output-dtype' );
+var binaryInputCastingDataType = require( '@stdlib/ndarray/base/binary-input-casting-dtype' );
+var resolveEnum = require( '@stdlib/ndarray/base/dtype-resolve-enum' );
+var spreadDimensions = require( '@stdlib/ndarray/base/spread-dimensions' );
+var getShape = require( '@stdlib/ndarray/shape' ); // note: non-base accessor is intentional due to input ndarrays originating in userland
+var ndims = require( '@stdlib/ndarray/ndims' );
+var getDType = require( '@stdlib/ndarray/base/dtype' );
+var getOrder = require( '@stdlib/ndarray/base/order' );
+var assign = require( '@stdlib/ndarray/base/assign' );
+var baseEmpty = require( '@stdlib/ndarray/base/empty' );
+var empty = require( '@stdlib/ndarray/empty' );
+var indicesComplement = require( '@stdlib/array/base/indices-complement' );
+var takeIndexed = require( '@stdlib/array/base/take-indexed' );
+var zeroTo = require( '@stdlib/array/base/zero-to' );
+var join = require( '@stdlib/array/base/join' );
+var copy = require( '@stdlib/array/base/copy' );
+var everyBy = require( '@stdlib/array/base/every-by' );
+var objectAssign = require( '@stdlib/object/assign' );
+var format = require( '@stdlib/string/format' );
+var defaultSettings = require( '@stdlib/ndarray/defaults' );
+var defaults = require( './defaults.json' );
+var validate = require( './validate.js' );
+var indexOfTypes = require( './index_of_types.js' );
+
+
+// FUNCTIONS //
+
+/**
+* Returns a list of data type enumeration constants.
+*
+* @private
+* @param {Collection} types - list of types
+* @returns {IntegerArray} list of data type enumeration constants
+*/
+function types2enums( types ) {
+ var out;
+ var i;
+
+ out = [];
+ for ( i = 0; i < types.length; i++ ) {
+ out.push( resolveEnum( types[ i ] ) ); // note: we're assuming that `types[i]` is a known data type; otherwise, the resolved enum will be `null`
+ }
+ return out;
+}
+
+/**
+* Reorders a list of ndarrays such that the output ndarray is the third ndarray argument when passing along to a resolved lower-level strided function.
+*
+* @private
+* @param {Array} arrays - list of input ndarrays
+* @param {ndarray} output - output ndarray
+* @returns {Array} reordered list
+*/
+function reorder( arrays, output ) { // TODO: consider replacing with an `array/base/*` utility which expands an input array by inserting a specified value at a specified index and returns a new array
+ var out;
+ var i;
+ var j;
+
+ out = [];
+ for ( i = 0, j = 0; i <= arrays.length; i++ ) {
+ if ( i === 2 ) {
+ out.push( output );
+ } else {
+ out.push( arrays[ j ] );
+ j += 1;
+ }
+ }
+ return out;
+}
+
+
+// MAIN //
+
+/**
+* Constructor for performing a binary reduction on two input ndarrays.
+*
+* @constructor
+* @param {Object} table - dispatch table
+* @param {Function} table.default - default strided binary reduction function
+* @param {StringArray} [table.types=[]] - one-dimensional list of ndarray data types describing specialized input ndarray argument signatures
+* @param {ArrayLikeObject} [table.fcns=[]] - list of strided binary reduction functions which are specific to specialized input ndarray argument signatures
+* @param {ArrayLikeObject} idtypes - list containing lists of supported input data types for each input ndarray argument
+* @param {StringArray} odtypes - list of supported output data types
+* @param {Object} policies - policies
+* @param {string} policies.output - output data type policy
+* @param {string} policies.casting - input ndarray casting policy
+* @throws {TypeError} first argument must be an object having valid properties
+* @throws {TypeError} second argument must be an array containing arrays of supported data types
+* @throws {TypeError} third argument must be an array of supported data types
+* @throws {TypeError} fourth argument must be an object having supported policies
+* @throws {Error} first argument must be an object having valid properties
+* @returns {BinaryStrided1dDispatch} instance
+*
+* @example
+* var base = require( '@stdlib/blas/base/ndarray/gdot' );
+* var dtypes = require( '@stdlib/ndarray/dtypes' );
+* var ndarray = require( '@stdlib/ndarray/base/ctor' );
+*
+* var idt = dtypes( 'real_and_generic' );
+* var odt = idt;
+* var policies = {
+* 'output': 'same',
+* 'casting': 'none'
+* };
+*
+* var table = {
+* 'default': base
+* };
+* var dot = new BinaryStrided1dDispatch( table, [ idt, idt ], odt, policies );
+*
+* var xbuf = [ 4.0, 2.0, -3.0, 5.0, -1.0 ];
+* var x = new ndarray( 'generic', xbuf, [ xbuf.length ], [ 1 ], 0, 'row-major' );
+*
+* var ybuf = [ 2.0, 6.0, -1.0, -4.0, 8.0 ];
+* var y = new ndarray( 'generic', ybuf, [ ybuf.length ], [ 1 ], 0, 'row-major' );
+*
+* var z = dot.apply( x, y );
+* // returns
+*
+* var v = z.get();
+* // returns -5.0
+*/
+function BinaryStrided1dDispatch( table, idtypes, odtypes, policies ) {
+ var dt;
+ var i;
+ if ( !( this instanceof BinaryStrided1dDispatch ) ) {
+ return new BinaryStrided1dDispatch( table, idtypes, odtypes, policies );
+ }
+ if ( !isObject( table ) ) {
+ throw new TypeError( format( 'invalid argument. First argument must be an object. Value: `%s`.', table ) );
+ }
+ if ( !isFunction( table.default ) ) {
+ throw new TypeError( format( 'invalid argument. First argument must be an object having a "default" property and an associated method.' ) );
+ }
+ if ( hasProp( table, 'types' ) && !isCollection( table.types ) && !isEmptyCollection( table.types ) ) {
+ throw new TypeError( format( 'invalid argument. First argument must be an object having a "types" property whose associated value is an array-like object.' ) );
+ }
+ if ( hasProp( table, 'fcns' ) && !isFunctionArray( table.fcns ) && !isEmptyCollection( table.fcns ) ) {
+ throw new TypeError( format( 'invalid argument. First argument must be an object having a "fcns" property whose associated value is an array-like object containing functions.' ) );
+ }
+ if ( !isCollection( idtypes ) ) {
+ throw new TypeError( format( 'invalid argument. Second argument must be an array-like object. Value: `%s`.', idtypes ) );
+ }
+ for ( i = 0; i < idtypes.length; i++ ) {
+ dt = idtypes[ i ];
+ if (
+ !isCollection( dt ) ||
+ dt.length < 1 ||
+ !everyBy( dt, isDataType )
+ ) {
+ throw new TypeError( format( 'invalid argument. Second argument must contain arrays of data types. Value: `%s`.', idtypes ) );
+ }
+ }
+ if (
+ !isCollection( odtypes ) ||
+ odtypes.length < 1 ||
+ !everyBy( odtypes, isDataType )
+ ) {
+ throw new TypeError( format( 'invalid argument. Third argument must be an array of data types. Value: `%s`.', odtypes ) );
+ }
+ if ( !isObject( policies ) ) {
+ throw new TypeError( format( 'invalid argument. Fourth argument must be an object. Value: `%s`.', table ) );
+ }
+ if ( !isOutputDataTypePolicy( policies.output ) ) {
+ throw new TypeError( format( 'invalid argument. Fourth argument must be an object having a supported output data type policy. Value: `%s`.', policies.output ) );
+ }
+ if ( !isInputCastingPolicy( policies.casting ) ) {
+ throw new TypeError( format( 'invalid argument. Fourth argument must be an object having a supported casting policy. Value: `%s`.', policies.casting ) );
+ }
+ this._table = {
+ 'default': table.default,
+ 'types': ( table.types ) ? types2enums( table.types ) : [], // note: convert to enums (i.e., integers) to ensure faster comparisons
+ 'fcns': ( table.fcns ) ? copy( table.fcns ) : []
+ };
+ if ( this._table.types.length !== 2 * this._table.fcns.length ) {
+ throw new Error( 'invalid argument. First argument specifies an unexpected number of types. An input ndarray data type must be specified for each provided strided function.' );
+ }
+ this._idtypes = idtypes;
+ this._odtypes = odtypes;
+ this._policies = {
+ 'output': policies.output,
+ 'casting': policies.casting
+ };
+ return this;
+}
+
+/**
+* Performs a binary reduction on two provided input ndarrays.
+*
+* @name apply
+* @memberof BinaryStrided1dDispatch.prototype
+* @type {Function}
+* @param {ndarrayLike} x - first input ndarray
+* @param {ndarrayLike} y - second input ndarray
+* @param {...ndarrayLike} [args] - additional ndarray arguments
+* @param {Options} [options] - function options
+* @param {IntegerArray} [options.dims] - list of dimensions over which to perform a binary 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} second 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 base = require( '@stdlib/blas/base/ndarray/gdot' );
+* var dtypes = require( '@stdlib/ndarray/dtypes' );
+* var ndarray = require( '@stdlib/ndarray/base/ctor' );
+*
+* var idt = dtypes( 'real_and_generic' );
+* var odt = idt;
+* var policies = {
+* 'output': 'same',
+* 'casting': 'none'
+* };
+*
+* var table = {
+* 'default': base
+* };
+* var dot = new BinaryStrided1dDispatch( table, [ idt, idt ], odt, policies );
+*
+* var xbuf = [ 4.0, 2.0, -3.0, 5.0, -1.0 ];
+* var x = new ndarray( 'generic', xbuf, [ xbuf.length ], [ 1 ], 0, 'row-major' );
+*
+* var ybuf = [ 2.0, 6.0, -1.0, -4.0, 8.0 ];
+* var y = new ndarray( 'generic', ybuf, [ ybuf.length ], [ 1 ], 0, 'row-major' );
+*
+* var z = dot.apply( x, y );
+* // returns
+*
+* var v = z.get();
+* // returns -5.0
+*/
+setReadOnly( BinaryStrided1dDispatch.prototype, 'apply', function apply( x, y ) {
+ var options;
+ var dtypes;
+ var nargs;
+ var args;
+ var opts;
+ var ordx;
+ var ordy;
+ var ordz;
+ var err;
+ var idx;
+ var shx;
+ var shy;
+ var shz;
+ var arr;
+ var tmp;
+ var xdt;
+ var ydt;
+ var zdt;
+ var dt;
+ var f;
+ var N;
+ var z;
+ var i;
+ var j;
+ var o;
+
+ // Default ndarray settings:
+ o = defaultSettings();
+
+ nargs = arguments.length;
+ if ( !isndarrayLike( x ) ) {
+ throw new TypeError( format( 'invalid argument. First argument must be an ndarray-like object. Value: `%s`.', x ) );
+ }
+ if ( !isndarrayLike( y ) ) {
+ throw new TypeError( format( 'invalid argument. Second argument must be an ndarray-like object. Value: `%s`.', y ) );
+ }
+ xdt = getDType( x );
+ ydt = getDType( y );
+ if ( !contains( this._idtypes[ 0 ], xdt ) ) {
+ throw new TypeError( format( 'invalid argument. First argument must have one of the following data types: "%s". Data type: `%s`.', join( this._idtypes[ 0 ], '", "' ), xdt ) );
+ }
+ if ( !contains( this._idtypes[ 1 ], ydt ) ) {
+ throw new TypeError( format( 'invalid argument. Second argument must have one of the following data types: "%s". Data type: `%s`.', join( this._idtypes[ 1 ], '", "' ), ydt ) );
+ }
+ ordx = getOrder( x );
+ ordy = getOrder( y );
+ if ( ordx === ordy ) {
+ ordz = ordx;
+ } else {
+ ordz = o.order;
+ }
+ args = [ x, y ];
+ for ( i = 2; i < nargs; i++ ) {
+ arr = arguments[ i ];
+ if ( !isndarrayLike( arr ) ) {
+ break;
+ }
+ dt = getDType( arr );
+ if ( !contains( this._idtypes[ i ], dt ) ) {
+ throw new TypeError( format( 'invalid argument. Argument %d must have one of the following data types: "%s". Data type: `%s`.', i, join( this._idtypes[ i ], '", "' ), dt ) );
+ }
+ // Note: we don't type promote additional ndarray arguments, as they are passed as scalars to the underlying strided reduction function...
+ args.push( arr );
+ }
+ // If we didn't make it up until the last argument, this means that we found a non-options argument which was not an ndarray...
+ if ( i < nargs-1 ) {
+ throw new TypeError( format( 'invalid argument. Argument %d must be an ndarray-like object. Value: `%s`.', i, arguments[ i ] ) );
+ }
+ shx = getShape( x );
+ shy = getShape( y );
+
+ // Verify that both input arrays have the same shape:
+ if ( shx.length !== shy.length ) {
+ throw new Error( format( 'invalid argument. Input arrays must have the same number of dimensions. First array dimensions: %d. Second array dimensions: %d.', shx.length, shy.length ) );
+ }
+ N = shx.length;
+ for ( j = 0; j < N; j++ ) {
+ if ( shx[ j ] !== shy[ j ] ) {
+ throw new Error( format( 'invalid argument. Input arrays must have the same shape. First array shape: [%s]. Second array shape: [%s].', join( shx, ',' ), join( shy, ',' ) ) );
+ }
+ }
+
+ opts = objectAssign( {}, defaults );
+ if ( nargs > i ) {
+ options = arguments[ nargs-1 ];
+ err = validate( opts, N, this._odtypes, options );
+ if ( err ) {
+ throw err;
+ }
+ }
+ // When a list of dimensions is not provided, reduce the entire input ndarray across all dimensions...
+ if ( opts.dims === null ) {
+ opts.dims = zeroTo( N );
+ }
+ // Resolve the list of non-reduced dimensions:
+ idx = indicesComplement( N, opts.dims );
+
+ // Resolve the output array shape:
+ shz = takeIndexed( shx, idx );
+
+ // Initialize an output array whose shape matches that of the non-reduced dimensions and which has the same memory layout as the input ndarrays:
+ zdt = opts.dtype || binaryOutputDataType( xdt, ydt, this._policies.output );
+ z = empty( shz, {
+ 'dtype': zdt,
+ 'order': ordz
+ });
+
+ // Determine whether we need to cast the input ndarray...
+ dt = binaryInputCastingDataType( xdt, ydt, zdt, this._policies.casting );
+ if ( xdt !== dt ) {
+ // TODO: replace the following logic with a call to `ndarray/base/(?maybe-)(cast|convert|copy)` or similar utility
+ tmp = baseEmpty( dt, shx, ordx );
+ assign( [ x, tmp ] );
+ args[ 0 ] = tmp;
+ xdt = dt;
+ }
+ if ( ydt !== dt ) {
+ // TODO: replace the following logic with a call to `ndarray/base/(?maybe-)(cast|convert|copy)` or similar utility
+ tmp = baseEmpty( dt, shy, ordy );
+ assign( [ y, tmp ] );
+ args[ 1 ] = tmp;
+ ydt = dt;
+ }
+ // Resolve the lower-level strided function satisfying the input ndarray data type:
+ dtypes = [ resolveEnum( xdt ), resolveEnum( ydt ) ];
+ i = indexOfTypes( this._table.fcns.length, 2, this._table.types, 2, 1, 0, dtypes, 1, 0 ); // eslint-disable-line max-len
+ if ( i >= 0 ) {
+ f = this._table.fcns[ i ];
+ } else {
+ f = this._table.default;
+ }
+ // Perform the reduction:
+ binaryReduceStrided1d( f, reorder( args, z ), opts.dims );
+
+ // Check whether we need to reinsert singleton dimensions which can be useful for broadcasting the returned output array to the shape of the original input array...
+ if ( opts.keepdims ) {
+ z = spreadDimensions( N, z, idx );
+ }
+ return z;
+});
+
+/**
+* Performs a binary reduction on two provided input ndarrays and assigns results to a provided output ndarray.
+*
+* @name assign
+* @memberof BinaryStrided1dDispatch.prototype
+* @type {Function}
+* @param {ndarrayLike} x - first input ndarray
+* @param {ndarrayLike} y - second input ndarray
+* @param {...ndarrayLike} [args] - additional ndarray arguments
+* @param {ndarrayLike} out - output ndarray
+* @param {Options} [options] - function options
+* @param {IntegerArray} [options.dims] - list of dimensions over which to perform a binary reduction.
+* @throws {TypeError} first argument must be an ndarray
+* @throws {TypeError} first argument must have a supported data type
+* @throws {TypeError} second argument must be an ndarray
+* @throws {TypeError} second argument must have a supported data type
+* @throws {TypeError} output argument must be an ndarray
+* @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 {ndarrayLike} output ndarray
+*
+* @example
+* var base = require( '@stdlib/blas/base/ndarray/gdot' );
+* var dtypes = require( '@stdlib/ndarray/dtypes' );
+* var ndarray = require( '@stdlib/ndarray/base/ctor' );
+*
+* var idt = dtypes( 'real_and_generic' );
+* var odt = idt;
+* var policies = {
+* 'output': 'same',
+* 'casting': 'none'
+* };
+*
+* var table = {
+* 'default': base
+* };
+* var dot = new BinaryStrided1dDispatch( table, [ idt, idt ], odt, policies );
+*
+* var xbuf = [ 4.0, 2.0, -3.0, 5.0, -1.0 ];
+* var x = new ndarray( 'generic', xbuf, [ xbuf.length ], [ 1 ], 0, 'row-major' );
+*
+* var ybuf = [ 2.0, 6.0, -1.0, -4.0, 8.0 ];
+* var y = new ndarray( 'generic', ybuf, [ ybuf.length ], [ 1 ], 0, 'row-major' );
+*
+* var zbuf = [ 0.0 ];
+* var z = new ndarray( 'generic', zbuf, [], [ 0 ], 0, 'row-major' );
+*
+* var out = dot.assign( x, y, z );
+* // returns
+*
+* var v = out.get();
+* // returns -5.0
+*
+* var bool = ( out === z );
+* // returns true
+*/
+setReadOnly( BinaryStrided1dDispatch.prototype, 'assign', function assign( x, y ) {
+ var options;
+ var dtypes;
+ var nargs;
+ var opts;
+ var args;
+ var arr;
+ var err;
+ var flg;
+ var shx;
+ var shy;
+ var xdt;
+ var ydt;
+ var tmp;
+ var dt;
+ var N;
+ var f;
+ var z;
+ var i;
+ var j;
+
+ nargs = arguments.length;
+ if ( !isndarrayLike( x ) ) {
+ throw new TypeError( format( 'invalid argument. First argument must be an ndarray-like object. Value: `%s`.', x ) );
+ }
+ if ( !isndarrayLike( y ) ) {
+ throw new TypeError( format( 'invalid argument. Second argument must be an ndarray-like object. Value: `%s`.', y ) );
+ }
+ // Validate the input ndarray data type in order to maintain similar behavior to `apply` above...
+ xdt = getDType( x );
+ ydt = getDType( y );
+ if ( !contains( this._idtypes[ 0 ], xdt ) ) {
+ throw new TypeError( format( 'invalid argument. First argument must have one of the following data types: "%s". Data type: `%s`.', join( this._idtypes[ 0 ], '", "' ), xdt ) );
+ }
+ if ( !contains( this._idtypes[ 1 ], ydt ) ) {
+ throw new TypeError( format( 'invalid argument. Second argument must have one of the following data types: "%s". Data type: `%s`.', join( this._idtypes[ 1 ], '", "' ), ydt ) );
+ }
+ shx = getShape( x );
+ shy = getShape( y );
+
+ // Verify that both input arrays have the same shape:
+ if ( shx.length !== shy.length ) {
+ throw new Error( format( 'invalid argument. Input arrays must have the same number of dimensions. First array dimensions: %d. Second array dimensions: %d.', shx.length, shy.length ) );
+ }
+ N = shx.length;
+ for ( j = 0; j < N; j++ ) {
+ if ( shx[ j ] !== shy[ j ] ) {
+ throw new Error( format( 'invalid argument. Input arrays must have the same shape. First array shape: [%s]. Second array shape: [%s].', join( shx, ',' ), join( shy, ',' ) ) );
+ }
+ }
+
+ args = [ x, y ];
+
+ // Resolve additional ndarray arguments...
+ for ( i = 2; i < nargs; i++ ) {
+ arr = arguments[ i ];
+ if ( !isndarrayLike( arr ) ) {
+ break;
+ }
+ args.push( arr );
+ }
+ // Ensure that we were provided an output ndarray...
+ if ( i < 3 ) {
+ throw new TypeError( format( 'invalid argument. Third argument must be an ndarray-like object. Value: `%s`.', arguments[ 1 ] ) );
+ }
+ // If we processed all but the last argument, assume that the last argument is an options argument...
+ else if ( i === nargs-1 ) {
+ options = arguments[ i ];
+ flg = true;
+ }
+ // Otherwise, if we have more than one argument remaining, then at least one argument is not an ndarray but should be...
+ else if ( i < nargs-1 ) {
+ throw new TypeError( format( 'invalid argument. Argument %d must be an ndarray-like object. Value: `%s`.', i, arguments[ i ] ) );
+ }
+ // Cache a reference to the output ndarray:
+ z = args.pop();
+
+ // Verify that additional ndarray arguments have expected dtypes (note: we intentionally don't validate the output ndarray dtype in order to provide an escape hatch for a user wanting to have an output ndarray having a specific dtype that `apply` does not support; note: we don't type promote additional ndarray arguments, as they are passed as scalars to the underlying strided reduction function)...
+ for ( i = 2; i < args.length; i++ ) {
+ dt = getDType( args[ i ] );
+ if ( !contains( this._idtypes[ i ], dt ) ) {
+ throw new TypeError( format( 'invalid argument. Argument %d must have one of the following data types: "%s". Data type: `%s`.', i, join( this._idtypes[ i ], '", "' ), dt ) );
+ }
+ }
+ // Validate any provided options...
+ N = ndims( x );
+ opts = objectAssign( {}, defaults );
+ if ( flg ) {
+ err = validate( opts, N, this._odtypes, options );
+ if ( err ) {
+ throw err;
+ }
+ }
+ // When a list of dimensions is not provided, reduce the entire input array across all dimensions...
+ if ( opts.dims === null ) {
+ opts.dims = zeroTo( N );
+ }
+ // Determine whether we need to cast the input ndarray...
+ dt = binaryInputCastingDataType( xdt, ydt, getDType( z ), this._policies.casting ); // eslint-disable-line max-len
+ if ( xdt !== dt ) {
+ // TODO: replace the following logic with a call to `ndarray/base/(?maybe-)(cast|convert|copy)` or similar utility
+ tmp = baseEmpty( dt, shx, getOrder( x ) );
+ assign( [ x, tmp ] );
+ args[ 0 ] = tmp;
+ xdt = dt;
+ }
+ if ( ydt !== dt ) {
+ // TODO: replace the following logic with a call to `ndarray/base/(?maybe-)(cast|convert|copy)` or similar utility
+ tmp = baseEmpty( dt, shy, getOrder( y ) );
+ assign( [ y, tmp ] );
+ args[ 1 ] = tmp;
+ ydt = dt;
+ }
+ // Resolve the lower-level strided function satisfying the input ndarray data type:
+ dtypes = [ resolveEnum( xdt ), resolveEnum( ydt ) ];
+ i = indexOfTypes( this._table.fcns.length, 2, this._table.types, 2, 1, 0, dtypes, 1, 0 ); // eslint-disable-line max-len
+ if ( i >= 0 ) {
+ f = this._table.fcns[ i ];
+ } else {
+ f = this._table.default;
+ }
+ // Perform the reduction:
+ binaryReduceStrided1d( f, reorder( args, z ), opts.dims ); // note: we assume that this lower-level function handles further validation of the output ndarray (e.g., expected shape, etc)
+
+ return z;
+});
+
+
+// EXPORTS //
+
+module.exports = BinaryStrided1dDispatch;
diff --git a/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d-dispatch/lib/validate.js b/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d-dispatch/lib/validate.js
new file mode 100644
index 000000000000..f1e9778ac8db
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d-dispatch/lib/validate.js
@@ -0,0 +1,98 @@
+/**
+* @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 isObject = require( '@stdlib/assert/is-plain-object' );
+var hasOwnProp = require( '@stdlib/assert/has-own-property' );
+var isBoolean = require( '@stdlib/assert/is-boolean' ).isPrimitive;
+var isIntegerArray = require( '@stdlib/assert/is-integer-array' ).primitives;
+var isEmptyCollection = require( '@stdlib/assert/is-empty-collection' );
+var normalizeIndices = require( '@stdlib/ndarray/base/to-unique-normalized-indices' );
+var join = require( '@stdlib/array/base/join' );
+var contains = require( '@stdlib/array/base/assert/contains' );
+var format = require( '@stdlib/string/format' );
+
+
+// MAIN //
+
+/**
+* Validates function options.
+*
+* @private
+* @param {Object} opts - destination object
+* @param {NonNegativeInteger} ndims - number of input ndarray dimensions
+* @param {Array} dtypes - list of supported output data types
+* @param {Options} options - function options
+* @param {boolean} [options.keepdims] - boolean indicating whether the reduced dimensions should be included in the returned ndarray as singleton dimensions
+* @param {IntegerArray} [options.dims] - list of dimensions over which to perform a reduction
+* @param {string} [options.dtype] - output ndarray data type
+* @returns {(Error|null)} null or an error object
+*
+* @example
+* var dtypes = [ 'float64', 'float32', 'generic' ];
+*
+* var opts = {};
+* var options = {
+* 'keepdims': true
+* };
+* var err = validate( opts, 3, dtypes, options );
+* if ( err ) {
+* throw err;
+* }
+*/
+function validate( opts, ndims, dtypes, options ) {
+ var tmp;
+ if ( !isObject( options ) ) {
+ return new TypeError( format( 'invalid argument. Options argument must be an object. Value: `%s`.', options ) );
+ }
+ if ( hasOwnProp( options, 'keepdims' ) ) {
+ opts.keepdims = options.keepdims;
+ if ( !isBoolean( opts.keepdims ) ) {
+ return new TypeError( format( 'invalid option. `%s` option must be a boolean. Option: `%s`.', 'keepdims', opts.keepdims ) );
+ }
+ }
+ if ( hasOwnProp( options, 'dims' ) ) {
+ opts.dims = options.dims;
+ if ( !isIntegerArray( opts.dims ) && !isEmptyCollection( opts.dims ) ) {
+ return new TypeError( format( 'invalid option. `%s` option must be an array of integers. Option: `%s`.', 'dims', opts.dims ) );
+ }
+ tmp = normalizeIndices( opts.dims, ndims-1 );
+ if ( tmp === null ) {
+ return new RangeError( format( 'invalid option. `%s` option contains an out-of-bounds dimension index. Option: [%s].', 'dims', join( opts.dims, ',' ) ) );
+ }
+ if ( tmp.length !== opts.dims.length ) {
+ return new Error( format( 'invalid option. `%s` option contains duplicate indices. Option: [%s].', 'dims', join( opts.dims, ',' ) ) );
+ }
+ opts.dims = tmp;
+ }
+ if ( hasOwnProp( options, 'dtype' ) ) {
+ opts.dtype = options.dtype;
+ if ( !contains( dtypes, opts.dtype ) ) {
+ return new TypeError( format( 'invalid option. `%s` option must be one of the following: "%s". Option: `%s`.', 'dtype', join( dtypes, '", "' ), opts.dtype ) );
+ }
+ }
+ return null;
+}
+
+
+// EXPORTS //
+
+module.exports = validate;
diff --git a/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d-dispatch/package.json b/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d-dispatch/package.json
new file mode 100644
index 000000000000..06d2d5609ee0
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d-dispatch/package.json
@@ -0,0 +1,63 @@
+{
+ "name": "@stdlib/ndarray/base/binary-reduce-strided1d-dispatch",
+ "version": "0.0.0",
+ "description": "Constructor for performing a binary reduction on two input ndarrays.",
+ "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",
+ "tools",
+ "ndarray",
+ "array",
+ "strided",
+ "vector",
+ "reduction",
+ "reduce",
+ "apply",
+ "call"
+ ]
+}
diff --git a/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d-dispatch/test/test.js b/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d-dispatch/test/test.js
new file mode 100644
index 000000000000..70247656f824
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/binary-reduce-strided1d-dispatch/test/test.js
@@ -0,0 +1,35 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+'use strict';
+
+// MODULES //
+
+var tape = require( 'tape' );
+var BinaryStrided1dDispatch = require( './../lib' );
+
+
+// TESTS //
+
+tape( 'main export is a function', function test( t ) {
+ t.ok( true, __filename );
+ t.strictEqual( typeof BinaryStrided1dDispatch, 'function', 'main export is a function' );
+ t.end();
+});
+
+// FIXME: add tests