diff --git a/lib/node_modules/@stdlib/lapack/base/dlaruv/README.md b/lib/node_modules/@stdlib/lapack/base/dlaruv/README.md
new file mode 100644
index 000000000000..36b71af693a5
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlaruv/README.md
@@ -0,0 +1,243 @@
+
+
+# dlaruv
+
+> Return a vector of `n` random real numbers from a uniform (0,1) distribution.
+
+
+
+## Usage
+
+```javascript
+var dlaruv = require( '@stdlib/lapack/base/dlaruv' );
+```
+
+#### dlaruv( N, ISEED, X )
+
+Returns a vector of `N` random real numbers from a uniform (0,1) distribution.
+
+```javascript
+var Int32Array = require( '@stdlib/array/int32' );
+var Float64Array = require( '@stdlib/array/float64' );
+
+var ISEED = new Int32Array( [ 0, 1, 2, 3 ] );
+var X = new Float64Array( 3 );
+
+dlaruv( 3, ISEED, X );
+// X =>
+```
+
+The function has the following parameters:
+
+- **N**: number of random numbers to generate. Must be at most `128`.
+- **ISEED**: [`Int32Array`][mdn-int32array] seed array of four integers. Each element must be between `0` and `4095`, and `ISEED[3]` must be odd. On exit, the seed is updated.
+- **X**: output [`Float64Array`][mdn-float64array].
+
+Note that indexing is relative to the first index. To introduce an offset, use [`typed array`][mdn-typed-array] views.
+
+
+
+```javascript
+var Int32Array = require( '@stdlib/array/int32' );
+var Float64Array = require( '@stdlib/array/float64' );
+
+// Initial arrays...
+var ISEED0 = new Int32Array( [ 0, 0, 1, 2, 3 ] );
+var X0 = new Float64Array( [ 0.0, 0.0, 0.0, 0.0 ] );
+
+// Create offset views...
+var ISEED1 = new Int32Array( ISEED0.buffer, ISEED0.BYTES_PER_ELEMENT*1 ); // start at 2nd element
+var X1 = new Float64Array( X0.buffer, X0.BYTES_PER_ELEMENT*1 ); // start at 2nd element
+
+dlaruv( 3, ISEED1, X1 );
+// X0 =>
+```
+
+#### dlaruv.ndarray( N, ISEED, strideISEED, offsetISEED, X, strideX, offsetX )
+
+Returns a vector of `N` random real numbers from a uniform (0,1) distribution using alternative indexing semantics.
+
+```javascript
+var Int32Array = require( '@stdlib/array/int32' );
+var Float64Array = require( '@stdlib/array/float64' );
+
+var ISEED = new Int32Array( [ 0, 1, 2, 3 ] );
+var X = new Float64Array( 3 );
+
+dlaruv.ndarray( 3, ISEED, 1, 0, X, 1, 0 );
+// X =>
+```
+
+The function has the following additional parameters:
+
+- **strideISEED**: stride length for `ISEED`.
+- **offsetISEED**: starting index for `ISEED`.
+- **strideX**: stride length for `X`.
+- **offsetX**: starting index for `X`.
+
+While [`typed array`][mdn-typed-array] views mandate a view offset based on the underlying buffer, the offset parameters support indexing semantics based on starting indices. For example,
+
+
+
+```javascript
+var Int32Array = require( '@stdlib/array/int32' );
+var Float64Array = require( '@stdlib/array/float64' );
+
+var ISEED = new Int32Array( [ 0, 0, 1, 2, 3 ] );
+var X = new Float64Array( [ 0.0, 0.0, 0.0, 0.0, 0.0 ] );
+
+dlaruv.ndarray( 3, ISEED, 1, 1, X, 1, 2 );
+// X =>
+```
+
+
+
+
+
+
+
+## Notes
+
+- `dlaruv()` corresponds to the [LAPACK][LAPACK] function [`dlaruv`][lapack-dlaruv].
+
+
+
+
+
+
+
+## Examples
+
+
+
+```javascript
+var Int32Array = require( '@stdlib/array/int32' );
+var Float64Array = require( '@stdlib/array/float64' );
+var dlaruv = require( '@stdlib/lapack/base/dlaruv' );
+
+var ISEED = new Int32Array( [ 1, 23, 456, 3795 ] );
+var X = new Float64Array( 10 );
+
+dlaruv( X.length, ISEED, X );
+
+console.log( X );
+console.log( ISEED );
+```
+
+
+
+
+
+
+
+* * *
+
+
+
+## C APIs
+
+
+
+
+
+
+
+
+
+
+
+### Usage
+
+```c
+TODO
+```
+
+#### TODO
+
+TODO.
+
+```c
+TODO
+```
+
+TODO
+
+```c
+TODO
+```
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+### Examples
+
+```c
+TODO
+```
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+[lapack]: https://www.netlib.org/lapack/explore-html/
+
+[lapack-dlaruv]: https://netlib.org/lapack/explore-html/d9/d0f/group__laruv.html
+
+[mdn-int32array]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Int32Array
+
+[mdn-float64array]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Float64Array
+
+[mdn-typed-array]: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray
+
+
+
+
diff --git a/lib/node_modules/@stdlib/lapack/base/dlaruv/benchmark/benchmark.js b/lib/node_modules/@stdlib/lapack/base/dlaruv/benchmark/benchmark.js
new file mode 100644
index 000000000000..2bde48eddaf8
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlaruv/benchmark/benchmark.js
@@ -0,0 +1,98 @@
+/**
+* @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 Int32Array = require( '@stdlib/array/int32' );
+var Float64Array = require( '@stdlib/array/float64' );
+var isnan = require( '@stdlib/math/base/assert/is-nan' );
+var pow = require( '@stdlib/math/base/special/pow' );
+var min = require( '@stdlib/math/base/special/min' );
+var format = require( '@stdlib/string/format' );
+var pkg = require( './../package.json' ).name;
+var dlaruv = require( './../lib/dlaruv.js' );
+
+
+// FUNCTIONS //
+
+/**
+* Creates a benchmark function.
+*
+* @private
+* @param {PositiveInteger} len - array length
+* @returns {Function} benchmark function
+*/
+function createBenchmark( len ) {
+ var ISEED = new Int32Array( [ 1619, 1381, 1011, 2459 ] );
+ var X = new Float64Array( len );
+ return benchmark;
+
+ /**
+ * Benchmark function.
+ *
+ * @private
+ * @param {Benchmark} b - benchmark instance
+ */
+ function benchmark( b ) {
+ var i;
+
+ b.tic();
+ for ( i = 0; i < b.iterations; i++ ) {
+ dlaruv( len, ISEED, X );
+ if ( isnan( X[ 0 ] ) ) {
+ b.fail( 'should not return NaN' );
+ }
+ }
+ b.toc();
+ if ( isnan( X[ 0 ] ) ) {
+ b.fail( 'should not return NaN' );
+ }
+ b.pass( 'benchmark finished' );
+ b.end();
+ }
+}
+
+
+// MAIN //
+
+/**
+* Main execution sequence.
+*
+* @private
+*/
+function main() {
+ var min2;
+ var len;
+ var max;
+ var f;
+ var i;
+
+ min2 = 0; // 10^min
+ max = 2; // 10^max (capped at 128)
+
+ for ( i = min2; i <= max; i++ ) {
+ len = min( pow( 10, i ), 128 );
+ f = createBenchmark( len );
+ bench( format( '%s:len=%d', pkg, len ), f );
+ }
+}
+
+main();
diff --git a/lib/node_modules/@stdlib/lapack/base/dlaruv/benchmark/benchmark.ndarray.js b/lib/node_modules/@stdlib/lapack/base/dlaruv/benchmark/benchmark.ndarray.js
new file mode 100644
index 000000000000..59b9d41ead5e
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlaruv/benchmark/benchmark.ndarray.js
@@ -0,0 +1,98 @@
+/**
+* @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 Int32Array = require( '@stdlib/array/int32' );
+var Float64Array = require( '@stdlib/array/float64' );
+var isnan = require( '@stdlib/math/base/assert/is-nan' );
+var pow = require( '@stdlib/math/base/special/pow' );
+var min = require( '@stdlib/math/base/special/min' );
+var format = require( '@stdlib/string/format' );
+var pkg = require( './../package.json' ).name;
+var dlaruv = require( './../lib/ndarray.js' );
+
+
+// FUNCTIONS //
+
+/**
+* Creates a benchmark function.
+*
+* @private
+* @param {PositiveInteger} len - array length
+* @returns {Function} benchmark function
+*/
+function createBenchmark( len ) {
+ var ISEED = new Int32Array( [ 1619, 1381, 1011, 2459 ] );
+ var X = new Float64Array( len );
+ return benchmark;
+
+ /**
+ * Benchmark function.
+ *
+ * @private
+ * @param {Benchmark} b - benchmark instance
+ */
+ function benchmark( b ) {
+ var i;
+
+ b.tic();
+ for ( i = 0; i < b.iterations; i++ ) {
+ dlaruv( len, ISEED, 1, 0, X, 1, 0 );
+ if ( isnan( X[ 0 ] ) ) {
+ b.fail( 'should not return NaN' );
+ }
+ }
+ b.toc();
+ if ( isnan( X[ 0 ] ) ) {
+ b.fail( 'should not return NaN' );
+ }
+ b.pass( 'benchmark finished' );
+ b.end();
+ }
+}
+
+
+// MAIN //
+
+/**
+* Main execution sequence.
+*
+* @private
+*/
+function main() {
+ var min2;
+ var len;
+ var max;
+ var f;
+ var i;
+
+ min2 = 0; // 10^min
+ max = 2; // 10^max (capped at 128)
+
+ for ( i = min2; i <= max; i++ ) {
+ len = min( pow( 10, i ), 128 );
+ f = createBenchmark( len );
+ bench( format( '%s::ndarray:len=%d', pkg, len ), f );
+ }
+}
+
+main();
diff --git a/lib/node_modules/@stdlib/lapack/base/dlaruv/docs/repl.txt b/lib/node_modules/@stdlib/lapack/base/dlaruv/docs/repl.txt
new file mode 100644
index 000000000000..208d705120ad
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlaruv/docs/repl.txt
@@ -0,0 +1,91 @@
+
+{{alias}}( N, ISEED, X )
+ Returns a vector of `N` random real numbers from a uniform (0,1)
+ distribution.
+
+ Indexing is relative to the first index. To introduce an offset, use typed
+ array views.
+
+ The function mutates the input seed array `ISEED`.
+
+ Parameters
+ ----------
+ N: integer
+ Number of random numbers to generate (N <= 128).
+
+ ISEED: Int32Array
+ Seed array of four integers. Each element must be between `0` and
+ `4095`, and `ISEED[3]` must be odd.
+
+ X: Float64Array
+ Output array.
+
+ Returns
+ -------
+ X: Float64Array
+ Output array `X` filled with random numbers.
+
+ Examples
+ --------
+ > var ISEED = new {{alias:@stdlib/array/int32}}( [ 1, 23, 456, 3795 ] );
+ > var X = new {{alias:@stdlib/array/float64}}( 10 );
+ > {{alias}}( X.length, ISEED, X )
+
+
+ // Using typed array views:
+ > var ISEED0 = new {{alias:@stdlib/array/int32}}( [ 0, 1, 2, 3, 3 ] );
+ > var X0 = new {{alias:@stdlib/array/float64}}( [ 0.0, 0.0, 0.0, 0.0 ] );
+ > var ISEED1 = new Int32Array( ISEED0.buffer, ISEED0.BYTES_PER_ELEMENT*1 );
+ > var X1 = new Float64Array( X0.buffer, X0.BYTES_PER_ELEMENT*1 );
+ > {{alias}}( 3, ISEED1, X1 )
+
+
+
+{{alias}}.ndarray( N, ISEED, strideISEED, offsetISEED, X, strideX, offsetX )
+ Returns a vector of `N` random real numbers from a uniform (0,1)
+ distribution using alternative indexing semantics.
+
+ While typed array views mandate a view offset based on the underlying
+ buffer, the offset parameters support indexing semantics based on starting
+ indices.
+
+ The function mutates the input seed array `ISEED`.
+
+ Parameters
+ ----------
+ N: integer
+ Number of random numbers to generate (N <= 128).
+
+ ISEED: Int32Array
+ Seed array of four integers. Each element must be between `0` and
+ `4095`, and `ISEED[3]` must be odd.
+
+ strideISEED: integer
+ Stride length for `ISEED`.
+
+ offsetISEED: integer
+ Starting index for `ISEED`.
+
+ X: Float64Array
+ Output array.
+
+ strideX: integer
+ Stride length for `X`.
+
+ offsetX: integer
+ Starting index for `X`.
+
+ Returns
+ -------
+ X: Float64Array
+ Output array `X` filled with random numbers.
+
+ Examples
+ --------
+ > var ISEED = new {{alias:@stdlib/array/int32}}( [ 1, 23, 456, 3795 ] );
+ > var X = new {{alias:@stdlib/array/float64}}( 10 );
+ > {{alias}}.ndarray( X.length, ISEED, 1, 0, X, 1, 0 )
+
+
+ See Also
+ --------
diff --git a/lib/node_modules/@stdlib/lapack/base/dlaruv/docs/types/index.d.ts b/lib/node_modules/@stdlib/lapack/base/dlaruv/docs/types/index.d.ts
new file mode 100644
index 000000000000..f5aa8063905e
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlaruv/docs/types/index.d.ts
@@ -0,0 +1,105 @@
+/*
+* @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
+
+///
+
+/**
+* Interface describing `dlaruv`.
+*/
+interface Routine {
+ /**
+ * Returns a vector of `N` random real numbers from a uniform (0,1) distribution.
+ *
+ * @param N - number of random numbers to generate (N <= 128)
+ * @param ISEED - seed array of four integers (each between 0 and 4095, ISEED[3] must be odd)
+ * @param X - output array
+ * @returns output array `X` filled with random numbers
+ *
+ * @example
+ * var Int32Array = require( '@stdlib/array/int32' );
+ * var Float64Array = require( '@stdlib/array/float64' );
+ *
+ * var ISEED = new Int32Array( [ 0, 1, 2, 3 ] );
+ * var X = new Float64Array( 3 );
+ *
+ * dlaruv( 3, ISEED, X );
+ * // X =>
+ */
+ ( N: number, ISEED: Int32Array, X: Float64Array ): Float64Array;
+
+ /**
+ * Returns a vector of `N` random real numbers from a uniform (0,1) distribution using alternative indexing semantics.
+ *
+ * @param N - number of random numbers to generate (N <= 128)
+ * @param ISEED - seed array of four integers (each between 0 and 4095, ISEED[3] must be odd)
+ * @param strideISEED - stride length for `ISEED`
+ * @param offsetISEED - starting index for `ISEED`
+ * @param X - output array
+ * @param strideX - stride length for `X`
+ * @param offsetX - starting index for `X`
+ * @returns output array `X` filled with random numbers
+ *
+ * @example
+ * var Int32Array = require( '@stdlib/array/int32' );
+ * var Float64Array = require( '@stdlib/array/float64' );
+ *
+ * var ISEED = new Int32Array( [ 0, 1, 2, 3 ] );
+ * var X = new Float64Array( 3 );
+ *
+ * dlaruv.ndarray( 3, ISEED, 1, 0, X, 1, 0 );
+ * // X =>
+ */
+ ndarray( N: number, ISEED: Int32Array, strideISEED: number, offsetISEED: number, X: Float64Array, strideX: number, offsetX: number ): Float64Array;
+}
+
+/**
+* Returns a vector of `N` random real numbers from a uniform (0,1) distribution.
+*
+* @param N - number of random numbers to generate (N <= 128)
+* @param ISEED - seed array of four integers (each between 0 and 4095, ISEED[3] must be odd)
+* @param X - output array
+* @returns output array `X` filled with random numbers
+*
+* @example
+* var Int32Array = require( '@stdlib/array/int32' );
+* var Float64Array = require( '@stdlib/array/float64' );
+*
+* var ISEED = new Int32Array( [ 0, 1, 2, 3 ] );
+* var X = new Float64Array( 3 );
+*
+* dlaruv( 3, ISEED, X );
+* // X =>
+*
+* @example
+* var Int32Array = require( '@stdlib/array/int32' );
+* var Float64Array = require( '@stdlib/array/float64' );
+*
+* var ISEED = new Int32Array( [ 0, 1, 2, 3 ] );
+* var X = new Float64Array( 3 );
+*
+* dlaruv.ndarray( 3, ISEED, 1, 0, X, 1, 0 );
+* // X =>
+*/
+declare var dlaruv: Routine;
+
+
+// EXPORTS //
+
+export = dlaruv;
diff --git a/lib/node_modules/@stdlib/lapack/base/dlaruv/docs/types/test.ts b/lib/node_modules/@stdlib/lapack/base/dlaruv/docs/types/test.ts
new file mode 100644
index 000000000000..a5c60f97996a
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlaruv/docs/types/test.ts
@@ -0,0 +1,214 @@
+/*
+* @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 dlaruv = require( './index' );
+
+
+// TESTS //
+
+// The function returns a Float64Array...
+{
+ const ISEED = new Int32Array( [ 0, 1, 2, 3 ] );
+ const X = new Float64Array( 3 );
+
+ dlaruv( 3, ISEED, X ); // $ExpectType Float64Array
+}
+
+// The compiler throws an error if the function is provided a first argument which is not a number...
+{
+ const ISEED = new Int32Array( [ 0, 1, 2, 3 ] );
+ const X = new Float64Array( 3 );
+
+ dlaruv( '5', ISEED, X ); // $ExpectError
+ dlaruv( true, ISEED, X ); // $ExpectError
+ dlaruv( false, ISEED, X ); // $ExpectError
+ dlaruv( null, ISEED, X ); // $ExpectError
+ dlaruv( void 0, ISEED, X ); // $ExpectError
+ dlaruv( [], ISEED, X ); // $ExpectError
+ dlaruv( {}, ISEED, X ); // $ExpectError
+ dlaruv( ( x: number ): number => x, ISEED, X ); // $ExpectError
+}
+
+// The compiler throws an error if the function is provided a second argument which is not an Int32Array...
+{
+ const X = new Float64Array( 3 );
+
+ dlaruv( 3, '5', X ); // $ExpectError
+ dlaruv( 3, 5, X ); // $ExpectError
+ dlaruv( 3, true, X ); // $ExpectError
+ dlaruv( 3, false, X ); // $ExpectError
+ dlaruv( 3, null, X ); // $ExpectError
+ dlaruv( 3, void 0, X ); // $ExpectError
+ dlaruv( 3, [], X ); // $ExpectError
+ dlaruv( 3, {}, X ); // $ExpectError
+ dlaruv( 3, ( x: number ): number => x, X ); // $ExpectError
+}
+
+// The compiler throws an error if the function is provided a third argument which is not a Float64Array...
+{
+ const ISEED = new Int32Array( [ 0, 1, 2, 3 ] );
+
+ dlaruv( 3, ISEED, '5' ); // $ExpectError
+ dlaruv( 3, ISEED, 5 ); // $ExpectError
+ dlaruv( 3, ISEED, true ); // $ExpectError
+ dlaruv( 3, ISEED, false ); // $ExpectError
+ dlaruv( 3, ISEED, null ); // $ExpectError
+ dlaruv( 3, ISEED, void 0 ); // $ExpectError
+ dlaruv( 3, ISEED, [] ); // $ExpectError
+ dlaruv( 3, ISEED, {} ); // $ExpectError
+ dlaruv( 3, ISEED, ( x: number ): number => x ); // $ExpectError
+}
+
+// The compiler throws an error if the function is provided an unsupported number of arguments...
+{
+ const ISEED = new Int32Array( [ 0, 1, 2, 3 ] );
+ const X = new Float64Array( 3 );
+
+ dlaruv(); // $ExpectError
+ dlaruv( 3 ); // $ExpectError
+ dlaruv( 3, ISEED ); // $ExpectError
+ dlaruv( 3, ISEED, X, 10 ); // $ExpectError
+}
+
+// Attached to main export is an `ndarray` method which returns a Float64Array...
+{
+ const ISEED = new Int32Array( [ 0, 1, 2, 3 ] );
+ const X = new Float64Array( 3 );
+
+ dlaruv.ndarray( 3, ISEED, 1, 0, X, 1, 0 ); // $ExpectType Float64Array
+}
+
+// The compiler throws an error if the `ndarray` method is provided a first argument which is not a number...
+{
+ const ISEED = new Int32Array( [ 0, 1, 2, 3 ] );
+ const X = new Float64Array( 3 );
+
+ dlaruv.ndarray( '5', ISEED, 1, 0, X, 1, 0 ); // $ExpectError
+ dlaruv.ndarray( true, ISEED, 1, 0, X, 1, 0 ); // $ExpectError
+ dlaruv.ndarray( false, ISEED, 1, 0, X, 1, 0 ); // $ExpectError
+ dlaruv.ndarray( null, ISEED, 1, 0, X, 1, 0 ); // $ExpectError
+ dlaruv.ndarray( void 0, ISEED, 1, 0, X, 1, 0 ); // $ExpectError
+ dlaruv.ndarray( [], ISEED, 1, 0, X, 1, 0 ); // $ExpectError
+ dlaruv.ndarray( {}, ISEED, 1, 0, X, 1, 0 ); // $ExpectError
+ dlaruv.ndarray( ( x: number ): number => x, ISEED, 1, 0, X, 1, 0 ); // $ExpectError
+}
+
+// The compiler throws an error if the `ndarray` method is provided a second argument which is not an Int32Array...
+{
+ const X = new Float64Array( 3 );
+
+ dlaruv.ndarray( 3, '5', 1, 0, X, 1, 0 ); // $ExpectError
+ dlaruv.ndarray( 3, 5, 1, 0, X, 1, 0 ); // $ExpectError
+ dlaruv.ndarray( 3, true, 1, 0, X, 1, 0 ); // $ExpectError
+ dlaruv.ndarray( 3, false, 1, 0, X, 1, 0 ); // $ExpectError
+ dlaruv.ndarray( 3, null, 1, 0, X, 1, 0 ); // $ExpectError
+ dlaruv.ndarray( 3, void 0, 1, 0, X, 1, 0 ); // $ExpectError
+ dlaruv.ndarray( 3, [], 1, 0, X, 1, 0 ); // $ExpectError
+ dlaruv.ndarray( 3, {}, 1, 0, X, 1, 0 ); // $ExpectError
+ dlaruv.ndarray( 3, ( x: number ): number => x, 1, 0, X, 1, 0 ); // $ExpectError
+}
+
+// The compiler throws an error if the `ndarray` method is provided a third argument which is not a number...
+{
+ const ISEED = new Int32Array( [ 0, 1, 2, 3 ] );
+ const X = new Float64Array( 3 );
+
+ dlaruv.ndarray( 3, ISEED, '5', 0, X, 1, 0 ); // $ExpectError
+ dlaruv.ndarray( 3, ISEED, true, 0, X, 1, 0 ); // $ExpectError
+ dlaruv.ndarray( 3, ISEED, false, 0, X, 1, 0 ); // $ExpectError
+ dlaruv.ndarray( 3, ISEED, null, 0, X, 1, 0 ); // $ExpectError
+ dlaruv.ndarray( 3, ISEED, void 0, 0, X, 1, 0 ); // $ExpectError
+ dlaruv.ndarray( 3, ISEED, [], 0, X, 1, 0 ); // $ExpectError
+ dlaruv.ndarray( 3, ISEED, {}, 0, X, 1, 0 ); // $ExpectError
+ dlaruv.ndarray( 3, ISEED, ( x: number ): number => x, 0, X, 1, 0 ); // $ExpectError
+}
+
+// The compiler throws an error if the `ndarray` method is provided a fourth argument which is not a number...
+{
+ const ISEED = new Int32Array( [ 0, 1, 2, 3 ] );
+ const X = new Float64Array( 3 );
+
+ dlaruv.ndarray( 3, ISEED, 1, '5', X, 1, 0 ); // $ExpectError
+ dlaruv.ndarray( 3, ISEED, 1, true, X, 1, 0 ); // $ExpectError
+ dlaruv.ndarray( 3, ISEED, 1, false, X, 1, 0 ); // $ExpectError
+ dlaruv.ndarray( 3, ISEED, 1, null, X, 1, 0 ); // $ExpectError
+ dlaruv.ndarray( 3, ISEED, 1, void 0, X, 1, 0 ); // $ExpectError
+ dlaruv.ndarray( 3, ISEED, 1, [], X, 1, 0 ); // $ExpectError
+ dlaruv.ndarray( 3, ISEED, 1, {}, X, 1, 0 ); // $ExpectError
+ dlaruv.ndarray( 3, ISEED, 1, ( x: number ): number => x, X, 1, 0 ); // $ExpectError
+}
+
+// The compiler throws an error if the `ndarray` method is provided a fifth argument which is not a Float64Array...
+{
+ const ISEED = new Int32Array( [ 0, 1, 2, 3 ] );
+
+ dlaruv.ndarray( 3, ISEED, 1, 0, '5', 1, 0 ); // $ExpectError
+ dlaruv.ndarray( 3, ISEED, 1, 0, 5, 1, 0 ); // $ExpectError
+ dlaruv.ndarray( 3, ISEED, 1, 0, true, 1, 0 ); // $ExpectError
+ dlaruv.ndarray( 3, ISEED, 1, 0, false, 1, 0 ); // $ExpectError
+ dlaruv.ndarray( 3, ISEED, 1, 0, null, 1, 0 ); // $ExpectError
+ dlaruv.ndarray( 3, ISEED, 1, 0, void 0, 1, 0 ); // $ExpectError
+ dlaruv.ndarray( 3, ISEED, 1, 0, [], 1, 0 ); // $ExpectError
+ dlaruv.ndarray( 3, ISEED, 1, 0, {}, 1, 0 ); // $ExpectError
+ dlaruv.ndarray( 3, ISEED, 1, 0, ( x: number ): number => x, 1, 0 ); // $ExpectError
+}
+
+// The compiler throws an error if the `ndarray` method is provided a sixth argument which is not a number...
+{
+ const ISEED = new Int32Array( [ 0, 1, 2, 3 ] );
+ const X = new Float64Array( 3 );
+
+ dlaruv.ndarray( 3, ISEED, 1, 0, X, '5', 0 ); // $ExpectError
+ dlaruv.ndarray( 3, ISEED, 1, 0, X, true, 0 ); // $ExpectError
+ dlaruv.ndarray( 3, ISEED, 1, 0, X, false, 0 ); // $ExpectError
+ dlaruv.ndarray( 3, ISEED, 1, 0, X, null, 0 ); // $ExpectError
+ dlaruv.ndarray( 3, ISEED, 1, 0, X, void 0, 0 ); // $ExpectError
+ dlaruv.ndarray( 3, ISEED, 1, 0, X, [], 0 ); // $ExpectError
+ dlaruv.ndarray( 3, ISEED, 1, 0, X, {}, 0 ); // $ExpectError
+ dlaruv.ndarray( 3, ISEED, 1, 0, X, ( x: number ): number => x, 0 ); // $ExpectError
+}
+
+// The compiler throws an error if the `ndarray` method is provided a seventh argument which is not a number...
+{
+ const ISEED = new Int32Array( [ 0, 1, 2, 3 ] );
+ const X = new Float64Array( 3 );
+
+ dlaruv.ndarray( 3, ISEED, 1, 0, X, 1, '5' ); // $ExpectError
+ dlaruv.ndarray( 3, ISEED, 1, 0, X, 1, true ); // $ExpectError
+ dlaruv.ndarray( 3, ISEED, 1, 0, X, 1, false ); // $ExpectError
+ dlaruv.ndarray( 3, ISEED, 1, 0, X, 1, null ); // $ExpectError
+ dlaruv.ndarray( 3, ISEED, 1, 0, X, 1, void 0 ); // $ExpectError
+ dlaruv.ndarray( 3, ISEED, 1, 0, X, 1, [] ); // $ExpectError
+ dlaruv.ndarray( 3, ISEED, 1, 0, X, 1, {} ); // $ExpectError
+ dlaruv.ndarray( 3, ISEED, 1, 0, X, 1, ( x: number ): number => x ); // $ExpectError
+}
+
+// The compiler throws an error if the `ndarray` method is provided an unsupported number of arguments...
+{
+ const ISEED = new Int32Array( [ 0, 1, 2, 3 ] );
+ const X = new Float64Array( 3 );
+
+ dlaruv.ndarray(); // $ExpectError
+ dlaruv.ndarray( 3 ); // $ExpectError
+ dlaruv.ndarray( 3, ISEED ); // $ExpectError
+ dlaruv.ndarray( 3, ISEED, 1 ); // $ExpectError
+ dlaruv.ndarray( 3, ISEED, 1, 0 ); // $ExpectError
+ dlaruv.ndarray( 3, ISEED, 1, 0, X ); // $ExpectError
+ dlaruv.ndarray( 3, ISEED, 1, 0, X, 1 ); // $ExpectError
+ dlaruv.ndarray( 3, ISEED, 1, 0, X, 1, 0, 10 ); // $ExpectError
+}
diff --git a/lib/node_modules/@stdlib/lapack/base/dlaruv/examples/index.js b/lib/node_modules/@stdlib/lapack/base/dlaruv/examples/index.js
new file mode 100644
index 000000000000..ccdb51763cf7
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlaruv/examples/index.js
@@ -0,0 +1,31 @@
+/**
+* @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 Int32Array = require( '@stdlib/array/int32' );
+var Float64Array = require( '@stdlib/array/float64' );
+var dlaruv = require( './../lib' );
+
+var ISEED = new Int32Array( [ 1, 23, 456, 3795 ] );
+var X = new Float64Array( 10 );
+
+dlaruv( X.length, ISEED, X );
+
+console.log( X );
+console.log( ISEED );
diff --git a/lib/node_modules/@stdlib/lapack/base/dlaruv/lib/base.js b/lib/node_modules/@stdlib/lapack/base/dlaruv/lib/base.js
new file mode 100644
index 000000000000..e8fdfe1d6c0c
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlaruv/lib/base.js
@@ -0,0 +1,254 @@
+/**
+* @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.
+*/
+
+/* eslint-disable max-len */
+
+'use strict';
+
+// MODULES //
+
+var floor = require( '@stdlib/math/base/special/floor' );
+var min = require( '@stdlib/math/base/special/min' );
+
+
+// VARIABLES //
+
+var LV = 128;
+var IPW2 = 4096;
+var R = 1.0 / IPW2;
+
+/*
+* MM table: 128 x 4 (row-major). Each row i contains the multiplier for the (i+1)-th power of the base multiplier modulo 2^48.
+* MM[i][j] = MM_TABLE[ i ][ j ], i = 0..127, j = 0..3
+* Transcribed directly from the LAPACK reference Fortran source (dlaruv.f).
+*/
+var MM_TABLE = [
+ [ 494, 322, 2508, 2549 ],
+ [ 2637, 789, 3754, 1145 ],
+ [ 255, 1440, 1766, 2253 ],
+ [ 2008, 752, 3572, 305 ],
+ [ 1253, 2859, 2893, 3301 ],
+ [ 3344, 123, 307, 1065 ],
+ [ 4084, 1848, 1297, 3133 ],
+ [ 1739, 643, 3966, 2913 ],
+ [ 3143, 2405, 758, 3285 ],
+ [ 3468, 2638, 2598, 1241 ],
+ [ 688, 2344, 3406, 1197 ],
+ [ 1657, 46, 2922, 3729 ],
+ [ 1238, 3814, 1038, 2501 ],
+ [ 3166, 913, 2934, 1673 ],
+ [ 1292, 3649, 2091, 541 ],
+ [ 3422, 339, 2451, 2753 ],
+ [ 1270, 3808, 1580, 949 ],
+ [ 2016, 822, 1958, 2361 ],
+ [ 154, 2832, 2055, 1165 ],
+ [ 2862, 3078, 1507, 4081 ],
+ [ 697, 3633, 1078, 2725 ],
+ [ 1706, 2970, 3273, 3305 ],
+ [ 491, 637, 17, 3069 ],
+ [ 931, 2249, 854, 3617 ],
+ [ 1444, 2081, 2916, 3733 ],
+ [ 444, 4019, 3971, 409 ],
+ [ 3577, 1478, 2889, 2157 ],
+ [ 3944, 242, 3831, 1361 ],
+ [ 2184, 481, 2621, 3973 ],
+ [ 1661, 2075, 1541, 1865 ],
+ [ 3482, 4058, 893, 2525 ],
+ [ 657, 622, 736, 1409 ],
+ [ 3023, 3376, 3992, 3445 ],
+ [ 3618, 812, 787, 3577 ],
+ [ 1267, 234, 2125, 77 ],
+ [ 1828, 641, 2364, 3761 ],
+ [ 164, 4005, 2460, 2149 ],
+ [ 3798, 1122, 257, 1449 ],
+ [ 3087, 3135, 1574, 3005 ],
+ [ 2400, 2640, 3912, 225 ],
+ [ 2870, 2302, 1216, 85 ],
+ [ 3876, 40, 3248, 3673 ],
+ [ 1905, 1832, 3401, 3117 ],
+ [ 1593, 2247, 2124, 3089 ],
+ [ 1797, 2034, 2762, 1349 ],
+ [ 1234, 2637, 149, 2057 ],
+ [ 3460, 1287, 2245, 413 ],
+ [ 328, 1691, 166, 65 ],
+ [ 2861, 496, 466, 1845 ],
+ [ 1950, 1597, 4018, 697 ],
+ [ 617, 2394, 1399, 3085 ],
+ [ 2070, 2584, 190, 3441 ],
+ [ 3331, 1843, 2879, 1573 ],
+ [ 769, 336, 153, 3689 ],
+ [ 1558, 1472, 2320, 2941 ],
+ [ 2412, 2407, 18, 929 ],
+ [ 2800, 433, 712, 533 ],
+ [ 189, 2096, 2159, 2841 ],
+ [ 287, 1761, 2318, 4077 ],
+ [ 2045, 2810, 2091, 721 ],
+ [ 1227, 566, 3443, 2821 ],
+ [ 2838, 442, 1510, 2249 ],
+ [ 209, 41, 449, 2397 ],
+ [ 2770, 1238, 1956, 2817 ],
+ [ 3654, 1086, 2201, 245 ],
+ [ 3993, 603, 3137, 1913 ],
+ [ 192, 840, 3399, 1997 ],
+ [ 2253, 3168, 1321, 3121 ],
+ [ 3491, 1499, 2271, 997 ],
+ [ 2889, 1084, 3667, 1833 ],
+ [ 2857, 3438, 2703, 2877 ],
+ [ 2094, 2408, 629, 1633 ],
+ [ 1818, 1589, 2365, 981 ],
+ [ 688, 2391, 2431, 2009 ],
+ [ 1407, 288, 1113, 941 ],
+ [ 634, 26, 3922, 2449 ],
+ [ 3231, 512, 2554, 197 ],
+ [ 815, 1456, 184, 2441 ],
+ [ 3524, 171, 2099, 285 ],
+ [ 1914, 1677, 3228, 1473 ],
+ [ 516, 2657, 4012, 2741 ],
+ [ 164, 2270, 1921, 3129 ],
+ [ 303, 2587, 3452, 909 ],
+ [ 2144, 2961, 3901, 2801 ],
+ [ 3480, 1970, 572, 421 ],
+ [ 119, 1817, 3309, 4073 ],
+ [ 3357, 676, 3171, 2813 ],
+ [ 837, 1410, 817, 2337 ],
+ [ 2826, 3723, 3039, 1429 ],
+ [ 2332, 2803, 1696, 1177 ],
+ [ 2089, 3185, 1256, 1901 ],
+ [ 3780, 184, 3715, 81 ],
+ [ 1700, 663, 2077, 1669 ],
+ [ 3712, 499, 3019, 2633 ],
+ [ 150, 3784, 1497, 2269 ],
+ [ 2000, 1631, 1101, 129 ],
+ [ 3375, 1925, 717, 1141 ],
+ [ 1621, 3912, 51, 249 ],
+ [ 3090, 1398, 981, 3917 ],
+ [ 3765, 1349, 1978, 2481 ],
+ [ 1149, 1441, 1813, 3941 ],
+ [ 3146, 2224, 3881, 2217 ],
+ [ 33, 2411, 76, 2749 ],
+ [ 3082, 1907, 3846, 3041 ],
+ [ 2741, 3192, 3694, 1877 ],
+ [ 359, 2786, 1682, 345 ],
+ [ 3316, 382, 124, 2861 ],
+ [ 1749, 37, 1660, 1809 ],
+ [ 185, 759, 3997, 3141 ],
+ [ 2784, 2948, 479, 2825 ],
+ [ 2202, 1862, 1141, 157 ],
+ [ 2199, 3802, 886, 2881 ],
+ [ 1364, 2423, 3514, 3637 ],
+ [ 1244, 2051, 1301, 1465 ],
+ [ 2020, 2295, 3604, 2829 ],
+ [ 3160, 1332, 1888, 2161 ],
+ [ 2785, 1832, 1836, 3365 ],
+ [ 2772, 2405, 1990, 361 ],
+ [ 1217, 3638, 2058, 2685 ],
+ [ 1822, 3661, 692, 3745 ],
+ [ 1245, 327, 1194, 2325 ],
+ [ 2252, 3660, 20, 3609 ],
+ [ 3904, 716, 3285, 3821 ],
+ [ 2774, 1842, 2046, 3537 ],
+ [ 997, 3987, 2107, 517 ],
+ [ 2573, 1368, 3508, 3017 ],
+ [ 1148, 1848, 3525, 2141 ],
+ [ 545, 2366, 3801, 1537 ]
+];
+
+
+// MAIN //
+
+/**
+* Returns a vector of `N` random real numbers from a uniform (0,1) distribution.
+*
+* @private
+* @param {NonNegativeInteger} N - number of random numbers to generate (N <= 128)
+* @param {Int32Array} ISEED - seed array of four integers (each between 0 and 4095, ISEED[3] must be odd)
+* @param {integer} strideISEED - stride length for `ISEED`
+* @param {NonNegativeInteger} offsetISEED - starting index for `ISEED`
+* @param {Float64Array} X - output array
+* @param {integer} strideX - stride length for `X`
+* @param {NonNegativeInteger} offsetX - starting index for `X`
+* @returns {Float64Array} output array `X` filled with random numbers
+*
+* @example
+* var Int32Array = require( '@stdlib/array/int32' );
+* var Float64Array = require( '@stdlib/array/float64' );
+*
+* var ISEED = new Int32Array( [ 0, 1, 2, 3 ] );
+* var X = new Float64Array( 3 );
+*
+* dlaruv( 3, ISEED, 1, 0, X, 1, 0 );
+* // X =>
+*/
+function dlaruv( N, ISEED, strideISEED, offsetISEED, X, strideX, offsetX ) {
+ var row;
+ var it1;
+ var it2;
+ var it3;
+ var it4;
+ var i1;
+ var i2;
+ var i3;
+ var i4;
+ var ox;
+ var i;
+
+ if ( N < 1 ) {
+ return X;
+ }
+
+ // Copy seed values into local variables...
+ i1 = ISEED[ offsetISEED ];
+ i2 = ISEED[ offsetISEED + strideISEED ];
+ i3 = ISEED[ offsetISEED + ( 2 * strideISEED ) ];
+ i4 = ISEED[ offsetISEED + ( 3 * strideISEED ) ];
+
+ ox = offsetX;
+ for ( i = 0; i < min( N, LV ); i++ ) {
+ row = MM_TABLE[ i ];
+
+ // Multiply the seed by the i-th power of the multiplier modulo 2^48:
+ it4 = i4 * row[ 3 ];
+ it3 = floor( it4 / IPW2 );
+ it4 -= IPW2 * it3;
+ it3 += ( i3 * row[ 3 ] ) + ( i4 * row[ 2 ] );
+ it2 = floor( it3 / IPW2 );
+ it3 -= IPW2 * it2;
+ it2 += ( i2 * row[ 3 ] ) + ( i3 * row[ 2 ] ) + ( i4 * row[ 1 ] );
+ it1 = floor( it2 / IPW2 );
+ it2 -= IPW2 * it1;
+ it1 += ( i1 * row[ 3 ] ) + ( i2 * row[ 2 ] ) + ( i3 * row[ 1 ] ) + ( i4 * row[ 0 ] );
+ it1 %= IPW2;
+
+ // Convert 48-bit integer to a real number in the interval (0,1):
+ X[ ox ] = ( R * ( it1 + ( R * ( it2 + ( R * ( it3 + ( R * it4 ) ) ) ) ) ) );
+ ox += strideX;
+ }
+
+ // Update seed values:
+ ISEED[ offsetISEED ] = it1;
+ ISEED[ offsetISEED + strideISEED ] = it2;
+ ISEED[ offsetISEED + ( 2 * strideISEED ) ] = it3;
+ ISEED[ offsetISEED + ( 3 * strideISEED ) ] = it4;
+
+ return X;
+}
+
+
+// EXPORTS //
+
+module.exports = dlaruv;
diff --git a/lib/node_modules/@stdlib/lapack/base/dlaruv/lib/dlaruv.js b/lib/node_modules/@stdlib/lapack/base/dlaruv/lib/dlaruv.js
new file mode 100644
index 000000000000..07fb1b400670
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlaruv/lib/dlaruv.js
@@ -0,0 +1,58 @@
+/**
+* @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 format = require( '@stdlib/string/format' );
+var base = require( './base.js' );
+
+
+// MAIN //
+
+/**
+* Returns a vector of `N` random real numbers from a uniform (0,1) distribution.
+*
+* @param {NonNegativeInteger} N - number of random numbers to generate (N <= 128)
+* @param {Int32Array} ISEED - seed array of four integers (each between 0 and 4095, ISEED[3] must be odd)
+* @param {Float64Array} X - output array
+* @throws {RangeError} first argument must be a nonnegative integer
+* @returns {Float64Array} output array `X` filled with random numbers
+*
+* @example
+* var Int32Array = require( '@stdlib/array/int32' );
+* var Float64Array = require( '@stdlib/array/float64' );
+*
+* var ISEED = new Int32Array( [ 0, 1, 2, 3 ] );
+* var X = new Float64Array( 3 );
+*
+* dlaruv( 3, ISEED, X );
+* // X =>
+*/
+function dlaruv( N, ISEED, X ) {
+ if ( N < 0 ) {
+ throw new RangeError( format( 'invalid argument. First argument must be a nonnegative integer. Value: `%d`.', N ) );
+ }
+ return base( N, ISEED, 1, 0, X, 1, 0 );
+}
+
+
+// EXPORTS //
+
+module.exports = dlaruv;
diff --git a/lib/node_modules/@stdlib/lapack/base/dlaruv/lib/index.js b/lib/node_modules/@stdlib/lapack/base/dlaruv/lib/index.js
new file mode 100644
index 000000000000..03c2ef30922d
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlaruv/lib/index.js
@@ -0,0 +1,72 @@
+/**
+* @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';
+
+/**
+* LAPACK routine to return a vector of `N` random real numbers from a uniform (0,1) distribution.
+*
+* @module @stdlib/lapack/base/dlaruv
+*
+* @example
+* var Int32Array = require( '@stdlib/array/int32' );
+* var Float64Array = require( '@stdlib/array/float64' );
+* var dlaruv = require( '@stdlib/lapack/base/dlaruv' );
+*
+* var ISEED = new Int32Array( [ 0, 1, 2, 3 ] );
+* var X = new Float64Array( 3 );
+*
+* dlaruv( 3, ISEED, X );
+* // X =>
+*
+* @example
+* var Int32Array = require( '@stdlib/array/int32' );
+* var Float64Array = require( '@stdlib/array/float64' );
+* var dlaruv = require( '@stdlib/lapack/base/dlaruv' );
+*
+* var ISEED = new Int32Array( [ 0, 1, 2, 3 ] );
+* var X = new Float64Array( 3 );
+*
+* dlaruv.ndarray( 3, ISEED, 1, 0, X, 1, 0 );
+* // X =>
+*/
+
+// MODULES //
+
+var join = require( 'path' ).join;
+var tryRequire = require( '@stdlib/utils/try-require' );
+var isError = require( '@stdlib/assert/is-error' );
+var main = require( './main.js' );
+
+
+// MAIN //
+
+var dlaruv;
+var tmp = tryRequire( join( __dirname, './native.js' ) );
+if ( isError( tmp ) ) {
+ dlaruv = main;
+} else {
+ dlaruv = tmp;
+}
+
+
+// EXPORTS //
+
+module.exports = dlaruv;
+
+// exports: { "ndarray": "dlaruv.ndarray" }
diff --git a/lib/node_modules/@stdlib/lapack/base/dlaruv/lib/main.js b/lib/node_modules/@stdlib/lapack/base/dlaruv/lib/main.js
new file mode 100644
index 000000000000..1494a1e52b11
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlaruv/lib/main.js
@@ -0,0 +1,35 @@
+/**
+* @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 setReadOnly = require( '@stdlib/utils/define-nonenumerable-read-only-property' );
+var dlaruv = require( './dlaruv.js' );
+var ndarray = require( './ndarray.js' );
+
+
+// MAIN //
+
+setReadOnly( dlaruv, 'ndarray', ndarray );
+
+
+// EXPORTS //
+
+module.exports = dlaruv;
diff --git a/lib/node_modules/@stdlib/lapack/base/dlaruv/lib/ndarray.js b/lib/node_modules/@stdlib/lapack/base/dlaruv/lib/ndarray.js
new file mode 100644
index 000000000000..3548a7717e36
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlaruv/lib/ndarray.js
@@ -0,0 +1,62 @@
+/**
+* @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 format = require( '@stdlib/string/format' );
+var base = require( './base.js' );
+
+
+// MAIN //
+
+/**
+* Returns a vector of `N` random real numbers from a uniform (0,1) distribution using alternative indexing semantics.
+*
+* @param {NonNegativeInteger} N - number of random numbers to generate (N <= 128)
+* @param {Int32Array} ISEED - seed array of four integers (each between 0 and 4095, ISEED[3] must be odd)
+* @param {integer} strideISEED - stride length for `ISEED`
+* @param {NonNegativeInteger} offsetISEED - starting index for `ISEED`
+* @param {Float64Array} X - output array
+* @param {integer} strideX - stride length for `X`
+* @param {NonNegativeInteger} offsetX - starting index for `X`
+* @throws {RangeError} first argument must be a nonnegative integer
+* @returns {Float64Array} output array `X` filled with random numbers
+*
+* @example
+* var Int32Array = require( '@stdlib/array/int32' );
+* var Float64Array = require( '@stdlib/array/float64' );
+*
+* var ISEED = new Int32Array( [ 0, 1, 2, 3 ] );
+* var X = new Float64Array( 3 );
+*
+* dlaruv( 3, ISEED, 1, 0, X, 1, 0 );
+* // X =>
+*/
+function dlaruv( N, ISEED, strideISEED, offsetISEED, X, strideX, offsetX ) {
+ if ( N < 0 ) {
+ throw new RangeError( format( 'invalid argument. First argument must be a nonnegative integer. Value: `%d`.', N ) );
+ }
+ return base( N, ISEED, strideISEED, offsetISEED, X, strideX, offsetX );
+}
+
+
+// EXPORTS //
+
+module.exports = dlaruv;
diff --git a/lib/node_modules/@stdlib/lapack/base/dlaruv/package.json b/lib/node_modules/@stdlib/lapack/base/dlaruv/package.json
new file mode 100644
index 000000000000..c7aca5466ce7
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlaruv/package.json
@@ -0,0 +1,70 @@
+{
+ "name": "@stdlib/lapack/base/dlaruv",
+ "version": "0.0.0",
+ "description": "Return a vector of n random real numbers from a uniform (0,1) distribution.",
+ "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",
+ "mathematics",
+ "math",
+ "lapack",
+ "dlaruv",
+ "random",
+ "uniform",
+ "prng",
+ "linear",
+ "algebra",
+ "subroutines",
+ "array",
+ "ndarray",
+ "float64",
+ "double",
+ "float64array"
+ ]
+}
diff --git a/lib/node_modules/@stdlib/lapack/base/dlaruv/test/fixtures/large_strides/medium_n.json b/lib/node_modules/@stdlib/lapack/base/dlaruv/test/fixtures/large_strides/medium_n.json
new file mode 100644
index 000000000000..b55a87d9349b
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlaruv/test/fixtures/large_strides/medium_n.json
@@ -0,0 +1,71 @@
+{
+ "N": 10,
+ "ISEED": [
+ 100,
+ 9999,
+ 200,
+ 9999,
+ 300,
+ 9999,
+ 401,
+ 9999
+ ],
+ "strideISEED": 2,
+ "offsetISEED": 0,
+ "X": [
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999
+ ],
+ "strideX": 2,
+ "offsetX": 0,
+ "X_out": [
+ 0.7221151762867244,
+ 9999,
+ 0.3059602026783388,
+ 9999,
+ 0.7615758157127068,
+ 9999,
+ 0.6079652337045935,
+ 9999,
+ 0.0786368892901983,
+ 9999,
+ 0.4000379493120114,
+ 9999,
+ 0.10082534071584703,
+ 9999,
+ 0.23506144863762657,
+ 9999,
+ 0.17051886842240904,
+ 9999,
+ 0.009087995793297665,
+ 9999
+ ],
+ "ISEED_out": [
+ 37,
+ 9999,
+ 919,
+ 9999,
+ 1099,
+ 9999,
+ 2025,
+ 9999
+ ]
+}
diff --git a/lib/node_modules/@stdlib/lapack/base/dlaruv/test/fixtures/large_strides/small_n.json b/lib/node_modules/@stdlib/lapack/base/dlaruv/test/fixtures/large_strides/small_n.json
new file mode 100644
index 000000000000..673094a8ecf2
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlaruv/test/fixtures/large_strides/small_n.json
@@ -0,0 +1,51 @@
+{
+ "N": 5,
+ "ISEED": [
+ 0,
+ 9999,
+ 1,
+ 9999,
+ 2,
+ 9999,
+ 3,
+ 9999
+ ],
+ "strideISEED": 2,
+ "offsetISEED": 0,
+ "X": [
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999
+ ],
+ "strideX": 2,
+ "offsetX": 0,
+ "X_out": [
+ 0.13185632717602047,
+ 9999,
+ 0.23381133728018355,
+ 9999,
+ 0.321647369501445,
+ 9999,
+ 0.7105395653957878,
+ 9999,
+ 0.021072610098311628,
+ 9999
+ ],
+ "ISEED_out": [
+ 86,
+ 9999,
+ 1283,
+ 9999,
+ 2995,
+ 9999,
+ 1711,
+ 9999
+ ]
+}
diff --git a/lib/node_modules/@stdlib/lapack/base/dlaruv/test/fixtures/medium_n.json b/lib/node_modules/@stdlib/lapack/base/dlaruv/test/fixtures/medium_n.json
new file mode 100644
index 000000000000..49bfa7b661ca
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlaruv/test/fixtures/medium_n.json
@@ -0,0 +1,43 @@
+{
+ "N": 10,
+ "ISEED": [
+ 100,
+ 200,
+ 300,
+ 401
+ ],
+ "strideISEED": 1,
+ "offsetISEED": 0,
+ "X": [
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0
+ ],
+ "strideX": 1,
+ "offsetX": 0,
+ "X_out": [
+ 0.7221151762867244,
+ 0.3059602026783388,
+ 0.7615758157127068,
+ 0.6079652337045935,
+ 0.0786368892901983,
+ 0.4000379493120114,
+ 0.10082534071584703,
+ 0.23506144863762657,
+ 0.17051886842240904,
+ 0.009087995793297665
+ ],
+ "ISEED_out": [
+ 37,
+ 919,
+ 1099,
+ 2025
+ ]
+}
diff --git a/lib/node_modules/@stdlib/lapack/base/dlaruv/test/fixtures/mixed_strides/medium_n.json b/lib/node_modules/@stdlib/lapack/base/dlaruv/test/fixtures/mixed_strides/medium_n.json
new file mode 100644
index 000000000000..d8c21f2dc7fd
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlaruv/test/fixtures/mixed_strides/medium_n.json
@@ -0,0 +1,71 @@
+{
+ "N": 10,
+ "ISEED": [
+ 401,
+ 9999,
+ 300,
+ 9999,
+ 200,
+ 9999,
+ 100,
+ 9999
+ ],
+ "strideISEED": -2,
+ "offsetISEED": 6,
+ "X": [
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999
+ ],
+ "strideX": 2,
+ "offsetX": 0,
+ "X_out": [
+ 0.7221151762867244,
+ 9999,
+ 0.3059602026783388,
+ 9999,
+ 0.7615758157127068,
+ 9999,
+ 0.6079652337045935,
+ 9999,
+ 0.0786368892901983,
+ 9999,
+ 0.4000379493120114,
+ 9999,
+ 0.10082534071584703,
+ 9999,
+ 0.23506144863762657,
+ 9999,
+ 0.17051886842240904,
+ 9999,
+ 0.009087995793297665,
+ 9999
+ ],
+ "ISEED_out": [
+ 2025,
+ 9999,
+ 1099,
+ 9999,
+ 919,
+ 9999,
+ 37,
+ 9999
+ ]
+}
diff --git a/lib/node_modules/@stdlib/lapack/base/dlaruv/test/fixtures/mixed_strides/small_n.json b/lib/node_modules/@stdlib/lapack/base/dlaruv/test/fixtures/mixed_strides/small_n.json
new file mode 100644
index 000000000000..d0658f040d6d
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlaruv/test/fixtures/mixed_strides/small_n.json
@@ -0,0 +1,51 @@
+{
+ "N": 5,
+ "ISEED": [
+ 3,
+ 9999,
+ 2,
+ 9999,
+ 1,
+ 9999,
+ 0,
+ 9999
+ ],
+ "strideISEED": -2,
+ "offsetISEED": 6,
+ "X": [
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999,
+ 0,
+ 9999
+ ],
+ "strideX": 2,
+ "offsetX": 0,
+ "X_out": [
+ 0.13185632717602047,
+ 9999,
+ 0.23381133728018355,
+ 9999,
+ 0.321647369501445,
+ 9999,
+ 0.7105395653957878,
+ 9999,
+ 0.021072610098311628,
+ 9999
+ ],
+ "ISEED_out": [
+ 1711,
+ 9999,
+ 2995,
+ 9999,
+ 1283,
+ 9999,
+ 86,
+ 9999
+ ]
+}
diff --git a/lib/node_modules/@stdlib/lapack/base/dlaruv/test/fixtures/negative_strides/medium_n.json b/lib/node_modules/@stdlib/lapack/base/dlaruv/test/fixtures/negative_strides/medium_n.json
new file mode 100644
index 000000000000..4b7de9bc1e25
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlaruv/test/fixtures/negative_strides/medium_n.json
@@ -0,0 +1,43 @@
+{
+ "N": 10,
+ "ISEED": [
+ 401,
+ 300,
+ 200,
+ 100
+ ],
+ "strideISEED": -1,
+ "offsetISEED": 3,
+ "X": [
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0
+ ],
+ "strideX": -1,
+ "offsetX": 9,
+ "X_out": [
+ 0.009087995793297665,
+ 0.17051886842240904,
+ 0.23506144863762657,
+ 0.10082534071584703,
+ 0.4000379493120114,
+ 0.0786368892901983,
+ 0.6079652337045935,
+ 0.7615758157127068,
+ 0.3059602026783388,
+ 0.7221151762867244
+ ],
+ "ISEED_out": [
+ 2025,
+ 1099,
+ 919,
+ 37
+ ]
+}
diff --git a/lib/node_modules/@stdlib/lapack/base/dlaruv/test/fixtures/negative_strides/small_n.json b/lib/node_modules/@stdlib/lapack/base/dlaruv/test/fixtures/negative_strides/small_n.json
new file mode 100644
index 000000000000..ccd9b0610330
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlaruv/test/fixtures/negative_strides/small_n.json
@@ -0,0 +1,33 @@
+{
+ "N": 5,
+ "ISEED": [
+ 3,
+ 2,
+ 1,
+ 0
+ ],
+ "strideISEED": -1,
+ "offsetISEED": 3,
+ "X": [
+ 0,
+ 0,
+ 0,
+ 0,
+ 0
+ ],
+ "strideX": -1,
+ "offsetX": 4,
+ "X_out": [
+ 0.021072610098311628,
+ 0.7105395653957878,
+ 0.321647369501445,
+ 0.23381133728018355,
+ 0.13185632717602047
+ ],
+ "ISEED_out": [
+ 1711,
+ 2995,
+ 1283,
+ 86
+ ]
+}
diff --git a/lib/node_modules/@stdlib/lapack/base/dlaruv/test/fixtures/offsets/medium_n.json b/lib/node_modules/@stdlib/lapack/base/dlaruv/test/fixtures/offsets/medium_n.json
new file mode 100644
index 000000000000..f3b8406c66a6
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlaruv/test/fixtures/offsets/medium_n.json
@@ -0,0 +1,47 @@
+{
+ "N": 10,
+ "ISEED": [
+ 9999,
+ 100,
+ 200,
+ 300,
+ 401
+ ],
+ "strideISEED": 1,
+ "offsetISEED": 1,
+ "X": [
+ 9999,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0
+ ],
+ "strideX": 1,
+ "offsetX": 1,
+ "X_out": [
+ 9999,
+ 0.7221151762867244,
+ 0.3059602026783388,
+ 0.7615758157127068,
+ 0.6079652337045935,
+ 0.0786368892901983,
+ 0.4000379493120114,
+ 0.10082534071584703,
+ 0.23506144863762657,
+ 0.17051886842240904,
+ 0.009087995793297665
+ ],
+ "ISEED_out": [
+ 9999,
+ 37,
+ 919,
+ 1099,
+ 2025
+ ]
+}
diff --git a/lib/node_modules/@stdlib/lapack/base/dlaruv/test/fixtures/offsets/small_n.json b/lib/node_modules/@stdlib/lapack/base/dlaruv/test/fixtures/offsets/small_n.json
new file mode 100644
index 000000000000..120ac928693b
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlaruv/test/fixtures/offsets/small_n.json
@@ -0,0 +1,37 @@
+{
+ "N": 5,
+ "ISEED": [
+ 9999,
+ 0,
+ 1,
+ 2,
+ 3
+ ],
+ "strideISEED": 1,
+ "offsetISEED": 1,
+ "X": [
+ 9999,
+ 0,
+ 0,
+ 0,
+ 0,
+ 0
+ ],
+ "strideX": 1,
+ "offsetX": 1,
+ "X_out": [
+ 9999,
+ 0.13185632717602047,
+ 0.23381133728018355,
+ 0.321647369501445,
+ 0.7105395653957878,
+ 0.021072610098311628
+ ],
+ "ISEED_out": [
+ 9999,
+ 86,
+ 1283,
+ 2995,
+ 1711
+ ]
+}
diff --git a/lib/node_modules/@stdlib/lapack/base/dlaruv/test/fixtures/small_n.json b/lib/node_modules/@stdlib/lapack/base/dlaruv/test/fixtures/small_n.json
new file mode 100644
index 000000000000..5be2930ac294
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlaruv/test/fixtures/small_n.json
@@ -0,0 +1,33 @@
+{
+ "N": 5,
+ "ISEED": [
+ 0,
+ 1,
+ 2,
+ 3
+ ],
+ "strideISEED": 1,
+ "offsetISEED": 0,
+ "X": [
+ 0,
+ 0,
+ 0,
+ 0,
+ 0
+ ],
+ "strideX": 1,
+ "offsetX": 0,
+ "X_out": [
+ 0.13185632717602047,
+ 0.23381133728018355,
+ 0.321647369501445,
+ 0.7105395653957878,
+ 0.021072610098311628
+ ],
+ "ISEED_out": [
+ 86,
+ 1283,
+ 2995,
+ 1711
+ ]
+}
diff --git a/lib/node_modules/@stdlib/lapack/base/dlaruv/test/test.dlaruv.js b/lib/node_modules/@stdlib/lapack/base/dlaruv/test/test.dlaruv.js
new file mode 100644
index 000000000000..fad5632b1f2c
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlaruv/test/test.dlaruv.js
@@ -0,0 +1,179 @@
+/**
+* @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 Float64Array = require( '@stdlib/array/float64' );
+var Int32Array = require( '@stdlib/array/int32' );
+var dlaruv = require( './../lib/dlaruv.js' );
+
+
+// FIXTURES //
+
+var SMALL_N = require( './fixtures/small_n.json' );
+var MEDIUM_N = require( './fixtures/medium_n.json' );
+
+
+// TESTS //
+
+tape( 'main export is a function', function test( t ) {
+ t.ok( true, __filename );
+ t.strictEqual( typeof dlaruv, 'function', 'main export is a function' );
+ t.end();
+});
+
+tape( 'the function has an arity of 3', function test( t ) {
+ t.strictEqual( dlaruv.length, 3, 'returns expected value' );
+ t.end();
+});
+
+tape( 'the function throws an error if provided an invalid first argument', function test( t ) {
+ var values;
+ var ISEED;
+ var X;
+ var i;
+
+ values = [
+ -1,
+ -2,
+ -3,
+ -4,
+ -5
+ ];
+
+ ISEED = new Int32Array( [ 0, 1, 2, 3 ] );
+ X = new Float64Array( 5 );
+
+ for ( i = 0; i < values.length; i++ ) {
+ t.throws( badValue( values[ i ] ), RangeError, 'throws an error when provided ' + values[ i ] );
+ }
+ t.end();
+
+ function badValue( value ) {
+ return function badValue() {
+ dlaruv( value, ISEED, X );
+ };
+ }
+});
+
+tape( 'the function returns a vector of random numbers from a uniform (0,1) distribution (small N)', function test( t ) {
+ var ISEED;
+ var data;
+ var X;
+
+ data = SMALL_N;
+
+ ISEED = new Int32Array( data.ISEED );
+ X = new Float64Array( data.X );
+
+ dlaruv( data.N, ISEED, X );
+ t.deepEqual( X, new Float64Array( data.X_out ), 'returns expected value' );
+ t.deepEqual( ISEED, new Int32Array( data.ISEED_out ), 'returns expected value' );
+
+ t.end();
+});
+
+tape( 'the function returns a vector of random numbers from a uniform (0,1) distribution (medium N)', function test( t ) {
+ var ISEED;
+ var data;
+ var X;
+
+ data = MEDIUM_N;
+
+ ISEED = new Int32Array( data.ISEED );
+ X = new Float64Array( data.X );
+
+ dlaruv( data.N, ISEED, X );
+ t.deepEqual( X, new Float64Array( data.X_out ), 'returns expected value' );
+ t.deepEqual( ISEED, new Int32Array( data.ISEED_out ), 'returns expected value' );
+
+ t.end();
+});
+
+tape( 'the function leaves output unchanged when `N` is equal to zero', function test( t ) {
+ var ISEED;
+ var data;
+ var X;
+
+ data = SMALL_N;
+
+ ISEED = new Int32Array( data.ISEED );
+ X = new Float64Array( data.X );
+
+ dlaruv( 0, ISEED, X );
+ t.deepEqual( X, new Float64Array( data.X ), 'returns expected value' );
+ t.deepEqual( ISEED, new Int32Array( data.ISEED ), 'returns expected value' );
+
+ t.end();
+});
+
+tape( 'the function produces deterministic output for the same seed', function test( t ) {
+ var ISEED1;
+ var ISEED2;
+ var X1;
+ var X2;
+
+ ISEED1 = new Int32Array( [ 0, 1, 2, 3 ] );
+ ISEED2 = new Int32Array( [ 0, 1, 2, 3 ] );
+ X1 = new Float64Array( 5 );
+ X2 = new Float64Array( 5 );
+
+ dlaruv( 5, ISEED1, X1 );
+ dlaruv( 5, ISEED2, X2 );
+
+ t.deepEqual( X1, X2, 'returns expected value' );
+ t.deepEqual( ISEED1, ISEED2, 'returns expected value' );
+
+ t.end();
+});
+
+tape( 'the function generates values in the open interval (0,1)', function test( t ) {
+ var ISEED;
+ var X;
+ var i;
+
+ ISEED = new Int32Array( [ 100, 200, 300, 401 ] );
+ X = new Float64Array( 128 );
+
+ dlaruv( 128, ISEED, X );
+
+ for ( i = 0; i < X.length; i++ ) {
+ t.ok( X[ i ] > 0.0 && X[ i ] < 1.0, 'value at index ' + i + ' is in (0,1): ' + X[ i ] );
+ }
+
+ t.end();
+});
+
+tape( 'the function generates at most 128 values per call', function test( t ) {
+ var ISEED;
+ var X;
+
+ ISEED = new Int32Array( [ 100, 200, 300, 401 ] );
+ X = new Float64Array( 130 );
+
+ dlaruv( 130, ISEED, X );
+
+ t.ok( X[ 127 ] > 0.0, 'returns expected value' );
+ t.strictEqual( X[ 128 ], 0.0, 'returns expected value' );
+ t.strictEqual( X[ 129 ], 0.0, 'returns expected value' );
+
+ t.end();
+});
diff --git a/lib/node_modules/@stdlib/lapack/base/dlaruv/test/test.js b/lib/node_modules/@stdlib/lapack/base/dlaruv/test/test.js
new file mode 100644
index 000000000000..d18d9aaa8072
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlaruv/test/test.js
@@ -0,0 +1,82 @@
+/**
+* @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 proxyquire = require( 'proxyquire' );
+var IS_BROWSER = require( '@stdlib/assert/is-browser' );
+var dlaruv = require( './../lib' );
+
+
+// VARIABLES //
+
+var opts = {
+ 'skip': IS_BROWSER
+};
+
+
+// TESTS //
+
+tape( 'main export is a function', function test( t ) {
+ t.ok( true, __filename );
+ t.strictEqual( typeof dlaruv, 'function', 'main export is a function' );
+ t.end();
+});
+
+tape( 'attached to the main export is a method providing an ndarray interface', function test( t ) {
+ t.strictEqual( typeof dlaruv.ndarray, 'function', 'method is a function' );
+ t.end();
+});
+
+tape( 'if a native implementation is available, the main export is the native implementation', opts, function test( t ) {
+ var dlaruv = proxyquire( './../lib', {
+ '@stdlib/utils/try-require': tryRequire
+ });
+
+ t.strictEqual( dlaruv, mock, 'returns expected value' );
+ t.end();
+
+ function tryRequire() {
+ return mock;
+ }
+
+ function mock() {
+ // Mock...
+ }
+});
+
+tape( 'if a native implementation is not available, the main export is a JavaScript implementation', opts, function test( t ) {
+ var dlaruv;
+ var main;
+
+ main = require( './../lib/main.js' );
+
+ dlaruv = proxyquire( './../lib', {
+ '@stdlib/utils/try-require': tryRequire
+ });
+
+ t.strictEqual( dlaruv, main, 'returns expected value' );
+ t.end();
+
+ function tryRequire() {
+ return new Error( 'Cannot find module' );
+ }
+});
diff --git a/lib/node_modules/@stdlib/lapack/base/dlaruv/test/test.ndarray.js b/lib/node_modules/@stdlib/lapack/base/dlaruv/test/test.ndarray.js
new file mode 100644
index 000000000000..d7895ac4b8e7
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dlaruv/test/test.ndarray.js
@@ -0,0 +1,297 @@
+/**
+* @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.
+*/
+
+/* eslint-disable max-len */
+
+'use strict';
+
+// MODULES //
+
+var tape = require( 'tape' );
+var Float64Array = require( '@stdlib/array/float64' );
+var Int32Array = require( '@stdlib/array/int32' );
+var dlaruv = require( './../lib/ndarray.js' );
+
+
+// FIXTURES //
+
+var SMALL_N = require( './fixtures/small_n.json' );
+var MEDIUM_N = require( './fixtures/medium_n.json' );
+var OFFSET_SMALL_N = require( './fixtures/offsets/small_n.json' );
+var OFFSET_MEDIUM_N = require( './fixtures/offsets/medium_n.json' );
+var NEGATIVE_STRIDES_SMALL_N = require( './fixtures/negative_strides/small_n.json' );
+var NEGATIVE_STRIDES_MEDIUM_N = require( './fixtures/negative_strides/medium_n.json' );
+var LARGE_STRIDES_SMALL_N = require( './fixtures/large_strides/small_n.json' );
+var LARGE_STRIDES_MEDIUM_N = require( './fixtures/large_strides/medium_n.json' );
+var MIXED_STRIDES_SMALL_N = require( './fixtures/mixed_strides/small_n.json' );
+var MIXED_STRIDES_MEDIUM_N = require( './fixtures/mixed_strides/medium_n.json' );
+
+
+// TESTS //
+
+tape( 'main export is a function', function test( t ) {
+ t.ok( true, __filename );
+ t.strictEqual( typeof dlaruv, 'function', 'main export is a function' );
+ t.end();
+});
+
+tape( 'the function has an arity of 7', function test( t ) {
+ t.strictEqual( dlaruv.length, 7, 'returns expected value' );
+ t.end();
+});
+
+tape( 'the function throws an error if provided an invalid first argument', function test( t ) {
+ var values;
+ var ISEED;
+ var X;
+ var i;
+
+ values = [
+ -1,
+ -2,
+ -3,
+ -4,
+ -5
+ ];
+
+ ISEED = new Int32Array( [ 0, 1, 2, 3 ] );
+ X = new Float64Array( 5 );
+
+ for ( i = 0; i < values.length; i++ ) {
+ t.throws( badValue( values[ i ] ), RangeError, 'throws an error when provided ' + values[ i ] );
+ }
+ t.end();
+
+ function badValue( value ) {
+ return function badValue() {
+ dlaruv( value, ISEED, 1, 0, X, 1, 0 );
+ };
+ }
+});
+
+tape( 'the function returns a vector of random numbers from a uniform (0,1) distribution (small N)', function test( t ) {
+ var ISEED;
+ var data;
+ var X;
+
+ data = SMALL_N;
+
+ ISEED = new Int32Array( data.ISEED );
+ X = new Float64Array( data.X );
+
+ dlaruv( data.N, ISEED, data.strideISEED, data.offsetISEED, X, data.strideX, data.offsetX );
+ t.deepEqual( X, new Float64Array( data.X_out ), 'returns expected value' );
+ t.deepEqual( ISEED, new Int32Array( data.ISEED_out ), 'returns expected value' );
+
+ t.end();
+});
+
+tape( 'the function returns a vector of random numbers from a uniform (0,1) distribution (medium N)', function test( t ) {
+ var ISEED;
+ var data;
+ var X;
+
+ data = MEDIUM_N;
+
+ ISEED = new Int32Array( data.ISEED );
+ X = new Float64Array( data.X );
+
+ dlaruv( data.N, ISEED, data.strideISEED, data.offsetISEED, X, data.strideX, data.offsetX );
+ t.deepEqual( X, new Float64Array( data.X_out ), 'returns expected value' );
+ t.deepEqual( ISEED, new Int32Array( data.ISEED_out ), 'returns expected value' );
+
+ t.end();
+});
+
+tape( 'the function supports providing positive strides (small N)', function test( t ) {
+ var ISEED;
+ var data;
+ var X;
+
+ data = LARGE_STRIDES_SMALL_N;
+
+ ISEED = new Int32Array( data.ISEED );
+ X = new Float64Array( data.X );
+
+ dlaruv( data.N, ISEED, data.strideISEED, data.offsetISEED, X, data.strideX, data.offsetX );
+ t.deepEqual( X, new Float64Array( data.X_out ), 'returns expected value' );
+
+ t.end();
+});
+
+tape( 'the function supports providing positive strides (medium N)', function test( t ) {
+ var ISEED;
+ var data;
+ var X;
+
+ data = LARGE_STRIDES_MEDIUM_N;
+
+ ISEED = new Int32Array( data.ISEED );
+ X = new Float64Array( data.X );
+
+ dlaruv( data.N, ISEED, data.strideISEED, data.offsetISEED, X, data.strideX, data.offsetX );
+ t.deepEqual( X, new Float64Array( data.X_out ), 'returns expected value' );
+
+ t.end();
+});
+
+tape( 'the function supports providing mixed sign strides (small N)', function test( t ) {
+ var ISEED;
+ var data;
+ var X;
+
+ data = MIXED_STRIDES_SMALL_N;
+
+ ISEED = new Int32Array( data.ISEED );
+ X = new Float64Array( data.X );
+
+ dlaruv( data.N, ISEED, data.strideISEED, data.offsetISEED, X, data.strideX, data.offsetX );
+ t.deepEqual( X, new Float64Array( data.X_out ), 'returns expected value' );
+
+ t.end();
+});
+
+tape( 'the function supports providing mixed sign strides (medium N)', function test( t ) {
+ var ISEED;
+ var data;
+ var X;
+
+ data = MIXED_STRIDES_MEDIUM_N;
+
+ ISEED = new Int32Array( data.ISEED );
+ X = new Float64Array( data.X );
+
+ dlaruv( data.N, ISEED, data.strideISEED, data.offsetISEED, X, data.strideX, data.offsetX );
+ t.deepEqual( X, new Float64Array( data.X_out ), 'returns expected value' );
+
+ t.end();
+});
+
+tape( 'the function supports providing negative strides (small N)', function test( t ) {
+ var ISEED;
+ var data;
+ var X;
+
+ data = NEGATIVE_STRIDES_SMALL_N;
+
+ ISEED = new Int32Array( data.ISEED );
+ X = new Float64Array( data.X );
+
+ dlaruv( data.N, ISEED, data.strideISEED, data.offsetISEED, X, data.strideX, data.offsetX );
+ t.deepEqual( X, new Float64Array( data.X_out ), 'returns expected value' );
+
+ t.end();
+});
+
+tape( 'the function supports providing negative strides (medium N)', function test( t ) {
+ var ISEED;
+ var data;
+ var X;
+
+ data = NEGATIVE_STRIDES_MEDIUM_N;
+
+ ISEED = new Int32Array( data.ISEED );
+ X = new Float64Array( data.X );
+
+ dlaruv( data.N, ISEED, data.strideISEED, data.offsetISEED, X, data.strideX, data.offsetX );
+ t.deepEqual( X, new Float64Array( data.X_out ), 'returns expected value' );
+
+ t.end();
+});
+
+tape( 'the function supports providing index offsets (small N)', function test( t ) {
+ var ISEED;
+ var data;
+ var X;
+
+ data = OFFSET_SMALL_N;
+
+ ISEED = new Int32Array( data.ISEED );
+ X = new Float64Array( data.X );
+
+ dlaruv( data.N, ISEED, data.strideISEED, data.offsetISEED, X, data.strideX, data.offsetX );
+ t.deepEqual( X, new Float64Array( data.X_out ), 'returns expected value' );
+
+ t.end();
+});
+
+tape( 'the function supports providing index offsets (medium N)', function test( t ) {
+ var ISEED;
+ var data;
+ var X;
+
+ data = OFFSET_MEDIUM_N;
+
+ ISEED = new Int32Array( data.ISEED );
+ X = new Float64Array( data.X );
+
+ dlaruv( data.N, ISEED, data.strideISEED, data.offsetISEED, X, data.strideX, data.offsetX );
+ t.deepEqual( X, new Float64Array( data.X_out ), 'returns expected value' );
+
+ t.end();
+});
+
+tape( 'the function leaves output unchanged when `N` is equal to zero', function test( t ) {
+ var ISEED;
+ var data;
+ var X;
+
+ data = SMALL_N;
+
+ ISEED = new Int32Array( data.ISEED );
+ X = new Float64Array( data.X );
+
+ dlaruv( 0, ISEED, data.strideISEED, data.offsetISEED, X, data.strideX, data.offsetX );
+ t.deepEqual( X, new Float64Array( data.X ), 'returns expected value' );
+ t.deepEqual( ISEED, new Int32Array( data.ISEED ), 'returns expected value' );
+
+ t.end();
+});
+
+tape( 'the function generates values in the open interval (0,1)', function test( t ) {
+ var ISEED;
+ var X;
+ var i;
+
+ ISEED = new Int32Array( [ 100, 200, 300, 401 ] );
+ X = new Float64Array( 128 );
+
+ dlaruv( 128, ISEED, 1, 0, X, 1, 0 );
+
+ for ( i = 0; i < X.length; i++ ) {
+ t.ok( X[ i ] > 0.0 && X[ i ] < 1.0, 'value at index ' + i + ' is in (0,1): ' + X[ i ] );
+ }
+
+ t.end();
+});
+
+tape( 'the function generates at most 128 values per call', function test( t ) {
+ var ISEED;
+ var X;
+
+ ISEED = new Int32Array( [ 100, 200, 300, 401 ] );
+ X = new Float64Array( 130 );
+
+ dlaruv( 130, ISEED, 1, 0, X, 1, 0 );
+
+ t.ok( X[ 127 ] > 0.0, 'returns expected value' );
+ t.strictEqual( X[ 128 ], 0.0, 'returns expected value' );
+ t.strictEqual( X[ 129 ], 0.0, 'returns expected value' );
+
+ t.end();
+});