diff --git a/lib/node_modules/@stdlib/ndarray/to-reversed-dimension/README.md b/lib/node_modules/@stdlib/ndarray/to-reversed-dimension/README.md
new file mode 100644
index 000000000000..d254cd511524
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/to-reversed-dimension/README.md
@@ -0,0 +1,130 @@
+
+
+# toReversedDimension
+
+> Return a new [`ndarray`][@stdlib/ndarray/ctor] where the order of elements of an input [`ndarray`][@stdlib/ndarray/ctor] is reversed.
+
+
+
+
+
+
+
+
+
+
+
+## Usage
+
+```javascript
+var toReversedDimension = require( '@stdlib/ndarray/to-reversed-dimension' );
+```
+
+#### toReversedDimension( x\[, options] )
+
+Returns a new [`ndarray`][@stdlib/ndarray/ctor] where the order of elements of an input [`ndarray`][@stdlib/ndarray/ctor] is reversed.
+
+```javascript
+var array = require( '@stdlib/ndarray/array' );
+
+var x = array( [ [ 1.0, 2.0 ], [ 3.0, 4.0 ] ] );
+// returns [ [ 1.0, 2.0 ], [ 3.0, 4.0 ] ]
+
+var y = toReversedDimension( x );
+// returns [ [ 2.0, 1.0 ], [ 4.0, 3.0 ] ]
+```
+
+The function accepts the following arguments:
+
+- **x**: input ndarray.
+- **options**: function options (_optional_).
+
+The function supports the following options:
+
+- **dim**: index of dimension along which to reverse elements. If provided an integer less than zero, the dimension index is resolved relative to the last dimension, with the last dimension corresponding to the value `-1`. Default: `-1`.
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+## Examples
+
+
+
+```javascript
+var uniform = require( '@stdlib/random/uniform' );
+var ndarray2array = require( '@stdlib/ndarray/to-array' );
+var toReversed = require( '@stdlib/ndarray/to-reversed-dimension' );
+
+var x = uniform( [ 3, 3, 3 ], -10.0, 10.0 );
+console.log( ndarray2array( x ) );
+
+var y = toReversed( x );
+console.log( ndarray2array( y ) );
+```
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+[@stdlib/ndarray/ctor]: https://github.com/stdlib-js/stdlib/tree/develop/lib/node_modules/%40stdlib/ndarray/ctor
+
+
+
+
+
+
+
+
diff --git a/lib/node_modules/@stdlib/ndarray/to-reversed-dimension/benchmark/benchmark.js b/lib/node_modules/@stdlib/ndarray/to-reversed-dimension/benchmark/benchmark.js
new file mode 100644
index 000000000000..ea93ed42237c
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/to-reversed-dimension/benchmark/benchmark.js
@@ -0,0 +1,201 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2026 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 format = require( '@stdlib/string/format' );
+var pkg = require( './../package.json' ).name;
+var toReversedDimension = require( './../lib' );
+
+
+// MAIN //
+
+bench( format( '%s::1d', pkg ), 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 = toReversedDimension( values[ i%values.length ], {
+ 'dim': 0
+ });
+ 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( format( '%s::2d', pkg ), 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 = toReversedDimension( values[ i%values.length ], {
+ 'dim': 0
+ });
+ 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( format( '%s::3d', pkg ), 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 = toReversedDimension( values[ i%values.length ], {
+ 'dim': 0
+ });
+ 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( format( '%s::4d', pkg ), 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 = toReversedDimension( values[ i%values.length ], {
+ 'dim': 0
+ });
+ 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( format( '%s::5d', pkg ), 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 = toReversedDimension( values[ i%values.length ], {
+ 'dim': 0
+ });
+ 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/to-reversed-dimension/docs/repl.txt b/lib/node_modules/@stdlib/ndarray/to-reversed-dimension/docs/repl.txt
new file mode 100644
index 000000000000..4ed2ac36be9d
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/to-reversed-dimension/docs/repl.txt
@@ -0,0 +1,34 @@
+
+{{alias}}( x[, options] )
+ Returns a new ndarray where the order of elements of an input ndarray is
+ reversed.
+
+ Parameters
+ ----------
+ x: ndarray
+ Input array.
+
+ options: object (optional)
+ Function options.
+
+ options.dim: integer (optional)
+ Index of dimension along which to reverse elements. If provided an
+ integer less than zero, the dimension index is resolved relative to the
+ last dimension, with the last dimension corresponding to the value `-1`.
+ Default: `-1`.
+
+ Returns
+ -------
+ out: ndarray
+ Output array.
+
+ Examples
+ --------
+ > var x = {{alias:@stdlib/ndarray/array}}( [ [ 1, 2 ], [ 3, 4 ] ] )
+ [ [ 1, 2 ], [ 3, 4 ] ]
+ > var y = {{alias}}( x )
+ [ [ 2, 1 ], [ 4, 3 ] ]
+
+ See Also
+ --------
+
diff --git a/lib/node_modules/@stdlib/ndarray/to-reversed-dimension/docs/types/index.d.ts b/lib/node_modules/@stdlib/ndarray/to-reversed-dimension/docs/types/index.d.ts
new file mode 100644
index 000000000000..95f1e7a33178
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/to-reversed-dimension/docs/types/index.d.ts
@@ -0,0 +1,57 @@
+/*
+* @license Apache-2.0
+*
+* Copyright (c) 2026 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+// TypeScript Version: 4.1
+
+///
+
+import { ndarray } from '@stdlib/types/ndarray';
+
+/**
+* Base options.
+*/
+interface Options {
+ /**
+ * Index of dimension to reverse.
+ */
+ dim?: number;
+}
+
+/**
+* Returns a new ndarray where the order of elements of an input ndarray is reversed.
+*
+* @param x - input array
+* @param options - function options
+* @param options.dim - index of dimension to reverse
+* @returns output array
+*
+* @example
+* var array = require( '@stdlib/ndarray/array' );
+*
+* var x = array( [ [ 1.0, 2.0 ], [ 3.0, 4.0 ] ] );
+* // returns [ [ 1.0, 2.0 ], [ 3.0, 4.0 ] ]
+*
+* var y = toReversedDimension( x );
+* // returns [ [ 2.0, 1.0 ], [ 4.0, 3.0 ] ]
+*/
+declare function toReversedDimension( x: T, options?: Options ): T;
+
+
+// EXPORTS //
+
+export = toReversedDimension;
diff --git a/lib/node_modules/@stdlib/ndarray/to-reversed-dimension/docs/types/test.ts b/lib/node_modules/@stdlib/ndarray/to-reversed-dimension/docs/types/test.ts
new file mode 100644
index 000000000000..e7ebe0f19580
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/to-reversed-dimension/docs/types/test.ts
@@ -0,0 +1,84 @@
+/*
+* @license Apache-2.0
+*
+* Copyright (c) 2026 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/empty' );
+import toReversedDimension = require( './index' );
+
+
+// TESTS //
+
+// The function returns an ndarray...
+{
+ var x = empty( [ 2, 2 ] );
+
+ toReversedDimension( x ); // $ExpectType float64ndarray
+ toReversedDimension( x, {} ); // $ExpectType float64ndarray
+}
+
+// The compiler throws an error if the function is provided a first argument which is not an ndarray...
+{
+ toReversedDimension( '10' ); // $ExpectError
+ toReversedDimension( 10 ); // $ExpectError
+ toReversedDimension( false ); // $ExpectError
+ toReversedDimension( true ); // $ExpectError
+ toReversedDimension( null ); // $ExpectError
+ toReversedDimension( [] ); // $ExpectError
+ toReversedDimension( {} ); // $ExpectError
+ toReversedDimension( ( x: number ): number => x ); // $ExpectError
+
+ toReversedDimension( '10', {} ); // $ExpectError
+ toReversedDimension( 10, {} ); // $ExpectError
+ toReversedDimension( false, {} ); // $ExpectError
+ toReversedDimension( true, {} ); // $ExpectError
+ toReversedDimension( null, {} ); // $ExpectError
+ toReversedDimension( [], {} ); // $ExpectError
+ toReversedDimension( {}, {} ); // $ExpectError
+ toReversedDimension( ( x: number ): number => x, {} ); // $ExpectError
+}
+
+// The compiler throws an error if the function is provided an options argument which is not an object...
+{
+ const x = empty( [ 2, 2 ] );
+
+ toReversedDimension( x, '5' ); // $ExpectError
+ toReversedDimension( x, true ); // $ExpectError
+ toReversedDimension( x, false ); // $ExpectError
+ toReversedDimension( x, null ); // $ExpectError
+ toReversedDimension( x, [ '5' ] ); // $ExpectError
+ toReversedDimension( x, ( x: number ): number => x ); // $ExpectError
+}
+
+// The compiler throws an error if the function is provided a `options.dim` property which is not a number...
+{
+ const x = empty( [ 2, 2 ] );
+
+ toReversedDimension( x, { 'dim': '5'} ); // $ExpectError
+ toReversedDimension( x, { 'dim': true } ); // $ExpectError
+ toReversedDimension( x, { 'dim': false } ); // $ExpectError
+ toReversedDimension( x, { 'dim': null } ); // $ExpectError
+ toReversedDimension( x, { 'dim': [ '5' ] } ); // $ExpectError
+ toReversedDimension( x, { 'dim': ( x: number ): number => x} ); // $ExpectError
+}
+
+// The compiler throws an error if the function is provided an unsupported number of arguments...
+{
+ const x = empty( [ 2, 2 ] );
+
+ toReversedDimension(); // $ExpectError
+ toReversedDimension( x, {}, {} ); // $ExpectError
+}
diff --git a/lib/node_modules/@stdlib/ndarray/to-reversed-dimension/examples/index.js b/lib/node_modules/@stdlib/ndarray/to-reversed-dimension/examples/index.js
new file mode 100644
index 000000000000..e962359ac097
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/to-reversed-dimension/examples/index.js
@@ -0,0 +1,29 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2026 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/uniform' );
+var ndarray2array = require( '@stdlib/ndarray/to-array' );
+var toReversedDimension = require( './../lib' );
+
+var x = uniform( [ 3, 3, 3 ], -10.0, 10.0 );
+console.log( ndarray2array( x ) );
+
+var y = toReversedDimension( x );
+console.log( ndarray2array( y ) );
diff --git a/lib/node_modules/@stdlib/ndarray/to-reversed-dimension/lib/index.js b/lib/node_modules/@stdlib/ndarray/to-reversed-dimension/lib/index.js
new file mode 100644
index 000000000000..9958c874dc9a
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/to-reversed-dimension/lib/index.js
@@ -0,0 +1,44 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2026 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 new ndarray where the order of elements of an input ndarray is reversed along a specified dimension.
+*
+* @module @stdlib/ndarray/to-reversed-dimension
+*
+* @example
+* var array = require( '@stdlib/ndarray/array' );
+* var toReversedDimension = require( '@stdlib/ndarray/to-reversed-dimension' );
+*
+*var x = array( [ [ 1.0, 2.0 ], [ 3.0, 4.0 ] ] );
+* // returns [ [ 1.0, 2.0 ], [ 3.0, 4.0 ] ]
+*
+* var y = toReversedDimension( x );
+* // returns [ [ 2.0, 1.0 ], [ 4.0, 3.0 ] ]
+*/
+
+// MODULES //
+
+var main = require( './main.js' );
+
+
+// EXPORTS //
+
+module.exports = main;
diff --git a/lib/node_modules/@stdlib/ndarray/to-reversed-dimension/lib/main.js b/lib/node_modules/@stdlib/ndarray/to-reversed-dimension/lib/main.js
new file mode 100644
index 000000000000..3b681991b25c
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/to-reversed-dimension/lib/main.js
@@ -0,0 +1,84 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2026 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 normalizeIndex = require( '@stdlib/ndarray/base/normalize-index' );
+var base = require( '@stdlib/ndarray/base/to-reversed-dimension' );
+var hasOwnProp = require( '@stdlib/assert/has-own-property' );
+var isndarrayLike = require( '@stdlib/assert/is-ndarray-like' );
+var isObject = require( '@stdlib/assert/is-plain-object' );
+var isInteger = require( '@stdlib/assert/is-integer' );
+var format = require( '@stdlib/string/format' );
+var ndims = require( '@stdlib/ndarray/ndims' );
+
+
+// MAIN //
+
+/**
+* Returns a new ndarray where the order of elements of an input ndarray is reversed.
+*
+* @param {ndarray} x - input array
+* @param {Object} options - function options
+* @param {integer} options.dim - index of dimension to reverse
+* @throws {TypeError} first argument must be an ndarray
+* @throws {TypeError} options argument must be an object
+* @returns {ndarray} output array
+*
+* @example
+* var array = require( '@stdlib/ndarray/array' );
+*
+*var x = array( [ [ 1.0, 2.0 ], [ 3.0, 4.0 ] ] );
+* // returns [ [ 1.0, 2.0 ], [ 3.0, 4.0 ] ]
+*
+* var y = toReversedDimension( x );
+* // returns [ [ 2.0, 1.0 ], [ 4.0, 3.0 ] ]
+*/
+function toReversedDimension( x, options ) {
+ var opts;
+ var d;
+ var N;
+
+ if ( !isndarrayLike( x ) ) {
+ throw new TypeError( format( 'invalid argument. First argument must be an ndarray. Value: `%s`.', x ) );
+ }
+ N = ndims( x );
+ opts = {
+ 'dim': -1
+ };
+ if ( arguments.length > 1 ) {
+ if ( !isObject( options ) ) {
+ throw new TypeError( format( 'invalid argument. Options argument must be an object. Value: `%s`.', options ) );
+ }
+ if ( hasOwnProp( options, 'dim' ) ) {
+ if ( !isInteger( options.dim ) ) {
+ throw new TypeError( format( 'invalid option. `%s` option must be an integer. Option: `%s`.', 'dim', options.dim ) );
+ }
+ opts.dim = options.dim;
+ }
+ }
+ d = normalizeIndex( opts.dim, N-1 );
+ return base( x, d );
+}
+
+
+// EXPORTS //
+
+module.exports = toReversedDimension;
diff --git a/lib/node_modules/@stdlib/ndarray/to-reversed-dimension/package.json b/lib/node_modules/@stdlib/ndarray/to-reversed-dimension/package.json
new file mode 100644
index 000000000000..8754189a4190
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/to-reversed-dimension/package.json
@@ -0,0 +1,66 @@
+{
+ "name": "@stdlib/ndarray/to-reversed-dimension",
+ "version": "0.0.0",
+ "description": "Return a new ndarray where the order of elements of an input ndarray 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",
+ "base",
+ "data",
+ "structure",
+ "vector",
+ "ndarray",
+ "matrix",
+ "reverse",
+ "dimension",
+ "flip",
+ "numpy.flip"
+ ]
+}
diff --git a/lib/node_modules/@stdlib/ndarray/to-reversed-dimension/test/test.js b/lib/node_modules/@stdlib/ndarray/to-reversed-dimension/test/test.js
new file mode 100644
index 000000000000..9cb8d80fb19a
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/to-reversed-dimension/test/test.js
@@ -0,0 +1,306 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2026 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 empty = require( '@stdlib/ndarray/empty' );
+var ndarray2array = require( '@stdlib/ndarray/to-array' );
+var array = require( '@stdlib/ndarray/array' );
+var ndims = require( '@stdlib/ndarray/base/ndims' );
+var getDType = require( '@stdlib/ndarray/base/dtype' );
+var getData = require( '@stdlib/ndarray/base/data-buffer' );
+var getShape = require( '@stdlib/ndarray/base/shape' );
+var numel = require( '@stdlib/ndarray/base/numel' );
+var toReversedDimension = require( './../lib' );
+
+
+// TESTS //
+
+tape( 'main export is a function', function test( t ) {
+ t.ok( true, __filename );
+ t.strictEqual( typeof toReversedDimension, '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() {
+ toReversedDimension( value );
+ };
+ }
+});
+
+tape( 'the function throws an error if provided a first argument which is not an ndarray (options)', function test( t ) {
+ var values;
+ var i;
+
+ values = [
+ '5',
+ 5,
+ NaN,
+ true,
+ false,
+ null,
+ void 0,
+ [],
+ {},
+ function noop() {}
+ ];
+
+ for ( i = 0; i < values.length; i++ ) {
+ t.throws( badValue( values[ i ] ), TypeError, 'throws an error when provided ' + values[ i ] );
+ }
+ t.end();
+
+ function badValue( value ) {
+ return function badValue() {
+ toReversedDimension( value, {} );
+ };
+ }
+});
+
+tape( 'the function throws an error if provided an options argument which is not an object', function test( t ) {
+ var values;
+ var x;
+ var i;
+
+ x = empty( [ 2, 2 ] );
+ 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() {
+ toReversedDimension( x, value );
+ };
+ }
+});
+
+tape( 'the function returns an error if provided a `dim` option which is not an integer', function test( t ) {
+ var values;
+ var x;
+ var i;
+
+ x = empty( [ 2, 2 ] );
+ values = [
+ '5',
+ -3.14,
+ 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() {
+ toReversedDimension( x, {
+ 'dim': value
+ });
+ };
+ }
+});
+
+tape( 'the function returns a new ndarray where the order of elements of an input ndarray is reversed (ndims=1)', function test( t ) {
+ var expected;
+ var actual;
+ var x;
+
+ x = array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] );
+
+ actual = toReversedDimension( x );
+ expected = [ 6.0, 5.0, 4.0, 3.0, 2.0, 1.0 ];
+
+ t.strictEqual( isndarrayLike( actual ), true, 'returns expected value' );
+ t.strictEqual( ndims( actual ), 1, 'returns expected value' );
+ t.strictEqual( numel( getShape( actual ) ), 6, 'returns expected value' );
+ t.strictEqual( String( getDType( actual ) ), String( getDType( x ) ), 'returns expected value' );
+ t.notEqual( getData( actual ), getData( x ), 'returns expected value' );
+ t.deepEqual( ndarray2array( actual ), expected, 'returns expected value' );
+
+ actual = toReversedDimension( x, {
+ 'dim': -1
+ });
+
+ t.strictEqual( isndarrayLike( actual ), true, 'returns expected value' );
+ t.strictEqual( ndims( actual ), 1, 'returns expected value' );
+ t.deepEqual( getShape( actual ), [ 6 ], 'returns expected value' );
+ t.strictEqual( String( getDType( actual ) ), String( getDType( x ) ), 'returns expected value' );
+ t.notEqual( getData( actual ), getData( x ), 'returns expected value' );
+ t.deepEqual( ndarray2array( actual ), expected, 'returns expected value' );
+
+ t.end();
+});
+
+tape( 'the function returns a new ndarray where the order of elements of an input ndarray is reversed (ndims=2)', function test( t ) {
+ var expected;
+ var actual;
+ var x;
+
+ x = array( [ [ 1.0, 2.0 ], [ 3.0, 4.0 ], [ 5.0, 6.0 ] ] );
+
+ actual = toReversedDimension( x );
+ expected = [ [ 2.0, 1.0 ], [ 4.0, 3.0 ], [ 6.0, 5.0 ] ];
+
+ t.strictEqual( isndarrayLike( actual ), true, 'returns expected value' );
+ t.strictEqual( ndims( actual ), 2, 'returns expected value' );
+ t.deepEqual( getShape( actual ), [ 3, 2 ], 'returns expected value' );
+ t.strictEqual( String( getDType( actual ) ), String( getDType( x ) ), 'returns expected value' );
+ t.notEqual( getData( actual ), getData( x ), 'returns expected value' );
+ t.deepEqual( ndarray2array( actual ), expected, 'returns expected value' );
+
+ actual = toReversedDimension( x, {
+ 'dim': -2
+ });
+ expected = [ [ 5.0, 6.0 ], [ 3.0, 4.0 ], [ 1.0, 2.0 ] ];
+
+ t.strictEqual( isndarrayLike( actual ), true, 'returns expected value' );
+ t.strictEqual( ndims( actual ), 2, 'returns expected value' );
+ t.deepEqual( getShape( actual ), [ 3, 2 ], 'returns expected value' );
+ t.strictEqual( String( getDType( actual ) ), String( getDType( x ) ), 'returns expected value' );
+ t.notEqual( getData( actual ), getData( x ), 'returns expected value' );
+ t.deepEqual( ndarray2array( actual ), expected, 'returns expected value' );
+
+ t.end();
+});
+
+tape( 'the function returns a new ndarray where the order of elements of an input ndarray is reversed (ndims=3)', function test( t ) {
+ var expected;
+ var actual;
+ var x;
+
+ x = array([
+ [
+ [ 1.0, 2.0 ],
+ [ 3.0, 4.0 ]
+ ],
+ [
+ [ 5.0, 6.0 ],
+ [ 7.0, 8.0 ]
+ ]
+ ]);
+
+ actual = toReversedDimension( x );
+ expected = [
+ [
+ [ 2.0, 1.0 ],
+ [ 4.0, 3.0 ]
+ ],
+ [
+ [ 6.0, 5.0 ],
+ [ 8.0, 7.0 ]
+ ]
+ ];
+
+ t.strictEqual( isndarrayLike( actual ), true, 'returns expected value' );
+ t.strictEqual( ndims( actual ), 3, 'returns expected value' );
+ t.deepEqual( getShape( actual ), [ 2, 2, 2 ], 'returns expected value' );
+ t.strictEqual( String( getDType( actual ) ), String( getDType( x ) ), 'returns expected value' );
+ t.notEqual( getData( actual ), getData( x ), 'returns expected value' );
+ t.deepEqual( ndarray2array( actual ), expected, 'returns expected value' );
+
+ actual = toReversedDimension( x, {
+ 'dim': -2
+ });
+ expected = [
+ [
+ [ 3.0, 4.0 ],
+ [ 1.0, 2.0 ]
+ ],
+ [
+ [ 7.0, 8.0 ],
+ [ 5.0, 6.0 ]
+ ]
+ ];
+
+ t.strictEqual( isndarrayLike( actual ), true, 'returns expected value' );
+ t.strictEqual( ndims( actual ), 3, 'returns expected value' );
+ t.deepEqual( getShape( actual ), [ 2, 2, 2 ], 'returns expected value' );
+ t.strictEqual( String( getDType( actual ) ), String( getDType( x ) ), 'returns expected value' );
+ t.notEqual( getData( actual ), getData( x ), 'returns expected value' );
+ t.deepEqual( ndarray2array( actual ), expected, 'returns expected value' );
+
+ actual = toReversedDimension( x, {
+ 'dim': -3
+ });
+ expected = [
+ [
+ [ 5.0, 6.0 ],
+ [ 7.0, 8.0 ]
+ ],
+ [
+ [ 1.0, 2.0 ],
+ [ 3.0, 4.0 ]
+ ]
+ ];
+
+ t.strictEqual( isndarrayLike( actual ), true, 'returns expected value' );
+ t.strictEqual( ndims( actual ), 3, 'returns expected value' );
+ t.deepEqual( getShape( actual ), [ 2, 2, 2 ], 'returns expected value' );
+ t.strictEqual( String( getDType( actual ) ), String( getDType( x ) ), 'returns expected value' );
+ t.notEqual( getData( actual ), getData( x ), 'returns expected value' );
+ t.deepEqual( ndarray2array( actual ), expected, 'returns expected value' );
+
+ t.end();
+});