From 82aa2ebd0e6b75b951039636af66a723b009fb0d Mon Sep 17 00:00:00 2001
From: Planeshifter <1913638+Planeshifter@users.noreply.github.com>
Date: Sat, 18 May 2024 01:14:22 +0000
Subject: [PATCH 1/2] feat: update namespace TypeScript declarations

Signed-off-by: stdlib-bot <82920195+stdlib-bot@users.noreply.github.com>
---
 .../math/base/special/docs/types/index.d.ts   | 698 ++++++++++++++++++
 .../@stdlib/string/base/docs/types/index.d.ts | 130 ++++
 .../@stdlib/string/docs/types/index.d.ts      |  55 ++
 3 files changed, 883 insertions(+)

diff --git a/lib/node_modules/@stdlib/math/base/special/docs/types/index.d.ts b/lib/node_modules/@stdlib/math/base/special/docs/types/index.d.ts
index 1c23a873fd21..fad322e899a7 100644
--- a/lib/node_modules/@stdlib/math/base/special/docs/types/index.d.ts
+++ b/lib/node_modules/@stdlib/math/base/special/docs/types/index.d.ts
@@ -25,21 +25,36 @@ import abs2 = require( '@stdlib/math/base/special/abs2' );
 import abs2f = require( '@stdlib/math/base/special/abs2f' );
 import absf = require( '@stdlib/math/base/special/absf' );
 import acos = require( '@stdlib/math/base/special/acos' );
+import acosd = require( '@stdlib/math/base/special/acosd' );
+import acosf = require( '@stdlib/math/base/special/acosf' );
 import acosh = require( '@stdlib/math/base/special/acosh' );
 import acot = require( '@stdlib/math/base/special/acot' );
+import acotd = require( '@stdlib/math/base/special/acotd' );
+import acotf = require( '@stdlib/math/base/special/acotf' );
 import acoth = require( '@stdlib/math/base/special/acoth' );
 import acovercos = require( '@stdlib/math/base/special/acovercos' );
 import acoversin = require( '@stdlib/math/base/special/acoversin' );
 import acsc = require( '@stdlib/math/base/special/acsc' );
+import acscd = require( '@stdlib/math/base/special/acscd' );
+import acscdf = require( '@stdlib/math/base/special/acscdf' );
+import acscf = require( '@stdlib/math/base/special/acscf' );
 import acsch = require( '@stdlib/math/base/special/acsch' );
 import ahavercos = require( '@stdlib/math/base/special/ahavercos' );
 import ahaversin = require( '@stdlib/math/base/special/ahaversin' );
 import asec = require( '@stdlib/math/base/special/asec' );
+import asecd = require( '@stdlib/math/base/special/asecd' );
+import asecdf = require( '@stdlib/math/base/special/asecdf' );
+import asecf = require( '@stdlib/math/base/special/asecf' );
 import asech = require( '@stdlib/math/base/special/asech' );
 import asin = require( '@stdlib/math/base/special/asin' );
+import asind = require( '@stdlib/math/base/special/asind' );
+import asindf = require( '@stdlib/math/base/special/asindf' );
+import asinf = require( '@stdlib/math/base/special/asinf' );
 import asinh = require( '@stdlib/math/base/special/asinh' );
 import atan = require( '@stdlib/math/base/special/atan' );
 import atan2 = require( '@stdlib/math/base/special/atan2' );
+import atand = require( '@stdlib/math/base/special/atand' );
+import atanf = require( '@stdlib/math/base/special/atanf' );
 import atanh = require( '@stdlib/math/base/special/atanh' );
 import avercos = require( '@stdlib/math/base/special/avercos' );
 import aversin = require( '@stdlib/math/base/special/aversin' );
@@ -89,10 +104,12 @@ import clampf = require( '@stdlib/math/base/special/clampf' );
 import copysign = require( '@stdlib/math/base/special/copysign' );
 import copysignf = require( '@stdlib/math/base/special/copysignf' );
 import cos = require( '@stdlib/math/base/special/cos' );
+import cosd = require( '@stdlib/math/base/special/cosd' );
 import cosh = require( '@stdlib/math/base/special/cosh' );
 import cosm1 = require( '@stdlib/math/base/special/cosm1' );
 import cospi = require( '@stdlib/math/base/special/cospi' );
 import cot = require( '@stdlib/math/base/special/cot' );
+import cotd = require( '@stdlib/math/base/special/cotd' );
 import coth = require( '@stdlib/math/base/special/coth' );
 import covercos = require( '@stdlib/math/base/special/covercos' );
 import coversin = require( '@stdlib/math/base/special/coversin' );
@@ -100,6 +117,8 @@ import cphase = require( '@stdlib/math/base/special/cphase' );
 import cpolar = require( '@stdlib/math/base/special/cpolar' );
 import cround = require( '@stdlib/math/base/special/cround' );
 import croundn = require( '@stdlib/math/base/special/croundn' );
+import csc = require( '@stdlib/math/base/special/csc' );
+import cscd = require( '@stdlib/math/base/special/cscd' );
 import csch = require( '@stdlib/math/base/special/csch' );
 import csignum = require( '@stdlib/math/base/special/csignum' );
 import deg2rad = require( '@stdlib/math/base/special/deg2rad' );
@@ -165,6 +184,7 @@ import invf = require( '@stdlib/math/base/special/invf' );
 import kernelBetainc = require( '@stdlib/math/base/special/kernel-betainc' );
 import kernelBetaincinv = require( '@stdlib/math/base/special/kernel-betaincinv' );
 import kernelCos = require( '@stdlib/math/base/special/kernel-cos' );
+import kernelLog1p = require( '@stdlib/math/base/special/kernel-log1p' );
 import kernelSin = require( '@stdlib/math/base/special/kernel-sin' );
 import kernelTan = require( '@stdlib/math/base/special/kernel-tan' );
 import kroneckerDelta = require( '@stdlib/math/base/special/kronecker-delta' );
@@ -205,9 +225,11 @@ import polygamma = require( '@stdlib/math/base/special/polygamma' );
 import pow = require( '@stdlib/math/base/special/pow' );
 import powm1 = require( '@stdlib/math/base/special/powm1' );
 import rad2deg = require( '@stdlib/math/base/special/rad2deg' );
+import rad2degf = require( '@stdlib/math/base/special/rad2degf' );
 import ramp = require( '@stdlib/math/base/special/ramp' );
 import rampf = require( '@stdlib/math/base/special/rampf' );
 import rcbrt = require( '@stdlib/math/base/special/rcbrt' );
+import rcbrtf = require( '@stdlib/math/base/special/rcbrtf' );
 import rempio2 = require( '@stdlib/math/base/special/rempio2' );
 import zeta = require( '@stdlib/math/base/special/riemann-zeta' );
 import risingFactorial = require( '@stdlib/math/base/special/rising-factorial' );
@@ -219,6 +241,7 @@ import roundn = require( '@stdlib/math/base/special/roundn' );
 import roundsd = require( '@stdlib/math/base/special/roundsd' );
 import rsqrt = require( '@stdlib/math/base/special/rsqrt' );
 import rsqrtf = require( '@stdlib/math/base/special/rsqrtf' );
+import secd = require( '@stdlib/math/base/special/secd' );
 import sici = require( '@stdlib/math/base/special/sici' );
 import signum = require( '@stdlib/math/base/special/signum' );
 import signumf = require( '@stdlib/math/base/special/signumf' );
@@ -234,6 +257,7 @@ import sqrt1pm1 = require( '@stdlib/math/base/special/sqrt1pm1' );
 import sqrtf = require( '@stdlib/math/base/special/sqrtf' );
 import sqrtpi = require( '@stdlib/math/base/special/sqrtpi' );
 import tan = require( '@stdlib/math/base/special/tan' );
+import tand = require( '@stdlib/math/base/special/tand' );
 import tanh = require( '@stdlib/math/base/special/tanh' );
 import tribonacci = require( '@stdlib/math/base/special/tribonacci' );
 import trigamma = require( '@stdlib/math/base/special/trigamma' );
@@ -386,6 +410,54 @@ interface Namespace {
 	*/
 	acos: typeof acos;
 
+	/**
+	* Computes the arccosine (in degrees) of a double-precision floating-point number.
+	*
+	* @param x - input value
+	* @returns arccosine (in degrees)
+	*
+	* @example
+	* var v = ns.acosd( 0.0 );
+	* // returns 0.0
+	*
+	* @example
+	* var v = ns.acosd( 0.5 );
+	* // returns ~60.0
+	*
+	* @example
+	* var v = ns.acosd( Math.sqrt( 2 ) / 2 );
+	* // returns ~45.0
+	*
+	* @example
+	* var v = ns.acosd( Math.sqrt( 3 ) / 2 );
+	* // returns ~30.0
+	*
+	* @example
+	* var v = ns.acosd( NaN );
+	* // returns NaN
+	*/
+	acosd: typeof acosd;
+
+	/**
+	* Computes the arccosine of a single-precision floating-point number.
+	*
+	* @param x - input value
+	* @returns arccosine (in radians)
+	*
+	* @example
+	* var v = ns.acosf( 1.0 );
+	* // returns 0.0
+	*
+	* @example
+	* var v = ns.acosf( 0.707 ); // ~pi/4
+	* // returns ~0.7855
+	*
+	* @example
+	* var v = ns.acosf( NaN );
+	* // returns NaN
+	*/
+	acosf: typeof acosf;
+
 	/**
 	* Computes the hyperbolic arccosine of a double-precision floating-point number.
 	*
@@ -438,6 +510,66 @@ interface Namespace {
 	*/
 	acot: typeof acot;
 
+	/**
+	* Computes the arccotangent (in degrees) of a double-precision floating-point number.
+	*
+	* @param x - input value
+	* @returns arccotangent (in degrees)
+	*
+	* @example
+	* var v = ns.acotd( 0.0 );
+	* // returns 90.0
+	*
+	* @example
+	* var v = ns.acotd( Math.sqrt(3) );
+	* // returns ~30.0
+	*
+	* @example
+	* var v = ns.acotd( 1 );
+	* // returns 45.0
+	*
+	* @example
+	* var v = ns.acotd( Math.sqrt(3) / 3 );
+	* // returns ~60.0
+	*
+	* @example
+	* var v = ns.acotd( NaN );
+	* // returns NaN
+	*/
+	acotd: typeof acotd;
+
+	/**
+	* Computes the inverse cotangent of a single-precision floating-point number.
+	*
+	* @param x - input value
+	* @returns inverse cotangent (in radians)
+	*
+	* @example
+	* var v = ns.acotf( 2.0 );
+	* // returns ~0.4636
+	*
+	* @example
+	* var v = ns.acotf( 0.0 );
+	* // returns ~1.5708
+	*
+	* @example
+	* var v = ns.acotf( 0.5 );
+	* // returns ~1.1071
+	*
+	* @example
+	* var v = ns.acotf( 1.0 );
+	* // returns ~0.7854
+	*
+	* @example
+	* var v = ns.acotf( NaN );
+	* // returns NaN
+	*
+	* @example
+	* var v = ns.acotf( Infinity );
+	* // returns 0.0
+	*/
+	acotf: typeof acotf;
+
 	/**
 	* Computes the inverse hyperbolic cotangent of a double-precision floating-point number.
 	*
@@ -538,6 +670,98 @@ interface Namespace {
 	*/
 	acsc: typeof acsc;
 
+	/**
+	* Computes the arccosecant (in degrees) of a double-precision floating-point number.
+	*
+	* @param x - input value
+	* @returns arccosecant (in degrees)
+	*
+	* @example
+	* var v = ns.acscd( Infinity );
+	* // returns 0.0
+	*
+	* @example
+	* var v = ns.acscd( 2 * Math.sqrt( 3 ) / 3 );
+	* // returns ~60.0
+	*
+	* @example
+	* var v = ns.acscd( Math.sqrt( 2 ) );
+	* // returns ~45.0
+	*
+	* @example
+	* var v = ns.acscd( 2 );
+	* // returns ~30.0
+	*
+	* @example
+	* var v = ns.acscd( 1 );
+	* // returns 90.0
+	*
+	* @example
+	* var v = ns.acscd( NaN );
+	* // returns NaN
+	*/
+	acscd: typeof acscd;
+
+	/**
+	* Computes the arccosecant (in degrees) of a single-precision floating-point number.
+	*
+	* @param x - input value
+	* @returns arccosecant (in degrees)
+	*
+	* @example
+	* var v = ns.acscdf( Infinity );
+	* // returns 0.0
+	*
+	* @example
+	* var v = ns.acscdf( 2.0 );
+	* // returns ~30.0
+	*
+	* @example
+	* var sqrtf = require( '@stdlib/math/base/special/sqrtf' );
+	*
+	* var v = ns.acscdf( 2.0 * sqrtf( 3.0 ) / 3.0 );
+	* // returns ~60.0
+	*
+	* @example
+	* var sqrtf = require( '@stdlib/math/base/special/sqrtf' );
+	*
+	** var v = ns.acscdf( sqrtf( 2.0 ) );
+	* // returns ~45.0
+	*
+	* @example
+	* var v = ns.acscdf( 1.0 );
+	* // returns 90.0
+	*
+	* @example
+	* var v = ns.acscdf( NaN );
+	* // returns NaN
+	*/
+	acscdf: typeof acscdf;
+
+	/**
+	* Computes the arccosecant of a single-precision floating-point number.
+	*
+	* @param x - input value
+	* @returns arccosecant (in radians)
+	*
+	* @example
+	* var v = ns.acscf( 1.0 );
+	* // returns ~1.57
+	*
+	* @example
+	* var v = ns.acscf( 3.141592653589793 );
+	* // returns ~0.32
+	*
+	* @example
+	* var v = ns.acscf( -3.141592653589793 );
+	* // returns ~-0.32
+	*
+	* @example
+	* var v = ns.acscf( NaN );
+	* // returns NaN
+	*/
+	acscf: typeof acscf;
+
 	/**
 	* Computes the hyperbolic arccosecant of a number.
 	*
@@ -626,6 +850,94 @@ interface Namespace {
 	*/
 	asec: typeof asec;
 
+	/**
+	* Computes the arcsecant (in degrees) of a double-precision floating-point number.
+	*
+	* @param x - input value
+	* @returns arcsecant (in degrees)
+	*
+	* @example
+	* var v = ns.asecd( 1 );
+	* // returns 0.0
+	*
+	* @example
+	* var v = ns.asecd( 2 * Math.sqrt( 3 ) / 3 );
+	* // returns ~30.0
+	*
+	* @example
+	* var v = ns.asecd( Math.sqrt( 2 ) );
+	* // returns ~45.0
+	*
+	* @example
+	* var v = ns.asecd( 2 );
+	* // returns ~60.0
+	*
+	* @example
+	* var v = ns.asecd( Infinity );
+	* // returns 90.0
+	*
+	* @example
+	* var v = ns.asecd( NaN );
+	* // returns NaN
+	*/
+	asecd: typeof asecd;
+
+	/**
+	* Computes the arcsecant (in degrees) of a single-precision floating-point number.
+	*
+	* @param x - input value
+	* @returns arcsecant (in degrees)
+	*
+	* @example
+	* var v = ns.asecdf( 1.0 );
+	* // returns 0.0
+	*
+	* @example
+	* var v = ns.asecdf( 2.0 );
+	* // returns ~60.0
+	*
+	* @example
+	* var sqrtf = require( '@stdlib/math/base/special/sqrtf' );
+	*
+	* var v = ns.asecdf( 2.0 * sqrtf( 3.0 ) / 3.0 );
+	* // returns ~30.0
+	*
+	* @example
+	* var sqrtf = require( '@stdlib/math/base/special/sqrtf' );
+	*
+	** var v = ns.asecdf( sqrtf( 2.0 ) );
+	* // returns 45.0
+	*
+	* @example
+	* var v = ns.asecdf( Infinity );
+	* // returns 90.0
+	*
+	* @example
+	* var v = ns.asecdf( NaN );
+	* // returns NaN
+	*/
+	asecdf: typeof asecdf;
+
+	/**
+	* Computes the inverse (arc) secant of a single-precision floating-point number.
+	*
+	* @param x - input value
+	* @returns inverse (arc) secant
+	*
+	* @example
+	* var v = ns.asecf( 1.0 );
+	* // returns 0.0
+	*
+	* @example
+	* var v = ns.asecf( 2.0 );
+	* // returns ~1.0472
+	*
+	* @example
+	* var v = ns.asecf( NaN );
+	* // returns NaN
+	*/
+	asecf: typeof asecf;
+
 	/**
 	* Computes the hyperbolic arcsecant of a number.
 	*
@@ -670,6 +982,94 @@ interface Namespace {
 	*/
 	asin: typeof asin;
 
+	/**
+	* Computes the arcsine (in degrees) of a double-precision floating-point number.
+	*
+	* @param x - input value
+	* @returns arcsine (in degrees)
+	*
+	* @example
+	* var v = ns.asind( 0.0 );
+	* // returns 0.0
+	*
+	* @example
+	* var v = ns.asind( 0.5 );
+	* // returns ~30.0
+	*
+	* @example
+	* var sqrt = require( '@stdlib/math/base/special/sqrt' );
+	*
+	* var v = ns.asindf( sqrt( 2.0 ) / 2.0 );
+	* // returns ~45.0
+	*
+	* @example
+	* var sqrt = require( '@stdlib/math/base/special/sqrt' );
+	*
+	** var v = ns.asindf( sqrt( 3.0 ) / 2.0 );
+	* // returns ~60.0
+	*
+	* @example
+	* var v = ns.asind( NaN );
+	* // returns NaN
+	*/
+	asind: typeof asind;
+
+	/**
+	* Computes the arcsine (in degrees) of a single-precision floating-point number.
+	*
+	* @param x - input value
+	* @returns arcsine (in degrees)
+	*
+	* @example
+	* var v = ns.asindf( 0.0 );
+	* // returns 0.0
+	*
+	* @example
+	* var v = ns.asindf( 0.5 );
+	* // returns ~30.0
+	*
+	* @example
+	* var sqrtf = require( '@stdlib/math/base/special/sqrtf' );
+	*
+	* var v = ns.asindf( sqrtf( 2.0 ) / 2.0 );
+	* // returns ~45.0
+	*
+	* @example
+	* var sqrtf = require( '@stdlib/math/base/special/sqrtf' );
+	*
+	** var v = ns.asindf( sqrtf( 3.0 ) / 2.0 );
+	* // returns ~60.0
+	*
+	* @example
+	* var v = ns.asindf( NaN );
+	* // returns NaN
+	*/
+	asindf: typeof asindf;
+
+	/**
+	* Computes the arcsine of a single-precision floating-point number.
+	*
+	* @param x - input value
+	* @returns arcsine (in radians)
+	*
+	* @example
+	* var v = ns.asinf( 0.0 );
+	* // returns 0.0
+	*
+	* @example
+	* var v = ns.asinf( 3.14/4.0 );
+	* // returns ~0.903
+	*
+	* @example
+	* var v = ns.asinf( -3.14/6.0 );
+	* // returns ~-0.551
+	*
+	* @example
+	* var v = ns.asinf( NaN );
+	* // returns NaN
+	*/
+	asinf: typeof asinf;
+
 	/**
 	* Computes the hyperbolic arcsine of a double-precision floating-point number.
 	*
@@ -763,6 +1163,66 @@ interface Namespace {
 	*/
 	atan2: typeof atan2;
 
+	/**
+	* Computes the arctangent (in degrees) of a double-precision floating-point number.
+	*
+	* @param x - input value
+	* @returns arctangent (in degrees)
+	*
+	* @example
+	* var v = ns.atand( 0.0 );
+	* // returns 0.0
+	*
+	* @example
+	* var v = ns.atand( 0.5 );
+	* // returns ~26.57
+	*
+	* @example
+	* var v = ns.atand( 1 / Math.sqrt( 3 ) );
+	* // returns ~30.0
+	*
+	* @example
+	* var v = ns.atand( 1 );
+	* // returns 45.0
+	*
+	* @example
+	* var v = ns.atand( Infinity );
+	* // returns 90.0
+	*
+	* @example
+	* var v = ns.atand( NaN );
+	* // returns NaN
+	*/
+	atand: typeof atand;
+
+	/**
+	* Computes the arctangent of a single-precision floating-point number.
+	*
+	* @param x - input value
+	* @returns arctangent (in radians)
+	*
+	* @example
+	* var v = ns.atanf( 0.0 );
+	* // returns 0.0
+	*
+	* @example
+	* var FLOAT32_PI = require( '@stdlib/constants/float32/pi' );
+	*
+	* var v = ns.atanf( FLOAT32_PI/4.0 );
+	* // returns ~0.666
+	*
+	* @example
+	* var FLOAT32_PI = require( '@stdlib/constants/float32/pi' );
+	*
+	* var v = ns.atanf( -FLOAT32_PI/4.0 );
+	* // returns ~-0.666
+	*
+	* @example
+	* var v = ns.atanf( NaN );
+	* // returns NaN
+	*/
+	atanf: typeof atanf;
+
 	/**
 	* Computes the hyperbolic arctangent of a double-precision floating-point number.
 	*
@@ -2163,6 +2623,30 @@ interface Namespace {
 	*/
 	cos: typeof cos;
 
+	/**
+	* Computes the cosine of an angle measured in degrees.
+	*
+	* @param x - input value (in degrees)
+	* @returns cosine
+	 *
+	 * @example
+	 * var v = ns.cosd( 0.0 );
+	 * // returns 1.0
+	 *
+	 * @example
+	 * var v = ns.cosd( 60.0 );
+	 * // returns ~0.5
+	 *
+	 * @example
+	 * var v = ns.cosd( 90.0);
+	 * // returns 0
+	 *
+	 * @example
+	 * var v = ns.cosd( NaN );
+	 * // returns NaN
+	*/
+	cosd: typeof cosd;
+
 	/**
 	* Computes the hyperbolic cosine of a double-precision floating-point number.
 	*
@@ -2263,6 +2747,30 @@ interface Namespace {
 	*/
 	cot: typeof cot;
 
+	/**
+	* Computes the cotangent of an angle measured in degrees
+	*
+	* @param x - input value (in degrees)
+	* @returns cotangent
+	 *
+	 * @example
+	 * var v = ns.cotd( 0.0 );
+	 * // returns Infinity
+	 *
+	 * @example
+	 * var v = ns.cotd( 60.0 );
+	 * // returns ~0.58
+	 *
+	 * @example
+	 * var v = ns.cotd( 90.0 );
+	 * // returns 0.0
+	 *
+	 * @example
+	 * var v = ns.cotd( NaN );
+	 * // returns NaN
+	*/
+	cotd: typeof cotd;
+
 	/**
 	* Computes the hyperbolic cotangent of a number.
 	*
@@ -2416,6 +2924,62 @@ interface Namespace {
 	*/
 	croundn: typeof croundn;
 
+	/**
+	* Computes the cosecant of a number.
+	*
+	* @param x - input value (in radians)
+	* @returns cosecant
+	*
+	* @example
+	* var v = ns.csc( 0.0 );
+	* // returns Infinity
+	*
+	* @example
+	* var v = ns.csc( 3.141592653589793/2.0 );
+	* // returns ~1.0
+	*
+	* @example
+	* var v = ns.csc( -3.141592653589793/6.0 );
+	* // returns ~-2.0
+	*
+	* @example
+	* var v = ns.csc( NaN );
+	* // returns NaN
+	*/
+	csc: typeof csc;
+
+	/**
+	* Computes the cosecant of a degree.
+	*
+	* @param x - input value (in degrees)
+	* @returns cosecant
+	*
+	* @example
+	* var v = ns.cscd( 30 );
+	* // returns ~2.0
+	*
+	* @example
+	* var v = ns.cscd( 45 );
+	* // returns ~1.41
+	*
+	* @example
+	* var v = ns.cscd( 60 );
+	* // returns ~1.15
+	*
+	* @example
+	* var v = ns.cscd( 90 );
+	* // returns 1.0
+	*
+	* @example
+	* var v = ns.cscd( 0 );
+	* // returns Infinity
+	*
+	* @example
+	* var v = ns.cscd( NaN );
+	* // returns NaN
+	*/
+	cscd: typeof cscd;
+
 	/**
 	* Computes the hyperbolic cosecant of a number.
 	*
@@ -4302,6 +4866,32 @@ interface Namespace {
 	*/
 	kernelCos: typeof kernelCos;
 
+	/**
+	* Computes `log(1+f) - f` for `1+f` in `~[sqrt(2)/2, sqrt(2)]`.
+	*
+	* ## Notes
+	*
+	* -   This function provides a common means for computing logarithms in base `e`. Argument reduction and adding the final term of the polynomial must be done by the caller for increased accuracy when different bases are used.
+	*
+	* @param f - input value
+	* @returns function value
+	*
+	* @example
+	* var v = ns.kernelLog1p( 1.0 );
+	* // returns ~0.1931
+	*
+	* @example
+	* var sqrt = require( '@stdlib/math/base/special/sqrt' );
+	*
+	* var v = ns.kernelLog1p( sqrt( 2.0 ) );
+	* // returns ~0.4672
+	*
+	* @example
+	* var v = ns.kernelLog1p( NaN );
+	* // returns NaN
+	*/
+	kernelLog1p: typeof kernelLog1p;
+
 	/**
 	* Computes the sine of a double-precision floating-point number on `[-π/4, π/4]`.
 	*
@@ -5533,6 +6123,26 @@ interface Namespace {
 	*/
 	rad2deg: typeof rad2deg;
 
+	/**
+	* Converts an angle from radians to degrees (single-precision).
+	*
+	* @param x - angle in radians
+	* @returns angle in degrees
+	*
+	* @example
+	* var d = ns.rad2degf( 3.141592653589793 / 2.0 );
+	* // returns 90.0
+	*
+	* @example
+	* var d = ns.rad2degf( -3.141592653589793 / 4.0 );
+	* // returns -45.0
+	*
+	* @example
+	* var d = ns.rad2degf( NaN );
+	* // returns NaN
+	*/
+	rad2degf: typeof rad2degf;
+
 	/**
 	* Evaluates the ramp function.
 	*
@@ -5613,6 +6223,38 @@ interface Namespace {
 	*/
 	rcbrt: typeof rcbrt;
 
+	/**
+	* Computes the reciprocal cube root of a single-precision floating-point number.
+	*
+	* @param x - input value
+	* @returns reciprocal cube root of `x`
+	*
+	* @example
+	* var v = ns.rcbrtf( 8.0 );
+	* // returns 0.5
+	*
+	* @example
+	* var v = ns.rcbrtf( 1000.0 );
+	* // returns ~0.1
+	*
+	* @example
+	* var v = ns.rcbrtf( 0.0 );
+	* // returns Infinity
+	*
+	* @example
+	* var v = ns.rcbrtf( Infinity );
+	* // returns 0.0
+	*
+	* @example
+	* var v = ns.rcbrtf( -8.0 );
+	* // returns -0.5
+	*
+	* @example
+	* var v = ns.rcbrtf( NaN );
+	* // returns NaN
+	*/
+	rcbrtf: typeof rcbrtf;
+
 	/**
 	* Computes `x - nπ/2 = r`.
 	*
@@ -5957,6 +6599,38 @@ interface Namespace {
 	*/
 	rsqrtf: typeof rsqrtf;
 
+	/**
+	* Computes the secant of an angle measured in degrees.
+	*
+	* @param x - input value (in degrees)
+	* @returns secant
+	*
+	* @example
+	* var v = ns.secd( 30 );
+	* // returns ~1.15
+	*
+	* @example
+	* var v = ns.secd( 45 );
+	* // returns ~1.41
+	*
+	* @example
+	* var v = ns.secd( 60 );
+	* // returns ~2.0
+	*
+	* @example
+	* var v = ns.secd( 90 );
+	* // returns 16331239353195370.0
+	*
+	* @example
+	* var v = ns.secd( 0 );
+	* // returns 1.0
+	*
+	* @example
+	* var v = ns.secd( NaN );
+	* // returns NaN
+	*/
+	secd: typeof secd;
+
 	/**
 	* Computes the sine and cosine integrals.
 	*
@@ -6385,6 +7059,30 @@ interface Namespace {
 	*/
 	tan: typeof tan;
 
+	/**
+	* Computes the tangent of an angle measured in degrees
+	*
+	* @param x - input value (in degrees)
+	* @returns tangent
+	*
+	* @example
+	* var v = ns.tand( 0.0 );
+	* // returns 0.0
+	*
+	* @example
+	* var v = ns.tand( 60.0 );
+	* // returns ~1.73
+	*
+	* @example
+	* var v = ns.tand( 90.0 );
+	* // returns Infinity
+	*
+	* @example
+	* var v = ns.tand( NaN );
+	* // returns NaN
+	*/
+	tand: typeof tand;
+
 	/**
 	* Computes the hyperbolic tangent of a double-precision floating-point number.
 	*
diff --git a/lib/node_modules/@stdlib/string/base/docs/types/index.d.ts b/lib/node_modules/@stdlib/string/base/docs/types/index.d.ts
index f77b24f54f9b..71ed7f524fe1 100644
--- a/lib/node_modules/@stdlib/string/base/docs/types/index.d.ts
+++ b/lib/node_modules/@stdlib/string/base/docs/types/index.d.ts
@@ -33,6 +33,7 @@ import firstCodePoint = require( '@stdlib/string/base/first-code-point' );
 import firstGraphemeCluster = require( '@stdlib/string/base/first-grapheme-cluster' );
 import forEach = require( '@stdlib/string/base/for-each' );
 import forEachCodePoint = require( '@stdlib/string/base/for-each-code-point' );
+import forEachCodePointRight = require( '@stdlib/string/base/for-each-code-point-right' );
 import forEachGraphemeCluster = require( '@stdlib/string/base/for-each-grapheme-cluster' );
 import forEachRight = require( '@stdlib/string/base/for-each-right' );
 import formatInterpolate = require( '@stdlib/string/base/format-interpolate' );
@@ -40,6 +41,9 @@ import formatTokenize = require( '@stdlib/string/base/format-tokenize' );
 import headercase = require( '@stdlib/string/base/headercase' );
 import invcase = require( '@stdlib/string/base/invcase' );
 import kebabcase = require( '@stdlib/string/base/kebabcase' );
+import last = require( '@stdlib/string/base/last' );
+import lastCodePoint = require( '@stdlib/string/base/last-code-point' );
+import lastGraphemeCluster = require( '@stdlib/string/base/last-grapheme-cluster' );
 import lpad = require( '@stdlib/string/base/left-pad' );
 import ltrim = require( '@stdlib/string/base/left-trim' );
 import lowercase = require( '@stdlib/string/base/lowercase' );
@@ -65,6 +69,7 @@ import rtrim = require( '@stdlib/string/base/right-trim' );
 import snakecase = require( '@stdlib/string/base/snakecase' );
 import startcase = require( '@stdlib/string/base/startcase' );
 import startsWith = require( '@stdlib/string/base/starts-with' );
+import stickycase = require( '@stdlib/string/base/stickycase' );
 import trim = require( '@stdlib/string/base/trim' );
 import truncateMiddle = require( '@stdlib/string/base/truncate-middle' );
 import uncapitalize = require( '@stdlib/string/base/uncapitalize' );
@@ -363,6 +368,31 @@ interface Namespace {
 	*/
 	forEachCodePoint: typeof forEachCodePoint;
 
+	/**
+	* Invokes a function for each Unicode code point in a string, iterating from right to left.
+	*
+	* ## Notes
+	*
+	* -   When invoked, the provided function is provided three arguments:
+	*
+	*     -   **value**: code point.
+	*     -   **index**: starting code point index.
+	*     -   **str**: input string.
+	*
+	* @param str - input string
+	* @param clbk - function to invoke
+	* @param thisArg - execution context
+	* @returns input string
+	*
+	* @example
+	* function log( value, index ) {
+	*     console.log( '%d: %s', index, value );
+	* }
+	*
+	* ns.forEachCodePointRight( 'Hello, World!', log );
+	*/
+	forEachCodePointRight: typeof forEachCodePointRight;
+
 	/**
 	* Invokes a function for each grapheme cluster (i.e., user-perceived character) in a string.
 	*
@@ -504,6 +534,85 @@ interface Namespace {
 	*/
 	kebabcase: typeof kebabcase;
 
+	/**
+	* Returns the last `n` UTF-16 code units of a string.
+	*
+	* @param str - input string
+	* @param n - number of code units to return
+	* @returns output string
+	*
+	* @example
+	* var s = ns.last( 'hello world', 1 );
+	* // returns 'd'
+	*
+	* @example
+	* var s = ns.last( 'foo', 2 );
+	* // returns 'oo'
+	*
+	* @example
+	* var s = ns.last( 'JavaScript', 6 );
+	* // returns 'Script'
+	*
+	* @example
+	* var s = ns.last( 'foo bar', 10 );
+	* // returns 'foo bar'
+	*/
+	last: typeof last;
+
+	/**
+	* Returns the last `n` Unicode code points of a string.
+	*
+	* @param str - input string
+	* @param n - number of code points to return
+	* @returns output string
+	*
+	* @example
+	* var out = ns.lastCodePoint( 'Hello World', 1 );
+	* // returns 'd'
+	*
+	* @example
+	* var out = ns.lastCodePoint( 'JavaScript', 6 );
+	* // returns 'Script'
+	*
+	* @example
+	* var out = ns.lastCodePoint( 'New', 5 );
+	* // returns 'New'
+	*
+	* @example
+	* var out = ns.lastCodePoint( 'अनुच्छेद', 1 );
+	* // returns 'द'
+	*/
+	lastCodePoint: typeof lastCodePoint;
+
+	/**
+	* Returns the last `n` grapheme clusters (i.e., user-perceived characters) of a string.
+	*
+	* @param str - input string
+	* @param n - number of grapheme clusters to return
+	* @returns output string
+	*
+	* @example
+	* var out = ns.lastGraphemeCluster( 'Hello World', 1 );
+	* // returns 'd'
+	*
+	* @example
+	* var out = ns.lastGraphemeCluster( 'Evening', 3 );
+	* // returns 'ing'
+	*
+	* @example
+	* var out = ns.lastGraphemeCluster( 'JavaScript', 6 );
+	* // returns 'Script'
+	*
+	* @example
+	* var out = ns.lastGraphemeCluster( '🐶🐮🐷🐰🐸', 2 );
+	* // returns '🐰🐸'
+	*
+	* @example
+	* var out = ns.lastGraphemeCluster( 'foo bar', 5 );
+	* // returns 'o bar'
+	*/
+	lastGraphemeCluster: typeof lastGraphemeCluster;
+
 	/**
 	* Left pads a string such that the padded string has a length of at least `len`.
 	*
@@ -1198,6 +1307,27 @@ interface Namespace {
 	*/
 	startsWith: typeof startsWith;
 
+	/**
+	 * Converts a string to "sticky caps" case.
+	 *
+	 * @param str - input string
+	 * @param p - probability of capitalization (default: 0.5)
+	 * @returns sticky case string
+	 *
+	 * @example
+	 * var str = ns.stickycase( 'hello world' );
+	 * // returns <string>
+	 *
+	 * @example
+	 * var str = ns.stickycase( 'hello world', 0.2 );
+	 * // returns <string>
+	 *
+	 * @example
+	 * var str = ns.stickycase( 'hello world', 0.8 );
+	 * // returns <string>
+	 */
+	stickycase: typeof stickycase;
+
 	/**
 	* Trims whitespace characters from the beginning and end of a string.
 	*
diff --git a/lib/node_modules/@stdlib/string/docs/types/index.d.ts b/lib/node_modules/@stdlib/string/docs/types/index.d.ts
index c3e0732e326c..9e7af70f7379 100644
--- a/lib/node_modules/@stdlib/string/docs/types/index.d.ts
+++ b/lib/node_modules/@stdlib/string/docs/types/index.d.ts
@@ -34,6 +34,7 @@ import format = require( '@stdlib/string/format' );
 import fromCodePoint = require( '@stdlib/string/from-code-point' );
 import headercase = require( '@stdlib/string/headercase' );
 import kebabcase = require( '@stdlib/string/kebabcase' );
+import last = require( '@stdlib/string/last' );
 import lpad = require( '@stdlib/string/left-pad' );
 import ltrim = require( '@stdlib/string/left-trim' );
 import ltrimN = require( '@stdlib/string/left-trim-n' );
@@ -68,6 +69,7 @@ import substringBefore = require( '@stdlib/string/substring-before' );
 import substringBeforeLast = require( '@stdlib/string/substring-before-last' );
 import graphemeClusters2iterator = require( '@stdlib/string/to-grapheme-cluster-iterator' );
 import graphemeClusters2iteratorRight = require( '@stdlib/string/to-grapheme-cluster-iterator-right' );
+import toWellFormed = require( '@stdlib/string/to-well-formed' );
 import trim = require( '@stdlib/string/trim' );
 import truncate = require( '@stdlib/string/truncate' );
 import truncateMiddle = require( '@stdlib/string/truncate-middle' );
@@ -382,6 +384,39 @@ interface Namespace {
 	*/
 	kebabcase: typeof kebabcase;
 
+	/**
+	* Returns the last character(s) of a string.
+	*
+	* @param str - input string
+	* @param n - number of characters to return (default: 1)
+	* @returns updated string
+	*
+	* @example
+	* var out = ns.last( 'ns.last man standing' );
+	* // returns 'g'
+	*
+	* @example
+	* var out = ns.last( 'presidential election' );
+	* // returns 'n'
+	*
+	* @example
+	* var out = ns.last( 'javaScript' );
+	* // returns 't'
+	*
+	* @example
+	* var out = ns.last( 'Hidden Treasures' );
+	* // returns 's'
+	*
+	* @example
+	* var out = ns.last( '🐶🐮🐷🐰🐸', 2 );
+	* // returns '🐰🐸'
+	*
+	* @example
+	* var out = ns.last( 'foo bar', 3 );
+	* // returns 'bar'
+	*/
+	last: typeof last;
+
 	/**
 	* Left pads a string such that the padded string has a length of at least `len`.
 	*
@@ -1216,6 +1251,26 @@ interface Namespace {
 	*/
 	graphemeClusters2iteratorRight: typeof graphemeClusters2iteratorRight;
 
+	/**
+	* Replaces all lone surrogates in order to create a new string which is well formed.
+	*
+	* @param str - string to test
+	* @returns new string which does not contain any lone surrogates
+	*
+	* @example
+	* var result = ns.toWellFormed( '\uDBFF' );
+	* // returns �
+	*
+	* @example
+	* var result = ns.toWellFormed( '\uDBFFFF\uDBFF' );
+	* // returns �FF�
+	*
+	* @example
+	* var result = ns.toWellFormed( '-5' );
+	* // returns -5
+	*/
+	toWellFormed: typeof toWellFormed;
+
 	/**
 	* Trims whitespace characters from the beginning and end of a string.
 	*

From baf1f25ff725d76f25247eb1700f576b8f1d8e0a Mon Sep 17 00:00:00 2001
From: Philipp Burckhardt <pburckhardt@outlook.com>
Date: Fri, 17 May 2024 21:26:39 -0400
Subject: [PATCH 2/2] chore: remove trailing space

Signed-off-by: Philipp Burckhardt <pburckhardt@outlook.com>
---
 .../@stdlib/math/base/special/docs/types/index.d.ts             | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/lib/node_modules/@stdlib/math/base/special/docs/types/index.d.ts b/lib/node_modules/@stdlib/math/base/special/docs/types/index.d.ts
index fad322e899a7..8e5598b8942b 100644
--- a/lib/node_modules/@stdlib/math/base/special/docs/types/index.d.ts
+++ b/lib/node_modules/@stdlib/math/base/special/docs/types/index.d.ts
@@ -3609,7 +3609,7 @@ interface Namespace {
 	* @example
 	* var v = ns.factorial2( 4 );
 	* // returns 8
-	* 
+	*
 	* @example
 	* var v = ns.factorial2( -10 );
 	* // returns NaN