diff --git a/lib/node_modules/@stdlib/lapack/base/dpbequ/NOTICE b/lib/node_modules/@stdlib/lapack/base/dpbequ/NOTICE
new file mode 100644
index 000000000000..3a19a9b0205e
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dpbequ/NOTICE
@@ -0,0 +1,54 @@
+DPBEQU derives from unchanged Reference-LAPACK SRC/dpbequ.f at commit
+2e5d9c1273435fbd953adb294ed603e4789afaba. The translation adds
+finite-selected-diagonal and conservative disjointness requirements,
+and retains the first tied extremum (an explicit mixed-zero source
+deviation). The full original BSD license follows.
+
+Copyright (c) 1992-2025 The University of Tennessee and The University
+ of Tennessee Research Foundation. All rights
+ reserved.
+Copyright (c) 2000-2025 The University of California Berkeley. All
+ rights reserved.
+Copyright (c) 2006-2025 The University of Colorado Denver. All rights
+ reserved.
+
+$COPYRIGHT$
+
+Additional copyrights may follow
+
+$HEADER$
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+- Redistributions of source code must retain the above copyright
+ notice, this list of conditions and the following disclaimer.
+
+- Redistributions in binary form must reproduce the above copyright
+ notice, this list of conditions and the following disclaimer listed
+ in this license in the documentation and/or other materials
+ provided with the distribution.
+
+- Neither the name of the copyright holders nor the names of its
+ contributors may be used to endorse or promote products derived from
+ this software without specific prior written permission.
+
+The copyright holders provide no reassurances that the source code
+provided does not infringe any patent, copyright, or any other
+intellectual property rights of third parties. The copyright holders
+disclaim any liability to any recipient for claims brought against
+recipient by any third party for infringement of that parties
+intellectual property rights.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/lib/node_modules/@stdlib/lapack/base/dpbequ/README.md b/lib/node_modules/@stdlib/lapack/base/dpbequ/README.md
new file mode 100644
index 000000000000..f45af3216f37
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dpbequ/README.md
@@ -0,0 +1,362 @@
+
+
+# dpbequ
+
+> Compute diagonal scaling factors for a symmetric band matrix.
+
+
+
+Computes `S[i]=1/sqrt(A[i,i])`, `SCOND=sqrt(min(A[i,i]))/sqrt(max(A[i,i]))` and `AMAX=max(A[i,i])` for positive selected diagonals. The input band matrix is unchanged. Scalar `INFO` reports the first nonpositive diagonal; positive diagonals alone do not establish positive definiteness or numerical stability. These interfaces and support restrictions remain proposed package adaptations.
+
+
+
+
+
+
+
+## Usage
+
+```javascript
+var dpbequ = require( '@stdlib/lapack/base/dpbequ' );
+```
+
+#### dpbequ( order, uplo, N, KD, AB, LDAB, S, SCOND, AMAX )
+
+Writes scaling factors and two scalar outputs and returns numeric `INFO`.
+
+```javascript
+var Float64Array = require( '@stdlib/array/float64' );
+
+var AB = new Float64Array( [ 4.0, 16.0, 64.0 ] );
+var S = new Float64Array( 3 );
+var SCOND = new Float64Array( 1 );
+var AMAX = new Float64Array( 1 );
+var info = dpbequ( 'column-major', 'lower', 3, 0, AB, 1, S, SCOND, AMAX );
+// returns 0
+// S => [ 0.5, 0.25, 0.125 ]
+// SCOND => [ 0.25 ]
+// AMAX => [ 64 ]
+```
+
+- **order**: `'row-major'` (`101`) or `'column-major'` (`102`).
+- **uplo**: `'upper'` (`121`) or `'lower'` (`122`); character selectors `'U'` and `'L'` are rejected.
+- **N**, **KD**: nonnegative primitive safe integers, at most `2147483646`.
+- **AB**: read-only intrinsic `Float64Array` containing the full `H`-by-`N` compact band view, `H=KD+1`.
+- **LDAB**: primitive safe integer leading dimension; column-major requires `LDAB>=H`, row-major `LDAB>=max(1,N)`.
+- **S**: output-only intrinsic `Float64Array` with `N` active scaling cells.
+- **SCOND**, **AMAX**: mutable intrinsic `Float64Array` scalar outputs at index zero.
+
+For zero-based `i,j`, upper storage places `A(i,j)` in band row `KD+i-j`, lower in row `i-j`. Band cell `b,j` is `AB[b*LDAB+j]` row-major or `AB[b+j*LDAB]` column-major. Upper diagonals are in row `KD`, lower in row zero. `KD>=N` is supported. Only selected diagonals are numerically read, but the entire conservative `H`-by-`N` view is validated, including unused cells and padding envelopes.
+
+
+
+#### dpbequ.ndarray( uplo, N, KD, AB, strideAB1, strideAB2, offsetAB, S, strideS, offsetS, SCOND, offsetSCOND, AMAX, offsetAMAX )
+
+Uses independent signed element strides and offsets relative to the actual typed-array views.
+
+```javascript
+var Float64Array = require( '@stdlib/array/float64' );
+
+var AB = new Float64Array( [ 4.0, -0.0, 16.0, 25.0 ] );
+var S = new Float64Array( 4 );
+var SCOND = new Float64Array( [ -7.0 ] );
+var AMAX = new Float64Array( [ -9.0 ] );
+var info = dpbequ.ndarray( 'lower', 4, 0, AB, 1, 1, 0, S, 1, 0, SCOND, 0, AMAX, 0 );
+// returns 2
+// S => [ 4, -0, 16, 25 ]
+// SCOND => [ -7 ]
+// AMAX => [ 25 ]
+```
+
+Band cell `b,j` is `AB[offsetAB+b*strideAB1+j*strideAB2]`; output cell `j` is `S[offsetS+j*strideS]`. Scalar cells are `SCOND[offsetSCOND]` and `AMAX[offsetAMAX]`. Metadata must be primitive safe integers; active offsets are nonnegative. Full views must fit, be injective and have exactly representable products, corners and indexed byte sums. Used zero strides are rejected. Valid unused singleton strides need not enter arithmetic.
+
+
+
+
+
+
+
+## Notes
+
+- All selected diagonals must be finite before any output write. Ignored band or padding entries may be nonfinite; no full-value scan is performed. This finite-diagonal restriction is a proposed deviation from Reference-LAPACK.
+- `INFO=0` writes all scaling factors and both scalar results. For positive `INFO`, every original selected diagonal is copied into `S`, `AMAX` includes all columns, and `SCOND` retains the caller's exact sentinel. `INFO` is the first one-based nonpositive diagonal, including negative zero. Failure is not a partial early diagonal copy.
+- Strict comparisons retain the first tied extremum. On mixed negative/positive zero failures, the first zero sign is retained in `AMAX`; sampled GNU reference builds instead retain the last zero sign. No universal signed-zero, nonfinite or untested-platform bitwise parity is claimed.
+- All four active conservative indexed byte envelopes must be pairwise disjoint, even though only the input diagonal is read. Disjoint envelopes may share one ordinary backing buffer. Overlapping gaps or unused band cells are still rejected; inputs are not copied to evade aliases.
+- Active views require intrinsic `Float64Array` over ordinary `ArrayBuffer`, including current in-bounds resizable extents. Shared backing, cloned shared storage, proxies, detached and current out-of-bounds views are rejected. Captured intrinsics ignore shadowed metadata and support genuine crossrealm views and subclasses.
+- Backing must remain stable and exclusive until synchronous return: no resize, detach, transfer, reentry or concurrent foreign mutation. Pure JavaScript cannot detect physical overlap between externally fabricated ordinary buffers with different identities; callers must guarantee physical disjointness. Native/C independently reject physical indexed-envelope overlaps, and these errors propagate without fallback.
+- For `N=0`, validate selectors, dimensions, main `LDAB`, and only active `SCOND`/`AMAX` storage, offsets and mutual disjointness. Write `SCOND=1` and positive-zero `AMAX` and return zero. `AB`, `S` and their unused ndarray metadata are not inspected. Main leading-dimension bounds still apply.
+- Native eligibility uses conservative signed32 metadata, products and corners before dispatch. Otherwise valid wider metadata uses the JavaScript kernel before mutation. Backend errors never trigger a retry after mutation. There is no numerical BLAS dependency, integer output staging or heap workspace; internal Node-API allocation is not a transactional engine-wide allocation guarantee.
+- Invalid selectors, array brands or backing throw `TypeError`; invalid integer metadata, geometry, aliases or selected nonfinite diagonals throw `RangeError` before routine-owned writes. Type annotations cannot encode these runtime preconditions.
+- The proposed Node engine floor is a feature/support declaration. Actual package execution uses Node24/Linux and does not certify Node16, other engines, native platforms or arbitrary toolchains.
+
+
+
+
+
+
+
+## Examples
+
+```javascript
+'use strict';
+
+// MODULES //
+
+var assert = require( 'assert' );
+var Float64Array = require( '@stdlib/array/float64' );
+var dpbequ = require( '@stdlib/lapack/base/dpbequ' );
+
+
+// MAIN //
+
+// Only selected diagonals are read; ignored band entries may be nonfinite:
+var AB = new Float64Array( [ 4.0, 16.0, 64.0, NaN, Infinity, 999.0 ] );
+var S = new Float64Array( 3 );
+var SCOND = new Float64Array( [ -7.0 ] );
+var AMAX = new Float64Array( [ -9.0 ] );
+var info = dpbequ( 'row-major', 'lower', 3, 1, AB, 3, S, SCOND, AMAX );
+assert.strictEqual( info, 0 );
+assert.strictEqual( Array.prototype.join.call( S, ',' ), '0.5,0.25,0.125' );
+assert.strictEqual( SCOND[ 0 ], 0.25 );
+assert.strictEqual( AMAX[ 0 ], 64.0 );
+assert.strictEqual( S[ 0 ]*S[ 0 ]*AB[ 0 ], 1.0 );
+assert.strictEqual( S[ 1 ]*S[ 1 ]*AB[ 1 ], 1.0 );
+assert.strictEqual( S[ 2 ]*S[ 2 ]*AB[ 2 ], 1.0 );
+console.log( 'INFO: %d; S: %s; SCOND: %d; AMAX: %d', info, Array.prototype.join.call( S, ', ' ), SCOND[ 0 ], AMAX[ 0 ] );
+
+// Signed band/output strides and scalar offsets retain all guards:
+AB = new Float64Array( [ 8.0, 64.0, 999.0, 16.0, 999.0, 4.0, 999.0, 8.0 ] );
+S = new Float64Array( [ 7.0, 7.0, 7.0, 7.0, 7.0 ] );
+SCOND = new Float64Array( [ 7.0, -7.0, 7.0 ] );
+AMAX = new Float64Array( [ 7.0, -9.0, 7.0 ] );
+info = dpbequ.ndarray( 'upper', 3, 1, AB, 1, -2, 4, S, -1, 3, SCOND, 1, AMAX, 1 );
+assert.strictEqual( info, 0 );
+assert.strictEqual( Array.prototype.join.call( S, ',' ), '7,0.125,0.25,0.5,7' );
+assert.strictEqual( Array.prototype.join.call( SCOND, ',' ), '7,0.25,7' );
+assert.strictEqual( Array.prototype.join.call( AMAX, ',' ), '7,64,7' );
+assert.strictEqual( Array.prototype.join.call( AB, ',' ), '8,64,999,16,999,4,999,8' );
+console.log( 'Strided INFO: %d; guarded S: %s', info, Array.prototype.join.call( S, ', ' ) );
+
+// Failure copies every diagonal and finds AMAX even in later columns:
+AB = new Float64Array( [ 4.0, -0.0, 16.0, 25.0 ] );
+S = new Float64Array( 4 );
+SCOND = new Float64Array( [ -0.0 ] );
+AMAX = new Float64Array( [ -9.0 ] );
+info = dpbequ( 'column-major', 'lower', 4, 0, AB, 1, S, SCOND, AMAX );
+assert.strictEqual( info, 2 );
+assert.strictEqual( Array.prototype.join.call( S, ',' ), '4,0,16,25' );
+assert.strictEqual( 1/S[ 1 ], -Infinity );
+assert.strictEqual( 1/SCOND[ 0 ], -Infinity );
+assert.strictEqual( AMAX[ 0 ], 25.0 );
+console.log( 'Failure INFO: %d; copied S: %s; AMAX: %d', info, Array.prototype.join.call( S, ', ' ), AMAX[ 0 ] );
+
+// Strict-first AMAX preserves the first tied zero sign on failure:
+AB = new Float64Array( [ -0.0, 0.0 ] );
+S = new Float64Array( 2 );
+info = dpbequ( 'row-major', 'lower', 2, 0, AB, 2, S, SCOND, AMAX );
+assert.strictEqual( info, 1 );
+assert.strictEqual( 1/AMAX[ 0 ], -Infinity );
+assert.strictEqual( 1/SCOND[ 0 ], -Infinity );
+console.log( 'Mixed-zero INFO: %d; first AMAX sign: %d', info, 1/AMAX[ 0 ] );
+
+// Empty input ignores AB/S but validates and writes both active scalars:
+info = dpbequ( 'column-major', 'upper', 0, 2, null, 3, null, SCOND, AMAX );
+assert.strictEqual( info, 0 );
+assert.strictEqual( SCOND[ 0 ], 1.0 );
+assert.strictEqual( 1/AMAX[ 0 ], Infinity );
+console.log( 'Empty INFO: %d; SCOND: %d; AMAX: %d', info, SCOND[ 0 ], AMAX[ 0 ] );
+```
+
+
+
+
+
+
+
+## C APIs
+
+```c
+#include "stdlib/lapack/base/dpbequ.h"
+```
+
+#### c_dpbequ( order, uplo, N, KD, AB, LDAB, S, SCOND, AMAX )
+
+```c
+LAPACK_INT API_SUFFIX(c_dpbequ)( const LAPACK_LAYOUT order, const int uplo, const LAPACK_INT N, const LAPACK_INT KD, const double *AB, const LAPACK_INT LDAB, double *S, double *SCOND, double *AMAX );
+```
+
+
+
+#### c_dpbequ_ndarray( uplo, N, KD, AB, strideAB1, strideAB2, offsetAB, S, strideS, offsetS, SCOND, offsetSCOND, AMAX, offsetAMAX )
+
+```c
+LAPACK_INT API_SUFFIX(c_dpbequ_ndarray)( const int uplo, const LAPACK_INT N, const LAPACK_INT KD, const double *AB, const LAPACK_INT strideAB1, const LAPACK_INT strideAB2, const LAPACK_INT offsetAB, double *S, const LAPACK_INT strideS, const LAPACK_INT offsetS, double *SCOND, const LAPACK_INT offsetSCOND, double *AMAX, const LAPACK_INT offsetAMAX );
+```
+
+Both return configured `LAPACK_INT` `INFO`; negative values identify prewrite argument errors (`-1` through `-9` main, `-1` through `-14` ndarray). Exact maps and validation precedence are documented in the public header. `LAPACK_ILP64` selects metadata width; API suffix configuration is independent. Raw `N/KD` are at most configured `MAX-1`; products, sums, magnitudes and physical byte envelopes cannot wrap. Minimum configured integer strides are rejected before negation on active calls. Caller storage must have sufficient capacity, double alignment and stable exclusive lifetime. Empty calls ignore input/vector pointers and inactive metadata but require two valid disjoint scalar cells. No numerical BLAS linkage is required.
+
+
+
+### Examples
+
+```c
+#include "stdlib/lapack/base/dpbequ.h"
+#include "stdlib/lapack/base/shared.h"
+#include
+#include
+#include
+#include
+
+/**
+* Main execution sequence.
+*/
+int main( void ) {
+ const double AB[] = { 4.0, 16.0, 64.0, NAN, INFINITY, 999.0 };
+ double before[ 6 ];
+ const double B[] = { 8.0, 64.0, 999.0, 16.0, 999.0, 4.0, 999.0, 8.0 };
+ double T[] = { 7.0, 7.0, 7.0, 7.0, 7.0 };
+ double C[] = { 7.0, -7.0, 7.0 };
+ double M[] = { 7.0, -9.0, 7.0 };
+ const double F[] = { 4.0, -0.0, 16.0, 25.0 };
+ const double Z[] = { -0.0, 0.0 };
+ double S[ 4 ] = { 0.0, 0.0, 0.0, 0.0 };
+ double sc = -0.0;
+ double am = -9.0;
+ LAPACK_INT info;
+
+ memcpy( before, AB, sizeof AB );
+ info = API_SUFFIX(c_dpbequ)( LAPACK_ROW_MAJOR, LAPACK_LOWER_TRIANGLE, 3, 1, AB, 3, S, &sc, &am );
+ if ( info != 0 || S[ 0 ] != 0.5 || S[ 1 ] != 0.25 || S[ 2 ] != 0.125 || sc != 0.25 || am != 64.0 || memcmp( before, AB, sizeof AB ) != 0 ) {
+ return EXIT_FAILURE;
+ }
+ if ( S[ 0 ]*S[ 0 ]*AB[ 0 ] != 1.0 || S[ 1 ]*S[ 1 ]*AB[ 1 ] != 1.0 || S[ 2 ]*S[ 2 ]*AB[ 2 ] != 1.0 ) {
+ return EXIT_FAILURE;
+ }
+ printf( "INFO: %d; SCOND: %.2f; AMAX: %.1f\n", (int)info, sc, am );
+
+ info = API_SUFFIX(c_dpbequ_ndarray)( LAPACK_UPPER_TRIANGLE, 3, 1, B, 1, -2, 4, T, -1, 3, C, 1, M, 1 );
+ if ( info != 0 || T[ 0 ] != 7.0 || T[ 1 ] != 0.125 || T[ 2 ] != 0.25 || T[ 3 ] != 0.5 || T[ 4 ] != 7.0 || C[ 0 ] != 7.0 || C[ 1 ] != 0.25 || C[ 2 ] != 7.0 || M[ 0 ] != 7.0 || M[ 1 ] != 64.0 || M[ 2 ] != 7.0 ) {
+ return EXIT_FAILURE;
+ }
+ printf( "Strided INFO: %d; guarded S: %.3f, %.2f, %.1f\n", (int)info, T[ 1 ], T[ 2 ], T[ 3 ] );
+
+ sc = -0.0;
+ info = API_SUFFIX(c_dpbequ)( LAPACK_COL_MAJOR, LAPACK_LOWER_TRIANGLE, 4, 0, F, 1, S, &sc, &am );
+ if ( info != 2 || S[ 0 ] != 4.0 || S[ 1 ] != 0.0 || !signbit(S[ 1 ]) || S[ 2 ] != 16.0 || S[ 3 ] != 25.0 || sc != 0.0 || !signbit(sc) || am != 25.0 ) {
+ return EXIT_FAILURE;
+ }
+ printf( "Failure INFO: %d; later-column AMAX: %.1f\n", (int)info, am );
+
+ info = API_SUFFIX(c_dpbequ)( LAPACK_ROW_MAJOR, LAPACK_LOWER_TRIANGLE, 2, 0, Z, 2, S, &sc, &am );
+ if ( info != 1 || am != 0.0 || !signbit(am) || sc != 0.0 || !signbit(sc) ) {
+ return EXIT_FAILURE;
+ }
+ printf( "Mixed-zero INFO: %d; first AMAX sign retained\n", (int)info );
+
+ info = API_SUFFIX(c_dpbequ)( LAPACK_COL_MAJOR, LAPACK_UPPER_TRIANGLE, 0, 2, NULL, 3, NULL, &sc, &am );
+ if ( info != 0 || sc != 1.0 || am != 0.0 || signbit(am) ) {
+ return EXIT_FAILURE;
+ }
+ printf( "Empty INFO: %d; SCOND: %.1f; AMAX: %.1f\n", (int)info, sc, am );
+ return EXIT_SUCCESS;
+}
+```
+
+
+
+
+
+
+
+
+
+
+
+## References
+
+The arithmetic follows [Reference-LAPACK DPBEQU][lapack-source] at commit `2e5d9c1273435fbd953adb294ed603e4789afaba`, with attribution to the University of Tennessee, University of California Berkeley, University of Colorado Denver and NAG Ltd. Public output/geometry/backing validation, the finite-diagonal domain and strict-first failure reduction are proposed adaptations. The original BSD conditions and disclaimer are retained in [NOTICE][lapack-notice] and reproduced below for distributions.
+
+```text
+Copyright (c) 1992-2025 The University of Tennessee and The University
+ of Tennessee Research Foundation. All rights
+ reserved.
+Copyright (c) 2000-2025 The University of California Berkeley. All
+ rights reserved.
+Copyright (c) 2006-2025 The University of Colorado Denver. All rights
+ reserved.
+
+$COPYRIGHT$
+
+Additional copyrights may follow
+
+$HEADER$
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+- Redistributions of source code must retain the above copyright
+ notice, this list of conditions and the following disclaimer.
+
+- Redistributions in binary form must reproduce the above copyright
+ notice, this list of conditions and the following disclaimer listed
+ in this license in the documentation and/or other materials
+ provided with the distribution.
+
+- Neither the name of the copyright holders nor the names of its
+ contributors may be used to endorse or promote products derived from
+ this software without specific prior written permission.
+
+The copyright holders provide no reassurances that the source code
+provided does not infringe any patent, copyright, or any other
+intellectual property rights of third parties. The copyright holders
+disclaim any liability to any recipient for claims brought against
+recipient by any third party for infringement of that parties
+intellectual property rights.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+```
+
+
+
+
+
+
+
+
+
+[lapack-source]: https://github.com/Reference-LAPACK/lapack/blob/2e5d9c1273435fbd953adb294ed603e4789afaba/SRC/dpbequ.f
+
+[lapack-notice]: ./NOTICE
+
+
+
+
diff --git a/lib/node_modules/@stdlib/lapack/base/dpbequ/benchmark/benchmark.js b/lib/node_modules/@stdlib/lapack/base/dpbequ/benchmark/benchmark.js
new file mode 100644
index 000000000000..5787816a22bd
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dpbequ/benchmark/benchmark.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 bench = require( '@stdlib/bench' );
+var Float64Array = require( '@stdlib/array/float64' );
+var Uint8Array = require( '@stdlib/array/uint8' );
+var abs = require( '@stdlib/math/base/special/abs' );
+var format = require( '@stdlib/string/format' );
+var pkg = require( './../package.json' ).name;
+var dpbequ = require( './../lib' );
+
+
+// FUNCTIONS //
+
+/**
+* Creates bounded scaling benchmarks with complete output/input checks.
+*
+* @private
+* @param {PositiveInteger} N - matrix order
+* @param {boolean} upper - whether to use upper storage
+* @param {boolean} failed - whether the second diagonal is negative zero
+* @returns {Function} benchmark function
+*/
+function createBenchmark( N, upper, failed ) {
+ var before;
+ var bytes;
+ var SCOND;
+ var AMAX;
+ var AB;
+ var ss;
+ var os;
+ var S;
+ var r;
+ var c;
+ var o;
+ var j;
+
+ AB = new Float64Array( 2*N );
+ S = new Float64Array( N+2 );
+ SCOND = new Float64Array( 1 );
+ AMAX = new Float64Array( 1 );
+ r = N;
+ c = 1;
+ o = 0;
+ ss = 1;
+ os = 0;
+ for ( j = 0; j < AB.length; j++ ) {
+ AB[ j ] = NaN;
+ }
+ for ( j = 0; j < N; j++ ) {
+ AB[ o+(( ( upper ) ? 1 : 0 )*r)+(j*c) ] = ( failed && j === 1 ) ? -0.0 : (j+2)*(j+2);
+ }
+ bytes = new Uint8Array( AB.buffer );
+ before = new Uint8Array( bytes );
+ return benchmark;
+
+ /**
+ * Benchmark function.
+ *
+ * @private
+ * @param {Benchmark} b - benchmark instance
+ */
+ function benchmark( b ) {
+ var diagonal;
+ var index;
+ var info;
+ var i;
+ var j;
+
+ b.tic();
+ for ( i = 0; i < b.iterations; i++ ) {
+ // Output reset is included in the measured workload:
+ for ( j = 0; j < S.length; j++ ) {
+ S[ j ] = 7.0;
+ }
+ SCOND[ 0 ] = -0.0;
+ AMAX[ 0 ] = -9.0;
+ info = dpbequ( 'row-major', ( upper ) ? 'upper' : 'lower', N, 1, AB, N, S, SCOND, AMAX );
+ if ( info !== (( failed ) ? 2 : 0) ) {
+ b.fail( 'should return the expected scaling status' );
+ b.end();
+ return;
+ }
+ }
+ b.toc();
+ for ( j = 0; j < N; j++ ) {
+ index = os+(j*ss);
+ diagonal = AB[ o+(( ( upper ) ? 1 : 0 )*r)+(j*c) ];
+ if ( failed ) {
+ if ( S[ index ] !== diagonal || (j === 1 && 1/S[ index ] !== -Infinity) ) {
+ b.fail( 'should copy every failure diagonal and preserve zero sign' );
+ b.end();
+ return;
+ }
+ } else if ( !( abs( (S[ index ]*S[ index ]*diagonal)-1.0 ) <= 1.0e-14 ) ) {
+ b.fail( 'should scale each positive diagonal to one' );
+ b.end();
+ return;
+ }
+ }
+ if ( AMAX[ 0 ] !== (N+1)*(N+1) || (( failed ) ? 1/SCOND[ 0 ] !== -Infinity : SCOND[ 0 ] !== 2/(N+1)) ) {
+ b.fail( 'should check full AMAX and SCOND output/sentinel' );
+ b.end();
+ return;
+ }
+ for ( j = 0; j < bytes.length; j++ ) {
+ if ( bytes[ j ] !== before[ j ] ) {
+ b.fail( 'should preserve every input byte' );
+ b.end();
+ return;
+ }
+ }
+ for ( j = 0; j < S.length; j++ ) {
+ if ( ((j < os+((N-1)*ss) || j > os) && ss < 0) || ((j < os || j > os+((N-1)*ss)) && ss > 0) ) {
+ if ( S[ j ] !== 7.0 ) {
+ b.fail( 'should retain unused output guards' );
+ b.end();
+ return;
+ }
+ }
+ }
+ b.pass( 'benchmark finished' );
+ b.end();
+ }
+}
+
+
+// MAIN //
+
+/**
+* Main execution sequence.
+*
+* @private
+*/
+function main() {
+ var options;
+ var sizes;
+ var name;
+ var fcn;
+ var i;
+ var j;
+ var k;
+
+ options = {
+ 'iterations': 200,
+ 'repeats': 2
+ };
+ sizes = [ 8, 16 ];
+ for ( i = 0; i < sizes.length; i++ ) {
+ for ( j = 0; j < 2; j++ ) {
+ for ( k = 0; k < 2; k++ ) {
+ name = format( '%s:N=%d:upper=%d:failed=%d', pkg, sizes[ i ], j, k );
+ fcn = createBenchmark( sizes[ i ], j === 1, k === 1 );
+ bench( name, options, fcn );
+ }
+ }
+ }
+}
+
+main();
diff --git a/lib/node_modules/@stdlib/lapack/base/dpbequ/benchmark/benchmark.ndarray.js b/lib/node_modules/@stdlib/lapack/base/dpbequ/benchmark/benchmark.ndarray.js
new file mode 100644
index 000000000000..f13857386339
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dpbequ/benchmark/benchmark.ndarray.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 bench = require( '@stdlib/bench' );
+var Float64Array = require( '@stdlib/array/float64' );
+var Uint8Array = require( '@stdlib/array/uint8' );
+var abs = require( '@stdlib/math/base/special/abs' );
+var format = require( '@stdlib/string/format' );
+var pkg = require( './../package.json' ).name;
+var dpbequ = require( './../lib' );
+
+
+// FUNCTIONS //
+
+/**
+* Creates bounded scaling benchmarks with complete output/input checks.
+*
+* @private
+* @param {PositiveInteger} N - matrix order
+* @param {boolean} upper - whether to use upper storage
+* @param {boolean} failed - whether the second diagonal is negative zero
+* @returns {Function} benchmark function
+*/
+function createBenchmark( N, upper, failed ) {
+ var before;
+ var bytes;
+ var SCOND;
+ var AMAX;
+ var AB;
+ var ss;
+ var os;
+ var S;
+ var r;
+ var c;
+ var o;
+ var j;
+
+ AB = new Float64Array( 2*N );
+ S = new Float64Array( N+2 );
+ SCOND = new Float64Array( 1 );
+ AMAX = new Float64Array( 1 );
+ r = 1;
+ c = -2;
+ o = 2*(N-1);
+ ss = -1;
+ os = N;
+ for ( j = 0; j < AB.length; j++ ) {
+ AB[ j ] = NaN;
+ }
+ for ( j = 0; j < N; j++ ) {
+ AB[ o+(( ( upper ) ? 1 : 0 )*r)+(j*c) ] = ( failed && j === 1 ) ? -0.0 : (j+2)*(j+2);
+ }
+ bytes = new Uint8Array( AB.buffer );
+ before = new Uint8Array( bytes );
+ return benchmark;
+
+ /**
+ * Benchmark function.
+ *
+ * @private
+ * @param {Benchmark} b - benchmark instance
+ */
+ function benchmark( b ) {
+ var diagonal;
+ var index;
+ var info;
+ var i;
+ var j;
+
+ b.tic();
+ for ( i = 0; i < b.iterations; i++ ) {
+ // Output reset is included in the measured workload:
+ for ( j = 0; j < S.length; j++ ) {
+ S[ j ] = 7.0;
+ }
+ SCOND[ 0 ] = -0.0;
+ AMAX[ 0 ] = -9.0;
+ info = dpbequ.ndarray( ( upper ) ? 'upper' : 'lower', N, 1, AB, r, c, o, S, ss, os, SCOND, 0, AMAX, 0 );
+ if ( info !== (( failed ) ? 2 : 0) ) {
+ b.fail( 'should return the expected scaling status' );
+ b.end();
+ return;
+ }
+ }
+ b.toc();
+ for ( j = 0; j < N; j++ ) {
+ index = os+(j*ss);
+ diagonal = AB[ o+(( ( upper ) ? 1 : 0 )*r)+(j*c) ];
+ if ( failed ) {
+ if ( S[ index ] !== diagonal || (j === 1 && 1/S[ index ] !== -Infinity) ) {
+ b.fail( 'should copy every failure diagonal and preserve zero sign' );
+ b.end();
+ return;
+ }
+ } else if ( !( abs( (S[ index ]*S[ index ]*diagonal)-1.0 ) <= 1.0e-14 ) ) {
+ b.fail( 'should scale each positive diagonal to one' );
+ b.end();
+ return;
+ }
+ }
+ if ( AMAX[ 0 ] !== (N+1)*(N+1) || (( failed ) ? 1/SCOND[ 0 ] !== -Infinity : SCOND[ 0 ] !== 2/(N+1)) ) {
+ b.fail( 'should check full AMAX and SCOND output/sentinel' );
+ b.end();
+ return;
+ }
+ for ( j = 0; j < bytes.length; j++ ) {
+ if ( bytes[ j ] !== before[ j ] ) {
+ b.fail( 'should preserve every input byte' );
+ b.end();
+ return;
+ }
+ }
+ for ( j = 0; j < S.length; j++ ) {
+ if ( ((j < os+((N-1)*ss) || j > os) && ss < 0) || ((j < os || j > os+((N-1)*ss)) && ss > 0) ) {
+ if ( S[ j ] !== 7.0 ) {
+ b.fail( 'should retain unused output guards' );
+ b.end();
+ return;
+ }
+ }
+ }
+ b.pass( 'benchmark finished' );
+ b.end();
+ }
+}
+
+
+// MAIN //
+
+/**
+* Main execution sequence.
+*
+* @private
+*/
+function main() {
+ var options;
+ var sizes;
+ var name;
+ var fcn;
+ var i;
+ var j;
+ var k;
+
+ options = {
+ 'iterations': 200,
+ 'repeats': 2
+ };
+ sizes = [ 8, 16 ];
+ for ( i = 0; i < sizes.length; i++ ) {
+ for ( j = 0; j < 2; j++ ) {
+ for ( k = 0; k < 2; k++ ) {
+ name = format( '%s:N=%d:upper=%d:failed=%d', pkg, sizes[ i ], j, k );
+ fcn = createBenchmark( sizes[ i ], j === 1, k === 1 );
+ bench( name, options, fcn );
+ }
+ }
+ }
+}
+
+main();
diff --git a/lib/node_modules/@stdlib/lapack/base/dpbequ/benchmark/c/Makefile b/lib/node_modules/@stdlib/lapack/base/dpbequ/benchmark/c/Makefile
new file mode 100644
index 000000000000..979768abbcec
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dpbequ/benchmark/c/Makefile
@@ -0,0 +1,146 @@
+#/
+# @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.
+#/
+
+# VARIABLES #
+
+ifndef VERBOSE
+ QUIET := @
+else
+ QUIET :=
+endif
+
+# Determine the OS ([1][1], [2][2]).
+#
+# [1]: https://en.wikipedia.org/wiki/Uname#Examples
+# [2]: http://stackoverflow.com/a/27776822/2225624
+OS ?= $(shell uname)
+ifneq (, $(findstring MINGW,$(OS)))
+ OS := WINNT
+else
+ifneq (, $(findstring MSYS,$(OS)))
+ OS := WINNT
+else
+ifneq (, $(findstring CYGWIN,$(OS)))
+ OS := WINNT
+else
+ifneq (, $(findstring Windows_NT,$(OS)))
+ OS := WINNT
+endif
+endif
+endif
+endif
+
+# Define the program used for compiling C source files:
+ifdef C_COMPILER
+ CC := $(C_COMPILER)
+else
+ CC := gcc
+endif
+
+# Define the command-line options when compiling C files:
+CFLAGS ?= \
+ -std=c99 \
+ -O3 \
+ -Wall \
+ -pedantic
+
+# Determine whether to generate position independent code ([1][1], [2][2]).
+#
+# [1]: https://gcc.gnu.org/onlinedocs/gcc/Code-Gen-Options.html#Code-Gen-Options
+# [2]: http://stackoverflow.com/questions/5311515/gcc-fpic-option
+ifeq ($(OS), WINNT)
+ fPIC ?=
+else
+ fPIC ?= -fPIC
+endif
+
+# List of includes (e.g., `-I /foo/bar -I /beep/boop/include`):
+INCLUDE ?=
+
+# List of source files:
+SOURCE_FILES ?=
+
+# List of libraries (e.g., `-lopenblas -lpthread`):
+LIBRARIES ?=
+
+# List of library paths (e.g., `-L /foo/bar -L /beep/boop`):
+LIBPATH ?=
+
+# List of C targets:
+c_targets := benchmark.out
+
+
+# RULES #
+
+#/
+# Compiles source files.
+#
+# @param {string} [C_COMPILER] - C compiler (e.g., `gcc`)
+# @param {string} [CFLAGS] - C compiler options
+# @param {(string|void)} [fPIC] - compiler flag determining whether to generate position independent code (e.g., `-fPIC`)
+# @param {string} [INCLUDE] - list of includes (e.g., `-I /foo/bar -I /beep/boop/include`)
+# @param {string} [SOURCE_FILES] - list of source files
+# @param {string} [LIBPATH] - list of library paths (e.g., `-L /foo/bar -L /beep/boop`)
+# @param {string} [LIBRARIES] - list of libraries (e.g., `-lopenblas -lpthread`)
+#
+# @example
+# make
+#
+# @example
+# make all
+#/
+all: $(c_targets)
+
+.PHONY: all
+
+#/
+# Compiles C source files.
+#
+# @private
+# @param {string} CC - C compiler (e.g., `gcc`)
+# @param {string} CFLAGS - C compiler options
+# @param {(string|void)} fPIC - compiler flag determining whether to generate position independent code (e.g., `-fPIC`)
+# @param {string} INCLUDE - list of includes (e.g., `-I /foo/bar`)
+# @param {string} SOURCE_FILES - list of source files
+# @param {string} LIBPATH - list of library paths (e.g., `-L /foo/bar`)
+# @param {string} LIBRARIES - list of libraries (e.g., `-lopenblas`)
+#/
+$(c_targets): %.out: %.c
+ $(QUIET) $(CC) $(CFLAGS) $(fPIC) $(INCLUDE) -o $@ $(SOURCE_FILES) $< $(LIBPATH) -lm $(LIBRARIES)
+
+#/
+# Runs compiled benchmarks.
+#
+# @example
+# make run
+#/
+run: $(c_targets)
+ $(QUIET) ./$<
+
+.PHONY: run
+
+#/
+# Removes generated files.
+#
+# @example
+# make clean
+#/
+clean:
+ $(QUIET) -rm -f *.o *.out
+
+.PHONY: clean
diff --git a/lib/node_modules/@stdlib/lapack/base/dpbequ/benchmark/c/benchmark.c b/lib/node_modules/@stdlib/lapack/base/dpbequ/benchmark/c/benchmark.c
new file mode 100644
index 000000000000..3530d0fcaefd
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dpbequ/benchmark/c/benchmark.c
@@ -0,0 +1,122 @@
+/**
+* @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.
+*/
+
+
+#include "stdlib/lapack/base/dpbequ.h"
+#include "stdlib/lapack/base/shared.h"
+#include
+#include
+#include
+#include
+#include
+#include
+
+/**
+* Main execution sequence.
+*/
+int main( void ) {
+ double AB[ 32 ] = { 0.0 };
+ double before[ 32 ];
+ double S[ 18 ];
+ double sc;
+ double am;
+ double diagonal;
+ LAPACK_INT r;
+ LAPACK_INT c;
+ LAPACK_INT o;
+ LAPACK_INT ss;
+ LAPACK_INT os;
+ LAPACK_INT info;
+ LAPACK_INT N;
+ const int32_t sizes[] = { 8, 16 };
+ int32_t i;
+ int32_t j;
+ int32_t upper;
+ int32_t failed;
+ int32_t nd;
+ int32_t repeat;
+ int32_t iteration;
+ int32_t count = 0;
+ double elapsed;
+ clock_t t;
+
+ for ( i = 0; i < 2; i++ ) {
+ N = sizes[ i ];
+ for ( upper = 0; upper < 2; upper++ ) {
+ for ( nd = 0; nd < 2; nd++ ) {
+ r = nd ? 1 : N;
+ c = nd ? -2 : 1;
+ o = nd ? 2*(N-1) : 0;
+ ss = nd ? -1 : 1;
+ os = nd ? N : 0;
+ for ( failed = 0; failed < 2; failed++ ) {
+ for ( j = 0; j < 2*N; j++ ) {
+ AB[ j ] = NAN;
+ }
+ for ( j = 0; j < N; j++ ) {
+ AB[ o+(upper*r)+(j*c) ] = (failed && j == 1) ? -0.0 : (double)((j+2)*(j+2));
+ }
+ memcpy( before, AB, (size_t)(2*N)*sizeof(double) );
+ for ( repeat = 0; repeat < 2; repeat++ ) {
+ t = clock();
+ for ( iteration = 0; iteration < 200; iteration++ ) {
+ for ( j = 0; j < N+2; j++ ) {
+ S[ j ] = 7.0;
+ }
+ sc = -0.0;
+ am = -9.0;
+ if ( nd ) {
+ info = API_SUFFIX(c_dpbequ_ndarray)( upper ? LAPACK_UPPER_TRIANGLE : LAPACK_LOWER_TRIANGLE, N, 1, AB, r, c, o, S, ss, os, &sc, 0, &am, 0 );
+ } else {
+ info = API_SUFFIX(c_dpbequ)( LAPACK_ROW_MAJOR, upper ? LAPACK_UPPER_TRIANGLE : LAPACK_LOWER_TRIANGLE, N, 1, AB, N, S, &sc, &am );
+ }
+ if ( info != (failed ? 2 : 0) ) {
+ return EXIT_FAILURE;
+ }
+ }
+
+ elapsed = (double)(clock()-t)/(double)CLOCKS_PER_SEC;
+ for ( j = 0; j < N; j++ ) {
+ diagonal = AB[ o+(upper*r)+(j*c) ];
+ if ( failed ) {
+ if ( S[ os+(j*ss) ] != diagonal || (j == 1 && !signbit(S[ os+(j*ss) ])) ) {
+ return EXIT_FAILURE;
+ }
+ } else if ( !(fabs(S[ os+(j*ss) ]*S[ os+(j*ss) ]*diagonal-1.0) <= 1.0e-14) ) {
+ return EXIT_FAILURE;
+ }
+ }
+ if ( am != (double)((N+1)*(N+1)) || (failed ? sc != 0.0 || !signbit(sc) : sc != 2.0/(double)(N+1)) || memcmp( before, AB, (size_t)(2*N)*sizeof(double) ) != 0 ) {
+ return EXIT_FAILURE;
+ }
+ for ( j = 0; j < N+2; j++ ) {
+ if ( ((ss < 0 && (j < os+(N-1)*ss || j > os)) || (ss > 0 && (j < os || j > os+(N-1)*ss))) && S[ j ] != 7.0 ) {
+ return EXIT_FAILURE;
+ }
+ }
+ count++;
+ printf( "# c::dpbequ:N=%d:upper=%d:ndarray=%d:failed=%d\n", (int)N, upper, nd, failed );
+ printf( "ok %d benchmark finished; 200 iterations; %.9f seconds\n", count, elapsed );
+ }
+ }
+ }
+ }
+ }
+ printf( "1..%d\n# total %d\n# pass %d\n", count, count, count );
+ return EXIT_SUCCESS;
+}
diff --git a/lib/node_modules/@stdlib/lapack/base/dpbequ/binding.gyp b/lib/node_modules/@stdlib/lapack/base/dpbequ/binding.gyp
new file mode 100644
index 000000000000..89dba19a0e05
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dpbequ/binding.gyp
@@ -0,0 +1,268 @@
+# @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.
+
+# A `.gyp` file for building a Node.js native add-on.
+#
+# [1]: https://gyp.gsrc.io/docs/InputFormatReference.md
+# [2]: https://gyp.gsrc.io/docs/UserDocumentation.md
+{
+ # List of files to include in this file:
+ 'includes': [
+ './include.gypi',
+ ],
+
+ # Define variables to be used throughout the configuration for all targets:
+ 'variables': {
+ # Target name should match the add-on export name:
+ 'addon_target_name%': 'addon',
+
+ # Fortran compiler (to override -Dfortran_compiler=):
+ 'fortran_compiler%': 'gfortran',
+
+ # Fortran compiler flags:
+ 'fflags': [
+ # Specify the Fortran standard to which a program is expected to conform:
+ '-std=f95',
+
+ # Indicate that the layout is free-form source code:
+ '-ffree-form',
+
+ # Aggressive optimization:
+ '-O3',
+
+ # Enable commonly used warning options:
+ '-Wall',
+
+ # Warn if source code contains problematic language features:
+ '-Wextra',
+
+ # Warn if a procedure is called without an explicit interface:
+ '-Wimplicit-interface',
+
+ # Do not transform names of entities specified in Fortran source files by appending underscores (i.e., don't mangle names, thus allowing easier usage in C wrappers):
+ '-fno-underscoring',
+
+ # Warn if source code contains Fortran 95 extensions and C-language constructs:
+ '-pedantic',
+
+ # Compile but do not link (output is an object file):
+ '-c',
+ ],
+
+ # Set variables based on the host OS:
+ 'conditions': [
+ [
+ 'OS=="win"',
+ {
+ # Define the object file suffix:
+ 'obj': 'obj',
+ },
+ {
+ # Define the object file suffix:
+ 'obj': 'o',
+ }
+ ], # end condition (OS=="win")
+ ], # end conditions
+ }, # end variables
+
+ # Define compile targets:
+ 'targets': [
+
+ # Target to generate an add-on:
+ {
+ # The target name should match the add-on export name:
+ 'target_name': '<(addon_target_name)',
+
+ # Define dependencies:
+ 'dependencies': [],
+
+ # Define directories which contain relevant include headers:
+ 'include_dirs': [
+ # Local include directory:
+ '<@(include_dirs)',
+ ],
+
+ # List of source files:
+ 'sources': [
+ '<@(src_files)',
+ ],
+
+ # Settings which should be applied when a target's object files are used as linker input:
+ 'link_settings': {
+ # Define libraries:
+ 'libraries': [
+ '<@(libraries)',
+ ],
+
+ # Define library directories:
+ 'library_dirs': [
+ '<@(library_dirs)',
+ ],
+ },
+
+ # C/C++ compiler flags:
+ 'cflags': [
+ # Enable commonly used warning options:
+ '-Wall',
+
+ # Aggressive optimization:
+ '-O3',
+ ],
+
+ # C specific compiler flags:
+ 'cflags_c': [
+ # Specify the C standard to which a program is expected to conform:
+ '-std=c99',
+ '-DNAPI_VERSION=8',
+ '-fno-fast-math',
+ '-ffp-contract=off',
+ ],
+
+ # C++ specific compiler flags:
+ 'cflags_cpp': [
+ # Specify the C++ standard to which a program is expected to conform:
+ '-std=c++11',
+ ],
+
+ # Linker flags:
+ 'ldflags': [],
+
+ # Apply conditions based on the host OS:
+ 'conditions': [
+ [
+ 'OS=="mac"',
+ {
+ # Linker flags:
+ 'ldflags': [
+ '-undefined dynamic_lookup',
+ '-Wl,-no-pie',
+ '-Wl,-search_paths_first',
+ ],
+ },
+ ], # end condition (OS=="mac")
+ [
+ 'OS!="win"',
+ {
+ # C/C++ flags:
+ 'cflags': [
+ # Generate platform-independent code:
+ '-fPIC',
+ ],
+ },
+ ], # end condition (OS!="win")
+ ], # end conditions
+
+ # Define custom build actions for particular inputs:
+ 'rules': [
+ {
+ # Define a rule for processing Fortran files:
+ 'extension': 'f',
+
+ # Define the pathnames to be used as inputs when performing processing:
+ 'inputs': [
+ # Full path of the current input:
+ '<(RULE_INPUT_PATH)'
+ ],
+
+ # Define the outputs produced during processing:
+ 'outputs': [
+ # Store an output object file in a directory for placing intermediate results (only accessible within a single target):
+ '<(INTERMEDIATE_DIR)/<(RULE_INPUT_ROOT).<(obj)'
+ ],
+
+ # Define the rule for compiling Fortran based on the host OS:
+ 'conditions': [
+ [
+ 'OS=="win"',
+
+ # Rule to compile Fortran on Windows:
+ {
+ 'rule_name': 'compile_fortran_windows',
+ 'message': 'Compiling Fortran file <(RULE_INPUT_PATH) on Windows...',
+
+ 'process_outputs_as_sources': 0,
+
+ # Define the command-line invocation:
+ 'action': [
+ '<(fortran_compiler)',
+ '<@(fflags)',
+ '<@(_inputs)',
+ '-o',
+ '<@(_outputs)',
+ ],
+ },
+
+ # Rule to compile Fortran on non-Windows:
+ {
+ 'rule_name': 'compile_fortran_linux',
+ 'message': 'Compiling Fortran file <(RULE_INPUT_PATH) on Linux...',
+
+ 'process_outputs_as_sources': 1,
+
+ # Define the command-line invocation:
+ 'action': [
+ '<(fortran_compiler)',
+ '<@(fflags)',
+ '-fPIC', # generate platform-independent code
+ '<@(_inputs)',
+ '-o',
+ '<@(_outputs)',
+ ],
+ }
+ ], # end condition (OS=="win")
+ ], # end conditions
+ }, # end rule (extension=="f")
+ ], # end rules
+ }, # end target <(addon_target_name)
+
+ # Target to copy a generated add-on to a standard location:
+ {
+ 'target_name': 'copy_addon',
+
+ # Declare that the output of this target is not linked:
+ 'type': 'none',
+
+ # Define dependencies:
+ 'dependencies': [
+ # Require that the add-on be generated before building this target:
+ '<(addon_target_name)',
+ ],
+
+ # Define a list of actions:
+ 'actions': [
+ {
+ 'action_name': 'copy_addon',
+ 'message': 'Copying addon...',
+
+ # Explicitly list the inputs in the command-line invocation below:
+ 'inputs': [],
+
+ # Declare the expected outputs:
+ 'outputs': [
+ '<(addon_output_dir)/<(addon_target_name).node',
+ ],
+
+ # Define the command-line invocation:
+ 'action': [
+ 'cp',
+ '<(PRODUCT_DIR)/<(addon_target_name).node',
+ '<(addon_output_dir)/<(addon_target_name).node',
+ ],
+ },
+ ], # end actions
+ }, # end target copy_addon
+ ], # end targets
+}
diff --git a/lib/node_modules/@stdlib/lapack/base/dpbequ/docs/repl.txt b/lib/node_modules/@stdlib/lapack/base/dpbequ/docs/repl.txt
new file mode 100644
index 000000000000..916de97335ce
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dpbequ/docs/repl.txt
@@ -0,0 +1,129 @@
+{{alias}}( order, uplo, N, KD, AB, LDAB, S, SCOND, AMAX )
+ Computes diagonal scaling for a symmetric compact band matrix.
+ S[i]=1/sqrt(diagonal[i]), SCOND=sqrt(min)/sqrt(max), AMAX=max.
+ Input AB is unchanged. INFO is zero or the first one-based
+ nonpositive diagonal. On failure all original diagonals are copied
+ to S, AMAX includes later columns and SCOND retains its sentinel.
+ Strict-first zero ties differ from sampled reference AMAX failures.
+
+ H=KD+1; full AB is H-by-N. Upper diagonal row KD, lower row zero.
+ KD>=N is supported. Selected diagonals must be finite before any
+ output write; ignored entries may be nonfinite. Positive diagonal
+ scaling does not certify positive definiteness or stability.
+
+ Active intrinsic Float64Array views need current ordinary backing,
+ pairwise disjoint conservative envelopes and stable exclusive
+ synchronous lifetime. RAB current valid extents are supported;
+ SAB, proxies, detached and OOB views are rejected. Pure JS callers
+ guarantee hidden foreign physical nonaliasing. Native physical
+ alias errors propagate and never trigger postmutation fallback.
+
+ N=0 validates only active SCOND/AMAX and required scalar/main LDAB
+ metadata, then writes SCOND=1, AMAX=+0. AB/S and inactive ndarray
+ metadata are ignored. Only predispatch valid wider metadata uses
+ JS fallback. Proposed Node>=16 is not compatibility proof; actual
+ execution uses Node24/Linux.
+
+ Parameters
+ ----------
+ order: string|number
+ Row-major (101) or column-major (102).
+ uplo: string|number
+ Upper (121) or lower (122).
+ N: integer
+ Matrix order in [0,2147483646].
+ KD: integer
+ Bandwidth in [0,2147483646].
+ AB: Float64Array
+ Read-only full (KD+1)-by-N compact band view.
+ LDAB: integer
+ >=KD+1 column-major or >=max(1,N) row-major.
+ S: Float64Array
+ Output-only N-vector.
+ SCOND: Float64Array
+ Mutable scalar at index zero; retained on failure.
+ AMAX: Float64Array
+ Mutable maximum scalar at index zero.
+
+ Returns
+ -------
+ info: number
+ Zero or the first one-based nonpositive diagonal.
+
+ Examples
+ --------
+ > var A = new {{alias:@stdlib/array/float64}}( [ 4, 16, 64 ] );
+ > var S = new {{alias:@stdlib/array/float64}}( 3 );
+ > var C = new {{alias:@stdlib/array/float64}}( 1 );
+ > var M = new {{alias:@stdlib/array/float64}}( 1 );
+ > {{alias}}( 'column-major', 'lower', 3, 0, A, 1, S, C, M )
+ 0
+ > S
+ [ 0.5, 0.25, 0.125 ]
+ > C
+ [ 0.25 ]
+ > M
+ [ 64 ]
+
+
+{{alias}}.ndarray( uplo, N, KD, AB, r, c, o, S, ss, os, SCOND, oc, AMAX, om )
+ Uses signed element indexing AB[o+b*r+j*c], S[os+j*ss],
+ SCOND[oc], AMAX[om] relative to the intrinsic typed-array views.
+ Active offsets are nonnegative safe integers; full views fit and
+ are injective with exact products/corners/byte sums. Used zero
+ strides and overlapping conservative envelopes are rejected.
+ On N=0 only active scalars and their offsets are inspected.
+
+ Parameters
+ ----------
+ uplo: string|number
+ Upper (121) or lower (122).
+ N: integer
+ Matrix order in [0,2147483646].
+ KD: integer
+ Bandwidth in [0,2147483646].
+ AB: Float64Array
+ Read-only full compact band view.
+ r: integer
+ Band-row element stride.
+ c: integer
+ Matrix-column element stride.
+ o: integer
+ Band starting offset.
+ S: Float64Array
+ Output-only N-vector.
+ ss: integer
+ Scaling element stride.
+ os: integer
+ Scaling starting offset.
+ SCOND: Float64Array
+ Mutable scalar; retained on failure.
+ oc: integer
+ Active SCOND offset.
+ AMAX: Float64Array
+ Mutable maximum scalar.
+ om: integer
+ Active AMAX offset.
+
+ Returns
+ -------
+ info: number
+ Zero or first one-based nonpositive diagonal.
+
+ Examples
+ --------
+ > var A = new {{alias:@stdlib/array/float64}}( [ 4, -0, 16, 25 ] );
+ > var S = new {{alias:@stdlib/array/float64}}( 4 );
+ > var C = new {{alias:@stdlib/array/float64}}( [ -7 ] );
+ > var M = new {{alias:@stdlib/array/float64}}( 1 );
+ > {{alias}}.ndarray( 'lower', 4, 0, A, 1, 1, 0, S, 1, 0, C, 0, M, 0 )
+ 2
+ > S
+ [ 4, -0, 16, 25 ]
+ > C
+ [ -7 ]
+ > M
+ [ 25 ]
+
+ See Also
+ --------
diff --git a/lib/node_modules/@stdlib/lapack/base/dpbequ/docs/types/index.d.ts b/lib/node_modules/@stdlib/lapack/base/dpbequ/docs/types/index.d.ts
new file mode 100644
index 000000000000..8daa5f3c8e44
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dpbequ/docs/types/index.d.ts
@@ -0,0 +1,125 @@
+/**
+* @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 { Layout, MatrixTriangle } from '@stdlib/types/blas';
+
+/**
+* Interface describing `dpbequ`.
+*/
+interface Routine {
+ /**
+ * Computes diagonal scaling for a symmetric band matrix.
+ *
+ * ## Notes
+ *
+ * - Full compact AB is (KD+1)-by-N; upper diagonal row KD, lower row zero. KD>=N is supported.
+ * - Selected diagonals must be finite before writes; ignored entries may be nonfinite.
+ * - INFO=0 writes scaling S, SCOND and AMAX. Positive INFO copies every original diagonal into S and writes full AMAX, retaining SCOND's exact sentinel.
+ * - The first nonpositive diagonal gives one-based INFO; strict comparisons preserve the first tied zero sign, differing from sampled reference AMAX failures.
+ * - Active intrinsic Float64Array views require current ordinary backing, stable exclusive lifetime and pairwise disjoint conservative indexed byte envelopes.
+ * - RAB current valid extents are supported; shared/proxy/detached/OOB views are rejected. Hidden foreign physical aliases remain a caller precondition in pure JS.
+ * - Empty calls validate only active disjoint scalar cells after required selectors/dimensions/main LDAB, then write SCOND=1 and AMAX=+0; inactive AB/S metadata is ignored.
+ * - Types cannot express finite values, geometry, lifetime, alias, exact arithmetic or configured native-domain constraints.
+ *
+ * @param order - row-major (101) or column-major (102) layout
+ * @param uplo - upper (121) or lower (122) triangle
+ * @param N - matrix order, integer in [0,2147483646]
+ * @param KD - bandwidth, integer in [0,2147483646]
+ * @param AB - read-only full compact band view
+ * @param LDAB - leading dimension, >=KD+1 column-major or >=max(1,N) row-major
+ * @param S - output-only N-vector
+ * @param SCOND - mutable scalar output at index zero, retained on failure
+ * @param AMAX - mutable maximum output at index zero
+ * @throws invalid selectors, storage or runtime domain
+ * @returns numeric INFO, zero or the first one-based nonpositive diagonal
+ *
+ * @example
+ * var Float64Array = require( '@stdlib/array/float64' );
+ *
+ * var AB = new Float64Array( [ 4.0, 16.0, 64.0 ] );
+ * var S = new Float64Array( 3 );
+ * var SCOND = new Float64Array( 1 );
+ * var AMAX = new Float64Array( 1 );
+ * var info = dpbequ( 'column-major', 'lower', 3, 0, AB, 1, S, SCOND, AMAX );
+ * // returns 0
+ * // S => [ 0.5, 0.25, 0.125 ]
+ * // SCOND => [ 0.25 ]
+ * // AMAX => [ 64 ]
+ */
+ ( order: Layout | 101 | 102, uplo: MatrixTriangle | 121 | 122, N: number, KD: number, AB: Float64Array, LDAB: number, S: Float64Array, SCOND: Float64Array, AMAX: Float64Array ): number;
+
+ /**
+ * Computes diagonal scaling for a symmetric band matrix with alternative indexing.
+ *
+ * ## Notes
+ *
+ * - Full compact AB is (KD+1)-by-N; upper diagonal row KD, lower row zero. KD>=N is supported.
+ * - Selected diagonals must be finite before writes; ignored entries may be nonfinite.
+ * - INFO=0 writes scaling S, SCOND and AMAX. Positive INFO copies every original diagonal into S and writes full AMAX, retaining SCOND's exact sentinel.
+ * - The first nonpositive diagonal gives one-based INFO; strict comparisons preserve the first tied zero sign, differing from sampled reference AMAX failures.
+ * - Active intrinsic Float64Array views require current ordinary backing, stable exclusive lifetime and pairwise disjoint conservative indexed byte envelopes.
+ * - RAB current valid extents are supported; shared/proxy/detached/OOB views are rejected. Hidden foreign physical aliases remain a caller precondition in pure JS.
+ * - Empty calls validate only active disjoint scalar cells after required selectors/dimensions/main LDAB, then write SCOND=1 and AMAX=+0; inactive AB/S metadata is ignored.
+ * - Types cannot express finite values, geometry, lifetime, alias, exact arithmetic or configured native-domain constraints.
+ *
+ * @param uplo - upper (121) or lower (122) triangle
+ * @param N - matrix order, integer in [0,2147483646]
+ * @param KD - bandwidth, integer in [0,2147483646]
+ * @param AB - read-only full compact band view
+ * @param strideAB1 - band-row element stride
+ * @param strideAB2 - matrix-column element stride
+ * @param offsetAB - band starting element offset
+ * @param S - output-only N-vector
+ * @param strideS - output-vector element stride
+ * @param offsetS - output-vector starting offset
+ * @param SCOND - mutable scalar output, retained on failure
+ * @param offsetSCOND - active SCOND scalar offset
+ * @param AMAX - mutable maximum output
+ * @param offsetAMAX - active AMAX scalar offset
+ * @throws invalid selectors, storage or runtime domain
+ * @returns numeric INFO, zero or the first one-based nonpositive diagonal
+ *
+ * @example
+ * var Float64Array = require( '@stdlib/array/float64' );
+ *
+ * var AB = new Float64Array( [ 4.0, -0.0, 16.0, 25.0 ] );
+ * var S = new Float64Array( 4 );
+ * var SCOND = new Float64Array( [ -7.0 ] );
+ * var AMAX = new Float64Array( 1 );
+ * var info = dpbequ.ndarray( 'lower', 4, 0, AB, 1, 1, 0, S, 1, 0, SCOND, 0, AMAX, 0 );
+ * // returns 2
+ * // S => [ 4, -0, 16, 25 ]
+ * // SCOND => [ -7 ]
+ * // AMAX => [ 25 ]
+ */
+ ndarray( uplo: MatrixTriangle | 121 | 122, N: number, KD: number, AB: Float64Array, strideAB1: number, strideAB2: number, offsetAB: number, S: Float64Array, strideS: number, offsetS: number, SCOND: Float64Array, offsetSCOND: number, AMAX: Float64Array, offsetAMAX: number ): number;
+}
+
+/**
+* Computes diagonal scaling factors for a symmetric band matrix.
+*/
+declare var dpbequ: Routine;
+
+
+// EXPORTS //
+
+export = dpbequ;
diff --git a/lib/node_modules/@stdlib/lapack/base/dpbequ/docs/types/test.ts b/lib/node_modules/@stdlib/lapack/base/dpbequ/docs/types/test.ts
new file mode 100644
index 000000000000..fc3d5827a5bd
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dpbequ/docs/types/test.ts
@@ -0,0 +1,96 @@
+/**
+* @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 dpbequ = require( './index' );
+
+var AB = new Float64Array( 6 );
+var S = new Float64Array( 3 );
+var SCOND = new Float64Array( 1 );
+var AMAX = new Float64Array( 1 );
+
+dpbequ( 'row-major', 'upper', 3, 1, AB, 3, S, SCOND, AMAX ); // $ExpectType number
+dpbequ( 'row-major', 'lower', 3, 1, AB, 3, S, SCOND, AMAX ); // $ExpectType number
+dpbequ( 'row-major', 121, 3, 1, AB, 3, S, SCOND, AMAX ); // $ExpectType number
+dpbequ( 'row-major', 122, 3, 1, AB, 3, S, SCOND, AMAX ); // $ExpectType number
+dpbequ( 'column-major', 'upper', 3, 1, AB, 3, S, SCOND, AMAX ); // $ExpectType number
+dpbequ( 'column-major', 'lower', 3, 1, AB, 3, S, SCOND, AMAX ); // $ExpectType number
+dpbequ( 'column-major', 121, 3, 1, AB, 3, S, SCOND, AMAX ); // $ExpectType number
+dpbequ( 'column-major', 122, 3, 1, AB, 3, S, SCOND, AMAX ); // $ExpectType number
+dpbequ( 101, 'upper', 3, 1, AB, 3, S, SCOND, AMAX ); // $ExpectType number
+dpbequ( 101, 'lower', 3, 1, AB, 3, S, SCOND, AMAX ); // $ExpectType number
+dpbequ( 101, 121, 3, 1, AB, 3, S, SCOND, AMAX ); // $ExpectType number
+dpbequ( 101, 122, 3, 1, AB, 3, S, SCOND, AMAX ); // $ExpectType number
+dpbequ( 102, 'upper', 3, 1, AB, 3, S, SCOND, AMAX ); // $ExpectType number
+dpbequ( 102, 'lower', 3, 1, AB, 3, S, SCOND, AMAX ); // $ExpectType number
+dpbequ( 102, 121, 3, 1, AB, 3, S, SCOND, AMAX ); // $ExpectType number
+dpbequ( 102, 122, 3, 1, AB, 3, S, SCOND, AMAX ); // $ExpectType number
+dpbequ.ndarray( 'upper', 3, 1, AB, 3, 1, 0, S, 1, 0, SCOND, 0, AMAX, 0 ); // $ExpectType number
+dpbequ.ndarray( 'lower', 3, 1, AB, 3, 1, 0, S, 1, 0, SCOND, 0, AMAX, 0 ); // $ExpectType number
+dpbequ.ndarray( 121, 3, 1, AB, 3, 1, 0, S, 1, 0, SCOND, 0, AMAX, 0 ); // $ExpectType number
+dpbequ.ndarray( 122, 3, 1, AB, 3, 1, 0, S, 1, 0, SCOND, 0, AMAX, 0 ); // $ExpectType number
+
+dpbequ( ); // $ExpectError
+dpbequ( 'row-major' ); // $ExpectError
+dpbequ( 'row-major', 'lower' ); // $ExpectError
+dpbequ( 'row-major', 'lower', 3 ); // $ExpectError
+dpbequ( 'row-major', 'lower', 3, 1 ); // $ExpectError
+dpbequ( 'row-major', 'lower', 3, 1, AB ); // $ExpectError
+dpbequ( 'row-major', 'lower', 3, 1, AB, 3 ); // $ExpectError
+dpbequ( 'row-major', 'lower', 3, 1, AB, 3, S ); // $ExpectError
+dpbequ( 'row-major', 'lower', 3, 1, AB, 3, S, SCOND ); // $ExpectError
+dpbequ( 'row-major', 'lower', 3, 1, AB, 3, S, SCOND, AMAX, 0 ); // $ExpectError
+dpbequ( 'invalid', 'lower', 3, 1, AB, 3, S, SCOND, AMAX ); // $ExpectError
+dpbequ( 'row-major', 'invalid', 3, 1, AB, 3, S, SCOND, AMAX ); // $ExpectError
+dpbequ( 'row-major', 'lower', 'invalid', 1, AB, 3, S, SCOND, AMAX ); // $ExpectError
+dpbequ( 'row-major', 'lower', 3, 'invalid', AB, 3, S, SCOND, AMAX ); // $ExpectError
+dpbequ( 'row-major', 'lower', 3, 1, 'invalid', 3, S, SCOND, AMAX ); // $ExpectError
+dpbequ( 'row-major', 'lower', 3, 1, AB, 'invalid', S, SCOND, AMAX ); // $ExpectError
+dpbequ( 'row-major', 'lower', 3, 1, AB, 3, 'invalid', SCOND, AMAX ); // $ExpectError
+dpbequ( 'row-major', 'lower', 3, 1, AB, 3, S, 'invalid', AMAX ); // $ExpectError
+dpbequ( 'row-major', 'lower', 3, 1, AB, 3, S, SCOND, 'invalid' ); // $ExpectError
+dpbequ.ndarray( ); // $ExpectError
+dpbequ.ndarray( 'lower' ); // $ExpectError
+dpbequ.ndarray( 'lower', 3 ); // $ExpectError
+dpbequ.ndarray( 'lower', 3, 1 ); // $ExpectError
+dpbequ.ndarray( 'lower', 3, 1, AB ); // $ExpectError
+dpbequ.ndarray( 'lower', 3, 1, AB, 3 ); // $ExpectError
+dpbequ.ndarray( 'lower', 3, 1, AB, 3, 1 ); // $ExpectError
+dpbequ.ndarray( 'lower', 3, 1, AB, 3, 1, 0 ); // $ExpectError
+dpbequ.ndarray( 'lower', 3, 1, AB, 3, 1, 0, S ); // $ExpectError
+dpbequ.ndarray( 'lower', 3, 1, AB, 3, 1, 0, S, 1 ); // $ExpectError
+dpbequ.ndarray( 'lower', 3, 1, AB, 3, 1, 0, S, 1, 0 ); // $ExpectError
+dpbequ.ndarray( 'lower', 3, 1, AB, 3, 1, 0, S, 1, 0, SCOND ); // $ExpectError
+dpbequ.ndarray( 'lower', 3, 1, AB, 3, 1, 0, S, 1, 0, SCOND, 0 ); // $ExpectError
+dpbequ.ndarray( 'lower', 3, 1, AB, 3, 1, 0, S, 1, 0, SCOND, 0, AMAX ); // $ExpectError
+dpbequ.ndarray( 'lower', 3, 1, AB, 3, 1, 0, S, 1, 0, SCOND, 0, AMAX, 0, 0 ); // $ExpectError
+dpbequ.ndarray( 'invalid', 3, 1, AB, 3, 1, 0, S, 1, 0, SCOND, 0, AMAX, 0 ); // $ExpectError
+dpbequ.ndarray( 'lower', 'invalid', 1, AB, 3, 1, 0, S, 1, 0, SCOND, 0, AMAX, 0 ); // $ExpectError
+dpbequ.ndarray( 'lower', 3, 'invalid', AB, 3, 1, 0, S, 1, 0, SCOND, 0, AMAX, 0 ); // $ExpectError
+dpbequ.ndarray( 'lower', 3, 1, 'invalid', 3, 1, 0, S, 1, 0, SCOND, 0, AMAX, 0 ); // $ExpectError
+dpbequ.ndarray( 'lower', 3, 1, AB, 'invalid', 1, 0, S, 1, 0, SCOND, 0, AMAX, 0 ); // $ExpectError
+dpbequ.ndarray( 'lower', 3, 1, AB, 3, 'invalid', 0, S, 1, 0, SCOND, 0, AMAX, 0 ); // $ExpectError
+dpbequ.ndarray( 'lower', 3, 1, AB, 3, 1, 'invalid', S, 1, 0, SCOND, 0, AMAX, 0 ); // $ExpectError
+dpbequ.ndarray( 'lower', 3, 1, AB, 3, 1, 0, 'invalid', 1, 0, SCOND, 0, AMAX, 0 ); // $ExpectError
+dpbequ.ndarray( 'lower', 3, 1, AB, 3, 1, 0, S, 'invalid', 0, SCOND, 0, AMAX, 0 ); // $ExpectError
+dpbequ.ndarray( 'lower', 3, 1, AB, 3, 1, 0, S, 1, 'invalid', SCOND, 0, AMAX, 0 ); // $ExpectError
+dpbequ.ndarray( 'lower', 3, 1, AB, 3, 1, 0, S, 1, 0, 'invalid', 0, AMAX, 0 ); // $ExpectError
+dpbequ.ndarray( 'lower', 3, 1, AB, 3, 1, 0, S, 1, 0, SCOND, 'invalid', AMAX, 0 ); // $ExpectError
+dpbequ.ndarray( 'lower', 3, 1, AB, 3, 1, 0, S, 1, 0, SCOND, 0, 'invalid', 0 ); // $ExpectError
+dpbequ.ndarray( 'lower', 3, 1, AB, 3, 1, 0, S, 1, 0, SCOND, 0, AMAX, 'invalid' ); // $ExpectError
+dpbequ( 'row-major', 0, 3, 1, AB, 3, S, SCOND, AMAX ); // $ExpectError
+dpbequ.ndarray( 0, 3, 1, AB, 3, 1, 0, S, 1, 0, SCOND, 0, AMAX, 0 ); // $ExpectError
diff --git a/lib/node_modules/@stdlib/lapack/base/dpbequ/examples/c/Makefile b/lib/node_modules/@stdlib/lapack/base/dpbequ/examples/c/Makefile
new file mode 100644
index 000000000000..c8f8e9a1517b
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dpbequ/examples/c/Makefile
@@ -0,0 +1,146 @@
+#/
+# @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.
+#/
+
+# VARIABLES #
+
+ifndef VERBOSE
+ QUIET := @
+else
+ QUIET :=
+endif
+
+# Determine the OS ([1][1], [2][2]).
+#
+# [1]: https://en.wikipedia.org/wiki/Uname#Examples
+# [2]: http://stackoverflow.com/a/27776822/2225624
+OS ?= $(shell uname)
+ifneq (, $(findstring MINGW,$(OS)))
+ OS := WINNT
+else
+ifneq (, $(findstring MSYS,$(OS)))
+ OS := WINNT
+else
+ifneq (, $(findstring CYGWIN,$(OS)))
+ OS := WINNT
+else
+ifneq (, $(findstring Windows_NT,$(OS)))
+ OS := WINNT
+endif
+endif
+endif
+endif
+
+# Define the program used for compiling C source files:
+ifdef C_COMPILER
+ CC := $(C_COMPILER)
+else
+ CC := gcc
+endif
+
+# Define the command-line options when compiling C files:
+CFLAGS ?= \
+ -std=c99 \
+ -O3 \
+ -Wall \
+ -pedantic
+
+# Determine whether to generate position independent code ([1][1], [2][2]).
+#
+# [1]: https://gcc.gnu.org/onlinedocs/gcc/Code-Gen-Options.html#Code-Gen-Options
+# [2]: http://stackoverflow.com/questions/5311515/gcc-fpic-option
+ifeq ($(OS), WINNT)
+ fPIC ?=
+else
+ fPIC ?= -fPIC
+endif
+
+# List of includes (e.g., `-I /foo/bar -I /beep/boop/include`):
+INCLUDE ?=
+
+# List of source files:
+SOURCE_FILES ?=
+
+# List of libraries (e.g., `-lopenblas -lpthread`):
+LIBRARIES ?=
+
+# List of library paths (e.g., `-L /foo/bar -L /beep/boop`):
+LIBPATH ?=
+
+# List of C targets:
+c_targets := example.out
+
+
+# RULES #
+
+#/
+# Compiles source files.
+#
+# @param {string} [C_COMPILER] - C compiler (e.g., `gcc`)
+# @param {string} [CFLAGS] - C compiler options
+# @param {(string|void)} [fPIC] - compiler flag determining whether to generate position independent code (e.g., `-fPIC`)
+# @param {string} [INCLUDE] - list of includes (e.g., `-I /foo/bar -I /beep/boop/include`)
+# @param {string} [SOURCE_FILES] - list of source files
+# @param {string} [LIBPATH] - list of library paths (e.g., `-L /foo/bar -L /beep/boop`)
+# @param {string} [LIBRARIES] - list of libraries (e.g., `-lopenblas -lpthread`)
+#
+# @example
+# make
+#
+# @example
+# make all
+#/
+all: $(c_targets)
+
+.PHONY: all
+
+#/
+# Compiles C source files.
+#
+# @private
+# @param {string} CC - C compiler (e.g., `gcc`)
+# @param {string} CFLAGS - C compiler options
+# @param {(string|void)} fPIC - compiler flag determining whether to generate position independent code (e.g., `-fPIC`)
+# @param {string} INCLUDE - list of includes (e.g., `-I /foo/bar`)
+# @param {string} SOURCE_FILES - list of source files
+# @param {string} LIBPATH - list of library paths (e.g., `-L /foo/bar`)
+# @param {string} LIBRARIES - list of libraries (e.g., `-lopenblas`)
+#/
+$(c_targets): %.out: %.c
+ $(QUIET) $(CC) $(CFLAGS) $(fPIC) $(INCLUDE) -o $@ $(SOURCE_FILES) $< $(LIBPATH) -lm $(LIBRARIES)
+
+#/
+# Runs compiled examples.
+#
+# @example
+# make run
+#/
+run: $(c_targets)
+ $(QUIET) ./$<
+
+.PHONY: run
+
+#/
+# Removes generated files.
+#
+# @example
+# make clean
+#/
+clean:
+ $(QUIET) -rm -f *.o *.out
+
+.PHONY: clean
diff --git a/lib/node_modules/@stdlib/lapack/base/dpbequ/examples/c/example.c b/lib/node_modules/@stdlib/lapack/base/dpbequ/examples/c/example.c
new file mode 100644
index 000000000000..0d09058641b5
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dpbequ/examples/c/example.c
@@ -0,0 +1,79 @@
+/**
+* @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.
+*/
+
+
+#include "stdlib/lapack/base/dpbequ.h"
+#include "stdlib/lapack/base/shared.h"
+#include
+#include
+#include
+#include
+
+/**
+* Main execution sequence.
+*/
+int main( void ) {
+ const double AB[] = { 4.0, 16.0, 64.0, NAN, INFINITY, 999.0 };
+ double before[ 6 ];
+ const double B[] = { 8.0, 64.0, 999.0, 16.0, 999.0, 4.0, 999.0, 8.0 };
+ double T[] = { 7.0, 7.0, 7.0, 7.0, 7.0 };
+ double C[] = { 7.0, -7.0, 7.0 };
+ double M[] = { 7.0, -9.0, 7.0 };
+ const double F[] = { 4.0, -0.0, 16.0, 25.0 };
+ const double Z[] = { -0.0, 0.0 };
+ double S[ 4 ] = { 0.0, 0.0, 0.0, 0.0 };
+ double sc = -0.0;
+ double am = -9.0;
+ LAPACK_INT info;
+
+ memcpy( before, AB, sizeof AB );
+ info = API_SUFFIX(c_dpbequ)( LAPACK_ROW_MAJOR, LAPACK_LOWER_TRIANGLE, 3, 1, AB, 3, S, &sc, &am );
+ if ( info != 0 || S[ 0 ] != 0.5 || S[ 1 ] != 0.25 || S[ 2 ] != 0.125 || sc != 0.25 || am != 64.0 || memcmp( before, AB, sizeof AB ) != 0 ) {
+ return EXIT_FAILURE;
+ }
+ if ( S[ 0 ]*S[ 0 ]*AB[ 0 ] != 1.0 || S[ 1 ]*S[ 1 ]*AB[ 1 ] != 1.0 || S[ 2 ]*S[ 2 ]*AB[ 2 ] != 1.0 ) {
+ return EXIT_FAILURE;
+ }
+ printf( "INFO: %d; SCOND: %.2f; AMAX: %.1f\n", (int)info, sc, am );
+
+ info = API_SUFFIX(c_dpbequ_ndarray)( LAPACK_UPPER_TRIANGLE, 3, 1, B, 1, -2, 4, T, -1, 3, C, 1, M, 1 );
+ if ( info != 0 || T[ 0 ] != 7.0 || T[ 1 ] != 0.125 || T[ 2 ] != 0.25 || T[ 3 ] != 0.5 || T[ 4 ] != 7.0 || C[ 0 ] != 7.0 || C[ 1 ] != 0.25 || C[ 2 ] != 7.0 || M[ 0 ] != 7.0 || M[ 1 ] != 64.0 || M[ 2 ] != 7.0 ) {
+ return EXIT_FAILURE;
+ }
+ printf( "Strided INFO: %d; guarded S: %.3f, %.2f, %.1f\n", (int)info, T[ 1 ], T[ 2 ], T[ 3 ] );
+
+ sc = -0.0;
+ info = API_SUFFIX(c_dpbequ)( LAPACK_COL_MAJOR, LAPACK_LOWER_TRIANGLE, 4, 0, F, 1, S, &sc, &am );
+ if ( info != 2 || S[ 0 ] != 4.0 || S[ 1 ] != 0.0 || !signbit(S[ 1 ]) || S[ 2 ] != 16.0 || S[ 3 ] != 25.0 || sc != 0.0 || !signbit(sc) || am != 25.0 ) {
+ return EXIT_FAILURE;
+ }
+ printf( "Failure INFO: %d; later-column AMAX: %.1f\n", (int)info, am );
+
+ info = API_SUFFIX(c_dpbequ)( LAPACK_ROW_MAJOR, LAPACK_LOWER_TRIANGLE, 2, 0, Z, 2, S, &sc, &am );
+ if ( info != 1 || am != 0.0 || !signbit(am) || sc != 0.0 || !signbit(sc) ) {
+ return EXIT_FAILURE;
+ }
+ printf( "Mixed-zero INFO: %d; first AMAX sign retained\n", (int)info );
+
+ info = API_SUFFIX(c_dpbequ)( LAPACK_COL_MAJOR, LAPACK_UPPER_TRIANGLE, 0, 2, NULL, 3, NULL, &sc, &am );
+ if ( info != 0 || sc != 1.0 || am != 0.0 || signbit(am) ) {
+ return EXIT_FAILURE;
+ }
+ printf( "Empty INFO: %d; SCOND: %.1f; AMAX: %.1f\n", (int)info, sc, am );
+ return EXIT_SUCCESS;
+}
diff --git a/lib/node_modules/@stdlib/lapack/base/dpbequ/examples/index.js b/lib/node_modules/@stdlib/lapack/base/dpbequ/examples/index.js
new file mode 100644
index 000000000000..24da8dbdbccd
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dpbequ/examples/index.js
@@ -0,0 +1,85 @@
+/**
+* @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 assert = require( 'assert' );
+var Float64Array = require( '@stdlib/array/float64' );
+var dpbequ = require( './../lib' );
+
+
+// MAIN //
+
+// Only selected diagonals are read; ignored band entries may be nonfinite:
+var AB = new Float64Array( [ 4.0, 16.0, 64.0, NaN, Infinity, 999.0 ] );
+var S = new Float64Array( 3 );
+var SCOND = new Float64Array( [ -7.0 ] );
+var AMAX = new Float64Array( [ -9.0 ] );
+var info = dpbequ( 'row-major', 'lower', 3, 1, AB, 3, S, SCOND, AMAX );
+assert.strictEqual( info, 0 );
+assert.strictEqual( Array.prototype.join.call( S, ',' ), '0.5,0.25,0.125' );
+assert.strictEqual( SCOND[ 0 ], 0.25 );
+assert.strictEqual( AMAX[ 0 ], 64.0 );
+assert.strictEqual( S[ 0 ]*S[ 0 ]*AB[ 0 ], 1.0 );
+assert.strictEqual( S[ 1 ]*S[ 1 ]*AB[ 1 ], 1.0 );
+assert.strictEqual( S[ 2 ]*S[ 2 ]*AB[ 2 ], 1.0 );
+console.log( 'INFO: %d; S: %s; SCOND: %d; AMAX: %d', info, Array.prototype.join.call( S, ', ' ), SCOND[ 0 ], AMAX[ 0 ] );
+
+// Signed band/output strides and scalar offsets retain all guards:
+AB = new Float64Array( [ 8.0, 64.0, 999.0, 16.0, 999.0, 4.0, 999.0, 8.0 ] );
+S = new Float64Array( [ 7.0, 7.0, 7.0, 7.0, 7.0 ] );
+SCOND = new Float64Array( [ 7.0, -7.0, 7.0 ] );
+AMAX = new Float64Array( [ 7.0, -9.0, 7.0 ] );
+info = dpbequ.ndarray( 'upper', 3, 1, AB, 1, -2, 4, S, -1, 3, SCOND, 1, AMAX, 1 );
+assert.strictEqual( info, 0 );
+assert.strictEqual( Array.prototype.join.call( S, ',' ), '7,0.125,0.25,0.5,7' );
+assert.strictEqual( Array.prototype.join.call( SCOND, ',' ), '7,0.25,7' );
+assert.strictEqual( Array.prototype.join.call( AMAX, ',' ), '7,64,7' );
+assert.strictEqual( Array.prototype.join.call( AB, ',' ), '8,64,999,16,999,4,999,8' );
+console.log( 'Strided INFO: %d; guarded S: %s', info, Array.prototype.join.call( S, ', ' ) );
+
+// Failure copies every diagonal and finds AMAX even in later columns:
+AB = new Float64Array( [ 4.0, -0.0, 16.0, 25.0 ] );
+S = new Float64Array( 4 );
+SCOND = new Float64Array( [ -0.0 ] );
+AMAX = new Float64Array( [ -9.0 ] );
+info = dpbequ( 'column-major', 'lower', 4, 0, AB, 1, S, SCOND, AMAX );
+assert.strictEqual( info, 2 );
+assert.strictEqual( Array.prototype.join.call( S, ',' ), '4,0,16,25' );
+assert.strictEqual( 1/S[ 1 ], -Infinity );
+assert.strictEqual( 1/SCOND[ 0 ], -Infinity );
+assert.strictEqual( AMAX[ 0 ], 25.0 );
+console.log( 'Failure INFO: %d; copied S: %s; AMAX: %d', info, Array.prototype.join.call( S, ', ' ), AMAX[ 0 ] );
+
+// Strict-first AMAX preserves the first tied zero sign on failure:
+AB = new Float64Array( [ -0.0, 0.0 ] );
+S = new Float64Array( 2 );
+info = dpbequ( 'row-major', 'lower', 2, 0, AB, 2, S, SCOND, AMAX );
+assert.strictEqual( info, 1 );
+assert.strictEqual( 1/AMAX[ 0 ], -Infinity );
+assert.strictEqual( 1/SCOND[ 0 ], -Infinity );
+console.log( 'Mixed-zero INFO: %d; first AMAX sign: %d', info, 1/AMAX[ 0 ] );
+
+// Empty input ignores AB/S but validates and writes both active scalars:
+info = dpbequ( 'column-major', 'upper', 0, 2, null, 3, null, SCOND, AMAX );
+assert.strictEqual( info, 0 );
+assert.strictEqual( SCOND[ 0 ], 1.0 );
+assert.strictEqual( 1/AMAX[ 0 ], Infinity );
+console.log( 'Empty INFO: %d; SCOND: %d; AMAX: %d', info, SCOND[ 0 ], AMAX[ 0 ] );
diff --git a/lib/node_modules/@stdlib/lapack/base/dpbequ/include.gypi b/lib/node_modules/@stdlib/lapack/base/dpbequ/include.gypi
new file mode 100644
index 000000000000..dcb556d250e8
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dpbequ/include.gypi
@@ -0,0 +1,70 @@
+# @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.
+
+# A GYP include file for building a Node.js native add-on.
+#
+# Note that nesting variables is required due to how GYP processes a configuration. Any variables defined within a nested 'variables' section is defined in the outer scope. Thus, conditions in the outer variable scope are free to use these variables without running into "variable undefined" errors.
+#
+# Main documentation:
+#
+# [1]: https://gyp.gsrc.io/docs/InputFormatReference.md
+# [2]: https://gyp.gsrc.io/docs/UserDocumentation.md
+#
+# Variable nesting hacks:
+#
+# [3]: https://chromium.googlesource.com/external/skia/gyp/+/master/common_variables.gypi
+# [4]: https://src.chromium.org/viewvc/chrome/trunk/src/build/common.gypi?revision=127004
+{
+ # Define variables to be used throughout the configuration for all targets:
+ 'variables': {
+ 'variables': {
+ # Host BLAS library (to override -Dblas=):
+ 'blas%': '',
+
+ # Path to BLAS library (to override -Dblas_dir=):
+ 'blas_dir%': '',
+ }, # end variables
+
+ # Source directory:
+ 'src_dir': './src',
+
+ # Include directories:
+ 'include_dirs': [
+ '<@(blas_dir)',
+ '= KD+1; row-major LDAB >= max(1,N). Only finite selected
+* diagonal entries are supported; ignored cells may be nonfinite.
+* Positive diagonals produce S[i]=1/sqrt(diagonal[i]),
+* SCOND=sqrt(min(diagonal))/sqrt(max(diagonal)), and AMAX=max(diagonal).
+* For a nonpositive diagonal, INFO is its first one-based index, every
+* original diagonal is copied into S, AMAX includes all columns, and
+* SCOND retains its caller sentinel. Strict comparisons preserve the
+* first tied extremum's zero sign, differing from sampled GNU reference
+* AMAX failure reductions. No universal signed-zero parity is claimed.
+*
+* Configured N/KD must lie in [0,MAX-1]. Negative argument positions
+* identify a prewrite validation error: order -1, uplo -2, N -3,
+* KD -4, AB geometry/alias/nonfinite -5, LDAB -6, S -7, SCOND -8,
+* AMAX or SCOND/AMAX overlap -9. For N=0, required scalar/layout/LDAB
+* validation precedes writes of SCOND=1 and AMAX=+0; AB/S are ignored.
+*
+* Active conservative band/vector/scalar indexed byte envelopes must
+* be pairwise disjoint, even if only a diagonal is numerically read.
+* Capacity, double alignment and stable exclusive lifetime are caller
+* preconditions. No numerical BLAS dependency or workspace is required.
+*/
+LAPACK_INT API_SUFFIX(c_dpbequ)( const LAPACK_LAYOUT order, const int uplo, const LAPACK_INT N, const LAPACK_INT KD, const double *AB, const LAPACK_INT LDAB, double *S, double *SCOND, double *AMAX );
+
+/**
+* Computes band-matrix scaling factors using alternative indexing.
+*
+* AB is indexed by offsetAB+i*strideAB1+j*strideAB2 over the complete
+* (KD+1)-by-N band; S by offsetS+j*strideS. Active scalar cells are
+* SCOND[offsetSCOND] and AMAX[offsetAMAX]. Used strides are nonzero;
+* products, index corners, byte envelopes and band injectivity validate
+* before any writes. Minimum configured integer strides are rejected
+* before negation even for singletons; other unused singleton strides
+* need not participate in arithmetic. Full physical envelopes must be
+* disjoint. Numeric and failure output semantics match c_dpbequ above.
+*
+* Negative positions: uplo -1, N -2, KD -3, AB null/alias/nonfinite -4,
+* strideAB1 -5, strideAB2/collision -6, offsetAB/envelope -7, S -8,
+* strideS -9, offsetS/envelope -10, SCOND null -11, offsetSCOND/envelope
+* -12, AMAX null/SCOND overlap -13, offsetAMAX/envelope -14. For N=0,
+* only uplo/N/KD and the disjoint active scalar cells validate; AB/S
+* and their inactive strides/offsets are ignored. Capacity, alignment
+* and stable exclusive lifetime remain caller preconditions.
+*/
+LAPACK_INT API_SUFFIX(c_dpbequ_ndarray)( const int uplo, const LAPACK_INT N, const LAPACK_INT KD, const double *AB, const LAPACK_INT strideAB1, const LAPACK_INT strideAB2, const LAPACK_INT offsetAB, double *S, const LAPACK_INT strideS, const LAPACK_INT offsetS, double *SCOND, const LAPACK_INT offsetSCOND, double *AMAX, const LAPACK_INT offsetAMAX );
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // !STDLIB_LAPACK_BASE_DPBEQU_H
diff --git a/lib/node_modules/@stdlib/lapack/base/dpbequ/lib/base.js b/lib/node_modules/@stdlib/lapack/base/dpbequ/lib/base.js
new file mode 100644
index 000000000000..35bbf13c131f
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dpbequ/lib/base.js
@@ -0,0 +1,138 @@
+/**
+* @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.
+*/
+/*
+ * Copyright (c) 1992-2025 The University of Tennessee and The University
+ * of Tennessee Research Foundation. All rights
+ * reserved.
+ * Copyright (c) 2000-2025 The University of California Berkeley. All
+ * rights reserved.
+ * Copyright (c) 2006-2025 The University of Colorado Denver. All rights
+ * reserved.
+ *
+ * $COPYRIGHT$
+ *
+ * Additional copyrights may follow
+ *
+ * $HEADER$
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ * - Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * - Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer listed
+ * in this license in the documentation and/or other materials
+ * provided with the distribution.
+ *
+ * - Neither the name of the copyright holders nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * The copyright holders provide no reassurances that the source code
+ * provided does not infringe any patent, copyright, or any other
+ * intellectual property rights of third parties. The copyright holders
+ * disclaim any liability to any recipient for claims brought against
+ * recipient by any third party for infringement of that parties
+ * intellectual property rights.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+'use strict';
+
+// MODULES //
+
+var sqrt = require( '@stdlib/math/base/special/sqrt' );
+
+
+// MAIN //
+
+/**
+* Computes scaling using already validated normalized views.
+* @private
+* @param {integer} uplo - numeric triangle
+* @param {NonNegativeInteger} N - order
+* @param {NonNegativeInteger} KD - bandwidth
+* @param {Float64Array} AB - band view
+* @param {integer} r - row stride
+* @param {integer} c - column stride
+* @param {integer} o - band offset
+* @param {Float64Array} S - vector output
+* @param {integer} ss - vector stride
+* @param {integer} os - vector offset
+* @param {Float64Array} SCOND - scalar output
+* @param {integer} oc - scalar offset
+* @param {Float64Array} AMAX - scalar output
+* @param {integer} om - scalar offset
+* @returns {integer} INFO
+*/
+function dpbequ( uplo, N, KD, AB, r, c, o, S, ss, os, SCOND, oc, AMAX, om ) { // eslint-disable-line max-params -- Preserve the adopted fourteen-argument ndarray contract.
+ var small;
+ var large;
+ var value;
+ var ai;
+ var j;
+ if ( N === 0 ) {
+ SCOND[oc] = 1;
+ AMAX[om] = 0;
+ return 0;
+ }
+ ai = o + ((uplo === 121) ? KD*r : 0);
+ small = AB[ai];
+ large = small;
+ for ( j = 0; j < N; j++ ) {
+ value = AB[ai+(j*c)];
+ S[os+(j*ss)] = value;
+ if ( value < small ) {
+ small = value;
+ }
+ if ( value > large ) {
+ large = value;
+ }
+ }
+ AMAX[om] = large;
+ if ( small <= 0 ) {
+ for ( j = 0; j < N; j++ ) {
+ if ( S[os+(j*ss)] <= 0 ) {
+ return j+1;
+ }
+ }
+ }
+ for ( j = 0; j < N; j++ ) {
+ S[os+(j*ss)] = 1 / sqrt( S[os+(j*ss)] );
+ }
+ SCOND[oc] = sqrt(small) / sqrt(large);
+ return 0;
+}
+
+
+// EXPORTS //
+
+module.exports = dpbequ;
diff --git a/lib/node_modules/@stdlib/lapack/base/dpbequ/lib/can_use_native.js b/lib/node_modules/@stdlib/lapack/base/dpbequ/lib/can_use_native.js
new file mode 100644
index 000000000000..f0459ed7fdea
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dpbequ/lib/can_use_native.js
@@ -0,0 +1,78 @@
+/**
+* @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 abs = require( '@stdlib/math/base/special/abs' );
+var min = require( '@stdlib/math/base/special/min' );
+var max = require( '@stdlib/math/base/special/max' );
+
+
+// MAIN //
+
+/**
+* Selects native only for conservative signed32 original metadata.
+* @private
+* @param {integer} uplo - numeric triangle
+* @param {NonNegativeInteger} N - order
+* @param {NonNegativeInteger} KD - bandwidth
+* @param {Float64Array} AB - band view
+* @param {integer} r - row stride
+* @param {integer} c - column stride
+* @param {integer} o - band offset
+* @param {Float64Array} S - vector output
+* @param {integer} ss - vector stride
+* @param {integer} os - vector offset
+* @param {Float64Array} SCOND - scalar output
+* @param {integer} oc - scalar offset
+* @param {Float64Array} AMAX - scalar output
+* @param {integer} om - scalar offset
+* @returns {boolean} eligibility
+*/
+function eligible( uplo, N, KD, AB, r, c, o, S, ss, os, SCOND, oc, AMAX, om ) { // eslint-disable-line max-params -- Preserve the adopted fourteen-argument ndarray contract.
+ var args = [ uplo, N, KD, r, c, o, ss, os, oc, om ];
+ var MAX = 2147483647;
+ var dr;
+ var dc;
+ var ds;
+ var i;
+ if ( N === 0 ) {
+ return ((oc <= MAX) && (om <= MAX));
+ }
+ for ( i = 0; i < args.length; i++ ) {
+ if ( abs(args[i]) > MAX ) {
+ return false;
+ }
+ }
+ if ( N === 0 ) {
+ return true;
+ }
+ dr = KD*r;
+ dc = (N-1)*c;
+ ds = (N-1)*ss;
+ if ( abs(dr) > MAX || abs(dc) > MAX || abs(ds) > MAX ) {
+ return false;
+ }
+ return o+min(dr, 0)+min(dc, 0) >= 0 && o+max(dr, 0)+max(dc, 0) <= MAX && os+min(ds, 0) >= 0 && os+max(ds, 0) <= MAX;
+}
+
+
+// EXPORTS //
+
+module.exports = eligible;
diff --git a/lib/node_modules/@stdlib/lapack/base/dpbequ/lib/factory.js b/lib/node_modules/@stdlib/lapack/base/dpbequ/lib/factory.js
new file mode 100644
index 000000000000..4dee36bed932
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dpbequ/lib/factory.js
@@ -0,0 +1,112 @@
+/**
+* @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 max = require( '@stdlib/math/base/special/max' );
+var isInteger = require( '@stdlib/assert/is-integer' ).isPrimitive;
+var setReadOnly = require( '@stdlib/utils/define-nonenumerable-read-only-property' );
+var validate = require( './validate.js' );
+
+
+// MAIN //
+
+/**
+* Creates a public validation contract around a normalized backend.
+* @private
+* @param {Function} backend - normalized backend
+* @param {Function} [eligible] - native eligibility
+* @param {Function} [fallback] - validated fallback
+* @returns {Function} public routine
+*/
+function factory( backend, eligible, fallback ) {
+ setReadOnly( dpbequ, 'ndarray', ndarray );
+ return dpbequ;
+
+ /**
+* Computes diagonal scaling from contiguous band storage.
+* @private
+* @param {string|integer} order - layout
+* @param {string|integer} uplo - triangle
+* @param {NonNegativeInteger} N - order
+* @param {NonNegativeInteger} KD - bandwidth
+* @param {Float64Array} AB - band storage
+* @param {PositiveInteger} LDAB - leading dimension
+* @param {Float64Array} S - scaling output
+* @param {Float64Array} SCOND - scalar output
+* @param {Float64Array} AMAX - scalar output
+* @throws {TypeError} invalid selector or storage
+* @throws {RangeError} invalid metadata or domain
+* @returns {integer} INFO
+*/
+ function dpbequ( order, uplo, N, KD, AB, LDAB, S, SCOND, AMAX ) {
+ var column;
+ var u;
+ if ( order !== 'row-major' && order !== 'column-major' && order !== 101 && order !== 102 ) {
+ throw new TypeError( 'invalid argument. Invalid layout.' );
+ }
+ u = validate.scalars( uplo, N, KD );
+ validate.integer( LDAB );
+ column = order === 'column-major' || order === 102;
+ if ( LDAB < ((column) ? KD+1 : max(1, N)) ) {
+ throw new RangeError( 'invalid argument. Invalid leading dimension.' );
+ }
+ return ndarray( u, N, KD, AB, (column) ? 1 : LDAB, (column) ? LDAB : 1, 0, S, 1, 0, SCOND, 0, AMAX, 0 );
+ }
+
+ /**
+* Computes diagonal scaling from signed injective band and output views.
+* @private
+* @param {string|integer} uplo - triangle
+* @param {NonNegativeInteger} N - order
+* @param {NonNegativeInteger} KD - bandwidth
+* @param {Float64Array} AB - band storage
+* @param {integer} r - row stride
+* @param {integer} c - column stride
+* @param {integer} o - band offset
+* @param {Float64Array} S - scaling output
+* @param {integer} ss - scaling stride
+* @param {integer} os - scaling offset
+* @param {Float64Array} SCOND - scalar output
+* @param {integer} oc - scalar offset
+* @param {Float64Array} AMAX - scalar output
+* @param {integer} om - scalar offset
+* @throws {TypeError} invalid selector or storage
+* @throws {RangeError} invalid metadata or domain
+* @returns {integer} INFO
+*/
+ function ndarray( uplo, N, KD, AB, r, c, o, S, ss, os, SCOND, oc, AMAX, om ) { // eslint-disable-line max-params -- Preserve the adopted fourteen-argument ndarray contract.
+ var info;
+ var use;
+ var u;
+ u = validate.scalars( uplo, N, KD );
+ validate( u, N, KD, AB, r, c, o, S, ss, os, SCOND, oc, AMAX, om );
+ use = (eligible && !eligible(u, N, KD, AB, r, c, o, S, ss, os, SCOND, oc, AMAX, om)) ? fallback : backend;
+ info = use( u, N, KD, AB, r, c, o, S, ss, os, SCOND, oc, AMAX, om );
+ if ( !isInteger(info) || info < 0 || info > N ) {
+ throw new RangeError( 'invalid argument. Private INFO is outside the scalar status domain.' );
+ }
+ return info;
+ }
+}
+
+
+// EXPORTS //
+
+module.exports = factory;
diff --git a/lib/node_modules/@stdlib/lapack/base/dpbequ/lib/index.js b/lib/node_modules/@stdlib/lapack/base/dpbequ/lib/index.js
new file mode 100644
index 000000000000..a36df112f95c
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dpbequ/lib/index.js
@@ -0,0 +1,36 @@
+/**
+* @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.
+*/
+/**
+* Compute diagonal scaling factors for a symmetric band matrix.
+* @module @stdlib/lapack/base/dpbequ
+*/
+'use strict';
+
+// MODULES //
+
+var resolve = require( 'path' ).resolve;
+var tryRequire = require( '@stdlib/utils/try-require' );
+var main = tryRequire( resolve(__dirname, './native.js') );
+if ( (main instanceof Error) ) {
+ main = require( './main.js' );
+}
+
+
+// EXPORTS //
+
+module.exports = main;
diff --git a/lib/node_modules/@stdlib/lapack/base/dpbequ/lib/main.js b/lib/node_modules/@stdlib/lapack/base/dpbequ/lib/main.js
new file mode 100644
index 000000000000..43aac2629129
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dpbequ/lib/main.js
@@ -0,0 +1,33 @@
+/**
+* @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 factory = require( './factory.js' );
+var base = require( './base.js' );
+
+
+// VARIABLES //
+
+var dpbequ = factory( base );
+
+
+// EXPORTS //
+
+module.exports = dpbequ;
diff --git a/lib/node_modules/@stdlib/lapack/base/dpbequ/lib/native.js b/lib/node_modules/@stdlib/lapack/base/dpbequ/lib/native.js
new file mode 100644
index 000000000000..d23737317e71
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dpbequ/lib/native.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 factory = require( './factory.js' );
+var base = require( './base.js' );
+var eligible = require( './can_use_native.js' );
+var addon = require( './../src/addon.node' );
+
+
+// VARIABLES //
+
+var dpbequ = factory( addon, eligible, base );
+
+
+// EXPORTS //
+
+module.exports = dpbequ;
diff --git a/lib/node_modules/@stdlib/lapack/base/dpbequ/lib/validate.js b/lib/node_modules/@stdlib/lapack/base/dpbequ/lib/validate.js
new file mode 100644
index 000000000000..20920eb0ffca
--- /dev/null
+++ b/lib/node_modules/@stdlib/lapack/base/dpbequ/lib/validate.js
@@ -0,0 +1,269 @@
+/**
+* @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 Symbol = require( '@stdlib/symbol/ctor' );
+var ArrayBuffer = require( '@stdlib/array/buffer' );
+var Float64Array = require( '@stdlib/array/float64' );
+var isSafeInteger = require( '@stdlib/assert/is-safe-integer' ).isPrimitive;
+var isFiniteNumber = require( '@stdlib/math/base/assert/is-finite' );
+var min = require( '@stdlib/math/base/special/min' );
+var max = require( '@stdlib/math/base/special/max' );
+var abs = require( '@stdlib/math/base/special/abs' );
+
+
+// VARIABLES //
+
+var MAX = 9007199254740991;
+var prototype = Object.getPrototypeOf( Float64Array.prototype );
+var tag = Object.getOwnPropertyDescriptor( prototype, Symbol.toStringTag ).get;
+var getLength = Object.getOwnPropertyDescriptor( prototype, 'length' ).get;
+var buffer = Object.getOwnPropertyDescriptor( prototype, 'buffer' ).get;
+var byteOffset = Object.getOwnPropertyDescriptor( prototype, 'byteOffset' ).get;
+var byteLength = Object.getOwnPropertyDescriptor( ArrayBuffer.prototype, 'byteLength' ).get;
+var values = prototype.values;
+
+
+// FUNCTIONS //
+
+/**
+* Validates exact primitive metadata.
+* @private
+* @param {number} value - metadata
+* @throws {RangeError} invalid metadata
+* @returns {integer} validated metadata
+*/
+function integer( value ) {
+ if ( !isSafeInteger( value ) ) {
+ throw new RangeError( 'invalid argument. Metadata must be primitive safe integers.' );
+ }
+ return value;
+}
+
+/**
+* Adds exact signed metadata before evaluating an oversized expression.
+* @private
+* @param {integer} x - first term
+* @param {integer} y - second term
+* @throws {RangeError} inexact sum
+* @returns {integer} exact sum
+*/
+function sum( x, y ) {
+ if ( ( y > 0 && x > MAX-y ) || ( y < 0 && x < -MAX-y ) ) {
+ throw new RangeError( 'invalid argument. Inexact indexed sum.' );
+ }
+ return x+y;
+}
+
+/**
+* Computes a checked product.
+* @private
+* @param {NonNegativeInteger} count - nonnegative count
+* @param {integer} stride - signed stride
+* @throws {RangeError} inexact product
+* @returns {integer} exact product
+*/
+function product( count, stride ) {
+ if ( count !== 0 && abs(stride) > MAX/count ) {
+ throw new RangeError( 'invalid argument. Inexact indexed product.' );
+ }
+ return integer( count*stride );
+}
+
+/**
+* Computes a greatest common divisor.
+* @private
+* @param {PositiveInteger} x - first value
+* @param {PositiveInteger} y - second value
+* @returns {PositiveInteger} divisor
+*/
+function gcd( x, y ) {
+ var z;
+ while ( y !== 0 ) {
+ z = x%y;
+ x = y;
+ y = z;
+ }
+ return x;
+}
+
+/**
+* Validates an intrinsic ordinary-backed full injective view.
+* @private
+* @param {Float64Array} x - input view
+* @param {PositiveInteger} h - logical rows
+* @param {PositiveInteger} n - logical columns
+* @param {integer} r - row stride
+* @param {integer} c - column stride
+* @param {integer} o - offset
+* @throws {TypeError} invalid brand or backing
+* @throws {RangeError} invalid geometry
+* @returns {Object} indexed byte envelope
+*/
+function view( x, h, n, r, c, o ) {
+ var first;
+ var data;
+ var size;
+ var last;
+ var lo;
+ var hi;
+ var dr;
+ var dc;
+ var g;
+ if ( tag.call(x) !== 'Float64Array' ) {
+ throw new TypeError( 'invalid argument. Must provide an intrinsic Float64Array.' );
+ }
+ values.call( x ); // Intrinsic detached and current out-of-bounds validation.
+ data = buffer.call( x );
+ size = byteLength.call( data ); // Rejects shared backing and tag spoofs.
+ integer( r );
+ integer( c );
+ integer( o );
+ if ( o < 0 || (h > 1 && r === 0) || (n > 1 && c === 0) ) {
+ throw new RangeError( 'invalid argument. Offsets must be nonnegative and active strides nonzero.' );
+ }
+ if ( h > 1 && n > 1 ) {
+ g = gcd( abs(r), abs(c) );
+ if ( abs(c)/g < h && abs(r)/g < n ) {
+ throw new RangeError( 'invalid argument. The full indexed view must be injective.' );
+ }
+ }
+ dr = product( h-1, r );
+ dc = product( n-1, c );
+ lo = sum( sum(o, min(dr, 0)), min(dc, 0) );
+ hi = sum( sum(o, max(dr, 0)), max(dc, 0) );
+ if ( lo < 0 || hi >= getLength.call(x) ) {
+ throw new RangeError( 'invalid argument. Indexed view exceeds the current intrinsic extent.' );
+ }
+ first = sum( byteOffset.call(x), product(lo, 8) );
+ last = sum( byteOffset.call(x), product(sum(hi, 1), 8) );
+ if ( last > size ) {
+ throw new RangeError( 'invalid argument. Indexed view exceeds current backing extent.' );
+ }
+ return {
+ 'buffer': data,
+ 'first': first,
+ 'last': last
+ };
+}
+
+/**
+* Rejects overlapping indexed envelopes before writes.
+* @private
+* @param {Array