Fix lint errors

Author: Planeshifter

lib/node_modules/@stdlib/random/base/geometric/lib/_geometric.js

@@ -15,31 +15,31 @@ var ln = require( '@stdlib/math/base/special/ln' );
 *
 * Consider
 *
-* ``` tex
+* ```tex
 * N = \left \lfloor \ln (U) / \ln (1-p) \right \rfloor
 * ```
 *
 * where \\( U \\) is uniform on the interval \\((0,1)\\). Accordingly, \\(N\\) must be a nonnegative integer, and, for every \\( n \geq 0\\), the event \\(A_n = \left \{ N = n \right \}\\) is
 *
-* ``` tex
+* ```tex
 * A_n = \left \{(n+1) \ln (1-p) < \ln (U) \leq n \ln (1-p) \right \}
 * ```
 *
 * where \\(\ln (1-p) < 0\\). Thus,
 *
-* ``` tex
+* ```tex
 * A_n = \left \{(1-p)^{n+1} < U \leq (1-p)^n \right \}
 * ```
 *
 * For every \\(u < v\\) on the interval \\((0,1)\\),
 *
-* ``` tex
+* ```tex
 * P\left \[u < U \leq v\right \] = v - u
 * ```
 *
 * Hence,
 *
-* ``` tex
+* ```tex
 * P\left \[N = n \right \] = P\left \[A_n\right \] = (1-p)^n - (1-p)^{n+1} = (1-p)^n(1-(1-p)) = p(1-p)^n
 * ```
 *

lib/node_modules/@stdlib/random/base/minstd/lib/minstd.js

@@ -15,7 +15,7 @@ var randint32 = require( './rand_int32.js' );
 *
 * Linear congruential generators (LCGs) use the recurrence relation
 *
-* ``` tex
+* ```tex
 * X_{n+1} = ( a \cdot X_n + c ) \operatorname{mod}(m)
 * ```
 *
@@ -29,7 +29,7 @@ var randint32 = require( './rand_int32.js' );
 *
 * In this implementation, the constants \\( a \\), \\( c \\), and \\( m \\) have the values
 *
-* ``` tex
+* ```tex
 * \begin{align*}
 * a &= 7^5 = 16807 \\
 * c &= 0 \\
@@ -51,7 +51,7 @@ var randint32 = require( './rand_int32.js' );
 *
 * Accordingly, the maximum possible product is
 *
-* ``` tex
+* ```tex
 * 16807 \cdot (m - 1) \approx 2^{46}
 * ```
 *

lib/node_modules/@stdlib/string/utf16-to-utf8-array/lib/main.js

@@ -45,39 +45,39 @@ var Ox10000 = 65536|0;
 *
 * ## Method
 *
-* * UTF-8 is defined to encode code points in one to four bytes, depending on the number of significant bits in the numerical value of the code point.
+* -   UTF-8 is defined to encode code points in one to four bytes, depending on the number of significant bits in the numerical value of the code point.
 *
-* * UTF-16 encoding uses one 16-bit unit for non-surrogates (U+0000 to U+D7FF and U+E000 to U+FFFF).
+* -   UTF-16 encoding uses one 16-bit unit for non-surrogates (U+0000 to U+D7FF and U+E000 to U+FFFF).
 *
-* * UTF-16 encoding uses two 16-bit units (surrogate pairs) for U+10000 to U+10FFFF and encodes U+10000-U+10FFFF by subtracting 0x10000 from the code point, expressing the result as a 20-bit binary, and splitting the 20 bits of 0x0-0xFFFFF as upper and lower 10-bits. The respective 10-bits are stored in two 16-bit words.
+* -   UTF-16 encoding uses two 16-bit units (surrogate pairs) for U+10000 to U+10FFFF and encodes U+10000-U+10FFFF by subtracting 0x10000 from the code point, expressing the result as a 20-bit binary, and splitting the 20 bits of 0x0-0xFFFFF as upper and lower 10-bits. The respective 10-bits are stored in two 16-bit words.
 *
-* * Let `N` be the number of significant bits.
+* -   Let `N` be the number of significant bits.
 *
-* * If `N <= 7` (i.e., U+0000 to U+007F), a code point is encoded in a single byte.
+* -   If `N <= 7` (i.e., U+0000 to U+007F), a code point is encoded in a single byte.
 *
-*   ``` text
-*   0xxxxxxx
-*   ```
+*     ```text
+*     0xxxxxxx
+*     ```
 *
-*   where an `x` refers to a code point bit.
+*     where an `x` refers to a code point bit.
 *
-* * If `N <= 11` (i.e., U+0080 to U+07FF; ASCII characters), a code point is encoded in two bytes (5+6 bits).
+* -   If `N <= 11` (i.e., U+0080 to U+07FF; ASCII characters), a code point is encoded in two bytes (5+6 bits).
 *
-*   ``` text
-*   110xxxxx 10xxxxxx
-*   ```
+*     ```text
+*     110xxxxx 10xxxxxx
+*     ```
 *
-* * If `N <= 16` (i.e., U+0800 to U+FFFF), a code point is encoded in three bytes (4+6+6 bits).
+* -   If `N <= 16` (i.e., U+0800 to U+FFFF), a code point is encoded in three bytes (4+6+6 bits).
 *
-*   ``` text
-*   1110xxxx 10xxxxxx 10xxxxxx
-*   ```
+*     ```text
+*     1110xxxx 10xxxxxx 10xxxxxx
+*     ```
 *
-* * If `N <= 21` (i.e., U+10000 to U+10FFFF), a code point is encoded in four bytes (3+6+6+6 bits).
+* -   If `N <= 21` (i.e., U+10000 to U+10FFFF), a code point is encoded in four bytes (3+6+6+6 bits).
 *
-*   ``` text
-*   11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
-*   ```
+*     ```text
+*     11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
+*     ```
 *
 *
 * @param {string} str - string to convert

lib/node_modules/@stdlib/string/utf16-to-utf8-array/test/test.js

@@ -66,7 +66,7 @@ tape( 'the function converts a UTF-16 encoded string to an array of integers usi
 	*
 	* To convert U+10437 to a UTF-8 array, pack the bit sequence (more specifically, the last 21 bits) into 4 bytes using UTF-8 encoding.
 	*
-	*   ``` text
+	*   ```text
 	*   00000000 000 00001 00000100 00110111
 	*
 	*   00001 00000100 00110111
@@ -78,30 +78,30 @@ tape( 'the function converts a UTF-16 encoded string to an array of integers usi
 	*
 	* To determine the surrogate pair,
 	*
-	* * Subtract 0x10000.
+	* -   Subtract 0x10000.
 	*
-	*   ``` text
-	*   0x10437 - 0x10000 = 0x00437 => 0000 0000 0100 0011 0111
-	*   ```
+	*     ```text
+	*     0x10437 - 0x10000 = 0x00437 => 0000 0000 0100 0011 0111
+	*     ```
 	*
-	* * Split into high and low 10-bits.
+	* -   Split into high and low 10-bits.
 	*
-	*   ``` text
-	*   0000 0000 01
-	*   00 0011 0111
-	*   ```
+	*     ```text
+	*     0000 0000 01
+	*     00 0011 0111
+	*     ```
 	*
-	* * Add 0xD800 to high 10-bits to get high surrogate.
+	* -   Add 0xD800 to high 10-bits to get high surrogate.
 	*
-	*   ``` text
-	*   0xD800 + 0x0001 = 0xD801 => 1101100000000001
-	*   ```
+	*     ```text
+	*     0xD800 + 0x0001 = 0xD801 => 1101100000000001
+	*     ```
 	*
-	* * Add 0xDC00 to low 10-bits to get low surrogate.
+	* -   Add 0xDC00 to low 10-bits to get low surrogate.
 	*
-	*   ``` text
-	*   0xDC00 + 0x0037 = 0xDC37 => 1101110000110111
-	*   ```
+	*     ```text
+	*     0xDC00 + 0x0037 = 0xDC37 => 1101110000110111
+	*     ```
 	*/
 
 	expected = [