From 95ee555651df9f9704d1c265cfe44386e11d39f4 Mon Sep 17 00:00:00 2001
From: headlessNode <harriskhan047@outlook.com>
Date: Sat, 27 Sep 2025 11:42:01 +0500
Subject: [PATCH 1/5] feat: add ndarray/reverse

---
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/ndarray/reverse/README.md         | 140 +++++++++++
 .../ndarray/reverse/benchmark/benchmark.js    | 223 ++++++++++++++++++
 .../@stdlib/ndarray/reverse/docs/repl.txt     |  28 +++
 .../ndarray/reverse/docs/types/index.d.ts     |  57 +++++
 .../ndarray/reverse/docs/types/test.ts        |  53 +++++
 .../@stdlib/ndarray/reverse/examples/index.js |  38 +++
 .../@stdlib/ndarray/reverse/lib/index.js      |  56 +++++
 .../@stdlib/ndarray/reverse/lib/main.js       |  68 ++++++
 .../@stdlib/ndarray/reverse/package.json      |  64 +++++
 .../@stdlib/ndarray/reverse/test/test.js      | 170 +++++++++++++
 10 files changed, 897 insertions(+)
 create mode 100644 lib/node_modules/@stdlib/ndarray/reverse/README.md
 create mode 100644 lib/node_modules/@stdlib/ndarray/reverse/benchmark/benchmark.js
 create mode 100644 lib/node_modules/@stdlib/ndarray/reverse/docs/repl.txt
 create mode 100644 lib/node_modules/@stdlib/ndarray/reverse/docs/types/index.d.ts
 create mode 100644 lib/node_modules/@stdlib/ndarray/reverse/docs/types/test.ts
 create mode 100644 lib/node_modules/@stdlib/ndarray/reverse/examples/index.js
 create mode 100644 lib/node_modules/@stdlib/ndarray/reverse/lib/index.js
 create mode 100644 lib/node_modules/@stdlib/ndarray/reverse/lib/main.js
 create mode 100644 lib/node_modules/@stdlib/ndarray/reverse/package.json
 create mode 100644 lib/node_modules/@stdlib/ndarray/reverse/test/test.js

diff --git a/lib/node_modules/@stdlib/ndarray/reverse/README.md b/lib/node_modules/@stdlib/ndarray/reverse/README.md
new file mode 100644
index 000000000000..5424c647f760
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/reverse/README.md
@@ -0,0 +1,140 @@
+<!--
+
+@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.
+
+-->
+
+# reverse
+
+> Return a **read-only** view of an input ndarray in which the order of elements along each dimension is reversed.
+
+<!-- Section to include introductory text. Make sure to keep an empty line after the intro section element. -->
+
+<section class="intro">
+
+</section>
+
+<!-- /.intro -->
+
+<!-- Package usage documentation. -->
+
+<section class="usage">
+
+## Usage
+
+```javascript
+var reverse = require( '@stdlib/ndarray/reverse' );
+```
+
+#### reverse( x )
+
+Returns a read-only view of an input ndarray in which the order of elements along each dimension is reversed.
+
+```javascript
+var ndarray = require( '@stdlib/ndarray/ctor' );
+var ndarray2array = require( '@stdlib/ndarray/to-array' );
+
+var buffer = [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ];
+var shape = [ 3, 2 ];
+var strides = [ 2, 1 ];
+var offset = 0;
+
+var x = ndarray( 'generic', buffer, shape, strides, offset, 'row-major' );
+// returns <ndarray>
+
+var arr = ndarray2array( x );
+// returns [ [ 1.0, 2.0 ], [ 3.0, 4.0 ], [ 5.0, 6.0 ] ]
+
+var y = reverse( x );
+// returns <ndarray>
+
+arr = ndarray2array( y );
+// returns [ [ 6.0, 5.0 ], [ 4.0, 3.0 ], [ 2.0, 1.0 ] ]
+```
+
+</section>
+
+<!-- /.usage -->
+
+<!-- Package usage notes. Make sure to keep an empty line after the `section` element and another before the `/section` close. -->
+
+<section class="notes">
+
+</section>
+
+<!-- /.notes -->
+
+<!-- Package usage examples. -->
+
+<section class="examples">
+
+## Examples
+
+<!-- eslint no-undef: "error" -->
+
+```javascript
+var ndarray = require( '@stdlib/ndarray/ctor' );
+var ndarray2array = require( '@stdlib/ndarray/to-array' );
+var reverse = require( '@stdlib/ndarray/reverse' );
+
+var buffer = [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 ];
+var shape = [ 2, 2, 2 ];
+var strides = [ 4, 2, 1 ];
+var offset = 0;
+
+var x = ndarray( 'generic', buffer, shape, strides, offset, 'row-major' );
+// returns <ndarray>
+
+console.log( ndarray2array( x ) );
+
+var y = reverse( x );
+// returns <ndarray>
+
+console.log( ndarray2array( y ) );
+```
+
+</section>
+
+<!-- /.examples -->
+
+<!-- Section to include cited references. If references are included, add a horizontal rule *before* the section. Make sure to keep an empty line after the `section` element and another before the `/section` close. -->
+
+<section class="references">
+
+</section>
+
+<!-- /.references -->
+
+<!-- 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">
+
+<!-- <related-links> -->
+
+<!-- </related-links> -->
+
+</section>
+
+<!-- /.links -->
diff --git a/lib/node_modules/@stdlib/ndarray/reverse/benchmark/benchmark.js b/lib/node_modules/@stdlib/ndarray/reverse/benchmark/benchmark.js
new file mode 100644
index 000000000000..529cb6ebaf93
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/reverse/benchmark/benchmark.js
@@ -0,0 +1,223 @@
+/**
+* @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 isndarrayLike = require( '@stdlib/assert/is-ndarray-like' );
+var empty = require( '@stdlib/ndarray/empty' );
+var pkg = require( './../package.json' ).name;
+var reverse = require( './../lib' );
+
+
+// MAIN //
+
+bench( pkg+'::0d', function benchmark( b ) {
+	var values;
+	var v;
+	var i;
+
+	/* eslint-disable object-curly-newline, stdlib/line-closing-bracket-spacing */
+
+	values = [
+
+		empty( [], { 'dtype': 'float64' } ),
+		empty( [], { 'dtype': 'float32' } ),
+		empty( [], { 'dtype': 'int32' } ),
+		empty( [], { 'dtype': 'complex128' } ),
+		empty( [], { 'dtype': 'generic' } )
+	];
+
+	/* eslint-enable object-curly-newline, stdlib/line-closing-bracket-spacing */
+
+	b.tic();
+	for ( i = 0; i < b.iterations; i++ ) {
+		v = reverse( values[ i%values.length ] );
+		if ( typeof v !== 'object' ) {
+			b.fail( 'should return an ndarray' );
+		}
+	}
+	b.toc();
+	if ( !isndarrayLike( v ) ) {
+		b.fail( 'should return an ndarray' );
+	}
+	b.pass( 'benchmark finished' );
+	b.end();
+});
+
+bench( pkg+'::1d', function benchmark( b ) {
+	var values;
+	var v;
+	var i;
+
+	/* eslint-disable object-curly-newline, stdlib/line-closing-bracket-spacing */
+
+	values = [
+		empty( [ 2 ], { 'dtype': 'float64' } ),
+		empty( [ 2 ], { 'dtype': 'float32' } ),
+		empty( [ 2 ], { 'dtype': 'int32' } ),
+		empty( [ 2 ], { 'dtype': 'complex128' } ),
+		empty( [ 2 ], { 'dtype': 'generic' } )
+	];
+
+	/* eslint-enable object-curly-newline, stdlib/line-closing-bracket-spacing */
+
+	b.tic();
+	for ( i = 0; i < b.iterations; i++ ) {
+		v = reverse( values[ i%values.length ] );
+		if ( typeof v !== 'object' ) {
+			b.fail( 'should return an ndarray' );
+		}
+	}
+	b.toc();
+	if ( !isndarrayLike( v ) ) {
+		b.fail( 'should return an ndarray' );
+	}
+	b.pass( 'benchmark finished' );
+	b.end();
+});
+
+bench( pkg+'::2d', function benchmark( b ) {
+	var values;
+	var v;
+	var i;
+
+	/* eslint-disable object-curly-newline, stdlib/line-closing-bracket-spacing */
+
+	values = [
+		empty( [ 2, 2 ], { 'dtype': 'float64' } ),
+		empty( [ 2, 2 ], { 'dtype': 'float32' } ),
+		empty( [ 2, 2 ], { 'dtype': 'int32' } ),
+		empty( [ 2, 2 ], { 'dtype': 'complex128' } ),
+		empty( [ 2, 2 ], { 'dtype': 'generic' } )
+	];
+
+	/* eslint-enable object-curly-newline, stdlib/line-closing-bracket-spacing */
+
+	b.tic();
+	for ( i = 0; i < b.iterations; i++ ) {
+		v = reverse( values[ i%values.length ] );
+		if ( typeof v !== 'object' ) {
+			b.fail( 'should return an ndarray' );
+		}
+	}
+	b.toc();
+	if ( !isndarrayLike( v ) ) {
+		b.fail( 'should return an ndarray' );
+	}
+	b.pass( 'benchmark finished' );
+	b.end();
+});
+
+bench( pkg+'::3d', function benchmark( b ) {
+	var values;
+	var v;
+	var i;
+
+	/* eslint-disable object-curly-newline, stdlib/line-closing-bracket-spacing */
+
+	values = [
+		empty( [ 2, 2, 2 ], { 'dtype': 'float64' } ),
+		empty( [ 2, 2, 2 ], { 'dtype': 'float32' } ),
+		empty( [ 2, 2, 2 ], { 'dtype': 'int32' } ),
+		empty( [ 2, 2, 2 ], { 'dtype': 'complex128' } ),
+		empty( [ 2, 2, 2 ], { 'dtype': 'generic' } )
+	];
+
+	/* eslint-enable object-curly-newline, stdlib/line-closing-bracket-spacing */
+
+	b.tic();
+	for ( i = 0; i < b.iterations; i++ ) {
+		v = reverse( values[ i%values.length ] );
+		if ( typeof v !== 'object' ) {
+			b.fail( 'should return an ndarray' );
+		}
+	}
+	b.toc();
+	if ( !isndarrayLike( v ) ) {
+		b.fail( 'should return an ndarray' );
+	}
+	b.pass( 'benchmark finished' );
+	b.end();
+});
+
+bench( pkg+'::4d', function benchmark( b ) {
+	var values;
+	var v;
+	var i;
+
+	/* eslint-disable object-curly-newline, stdlib/line-closing-bracket-spacing */
+
+	values = [
+		empty( [ 2, 2, 2, 2 ], { 'dtype': 'float64' } ),
+		empty( [ 2, 2, 2, 2 ], { 'dtype': 'float32' } ),
+		empty( [ 2, 2, 2, 2 ], { 'dtype': 'int32' } ),
+		empty( [ 2, 2, 2, 2 ], { 'dtype': 'complex128' } ),
+		empty( [ 2, 2, 2, 2 ], { 'dtype': 'generic' } )
+	];
+
+	/* eslint-enable object-curly-newline, stdlib/line-closing-bracket-spacing */
+
+	b.tic();
+	for ( i = 0; i < b.iterations; i++ ) {
+		v = reverse( values[ i%values.length ] );
+		if ( typeof v !== 'object' ) {
+			b.fail( 'should return an ndarray' );
+		}
+	}
+	b.toc();
+	if ( !isndarrayLike( v ) ) {
+		b.fail( 'should return an ndarray' );
+	}
+	b.pass( 'benchmark finished' );
+	b.end();
+});
+
+bench( pkg+'::5d', function benchmark( b ) {
+	var values;
+	var v;
+	var i;
+
+	/* eslint-disable object-curly-newline, stdlib/line-closing-bracket-spacing */
+
+	values = [
+		empty( [ 2, 2, 2, 2, 2 ], { 'dtype': 'float64' } ),
+		empty( [ 2, 2, 2, 2, 2 ], { 'dtype': 'float32' } ),
+		empty( [ 2, 2, 2, 2, 2 ], { 'dtype': 'int32' } ),
+		empty( [ 2, 2, 2, 2, 2 ], { 'dtype': 'complex128' } ),
+		empty( [ 2, 2, 2, 2, 2 ], { 'dtype': 'generic' } )
+	];
+
+	/* eslint-enable object-curly-newline, stdlib/line-closing-bracket-spacing */
+
+	b.tic();
+	for ( i = 0; i < b.iterations; i++ ) {
+		v = reverse( values[ i%values.length ] );
+		if ( typeof v !== 'object' ) {
+			b.fail( 'should return an ndarray' );
+		}
+	}
+	b.toc();
+	if ( !isndarrayLike( v ) ) {
+		b.fail( 'should return an ndarray' );
+	}
+	b.pass( 'benchmark finished' );
+	b.end();
+});
diff --git a/lib/node_modules/@stdlib/ndarray/reverse/docs/repl.txt b/lib/node_modules/@stdlib/ndarray/reverse/docs/repl.txt
new file mode 100644
index 000000000000..1be14dafe445
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/reverse/docs/repl.txt
@@ -0,0 +1,28 @@
+{{alias}}( x )
+    Returns a read-only view of an input ndarray in which the order of
+    elements along each dimension is reversed.
+
+    Parameters
+    ----------
+    x: ndarray
+        Input array.
+
+    Returns
+    -------
+    out: ndarray
+        A read-only view of an input ndarray in which the order of elements
+        along each dimension is reversed.
+
+    Examples
+    --------
+    > var x = {{alias:@stdlib/ndarray/array}}( [ [ 1, 2 ], [ 3, 4 ] ] )
+    <ndarray>
+    > {{alias:@stdlib/ndarray/to-array}}( x )
+    [ [ 1, 2 ], [ 3, 4 ] ]
+    > var y = {{alias}}( x )
+    <ndarray>
+    > {{alias:@stdlib/ndarray/to-array}}( y )
+    [ [ 4, 3 ], [ 2, 1 ] ]
+
+    See Also
+    --------
diff --git a/lib/node_modules/@stdlib/ndarray/reverse/docs/types/index.d.ts b/lib/node_modules/@stdlib/ndarray/reverse/docs/types/index.d.ts
new file mode 100644
index 000000000000..86f5cc3b987a
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/reverse/docs/types/index.d.ts
@@ -0,0 +1,57 @@
+/*
+* @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 { ndarray } from '@stdlib/types/ndarray';
+
+/**
+* Returns a read-only view of an input ndarray in which the order of elements along each dimension is reversed.
+*
+* @param x - input array
+* @returns output array
+*
+* @example
+* var ndarray = require( '@stdlib/ndarray/ctor' );
+* var ndarray2array = require( '@stdlib/ndarray/to-array' );
+*
+* var buffer = [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ];
+* var shape = [ 3, 2 ];
+* var strides = [ 2, 1 ];
+* var offset = 0;
+*
+* var x = ndarray( 'generic', buffer, shape, strides, offset, 'row-major' );
+* // returns <ndarray>
+*
+* var arr = ndarray2array( x );
+* // returns [ [ 1.0, 2.0 ], [ 3.0, 4.0 ], [ 5.0, 6.0 ] ]
+*
+* var y = reverse( x );
+* // returns <ndarray>
+*
+* arr = ndarray2array( y );
+* // returns [ [ 6.0, 5.0 ], [ 4.0, 3.0 ], [ 2.0, 1.0 ] ]
+*/
+declare function reverse<T extends ndarray = ndarray>( x: T ): T;
+
+
+// EXPORTS //
+
+export = reverse;
diff --git a/lib/node_modules/@stdlib/ndarray/reverse/docs/types/test.ts b/lib/node_modules/@stdlib/ndarray/reverse/docs/types/test.ts
new file mode 100644
index 000000000000..897c27af63ff
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/reverse/docs/types/test.ts
@@ -0,0 +1,53 @@
+/*
+* @license Apache-2.0
+*
+* Copyright (c) 2025 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*    http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+import empty = require( '@stdlib/ndarray/base/empty' );
+import reverse = require( './index' );
+
+
+// TESTS //
+
+// The function returns an ndarray...
+{
+	const order = 'row-major';
+	const sh = [ 2, 2 ];
+
+	reverse( empty( 'float64', sh, order ) ); // $ExpectType float64ndarray
+	reverse( empty( 'complex64', sh, order ) ); // $ExpectType complex64ndarray
+	reverse( empty( 'int32', sh, order ) ); // $ExpectType int32ndarray
+}
+
+// The compiler throws an error if the function is provided a first argument which is not an ndarray...
+{
+	reverse( '10' ); // $ExpectError
+	reverse( 10 ); // $ExpectError
+	reverse( false ); // $ExpectError
+	reverse( true ); // $ExpectError
+	reverse( null ); // $ExpectError
+	reverse( [] ); // $ExpectError
+	reverse( {} ); // $ExpectError
+	reverse( ( x: number ): number => x ); // $ExpectError
+}
+
+// The compiler throws an error if the function is provided an unsupported number of arguments...
+{
+	const x = empty( 'float64', [ 2, 2 ], 'row-major' );
+
+	reverse(); // $ExpectError
+	reverse( x, {} ); // $ExpectError
+}
diff --git a/lib/node_modules/@stdlib/ndarray/reverse/examples/index.js b/lib/node_modules/@stdlib/ndarray/reverse/examples/index.js
new file mode 100644
index 000000000000..3d8ac402a7d4
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/reverse/examples/index.js
@@ -0,0 +1,38 @@
+/**
+* @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 ndarray = require( '@stdlib/ndarray/ctor' );
+var ndarray2array = require( '@stdlib/ndarray/to-array' );
+var reverse = require( './../lib' );
+
+var buffer = [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 ];
+var shape = [ 2, 2, 2 ];
+var strides = [ 4, 2, 1 ];
+var offset = 0;
+
+var x = ndarray( 'generic', buffer, shape, strides, offset, 'row-major' );
+// returns <ndarray>
+
+console.log( ndarray2array( x ) );
+
+var y = reverse( x );
+// returns <ndarray>
+
+console.log( ndarray2array( y ) );
diff --git a/lib/node_modules/@stdlib/ndarray/reverse/lib/index.js b/lib/node_modules/@stdlib/ndarray/reverse/lib/index.js
new file mode 100644
index 000000000000..fb0494a6e37c
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/reverse/lib/index.js
@@ -0,0 +1,56 @@
+/**
+* @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';
+
+/**
+* Return a read-only view of an input ndarray in which the order of elements along each dimension is reversed.
+*
+* @module @stdlib/ndarray/reverse
+*
+* @example
+* var ndarray = require( '@stdlib/ndarray/ctor' );
+* var ndarray2array = require( '@stdlib/ndarray/to-array' );
+* var reverse = require( '@stdlib/ndarray/reverse' );
+*
+* var buffer = [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ];
+* var shape = [ 3, 2 ];
+* var strides = [ 2, 1 ];
+* var offset = 0;
+*
+* var x = ndarray( 'generic', buffer, shape, strides, offset, 'row-major' );
+* // returns <ndarray>
+*
+* var arr = ndarray2array( x );
+* // returns [ [ 1.0, 2.0 ], [ 3.0, 4.0 ], [ 5.0, 6.0 ] ]
+*
+* var y = reverse( x );
+* // returns <ndarray>
+*
+* arr = ndarray2array( y );
+* // returns [ [ 6.0, 5.0 ], [ 4.0, 3.0 ], [ 2.0, 1.0 ] ]
+*/
+
+// MODULES //
+
+var main = require( './main.js' );
+
+
+// EXPORTS //
+
+module.exports = main;
diff --git a/lib/node_modules/@stdlib/ndarray/reverse/lib/main.js b/lib/node_modules/@stdlib/ndarray/reverse/lib/main.js
new file mode 100644
index 000000000000..ae323dfd581c
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/reverse/lib/main.js
@@ -0,0 +1,68 @@
+/**
+* @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 isndarrayLike = require( '@stdlib/assert/is-ndarray-like' );
+var base = require( '@stdlib/ndarray/base/reverse' );
+var format = require( '@stdlib/string/format' );
+
+
+// MAIN //
+
+/**
+* Returns a read-only view of an input ndarray in which the order of elements along each dimension is reversed.
+*
+* @param {ndarray} x - input array
+* @throws {TypeError} first argument must be an ndarray having one or more dimensions
+* @returns {ndarray} ndarray view
+*
+* @example
+* var ndarray = require( '@stdlib/ndarray/ctor' );
+* var ndarray2array = require( '@stdlib/ndarray/to-array' );
+*
+* var buffer = [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ];
+* var shape = [ 3, 2 ];
+* var strides = [ 2, 1 ];
+* var offset = 0;
+*
+* var x = ndarray( 'generic', buffer, shape, strides, offset, 'row-major' );
+* // returns <ndarray>
+*
+* var arr = ndarray2array( x );
+* // returns [ [ 1.0, 2.0 ], [ 3.0, 4.0 ], [ 5.0, 6.0 ] ]
+*
+* var y = reverse( x );
+* // returns <ndarray>
+*
+* arr = ndarray2array( y );
+* // returns [ [ 6.0, 5.0 ], [ 4.0, 3.0 ], [ 2.0, 1.0 ] ]
+*/
+function reverse( x ) {
+	if ( !isndarrayLike( x ) ) {
+		throw new TypeError( format( 'invalid argument. First argument must be an ndarray. Value: `%s`.', x ) );
+	}
+	return base( x, false );
+}
+
+
+// EXPORTS //
+
+module.exports = reverse;
diff --git a/lib/node_modules/@stdlib/ndarray/reverse/package.json b/lib/node_modules/@stdlib/ndarray/reverse/package.json
new file mode 100644
index 000000000000..6c25a4124323
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/reverse/package.json
@@ -0,0 +1,64 @@
+{
+  "name": "@stdlib/ndarray/reverse",
+  "version": "0.0.0",
+  "description": "Return a read-only view of an input ndarray in which the order of elements along each dimension is reversed.",
+  "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",
+    "stdtypes",
+    "types",
+    "data",
+    "structure",
+    "vector",
+    "ndarray",
+    "matrix",
+    "view",
+    "reverse",
+    "flip"
+  ]
+}
diff --git a/lib/node_modules/@stdlib/ndarray/reverse/test/test.js b/lib/node_modules/@stdlib/ndarray/reverse/test/test.js
new file mode 100644
index 000000000000..cba6274ff4d7
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/reverse/test/test.js
@@ -0,0 +1,170 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+*    http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+'use strict';
+
+// MODULES //
+
+var tape = require( 'tape' );
+var isndarrayLike = require( '@stdlib/assert/is-ndarray-like' );
+var isReadOnly = require( '@stdlib/ndarray/base/assert/is-read-only' );
+var zeroTo = require( '@stdlib/array/zero-to' );
+var ndarray = require( '@stdlib/ndarray/ctor' );
+var getShape = require( '@stdlib/ndarray/shape' );
+var ndarray2array = require( '@stdlib/ndarray/to-array' );
+var reverse = require( './../lib' );
+
+
+// TESTS //
+
+tape( 'main export is a function', function test( t ) {
+	t.ok( true, __filename );
+	t.strictEqual( typeof reverse, 'function', 'main export is a function' );
+	t.end();
+});
+
+tape( 'the function throws an error if provided a first argument which is not an ndarray', 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() {
+			reverse( value );
+		};
+	}
+});
+
+tape( 'the function returns a read-only view of an input ndarray in which the order of elements along each dimension is reversed (ndims=1)', function test( t ) {
+	var expected;
+	var actual;
+	var buf;
+	var ord;
+	var sh;
+	var st;
+	var o;
+	var x;
+
+	buf = zeroTo( 10, 'float64' );
+	sh = [ 5 ];
+	st = [ 2 ];
+	o = 0;
+	ord = 'row-major';
+
+	x = new ndarray( 'float64', buf, sh, st, o, ord );
+
+	actual = reverse( x );
+	expected = [ 8, 6, 4, 2, 0 ];
+
+	t.strictEqual( isndarrayLike( actual ), true, 'returns expected value' );
+	t.strictEqual( isReadOnly( actual ), true, 'returns expected value' );
+	t.deepEqual( getShape( x ), getShape( actual ), 'returns expected value' );
+	t.deepEqual( ndarray2array( actual ), expected, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function returns a read-only view of an input ndarray in which the order of elements along each dimension is reversed (ndims=2)', function test( t ) {
+	var expected;
+	var actual;
+	var buf;
+	var ord;
+	var sh;
+	var st;
+	var o;
+	var x;
+
+	buf = zeroTo( 12, 'float64' );
+	sh = [ 3, 2 ];
+	st = [ 4, 2 ];
+	o = 0;
+	ord = 'row-major';
+
+	x = new ndarray( 'float64', buf, sh, st, o, ord );
+
+	actual = reverse( x );
+	expected = [
+		[ 10, 8 ],
+		[ 6, 4 ],
+		[ 2, 0 ]
+	];
+
+	t.strictEqual( isndarrayLike( actual ), true, 'returns expected value' );
+	t.strictEqual( isReadOnly( actual ), true, 'returns expected value' );
+	t.deepEqual( getShape( x ), getShape( actual ), 'returns expected value' );
+	t.deepEqual( ndarray2array( actual ), expected, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function returns a read-only view of an input ndarray in which the order of elements along each dimension is reversed (ndims=3)', function test( t ) {
+	var expected;
+	var actual;
+	var buf;
+	var ord;
+	var sh;
+	var st;
+	var o;
+	var x;
+
+	buf = zeroTo( 24, 'float64' );
+	sh = [ 2, 3, 2 ];
+	st = [ 12, 4, 2 ];
+	o = 0;
+	ord = 'row-major';
+
+	x = new ndarray( 'float64', buf, sh, st, o, ord );
+
+	actual = reverse( x );
+	expected = [
+		[
+			[ 22, 20 ],
+			[ 18, 16 ],
+			[ 14, 12 ]
+		],
+		[
+			[ 10, 8 ],
+			[ 6, 4 ],
+			[ 2, 0 ]
+		]
+	];
+
+	t.strictEqual( isndarrayLike( actual ), true, 'returns expected value' );
+	t.strictEqual( isReadOnly( actual ), true, 'returns expected value' );
+	t.deepEqual( getShape( x ), getShape( actual ), 'returns expected value' );
+	t.deepEqual( ndarray2array( actual ), expected, 'returns expected value' );
+
+	t.end();
+});

From 330a705f06d5bdff11a143bdf923b55555a32ff4 Mon Sep 17 00:00:00 2001
From: headlessNode <harriskhan047@outlook.com>
Date: Sat, 27 Sep 2025 12:38:32 +0500
Subject: [PATCH 2/5] test: add test case

---
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: na
  - task: lint_javascript_src
    status: na
  - 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: na
  - task: lint_typescript_tests
    status: na
  - task: lint_license_headers
    status: passed
---
---
 .../@stdlib/ndarray/reverse/README.md         |  6 ++++--
 .../@stdlib/ndarray/reverse/test/test.js      | 20 +++++++++++++++++++
 2 files changed, 24 insertions(+), 2 deletions(-)

diff --git a/lib/node_modules/@stdlib/ndarray/reverse/README.md b/lib/node_modules/@stdlib/ndarray/reverse/README.md
index 5424c647f760..8b7d53d25dcd 100644
--- a/lib/node_modules/@stdlib/ndarray/reverse/README.md
+++ b/lib/node_modules/@stdlib/ndarray/reverse/README.md
@@ -20,7 +20,7 @@ limitations under the License.
 
 # reverse
 
-> Return a **read-only** view of an input ndarray in which the order of elements along each dimension is reversed.
+> Return a **read-only** view of an input [`ndarray`][@stdlib/ndarray/ctor] in which the order of elements along each dimension is reversed.
 
 <!-- Section to include introductory text. Make sure to keep an empty line after the intro section element. -->
 
@@ -42,7 +42,7 @@ var reverse = require( '@stdlib/ndarray/reverse' );
 
 #### reverse( x )
 
-Returns a read-only view of an input ndarray in which the order of elements along each dimension is reversed.
+Returns a read-only view of an input [`ndarray`][@stdlib/ndarray/ctor] in which the order of elements along each dimension is reversed.
 
 ```javascript
 var ndarray = require( '@stdlib/ndarray/ctor' );
@@ -131,6 +131,8 @@ console.log( ndarray2array( y ) );
 
 <section class="links">
 
+[@stdlib/ndarray/ctor]: https://github.com/stdlib-js/stdlib/tree/develop/lib/node_modules/%40stdlib/ndarray/ctor
+
 <!-- <related-links> -->
 
 <!-- </related-links> -->
diff --git a/lib/node_modules/@stdlib/ndarray/reverse/test/test.js b/lib/node_modules/@stdlib/ndarray/reverse/test/test.js
index cba6274ff4d7..5b81cb4ca8c4 100644
--- a/lib/node_modules/@stdlib/ndarray/reverse/test/test.js
+++ b/lib/node_modules/@stdlib/ndarray/reverse/test/test.js
@@ -26,6 +26,7 @@ var isReadOnly = require( '@stdlib/ndarray/base/assert/is-read-only' );
 var zeroTo = require( '@stdlib/array/zero-to' );
 var ndarray = require( '@stdlib/ndarray/ctor' );
 var getShape = require( '@stdlib/ndarray/shape' );
+var scalar2ndarray = require( '@stdlib/ndarray/from-scalar' );
 var ndarray2array = require( '@stdlib/ndarray/to-array' );
 var reverse = require( './../lib' );
 
@@ -67,6 +68,25 @@ tape( 'the function throws an error if provided a first argument which is not an
 	}
 });
 
+tape( 'the function returns a read-only view of a zero-dimensional input ndarray', function test( t ) {
+	var actual;
+	var x;
+
+	x = scalar2ndarray( 10.0, {
+		'dtype': 'float64',
+		'order': 'row-major'
+	});
+
+	actual = reverse( x );
+
+	t.strictEqual( isndarrayLike( actual ), true, 'returns expected value' );
+	t.strictEqual( isReadOnly( actual ), true, 'returns expected value' );
+	t.strictEqual( actual.get(), x.get(), 'returns expected value' );
+	t.deepEqual( getShape( x ), getShape( actual ), 'returns expected value' );
+
+	t.end();
+});
+
 tape( 'the function returns a read-only view of an input ndarray in which the order of elements along each dimension is reversed (ndims=1)', function test( t ) {
 	var expected;
 	var actual;

From 7e54eaddbecdeb75be30fdefdc2d31357f9f38e6 Mon Sep 17 00:00:00 2001
From: Athan <kgryte@gmail.com>
Date: Tue, 30 Sep 2025 12:13:08 +0100
Subject: [PATCH 3/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: 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: 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: na
  - task: lint_license_headers
    status: passed
---
---
 .../@stdlib/ndarray/reverse/README.md         | 24 +++++--------------
 .../@stdlib/ndarray/reverse/docs/repl.txt     |  5 ++--
 .../@stdlib/ndarray/reverse/examples/index.js | 13 ++--------
 .../@stdlib/ndarray/reverse/lib/main.js       |  2 +-
 .../@stdlib/ndarray/reverse/test/test.js      |  4 ++++
 5 files changed, 16 insertions(+), 32 deletions(-)

diff --git a/lib/node_modules/@stdlib/ndarray/reverse/README.md b/lib/node_modules/@stdlib/ndarray/reverse/README.md
index 8b7d53d25dcd..e71693720ed2 100644
--- a/lib/node_modules/@stdlib/ndarray/reverse/README.md
+++ b/lib/node_modules/@stdlib/ndarray/reverse/README.md
@@ -45,15 +45,12 @@ var reverse = require( '@stdlib/ndarray/reverse' );
 Returns a read-only view of an input [`ndarray`][@stdlib/ndarray/ctor] in which the order of elements along each dimension is reversed.
 
 ```javascript
-var ndarray = require( '@stdlib/ndarray/ctor' );
+var array = require( '@stdlib/ndarray/array' );
 var ndarray2array = require( '@stdlib/ndarray/to-array' );
 
-var buffer = [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ];
-var shape = [ 3, 2 ];
-var strides = [ 2, 1 ];
-var offset = 0;
-
-var x = ndarray( 'generic', buffer, shape, strides, offset, 'row-major' );
+var x = array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ], {
+    'shape': [ 3, 2 ]
+});
 // returns <ndarray>
 
 var arr = ndarray2array( x );
@@ -87,23 +84,14 @@ arr = ndarray2array( y );
 <!-- eslint no-undef: "error" -->
 
 ```javascript
-var ndarray = require( '@stdlib/ndarray/ctor' );
+var uniform = require( '@stdlib/random/uniform' );
 var ndarray2array = require( '@stdlib/ndarray/to-array' );
 var reverse = require( '@stdlib/ndarray/reverse' );
 
-var buffer = [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 ];
-var shape = [ 2, 2, 2 ];
-var strides = [ 4, 2, 1 ];
-var offset = 0;
-
-var x = ndarray( 'generic', buffer, shape, strides, offset, 'row-major' );
-// returns <ndarray>
-
+var x = uniform( [ 3, 3, 3 ], -10.0, 10.0 );
 console.log( ndarray2array( x ) );
 
 var y = reverse( x );
-// returns <ndarray>
-
 console.log( ndarray2array( y ) );
 ```
 
diff --git a/lib/node_modules/@stdlib/ndarray/reverse/docs/repl.txt b/lib/node_modules/@stdlib/ndarray/reverse/docs/repl.txt
index 1be14dafe445..4af1dfe9212d 100644
--- a/lib/node_modules/@stdlib/ndarray/reverse/docs/repl.txt
+++ b/lib/node_modules/@stdlib/ndarray/reverse/docs/repl.txt
@@ -1,6 +1,7 @@
+
 {{alias}}( x )
-    Returns a read-only view of an input ndarray in which the order of
-    elements along each dimension is reversed.
+    Returns a read-only view of an input ndarray in which the order of elements
+    along each dimension is reversed.
 
     Parameters
     ----------
diff --git a/lib/node_modules/@stdlib/ndarray/reverse/examples/index.js b/lib/node_modules/@stdlib/ndarray/reverse/examples/index.js
index 3d8ac402a7d4..633c03d10754 100644
--- a/lib/node_modules/@stdlib/ndarray/reverse/examples/index.js
+++ b/lib/node_modules/@stdlib/ndarray/reverse/examples/index.js
@@ -18,21 +18,12 @@
 
 'use strict';
 
-var ndarray = require( '@stdlib/ndarray/ctor' );
+var uniform = require( '@stdlib/random/uniform' );
 var ndarray2array = require( '@stdlib/ndarray/to-array' );
 var reverse = require( './../lib' );
 
-var buffer = [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 ];
-var shape = [ 2, 2, 2 ];
-var strides = [ 4, 2, 1 ];
-var offset = 0;
-
-var x = ndarray( 'generic', buffer, shape, strides, offset, 'row-major' );
-// returns <ndarray>
-
+var x = uniform( [ 3, 3, 3 ], -10.0, 10.0 );
 console.log( ndarray2array( x ) );
 
 var y = reverse( x );
-// returns <ndarray>
-
 console.log( ndarray2array( y ) );
diff --git a/lib/node_modules/@stdlib/ndarray/reverse/lib/main.js b/lib/node_modules/@stdlib/ndarray/reverse/lib/main.js
index ae323dfd581c..c854bf310afb 100644
--- a/lib/node_modules/@stdlib/ndarray/reverse/lib/main.js
+++ b/lib/node_modules/@stdlib/ndarray/reverse/lib/main.js
@@ -31,7 +31,7 @@ var format = require( '@stdlib/string/format' );
 * Returns a read-only view of an input ndarray in which the order of elements along each dimension is reversed.
 *
 * @param {ndarray} x - input array
-* @throws {TypeError} first argument must be an ndarray having one or more dimensions
+* @throws {TypeError} first argument must be an ndarray
 * @returns {ndarray} ndarray view
 *
 * @example
diff --git a/lib/node_modules/@stdlib/ndarray/reverse/test/test.js b/lib/node_modules/@stdlib/ndarray/reverse/test/test.js
index 5b81cb4ca8c4..4c391cb72530 100644
--- a/lib/node_modules/@stdlib/ndarray/reverse/test/test.js
+++ b/lib/node_modules/@stdlib/ndarray/reverse/test/test.js
@@ -79,6 +79,7 @@ tape( 'the function returns a read-only view of a zero-dimensional input ndarray
 
 	actual = reverse( x );
 
+	t.notEqual( actual, x, 'returns expected value' );
 	t.strictEqual( isndarrayLike( actual ), true, 'returns expected value' );
 	t.strictEqual( isReadOnly( actual ), true, 'returns expected value' );
 	t.strictEqual( actual.get(), x.get(), 'returns expected value' );
@@ -108,6 +109,7 @@ tape( 'the function returns a read-only view of an input ndarray in which the or
 	actual = reverse( x );
 	expected = [ 8, 6, 4, 2, 0 ];
 
+	t.notEqual( actual, x, 'returns expected value' );
 	t.strictEqual( isndarrayLike( actual ), true, 'returns expected value' );
 	t.strictEqual( isReadOnly( actual ), true, 'returns expected value' );
 	t.deepEqual( getShape( x ), getShape( actual ), 'returns expected value' );
@@ -141,6 +143,7 @@ tape( 'the function returns a read-only view of an input ndarray in which the or
 		[ 2, 0 ]
 	];
 
+	t.notEqual( actual, x, 'returns expected value' );
 	t.strictEqual( isndarrayLike( actual ), true, 'returns expected value' );
 	t.strictEqual( isReadOnly( actual ), true, 'returns expected value' );
 	t.deepEqual( getShape( x ), getShape( actual ), 'returns expected value' );
@@ -181,6 +184,7 @@ tape( 'the function returns a read-only view of an input ndarray in which the or
 		]
 	];
 
+	t.notEqual( actual, x, 'returns expected value' );
 	t.strictEqual( isndarrayLike( actual ), true, 'returns expected value' );
 	t.strictEqual( isReadOnly( actual ), true, 'returns expected value' );
 	t.deepEqual( getShape( x ), getShape( actual ), 'returns expected value' );

From a153dffe78bb4e10f648e90bb787e76c10069b20 Mon Sep 17 00:00:00 2001
From: Athan <kgryte@gmail.com>
Date: Tue, 30 Sep 2025 12:14:34 +0100
Subject: [PATCH 4/5] test: ensure returned ndarrays are views

---
type: pre_commit_static_analysis_report
description: Results of running static analysis checks when committing changes.
report:
  - task: lint_filenames
    status: passed
  - task: lint_editorconfig
    status: passed
  - task: lint_markdown
    status: na
  - task: lint_package_json
    status: na
  - task: lint_repl_help
    status: na
  - task: lint_javascript_src
    status: na
  - task: lint_javascript_cli
    status: na
  - task: lint_javascript_examples
    status: na
  - task: lint_javascript_tests
    status: 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: na
  - task: lint_license_headers
    status: passed
---
---
 lib/node_modules/@stdlib/ndarray/reverse/test/test.js | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/lib/node_modules/@stdlib/ndarray/reverse/test/test.js b/lib/node_modules/@stdlib/ndarray/reverse/test/test.js
index 4c391cb72530..357be774f0c2 100644
--- a/lib/node_modules/@stdlib/ndarray/reverse/test/test.js
+++ b/lib/node_modules/@stdlib/ndarray/reverse/test/test.js
@@ -26,6 +26,7 @@ var isReadOnly = require( '@stdlib/ndarray/base/assert/is-read-only' );
 var zeroTo = require( '@stdlib/array/zero-to' );
 var ndarray = require( '@stdlib/ndarray/ctor' );
 var getShape = require( '@stdlib/ndarray/shape' );
+var getData = require( '@stdlib/ndarray/data-buffer' );
 var scalar2ndarray = require( '@stdlib/ndarray/from-scalar' );
 var ndarray2array = require( '@stdlib/ndarray/to-array' );
 var reverse = require( './../lib' );
@@ -83,6 +84,7 @@ tape( 'the function returns a read-only view of a zero-dimensional input ndarray
 	t.strictEqual( isndarrayLike( actual ), true, 'returns expected value' );
 	t.strictEqual( isReadOnly( actual ), true, 'returns expected value' );
 	t.strictEqual( actual.get(), x.get(), 'returns expected value' );
+	t.strictEqual( getData( actual ), getData( x ), 'returns expected value' );
 	t.deepEqual( getShape( x ), getShape( actual ), 'returns expected value' );
 
 	t.end();
@@ -112,6 +114,7 @@ tape( 'the function returns a read-only view of an input ndarray in which the or
 	t.notEqual( actual, x, 'returns expected value' );
 	t.strictEqual( isndarrayLike( actual ), true, 'returns expected value' );
 	t.strictEqual( isReadOnly( actual ), true, 'returns expected value' );
+	t.strictEqual( getData( actual ), getData( x ), 'returns expected value' );
 	t.deepEqual( getShape( x ), getShape( actual ), 'returns expected value' );
 	t.deepEqual( ndarray2array( actual ), expected, 'returns expected value' );
 
@@ -146,6 +149,7 @@ tape( 'the function returns a read-only view of an input ndarray in which the or
 	t.notEqual( actual, x, 'returns expected value' );
 	t.strictEqual( isndarrayLike( actual ), true, 'returns expected value' );
 	t.strictEqual( isReadOnly( actual ), true, 'returns expected value' );
+	t.strictEqual( getData( actual ), getData( x ), 'returns expected value' );
 	t.deepEqual( getShape( x ), getShape( actual ), 'returns expected value' );
 	t.deepEqual( ndarray2array( actual ), expected, 'returns expected value' );
 
@@ -187,6 +191,7 @@ tape( 'the function returns a read-only view of an input ndarray in which the or
 	t.notEqual( actual, x, 'returns expected value' );
 	t.strictEqual( isndarrayLike( actual ), true, 'returns expected value' );
 	t.strictEqual( isReadOnly( actual ), true, 'returns expected value' );
+	t.strictEqual( getData( actual ), getData( x ), 'returns expected value' );
 	t.deepEqual( getShape( x ), getShape( actual ), 'returns expected value' );
 	t.deepEqual( ndarray2array( actual ), expected, 'returns expected value' );
 

From 85aaf81e9daf1f85933d7605783a11a4692d8730 Mon Sep 17 00:00:00 2001
From: Athan <kgryte@gmail.com>
Date: Tue, 30 Sep 2025 12:17:01 +0100
Subject: [PATCH 5/5] test: ensure returned view has same data type

---
type: pre_commit_static_analysis_report
description: Results of running static analysis checks when committing changes.
report:
  - task: lint_filenames
    status: passed
  - task: lint_editorconfig
    status: passed
  - task: lint_markdown
    status: na
  - task: lint_package_json
    status: na
  - task: lint_repl_help
    status: na
  - task: lint_javascript_src
    status: na
  - task: lint_javascript_cli
    status: na
  - task: lint_javascript_examples
    status: na
  - task: lint_javascript_tests
    status: 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: na
  - task: lint_license_headers
    status: passed
---
---
 lib/node_modules/@stdlib/ndarray/reverse/test/test.js | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/lib/node_modules/@stdlib/ndarray/reverse/test/test.js b/lib/node_modules/@stdlib/ndarray/reverse/test/test.js
index 357be774f0c2..ce611d005126 100644
--- a/lib/node_modules/@stdlib/ndarray/reverse/test/test.js
+++ b/lib/node_modules/@stdlib/ndarray/reverse/test/test.js
@@ -23,10 +23,12 @@
 var tape = require( 'tape' );
 var isndarrayLike = require( '@stdlib/assert/is-ndarray-like' );
 var isReadOnly = require( '@stdlib/ndarray/base/assert/is-read-only' );
+var isEqualDataType = require( '@stdlib/ndarray/base/assert/is-equal-data-type' );
 var zeroTo = require( '@stdlib/array/zero-to' );
 var ndarray = require( '@stdlib/ndarray/ctor' );
 var getShape = require( '@stdlib/ndarray/shape' );
 var getData = require( '@stdlib/ndarray/data-buffer' );
+var getDType = require( '@stdlib/ndarray/dtype' );
 var scalar2ndarray = require( '@stdlib/ndarray/from-scalar' );
 var ndarray2array = require( '@stdlib/ndarray/to-array' );
 var reverse = require( './../lib' );
@@ -85,6 +87,7 @@ tape( 'the function returns a read-only view of a zero-dimensional input ndarray
 	t.strictEqual( isReadOnly( actual ), true, 'returns expected value' );
 	t.strictEqual( actual.get(), x.get(), 'returns expected value' );
 	t.strictEqual( getData( actual ), getData( x ), 'returns expected value' );
+	t.strictEqual( isEqualDataType( getDType( actual ), getDType( x ) ), true, 'returns expected value' );
 	t.deepEqual( getShape( x ), getShape( actual ), 'returns expected value' );
 
 	t.end();
@@ -115,6 +118,7 @@ tape( 'the function returns a read-only view of an input ndarray in which the or
 	t.strictEqual( isndarrayLike( actual ), true, 'returns expected value' );
 	t.strictEqual( isReadOnly( actual ), true, 'returns expected value' );
 	t.strictEqual( getData( actual ), getData( x ), 'returns expected value' );
+	t.strictEqual( isEqualDataType( getDType( actual ), getDType( x ) ), true, 'returns expected value' );
 	t.deepEqual( getShape( x ), getShape( actual ), 'returns expected value' );
 	t.deepEqual( ndarray2array( actual ), expected, 'returns expected value' );
 
@@ -150,6 +154,7 @@ tape( 'the function returns a read-only view of an input ndarray in which the or
 	t.strictEqual( isndarrayLike( actual ), true, 'returns expected value' );
 	t.strictEqual( isReadOnly( actual ), true, 'returns expected value' );
 	t.strictEqual( getData( actual ), getData( x ), 'returns expected value' );
+	t.strictEqual( isEqualDataType( getDType( actual ), getDType( x ) ), true, 'returns expected value' );
 	t.deepEqual( getShape( x ), getShape( actual ), 'returns expected value' );
 	t.deepEqual( ndarray2array( actual ), expected, 'returns expected value' );
 
@@ -192,6 +197,7 @@ tape( 'the function returns a read-only view of an input ndarray in which the or
 	t.strictEqual( isndarrayLike( actual ), true, 'returns expected value' );
 	t.strictEqual( isReadOnly( actual ), true, 'returns expected value' );
 	t.strictEqual( getData( actual ), getData( x ), 'returns expected value' );
+	t.strictEqual( isEqualDataType( getDType( actual ), getDType( x ) ), true, 'returns expected value' );
 	t.deepEqual( getShape( x ), getShape( actual ), 'returns expected value' );
 	t.deepEqual( ndarray2array( actual ), expected, 'returns expected value' );