diff --git a/lib/node_modules/@stdlib/lapack/base/dgeqr2/README.md b/lib/node_modules/@stdlib/lapack/base/dgeqr2/README.md
new file mode 100644
index 000000000000..9c27ab805232
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dgeqr2/README.md
@@ -0,0 +1,345 @@
+
+
+# dgeqr2
+
+> Computes a QR factorization of a general rectangular matrix using an unblocked algorithm.
+
+
+
+dgeqr2 computes an LQ factorization of a real m-by-n matrix A:
+
+
+
+```math
+A = Q * \left[
+\begin{array}{c}
+R \\
+0
+\end{array}
+\right]
+```
+
+
+
+Where:
+
+- `Q` is an `M-by-M` orthogonal matrix.
+- `R` is an upper-triangular `N-by-N` matrix.
+- `0` is a `(m-n)-by-n` zero matrix, if `M > N`.
+
+On exit, the elements on and above the diagonal of the array contain the min(M,N) by N upper trapezoidal matrix R (R is upper triangular if M >= N). The elements below the diagonal, with the array TAU represent the orthogonal matrix Q as a product of elementary reflectors.
+
+The matrix Q is represented as a product of elementary reflectors
+
+
+
+```math
+Q = H(1) H(2) . . . H(K)
+```
+
+
+
+where `K` = `min(M,N)`.
+
+Each H(i) has the form
+
+
+
+```math
+H(i) = I - TAU_i V_i V_i^T
+```
+
+
+
+Where `TAU` is a real scalar, and `V` is a real vector with `V(1:i-1)` = 0 and `V(i)` = 1 and `V(i+1:n)` is stored on exit in `A(i+1:m,i)`
+
+
+
+
+
+
+
+## Usage
+
+```javascript
+var dgeqr2 = require( '@stdlib/lapack/base/dgeqr2' );
+```
+
+#### dgeqr2( order, M, N, A, LDA, TAU, WORK )
+
+Compute a QR factorization of a general rectangular matrix using an unblocked algorithm.
+
+```javascript
+var Float64Array = require( '@stdlib/array/float64' );
+var dgeqr2 = require( '@stdlib/lapack/base/dgeqr2' );
+
+var A = new Float64Array( [ 1, 5, 9, 2, 6, 10, 3, 7, 11, 4, 8, 12 ] );
+var TAU = new Float64Array( 3 );
+var work = new Float64Array( 3 );
+
+dgeqr2( 'column-major', 3, 4, A, 3, TAU, work );
+// A => [ ~-10.344, ~0.441, ~0.793, ~-11.794, ~0.947, ~0.919, ~-13.244, ~1.894, ~0.0, ~-14.694, ~2.842, ~0.0 ]
+// TAU => [ ~1.097, ~1.084, 0.0 ]
+// work => [ ~-1.894, ~-2.842, ~17.046, 0.0 ]
+```
+
+The function has the following parameters:
+
+- **order**: storage layout.
+- **M**: number of rows in `A`.
+- **N**: number of columns in `A`.
+- **A**: input/output matrix as a [`Float64Array`][@stdlib/array/float64]. Should have `M*N` indexed elements. On exit, the elements on and below the diagonal of `A` contain the lower trapezoidal matrix `L`, and the elements above the diagonal, together with `TAU`, represent the orthogonal matrix `Q`.
+- **LDA**: stride of the first dimension of `A` (a.k.a., leading dimension of the matrix `A`).
+- **TAU**: output array of scalar factors as a [`Float64Array`][@stdlib/array/float64]. Should have `min(M,N)` indexed elements.
+- **WORK**: workspace array as a [`Float64Array`][@stdlib/array/float64]. Should have at least `M` indexed elements.
+
+Note that indexing is relative to the first index. To introduce an offset, use [`typed array`][mdn-typed-array] views.
+
+
+
+```javascript
+var Float64Array = require( '@stdlib/array/float64' );
+var dgeqr2 = require( '@stdlib/lapack/base/dgeqr2' );
+
+// Initial arrays...
+var A0 = new Float64Array( [ 0.0, 1.0, 5.0, 9.0, 2.0, 6.0, 10.0, 3.0, 7.0, 11.0, 4.0, 8.0, 12.0 ] );
+var TAU0 = new Float64Array( 4 );
+var work0 = new Float64Array( 5 );
+
+// Create offset views...
+var A = new Float64Array( A0.buffer, A0.BYTES_PER_ELEMENT*1 ); // start at 2nd element
+var TAU = new Float64Array( TAU0.buffer, TAU0.BYTES_PER_ELEMENT*1 ); // start at 2nd element
+var work = new Float64Array( work0.buffer, work0.BYTES_PER_ELEMENT*1 ); // start at 2nd element
+
+dgeqr2( 'column-major', 3, 4, A, 3, TAU, work );
+// A0 => [ 0.0, ~-10.344, ~0.441, ~0.793, ~-11.794, ~0.947, ~0.919, ~-13.244, ~1.894, ~0.0, ~-14.694, ~2.842, ~0.0 ]
+// TAU0 => [ 0.0, ~1.097, ~1.084, 0.0 ]
+// work0 => [ 0.0, ~-1.894, ~-2.842, ~17.046, 0.0 ]
+```
+
+
+
+#### dgeqr2.ndarray( M, N, A, strideA1, strideA2, offsetA, TAU, strideTAU, offsetTAU, WORK, strideWORK, offsetWORK )
+
+Compute a QR factorization of a general rectangular matrix using an unblocked algorithm using alternative indexing semantics.
+
+```javascript
+var Float64Array = require( '@stdlib/array/float64' );
+var dgeqr2 = require( '@stdlib/lapack/base/dgeqr2' );
+
+var A = new Float64Array( [ 1, 5, 9, 2, 6, 10, 3, 7, 11, 4, 8, 12 ] );
+var TAU = new Float64Array( 3 );
+var work = new Float64Array( 4 );
+
+dgeqr2.ndarray( 3, 4, A, 1, 3, 0, TAU, 1, 0, work, 1, 0 );
+// A => [ ~-10.344, ~0.441, ~0.793, ~-11.794, ~0.947, ~0.919, ~-13.244, ~1.894, ~0.0, ~-14.694, ~2.842, ~0.0 ]
+// TAU => [ ~1.097, ~1.084, 0.0 ]
+// work => [ ~-1.894, ~-2.842, ~17.046, 0.0 ]
+```
+
+The function has the following additional parameters:
+
+- **strideA1**: stride length for the first dimension of `A`.
+- **strideA2**: stride length for the second dimension of `A`.
+- **offsetA**: starting index for `A`.
+- **strideTAU**: stride length for `TAU`.
+- **offsetTAU**: starting index for `TAU`.
+- **strideWORK**: stride length for `WORK`.
+- **offsetWORK**: starting index for `WORK`.
+
+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 Float64Array = require( '@stdlib/array/float64' );
+var dgeqr2 = require( '@stdlib/lapack/base/dgeqr2' );
+
+var A0 = new Float64Array( [ 0.0, 1.0, 5.0, 9.0, 2.0, 6.0, 10.0, 3.0, 7.0, 11.0, 4.0, 8.0, 12.0 ] );
+var TAU0 = new Float64Array( 4 );
+var work0 = new Float64Array( 5 );
+dgeqr2.ndarray( 3, 4, A0, 1, 3, 1, TAU0, 1, 1, work0, 1, 1 );
+// A0 => [ 0.0, ~-10.344, ~0.441, ~0.793, ~-11.794, ~0.947, ~0.919, ~-13.244, ~1.894, ~0.0, ~-14.694, ~2.842, ~0.0 ]
+// TAU0 => [ 0.0, ~1.097, ~1.084, 0.0 ]
+// work0 => [ 0.0, ~-1.894, ~-2.842, ~17.046, 0.0 ]
+```
+
+
+
+
+
+
+
+## Notes
+
+- Both functions mutate the input arrays `A`, `TAU`, and `WORK`.
+- Both functions return a status code indicating success or failure. The status code indicates the following conditions:
+ - `0`: computation was successful.
+ - `<0`: the `-i`th argument had an illegal value.
+ - `dgeqr2()` corresponds to the [LAPACK][lapack] routine [`dgeqr2`][lapack-dgeqr2].
+
+
+
+
+
+
+
+## Examples
+
+
+
+```javascript
+var Float64Array = require( '@stdlib/array/float64' );
+var ndarray2array = require( '@stdlib/ndarray/base/to-array' );
+var shape2strides = require( '@stdlib/ndarray/base/shape2strides' );
+var dgeqr2 = require( '@stdlib/lapack/base/dgeqr' );
+
+// Specify matrix meta data:
+var shape = [ 3, 4 ];
+var order = 'row-major';
+var strides = shape2strides( shape, order );
+
+// Create a matrix stored in linear memory:
+var A = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ] ); // eslint-disable-line max-len
+
+console.log( 'A (unmodified):', ndarray2array( A, shape, strides, 0, order ) );
+
+// Output arrays:
+var TAU = new Float64Array( 3 );
+var work = new Float64Array( shape[ 1 ] );
+
+// Compute the LQ factorization in-place:
+var info = dgeqr2( order, shape[ 0 ], shape[ 1 ], A, strides[ 0 ], TAU, work );
+
+console.log( 'Status Code:', info );
+console.log( 'A (L + reflectors):', ndarray2array( A, shape, strides, 0, order ) );
+console.log( 'TAU:', TAU );
+console.log( 'WORK:', work );
+
+// Re-initialize arrays for the ndarray interface:
+A = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ] );
+TAU = new Float64Array( 3 );
+work = new Float64Array( 3 );
+
+// Compute the LQ factorization again using the ndarray interface:
+info = dgeqr2.ndarray( shape[ 0 ], shape[ 1 ], A, strides[ 0 ], strides[ 1 ], 0, TAU, 1, 0, work, 1, 0 );
+
+console.log( 'Status Code:', info );
+console.log( 'A (L + reflectors):', ndarray2array( A, shape, strides, 0, order ) );
+console.log( 'TAU:', TAU );
+console.log( 'WORK:', work );
+```
+
+
+
+
+
+
+
+* * *
+
+
+
+## C APIs
+
+
+
+
+
+
+
+
+
+
+
+### Usage
+
+```c
+TODO
+```
+
+#### TODO
+
+TODO.
+
+```c
+TODO
+```
+
+TODO
+
+```c
+TODO
+```
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+### Examples
+
+```c
+TODO
+```
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+[lapack]: https://www.netlib.org/lapack/explore-html/
+
+[lapack-dgeqr2]: https://www.netlib.org/lapack/explore-html/d6/da5/group__geqr2_ga0ff91490bc2e246cabb8fe02f3f1da97.html
+
+[@stdlib/array/float64]: https://stdlib.io/docs/api/latest/@stdlib/array/float64
+
+[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/dgeqr2/benchmark/benchmark.js b/lib/node_modules/@stdlib/lapack/base/dgeqr2/benchmark/benchmark.js
new file mode 100644
index 000000000000..4f8d51ab6040
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dgeqr2/benchmark/benchmark.js
@@ -0,0 +1,118 @@
+/**
+* @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 discreteUniform = require( '@stdlib/random/array/discrete-uniform' );
+var Float64Array = require( '@stdlib/array/float64' );
+var floor = require( '@stdlib/math/base/special/floor' );
+var pow = require( '@stdlib/math/base/special/pow' );
+var format = require( '@stdlib/string/format' );
+var pkg = require( './../package.json' ).name;
+var dgeqr2 = require( './../lib/dgeqr2.js' );
+
+
+// VARIABLES //
+
+var LAYOUTS = [
+ 'row-major',
+ 'column-major'
+];
+var opts = {
+ 'dtype': 'float64'
+};
+
+
+// FUNCTIONS //
+
+/**
+* Creates a benchmark function.
+*
+* @private
+* @param {string} order - storage layout
+* @param {PositiveInteger} N - matrix dimension
+* @returns {Function} benchmark function
+*/
+function createBenchmark( order, N ) {
+ var work = new Float64Array( N );
+ var TAU = new Float64Array( N );
+ var A = discreteUniform( N*N, 1.0, 10.0, opts );
+
+ return benchmark;
+
+ /**
+ * Benchmark function.
+ *
+ * @private
+ * @param {Benchmark} b - benchmark instance
+ */
+ function benchmark( b ) {
+ var i;
+ var z;
+
+ b.tic();
+ for ( i = 0; i < b.iterations; i++ ) {
+ z = dgeqr2( order, N, N, A, N, TAU, work );
+ if ( z !== 0 ) {
+ b.fail( 'should return 0' );
+ }
+ }
+ b.toc();
+
+ if ( z !== 0 ) {
+ b.fail( 'should return 0' );
+ }
+ b.pass( 'benchmark finished' );
+ b.end();
+ }
+}
+
+
+// MAIN //
+
+/**
+* Main execution sequence.
+*
+* @private
+*/
+function main() {
+ var min;
+ var max;
+ var ord;
+ var N;
+ var f;
+ var i;
+ var k;
+
+ min = 1; // 10^min
+ max = 6; // 10^max
+
+ for ( k = 0; k < LAYOUTS.length; k++ ) {
+ ord = LAYOUTS[ k ];
+ for ( i = min; i <= max; i++ ) {
+ N = floor( pow( pow( 10, i ), 1.0/2.0 ) );
+ f = createBenchmark( ord, N );
+ bench( format( '%s::square_matrix:order=%s,size=%d', pkg, ord, N*N ), f );
+ }
+ }
+}
+
+main();
diff --git a/lib/node_modules/@stdlib/lapack/base/dgeqr2/benchmark/benchmark.ndarray.js b/lib/node_modules/@stdlib/lapack/base/dgeqr2/benchmark/benchmark.ndarray.js
new file mode 100644
index 000000000000..1dc26bb40a4b
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dgeqr2/benchmark/benchmark.ndarray.js
@@ -0,0 +1,132 @@
+/**
+* @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 discreteUniform = require( '@stdlib/random/array/discrete-uniform' );
+var isColumnMajor = require( '@stdlib/ndarray/base/assert/is-column-major-string' );
+var Float64Array = require( '@stdlib/array/float64' );
+var floor = require( '@stdlib/math/base/special/floor' );
+var pow = require( '@stdlib/math/base/special/pow' );
+var format = require( '@stdlib/string/format' );
+var pkg = require( './../package.json' ).name;
+var dgeqr2 = require( './../lib/ndarray.js' );
+
+
+// VARIABLES //
+
+var LAYOUTS = [
+ 'row-major',
+ 'column-major'
+];
+var opts = {
+ 'dtype': 'float64'
+};
+
+
+// FUNCTIONS //
+
+/**
+* Creates a benchmark function.
+*
+* @private
+* @param {string} order - storage layout
+* @param {PositiveInteger} N - matrix dimension
+* @returns {Function} benchmark function
+*/
+function createBenchmark( order, N ) {
+ var work;
+ var TAU;
+ var sa1;
+ var sa2;
+ var A;
+
+ work = new Float64Array( N );
+ TAU = new Float64Array( N );
+ A = discreteUniform( N*N, 1.0, 10.0, opts );
+ if ( isColumnMajor( order ) ) {
+ sa1 = 1;
+ sa2 = N;
+ } else { // order === 'row-major'
+ sa1 = N;
+ sa2 = 1;
+ }
+
+ return benchmark;
+
+ /**
+ * Benchmark function.
+ *
+ * @private
+ * @param {Benchmark} b - benchmark instance
+ */
+ function benchmark( b ) {
+ var i;
+ var z;
+
+ b.tic();
+ for ( i = 0; i < b.iterations; i++ ) {
+ z = dgeqr2( N, N, A, sa1, sa2, 0, TAU, 1, 0, work, 1, 0 );
+ if ( z !== 0 ) {
+ b.fail( 'should return 0' );
+ }
+ }
+ b.toc();
+
+ if ( z !== 0 ) {
+ b.fail( 'should return 0' );
+ }
+ b.pass( 'benchmark finished' );
+ b.end();
+ }
+}
+
+
+// MAIN //
+
+/**
+* Main execution sequence.
+*
+* @private
+*/
+function main() {
+ var min;
+ var max;
+ var ord;
+ var N;
+ var f;
+ var i;
+ var k;
+
+ min = 1; // 10^min
+ max = 6; // 10^max
+
+ for ( k = 0; k < LAYOUTS.length; k++ ) {
+ ord = LAYOUTS[ k ];
+ for ( i = min; i <= max; i++ ) {
+ N = floor( pow( pow( 10, i ), 1.0/2.0 ) );
+ f = createBenchmark( ord, N );
+ bench( format( '%s::square_matrix:ndarray:order=%s,size=%d', pkg, ord, N*N ), f );
+ }
+ }
+}
+
+main();
diff --git a/lib/node_modules/@stdlib/lapack/base/dgeqr2/docs/repl.txt b/lib/node_modules/@stdlib/lapack/base/dgeqr2/docs/repl.txt
new file mode 100644
index 000000000000..20d43e423aad
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dgeqr2/docs/repl.txt
@@ -0,0 +1,182 @@
+
+{{alias}}( order, M, N, A, LDA, TAU, WORK )
+ Computes an computes a QR factorization of a real `M-by-N` matrix `A`.
+
+ On exit, the elements on and above the diagonal of A contain the min(M,N)
+ by `N` upper trapezoidal matrix R (R is upper triangular if M >= N) matrix
+ `R`. The elements below the diagonal, with the array `TAU`, represent the
+ orthogonal matrix `Q` as a product of elementary reflectors.
+
+ Parameters
+ ----------
+ order: string
+ Storage layout order.
+
+ M: NonNegativeInteger
+ Number of rows in `A`.
+
+ N: NonNegativeInteger
+ Number of columns in `A`.
+
+ A: Float64Array
+ Input/output matrix.
+
+ LDA: PositiveInteger
+ Stride of the first dimension of `A` (i.e., the leading dimension of
+ the matrix `A`).
+
+ TAU: Float64Array
+ Output array of scalar factors. Should have `min(M,N)` indexed
+ elements.
+
+ WORK: Float64Array
+ Workspace array. Should have at least `M` indexed elements.
+
+ Returns
+ -------
+ status: integer
+ Status code. The status code indicates the following conditions:
+
+ - if equal to zero, then the computation was successful.
+ - if less than zero, then the `-i`th argument had an illegal value.
+
+ Examples
+ --------
+ > var Float64Array = require( '@stdlib/array/float64' );
+ > var dgeqr2 = require( '@stdlib/lapack/base/dgeqr2' );
+
+ > var A = new Float64Array( [ 1, 5, 9, 2, 6, 10, 3, 7, 11, 4, 8, 12 ] );
+ > var TAU = new Float64Array( 3 );
+ > var work = new Float64Array( 4 );
+ > dgeqr2( 'column-major', 3, 4, A, 3, TAU, work )
+ 0
+ > A[ 0 ]
+ ~-10.344
+ > A[ 1 ]
+ ~0.441
+ > A[ 2 ]
+ ~0.793
+ > A[ 3 ]
+ ~-11.794
+ > A[ 4 ]
+ ~0.947
+ > A[ 5 ]
+ ~0.919
+ > A[ 6 ]
+ ~-13.244
+ > A[ 7 ]
+ ~1.894
+ > A[ 8 ]
+ ~0.0
+ > A[ 9 ]
+ ~-14.694
+ > A[ 10 ]
+ ~2.842
+ > A[ 11 ]
+ ~0.0
+ > TAU
+ [ ~1.097, ~1.084, 0.0 ]
+ > work
+ [ ~-1.894, ~-2.842, ~17.046, 0.0 ]
+
+
+{{alias}}.ndarray( M, N, A, sA1, sA2, oA, TAU, sT, oT, WORK, sWORK, oWORK )
+ Computes an computes a QR factorization of a real `M-by-N` matrix `A`
+ using alternative indexing semantics.
+
+ On exit, the elements on and above the diagonal of A contain the min(M,N)
+ by `N` upper trapezoidal matrix R (R is upper triangular if M >= N) matrix
+ `R`. The elements below the diagonal, with the array `TAU`, represent the
+ orthogonal matrix `Q` as a product of elementary reflectors.
+
+ Parameters
+ ----------
+ M: NonNegativeInteger
+ Number of rows in `A`.
+
+ N: NonNegativeInteger
+ Number of columns in `A`.
+
+ A: Float64Array
+ Input/output matrix. On entry, the matrix `A`. On exit, the elements on
+ and below the diagonal of `A` contain the lower trapezoidal matrix `L`,
+ and the elements above the diagonal contain information used to
+ represent `Q`.
+
+ sA1: integer
+ Stride length for the first dimension of `A`.
+
+ sA2: integer
+ Stride length for the second dimension of `A`.
+
+ oA: NonNegativeInteger
+ Starting index for `A`.
+
+ TAU: Float64Array
+ Output array of scalar factors. Should have `min(M,N)` indexed
+ elements.
+
+ sT: integer
+ Stride length for `TAU`.
+
+ oT: NonNegativeInteger
+ Starting index for `TAU`.
+
+ WORK: Float64Array
+ Workspace array. Should have at least `M` indexed elements.
+
+ sWORK: integer
+ Stride length for `WORK`.
+
+ oWORK: NonNegativeInteger
+ Starting index for `WORK`.
+
+ Returns
+ -------
+ status: integer
+ Status code. The status code indicates the following conditions:
+
+ - if equal to zero, then the computation was successful.
+ - if less than zero, then the `-i`th argument had an illegal value.
+
+ Examples
+ --------
+ > var Float64Array = require( '@stdlib/array/float64' );
+ > var dgeqr2 = require( '@stdlib/lapack/base/dgeqr2' );
+
+ > var A = new Float64Array( [ 1, 5, 9, 2, 6, 10, 3, 7, 11, 4, 8, 12 ] );
+ > var TAU = new Float64Array( 3 );
+ > var work = new Float64Array( 4 );
+ > dgeqr2.ndarray( 3, 4, A, 1, 3, 0, TAU, 1, 0, work, 1, 0 )
+ 0
+ > A[ 0 ]
+ ~-10.344
+ > A[ 1 ]
+ ~0.441
+ > A[ 2 ]
+ ~0.793
+ > A[ 3 ]
+ ~-11.794
+ > A[ 4 ]
+ ~0.947
+ > A[ 5 ]
+ ~0.919
+ > A[ 6 ]
+ ~-13.244
+ > A[ 7 ]
+ ~1.894
+ > A[ 8 ]
+ ~0.0
+ > A[ 9 ]
+ ~-14.694
+ > A[ 10 ]
+ ~2.842
+ > A[ 11 ]
+ ~0.0
+ > TAU
+ [ ~1.097, ~1.084, 0.0 ]
+ > work
+ [ ~-1.894, ~-2.842, ~17.046, 0.0 ]
+
+ See Also
+ --------
diff --git a/lib/node_modules/@stdlib/lapack/base/dgeqr2/docs/types/index.d.ts b/lib/node_modules/@stdlib/lapack/base/dgeqr2/docs/types/index.d.ts
new file mode 100644
index 000000000000..2a1193ebd0c0
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dgeqr2/docs/types/index.d.ts
@@ -0,0 +1,151 @@
+/*
+* @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
+
+/**
+* Status code.
+*
+* ## Notes
+*
+* The status code indicates the following conditions:
+*
+* - if equal to zero, then the computation was successful.
+* - if less than zero, then the `-i`th argument had an illegal value.
+*/
+type StatusCode = number;
+
+/**
+* Interface describing `dgeqr2`.
+*/
+interface Routine {
+ /**
+ * Computes an computes a QR factorization of a real `M-by-N` matrix `A`.
+ *
+ * ## Notes
+ *
+ * - On exit, the elements on and above the diagonal of A contain the min(M,N) by `N` upper trapezoidal matrix R (R is upper triangular if M >= N) matrix `R`.
+ * - The elements below the diagonal, with the array `TAU`, represent the orthogonal matrix `Q` as a product of elementary reflectors.
+ *
+ * @param order - storage layout
+ * @param M - number of rows in `A`
+ * @param N - number of columns in `A`
+ * @param A - input/output matrix
+ * @param LDA - stride of the first dimension of `A` (i.e., leading dimension of `A`)
+ * @param TAU - output array of scalar factors (length min(M,N))
+ * @param WORK - workspace array (length >= M)
+ * @returns status code
+ *
+ * @example
+ * var Float64Array = require( '@stdlib/array/float64' );
+ *
+ * var A = new Float64Array( [ 1, 5, 9, 2, 6, 10, 3, 7, 11, 4, 8, 12 ] );
+ * var TAU = new Float64Array( 3 );
+ * var work = new Float64Array( 3 );
+ *
+ * dgeqr2( 'column-major', 3, 4, A, 3, TAU, work );
+ * // A => [ ~-10.344, ~0.441, ~0.793, ~-11.794, ~0.947, ~0.919, ~-13.244, ~1.894, ~0.0, ~-14.694, ~2.842, ~0.0 ]
+ * // TAU => [ ~1.097, ~1.084, 0.0 ]
+ * // work => [ ~-1.894, ~-2.842, ~17.046, 0.0 ]
+ */
+ ( order: string, M: number, N: number, A: Float64Array, LDA: number, TAU: Float64Array, WORK: Float64Array ): StatusCode;
+
+ /**
+ * Computes an computes a QR factorization of a real `M-by-N` matrix `A` using alternative indexing semantics.
+ *
+ * ## Notes
+ *
+ * - On exit, the elements on and above the diagonal of A contain the min(M,N) by `N` upper trapezoidal matrix R (R is upper triangular if M >= N) matrix `R`.
+ * - The elements below the diagonal, with the array `TAU`, represent the orthogonal matrix `Q` as a product of elementary reflectors.
+ *
+ * @param M - number of rows in `A`
+ * @param N - number of columns in `A`
+ * @param A - input/output matrix
+ * @param strideA1 - stride of the first dimension of `A`
+ * @param strideA2 - stride of the second dimension of `A`
+ * @param offsetA - starting index for `A`
+ * @param TAU - output array of scalar factors (length min(M,N))
+ * @param strideTAU - stride for `TAU`
+ * @param offsetTAU - starting index for `TAU`
+ * @param WORK - workspace array (length >= M)
+ * @param strideWORK - stride for `WORK`
+ * @param offsetWORK - starting index for `WORK`
+ * @returns status code
+ *
+ * @example
+ * var Float64Array = require( '@stdlib/array/float64' );
+ *
+ * var A = new Float64Array( [ 1, 5, 9, 2, 6, 10, 3, 7, 11, 4, 8, 12 ] );
+ * var TAU = new Float64Array( 3 );
+ * var work = new Float64Array( 3 );
+ *
+ * dgeqr2.ndarray( 3, 4, A, 1, 3, 0, TAU, 1, 0, work, 1, 0 );
+ * // A => [ ~-10.344, ~0.441, ~0.793, ~-11.794, ~0.947, ~0.919, ~-13.244, ~1.894, ~0.0, ~-14.694, ~2.842, ~0.0 ]
+ * // TAU => [ ~1.097, ~1.084, 0.0 ]
+ * // work => [ ~-1.894, ~-2.842, ~17.046, 0.0 ]
+ */
+ ndarray( M: number, N: number, A: Float64Array, strideA1: number, strideA2: number, offsetA: number, TAU: Float64Array, strideTAU: number, offsetTAU: number, WORK: Float64Array, strideWORK: number, offsetWORK: number ): StatusCode;
+}
+
+/**
+* Computes an computes a QR factorization of a real `M-by-N` matrix `A`.
+*
+* ## Notes
+*
+* - On exit, the elements on and above the diagonal of A contain the min(M,N) by `N` upper trapezoidal matrix R (R is upper triangular if M >= N) matrix `R`.
+* - The elements below the diagonal, with the array `TAU`, represent the orthogonal matrix `Q` as a product of elementary reflectors.
+*
+* @param order - storage layout
+* @param M - number of rows in `A`
+* @param N - number of columns in `A`
+* @param A - input/output matrix
+* @param LDA - stride of the first dimension of `A` (i.e., leading dimension of `A`)
+* @param TAU - output array of scalar factors (length min(M,N))
+* @param WORK - workspace array (length >= M)
+* @returns status code
+*
+* @example
+* var Float64Array = require( '@stdlib/array/float64' );
+*
+* var A = new Float64Array( [ 1, 5, 9, 2, 6, 10, 3, 7, 11, 4, 8, 12 ] );
+* var TAU = new Float64Array( 3 );
+* var work = new Float64Array( 4 );
+*
+* dgeqr2( 'column-major', 3, 4, A, 3, TAU, work );
+* // A => [ ~-10.344, ~0.441, ~0.793, ~-11.794, ~0.947, ~0.919, ~-13.244, ~1.894, ~0.0, ~-14.694, ~2.842, ~0.0 ]
+* // TAU => [ ~1.097, ~1.084, 0.0 ]
+* // work => [ ~-1.894, ~-2.842, ~17.046, 0.0 ]
+*
+* @example
+* var Float64Array = require( '@stdlib/array/float64' );
+*
+* var A = new Float64Array( [ 1, 5, 9, 2, 6, 10, 3, 7, 11, 4, 8, 12 ] );
+* var TAU = new Float64Array( 3 );
+* var work = new Float64Array( 4 );
+*
+* dgeqr2.ndarray( 3, 4, A, 1, 3, 0, TAU, 1, 0, work, 1, 0 );
+* // A => [ ~-10.344, ~0.441, ~0.793, ~-11.794, ~0.947, ~0.919, ~-13.244, ~1.894, ~0.0, ~-14.694, ~2.842, ~0.0 ]
+* // TAU => [ ~1.097, ~1.084, 0.0 ]
+* // work => [ ~-1.894, ~-2.842, ~17.046, 0.0 ]
+*/
+declare var dgeqr2: Routine;
+
+
+// EXPORTS //
+
+export = dgeqr2;
diff --git a/lib/node_modules/@stdlib/lapack/base/dgeqr2/docs/types/test.ts b/lib/node_modules/@stdlib/lapack/base/dgeqr2/docs/types/test.ts
new file mode 100644
index 000000000000..c3cfa864fd5f
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dgeqr2/docs/types/test.ts
@@ -0,0 +1,382 @@
+/*
+* @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 dgeqr2 = require( './index' );
+
+// TESTS //
+
+// The function returns a number...
+{
+ var A = new Float64Array( 12 );
+ var TAU = new Float64Array( 3 );
+ var WORK = new Float64Array( 4 );
+
+ dgeqr2( 'column-major', 3, 4, A, 3, TAU, WORK ); // $ExpectType number
+}
+
+// The compiler throws an error if the function is provided a first argument which is not a string...
+{
+ var A = new Float64Array( 12 );
+ var TAU = new Float64Array( 3 );
+ var WORK = new Float64Array( 4 );
+
+ dgeqr2( 5, 3, 4, A, 3, TAU, WORK ); // $ExpectError
+ dgeqr2( true, 3, 4, A, 3, TAU, WORK ); // $ExpectError
+ dgeqr2( false, 3, 4, A, 3, TAU, WORK ); // $ExpectError
+ dgeqr2( null, 3, 4, A, 3, TAU, WORK ); // $ExpectError
+ dgeqr2( undefined, 3, 4, A, 3, TAU, WORK ); // $ExpectError
+ dgeqr2( [], 3, 4, A, 3, TAU, WORK ); // $ExpectError
+ dgeqr2( {}, 3, 4, A, 3, TAU, WORK ); // $ExpectError
+ dgeqr2( ( x: number ): number => x, 3, 4, A, 3, TAU, WORK ); // $ExpectError
+}
+
+// The compiler throws an error if the function is provided a second argument which is not a number...
+{
+ var A = new Float64Array( 12 );
+ var TAU = new Float64Array( 3 );
+ var WORK = new Float64Array( 4 );
+
+ dgeqr2( 'column-major', '5', 4, A, 3, TAU, WORK ); // $ExpectError
+ dgeqr2( 'column-major', true, 4, A, 3, TAU, WORK ); // $ExpectError
+ dgeqr2( 'column-major', false, 4, A, 3, TAU, WORK ); // $ExpectError
+ dgeqr2( 'column-major', null, 4, A, 3, TAU, WORK ); // $ExpectError
+ dgeqr2( 'column-major', undefined, 4, A, 3, TAU, WORK ); // $ExpectError
+ dgeqr2( 'column-major', [], 4, A, 3, TAU, WORK ); // $ExpectError
+ dgeqr2( 'column-major', {}, 4, A, 3, TAU, WORK ); // $ExpectError
+ dgeqr2( 'column-major', ( x: number ): number => x, 4, A, 3, TAU, WORK ); // $ExpectError
+}
+
+// The compiler throws an error if the function is provided a third argument which is not a number...
+{
+ var A = new Float64Array( 12 );
+ var TAU = new Float64Array( 3 );
+ var WORK = new Float64Array( 4 );
+
+ dgeqr2( 'column-major', 3, '5', A, 3, TAU, WORK ); // $ExpectError
+ dgeqr2( 'column-major', 3, true, A, 3, TAU, WORK ); // $ExpectError
+ dgeqr2( 'column-major', 3, false, A, 3, TAU, WORK ); // $ExpectError
+ dgeqr2( 'column-major', 3, null, A, 3, TAU, WORK ); // $ExpectError
+ dgeqr2( 'column-major', 3, undefined, A, 3, TAU, WORK ); // $ExpectError
+ dgeqr2( 'column-major', 3, [], A, 3, TAU, WORK ); // $ExpectError
+ dgeqr2( 'column-major', 3, {}, A, 3, TAU, WORK ); // $ExpectError
+ dgeqr2( 'column-major', 3, ( x: number ): number => x, A, 3, TAU, WORK ); // $ExpectError
+}
+
+// The compiler throws an error if the function is provided a fourth argument which is not a Float64Array...
+{
+ var TAU = new Float64Array( 3 );
+ var WORK = new Float64Array( 4 );
+
+ dgeqr2( 'column-major', 3, 4, '5', 3, TAU, WORK ); // $ExpectError
+ dgeqr2( 'column-major', 3, 4, 5, 3, TAU, WORK ); // $ExpectError
+ dgeqr2( 'column-major', 3, 4, true, 3, TAU, WORK ); // $ExpectError
+ dgeqr2( 'column-major', 3, 4, false, 3, TAU, WORK ); // $ExpectError
+ dgeqr2( 'column-major', 3, 4, null, 3, TAU, WORK ); // $ExpectError
+ dgeqr2( 'column-major', 3, 4, undefined, 3, TAU, WORK ); // $ExpectError
+ dgeqr2( 'column-major', 3, 4, [], 3, TAU, WORK ); // $ExpectError
+ dgeqr2( 'column-major', 3, 4, {}, 3, TAU, WORK ); // $ExpectError
+ dgeqr2( 'column-major', 3, 4, ( x: number ): number => x, 3, TAU, WORK ); // $ExpectError
+}
+
+// The compiler throws an error if the function is provided a fifth argument which is not a number...
+{
+ var A = new Float64Array( 12 );
+ var TAU = new Float64Array( 3 );
+ var WORK = new Float64Array( 4 );
+
+ dgeqr2( 'column-major', 3, 4, A, '5', TAU, WORK ); // $ExpectError
+ dgeqr2( 'column-major', 3, 4, A, true, TAU, WORK ); // $ExpectError
+ dgeqr2( 'column-major', 3, 4, A, false, TAU, WORK ); // $ExpectError
+ dgeqr2( 'column-major', 3, 4, A, null, TAU, WORK ); // $ExpectError
+ dgeqr2( 'column-major', 3, 4, A, undefined, TAU, WORK ); // $ExpectError
+ dgeqr2( 'column-major', 3, 4, A, [], TAU, WORK ); // $ExpectError
+ dgeqr2( 'column-major', 3, 4, A, {}, TAU, WORK ); // $ExpectError
+ dgeqr2( 'column-major', 3, 4, A, ( x: number ): number => x, TAU, WORK ); // $ExpectError
+}
+
+// The compiler throws an error if the function is provided a sixth argument which is not a Float64Array...
+{
+ var A = new Float64Array( 12 );
+ var WORK = new Float64Array( 4 );
+
+ dgeqr2( 'column-major', 3, 4, A, 3, '5', WORK ); // $ExpectError
+ dgeqr2( 'column-major', 3, 4, A, 3, 5, WORK ); // $ExpectError
+ dgeqr2( 'column-major', 3, 4, A, 3, true, WORK ); // $ExpectError
+ dgeqr2( 'column-major', 3, 4, A, 3, false, WORK ); // $ExpectError
+ dgeqr2( 'column-major', 3, 4, A, 3, null, WORK ); // $ExpectError
+ dgeqr2( 'column-major', 3, 4, A, 3, undefined, WORK ); // $ExpectError
+ dgeqr2( 'column-major', 3, 4, A, 3, [], WORK ); // $ExpectError
+ dgeqr2( 'column-major', 3, 4, A, 3, {}, WORK ); // $ExpectError
+ dgeqr2( 'column-major', 3, 4, A, 3, ( x: number ): number => x, WORK ); // $ExpectError
+}
+
+// The compiler throws an error if the function is provided a seventh argument which is not a Float64Array...
+{
+ var A = new Float64Array( 12 );
+ var TAU = new Float64Array( 3 );
+
+ dgeqr2( 'column-major', 3, 4, A, 3, TAU, '5' ); // $ExpectError
+ dgeqr2( 'column-major', 3, 4, A, 3, TAU, 5 ); // $ExpectError
+ dgeqr2( 'column-major', 3, 4, A, 3, TAU, true ); // $ExpectError
+ dgeqr2( 'column-major', 3, 4, A, 3, TAU, false ); // $ExpectError
+ dgeqr2( 'column-major', 3, 4, A, 3, TAU, null ); // $ExpectError
+ dgeqr2( 'column-major', 3, 4, A, 3, TAU, undefined ); // $ExpectError
+ dgeqr2( 'column-major', 3, 4, A, 3, TAU, [] ); // $ExpectError
+ dgeqr2( 'column-major', 3, 4, A, 3, TAU, {} ); // $ExpectError
+ dgeqr2( 'column-major', 3, 4, A, 3, TAU, ( x: number ): number => x ); // $ExpectError
+}
+
+// The compiler throws an error if the function is provided unsupported number of arguments...
+{
+ var A = new Float64Array( 12 );
+ var TAU = new Float64Array( 3 );
+ var WORK = new Float64Array( 4 );
+
+ dgeqr2(); // $ExpectError
+ dgeqr2( 'column-major' ); // $ExpectError
+ dgeqr2( 'column-major', 3 ); // $ExpectError
+ dgeqr2( 'column-major', 3, 4 ); // $ExpectError
+ dgeqr2( 'column-major', 3, 4, A ); // $ExpectError
+ dgeqr2( 'column-major', 3, 4, A, 3 ); // $ExpectError
+ dgeqr2( 'column-major', 3, 4, A, 3, TAU ); // $ExpectError
+ dgeqr2( 'column-major', 3, 4, A, 3, TAU, WORK, 10 ); // $ExpectError
+}
+
+// Attached to main export is an `ndarray` method which returns a number...
+{
+ var A = new Float64Array( 12 );
+ var TAU = new Float64Array( 3 );
+ var WORK = new Float64Array( 4 );
+
+ dgeqr2.ndarray( 3, 4, A, 1, 3, 0, TAU, 1, 0, WORK, 1, 0 ); // $ExpectType number
+}
+
+// The compiler throws an error if the function is provided a first argument which is not a number...
+{
+ var A = new Float64Array( 12 );
+ var TAU = new Float64Array( 3 );
+ var WORK = new Float64Array( 4 );
+
+ dgeqr2.ndarray( '5', 4, A, 1, 3, 0, TAU, 1, 0, WORK, 1, 0 ); // $ExpectError
+ dgeqr2.ndarray( true, 4, A, 1, 3, 0, TAU, 1, 0, WORK, 1, 0 ); // $ExpectError
+ dgeqr2.ndarray( false, 4, A, 1, 3, 0, TAU, 1, 0, WORK, 1, 0 ); // $ExpectError
+ dgeqr2.ndarray( null, 4, A, 1, 3, 0, TAU, 1, 0, WORK, 1, 0 ); // $ExpectError
+ dgeqr2.ndarray( undefined, 4, A, 1, 3, 0, TAU, 1, 0, WORK, 1, 0 ); // $ExpectError
+ dgeqr2.ndarray( [], 4, A, 1, 3, 0, TAU, 1, 0, WORK, 1, 0 ); // $ExpectError
+ dgeqr2.ndarray( {}, 4, A, 1, 3, 0, TAU, 1, 0, WORK, 1, 0 ); // $ExpectError
+ dgeqr2.ndarray( ( x: number ): number => x, 4, A, 1, 3, 0, TAU, 1, 0, WORK, 1, 0 ); // $ExpectError
+}
+
+// The compiler throws an error if the function is provided a second argument which is not a number...
+{
+ var A = new Float64Array( 12 );
+ var TAU = new Float64Array( 3 );
+ var WORK = new Float64Array( 4 );
+
+ dgeqr2.ndarray( 3, '5', A, 1, 3, 0, TAU, 1, 0, WORK, 1, 0 ); // $ExpectError
+ dgeqr2.ndarray( 3, true, A, 1, 3, 0, TAU, 1, 0, WORK, 1, 0 ); // $ExpectError
+ dgeqr2.ndarray( 3, false, A, 1, 3, 0, TAU, 1, 0, WORK, 1, 0 ); // $ExpectError
+ dgeqr2.ndarray( 3, null, A, 1, 3, 0, TAU, 1, 0, WORK, 1, 0 ); // $ExpectError
+ dgeqr2.ndarray( 3, undefined, A, 1, 3, 0, TAU, 1, 0, WORK, 1, 0 ); // $ExpectError
+ dgeqr2.ndarray( 3, [], A, 1, 3, 0, TAU, 1, 0, WORK, 1, 0 ); // $ExpectError
+ dgeqr2.ndarray( 3, {}, A, 1, 3, 0, TAU, 1, 0, WORK, 1, 0 ); // $ExpectError
+ dgeqr2.ndarray( 3, ( x: number ): number => x, A, 1, 3, 0, TAU, 1, 0, WORK, 1, 0 ); // $ExpectError
+}
+
+// The compiler throws an error if the function is provided a third argument which is not a Float64Array...
+{
+ var TAU = new Float64Array( 3 );
+ var WORK = new Float64Array( 4 );
+
+ dgeqr2.ndarray( 3, 4, '5', 1, 3, 0, TAU, 1, 0, WORK, 1, 0 ); // $ExpectError
+ dgeqr2.ndarray( 3, 4, 5, 1, 3, 0, TAU, 1, 0, WORK, 1, 0 ); // $ExpectError
+ dgeqr2.ndarray( 3, 4, true, 1, 3, 0, TAU, 1, 0, WORK, 1, 0 ); // $ExpectError
+ dgeqr2.ndarray( 3, 4, false, 1, 3, 0, TAU, 1, 0, WORK, 1, 0 ); // $ExpectError
+ dgeqr2.ndarray( 3, 4, null, 1, 3, 0, TAU, 1, 0, WORK, 1, 0 ); // $ExpectError
+ dgeqr2.ndarray( 3, 4, undefined, 1, 3, 0, TAU, 1, 0, WORK, 1, 0 ); // $ExpectError
+ dgeqr2.ndarray( 3, 4, [], 1, 3, 0, TAU, 1, 0, WORK, 1, 0 ); // $ExpectError
+ dgeqr2.ndarray( 3, 4, {}, 1, 3, 0, TAU, 1, 0, WORK, 1, 0 ); // $ExpectError
+ dgeqr2.ndarray( 3, 4, ( x: number ): number => x, 1, 3, 0, TAU, 1, 0, WORK, 1, 0 ); // $ExpectError
+}
+
+// The compiler throws an error if the function is provided a fourth argument which is not a number...
+{
+ var A = new Float64Array( 12 );
+ var TAU = new Float64Array( 3 );
+ var WORK = new Float64Array( 4 );
+
+ dgeqr2.ndarray( 3, 4, A, '5', 3, 0, TAU, 1, 0, WORK, 1, 0 ); // $ExpectError
+ dgeqr2.ndarray( 3, 4, A, true, 3, 0, TAU, 1, 0, WORK, 1, 0 ); // $ExpectError
+ dgeqr2.ndarray( 3, 4, A, false, 3, 0, TAU, 1, 0, WORK, 1, 0 ); // $ExpectError
+ dgeqr2.ndarray( 3, 4, A, null, 3, 0, TAU, 1, 0, WORK, 1, 0 ); // $ExpectError
+ dgeqr2.ndarray( 3, 4, A, undefined, 3, 0, TAU, 1, 0, WORK, 1, 0 ); // $ExpectError
+ dgeqr2.ndarray( 3, 4, A, [], 3, 0, TAU, 1, 0, WORK, 1, 0 ); // $ExpectError
+ dgeqr2.ndarray( 3, 4, A, {}, 3, 0, TAU, 1, 0, WORK, 1, 0 ); // $ExpectError
+ dgeqr2.ndarray( 3, 4, A, ( x: number ): number => x, 3, 0, TAU, 1, 0, WORK, 1, 0 ); // $ExpectError
+}
+
+// The compiler throws an error if the function is provided a fifth argument which is not a number...
+{
+ var A = new Float64Array( 12 );
+ var TAU = new Float64Array( 3 );
+ var WORK = new Float64Array( 4 );
+
+ dgeqr2.ndarray( 3, 4, A, 1, '5', 0, TAU, 1, 0, WORK, 1, 0 ); // $ExpectError
+ dgeqr2.ndarray( 3, 4, A, 1, true, 0, TAU, 1, 0, WORK, 1, 0 ); // $ExpectError
+ dgeqr2.ndarray( 3, 4, A, 1, false, 0, TAU, 1, 0, WORK, 1, 0 ); // $ExpectError
+ dgeqr2.ndarray( 3, 4, A, 1, null, 0, TAU, 1, 0, WORK, 1, 0 ); // $ExpectError
+ dgeqr2.ndarray( 3, 4, A, 1, undefined, 0, TAU, 1, 0, WORK, 1, 0 ); // $ExpectError
+ dgeqr2.ndarray( 3, 4, A, 1, [], 0, TAU, 1, 0, WORK, 1, 0 ); // $ExpectError
+ dgeqr2.ndarray( 3, 4, A, 1, {}, 0, TAU, 1, 0, WORK, 1, 0 ); // $ExpectError
+ dgeqr2.ndarray( 3, 4, A, 1, ( x: number ): number => x, 0, TAU, 1, 0, WORK, 1, 0 ); // $ExpectError
+}
+
+// The compiler throws an error if the function is provided a sixth argument which is not a number...
+{
+ var A = new Float64Array( 12 );
+ var TAU = new Float64Array( 3 );
+ var WORK = new Float64Array( 4 );
+
+ dgeqr2.ndarray( 3, 4, A, 1, 3, '5', TAU, 1, 0, WORK, 1, 0 ); // $ExpectError
+ dgeqr2.ndarray( 3, 4, A, 1, 3, true, TAU, 1, 0, WORK, 1, 0 ); // $ExpectError
+ dgeqr2.ndarray( 3, 4, A, 1, 3, false, TAU, 1, 0, WORK, 1, 0 ); // $ExpectError
+ dgeqr2.ndarray( 3, 4, A, 1, 3, null, TAU, 1, 0, WORK, 1, 0 ); // $ExpectError
+ dgeqr2.ndarray( 3, 4, A, 1, 3, undefined, TAU, 1, 0, WORK, 1, 0 ); // $ExpectError
+ dgeqr2.ndarray( 3, 4, A, 1, 3, [], TAU, 1, 0, WORK, 1, 0 ); // $ExpectError
+ dgeqr2.ndarray( 3, 4, A, 1, 3, {}, TAU, 1, 0, WORK, 1, 0 ); // $ExpectError
+ dgeqr2.ndarray( 3, 4, A, 1, 3, ( x: number ): number => x, TAU, 1, 0, WORK, 1, 0 ); // $ExpectError
+}
+
+// The compiler throws an error if the function is provided a seventh argument which is not a Float64Array...
+{
+ var A = new Float64Array( 12 );
+ var WORK = new Float64Array( 4 );
+
+ dgeqr2.ndarray( 3, 4, A, 1, 3, 0, '5', 1, 0, WORK, 1, 0 ); // $ExpectError
+ dgeqr2.ndarray( 3, 4, A, 1, 3, 0, 5, 1, 0, WORK, 1, 0 ); // $ExpectError
+ dgeqr2.ndarray( 3, 4, A, 1, 3, 0, true, 1, 0, WORK, 1, 0 ); // $ExpectError
+ dgeqr2.ndarray( 3, 4, A, 1, 3, 0, false, 1, 0, WORK, 1, 0 ); // $ExpectError
+ dgeqr2.ndarray( 3, 4, A, 1, 3, 0, null, 1, 0, WORK, 1, 0 ); // $ExpectError
+ dgeqr2.ndarray( 3, 4, A, 1, 3, 0, undefined, 1, 0, WORK, 1, 0 ); // $ExpectError
+ dgeqr2.ndarray( 3, 4, A, 1, 3, 0, [], 1, 0, WORK, 1, 0 ); // $ExpectError
+ dgeqr2.ndarray( 3, 4, A, 1, 3, 0, {}, 1, 0, WORK, 1, 0 ); // $ExpectError
+ dgeqr2.ndarray( 3, 4, A, 1, 3, 0, ( x: number ): number => x, 1, 0, WORK, 1, 0 ); // $ExpectError
+}
+
+// The compiler throws an error if the function is provided an eighth argument which is not a number...
+{
+ var A = new Float64Array( 12 );
+ var TAU = new Float64Array( 3 );
+ var WORK = new Float64Array( 4 );
+
+ dgeqr2.ndarray( 3, 4, A, 1, 3, 0, TAU, '5', 0, WORK, 1, 0 ); // $ExpectError
+ dgeqr2.ndarray( 3, 4, A, 1, 3, 0, TAU, true, 0, WORK, 1, 0 ); // $ExpectError
+ dgeqr2.ndarray( 3, 4, A, 1, 3, 0, TAU, false, 0, WORK, 1, 0 ); // $ExpectError
+ dgeqr2.ndarray( 3, 4, A, 1, 3, 0, TAU, null, 0, WORK, 1, 0 ); // $ExpectError
+ dgeqr2.ndarray( 3, 4, A, 1, 3, 0, TAU, undefined, 0, WORK, 1, 0 ); // $ExpectError
+ dgeqr2.ndarray( 3, 4, A, 1, 3, 0, TAU, [], 0, WORK, 1, 0 ); // $ExpectError
+ dgeqr2.ndarray( 3, 4, A, 1, 3, 0, TAU, {}, 0, WORK, 1, 0 ); // $ExpectError
+ dgeqr2.ndarray( 3, 4, A, 1, 3, 0, TAU, ( x: number ): number => x, 0, WORK, 1, 0 ); // $ExpectError
+}
+
+// The compiler throws an error if the function is provided a ninth argument which is not a number...
+{
+ var A = new Float64Array( 12 );
+ var TAU = new Float64Array( 3 );
+ var WORK = new Float64Array( 4 );
+
+ dgeqr2.ndarray( 3, 4, A, 1, 3, 0, TAU, 1, '5', WORK, 1, 0 ); // $ExpectError
+ dgeqr2.ndarray( 3, 4, A, 1, 3, 0, TAU, 1, true, WORK, 1, 0 ); // $ExpectError
+ dgeqr2.ndarray( 3, 4, A, 1, 3, 0, TAU, 1, false, WORK, 1, 0 ); // $ExpectError
+ dgeqr2.ndarray( 3, 4, A, 1, 3, 0, TAU, 1, null, WORK, 1, 0 ); // $ExpectError
+ dgeqr2.ndarray( 3, 4, A, 1, 3, 0, TAU, 1, undefined, WORK, 1, 0 ); // $ExpectError
+ dgeqr2.ndarray( 3, 4, A, 1, 3, 0, TAU, 1, [], WORK, 1, 0 ); // $ExpectError
+ dgeqr2.ndarray( 3, 4, A, 1, 3, 0, TAU, 1, {}, WORK, 1, 0 ); // $ExpectError
+ dgeqr2.ndarray( 3, 4, A, 1, 3, 0, TAU, 1, ( x: number ): number => x, WORK, 1, 0 ); // $ExpectError
+}
+
+// The compiler throws an error if the function is provided a tenth argument which is not a Float64Array...
+{
+ var A = new Float64Array( 12 );
+ var TAU = new Float64Array( 3 );
+
+ dgeqr2.ndarray( 3, 4, A, 1, 3, 0, TAU, 1, 0, '5', 1, 0 ); // $ExpectError
+ dgeqr2.ndarray( 3, 4, A, 1, 3, 0, TAU, 1, 0, 5, 1, 0 ); // $ExpectError
+ dgeqr2.ndarray( 3, 4, A, 1, 3, 0, TAU, 1, 0, true, 1, 0 ); // $ExpectError
+ dgeqr2.ndarray( 3, 4, A, 1, 3, 0, TAU, 1, 0, false, 1, 0 ); // $ExpectError
+ dgeqr2.ndarray( 3, 4, A, 1, 3, 0, TAU, 1, 0, null, 1, 0 ); // $ExpectError
+ dgeqr2.ndarray( 3, 4, A, 1, 3, 0, TAU, 1, 0, undefined, 1, 0 ); // $ExpectError
+ dgeqr2.ndarray( 3, 4, A, 1, 3, 0, TAU, 1, 0, [], 1, 0 ); // $ExpectError
+ dgeqr2.ndarray( 3, 4, A, 1, 3, 0, TAU, 1, 0, {}, 1, 0 ); // $ExpectError
+ dgeqr2.ndarray( 3, 4, A, 1, 3, 0, TAU, 1, 0, ( x: number ): number => x, 1, 0 ); // $ExpectError
+}
+
+// The compiler throws an error if the function is provided an eleventh argument which is not a number...
+{
+ var A = new Float64Array( 12 );
+ var TAU = new Float64Array( 3 );
+ var WORK = new Float64Array( 4 );
+
+ dgeqr2.ndarray( 3, 4, A, 1, 3, 0, TAU, 1, 0, WORK, '5', 0 ); // $ExpectError
+ dgeqr2.ndarray( 3, 4, A, 1, 3, 0, TAU, 1, 0, WORK, true, 0 ); // $ExpectError
+ dgeqr2.ndarray( 3, 4, A, 1, 3, 0, TAU, 1, 0, WORK, false, 0 ); // $ExpectError
+ dgeqr2.ndarray( 3, 4, A, 1, 3, 0, TAU, 1, 0, WORK, null, 0 ); // $ExpectError
+ dgeqr2.ndarray( 3, 4, A, 1, 3, 0, TAU, 1, 0, WORK, undefined, 0 ); // $ExpectError
+ dgeqr2.ndarray( 3, 4, A, 1, 3, 0, TAU, 1, 0, WORK, [], 0 ); // $ExpectError
+ dgeqr2.ndarray( 3, 4, A, 1, 3, 0, TAU, 1, 0, WORK, {}, 0 ); // $ExpectError
+ dgeqr2.ndarray( 3, 4, A, 1, 3, 0, TAU, 1, 0, WORK, ( x: number ): number => x, 0 ); // $ExpectError
+}
+
+// The compiler throws an error if the function is provided a twelfth argument which is not a number...
+{
+ var A = new Float64Array( 12 );
+ var TAU = new Float64Array( 3 );
+ var WORK = new Float64Array( 4 );
+
+ dgeqr2.ndarray( 3, 4, A, 1, 3, 0, TAU, 1, 0, WORK, 1, '5' ); // $ExpectError
+ dgeqr2.ndarray( 3, 4, A, 1, 3, 0, TAU, 1, 0, WORK, 1, true ); // $ExpectError
+ dgeqr2.ndarray( 3, 4, A, 1, 3, 0, TAU, 1, 0, WORK, 1, false ); // $ExpectError
+ dgeqr2.ndarray( 3, 4, A, 1, 3, 0, TAU, 1, 0, WORK, 1, null ); // $ExpectError
+ dgeqr2.ndarray( 3, 4, A, 1, 3, 0, TAU, 1, 0, WORK, 1, undefined ); // $ExpectError
+ dgeqr2.ndarray( 3, 4, A, 1, 3, 0, TAU, 1, 0, WORK, 1, [] ); // $ExpectError
+ dgeqr2.ndarray( 3, 4, A, 1, 3, 0, TAU, 1, 0, WORK, 1, {} ); // $ExpectError
+ dgeqr2.ndarray( 3, 4, A, 1, 3, 0, TAU, 1, 0, WORK, 1, ( x: number ): number => x ); // $ExpectError
+}
+
+// The compiler throws an error if the function is provided an unsupported number of arguments...
+{
+ var A = new Float64Array( 12 );
+ var TAU = new Float64Array( 3 );
+ var WORK = new Float64Array( 4 );
+
+ dgeqr2.ndarray(); // $ExpectError
+ dgeqr2.ndarray( 3 ); // $ExpectError
+ dgeqr2.ndarray( 3, 4 ); // $ExpectError
+ dgeqr2.ndarray( 3, 4, A ); // $ExpectError
+ dgeqr2.ndarray( 3, 4, A, 1 ); // $ExpectError
+ dgeqr2.ndarray( 3, 4, A, 1, 3 ); // $ExpectError
+ dgeqr2.ndarray( 3, 4, A, 1, 3, 0 ); // $ExpectError
+ dgeqr2.ndarray( 3, 4, A, 1, 3, 0, TAU ); // $ExpectError
+ dgeqr2.ndarray( 3, 4, A, 1, 3, 0, TAU, 1 ); // $ExpectError
+ dgeqr2.ndarray( 3, 4, A, 1, 3, 0, TAU, 1, 0 ); // $ExpectError
+ dgeqr2.ndarray( 3, 4, A, 1, 3, 0, TAU, 1, 0, WORK ); // $ExpectError
+ dgeqr2.ndarray( 3, 4, A, 1, 3, 0, TAU, 1, 0, WORK, 1 ); // $ExpectError
+ dgeqr2.ndarray( 3, 4, A, 1, 3, 0, TAU, 1, 0, WORK, 1, 0, 10 ); // $ExpectError
+}
diff --git a/lib/node_modules/@stdlib/lapack/base/dgeqr2/examples/index.js b/lib/node_modules/@stdlib/lapack/base/dgeqr2/examples/index.js
new file mode 100644
index 000000000000..c4f04ee131c3
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dgeqr2/examples/index.js
@@ -0,0 +1,59 @@
+/**
+* @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 Float64Array = require( '@stdlib/array/float64' );
+var ndarray2array = require( '@stdlib/ndarray/base/to-array' );
+var shape2strides = require( '@stdlib/ndarray/base/shape2strides' );
+var dgeqr2 = require( './../lib' );
+
+// Specify matrix meta data:
+var shape = [ 3, 4 ];
+var order = 'row-major';
+var strides = shape2strides( shape, order );
+
+// Create a matrix stored in linear memory:
+var A = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ] ); // eslint-disable-line max-len
+
+console.log( 'A (unmodified):', ndarray2array( A, shape, strides, 0, order ) );
+
+// Output arrays:
+var TAU = new Float64Array( 3 );
+var work = new Float64Array( shape[ 1 ] );
+
+// Compute the LQ factorization in-place:
+var info = dgeqr2( order, shape[ 0 ], shape[ 1 ], A, strides[ 0 ], TAU, work );
+
+console.log( 'Status Code:', info );
+console.log( 'A (L + reflectors):', ndarray2array( A, shape, strides, 0, order ) );
+console.log( 'TAU:', TAU );
+console.log( 'WORK:', work );
+
+// Re-initialize arrays for the ndarray interface:
+A = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0 ] );
+TAU = new Float64Array( 3 );
+work = new Float64Array( 3 );
+
+// Compute the LQ factorization again using the ndarray interface:
+info = dgeqr2.ndarray( shape[ 0 ], shape[ 1 ], A, strides[ 0 ], strides[ 1 ], 0, TAU, 1, 0, work, 1, 0 );
+
+console.log( 'Status Code:', info );
+console.log( 'A (L + reflectors):', ndarray2array( A, shape, strides, 0, order ) );
+console.log( 'TAU:', TAU );
+console.log( 'WORK:', work );
diff --git a/lib/node_modules/@stdlib/lapack/base/dgeqr2/lib/base.js b/lib/node_modules/@stdlib/lapack/base/dgeqr2/lib/base.js
new file mode 100644
index 000000000000..6cc46926cd09
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dgeqr2/lib/base.js
@@ -0,0 +1,99 @@
+/**
+* @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 dlarf1f = require( '@stdlib/lapack/base/dlarf1f' ).ndarray;
+var Float64Array = require( '@stdlib/array/float64' );
+var min = require( '@stdlib/math/base/special/min' );
+var dlarfg = require( './dlarfg.js' );
+
+
+// MAIN //
+
+/**
+* Compute a QR factorization of a general rectangular matrix using an unblocked algorithm.
+*
+* ## Notes
+*
+* - On exit, the elements on and above the diagonal of A contain the min(M,N) by `N` upper trapezoidal matrix R (R is upper triangular if M >= N) matrix `R`.
+* - The elements below the diagonal, with the array `TAU`, represent the orthogonal matrix `Q` as a product of elementary reflectors.
+*
+* @private
+* @param {NonNegativeInteger} M - number of rows in `A`
+* @param {NonNegativeInteger} N - number of columns in `A`
+* @param {Float64Array} A - input/output matrix
+* @param {integer} strideA1 - stride of the first dimension of `A`
+* @param {integer} strideA2 - stride of the second dimension of `A`
+* @param {NonNegativeInteger} offsetA - starting index for `A`
+* @param {Float64Array} TAU - output array of scalar factors (length min(M,N))
+* @param {integer} strideTAU - stride for TAU
+* @param {NonNegativeInteger} offsetTAU - starting index for TAU
+* @param {Float64Array} WORK - workspace array (length >= M)
+* @param {integer} strideWORK - stride for WORK
+* @param {NonNegativeInteger} offsetWORK - starting index for WORK
+* @returns {integer} status code
+*
+* @example
+* var Float64Array = require( '@stdlib/array/float64' );
+*
+* var A = new Float64Array( [ 1, 5, 9, 2, 6, 10, 3, 7, 11, 4, 8, 12 ] );
+* var TAU = new Float64Array( 3 );
+* var work = new Float64Array( 4 );
+*
+* dgeqr2( 3, 4, A, 1, 3, 0, TAU, 1, 0, work, 1, 0 );
+* // A => [ ~-10.344, ~0.441, ~0.793, ~-11.794, ~0.947, ~0.919, ~-13.244, ~1.894, ~0.0, ~-14.694, ~2.842, ~0.0 ]
+* // TAU => [ ~1.097, ~1.084, 0.0 ]
+* // work => [ ~-1.894, ~-2.842, ~17.046, 0.0 ]
+*/
+function dgeqr2( M, N, A, strideA1, strideA2, offsetA, TAU, strideTAU, offsetTAU, WORK, strideWORK, offsetWORK ) { // eslint-disable-line stdlib/jsdoc-doctest-decimal-point, max-len, max-params
+ var taui;
+ var aii;
+ var out;
+ var K;
+ var i;
+
+ K = min( M, N );
+ out = new Float64Array( 2 );
+
+ aii = offsetA; // Index of A(i,i)
+ taui = offsetTAU; // Index of TAU(i)
+
+ for ( i = 0; i < K; i++ ) {
+ // Generate elementary reflector H(i) to annihilate A(i+1:m,i)
+ out[ 0 ] = A[ aii ];
+ dlarfg( M - i, A, strideA1, aii + ( min( 1, M - 1 - i ) * strideA1 ), out, 1, 0 );
+ A[ aii ] = out[ 0 ];
+ TAU[ taui ] = out[ 1 ];
+
+ if ( i < N - 1 ) {
+ // Apply H(i) to A(i:m,i+1:n) from the left
+ dlarf1f( 'left', M - i, N - i - 1, A, strideA1, aii, TAU[ taui ], A, strideA1, strideA2, aii + strideA2, WORK, strideWORK, offsetWORK );
+ }
+ aii += strideA1 + strideA2;
+ taui += strideTAU;
+ }
+ return 0;
+}
+
+
+// EXPORTS //
+
+module.exports = dgeqr2;
diff --git a/lib/node_modules/@stdlib/lapack/base/dgeqr2/lib/dgeqr2.js b/lib/node_modules/@stdlib/lapack/base/dgeqr2/lib/dgeqr2.js
new file mode 100644
index 000000000000..d8bc69960f55
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dgeqr2/lib/dgeqr2.js
@@ -0,0 +1,88 @@
+/**
+* @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 isLayout = require( '@stdlib/blas/base/assert/is-layout' );
+var isColumnMajor = require( '@stdlib/ndarray/base/assert/is-column-major-string' );
+var max = require( '@stdlib/math/base/special/max' );
+var format = require( '@stdlib/string/format' );
+var base = require( './base.js' );
+
+
+// MAIN //
+
+/**
+* Computes an computes a QR factorization of a real `M-by-N` matrix `A`.
+*
+* ## Notes
+*
+* - On exit, the elements on and above the diagonal of A contain the min(M,N) by `N` upper trapezoidal matrix R (R is upper triangular if M >= N) matrix `R`.
+* - The elements below the diagonal, with the array `TAU`, represent the orthogonal matrix `Q` as a product of elementary reflectors.
+*
+* @param {string} order - storage layout
+* @param {NonNegativeInteger} M - number of rows in `A`
+* @param {NonNegativeInteger} N - number of columns in `A`
+* @param {Float64Array} A - input/output matrix
+* @param {PositiveInteger} LDA - stride of the first dimension of `A` (a.k.a., leading dimension of the matrix `A`)
+* @param {Float64Array} TAU - output array of scalar factors (length min(M,N))
+* @param {Float64Array} WORK - workspace array (length >= M)
+* @throws {TypeError} first argument must be a valid order
+* @throws {RangeError} fifth argument must be greater than or equal to max(1,`M`)
+* @returns {integer} status code
+*
+* @example
+* var Float64Array = require( '@stdlib/array/float64' );
+*
+* var A = new Float64Array( [ 1, 5, 9, 2, 6, 10, 3, 7, 11, 4, 8, 12 ] );
+* var TAU = new Float64Array( 3 );
+* var work = new Float64Array( 4 );
+*
+* dgeqr2( 'column-major', 3, 4, A, 3, TAU, work );
+* // A => [ ~-10.344, ~0.441, ~0.793, ~-11.794, ~0.947, ~0.919, ~-13.244, ~1.894, ~0.0, ~-14.694, ~2.842, ~0.0 ]
+* // TAU => [ ~1.097, ~1.084, 0.0 ]
+* // work => [ ~-1.894, ~-2.842, ~17.046, 0.0 ]
+*/
+function dgeqr2( order, M, N, A, LDA, TAU, WORK ) { // eslint-disable-line stdlib/jsdoc-doctest-decimal-point
+ var sa1;
+ var sa2;
+
+ if ( !isLayout( order ) ) {
+ throw new TypeError( format( 'invalid argument. First argument must be a valid order. Value: `%s`.', order ) );
+ }
+ if ( isColumnMajor( order ) ) {
+ if ( LDA < max( 1, M ) ) {
+ throw new RangeError( format( 'invalid argument. Fifth argument must be greater than or equal to max(1,`M`). Value: `%d`.', LDA ) );
+ }
+ }
+ if ( isColumnMajor( order ) ) {
+ sa1 = 1;
+ sa2 = LDA;
+ } else { // order === 'row-major'
+ sa1 = LDA;
+ sa2 = 1;
+ }
+ return base( M, N, A, sa1, sa2, 0, TAU, 1, 0, WORK, 1, 0 );
+}
+
+
+// EXPORTS //
+
+module.exports = dgeqr2;
diff --git a/lib/node_modules/@stdlib/lapack/base/dgeqr2/lib/dlarfg.js b/lib/node_modules/@stdlib/lapack/base/dgeqr2/lib/dlarfg.js
new file mode 100644
index 000000000000..04ab125dc7e7
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dgeqr2/lib/dlarfg.js
@@ -0,0 +1,142 @@
+/**
+* @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 dnrm2 = require( '@stdlib/blas/base/dnrm2' ).ndarray;
+var sign = require( '@stdlib/math/base/special/copysign' );
+var dlamch = require( '@stdlib/lapack/base/dlamch' );
+var abs = require( '@stdlib/math/base/special/abs' );
+var dscal = require( '@stdlib/blas/base/dscal' ).ndarray;
+var dlapy2 = require( '@stdlib/lapack/base/dlapy2' );
+
+
+// MAIN //
+
+/**
+* Generates a real elementary reflector `H` of order `N` such that applying `H` to a vector `[alpha; X]` zeros out `X`.
+*
+* `H` is a Householder matrix with the form:
+*
+* ```tex
+* H \cdot \begin{bmatrix} \alpha \\ x \end{bmatrix} = \begin{bmatrix} \beta \\ 0 \end{bmatrix}, \quad \text{and} \quad H^T H = I
+* ```
+*
+* where:
+*
+* - `tau` is a scalar
+* - `X` is a vector of length `N-1`
+* - `beta` is a scalar value
+* - `H` is an orthogonal matrix known as a Householder reflector.
+*
+* The reflector `H` is constructed in the form:
+*
+* ```tex
+* H = I - \tau \begin{bmatrix}1 \\ v \end{bmatrix} \begin{bmatrix}1 & v^T \end{bmatrix}
+* ```
+*
+* where:
+*
+* - `tau` is a real scalar
+* - `V` is a real vector of length `N-1` that defines the Householder vector
+* - The vector `[1; V]` is the Householder direction.
+*
+* The values of `tau` and `V` are chosen so that applying `H` to the vector `[alpha; X]` results in a new vector `[beta; 0]`, i.e., only the first component remains nonzero. The reflector matrix `H` is symmetric and orthogonal, satisfying `H^T = H` and `H^T H = I`
+*
+* ## Special cases
+*
+* - If all elements of `X` are zero, then `tau = 0` and `H = I`, the identity matrix.
+* - Otherwise, `tau` satisfies `1 ≤ tau ≤ 2`, ensuring numerical stability in transformations.
+*
+* ## Notes
+*
+* - `X` should have `N-1` indexed elements
+* - The output array contains the following two elements: `alpha` and `tau`
+*
+* @private
+* @param {NonNegativeInteger} N - number of rows/columns of the elementary reflector `H`
+* @param {Float64Array} X - input vector
+* @param {integer} strideX - stride length for `X`
+* @param {NonNegativeInteger} offsetX - starting index of `X`
+* @param {Float64Array} out - output array
+* @param {integer} strideOut - stride length for `out`
+* @param {NonNegativeInteger} offsetOut - starting index of `out`
+* @returns {void}
+*
+* @example
+* var Float64Array = require( '@stdlib/array/float64' );
+*
+* var X = new Float64Array( [ 2.0, 3.0, 4.0 ] );
+* var out = new Float64Array( [ 4.0, 0.0 ] );
+*
+* dlarfg( 4, X, 1, 0, out, 1, 0 );
+* // X => [ ~0.19, ~0.28, ~0.37 ]
+* // out => [ ~-6.7, ~1.6 ]
+*/
+function dlarfg( N, X, strideX, offsetX, out, strideOut, offsetOut ) {
+ var safemin;
+ var rsafmin;
+ var xnorm;
+ var alpha;
+ var beta;
+ var tau;
+ var knt;
+ var i;
+
+ if ( N <= 1 ) {
+ out[ offsetOut + strideOut ] = 0.0;
+ return;
+ }
+
+ xnorm = dnrm2( N - 1, X, strideX, offsetX );
+ alpha = out[ offsetOut ];
+
+ if ( xnorm === 0.0 ) {
+ out[ strideOut + offsetOut ] = 0.0;
+ } else {
+ beta = -1.0 * sign( dlapy2( alpha, xnorm ), alpha );
+ safemin = dlamch( 'safemin' ) / dlamch( 'epsilon' );
+ knt = 0;
+ if ( abs( beta ) < safemin ) {
+ rsafmin = 1.0 / safemin;
+ while ( abs( beta ) < safemin && knt < 20 ) {
+ knt += 1;
+ dscal( N-1, rsafmin, X, strideX, offsetX );
+ beta *= rsafmin;
+ alpha *= rsafmin;
+ }
+ xnorm = dnrm2( N - 1, X, strideX, offsetX );
+ beta = -1.0 * sign( dlapy2( alpha, xnorm ), alpha );
+ }
+ tau = ( beta - alpha ) / beta;
+ dscal( N-1, 1.0 / ( alpha - beta ), X, strideX, offsetX );
+ for ( i = 0; i < knt; i++ ) {
+ beta *= safemin;
+ }
+
+ out[ offsetOut ] = beta;
+ out[ strideOut + offsetOut ] = tau;
+ }
+}
+
+
+// EXPORTS //
+
+module.exports = dlarfg;
diff --git a/lib/node_modules/@stdlib/lapack/base/dgeqr2/lib/index.js b/lib/node_modules/@stdlib/lapack/base/dgeqr2/lib/index.js
new file mode 100644
index 000000000000..cc7b332256f2
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dgeqr2/lib/index.js
@@ -0,0 +1,63 @@
+/**
+* @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 compute an computes a QR factorization of a real `M-by-N` matrix `A`.
+*
+* @module @stdlib/lapack/base/dgeqr2
+*
+* @example
+* var Float64Array = require( '@stdlib/array/float64' );
+* var dgeqr2 = require( '@stdlib/lapack/base/dgeqr2' );
+*
+* var A = new Float64Array( [ 1, 5, 9, 2, 6, 10, 3, 7, 11, 4, 8, 12 ] );
+* var TAU = new Float64Array( 3 );
+* var work = new Float64Array( 4 );
+*
+* var out = dgeqr2( 'column-major', 3, 4, A, 3, TAU, work );
+* // A => [ ~-10.344, ~0.441, ~0.793, ~-11.794, ~0.947, ~0.919, ~-13.244, ~1.894, ~0.0, ~-14.694, ~2.842, ~0.0 ]
+* // TAU => [ ~1.097, ~1.084, 0.0 ]
+* // work => [ ~-1.894, ~-2.842, ~17.046, 0.0 ]
+*/
+
+// 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 dgeqr2;
+var tmp = tryRequire( join( __dirname, './native.js' ) );
+if ( isError( tmp ) ) {
+ dgeqr2 = main;
+} else {
+ dgeqr2 = tmp;
+}
+
+
+// EXPORTS //
+
+module.exports = dgeqr2;
+
+// exports: { "ndarray": "dgeqr2.ndarray" }
diff --git a/lib/node_modules/@stdlib/lapack/base/dgeqr2/lib/main.js b/lib/node_modules/@stdlib/lapack/base/dgeqr2/lib/main.js
new file mode 100644
index 000000000000..7fcca931b090
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dgeqr2/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 dgeqr2 = require( './dgeqr2.js' );
+var ndarray = require( './ndarray.js' );
+
+
+// MAIN //
+
+setReadOnly( dgeqr2, 'ndarray', ndarray );
+
+
+// EXPORTS //
+
+module.exports = dgeqr2;
diff --git a/lib/node_modules/@stdlib/lapack/base/dgeqr2/lib/ndarray.js b/lib/node_modules/@stdlib/lapack/base/dgeqr2/lib/ndarray.js
new file mode 100644
index 000000000000..5e15ff5f65cd
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dgeqr2/lib/ndarray.js
@@ -0,0 +1,71 @@
+/**
+* @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 base = require( './base.js' );
+
+
+// MAIN //
+
+/**
+* Computes an computes a QR factorization of a real `M-by-N` matrix `A` using alternative indexing semantics.
+*
+* ## Notes
+*
+* - On exit, the elements on and above the diagonal of A contain the min(M,N) by `N` upper trapezoidal matrix R (R is upper triangular if M >= N) matrix `R`.
+* - The elements below the diagonal, with the array `TAU`, represent the orthogonal matrix `Q` as a product of elementary reflectors.
+*
+* @param {NonNegativeInteger} M - number of rows in `A`
+* @param {NonNegativeInteger} N - number of columns in `A`
+* @param {Float64Array} A - input/output matrix
+* @param {integer} strideA1 - stride of the first dimension of `A`
+* @param {integer} strideA2 - stride of the second dimension of `A`
+* @param {NonNegativeInteger} offsetA - starting index for A``
+* @param {Float64Array} TAU - output array of scalar factors (length min(M,N))
+* @param {integer} strideTAU - stride for TAU
+* @param {NonNegativeInteger} offsetTAU - starting index for TAU
+* @param {Float64Array} WORK - workspace array (length >= M)
+* @param {integer} strideWORK - stride for WORK
+* @param {NonNegativeInteger} offsetWORK - starting index for WORK
+* @returns {integer} status code
+*
+* @example
+* var Float64Array = require( '@stdlib/array/float64' );
+*
+* var A = new Float64Array( [ 1, 5, 9, 2, 6, 10, 3, 7, 11, 4, 8, 12 ] );
+* var TAU = new Float64Array( 3 );
+* var work = new Float64Array( 4 );
+*
+* dgeqr2( 3, 4, A, 1, 3, 0, TAU, 1, 0, work, 1, 0 );
+* // A => [ ~-10.344, ~0.441, ~0.793, ~-11.794, ~0.947, ~0.919, ~-13.244, ~1.894, ~0.0, ~-14.694, ~2.842, ~0.0 ]
+* // TAU => [ ~1.097, ~1.084, 0.0 ]
+* // work => [ ~-1.894, ~-2.842, ~17.046, 0.0 ]
+*/
+function dgeqr2( M, N, A, strideA1, strideA2, offsetA, TAU, strideTAU, offsetTAU, WORK, strideWORK, offsetWORK ) { // eslint-disable-line stdlib/jsdoc-doctest-decimal-point, max-params
+ return base( M, N, A, strideA1, strideA2, offsetA, TAU, strideTAU, offsetTAU, WORK, strideWORK, offsetWORK );
+}
+
+
+// EXPORTS //
+
+module.exports = dgeqr2;
diff --git a/lib/node_modules/@stdlib/lapack/base/dgeqr2/package.json b/lib/node_modules/@stdlib/lapack/base/dgeqr2/package.json
new file mode 100644
index 000000000000..fb053454632a
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dgeqr2/package.json
@@ -0,0 +1,69 @@
+{
+ "name": "@stdlib/lapack/base/dgeqr2",
+ "version": "0.0.0",
+ "description": "LAPACK routine to compute an computes a QR factorization of a real `M-by-N` matrix `A`.",
+ "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",
+ "dgelq2",
+ "reflector",
+ "linear",
+ "algebra",
+ "subroutines",
+ "array",
+ "ndarray",
+ "matrix",
+ "float64",
+ "double",
+ "float64array"
+ ]
+}
diff --git a/lib/node_modules/@stdlib/lapack/base/dgeqr2/test/fixtures/col_maj.json b/lib/node_modules/@stdlib/lapack/base/dgeqr2/test/fixtures/col_maj.json
new file mode 100644
index 000000000000..3b4711ab68de
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dgeqr2/test/fixtures/col_maj.json
@@ -0,0 +1,49 @@
+{
+ "order": "column-major",
+
+ "M": 3,
+ "N": 4,
+
+ "A": [ 1, 5, 9, 2, 6, 10, 3, 7, 11, 4, 8, 12 ],
+ "strideA1": 1,
+ "strideA2": 3,
+ "offsetA": 0,
+ "LDA": 3,
+ "A_mat": [
+ [1, 2, 3, 4],
+ [5, 6, 7, 8],
+ [9, 10, 11, 12]
+ ],
+
+ "TAU": [ 0, 0, 0 ],
+ "strideTAU": 1,
+ "offsetTAU": 0,
+
+ "WORK": [ 0, 0, 0, 0 ],
+ "strideWORK": 1,
+ "offsetWORK": 0,
+
+ "A_out": [
+ -10.34408043278860311887,
+ 0.44075851098059426469,
+ 0.79336531976506974306,
+ -11.79418516635709224261,
+ 0.94720444555662541841,
+ 0.91891723513735434903,
+ -13.24428989992558669542,
+ 1.89440889111325461158,
+ 0.0000000000000015543122344752192,
+ -14.69439463349408470094,
+ 2.84161333666988724644,
+ 0.000000000000004440892098500626
+ ],
+ "A_out_mat": [
+ [ -10.3440804327886031, -11.7941851663570922, -13.2442898999255867, -14.6943946334940847 ],
+ [ 0.4407585109805943, 0.9472044455566254, 1.8944088911132546, 2.8416133366698872 ],
+ [ 0.7933653197650697, 0.9189172351373543, 0.0000000000000016, 0.0000000000000044 ]
+ ],
+
+ "TAU_out": [ 1.0966736489045663, 1.0843582549564548, 0.0000000000000000 ],
+
+ "WORK_out": [ -1.8944088911132555, -2.8416133366698908, 17.0464519250255933, 0.0000000000000000 ]
+}
diff --git a/lib/node_modules/@stdlib/lapack/base/dgeqr2/test/fixtures/row_maj.json b/lib/node_modules/@stdlib/lapack/base/dgeqr2/test/fixtures/row_maj.json
new file mode 100644
index 000000000000..622f8d3b64ca
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dgeqr2/test/fixtures/row_maj.json
@@ -0,0 +1,49 @@
+{
+ "order": "row-major",
+
+ "M": 3,
+ "N": 4,
+
+ "A": [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12 ],
+ "strideA1": 4,
+ "strideA2": 1,
+ "offsetA": 0,
+ "LDA": 4,
+ "A_mat": [
+ [1, 2, 3, 4],
+ [5, 6, 7, 8],
+ [9, 10, 11, 12]
+ ],
+
+ "TAU": [ 0, 0, 0 ],
+ "strideTAU": 1,
+ "offsetTAU": 0,
+
+ "WORK": [ 0, 0, 0, 0 ],
+ "strideWORK": 1,
+ "offsetWORK": 0,
+
+ "A_out": [
+ -10.3440804327886031,
+ -11.7941851663570922,
+ -13.2442898999255867,
+ -14.6943946334940847,
+ 0.4407585109805943,
+ 0.9472044455566254,
+ 1.8944088911132546,
+ 2.8416133366698872,
+ 0.7933653197650697,
+ 0.9189172351373543,
+ 0.0000000000000016,
+ 0.0000000000000044
+ ],
+ "A_out_mat": [
+ [ -10.3440804327886031, -11.7941851663570922, -13.2442898999255867, -14.6943946334940847 ],
+ [ 0.4407585109805943, 0.9472044455566254, 1.8944088911132546, 2.8416133366698872 ],
+ [ 0.7933653197650697, 0.9189172351373543, 0.0000000000000016, 0.0000000000000044 ]
+ ],
+
+ "TAU_out": [ 1.0966736489045663, 1.0843582549564548, 0.0000000000000000 ],
+
+ "WORK_out": [ -1.8944088911132555, -2.8416133366698908, 17.0464519250255933, 0.0000000000000000 ]
+}
diff --git a/lib/node_modules/@stdlib/lapack/base/dgeqr2/test/test.dgeqr2.js b/lib/node_modules/@stdlib/lapack/base/dgeqr2/test/test.dgeqr2.js
new file mode 100644
index 000000000000..2e0919c90865
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dgeqr2/test/test.dgeqr2.js
@@ -0,0 +1,166 @@
+/**
+* @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 isAlmostEqual = require( '@stdlib/assert/is-almost-equal-float64array' );
+var dgeqr2 = require( './../lib/dgeqr2.js' );
+
+
+// FIXTURES //
+
+var COL_MAJ = require( './fixtures/col_maj.json' );
+var ROW_MAJ = require( './fixtures/row_maj.json' );
+
+
+// TESTS //
+
+tape( 'main export is a function', function test( t ) {
+ t.ok( true, __filename );
+ t.strictEqual( typeof dgeqr2, 'function', 'main export is a function' );
+ t.end();
+});
+
+tape( 'the function has an arity of 7', function test( t ) {
+ t.strictEqual( dgeqr2.length, 7, 'returns expected value' );
+ t.end();
+});
+
+tape( 'the function throws an error if provided a first argument which is not a valid order', function test( t ) {
+ var values;
+ var work;
+ var TAU;
+ var A;
+ var i;
+
+ A = new Float64Array( [ 1, 5, 9, 2, 6, 10, 3, 7, 11, 4, 8, 12 ] );
+ TAU = new Float64Array( 3 );
+ work = new Float64Array( 3 );
+
+ values = [
+ 'foo',
+ 'bar',
+ 'beep',
+ 'boop',
+ -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() {
+ dgeqr2( value, 3, 4, A, 3, TAU, work );
+ };
+ }
+});
+
+tape( 'the function throws an error if provided a fifth argument which is not a valid LDA value', function test( t ) {
+ var values;
+ var work;
+ var TAU;
+ var A;
+ var i;
+
+ A = new Float64Array( [ 1, 5, 9, 2, 6, 10, 3, 7, 11, 4, 8, 12 ] );
+ TAU = new Float64Array( 3 );
+ work = new Float64Array( 3 );
+
+ values = [
+ 2,
+ 1,
+ 0
+ ];
+
+ 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() {
+ dgeqr2( 'column-major', 3, 4, A, value, TAU, work );
+ };
+ }
+});
+
+tape( 'the function computes an computes a QR factorization of a real `M-by-N` matrix `A` (col-major)', function test( t ) {
+ var expectedWork;
+ var expectedTau;
+ var expectedA;
+ var data;
+ var work;
+ var tau;
+ var A;
+
+ data = COL_MAJ;
+
+ A = new Float64Array( data.A );
+ tau = new Float64Array( data.TAU );
+ work = new Float64Array( data.WORK );
+
+ expectedA = new Float64Array( data.A_out );
+ expectedTau = new Float64Array( data.TAU_out );
+ expectedWork = new Float64Array( data.WORK_out );
+
+ dgeqr2( data.order, data.M, data.N, A, data.LDA, tau, work );
+ t.strictEqual( isAlmostEqual( A, expectedA, 1 ), true, 'returns expected value' );
+ t.strictEqual( isAlmostEqual( tau, expectedTau, 1 ), true, 'returns expected value' );
+ t.strictEqual( isAlmostEqual( work, expectedWork, 1 ), true, 'returns expected value' );
+ t.end();
+});
+
+tape( 'the function computes an computes a QR factorization of a real `M-by-N` matrix `A` (row-major)', function test( t ) {
+ var expectedWork;
+ var expectedTau;
+ var expectedA;
+ var data;
+ var work;
+ var tau;
+ var A;
+
+ data = ROW_MAJ;
+
+ A = new Float64Array( data.A );
+ tau = new Float64Array( data.TAU );
+ work = new Float64Array( data.WORK );
+
+ expectedA = new Float64Array( data.A_out );
+ expectedTau = new Float64Array( data.TAU_out );
+ expectedWork = new Float64Array( data.WORK_out );
+
+ dgeqr2( data.order, data.M, data.N, A, data.LDA, tau, work );
+ t.strictEqual( isAlmostEqual( A, expectedA, 1 ), true, 'returns expected value' );
+ t.strictEqual( isAlmostEqual( tau, expectedTau, 1 ), true, 'returns expected value' );
+ t.strictEqual( isAlmostEqual( work, expectedWork, 1 ), true, 'returns expected value' );
+ t.end();
+});
diff --git a/lib/node_modules/@stdlib/lapack/base/dgeqr2/test/test.js b/lib/node_modules/@stdlib/lapack/base/dgeqr2/test/test.js
new file mode 100644
index 000000000000..23ed57a6698b
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dgeqr2/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 dgeqr2 = 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 dgeqr2, '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 dgeqr2.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 dgeqr2 = proxyquire( './../lib', {
+ '@stdlib/utils/try-require': tryRequire
+ });
+
+ t.strictEqual( dgeqr2, 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 dgeqr2;
+ var main;
+
+ main = require( './../lib/dgeqr2.js' );
+
+ dgeqr2 = proxyquire( './../lib', {
+ '@stdlib/utils/try-require': tryRequire
+ });
+
+ t.strictEqual( dgeqr2, main, 'returns expected value' );
+ t.end();
+
+ function tryRequire() {
+ return new Error( 'Cannot find module' );
+ }
+});