diff --git a/lib/node_modules/@stdlib/blas/ext/base/docs/types/index.d.ts b/lib/node_modules/@stdlib/blas/ext/base/docs/types/index.d.ts
index 1bbf59a49253..3f5139cd2d6a 100644
--- a/lib/node_modules/@stdlib/blas/ext/base/docs/types/index.d.ts
+++ b/lib/node_modules/@stdlib/blas/ext/base/docs/types/index.d.ts
@@ -29,6 +29,7 @@ import cindexOf = require( '@stdlib/blas/ext/base/cindex-of' );
 import cindexOfColumn = require( '@stdlib/blas/ext/base/cindex-of-column' );
 import cindexOfRow = require( '@stdlib/blas/ext/base/cindex-of-row' );
 import clastIndexOfRow = require( '@stdlib/blas/ext/base/clast-index-of-row' );
+import clogspace = require( '@stdlib/blas/ext/base/clogspace' );
 import coneTo = require( '@stdlib/blas/ext/base/cone-to' );
 import creplicate = require( '@stdlib/blas/ext/base/creplicate' );
 import csum = require( '@stdlib/blas/ext/base/csum' );
@@ -140,6 +141,7 @@ import dwapx = require( '@stdlib/blas/ext/base/dwapx' );
 import dwax = require( '@stdlib/blas/ext/base/dwax' );
 import dwhere = require( '@stdlib/blas/ext/base/dwhere' );
 import dwxmy = require( '@stdlib/blas/ext/base/dwxmy' );
+import dwxpy = require( '@stdlib/blas/ext/base/dwxpy' );
 import dwxsa = require( '@stdlib/blas/ext/base/dwxsa' );
 import dxdy = require( '@stdlib/blas/ext/base/dxdy' );
 import dxmy = require( '@stdlib/blas/ext/base/dxmy' );
@@ -194,6 +196,7 @@ import gindexOfNotEqual = require( '@stdlib/blas/ext/base/gindex-of-not-equal' )
 import gindexOfRow = require( '@stdlib/blas/ext/base/gindex-of-row' );
 import gindexOfSameValue = require( '@stdlib/blas/ext/base/gindex-of-same-value' );
 import gindexOfTruthy = require( '@stdlib/blas/ext/base/gindex-of-truthy' );
+import gindexOfTruthyRow = require( '@stdlib/blas/ext/base/gindex-of-truthy-row' );
 import gjoin = require( '@stdlib/blas/ext/base/gjoin' );
 import gjoinBetween = require( '@stdlib/blas/ext/base/gjoin-between' );
 import glastIndexEqual = require( '@stdlib/blas/ext/base/glast-index-equal' );
@@ -224,6 +227,7 @@ import gsort2hp = require( '@stdlib/blas/ext/base/gsort2hp' );
 import gsort2ins = require( '@stdlib/blas/ext/base/gsort2ins' );
 import gsort2sh = require( '@stdlib/blas/ext/base/gsort2sh' );
 import gsorthp = require( '@stdlib/blas/ext/base/gsorthp' );
+import gsorthpBy = require( '@stdlib/blas/ext/base/gsorthp-by' );
 import gsortins = require( '@stdlib/blas/ext/base/gsortins' );
 import gsortsh = require( '@stdlib/blas/ext/base/gsortsh' );
 import gsum = require( '@stdlib/blas/ext/base/gsum' );
@@ -727,6 +731,68 @@ interface Namespace {
 	*/
 	clastIndexOfRow: typeof clastIndexOfRow;
 
+	/**
+	* Fills a single-precision complex floating-point strided array with logarithmically spaced values over a specified interval.
+	*
+	* @param N - number of indexed elements
+	* @param base - base of the logarithmic scale
+	* @param start - exponent of the starting value
+	* @param stop - exponent of the final value
+	* @param endpoint - boolean indicating whether to include the `base^stop` value when writing values to the input array
+	* @param x - input array
+	* @param strideX - stride length
+	* @returns input array
+	*
+	* @example
+	* var Complex64Array = require( '@stdlib/array/complex64' );
+	* var Complex64 = require( '@stdlib/complex/float32/ctor' );
+	*
+	* var x = new Complex64Array( [ 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 ] );
+	*
+	* var strt = new Complex64( 0.0, 0.0 );
+	* var stp = new Complex64( 2.0, 0.0 );
+	*
+	* ns.clogspace( x.length, 10.0, strt, stp, true, x, 1 );
+	* // x => <Complex64Array>[ 1.0, 0.0, 10.0, 0.0, 100.0, 0.0 ]
+	*
+	* @example
+	* var Complex64Array = require( '@stdlib/array/complex64' );
+	* var Complex64 = require( '@stdlib/complex/float32/ctor' );
+	*
+	* var x = new Complex64Array( [ 0.0, 0.0, 0.0, 0.0 ] );
+	*
+	* var strt = new Complex64( 0.0, 0.0 );
+	* var stp = new Complex64( 2.0, 0.0 );
+	*
+	* ns.clogspace( x.length, 10.0, strt, stp, false, x, 1 );
+	* // x => <Complex64Array>[ 1.0, 0.0, 10.0, 0.0 ]
+	*
+	* @example
+	* var Complex64Array = require( '@stdlib/array/complex64' );
+	* var Complex64 = require( '@stdlib/complex/float32/ctor' );
+	*
+	* var x = new Complex64Array( [ 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 ] );
+	*
+	* var strt = new Complex64( 0.0, 0.0 );
+	* var stp = new Complex64( 2.0, 0.0 );
+	*
+	* ns.clogspace.ndarray( x.length, 10.0, strt, stp, true, x, 1, 0 );
+	* // x => <Complex64Array>[ 1.0, 0.0, 10.0, 0.0, 100.0, 0.0 ]
+	*
+	* @example
+	* var Complex64Array = require( '@stdlib/array/complex64' );
+	* var Complex64 = require( '@stdlib/complex/float32/ctor' );
+	*
+	* var x = new Complex64Array( [ 0.0, 0.0, 0.0, 0.0 ] );
+	*
+	* var strt = new Complex64( 0.0, 0.0 );
+	* var stp = new Complex64( 2.0, 0.0 );
+	*
+	* ns.clogspace.ndarray( x.length, 10.0, strt, stp, false, x, 1, 0 );
+	* // x => <Complex64Array>[ 1.0, 0.0, 10.0, 0.0 ]
+	*/
+	clogspace: typeof clogspace;
+
 	/**
 	* Fills a single-precision complex floating-point strided array with linearly spaced numeric elements which increment by `1` starting from one.
 	*
@@ -4129,6 +4195,40 @@ interface Namespace {
 	*/
 	dwxmy: typeof dwxmy;
 
+	/**
+	* Adds elements of a double-precision floating-point strided array `x` to the corresponding elements of a double-precision floating-point strided array `y` and assigns the results to elements in a double-precision floating-point strided array `w`.
+	*
+	* @param N - number of indexed elements
+	* @param x - first input array
+	* @param strideX - `x` stride length
+	* @param y - second input array
+	* @param strideY - `y` stride length
+	* @param w - output array
+	* @param strideW - `w` stride length
+	* @returns `w`
+	*
+	* @example
+	* var Float64Array = require( '@stdlib/array/float64' );
+	*
+	* var x = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0 ] );
+	* var y = new Float64Array( [ 2.0, 3.0, 4.0, 5.0, 6.0 ] );
+	* var w = new Float64Array( [ 0.0, 0.0, 0.0, 0.0, 0.0 ] );
+	*
+	* ns.dwxpy( x.length, x, 1, y, 1, w, 1 );
+	* // w => <Float64Array>[ 3.0, 5.0, 7.0, 9.0, 11.0 ]
+	*
+	* @example
+	* var Float64Array = require( '@stdlib/array/float64' );
+	*
+	* var x = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0 ] );
+	* var y = new Float64Array( [ 2.0, 3.0, 4.0, 5.0, 6.0 ] );
+	* var w = new Float64Array( [ 0.0, 0.0, 0.0, 0.0, 0.0 ] );
+	*
+	* ns.dwxpy.ndarray( x.length, x, 1, 0, y, 1, 0, w, 1, 0 );
+	* // w => <Float64Array>[ 3.0, 5.0, 7.0, 9.0, 11.0 ]
+	*/
+	dwxpy: typeof dwxpy;
+
 	/**
 	* Subtracts a scalar constant from each element in a double-precision floating-point strided array `x` and assigns the results to a double-precision floating-point strided array `w`.
 	*
@@ -5641,6 +5741,34 @@ interface Namespace {
 	*/
 	gindexOfTruthy: typeof gindexOfTruthy;
 
+	/**
+	* Returns the index of the first row in an input matrix which contains at least one truthy element.
+	*
+	* ## Notes
+	*
+	* -   If the function is provided an empty matrix or if the function is unable to find a row with at least one truthy element, the function returns `-1` (i.e., an invalid index).
+	*
+	* @param order - storage layout
+	* @param M - number of rows in `A`
+	* @param N - number of columns in `A`
+	* @param A - input matrix
+	* @param LDA - stride of the first dimension of `A` (a.k.a., leading dimension of the matrix `A`)
+	* @returns row index
+	*
+	* @example
+	* var A = [ 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 0.0, 0.0, 0.0, 0.0 ];
+	*
+	* var out = ns.gindexOfTruthyRow( 'row-major', 4, 4, A, 4 );
+	* // returns 1
+	*
+	* @example
+	* var A = [ 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 0.0, 0.0, 0.0, 0.0 ];
+	*
+	* var out = ns.gindexOfTruthyRow.ndarray( 4, 4, A, 4, 1, 0 );
+	* // returns 1
+	*/
+	gindexOfTruthyRow: typeof gindexOfTruthyRow;
+
 	/**
 	* Returns a string created by joining strided array elements using a specified separator.
 	*
@@ -6451,6 +6579,50 @@ interface Namespace {
 	*/
 	gsorthp: typeof gsorthp;
 
+	/**
+	* Sorts a strided array using heapsort according to a provided callback function.
+	*
+	* @param N - number of indexed elements
+	* @param x - input array
+	* @param strideX - stride length
+	* @param clbk - callback function
+	* @param thisArg - execution context
+	* @returns `x`
+	*
+	* @example
+	* var x = [ 1.0, -2.0, 3.0, -4.0 ];
+	*
+	* function clbk( a, b ) {
+	*     if ( a < b ) {
+	*         return -1;
+	*     }
+	*     if ( a > b ) {
+	*         return 1;
+	*     }
+	*     return 0;
+	* }
+	*
+	* ns.gsorthpBy( x.length, x, 1, clbk );
+	* // x => [ -4.0, -2.0, 1.0, 3.0 ]
+	*
+	* @example
+	* var x = [ 1.0, -2.0, 3.0, -4.0 ];
+	*
+	* function clbk( a, b ) {
+	*     if ( a < b ) {
+	*         return -1;
+	*     }
+	*     if ( a > b ) {
+	*         return 1;
+	*     }
+	*     return 0;
+	* }
+	*
+	* ns.gsorthpBy.ndarray( x.length, x, 1, 0, clbk );
+	* // x => [ -4.0, -2.0, 1.0, 3.0 ]
+	*/
+	gsorthpBy: typeof gsorthpBy;
+
 	/**
 	* Sorts a strided array using insertion sort.
 	*