From 6a1160458e5a940d162a532476a2a94843300233 Mon Sep 17 00:00:00 2001
From: gururaj1512 <gururajgurram1512@gmail.com>
Date: Wed, 4 Jun 2025 13:08:25 +0000
Subject: [PATCH 1/5] feat: add `stats/array/nanmax-by`

---
type: pre_commit_static_analysis_report
description: Results of running static analysis checks when committing changes.
report:
  - task: lint_filenames
    status: passed
  - task: lint_editorconfig
    status: passed
  - task: lint_markdown
    status: passed
  - task: lint_package_json
    status: passed
  - task: lint_repl_help
    status: passed
  - task: lint_javascript_src
    status: passed
  - task: lint_javascript_cli
    status: na
  - task: lint_javascript_examples
    status: passed
  - task: lint_javascript_tests
    status: passed
  - task: lint_javascript_benchmarks
    status: passed
  - task: lint_python
    status: na
  - task: lint_r
    status: na
  - task: lint_c_src
    status: na
  - task: lint_c_examples
    status: na
  - task: lint_c_benchmarks
    status: na
  - task: lint_c_tests_fixtures
    status: na
  - task: lint_shell
    status: na
  - task: lint_typescript_declarations
    status: passed
  - task: lint_typescript_tests
    status: passed
  - task: lint_license_headers
    status: passed
---
---
 .../@stdlib/stats/array/nanmax-by/README.md   | 154 +++++++++
 .../array/nanmax-by/benchmark/benchmark.js    | 115 +++++++
 .../stats/array/nanmax-by/docs/repl.txt       |  44 +++
 .../array/nanmax-by/docs/types/index.d.ts     |  97 ++++++
 .../stats/array/nanmax-by/docs/types/test.ts  |  72 +++++
 .../stats/array/nanmax-by/examples/index.js   |  41 +++
 .../stats/array/nanmax-by/lib/index.js        |  46 +++
 .../@stdlib/stats/array/nanmax-by/lib/main.js |  94 ++++++
 .../stats/array/nanmax-by/package.json        |  67 ++++
 .../stats/array/nanmax-by/test/test.js        | 306 ++++++++++++++++++
 10 files changed, 1036 insertions(+)
 create mode 100644 lib/node_modules/@stdlib/stats/array/nanmax-by/README.md
 create mode 100644 lib/node_modules/@stdlib/stats/array/nanmax-by/benchmark/benchmark.js
 create mode 100644 lib/node_modules/@stdlib/stats/array/nanmax-by/docs/repl.txt
 create mode 100644 lib/node_modules/@stdlib/stats/array/nanmax-by/docs/types/index.d.ts
 create mode 100644 lib/node_modules/@stdlib/stats/array/nanmax-by/docs/types/test.ts
 create mode 100644 lib/node_modules/@stdlib/stats/array/nanmax-by/examples/index.js
 create mode 100644 lib/node_modules/@stdlib/stats/array/nanmax-by/lib/index.js
 create mode 100644 lib/node_modules/@stdlib/stats/array/nanmax-by/lib/main.js
 create mode 100644 lib/node_modules/@stdlib/stats/array/nanmax-by/package.json
 create mode 100644 lib/node_modules/@stdlib/stats/array/nanmax-by/test/test.js

diff --git a/lib/node_modules/@stdlib/stats/array/nanmax-by/README.md b/lib/node_modules/@stdlib/stats/array/nanmax-by/README.md
new file mode 100644
index 000000000000..bbdac2557fc5
--- /dev/null
+++ b/lib/node_modules/@stdlib/stats/array/nanmax-by/README.md
@@ -0,0 +1,154 @@
+<!--
+
+@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.
+
+-->
+
+# nanmaxBy
+
+> Calculate the maximum value of an array via a callback function, ignoring `NaN` values.
+
+<section class="intro">
+
+</section>
+
+<!-- /.intro -->
+
+<section class="usage">
+
+## Usage
+
+```javascript
+var nanmaxBy = require( '@stdlib/stats/array/nanmax-by' );
+```
+
+#### nanmaxBy( x, clbk\[, thisArg] )
+
+Computes the maximum value of an array via a callback function, ignoring `NaN` values.
+
+```javascript
+function accessor( v ) {
+    return v * 2.0;
+}
+
+var x = [ -2.0, 1.0, 3.0, -5.0, 4.0, NaN, 0.0, -1.0, -3.0, NaN ];
+
+var v = nanmaxBy( x, accessor );
+// returns 8.0
+```
+
+The function has the following parameters:
+
+-   **x**: input array.
+-   **clbk**: callback function.
+-   **thisArg**: execution context (_optional_).
+
+The invoked callback is provided three arguments:
+
+-   **value**: current array element.
+-   **index**: current array index.
+-   **array**: input array.
+
+To set the callback execution context, provide a `thisArg`.
+
+```javascript
+function accessor( v ) {
+    this.count += 1;
+    return v * 2.0;
+}
+
+var x = [ -2.0, 1.0, 3.0, -5.0, 4.0, NaN, 0.0, -1.0, -3.0, NaN ];
+
+var context = {
+    'count': 0
+};
+
+var v = nanmaxBy( x, accessor, context );
+// returns 8.0
+
+var cnt = context.count;
+// returns 10
+```
+
+</section>
+
+<!-- /.usage -->
+
+<section class="notes">
+
+## Notes
+
+-   If provided an empty array, the function returns `NaN`.
+-   A provided callback function should return a numeric value.
+-   If a provided callback function does not return any value (or equivalently, explicitly returns `undefined`), the value is **ignored**.
+-   The function supports array-like objects having getter and setter accessors for array element access (e.g., [`@stdlib/array/base/accessor`][@stdlib/array/base/accessor]).
+
+</section>
+
+<!-- /.notes -->
+
+<section class="examples">
+
+## Examples
+
+<!-- eslint no-undef: "error" -->
+
+```javascript
+var uniform = require( '@stdlib/random/base/uniform' );
+var bernoulli = require( '@stdlib/random/base/bernoulli' );
+var filledarrayBy = require( '@stdlib/array/filled-by' );
+var nanmaxBy = require( '@stdlib/stats/array/nanmax-by' );
+
+function rand() {
+    if ( bernoulli( 0.8 ) < 1 ) {
+        return NaN;
+    }
+    return uniform( -50.0, 50.0 );
+}
+
+function accessor( v ) {
+    return v * 2.0;
+}
+
+var x = filledarrayBy( 10, 'float64', rand );
+console.log( x );
+
+var v = nanmaxBy( x, accessor );
+console.log( v );
+```
+
+</section>
+
+<!-- /.examples -->
+
+<!-- Section for related `stdlib` packages. Do not manually edit this section, as it is automatically populated. -->
+
+<section class="related">
+
+</section>
+
+<!-- /.related -->
+
+<!-- Section for all links. Make sure to keep an empty line after the `section` element and another before the `/section` close. -->
+
+<section class="links">
+
+[@stdlib/array/base/accessor]: https://github.com/stdlib-js/stdlib/tree/develop/lib/node_modules/%40stdlib/array/base/accessor
+
+</section>
+
+<!-- /.links -->
diff --git a/lib/node_modules/@stdlib/stats/array/nanmax-by/benchmark/benchmark.js b/lib/node_modules/@stdlib/stats/array/nanmax-by/benchmark/benchmark.js
new file mode 100644
index 000000000000..d86bc63bb61a
--- /dev/null
+++ b/lib/node_modules/@stdlib/stats/array/nanmax-by/benchmark/benchmark.js
@@ -0,0 +1,115 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*    http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+'use strict';
+
+// MODULES //
+
+var bench = require( '@stdlib/bench' );
+var uniform = require( '@stdlib/random/base/uniform' );
+var bernoulli = require( '@stdlib/random/base/bernoulli' );
+var filledarrayBy = require( '@stdlib/array/filled-by' );
+var isnan = require( '@stdlib/math/base/assert/is-nan' );
+var pow = require( '@stdlib/math/base/special/pow' );
+var pkg = require( './../package.json' ).name;
+var nanmaxBy = require( './../lib' );
+
+
+// FUNCTIONS //
+
+/**
+* Accessor function.
+*
+* @private
+* @param {number} value - array element
+* @returns {number} accessed value
+*/
+function accessor( value ) {
+	return value * 2.0;
+}
+
+/**
+* Returns a random number.
+*
+* @private
+* @returns {number} random number
+*/
+function rand() {
+	if ( bernoulli( 0.8 ) < 1 ) {
+		return NaN;
+	}
+	return uniform( -10.0, 10.0 );
+}
+
+/**
+* Creates a benchmark function.
+*
+* @private
+* @param {PositiveInteger} len - array length
+* @returns {Function} benchmark function
+*/
+function createBenchmark( len ) {
+	var x = filledarrayBy( len, 'generic', rand );
+	return benchmark;
+
+	function benchmark( b ) {
+		var v;
+		var i;
+
+		b.tic();
+		for ( i = 0; i < b.iterations; i++ ) {
+			v = nanmaxBy( x, accessor );
+			if ( isnan( v ) ) {
+				b.fail( 'should not return NaN' );
+			}
+		}
+		b.toc();
+		if ( isnan( v ) ) {
+			b.fail( 'should not return NaN' );
+		}
+		b.pass( 'benchmark finished' );
+		b.end();
+	}
+}
+
+
+// MAIN //
+
+/**
+* Main execution sequence.
+*
+* @private
+*/
+function main() {
+	var len;
+	var min;
+	var max;
+	var f;
+	var i;
+
+	min = 1; // 10^min
+	max = 6; // 10^max
+
+	for ( i = min; i <= max; i++ ) {
+		len = pow( 10, i );
+		f = createBenchmark( len );
+		bench( pkg+':len='+len, f );
+	}
+}
+
+main();
diff --git a/lib/node_modules/@stdlib/stats/array/nanmax-by/docs/repl.txt b/lib/node_modules/@stdlib/stats/array/nanmax-by/docs/repl.txt
new file mode 100644
index 000000000000..e096333fbf19
--- /dev/null
+++ b/lib/node_modules/@stdlib/stats/array/nanmax-by/docs/repl.txt
@@ -0,0 +1,44 @@
+
+{{alias}}( x, clbk[, thisArg] )
+    Computes the maximum value of an array via a callback function, ignoring
+    `NaN` values.
+
+    If provided an empty array, the function returns `NaN`.
+
+    The callback function is provided three arguments:
+
+    - value: current array element.
+    - index: current array index.
+    - array: the input array.
+
+    The callback function should return a numeric value.
+
+    If the callback function does not return any value (or equivalently,
+    explicitly returns `undefined`), the value is ignored.
+
+    Parameters
+    ----------
+    x: Array<number>|TypedArray
+        Input array.
+
+    clbk: Function
+        Callback function.
+
+    thisArg: any (optional)
+        Execution context.
+
+    Returns
+    -------
+    out: number
+        Maximum value.
+
+    Examples
+    --------
+    > function accessor( v ) { return v * 2.0; };
+    > var x = [ -2.0, 1.0, 3.0, -5.0, 4.0, NaN, -1.0, -3.0 ];
+    > {{alias}}( x, accessor )
+    8.0
+
+    See Also
+    --------
+
diff --git a/lib/node_modules/@stdlib/stats/array/nanmax-by/docs/types/index.d.ts b/lib/node_modules/@stdlib/stats/array/nanmax-by/docs/types/index.d.ts
new file mode 100644
index 000000000000..24ffc865bbdb
--- /dev/null
+++ b/lib/node_modules/@stdlib/stats/array/nanmax-by/docs/types/index.d.ts
@@ -0,0 +1,97 @@
+/*
+* @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
+
+/// <reference types="@stdlib/types"/>
+
+import { NumericArray, Collection, AccessorArrayLike } from '@stdlib/types/array';
+
+/**
+* Input array.
+*/
+type InputArray = NumericArray | Collection<number> | AccessorArrayLike<number>;
+
+/**
+* Returns an accessed value.
+*
+* @returns accessed value
+*/
+type Nullary<ThisArg> = ( this: ThisArg ) => number | void;
+
+/**
+* Returns an accessed value.
+*
+* @param value - current array element
+* @returns accessed value
+*/
+type Unary<T, ThisArg> = ( this: ThisArg, value: T ) => number | void;
+
+/**
+* Returns an accessed value.
+*
+* @param value - current array element
+* @param index - current array index
+* @returns accessed value
+*/
+type Binary<T, ThisArg> = ( this: ThisArg, value: T, index: number ) => number | void;
+
+/**
+* Returns an accessed value.
+*
+* @param value - current array element
+* @param index - current array index
+* @param array - input array
+* @returns accessed value
+*/
+type Ternary<T, U, ThisArg> = ( this: ThisArg, value: T, index: number, array: U ) => number | void;
+
+/**
+* Returns an accessed value.
+*
+* @param value - current array element
+* @param index - current array index
+* @param array - input array
+* @returns accessed value
+*/
+type Callback<T, U, ThisArg> = Nullary<ThisArg> | Unary<T, ThisArg> | Binary<T, ThisArg> | Ternary<T, U, ThisArg>;
+
+/**
+* Computes the maximum value of an array via a callback function, ignoring `NaN` values.
+*
+* @param x - input array
+* @param clbk - callback
+* @param thisArg - execution context
+* @returns maximum value
+*
+* @example
+* var x = [ -2.0, 1.0, 3.0, -5.0, 4.0, NaN, 0.0, -1.0, -3.0 ];
+*
+* function accessor( v ) {
+*     return v * 2.0;
+* }
+*
+* var v = nanmaxBy( x, accessor );
+* // returns 8.0
+*/
+declare function nanmaxBy<T = number, U extends InputArray = InputArray, ThisArg = unknown>( x: U, clbk: Callback<T, U, ThisArg>, thisArg?: ThisParameterType<Callback<T, U, ThisArg>> ): number;
+
+
+// EXPORTS //
+
+export = nanmaxBy;
diff --git a/lib/node_modules/@stdlib/stats/array/nanmax-by/docs/types/test.ts b/lib/node_modules/@stdlib/stats/array/nanmax-by/docs/types/test.ts
new file mode 100644
index 000000000000..ec0e238dbfbe
--- /dev/null
+++ b/lib/node_modules/@stdlib/stats/array/nanmax-by/docs/types/test.ts
@@ -0,0 +1,72 @@
+/*
+* @license Apache-2.0
+*
+* Copyright (c) 2025 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*    http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+import AccessorArray = require( '@stdlib/array/base/accessor' );
+import nanmaxBy = require( './index' );
+
+const accessor = (): number => {
+	return 5.0;
+};
+
+
+// TESTS //
+
+// The function returns a number...
+{
+	const x = new Float64Array( 10 );
+
+	nanmaxBy( x, accessor ); // $ExpectType number
+	nanmaxBy( new AccessorArray( x ), accessor ); // $ExpectType number
+
+	nanmaxBy( x, accessor, {} ); // $ExpectType number
+	nanmaxBy( new AccessorArray( x ), accessor, {} ); // $ExpectType number
+}
+
+// The compiler throws an error if the function is provided a first argument which is not a numeric array...
+{
+	nanmaxBy( 10, accessor ); // $ExpectError
+	nanmaxBy( '10', accessor ); // $ExpectError
+	nanmaxBy( true, accessor ); // $ExpectError
+	nanmaxBy( false, accessor ); // $ExpectError
+	nanmaxBy( null, accessor ); // $ExpectError
+	nanmaxBy( undefined, accessor ); // $ExpectError
+	nanmaxBy( {}, accessor ); // $ExpectError
+	nanmaxBy( ( x: number ): number => x, accessor ); // $ExpectError
+}
+
+// The compiler throws an error if the function is provided a second argument which is not a function...
+{
+	const x = new Float64Array( 10 );
+
+	nanmaxBy( x, '10' ); // $ExpectError
+	nanmaxBy( x, true ); // $ExpectError
+	nanmaxBy( x, false ); // $ExpectError
+	nanmaxBy( x, null ); // $ExpectError
+	nanmaxBy( x, undefined ); // $ExpectError
+	nanmaxBy( x, [] ); // $ExpectError
+	nanmaxBy( x, {} ); // $ExpectError
+}
+
+// The compiler throws an error if the function is provided an unsupported number of arguments...
+{
+	const x = new Float64Array( 10 );
+
+	nanmaxBy(); // $ExpectError
+	nanmaxBy( x ); // $ExpectError
+	nanmaxBy( x, accessor, {}, 10 ); // $ExpectError
+}
diff --git a/lib/node_modules/@stdlib/stats/array/nanmax-by/examples/index.js b/lib/node_modules/@stdlib/stats/array/nanmax-by/examples/index.js
new file mode 100644
index 000000000000..51d5cb4a34c0
--- /dev/null
+++ b/lib/node_modules/@stdlib/stats/array/nanmax-by/examples/index.js
@@ -0,0 +1,41 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*    http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+'use strict';
+
+var uniform = require( '@stdlib/random/base/uniform' );
+var bernoulli = require( '@stdlib/random/base/bernoulli' );
+var filledarrayBy = require( '@stdlib/array/filled-by' );
+var nanmaxBy = require( './../lib' );
+
+function rand() {
+	if ( bernoulli( 0.8 ) < 1 ) {
+		return NaN;
+	}
+	return uniform( -50.0, 50.0 );
+}
+
+function accessor( v ) {
+	return v * 2.0;
+}
+
+var x = filledarrayBy( 10, 'float64', rand );
+console.log( x );
+
+var v = nanmaxBy( x, accessor );
+console.log( v );
diff --git a/lib/node_modules/@stdlib/stats/array/nanmax-by/lib/index.js b/lib/node_modules/@stdlib/stats/array/nanmax-by/lib/index.js
new file mode 100644
index 000000000000..39e2766ceb3c
--- /dev/null
+++ b/lib/node_modules/@stdlib/stats/array/nanmax-by/lib/index.js
@@ -0,0 +1,46 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*    http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+'use strict';
+
+/**
+* Compute the maximum value of an array via a callback function, ignoring `NaN` values.
+*
+* @module @stdlib/stats/array/nanmax-by
+*
+* @example
+* var nanmaxBy = require( '@stdlib/stats/array/nanmax-by' );
+*
+* function accessor( v ) {
+*     return v * 2.0;
+* }
+*
+* var x = [ -2.0, 1.0, 3.0, -5.0, 4.0, NaN, 0.0, -1.0, -3.0 ];
+*
+* var v = nanmaxBy( x, accessor );
+* // returns 8.0
+*/
+
+// MODULES //
+
+var main = require( './main.js' );
+
+
+// EXPORTS //
+
+module.exports = main;
diff --git a/lib/node_modules/@stdlib/stats/array/nanmax-by/lib/main.js b/lib/node_modules/@stdlib/stats/array/nanmax-by/lib/main.js
new file mode 100644
index 000000000000..d0dbe8e42c1f
--- /dev/null
+++ b/lib/node_modules/@stdlib/stats/array/nanmax-by/lib/main.js
@@ -0,0 +1,94 @@
+/**
+* @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 isCollection = require( '@stdlib/assert/is-collection' );
+var dtypes = require( '@stdlib/array/dtypes' );
+var dtype = require( '@stdlib/array/dtype' );
+var contains = require( '@stdlib/array/base/assert/contains' );
+var join = require( '@stdlib/array/base/join' );
+var strided = require( '@stdlib/stats/base/nanmax-by' ).ndarray;
+var format = require( '@stdlib/string/format' );
+var isFunction = require( '@stdlib/assert/is-function' );
+
+
+// VARIABLES //
+
+var IDTYPES = dtypes( 'real_and_generic' );
+var GENERIC_DTYPE = 'generic';
+
+
+// MAIN //
+
+/**
+* Computes the maximum value of an array via a callback function, ignoring `NaN` values.
+*
+* @param {NumericArray} x - input array
+* @param {Callback} clbk - callback
+* @param {*} [thisArg] - execution context
+* @throws {TypeError} first argument must be an array-like object
+* @throws {TypeError} first argument must have a supported data type
+* @throws {TypeError} second argument must be a function
+* @returns {number} maximum value
+*
+* @example
+* var x = [ -2.0, 1.0, 3.0, -5.0, 4.0, NaN, 0.0, -1.0, -3.0 ];
+*
+* function accessor( v ) {
+*     return v * 2.0;
+* }
+*
+* var v = nanmaxBy( x, accessor );
+* // returns 8.0
+*/
+function nanmaxBy( x, clbk, thisArg ) {
+	var dt;
+	if ( !isCollection( x ) ) {
+		throw new TypeError( format( 'invalid argument. First argument must be an array-like object. Value: `%s`.', x ) );
+	}
+	dt = dtype( x ) || GENERIC_DTYPE;
+	if ( !contains( IDTYPES, dt ) ) {
+		throw new TypeError( format( 'invalid argument. First argument must have one of the following data types: "%s". Data type: `%s`.', join( IDTYPES, '", "' ), dt ) );
+	}
+	if ( !isFunction( clbk ) ) {
+		throw new TypeError( format( 'invalid argument. Second argument must be a function. Value: `%s`.', clbk ) );
+	}
+	return strided( x.length, x, 1, 0, wrapper );
+
+	/**
+	* Invokes a provided callback.
+	*
+	* @private
+	* @param {number} value - current element
+	* @param {NonNegativeInteger} aidx - current array index
+	* @param {NonNegativeInteger} sidx - current strided index
+	* @param {NumericArray} arr - input array
+	* @returns {number} callback return value
+	*/
+	function wrapper( value, aidx, sidx, arr ) {
+		return clbk.call( thisArg, value, aidx, arr );
+	}
+}
+
+
+// EXPORTS //
+
+module.exports = nanmaxBy;
diff --git a/lib/node_modules/@stdlib/stats/array/nanmax-by/package.json b/lib/node_modules/@stdlib/stats/array/nanmax-by/package.json
new file mode 100644
index 000000000000..aa7f0b146cb8
--- /dev/null
+++ b/lib/node_modules/@stdlib/stats/array/nanmax-by/package.json
@@ -0,0 +1,67 @@
+{
+  "name": "@stdlib/stats/array/nanmax-by",
+  "version": "0.0.0",
+  "description": "Calculate the maximum value of an array via a callback function, ignoring NaN values.",
+  "license": "Apache-2.0",
+  "author": {
+    "name": "The Stdlib Authors",
+    "url": "https://github.com/stdlib-js/stdlib/graphs/contributors"
+  },
+  "contributors": [
+    {
+      "name": "The Stdlib Authors",
+      "url": "https://github.com/stdlib-js/stdlib/graphs/contributors"
+    }
+  ],
+  "main": "./lib",
+  "directories": {
+    "benchmark": "./benchmark",
+    "doc": "./docs",
+    "example": "./examples",
+    "lib": "./lib",
+    "test": "./test"
+  },
+  "types": "./docs/types",
+  "scripts": {},
+  "homepage": "https://github.com/stdlib-js/stdlib",
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/stdlib-js/stdlib.git"
+  },
+  "bugs": {
+    "url": "https://github.com/stdlib-js/stdlib/issues"
+  },
+  "dependencies": {},
+  "devDependencies": {},
+  "engines": {
+    "node": ">=0.10.0",
+    "npm": ">2.7.0"
+  },
+  "os": [
+    "aix",
+    "darwin",
+    "freebsd",
+    "linux",
+    "macos",
+    "openbsd",
+    "sunos",
+    "win32",
+    "windows"
+  ],
+  "keywords": [
+    "stdlib",
+    "stdmath",
+    "statistics",
+    "stats",
+    "mathematics",
+    "math",
+    "maximum",
+    "max",
+    "range",
+    "extremes",
+    "domain",
+    "extent",
+    "array"
+  ],
+  "__stdlib__": {}
+}
diff --git a/lib/node_modules/@stdlib/stats/array/nanmax-by/test/test.js b/lib/node_modules/@stdlib/stats/array/nanmax-by/test/test.js
new file mode 100644
index 000000000000..0ff603ba5a7b
--- /dev/null
+++ b/lib/node_modules/@stdlib/stats/array/nanmax-by/test/test.js
@@ -0,0 +1,306 @@
+/**
+* @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 isnan = require( '@stdlib/math/base/assert/is-nan' );
+var toAccessorArray = require( '@stdlib/array/base/to-accessor-array' );
+var isPositiveZero = require( '@stdlib/math/base/assert/is-positive-zero' );
+var BooleanArray = require( '@stdlib/array/bool' );
+var Complex128Array = require( '@stdlib/array/complex128' );
+var isSameArray = require( '@stdlib/assert/is-same-array' );
+var nanmaxBy = require( './../lib/main.js' );
+
+
+// FUNCTIONS //
+
+function accessor( v ) {
+	if ( v === void 0 ) {
+		return;
+	}
+	return v * 2.0;
+}
+
+
+// TESTS //
+
+tape( 'main export is a function', function test( t ) {
+	t.ok( true, __filename );
+	t.strictEqual( typeof nanmaxBy, 'function', 'main export is a function' );
+	t.end();
+});
+
+tape( 'the function has an arity of 3', function test( t ) {
+	t.strictEqual( nanmaxBy.length, 3, 'returns expected value' );
+	t.end();
+});
+
+tape( 'the function throws an error if provided a first argument which is not an array-like object', function test( t ) {
+	var values;
+	var i;
+
+	values = [
+		'5',
+		5,
+		NaN,
+		true,
+		false,
+		null,
+		void 0,
+		{},
+		function noop() {}
+	];
+	for ( i = 0; i < values.length; i++ ) {
+		t.throws( badValue( values[ i ] ), TypeError, 'throws an error when provided ' + values[ i ] );
+	}
+	t.end();
+
+	function badValue( value ) {
+		return function badValue() {
+			nanmaxBy( value );
+		};
+	}
+});
+
+tape( 'the function throws an error if provided a first argument which has an unsupported data type', function test( t ) {
+	var values;
+	var i;
+
+	values = [
+		new BooleanArray( 4 ),
+		new Complex128Array( 4 )
+	];
+	for ( i = 0; i < values.length; i++ ) {
+		t.throws( badValue( values[ i ] ), TypeError, 'throws an error when provided ' + values[ i ] );
+	}
+	t.end();
+
+	function badValue( value ) {
+		return function badValue() {
+			nanmaxBy( value );
+		};
+	}
+});
+
+tape( 'the function throws an error if provided a second argument which is not a function', function test( t ) {
+	var values;
+	var i;
+	var x;
+
+	x = [ 1.0, -2.0, -4.0, 5.0, 0.0, 3.0 ];
+	values = [
+		'5',
+		5,
+		NaN,
+		null,
+		void 0,
+		true,
+		[],
+		{}
+	];
+
+	for ( i = 0; i < values.length; i++ ) {
+		t.throws( badValue( values[i] ), TypeError, 'throws a type error when provided '+values[i] );
+	}
+	t.end();
+
+	function badValue( value ) {
+		return function badValue() {
+			nanmaxBy( x, value );
+		};
+	}
+});
+
+tape( 'the function calculates the maximum value of an array via a callback function', function test( t ) {
+	var x;
+	var v;
+
+	x = [ 1.0, -2.0, -4.0, 5.0, 0.0, 3.0, NaN, NaN ];
+	v = nanmaxBy( x, accessor );
+	t.strictEqual( v, 10.0, 'returns expected value' );
+
+	x = [ -4.0, NaN, -5.0 ];
+	v = nanmaxBy( x, accessor );
+	t.strictEqual( v, -8.0, 'returns expected value' );
+
+	x = [ -0.0, NaN, 0.0, -0.0 ];
+	v = nanmaxBy( x, accessor );
+	t.strictEqual( isPositiveZero( v ), true, 'returns expected value' );
+
+	x = [ NaN ];
+	v = nanmaxBy( x, accessor );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
+
+	x = [ NaN, NaN ];
+	v = nanmaxBy( x, accessor );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function calculates the maximum value of an array via a callback function (accessors)', function test( t ) {
+	var x;
+	var v;
+
+	x = [ 1.0, -2.0, -4.0, 5.0, 0.0, 3.0, NaN, NaN ];
+	v = nanmaxBy( toAccessorArray( x ), accessor );
+	t.strictEqual( v, 5.0, 'returns expected value' );
+
+	x = [ -4.0, NaN, -5.0 ];
+	v = nanmaxBy( toAccessorArray( x ), accessor );
+	t.strictEqual( v, -4.0, 'returns expected value' );
+
+	x = [ -0.0, NaN, 0.0, -0.0 ];
+	v = nanmaxBy( toAccessorArray( x ), accessor );
+	t.strictEqual( isPositiveZero( v ), true, 'returns expected value' );
+
+	x = [ NaN ];
+	v = nanmaxBy( toAccessorArray( x ), accessor );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
+
+	x = [ NaN, NaN ];
+	v = nanmaxBy( toAccessorArray( x ), accessor );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function calculates the maximum value of an array via a callback function (array-like object)', function test( t ) {
+	var x;
+	var v;
+
+	x = {
+		'length': 7,
+		'0': 1.0,
+		'1': -2.0,
+		'2': -4.0,
+		'3': NaN,
+		'4': 5.0,
+		'5': 0.0,
+		'6': 3.0
+	};
+	v = nanmaxBy( x, accessor );
+	t.strictEqual( v, 10.0, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function supports providing a callback execution context', function test( t ) {
+	var expected;
+	var indices;
+	var values;
+	var arrays;
+	var ctx;
+	var x;
+
+	x = [ 1.0, 2.0, 3.0, NaN, 4.0, 5.0 ];
+	ctx = {
+		'count': 0
+	};
+	indices = [];
+	values = [];
+	arrays = [];
+	nanmaxBy( x, accessor, ctx );
+
+	t.strictEqual( ctx.count, x.length, 'returns expected value' );
+
+	expected = [ 0, 1, 2, 3, 4, 5 ];
+	t.deepEqual( indices, expected, 'returns expected value' );
+
+	expected = [ 1.0, 2.0, 3.0, NaN, 4.0, 5.0 ];
+	t.deepEqual( isSameArray( values, expected ), true, 'returns expected value' );
+
+	expected = [ x, x, x, x, x, x ];
+	t.deepEqual( arrays, expected, 'returns expected value' );
+	t.end();
+
+	function accessor( v, idx, arr ) {
+		this.count += 1; // eslint-disable-line no-invalid-this
+		indices.push( idx );
+		values.push( v );
+		arrays.push( arr );
+		return v * 2.0;
+	}
+});
+
+tape( 'the function supports providing a callback execution context (accessors)', function test( t ) {
+	var expected;
+	var indices;
+	var values;
+	var arrays;
+	var ctx;
+	var ax;
+	var x;
+
+	x = [ 1.0, 2.0, 3.0, NaN, 4.0, 5.0 ];
+	ax = toAccessorArray( x );
+	ctx = {
+		'count': 0
+	};
+	indices = [];
+	values = [];
+	arrays = [];
+	nanmaxBy( ax, accessor, ctx );
+
+	t.strictEqual( ctx.count, x.length, 'returns expected value' );
+
+	expected = [ 0, 1, 2, 3, 4, 5 ];
+	t.deepEqual( indices, expected, 'returns expected value' );
+
+	expected = [ 1.0, 2.0, 3.0, NaN, 4.0, 5.0 ];
+	t.deepEqual( values, expected, 'returns expected value' );
+
+	expected = [ ax, ax, ax, ax, ax, ax ];
+	t.deepEqual( arrays, expected, 'returns expected value' );
+	t.end();
+
+	function accessor( v, idx, arr ) {
+		this.count += 1; // eslint-disable-line no-invalid-this
+		indices.push( idx );
+		values.push( v );
+		arrays.push( arr );
+		return v * 2.0;
+	}
+});
+
+tape( 'if provided an empty array, the function returns `NaN`', function test( t ) {
+	var v = nanmaxBy( [], accessor );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
+	t.end();
+});
+
+tape( 'if provided an empty array, the function returns `NaN` (accessors)', function test( t ) {
+	var v = nanmaxBy( toAccessorArray( [] ), accessor );
+	t.strictEqual( isnan( v ), true, 'returns expected value' );
+	t.end();
+});
+
+tape( 'if provided an array containing a single element, the function returns the result of applying a provided callback function to that element', function test( t ) {
+	var v = nanmaxBy( [ 1.0 ], accessor );
+	t.strictEqual( v, 2.0, 'returns expected value' );
+	t.end();
+});
+
+tape( 'if provided an array containing a single element, the function returns the result of applying a provided callback function to that element (accessors)', function test( t ) {
+	var v = nanmaxBy( toAccessorArray( [ 1.0 ] ), accessor );
+	t.strictEqual( v, 2.0, 'returns expected value' );
+	t.end();
+});

From d162f335b4c2f79860ab3b27f62889517735a15b Mon Sep 17 00:00:00 2001
From: Gururaj Gurram <143020143+gururaj1512@users.noreply.github.com>
Date: Wed, 4 Jun 2025 19:06:08 +0530
Subject: [PATCH 2/5] fix: update test case values

Signed-off-by: Gururaj Gurram <143020143+gururaj1512@users.noreply.github.com>
---
 lib/node_modules/@stdlib/stats/array/nanmax-by/test/test.js | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/lib/node_modules/@stdlib/stats/array/nanmax-by/test/test.js b/lib/node_modules/@stdlib/stats/array/nanmax-by/test/test.js
index 0ff603ba5a7b..e174cea0d854 100644
--- a/lib/node_modules/@stdlib/stats/array/nanmax-by/test/test.js
+++ b/lib/node_modules/@stdlib/stats/array/nanmax-by/test/test.js
@@ -162,11 +162,11 @@ tape( 'the function calculates the maximum value of an array via a callback func
 
 	x = [ 1.0, -2.0, -4.0, 5.0, 0.0, 3.0, NaN, NaN ];
 	v = nanmaxBy( toAccessorArray( x ), accessor );
-	t.strictEqual( v, 5.0, 'returns expected value' );
+	t.strictEqual( v, 10.0, 'returns expected value' );
 
 	x = [ -4.0, NaN, -5.0 ];
 	v = nanmaxBy( toAccessorArray( x ), accessor );
-	t.strictEqual( v, -4.0, 'returns expected value' );
+	t.strictEqual( v, -8.0, 'returns expected value' );
 
 	x = [ -0.0, NaN, 0.0, -0.0 ];
 	v = nanmaxBy( toAccessorArray( x ), accessor );
@@ -266,7 +266,7 @@ tape( 'the function supports providing a callback execution context (accessors)'
 	t.deepEqual( indices, expected, 'returns expected value' );
 
 	expected = [ 1.0, 2.0, 3.0, NaN, 4.0, 5.0 ];
-	t.deepEqual( values, expected, 'returns expected value' );
+	t.deepEqual( isSameArray( values, expected ), true, 'returns expected value' );
 
 	expected = [ ax, ax, ax, ax, ax, ax ];
 	t.deepEqual( arrays, expected, 'returns expected value' );

From 0fab6389c0342ea35ecc0c5bc7c8ed4fac7f94a2 Mon Sep 17 00:00:00 2001
From: Athan <kgryte@gmail.com>
Date: Wed, 4 Jun 2025 20:48:22 -0700
Subject: [PATCH 3/5] docs: add note

Signed-off-by: Athan <kgryte@gmail.com>
---
 lib/node_modules/@stdlib/stats/array/nanmax-by/README.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/lib/node_modules/@stdlib/stats/array/nanmax-by/README.md b/lib/node_modules/@stdlib/stats/array/nanmax-by/README.md
index bbdac2557fc5..b2c30c6b7709 100644
--- a/lib/node_modules/@stdlib/stats/array/nanmax-by/README.md
+++ b/lib/node_modules/@stdlib/stats/array/nanmax-by/README.md
@@ -94,6 +94,7 @@ var cnt = context.count;
 
 -   If provided an empty array, the function returns `NaN`.
 -   A provided callback function should return a numeric value.
+-   If a provided callback function returns `NaN`, the value is **ignored**.
 -   If a provided callback function does not return any value (or equivalently, explicitly returns `undefined`), the value is **ignored**.
 -   The function supports array-like objects having getter and setter accessors for array element access (e.g., [`@stdlib/array/base/accessor`][@stdlib/array/base/accessor]).
 

From 62a06d4a0e31b2361c306fdcfe720ec9c3e5c71b Mon Sep 17 00:00:00 2001
From: Athan <kgryte@gmail.com>
Date: Wed, 4 Jun 2025 20:49:43 -0700
Subject: [PATCH 4/5] docs: add note

Signed-off-by: Athan <kgryte@gmail.com>
---
 lib/node_modules/@stdlib/stats/array/nanmax-by/docs/repl.txt | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/lib/node_modules/@stdlib/stats/array/nanmax-by/docs/repl.txt b/lib/node_modules/@stdlib/stats/array/nanmax-by/docs/repl.txt
index e096333fbf19..c08a7ba9d729 100644
--- a/lib/node_modules/@stdlib/stats/array/nanmax-by/docs/repl.txt
+++ b/lib/node_modules/@stdlib/stats/array/nanmax-by/docs/repl.txt
@@ -13,6 +13,8 @@
 
     The callback function should return a numeric value.
 
+    If the callback function returns `NaN`, the value is ignored.
+
     If the callback function does not return any value (or equivalently,
     explicitly returns `undefined`), the value is ignored.
 

From c47834f691c5d4e0f70b0c0e3d7c39c153a11e30 Mon Sep 17 00:00:00 2001
From: Athan <kgryte@gmail.com>
Date: Wed, 4 Jun 2025 21:11:25 -0700
Subject: [PATCH 5/5] chore: 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: na
  - 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: na
  - task: lint_javascript_tests
    status: passed
  - 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
---
---
 .../stats/array/nanmax-by/docs/repl.txt       |  2 +-
 .../array/nanmax-by/docs/types/index.d.ts     |  6 ++--
 .../stats/array/nanmax-by/docs/types/test.ts  | 10 ++++--
 .../@stdlib/stats/array/nanmax-by/lib/main.js | 24 +++-----------
 .../stats/array/nanmax-by/test/test.js        | 33 +++++--------------
 5 files changed, 24 insertions(+), 51 deletions(-)

diff --git a/lib/node_modules/@stdlib/stats/array/nanmax-by/docs/repl.txt b/lib/node_modules/@stdlib/stats/array/nanmax-by/docs/repl.txt
index c08a7ba9d729..ebd7f759e28d 100644
--- a/lib/node_modules/@stdlib/stats/array/nanmax-by/docs/repl.txt
+++ b/lib/node_modules/@stdlib/stats/array/nanmax-by/docs/repl.txt
@@ -20,7 +20,7 @@
 
     Parameters
     ----------
-    x: Array<number>|TypedArray
+    x: Array|TypedArray
         Input array.
 
     clbk: Function
diff --git a/lib/node_modules/@stdlib/stats/array/nanmax-by/docs/types/index.d.ts b/lib/node_modules/@stdlib/stats/array/nanmax-by/docs/types/index.d.ts
index 24ffc865bbdb..3eb951120ef7 100644
--- a/lib/node_modules/@stdlib/stats/array/nanmax-by/docs/types/index.d.ts
+++ b/lib/node_modules/@stdlib/stats/array/nanmax-by/docs/types/index.d.ts
@@ -20,12 +20,12 @@
 
 /// <reference types="@stdlib/types"/>
 
-import { NumericArray, Collection, AccessorArrayLike } from '@stdlib/types/array';
+import { Collection, AccessorArrayLike } from '@stdlib/types/array';
 
 /**
 * Input array.
 */
-type InputArray = NumericArray | Collection<number> | AccessorArrayLike<number>;
+type InputArray<T> = Collection<T> | AccessorArrayLike<T>;
 
 /**
 * Returns an accessed value.
@@ -89,7 +89,7 @@ type Callback<T, U, ThisArg> = Nullary<ThisArg> | Unary<T, ThisArg> | Binary<T,
 * var v = nanmaxBy( x, accessor );
 * // returns 8.0
 */
-declare function nanmaxBy<T = number, U extends InputArray = InputArray, ThisArg = unknown>( x: U, clbk: Callback<T, U, ThisArg>, thisArg?: ThisParameterType<Callback<T, U, ThisArg>> ): number;
+declare function nanmaxBy<T = unknown, U extends InputArray<T> = InputArray<T>, ThisArg = unknown>( x: U, clbk: Callback<T, U, ThisArg>, thisArg?: ThisParameterType<Callback<T, U, ThisArg>> ): number;
 
 
 // EXPORTS //
diff --git a/lib/node_modules/@stdlib/stats/array/nanmax-by/docs/types/test.ts b/lib/node_modules/@stdlib/stats/array/nanmax-by/docs/types/test.ts
index ec0e238dbfbe..38727f9cd9b4 100644
--- a/lib/node_modules/@stdlib/stats/array/nanmax-by/docs/types/test.ts
+++ b/lib/node_modules/@stdlib/stats/array/nanmax-by/docs/types/test.ts
@@ -19,9 +19,14 @@
 import AccessorArray = require( '@stdlib/array/base/accessor' );
 import nanmaxBy = require( './index' );
 
-const accessor = (): number => {
+/**
+* Accessor function.
+*
+* @returns accessed value
+*/
+function accessor(): number {
 	return 5.0;
-};
+}
 
 
 // TESTS //
@@ -40,7 +45,6 @@ const accessor = (): number => {
 // The compiler throws an error if the function is provided a first argument which is not a numeric array...
 {
 	nanmaxBy( 10, accessor ); // $ExpectError
-	nanmaxBy( '10', accessor ); // $ExpectError
 	nanmaxBy( true, accessor ); // $ExpectError
 	nanmaxBy( false, accessor ); // $ExpectError
 	nanmaxBy( null, accessor ); // $ExpectError
diff --git a/lib/node_modules/@stdlib/stats/array/nanmax-by/lib/main.js b/lib/node_modules/@stdlib/stats/array/nanmax-by/lib/main.js
index d0dbe8e42c1f..204cfe374de8 100644
--- a/lib/node_modules/@stdlib/stats/array/nanmax-by/lib/main.js
+++ b/lib/node_modules/@stdlib/stats/array/nanmax-by/lib/main.js
@@ -21,19 +21,9 @@
 // MODULES //
 
 var isCollection = require( '@stdlib/assert/is-collection' );
-var dtypes = require( '@stdlib/array/dtypes' );
-var dtype = require( '@stdlib/array/dtype' );
-var contains = require( '@stdlib/array/base/assert/contains' );
-var join = require( '@stdlib/array/base/join' );
+var isFunction = require( '@stdlib/assert/is-function' );
 var strided = require( '@stdlib/stats/base/nanmax-by' ).ndarray;
 var format = require( '@stdlib/string/format' );
-var isFunction = require( '@stdlib/assert/is-function' );
-
-
-// VARIABLES //
-
-var IDTYPES = dtypes( 'real_and_generic' );
-var GENERIC_DTYPE = 'generic';
 
 
 // MAIN //
@@ -41,11 +31,10 @@ var GENERIC_DTYPE = 'generic';
 /**
 * Computes the maximum value of an array via a callback function, ignoring `NaN` values.
 *
-* @param {NumericArray} x - input array
+* @param {Collection} x - input array
 * @param {Callback} clbk - callback
 * @param {*} [thisArg] - execution context
 * @throws {TypeError} first argument must be an array-like object
-* @throws {TypeError} first argument must have a supported data type
 * @throws {TypeError} second argument must be a function
 * @returns {number} maximum value
 *
@@ -60,14 +49,9 @@ var GENERIC_DTYPE = 'generic';
 * // returns 8.0
 */
 function nanmaxBy( x, clbk, thisArg ) {
-	var dt;
 	if ( !isCollection( x ) ) {
 		throw new TypeError( format( 'invalid argument. First argument must be an array-like object. Value: `%s`.', x ) );
 	}
-	dt = dtype( x ) || GENERIC_DTYPE;
-	if ( !contains( IDTYPES, dt ) ) {
-		throw new TypeError( format( 'invalid argument. First argument must have one of the following data types: "%s". Data type: `%s`.', join( IDTYPES, '", "' ), dt ) );
-	}
 	if ( !isFunction( clbk ) ) {
 		throw new TypeError( format( 'invalid argument. Second argument must be a function. Value: `%s`.', clbk ) );
 	}
@@ -77,10 +61,10 @@ function nanmaxBy( x, clbk, thisArg ) {
 	* Invokes a provided callback.
 	*
 	* @private
-	* @param {number} value - current element
+	* @param {*} value - current element
 	* @param {NonNegativeInteger} aidx - current array index
 	* @param {NonNegativeInteger} sidx - current strided index
-	* @param {NumericArray} arr - input array
+	* @param {Collection} arr - input array
 	* @returns {number} callback return value
 	*/
 	function wrapper( value, aidx, sidx, arr ) {
diff --git a/lib/node_modules/@stdlib/stats/array/nanmax-by/test/test.js b/lib/node_modules/@stdlib/stats/array/nanmax-by/test/test.js
index e174cea0d854..740d25a83440 100644
--- a/lib/node_modules/@stdlib/stats/array/nanmax-by/test/test.js
+++ b/lib/node_modules/@stdlib/stats/array/nanmax-by/test/test.js
@@ -24,14 +24,19 @@ var tape = require( 'tape' );
 var isnan = require( '@stdlib/math/base/assert/is-nan' );
 var toAccessorArray = require( '@stdlib/array/base/to-accessor-array' );
 var isPositiveZero = require( '@stdlib/math/base/assert/is-positive-zero' );
-var BooleanArray = require( '@stdlib/array/bool' );
-var Complex128Array = require( '@stdlib/array/complex128' );
 var isSameArray = require( '@stdlib/assert/is-same-array' );
 var nanmaxBy = require( './../lib/main.js' );
 
 
 // FUNCTIONS //
 
+/**
+* Accessor function.
+*
+* @private
+* @param {number} v - value
+* @returns {(number|void)} result
+*/
 function accessor( v ) {
 	if ( v === void 0 ) {
 		return;
@@ -80,26 +85,6 @@ tape( 'the function throws an error if provided a first argument which is not an
 	}
 });
 
-tape( 'the function throws an error if provided a first argument which has an unsupported data type', function test( t ) {
-	var values;
-	var i;
-
-	values = [
-		new BooleanArray( 4 ),
-		new Complex128Array( 4 )
-	];
-	for ( i = 0; i < values.length; i++ ) {
-		t.throws( badValue( values[ i ] ), TypeError, 'throws an error when provided ' + values[ i ] );
-	}
-	t.end();
-
-	function badValue( value ) {
-		return function badValue() {
-			nanmaxBy( value );
-		};
-	}
-});
-
 tape( 'the function throws an error if provided a second argument which is not a function', function test( t ) {
 	var values;
 	var i;
@@ -226,7 +211,7 @@ tape( 'the function supports providing a callback execution context', function t
 	t.deepEqual( indices, expected, 'returns expected value' );
 
 	expected = [ 1.0, 2.0, 3.0, NaN, 4.0, 5.0 ];
-	t.deepEqual( isSameArray( values, expected ), true, 'returns expected value' );
+	t.strictEqual( isSameArray( values, expected ), true, 'returns expected value' );
 
 	expected = [ x, x, x, x, x, x ];
 	t.deepEqual( arrays, expected, 'returns expected value' );
@@ -266,7 +251,7 @@ tape( 'the function supports providing a callback execution context (accessors)'
 	t.deepEqual( indices, expected, 'returns expected value' );
 
 	expected = [ 1.0, 2.0, 3.0, NaN, 4.0, 5.0 ];
-	t.deepEqual( isSameArray( values, expected ), true, 'returns expected value' );
+	t.strictEqual( isSameArray( values, expected ), true, 'returns expected value' );
 
 	expected = [ ax, ax, ax, ax, ax, ax ];
 	t.deepEqual( arrays, expected, 'returns expected value' );