chore: fix and clean-up

---
type: pre_commit_static_analysis_report
description: Results of running static analysis checks when committing changes.
report:
  - task: lint_filenames
    status: passed
  - task: lint_editorconfig
    status: passed
  - task: lint_markdown
    status: passed
  - task: lint_package_json
    status: na
  - task: lint_repl_help
    status: passed
  - task: lint_javascript_src
    status: passed
  - task: lint_javascript_cli
    status: na
  - task: lint_javascript_examples
    status: passed
  - task: lint_javascript_tests
    status: na
  - task: lint_javascript_benchmarks
    status: na
  - task: lint_python
    status: na
  - task: lint_r
    status: na
  - task: lint_c_src
    status: na
  - task: lint_c_examples
    status: na
  - task: lint_c_benchmarks
    status: na
  - task: lint_c_tests_fixtures
    status: na
  - task: lint_shell
    status: na
  - task: lint_typescript_declarations
    status: passed
  - task: lint_typescript_tests
    status: passed
  - task: lint_license_headers
    status: passed
---

Author: kgryte

lib/node_modules/@stdlib/ndarray/base/unary-reduce-subarray-by/README.md

@@ -101,8 +101,8 @@ The function accepts the following arguments:
 -   **arrays**: array-like object containing one input ndarray and one output ndarray, followed by any additional ndarray arguments.
 -   **dims**: list of dimensions over which to perform a reduction.
 -   **options**: function options which are passed through to `fcn` (_optional_).
--   **clbk**: callback function which is passed through to `fcn`.
--   **thisArg**: callback execution context which is passed through to `fcn` (_optional_).
+-   **clbk**: callback function.
+-   **thisArg**: callback execution context (_optional_).
 
 Each provided ndarray should be an object with the following properties:
 
@@ -113,7 +113,7 @@ Each provided ndarray should be an object with the following properties:
 -   **offset**: index offset.
 -   **order**: specifies whether an ndarray is row-major (C-style) or column major (Fortran-style).
 
-The invoked callback function is provided following arguments:
+The invoked callback function is provided the following arguments:
 
 -   **value**: input array element.
 -   **indices**: current array element indices.
@@ -136,14 +136,14 @@ function clbk( value ) {
 
 // Create data buffers:
 var xbuf = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 0.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ] );
-var ybuf = filled( false, 3 );
+var ybuf = filled( false, 6 );
 
 // Define the array shapes:
-var xsh = [ 3, 1, 2 ];
+var xsh = [ 3, 2, 2 ];
 var ysh = [ 3, 2 ];
 
 // Define the array strides:
-var sx = [ 2, 2, 1 ];
+var sx = [ 4, 2, 1 ];
 var sy = [ 2, 1 ];
 
 // Define the index offsets:
@@ -178,12 +178,14 @@ var ctx = {
 unaryReduceSubarrayBy( everyBy, [ x, y ], [ 1 ], clbk, ctx );
 
 var arr = ndarray2array( y.data, y.shape, y.strides, y.offset, y.order );
-// returns [ [ true, true ], [ true, true ], [ true, false ] ]
+// returns [ [ true, true ], [ true, false ], [ true, true ] ]
 
 var count = ctx.count;
-// returns 6
+// returns 11
 ```
 
+#### TODO: document factory method
+
 </section>
 
 <!-- /.usage -->
@@ -197,15 +199,14 @@ var count = ctx.count;
 -   The reduction function is expected to have the following signature:
 
     ```text
-    fcn( arrays[, options], clbk[, thisArg] )
+    fcn( arrays[, options], wrappedCallback )
     ```
 
     where
 
     -   **arrays**: array containing a subarray of the input ndarray and any additional ndarray arguments as zero-dimensional ndarrays.
-    -   **options**: function options which are passed through to `fcn` (_optional_).
-    -   **clbk**: callback function which is passed through to `fcn`.
-    -   **thisArg**: callback execution context which is passed through to `fcn` (_optional_).
+    -   **options**: function options (_optional_).
+    -   **wrappedCallback**: callback function. This function is a wrapper around a provided `clbk` argument.
 
 -   For very high-dimensional ndarrays which are non-contiguous, one should consider copying the underlying data to contiguous memory before performing a reduction in order to achieve better performance.
 
@@ -227,30 +228,29 @@ var everyBy = require( '@stdlib/ndarray/base/every-by' );
 var unaryReduceSubarrayBy = require( '@stdlib/ndarray/base/unary-reduce-subarray-by' );
 
 function clbk( value ) {
-    return value > 0;
+    return value > -3;
 }
 
-var N = 10;
 var x = {
     'dtype': 'generic',
-    'data': discreteUniform( N, -5, 5, {
+    'data': discreteUniform( 40, -5, 5, {
         'dtype': 'generic'
     }),
-    'shape': [ 3, 1, 2 ],
-    'strides': [ 1, 3, 3 ],
+    'shape': [ 2, 5, 2, 2 ],
+    'strides': [ 1, 2, 10, 20 ],
     'offset': 0,
     'order': 'column-major'
 };
 var y = {
     'dtype': 'generic',
-    'data': filled( false, 2 ),
-    'shape': [ 3, 2 ],
-    'strides': [ 1, 3 ],
+    'data': filled( false, 10 ),
+    'shape': [ 2, 5 ],
+    'strides': [ 1, 2 ],
     'offset': 0,
     'order': 'column-major'
 };
 
-unaryReduceSubarrayBy( everyBy, [ x, y ], [ 1 ], clbk );
+unaryReduceSubarrayBy( everyBy, [ x, y ], [ 2, 3 ], clbk );
 
 console.log( ndarray2array( x.data, x.shape, x.strides, x.offset, x.order ) );
 console.log( ndarray2array( y.data, y.shape, y.strides, y.offset, y.order ) );

lib/node_modules/@stdlib/ndarray/base/unary-reduce-subarray-by/docs/repl.txt

@@ -26,15 +26,15 @@
         subarray to a single scalar value. The function should have the
         following signature:
 
-            fcn( arrays[, options], clbk[, thisArg ] )
+            fcn( arrays[, options], wrappedCallback )
 
         where
 
         - arrays: array containing a subarray of the input ndarray and any
         additional ndarray arguments as zero-dimensional ndarrays.
         - options: function options.
-        - clbk: callback function.
-        - thisArg: callback execution context.
+        - wrappedCallbac: callback function. This function is a wrapper around a
+        provided `clbk` argument.
 
     arrays: ArrayLikeObject<ndarray>
         Array-like object containing one input ndarray and one output ndarray,
@@ -72,7 +72,7 @@
     // Define a trivial reduction function...
     > function fcn( arrays, clbk, thisArg ) {
     ...     var v = arrays[0].data[ arrays[0].offset ];
-    ...     return clbk.call( thisArg, v, 0, arrays[0].ref );
+    ...     return clbk.call( thisArg, v, [ 0 ], arrays[0] );
     ... };
 
     // Using minimal ndarray-like objects...

lib/node_modules/@stdlib/ndarray/base/unary-reduce-subarray-by/docs/types/index.d.ts

@@ -24,48 +24,121 @@ import { ArrayLike } from '@stdlib/types/array';
 import { typedndarray } from '@stdlib/types/ndarray';
 
 /**
-* Returns the result of the callback function.
+* Input ndarray.
+*/
+type InputArray<T> = typedndarray<T>;
+
+/**
+* Output ndarray.
+*/
+type OutputArray<U> = typedndarray<U>;
+
+/**
+* Additional ndarray arguments.
+*/
+type AdditionalArray<V> = typedndarray<V>;
+
+/**
+* ndarray arguments.
+*/
+type ListOfArrays<T, U, V> = [ InputArray<T>, OutputArray<U>, ...Array<AdditionalArray<V>> ];
+
+/**
+* ndarrays arguments passed to reduction function.
+*/
+type ReductionArrays<T, V> = [ InputArray<T>, ...Array<AdditionalArray<V>> ];
+
+/**
+* Callback invoked for each ndarray element.
 *
-* @returns result of the callback function
+* @returns output value
 */
-type Nullary<U> = ( this: U ) => unknown;
+type Nullary<W, ThisArg> = ( this: ThisArg ) => W;
 
 /**
 * Returns the results of the callback function.
 *
 * @param value - current array element
-* @returns result of the callback function
+* @returns output value
 */
-type Unary<T, U> = ( this: U, value: T ) => unknown;
+type Unary<T, W, ThisArg> = ( this: ThisArg, value: T ) => W;
 
 /**
-* Returns the result of the callback function.
+* Callback invoked for each ndarray element.
 *
 * @param value - current array element
 * @param indices - current array element indices
-* @returns result of the callback function
+* @returns output value
 */
-type Binary<T, U> = ( this: U, value: T, indices: Array<number> ) => unknown;
+type Binary<T, W, ThisArg> = ( this: ThisArg, value: T, indices: Array<number> ) => W;
 
 /**
-* Returns the result of the callback function.
+* Callback invoked for each ndarray element.
 *
 * @param value - current array element
 * @param indices - current array element indices
 * @param arr - input array
-* @returns result of the callback function
+* @returns output value
 */
-type Ternary<T, U> = ( this: U, value: T, indices: Array<number>, arr: typedndarray<T> ) => unknown;
+type Ternary<T, W, ThisArg> = ( this: ThisArg, value: T, indices: Array<number>, arr: typedndarray<T> ) => W;
 
 /**
-* Returns the result of the callback function.
+* Callback invoked for each ndarray element.
 *
 * @param value - current array element
 * @param indices - current array element indices
 * @param arr - input array
-* @returns result of the callback function
+* @returns output value
+*/
+type Callback<T, W, ThisArg> = Nullary<W, ThisArg> | Unary<T, W, ThisArg> | Binary<T, W, ThisArg> | Ternary<T, W, ThisArg>;
+
+/**
+* Unary reduction function.
+*
+* @param arrays - list of ndarrays
+* @param clbk - callback function
+* @returns reduction result
 */
-type Callback<T, U> = Nullary<U> | Unary<T, U> | Binary<T, U> | Ternary<T, U>;
+type UnaryReductionFcn<T, U, W> = ( arrays: [ typedndarray<T> ], clbk: Callback<T, W, unknown> ) => U;
+
+/**
+* Unary reduction function.
+*
+* @param arrays - list of ndarrays
+* @param options - function options
+* @param clbk - callback function
+* @returns reduction result
+*/
+type UnaryReductionFcnWithOptions<T, U, W> = ( arrays: [ typedndarray<T> ], options: Object, clbk: Callback<T, W, unknown> ) => U;
+
+/**
+* Reduction function.
+*
+* @param arrays - list of ndarrays
+* @param clbk - callback function
+* @returns reduction result
+*/
+type ReductionFcn<T, U, V, W> = ( arrays: ReductionArrays<T, V>, clbk: Callback<T, W, unknown> ) => U;
+
+/**
+* Reduction function.
+*
+* @param arrays - list of ndarrays
+* @param options - function options
+* @param clbk - callback function
+* @returns reduction result
+*/
+type ReductionFcnWithOptions<T, U, V, W> = ( arrays: ReductionArrays<T, V>, options: Object, clbk: Callback<T, W, unknown> ) => U;
+
+/**
+* Reduction function.
+*
+* @param arrays - list of ndarrays
+* @param options - function options
+* @param clbk - callback function
+* @returns reduction result
+*/
+type Reduction<T, U, V, W> = UnaryReductionFcn<T, U, W> | UnaryReductionFcnWithOptions<T, U, W> | ReductionFcn<T, U, V, W> | ReductionFcnWithOptions<T, U, V, W>;
 
 /**
 * Performs a reduction over a list of specified dimensions in an input ndarray according to a callback function and assigns results to a provided output ndarray.
@@ -83,14 +156,9 @@ type Callback<T, U> = Nullary<U> | Unary<T, U> | Binary<T, U> | Ternary<T, U>;
 * var everyBy = require( '@stdlib/ndarray/base/every-by' );
 *
 * function clbk( value ) {
-*     this.count += 1;
 *     return value > 0.0;
 * }
 *
-* var ctx = {
-*     'count': 0
-* };
-*
 * // Create data buffers:
 * var xbuf = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 0.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ] );
 * var ybuf = filled( false, 3 );
@@ -128,12 +196,12 @@ type Callback<T, U> = Nullary<U> | Unary<T, U> | Binary<T, U> | Ternary<T, U>;
 * };
 *
 * // Perform a reduction:
-* unaryReduceSubarrayBy( everyBy, [ x, y ], [ 2, 3 ], clbk, ctx );
+* unaryReduceSubarrayBy( everyBy, [ x, y ], [ 2, 3 ], clbk );
 *
 * var arr = ndarray2array( y.data, y.shape, y.strides, y.offset, y.order );
 * // returns [ [ true, false, true ] ]
 */
-declare function unaryReduceSubarrayBy<T = unknown, U = unknown>( fcn: Function, arrays: ArrayLike<typedndarray<T>>, dims: ArrayLike<number>, clbk: Callback<T, U>, thisArg?: ThisParameterType<Callback<T, U>> ): void;
+declare function unaryReduceSubarrayBy<T = unknown, U = unknown, V = unknown, W = unknown, ThisArg = unknown>( fcn: Reduction<T, U, V, W>, arrays: ListOfArrays<T, U, V>, dims: ArrayLike<number>, clbk: Callback<T, W, ThisArg>, thisArg?: ThisParameterType<Callback<T, W, ThisArg>> ): void;
 
 /**
 * Performs a reduction over a list of specified dimensions in an input ndarray according to a callback function and assigns results to a provided output ndarray.
@@ -152,14 +220,9 @@ declare function unaryReduceSubarrayBy<T = unknown, U = unknown>( fcn: Function,
 * var everyBy = require( '@stdlib/ndarray/base/every-by' );
 *
 * function clbk( value ) {
-*     this.count += 1;
 *     return value > 0.0;
 * }
 *
-* var ctx = {
-*     'count': 0
-* };
-*
 * // Create data buffers:
 * var xbuf = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 0.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ] );
 * var ybuf = filled( false, 3 );
@@ -197,12 +260,12 @@ declare function unaryReduceSubarrayBy<T = unknown, U = unknown>( fcn: Function,
 * };
 *
 * // Perform a reduction:
-* unaryReduceSubarrayBy( everyBy, [ x, y ], [ 2, 3 ], {}, clbk, ctx );
+* unaryReduceSubarrayBy( everyBy, [ x, y ], [ 2, 3 ], {}, clbk );
 *
 * var arr = ndarray2array( y.data, y.shape, y.strides, y.offset, y.order );
 * // returns [ [ true, false, true ] ]
 */
-declare function unaryReduceSubarrayBy<T = unknown, U = unknown>( fcn: Function, arrays: ArrayLike<typedndarray<T>>, dims: ArrayLike<number>, options: Object, clbk: Callback<T, U>, thisArg?: ThisParameterType<Callback<T, U>> ): void;
+declare function unaryReduceSubarrayBy<T = unknown, U = unknown, V = unknown, W = unknown, ThisArg = unknown>( fcn: Reduction<T, U, V, W>, arrays: ListOfArrays<T, U, V>, dims: ArrayLike<number>, options: Object, clbk: Callback<T, W, ThisArg>, thisArg?: ThisParameterType<Callback<T, W, ThisArg>> ): void;
 
 
 // EXPORTS //