Merge branch 'develop' of https://github.com/stdlib-js/stdlib into develop

---
type: pre_push_report
description: Results of running various checks prior to pushing changes.
report:
  - task: run_javascript_examples
    status: na
  - task: run_c_examples
    status: na
  - task: run_cpp_examples
    status: na
  - task: run_javascript_readme_examples
    status: na
  - task: run_c_benchmarks
    status: na
  - task: run_cpp_benchmarks
    status: na
  - task: run_fortran_benchmarks
    status: na
  - task: run_javascript_benchmarks
    status: na
  - task: run_julia_benchmarks
    status: na
  - task: run_python_benchmarks
    status: na
  - task: run_r_benchmarks
    status: na
  - task: run_javascript_tests
    status: na
---

Author: kgryte

lib/node_modules/@stdlib/_tools/eslint/rules/README.md

@@ -58,6 +58,7 @@ var eslint = rules;
 -   <span class="signature">[`empty-line-before-comment`][@stdlib/_tools/eslint/rules/empty-line-before-comment]</span><span class="delimiter">: </span><span class="description">ESLint rule to enforce empty lines before comments.</span>
 -   <span class="signature">[`eol-open-bracket-spacing`][@stdlib/_tools/eslint/rules/eol-open-bracket-spacing]</span><span class="delimiter">: </span><span class="description">ESLint rule to enforce that no spaces are present between an opening parenthesis or bracket and a nested object or array expression at the end of a line.</span>
 -   <span class="signature">[`first-unit-test`][@stdlib/_tools/eslint/rules/first-unit-test]</span><span class="delimiter">: </span><span class="description">ESLint rule to enforce that a tape file starts with the expected test.</span>
+-   <span class="signature">[`line-closing-bracket-spacing`][@stdlib/_tools/eslint/rules/line-closing-bracket-spacing]</span><span class="delimiter">: </span><span class="description">ESLint rule to enforce that no spaces are present between a closing parenthesis or bracket and a nested object or array expression at the beginning of a line.</span>
 -   <span class="signature">[`module-exports-last`][@stdlib/_tools/eslint/rules/module-exports-last]</span><span class="delimiter">: </span><span class="description">ESLint rule enforcing that export statements appear at the end of a file.</span>
 -   <span class="signature">[`namespace-export-all`][@stdlib/_tools/eslint/rules/namespace-export-all]</span><span class="delimiter">: </span><span class="description">ESLint rule to enforce that a namespace `index.js` exports all packages in the respective namespace directory.</span>
 -   <span class="signature">[`namespace-index-order`][@stdlib/_tools/eslint/rules/namespace-index-order]</span><span class="delimiter">: </span><span class="description">ESLint rule to enforce that modules in a namespace `index.js` file are listed in alphabetical order according to module name.</span>
@@ -377,6 +378,8 @@ console.log( getKeys( rules ) );
 
 [@stdlib/_tools/eslint/rules/first-unit-test]: https://github.com/stdlib-js/stdlib/tree/develop/lib/node_modules/%40stdlib/_tools/eslint/rules/first-unit-test
 
+[@stdlib/_tools/eslint/rules/line-closing-bracket-spacing]: https://github.com/stdlib-js/stdlib/tree/develop/lib/node_modules/%40stdlib/_tools/eslint/rules/line-closing-bracket-spacing
+
 [@stdlib/_tools/eslint/rules/module-exports-last]: https://github.com/stdlib-js/stdlib/tree/develop/lib/node_modules/%40stdlib/_tools/eslint/rules/module-exports-last
 
 [@stdlib/_tools/eslint/rules/namespace-export-all]: https://github.com/stdlib-js/stdlib/tree/develop/lib/node_modules/%40stdlib/_tools/eslint/rules/namespace-export-all

lib/node_modules/@stdlib/array/base/cuany-by/README.md

@@ -148,7 +148,6 @@ console.log( out );
 
 <section class="links">
 
-
 </section>
 
 <!-- /.links -->

lib/node_modules/@stdlib/blas/base/gaxpy/README.md

@@ -159,8 +159,8 @@ console.log( y );
 
 ## See Also
 
--   <span class="package-name">[`@stdlib/blas/base/daxpy`][@stdlib/blas/base/daxpy]</span><span class="delimiter">: </span><span class="description">multiply a vector x by a constant and add the result to y.</span>
--   <span class="package-name">[`@stdlib/blas/base/saxpy`][@stdlib/blas/base/saxpy]</span><span class="delimiter">: </span><span class="description">multiply a vector x by a constant and add the result to y.</span>
+-   <span class="package-name">[`@stdlib/blas/base/daxpy`][@stdlib/blas/base/daxpy]</span><span class="delimiter">: </span><span class="description">multiply a vector `x` by a constant and add the result to `y`.</span>
+-   <span class="package-name">[`@stdlib/blas/base/saxpy`][@stdlib/blas/base/saxpy]</span><span class="delimiter">: </span><span class="description">multiply a vector `x` by a constant and add the result to `y`.</span>
 
 </section>
 

lib/node_modules/@stdlib/nlp/sentencize/README.md

@@ -90,6 +90,12 @@ bool = ( out[ 0 ] === sentences[ 0 ] );
 
 <section class="related">
 
+* * *
+
+## See Also
+
+-   <span class="package-name">[`@stdlib/nlp/tokenize`][@stdlib/nlp/tokenize]</span><span class="delimiter">: </span><span class="description">tokenize a string.</span>
+
 </section>
 
 <!-- /.related -->
@@ -98,6 +104,12 @@ bool = ( out[ 0 ] === sentences[ 0 ] );
 
 <section class="links">
 
+<!-- <related-links> -->
+
+[@stdlib/nlp/tokenize]: https://github.com/stdlib-js/stdlib/tree/develop/lib/node_modules/%40stdlib/nlp/tokenize
+
+<!-- </related-links> -->
+
 </section>
 
 <!-- /.links -->

lib/node_modules/@stdlib/repl/code-blocks/data/data.csv

@@ -1844,8 +1844,8 @@ base.strided.dnannsumors,"\nbase.strided.dnannsumors( N:integer, x:Float64Array,
 base.strided.dnannsumors.ndarray,"\nbase.strided.dnannsumors.ndarray( N:integer, x:Float64Array, strideX:integer, \n  offsetX:integer, out:Float64Array, strideOut:integer, offsetOut:integer )\n    Computes the sum of double-precision floating-point strided array elements,\n    ignoring `NaN` values and using ordinary recursive summation and alternative\n    indexing semantics.\n"
 base.strided.dnannsumpw,"\nbase.strided.dnannsumpw( N:integer, x:Float64Array, strideX:integer, \n  out:Float64Array, strideOut:integer )\n    Computes the sum of double-precision floating-point strided array elements,\n    ignoring `NaN` values and using pairwise summation.\n"
 base.strided.dnannsumpw.ndarray,"\nbase.strided.dnannsumpw.ndarray( N:integer, x:Float64Array, strideX:integer, \n  offsetX:integer, out:Float64Array, strideOut:integer, offsetOut:integer )\n    Computes the sum of double-precision floating-point strided array elements,\n    ignoring `NaN` values and using pairwise summation and alternative indexing\n    semantics.\n"
-base.strided.dnanrange,"\nbase.strided.dnanrange( N:integer, x:Float64Array, stride:integer )\n    Computes the range of a double-precision floating-point strided array,\n    ignoring `NaN` values.\n"
-base.strided.dnanrange.ndarray,"\nbase.strided.dnanrange.ndarray( N:integer, x:Float64Array, stride:integer, \n  offset:integer )\n    Computes the range of a double-precision floating-point strided array,\n    ignoring `NaN` values and using alternative indexing semantics.\n"
+base.strided.dnanrange,"\nbase.strided.dnanrange( N:integer, x:Float64Array, strideX:integer )\n    Computes the range of a double-precision floating-point strided array,\n    ignoring `NaN` values.\n"
+base.strided.dnanrange.ndarray,"\nbase.strided.dnanrange.ndarray( N:integer, x:Float64Array, strideX:integer, \n  offsetX:integer )\n    Computes the range of a double-precision floating-point strided array,\n    ignoring `NaN` values and using alternative indexing semantics.\n"
 base.strided.dnanstdev,"\nbase.strided.dnanstdev( N:integer, correction:number, x:Float64Array, \n  stride:integer )\n    Computes the standard deviation of a double-precision floating-point strided\n    array ignoring `NaN` values.\n"
 base.strided.dnanstdev.ndarray,"\nbase.strided.dnanstdev.ndarray( N:integer, correction:number, x:Float64Array, \n  stride:integer, offset:integer )\n    Computes the standard deviation of a double-precision floating-point strided\n    array ignoring `NaN` values and using alternative indexing semantics.\n"
 base.strided.dnanstdevch,"\nbase.strided.dnanstdevch( N:integer, correction:number, x:Float64Array, \n  stride:integer )\n    Computes the standard deviation of a double-precision floating-point strided\n    array ignoring `NaN` values and using a one-pass trial mean algorithm.\n"
@@ -2355,8 +2355,8 @@ base.strided.smsktrunc,"\nbase.strided.smsktrunc( N:integer, x:Float32Array, sx:
 base.strided.smsktrunc.ndarray,"\nbase.strided.smsktrunc.ndarray( N:integer, x:Float32Array, sx:integer, \n  ox:integer, m:Float32Array, sm:integer, om:integer, y:Float32Array, \n  sy:integer, oy:integer )\n    Rounds each element in a single-precision floating-point strided array `x`\n    toward zero according to a strided mask array and assigns the results to\n    elements in a single-precision floating-point strided array `y` using\n    alternative indexing semantics.\n"
 base.strided.snanmax,"\nbase.strided.snanmax( N:integer, x:Float32Array, strideX:integer )\n    Computes the maximum value of a single-precision floating-point strided\n    array, ignoring `NaN` values.\n"
 base.strided.snanmax.ndarray,"\nbase.strided.snanmax.ndarray( N:integer, x:Float32Array, strideX:integer, \n  offsetX:integer )\n    Computes the maximum value of a single-precision floating-point strided\n    array, ignoring `NaN` values and using alternative indexing semantics.\n"
-base.strided.snanmaxabs,"\nbase.strided.snanmaxabs( N:integer, x:Float32Array, stride:integer )\n    Computes the maximum absolute value of a single-precision floating-point\n    strided array, ignoring `NaN` values.\n"
-base.strided.snanmaxabs.ndarray,"\nbase.strided.snanmaxabs.ndarray( N:integer, x:Float32Array, stride:integer, \n  offset:integer )\n    Computes the maximum absolute value of a single-precision floating-point\n    strided array, ignoring `NaN` values and using alternative indexing\n    semantics.\n"
+base.strided.snanmaxabs,"\nbase.strided.snanmaxabs( N:integer, x:Float32Array, strideX:integer )\n    Computes the maximum absolute value of a single-precision floating-point\n    strided array, ignoring `NaN` values.\n"
+base.strided.snanmaxabs.ndarray,"\nbase.strided.snanmaxabs.ndarray( N:integer, x:Float32Array, strideX:integer, \n  offsetX:integer )\n    Computes the maximum absolute value of a single-precision floating-point\n    strided array, ignoring `NaN` values and using alternative indexing\n    semantics.\n"
 base.strided.snanmean,"\nbase.strided.snanmean( N:integer, x:Float32Array, stride:integer )\n    Computes the arithmetic mean of a single-precision floating-point strided\n    array, ignoring `NaN` values.\n"
 base.strided.snanmean.ndarray,"\nbase.strided.snanmean.ndarray( N:integer, x:Float32Array, stride:integer, \n  offset:integer )\n    Computes the arithmetic mean of a single-precision floating-point strided\n    array, ignoring `NaN` values and using alternative indexing semantics.\n"
 base.strided.snanmeanors,"\nbase.strided.snanmeanors( N:integer, x:Float32Array, stride:integer )\n    Computes the arithmetic mean of a single-precision floating-point strided\n    array, ignoring `NaN` values and using ordinary recursive summation.\n"
@@ -2367,16 +2367,16 @@ base.strided.snanmeanwd,"\nbase.strided.snanmeanwd( N:integer, x:Float32Array, s
 base.strided.snanmeanwd.ndarray,"\nbase.strided.snanmeanwd.ndarray( N:integer, x:Float32Array, stride:integer, \n  offset:integer )\n    Computes the arithmetic mean of a single-precision floating-point strided\n    array, ignoring `NaN` values and using Welford's algorithm and alternative\n    indexing semantics.\n"
 base.strided.snanmin,"\nbase.strided.snanmin( N:integer, x:Float32Array, strideX:integer )\n    Computes the minimum value of a single-precision floating-point strided\n    array, ignoring `NaN` values.\n"
 base.strided.snanmin.ndarray,"\nbase.strided.snanmin.ndarray( N:integer, x:Float32Array, strideX:integer, \n  offsetX:integer )\n    Computes the minimum value of a single-precision floating-point strided\n    array, ignoring `NaN` values and using alternative indexing semantics.\n"
-base.strided.snanminabs,"\nbase.strided.snanminabs( N:integer, x:Float32Array, stride:integer )\n    Computes the minimum absolute value of a single-precision floating-point\n    strided array, ignoring `NaN` values.\n"
-base.strided.snanminabs.ndarray,"\nbase.strided.snanminabs.ndarray( N:integer, x:Float32Array, stride:integer, \n  offset:integer )\n    Computes the minimum absolute value of a single-precision floating-point\n    strided array, ignoring `NaN` values and using alternative indexing\n    semantics.\n"
+base.strided.snanminabs,"\nbase.strided.snanminabs( N:integer, x:Float32Array, strideX:integer )\n    Computes the minimum absolute value of a single-precision floating-point\n    strided array, ignoring `NaN` values.\n"
+base.strided.snanminabs.ndarray,"\nbase.strided.snanminabs.ndarray( N:integer, x:Float32Array, strideX:integer, \n  offsetX:integer )\n    Computes the minimum absolute value of a single-precision floating-point\n    strided array, ignoring `NaN` values and using alternative indexing\n    semantics.\n"
 base.strided.snanmskmax,"\nbase.strided.snanmskmax( N:integer, x:Float32Array, strideX:integer, \n  mask:Uint8Array, strideMask:integer )\n    Computes the maximum value of a single-precision floating-point strided\n    array according to a mask, ignoring `NaN` values.\n"
 base.strided.snanmskmax.ndarray,"\nbase.strided.snanmskmax.ndarray( N:integer, x:Float32Array, strideX:integer, \n  offsetX:integer, mask:Uint8Array, strideMask:integer, offsetMask:integer )\n    Computes the maximum value of a single-precision floating-point strided\n    array according to a mask, ignoring `NaN` values and using alternative\n    indexing semantics.\n"
 base.strided.snanmskmin,"\nbase.strided.snanmskmin( N:integer, x:Float32Array, strideX:integer, \n  mask:Uint8Array, strideMask:integer )\n    Computes the minimum value of a single-precision floating-point strided\n    array according to a mask, ignoring `NaN` values.\n"
 base.strided.snanmskmin.ndarray,"\nbase.strided.snanmskmin.ndarray( N:integer, x:Float32Array, strideX:integer, \n  offsetX:integer, mask:Uint8Array, strideMask:integer, offsetMask:integer )\n    Computes the minimum value of a single-precision floating-point strided\n    array according to a mask, ignoring `NaN` values and using alternative\n    indexing semantics.\n"
 base.strided.snanmskrange,"\nbase.strided.snanmskrange( N:integer, x:Float32Array, strideX:integer, \n  mask:Uint8Array, strideMask:integer )\n    Computes the range of a single-precision floating-point strided array\n    according to a mask, ignoring `NaN` values.\n"
 base.strided.snanmskrange.ndarray,"\nbase.strided.snanmskrange.ndarray( N:integer, x:Float32Array, strideX:integer, \n  offsetX:integer, mask:Uint8Array, strideMask:integer, offsetMask:integer )\n    Computes the range of a single-precision floating-point strided array\n    according to a mask, ignoring `NaN` values and using alternative indexing\n    semantics.\n"
-base.strided.snanrange,"\nbase.strided.snanrange( N:integer, x:Float32Array, stride:integer )\n    Computes the range of a single-precision floating-point strided array,\n    ignoring `NaN` values.\n"
-base.strided.snanrange.ndarray,"\nbase.strided.snanrange.ndarray( N:integer, x:Float32Array, stride:integer, \n  offset:integer )\n    Computes the range of a single-precision floating-point strided array,\n    ignoring `NaN` values and using alternative indexing semantics.\n"
+base.strided.snanrange,"\nbase.strided.snanrange( N:integer, x:Float32Array, strideX:integer )\n    Computes the range of a single-precision floating-point strided array,\n    ignoring `NaN` values.\n"
+base.strided.snanrange.ndarray,"\nbase.strided.snanrange.ndarray( N:integer, x:Float32Array, strideX:integer, \n  offsetX:integer )\n    Computes the range of a single-precision floating-point strided array,\n    ignoring `NaN` values and using alternative indexing semantics.\n"
 base.strided.snanstdev,"\nbase.strided.snanstdev( N:integer, correction:number, x:Float32Array, \n  stride:integer )\n    Computes the standard deviation of a single-precision floating-point strided\n    array ignoring `NaN` values.\n"
 base.strided.snanstdev.ndarray,"\nbase.strided.snanstdev.ndarray( N:integer, correction:number, x:Float32Array, \n  stride:integer, offset:integer )\n    Computes the standard deviation of a single-precision floating-point strided\n    array ignoring `NaN` values and alternative indexing semantics.\n"
 base.strided.snanstdevch,"\nbase.strided.snanstdevch( N:integer, correction:number, x:Float32Array, \n  stride:integer )\n    Computes the standard deviation of a single-precision floating-point strided\n    array ignoring `NaN` values and using a one-pass trial mean algorithm.\n"