diff --git a/lib/node_modules/@stdlib/blas/base/dsyr/README.md b/lib/node_modules/@stdlib/blas/base/dsyr/README.md
index 62b1b6179a5d..dbfe5131e9e4 100644
--- a/lib/node_modules/@stdlib/blas/base/dsyr/README.md
+++ b/lib/node_modules/@stdlib/blas/base/dsyr/README.md
@@ -183,21 +183,65 @@ console.log( A );
 ### Usage
 
 ```c
-TODO
+#include "stdlib/blas/base/dsyr.h"
 ```
 
-#### TODO
+#### c_dsyr( order, uplo, N, alpha, \*X, strideX, \*A, LDA )
 
-TODO.
+Performs the symmetric rank 1 operation `A = α*x*x^T + A`.
 
 ```c
-TODO
+#include "stdlib/blas/base/shared.h"
+
+double A[] = { 1.0, 0.0, 0.0, 2.0, 1.0, 0.0, 3.0, 2.0, 1.0 };
+const double x[] = { 1.0, 2.0, 3.0 };
+
+c_dsyr( CblasColMajor, CblasUpper, 3, 1.0, x, 1, A, 3 );
+```
+
+The function accepts the following arguments:
+
+-   **order**: `[in] CBLAS_LAYOUT` storage layout.
+-   **uplo**: `[in] CBLAS_UPLO` specifies whether the upper or lower triangular part of the symmetric matrix `A` should be referenced.
+-   **N**: `[in] CBLAS_INT` number of elements along each dimension of `A`.
+-   **alpha**: `[in] double` scalar.
+-   **X**: `[in] double*` input array.
+-   **strideX**: `[in] CBLAS_INT` index increment for `X`.
+-   **A**: `[inout] double*` input matrix.
+-   **LDA**: `[in] CBLAS_INT` stride of the first dimension of `A` (a.k.a., leading dimension of the matrix `A`).
+
+```c
+void c_dsyr( const CBLAS_LAYOUT order, const CBLAS_UPLO uplo, const CBLAS_INT N, const double alpha, const double *X, const CBLAS_INT strideX, double *A, const CBLAS_INT LDA )
 ```
 
-TODO
+#### c_dsyr_ndarray( uplo, N, alpha, \*X, strideX, offsetX, \*A, sa1, sa2, oa )
+
+Performs the symmetric rank 1 operation `A = α*x*x^T + A` using alternative indexing semantics.
+
+```c
+#include "stdlib/blas/base/shared.h"
+
+double A[] = { 1.0, 2.0, 3.0, 0.0, 1.0, 2.0, 0.0, 0.0, 1.0 };
+const double x[] = { 1.0, 2.0, 3.0 };
+
+c_dsyr_ndarray( CblasUpper, 3, 1.0, x, 1, 0, A, 3, 1, 0 );
+```
+
+The function accepts the following arguments:
+
+-   **uplo**: `[in] CBLAS_UPLO` specifies whether the upper or lower triangular part of the symmetric matrix `A` should be referenced.
+-   **N**: `[in] CBLAS_INT` number of elements along each dimension of `A`.
+-   **alpha**: `[in] double` scalar.
+-   **X**: `[in] double*` input array.
+-   **strideX**: `[in] CBLAS_INT` index increment for `X`.
+-   **offsetX**: `[in] CBLAS_INT` starting index for `X`.
+-   **A**: `[inout] double*` input matrix.
+-   **sa1**: `[in] CBLAS_INT` stride of the first dimension of `A`.
+-   **sa2**: `[in] CBLAS_INT` stride of the second dimension of `A`.
+-   **oa**: `[in] CBLAS_INT` starting index for `A`.
 
 ```c
-TODO
+void c_dsyr_ndarray( const CBLAS_UPLO uplo, const CBLAS_INT N, const double alpha, const double *X, const CBLAS_INT strideX, const CBLAS_INT offsetX, double *A, const CBLAS_INT sa1, const CBLAS_INT sa2, const CBLAS_INT oa )
 ```
 
 </section>
@@ -219,7 +263,34 @@ TODO
 ### Examples
 
 ```c
-TODO
+#include "stdlib/blas/base/dsyr.h"
+#include "stdlib/blas/base/shared.h"
+#include <stdio.h>
+
+int main( void ) {
+    // Create strided arrays:
+    double A[] = { 1.0, 0.0, 0.0, 2.0, 1.0, 0.0, 3.0, 2.0, 1.0 };
+    const double x[] = { 1.0, 2.0, 3.0 };
+
+    // Specify the number of elements along each dimension of `A`:
+    const int N = 3;
+
+    // Perform the symmetric rank 1 operation `A = α*x*x^T + A`:
+    c_dsyr( CblasColMajor, CblasUpper, N, 1.0, x, 1, A, N );
+
+    // Print the result:
+    for ( int i = 0; i < N*N; i++ ) {
+        printf( "A[ %i ] = %f\n", i, A[ i ] );
+    }
+
+    // Perform the symmetric rank 1 operation `A = α*x*x^T + A`:
+    c_dsyr_ndarray( CblasUpper, N, 1.0, x, 1, 0, A, N, 1, 0 );
+
+    // Print the result:
+    for ( int i = 0; i < N*N; i++ ) {
+        printf( "A[ %i ] = %f\n", i, A[ i ] );
+    }
+}
 ```
 
 </section>
diff --git a/lib/node_modules/@stdlib/blas/base/dsyr/benchmark/benchmark.native.js b/lib/node_modules/@stdlib/blas/base/dsyr/benchmark/benchmark.native.js
new file mode 100644
index 000000000000..ec7bf95c8b72
--- /dev/null
+++ b/lib/node_modules/@stdlib/blas/base/dsyr/benchmark/benchmark.native.js
@@ -0,0 +1,109 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 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 resolve = require( 'path' ).resolve;
+var bench = require( '@stdlib/bench' );
+var isnan = require( '@stdlib/math/base/assert/is-nan' );
+var ones = require( '@stdlib/array/ones' );
+var pow = require( '@stdlib/math/base/special/pow' );
+var floor = require( '@stdlib/math/base/special/floor' );
+var tryRequire = require( '@stdlib/utils/try-require' );
+var pkg = require( './../package.json' ).name;
+
+
+// VARIABLES //
+
+var dsyr = tryRequire( resolve( __dirname, './../lib/dsyr.native.js' ) );
+var opts = {
+	'skip': ( dsyr instanceof Error )
+};
+var options = {
+	'dtype': 'float64'
+};
+
+
+// FUNCTIONS //
+
+/**
+* Creates a benchmark function.
+*
+* @private
+* @param {PositiveInteger} N - number of elements along each dimension
+* @returns {Function} benchmark function
+*/
+function createBenchmark( N ) {
+	var x = ones( N, options.dtype );
+	var A = ones( N*N, options.dtype );
+	return benchmark;
+
+	/**
+	* Benchmark function.
+	*
+	* @private
+	* @param {Benchmark} b - benchmark instance
+	*/
+	function benchmark( b ) {
+		var z;
+		var i;
+
+		b.tic();
+		for ( i = 0; i < b.iterations; i++ ) {
+			z = dsyr( 'row-major', 'upper', N, 1.0, x, 1, A, N );
+			if ( isnan( z[ i%z.length ] ) ) {
+				b.fail( 'should not return NaN' );
+			}
+		}
+		b.toc();
+		if ( isnan( z[ i%z.length ] ) ) {
+			b.fail( 'should not return NaN' );
+		}
+		b.pass( 'benchmark finished' );
+		b.end();
+	}
+}
+
+
+// MAIN //
+
+/**
+* Main execution sequence.
+*
+* @private
+*/
+function main() {
+	var min;
+	var max;
+	var N;
+	var f;
+	var i;
+
+	min = 1; // 10^min
+	max = 6; // 10^max
+
+	for ( i = min; i <= max; i++ ) {
+		N = floor( pow( pow( 10, i ), 1.0/2.0 ) );
+		f = createBenchmark( N );
+		bench( pkg+'::native:size='+(N*N), opts, f );
+	}
+}
+
+main();
diff --git a/lib/node_modules/@stdlib/blas/base/dsyr/benchmark/benchmark.ndarray.native.js b/lib/node_modules/@stdlib/blas/base/dsyr/benchmark/benchmark.ndarray.native.js
new file mode 100644
index 000000000000..d9c133e73870
--- /dev/null
+++ b/lib/node_modules/@stdlib/blas/base/dsyr/benchmark/benchmark.ndarray.native.js
@@ -0,0 +1,109 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 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 resolve = require( 'path' ).resolve;
+var bench = require( '@stdlib/bench' );
+var isnan = require( '@stdlib/math/base/assert/is-nan' );
+var ones = require( '@stdlib/array/ones' );
+var pow = require( '@stdlib/math/base/special/pow' );
+var floor = require( '@stdlib/math/base/special/floor' );
+var tryRequire = require( '@stdlib/utils/try-require' );
+var pkg = require( './../package.json' ).name;
+
+
+// VARIABLES //
+
+var dsyr = tryRequire( resolve( __dirname, './../lib/ndarray.native.js' ) );
+var opts = {
+	'skip': ( dsyr instanceof Error )
+};
+var options = {
+	'dtype': 'float64'
+};
+
+
+// FUNCTIONS //
+
+/**
+* Creates a benchmark function.
+*
+* @private
+* @param {PositiveInteger} N - number of elements along each dimension
+* @returns {Function} benchmark function
+*/
+function createBenchmark( N ) {
+	var x = ones( N, options.dtype );
+	var A = ones( N*N, options.dtype );
+	return benchmark;
+
+	/**
+	* Benchmark function.
+	*
+	* @private
+	* @param {Benchmark} b - benchmark instance
+	*/
+	function benchmark( b ) {
+		var z;
+		var i;
+
+		b.tic();
+		for ( i = 0; i < b.iterations; i++ ) {
+			z = dsyr( 'upper', N, 1.0, x, 1, 0, A, N, 1, 0 );
+			if ( isnan( z[ i%z.length ] ) ) {
+				b.fail( 'should not return NaN' );
+			}
+		}
+		b.toc();
+		if ( isnan( z[ i%z.length ] ) ) {
+			b.fail( 'should not return NaN' );
+		}
+		b.pass( 'benchmark finished' );
+		b.end();
+	}
+}
+
+
+// MAIN //
+
+/**
+* Main execution sequence.
+*
+* @private
+*/
+function main() {
+	var min;
+	var max;
+	var N;
+	var f;
+	var i;
+
+	min = 1; // 10^min
+	max = 6; // 10^max
+
+	for ( i = min; i <= max; i++ ) {
+		N = floor( pow( pow( 10, i ), 1.0/2.0 ) );
+		f = createBenchmark( N );
+		bench( pkg+'::native:ndarray:size='+(N*N), opts, f );
+	}
+}
+
+main();
diff --git a/lib/node_modules/@stdlib/blas/base/dsyr/benchmark/c/Makefile b/lib/node_modules/@stdlib/blas/base/dsyr/benchmark/c/Makefile
new file mode 100644
index 000000000000..a4bd7b38fd74
--- /dev/null
+++ b/lib/node_modules/@stdlib/blas/base/dsyr/benchmark/c/Makefile
@@ -0,0 +1,146 @@
+#/
+# @license Apache-2.0
+#
+# Copyright (c) 2025 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/blas/base/dsyr/benchmark/c/benchmark.c b/lib/node_modules/@stdlib/blas/base/dsyr/benchmark/c/benchmark.c
new file mode 100644
index 000000000000..80bdea3c21f0
--- /dev/null
+++ b/lib/node_modules/@stdlib/blas/base/dsyr/benchmark/c/benchmark.c
@@ -0,0 +1,179 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 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/blas/base/dsyr.h"
+#include "stdlib/blas/base/shared.h"
+#include "stdlib/blas/ext/base/sfill.h"
+#include <stdlib.h>
+#include <stdio.h>
+#include <math.h>
+#include <time.h>
+#include <sys/time.h>
+
+#define NAME "dsyr"
+#define ITERATIONS 10000000
+#define REPEATS 3
+#define MIN 1
+#define MAX 6
+
+/**
+* Prints the TAP version.
+*/
+static void print_version( void ) {
+	printf( "TAP version 13\n" );
+}
+
+/**
+* Prints the TAP summary.
+*
+* @param total     total number of tests
+* @param passing   total number of passing tests
+*/
+static void print_summary( int total, int passing ) {
+	printf( "#\n" );
+	printf( "1..%d\n", total ); // TAP plan
+	printf( "# total %d\n", total );
+	printf( "# pass  %d\n", passing );
+	printf( "#\n" );
+	printf( "# ok\n" );
+}
+
+/**
+* Prints benchmarks results.
+*
+* @param iterations   number of iterations
+* @param elapsed      elapsed time in seconds
+*/
+static void print_results( int iterations, double elapsed ) {
+	double rate = (double)iterations / elapsed;
+	printf( "  ---\n" );
+	printf( "  iterations: %d\n", iterations );
+	printf( "  elapsed: %0.9f\n", elapsed );
+	printf( "  rate: %0.9f\n", rate );
+	printf( "  ...\n" );
+}
+
+/**
+* Returns a clock time.
+*
+* @return clock time
+*/
+static double tic( void ) {
+	struct timeval now;
+	gettimeofday( &now, NULL );
+	return (double)now.tv_sec + (double)now.tv_usec/1.0e6;
+}
+
+/**
+* Runs a benchmark.
+*
+* @param iterations   number of iterations
+* @param N            number of elements along each dimension
+* @return             elapsed time in seconds
+*/
+static double benchmark1( int iterations, int N ) {
+	double elapsed;
+	double A[ N*N ];
+	double x[ N ];
+	double t;
+	int i;
+
+	stdlib_strided_sfill( N, 0.5, x, 1 );
+	stdlib_strided_sfill( N*N, 1.0, A, 1 );
+	t = tic();
+	for ( i = 0; i < iterations; i++ ) {
+		c_dsyr( CblasRowMajor, CblasUpper, N, 1.0, x, 1, A, N );
+		if ( A[ 0 ] != A[ 0 ] ) {
+			printf( "should not return NaN\n" );
+			break;
+		}
+	}
+	elapsed = tic() - t;
+	if ( A[ 0 ] != A[ 0 ] ) {
+		printf( "should not return NaN\n" );
+	}
+	return elapsed;
+}
+
+/**
+* Runs a benchmark.
+*
+* @param iterations   number of iterations
+* @param N            number of elements along each dimension
+* @return             elapsed time in seconds
+*/
+static double benchmark2( int iterations, int N ) {
+	double elapsed;
+	double A[ N*N ];
+	double x[ N ];
+	double t;
+	int i;
+
+	stdlib_strided_sfill( N, 0.5, x, 1 );
+	stdlib_strided_sfill( N*N, 1.0, A, 1 );
+	t = tic();
+	for ( i = 0; i < iterations; i++ ) {
+		c_dsyr_ndarray( CblasUpper, N, 1.0, x, 1, 0, A, N, 1, 0 );
+		if ( A[ 0 ] != A[ 0 ] ) {
+			printf( "should not return NaN\n" );
+			break;
+		}
+	}
+	elapsed = tic() - t;
+	if ( A[ 0 ] != A[ 0 ] ) {
+		printf( "should not return NaN\n" );
+	}
+	return elapsed;
+}
+
+/**
+* Main execution sequence.
+*/
+int main( void ) {
+	double elapsed;
+	int count;
+	int iter;
+	int i;
+	int j;
+	int N;
+
+	// Use the current time to seed the random number generator:
+	srand( time( NULL ) );
+
+	print_version();
+	count = 0;
+	for ( i = MIN; i <= MAX; i++ ) {
+		N = floor( pow( pow( 10, i ), 1.0/2.0 ) );
+		iter = ITERATIONS / pow( 10, i-1 );
+		for ( j = 0; j < REPEATS; j++ ) {
+			count += 1;
+			printf( "# c::%s:size=%d\n", NAME, N*N );
+			elapsed = benchmark1( iter, N );
+			print_results( iter, elapsed );
+			printf( "ok %d benchmark finished\n", count );
+		}
+		for ( j = 0; j < REPEATS; j++ ) {
+			count += 1;
+			printf( "# c::%s:ndarray:size=%d\n", NAME, N*N );
+			elapsed = benchmark2( iter, N );
+			print_results( iter, elapsed );
+			printf( "ok %d benchmark finished\n", count );
+		}
+	}
+	print_summary( count, count );
+}
diff --git a/lib/node_modules/@stdlib/blas/base/dsyr/binding.gyp b/lib/node_modules/@stdlib/blas/base/dsyr/binding.gyp
new file mode 100644
index 000000000000..08de71a2020e
--- /dev/null
+++ b/lib/node_modules/@stdlib/blas/base/dsyr/binding.gyp
@@ -0,0 +1,265 @@
+# @license Apache-2.0
+#
+# Copyright (c) 2025 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=<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',
+      ],
+
+      # 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/blas/base/dsyr/examples/c/Makefile b/lib/node_modules/@stdlib/blas/base/dsyr/examples/c/Makefile
new file mode 100644
index 000000000000..25ced822f96a
--- /dev/null
+++ b/lib/node_modules/@stdlib/blas/base/dsyr/examples/c/Makefile
@@ -0,0 +1,146 @@
+#/
+# @license Apache-2.0
+#
+# Copyright (c) 2025 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/blas/base/dsyr/examples/c/example.c b/lib/node_modules/@stdlib/blas/base/dsyr/examples/c/example.c
new file mode 100644
index 000000000000..0ecb27a64801
--- /dev/null
+++ b/lib/node_modules/@stdlib/blas/base/dsyr/examples/c/example.c
@@ -0,0 +1,46 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 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/blas/base/dsyr.h"
+#include "stdlib/blas/base/shared.h"
+#include <stdio.h>
+
+int main( void ) {
+	// Create strided arrays:
+	double A[] = { 1.0, 0.0, 0.0, 2.0, 1.0, 0.0, 3.0, 2.0, 1.0 };
+	const double x[] = { 1.0, 2.0, 3.0 };
+
+	// Specify the number of elements along each dimension of `A`:
+	const int N = 3;
+
+	// Perform the symmetric rank 1 operation `A = α*x*x^T + A`:
+	c_dsyr( CblasColMajor, CblasUpper, N, 1.0, x, 1, A, N );
+
+	// Print the result:
+	for ( int i = 0; i < N*N; i++ ) {
+		printf( "A[ %i ] = %f\n", i, A[ i ] );
+	}
+
+	// Perform the symmetric rank 1 operation `A = α*x*x^T + A`:
+	c_dsyr_ndarray( CblasUpper, N, 1.0, x, 1, 0, A, N, 1, 0 );
+
+	// Print the result:
+	for ( int i = 0; i < N*N; i++ ) {
+		printf( "A[ %i ] = %f\n", i, A[ i ] );
+	}
+}
diff --git a/lib/node_modules/@stdlib/blas/base/dsyr/include.gypi b/lib/node_modules/@stdlib/blas/base/dsyr/include.gypi
new file mode 100644
index 000000000000..4217944b5d20
--- /dev/null
+++ b/lib/node_modules/@stdlib/blas/base/dsyr/include.gypi
@@ -0,0 +1,70 @@
+# @license Apache-2.0
+#
+# Copyright (c) 2025 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>):
+      'blas%': '',
+
+      # Path to BLAS library (to override -Dblas_dir=<path>):
+      'blas_dir%': '',
+    }, # end variables
+
+    # Source directory:
+    'src_dir': './src',
+
+    # Include directories:
+    'include_dirs': [
+      '<@(blas_dir)',
+      '<!@(node -e "var arr = require(\'@stdlib/utils/library-manifest\')(\'./manifest.json\',{\'os\':\'<(OS)\',\'blas\':\'<(blas)\'},{\'basedir\':process.cwd(),\'paths\':\'posix\'}).include; for ( var i = 0; i < arr.length; i++ ) { console.log( arr[ i ] ); }")',
+    ],
+
+    # Add-on destination directory:
+    'addon_output_dir': './src',
+
+    # Source files:
+    'src_files': [
+      '<(src_dir)/addon.c',
+      '<!@(node -e "var arr = require(\'@stdlib/utils/library-manifest\')(\'./manifest.json\',{\'os\':\'<(OS)\',\'blas\':\'<(blas)\'},{\'basedir\':process.cwd(),\'paths\':\'posix\'}).src; for ( var i = 0; i < arr.length; i++ ) { console.log( arr[ i ] ); }")',
+    ],
+
+    # Library dependencies:
+    'libraries': [
+      '<!@(node -e "var arr = require(\'@stdlib/utils/library-manifest\')(\'./manifest.json\',{\'os\':\'<(OS)\',\'blas\':\'<(blas)\'},{\'basedir\':process.cwd(),\'paths\':\'posix\'}).libraries; for ( var i = 0; i < arr.length; i++ ) { console.log( arr[ i ] ); }")',
+    ],
+
+    # Library directories:
+    'library_dirs': [
+      '<@(blas_dir)',
+      '<!@(node -e "var arr = require(\'@stdlib/utils/library-manifest\')(\'./manifest.json\',{\'os\':\'<(OS)\',\'blas\':\'<(blas)\'},{\'basedir\':process.cwd(),\'paths\':\'posix\'}).libpath; for ( var i = 0; i < arr.length; i++ ) { console.log( arr[ i ] ); }")',
+    ],
+  }, # end variables
+}
diff --git a/lib/node_modules/@stdlib/blas/base/dsyr/include/stdlib/blas/base/dsyr.h b/lib/node_modules/@stdlib/blas/base/dsyr/include/stdlib/blas/base/dsyr.h
new file mode 100644
index 000000000000..8d192bc4007d
--- /dev/null
+++ b/lib/node_modules/@stdlib/blas/base/dsyr/include/stdlib/blas/base/dsyr.h
@@ -0,0 +1,48 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 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.
+*/
+
+/**
+* Header file containing function declarations for the C interface to the BLAS Level 2 routine `dsyr`.
+*/
+#ifndef DSYR_H
+#define DSYR_H
+
+#include "stdlib/blas/base/shared.h"
+
+/*
+* If C++, prevent name mangling so that the compiler emits a binary file having undecorated names, thus mirroring the behavior of a C compiler.
+*/
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+* Performs the symmetric rank 1 operation `A = α*x*x^T + A`.
+*/
+void API_SUFFIX(c_dsyr)( const CBLAS_LAYOUT order, const CBLAS_UPLO uplo, const CBLAS_INT N, const double alpha, const double *X, const CBLAS_INT strideX, double *A, const CBLAS_INT LDA );
+
+/**
+* Performs the symmetric rank 1 operation `A = α*x*x^T + A` using alternative indexing semantics.
+*/
+void API_SUFFIX(c_dsyr_ndarray)( const CBLAS_UPLO uplo, const CBLAS_INT N, const double alpha, const double *X, const CBLAS_INT strideX, const CBLAS_INT offsetX, double *A, const CBLAS_INT strideA1, const CBLAS_INT strideA2, const CBLAS_INT offsetA );
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // !DSYR_H
diff --git a/lib/node_modules/@stdlib/blas/base/dsyr/include/stdlib/blas/base/dsyr_cblas.h b/lib/node_modules/@stdlib/blas/base/dsyr/include/stdlib/blas/base/dsyr_cblas.h
new file mode 100644
index 000000000000..ceb0f69dcba5
--- /dev/null
+++ b/lib/node_modules/@stdlib/blas/base/dsyr/include/stdlib/blas/base/dsyr_cblas.h
@@ -0,0 +1,43 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 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.
+*/
+
+/**
+* Header file containing function declarations for the C interface to the CBLAS Level 2 routine `cblas_dsyr`.
+*/
+#ifndef DSYR_CBLAS_H
+#define DSYR_CBLAS_H
+
+#include "stdlib/blas/base/shared.h"
+
+/*
+* If C++, prevent name mangling so that the compiler emits a binary file having undecorated names, thus mirroring the behavior of a C compiler.
+*/
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+* Performs the symmetric rank 1 operation `A = α*x*x^T + A`.
+*/
+void API_SUFFIX(cblas_ssyr)( const CBLAS_LAYOUT order, const CBLAS_UPLO uplo, const CBLAS_INT N, const double alpha, const double *X, const CBLAS_INT strideX, double *A, const CBLAS_INT LDA );
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // !DSYR_CBLAS_H
diff --git a/lib/node_modules/@stdlib/blas/base/dsyr/lib/dsyr.native.js b/lib/node_modules/@stdlib/blas/base/dsyr/lib/dsyr.native.js
new file mode 100644
index 000000000000..47d2292e7306
--- /dev/null
+++ b/lib/node_modules/@stdlib/blas/base/dsyr/lib/dsyr.native.js
@@ -0,0 +1,60 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 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 resolveOrder = require( '@stdlib/blas/base/layout-resolve-enum' );
+var resolveUplo = require( '@stdlib/blas/base/matrix-triangle-resolve-enum' );
+var addon = require( './../src/addon.node' );
+
+
+// MAIN //
+
+/**
+* Performs the symmetric rank 1 operation `A = α*x*x^T + A`.
+*
+* @param {string} order - storage layout
+* @param {string} uplo - specifies whether the upper or lower triangular part of the symmetric matrix `A` should be referenced
+* @param {NonNegativeInteger} N - number of elements along each dimension of `A`
+* @param {number} alpha - scalar
+* @param {Float64Array} x - input vector
+* @param {integer} strideX - `x` stride length
+* @param {Float64Array} A - input matrix
+* @param {integer} LDA - stride of the first dimension of `A` (a.k.a., leading dimension of the matrix `A`)
+* @returns {Float64Array} `A`
+*
+* @example
+* var Float64Array = require( '@stdlib/array/float64' );
+*
+* var A = new Float64Array( [ 1.0, 2.0, 3.0, 0.0, 1.0, 2.0, 0.0, 0.0, 1.0 ] ); // => [ [ 1.0, 2.0, 3.0 ], [ 0.0, 1.0, 2.0 ], [ 0.0, 0.0, 1.0 ] ]
+* var x = new Float64Array( [ 1.0, 2.0, 3.0 ] );
+*
+* dsyr( 'row-major', 'upper', 3, 1.0, x, 1, A, 3 );
+* // A => <Float64Array>[ 2.0, 4.0, 6.0, 0.0, 5.0, 8.0, 0.0, 0.0, 10.0 ]
+*/
+function dsyr( order, uplo, N, alpha, x, strideX, A, LDA ) {
+	addon( resolveOrder( order ), resolveUplo( uplo ), N, alpha, x, strideX, A, LDA ); // eslint-disable-line max-len
+	return A;
+}
+
+
+// EXPORTS //
+
+module.exports = dsyr;
diff --git a/lib/node_modules/@stdlib/blas/base/dsyr/lib/native.js b/lib/node_modules/@stdlib/blas/base/dsyr/lib/native.js
new file mode 100644
index 000000000000..4c4d0bb3579d
--- /dev/null
+++ b/lib/node_modules/@stdlib/blas/base/dsyr/lib/native.js
@@ -0,0 +1,35 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 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 setReadOnly = require( '@stdlib/utils/define-nonenumerable-read-only-property' );
+var dsyr = require( './dsyr.native.js' );
+var ndarray = require( './ndarray.native.js' );
+
+
+// MAIN //
+
+setReadOnly( dsyr, 'ndarray', ndarray );
+
+
+// EXPORTS //
+
+module.exports = dsyr;
diff --git a/lib/node_modules/@stdlib/blas/base/dsyr/lib/ndarray.native.js b/lib/node_modules/@stdlib/blas/base/dsyr/lib/ndarray.native.js
new file mode 100644
index 000000000000..72bd9717561e
--- /dev/null
+++ b/lib/node_modules/@stdlib/blas/base/dsyr/lib/ndarray.native.js
@@ -0,0 +1,61 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 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 resolveUplo = require( '@stdlib/blas/base/matrix-triangle-resolve-enum' );
+var addon = require( './../src/addon.node' );
+
+
+// MAIN //
+
+/**
+* Performs the symmetric rank 1 operation `A = α*x*x^T + A`.
+*
+* @param {string} uplo - specifies whether the upper or lower triangular part of the symmetric matrix `A` should be referenced
+* @param {NonNegativeInteger} N - number of elements along each dimension of `A`
+* @param {number} alpha - scalar
+* @param {Float64Array} x - input vector
+* @param {integer} strideX - `x` stride length
+* @param {NonNegativeInteger} offsetX - starting index for `x`
+* @param {Float64Array} A - input matrix
+* @param {integer} strideA1 - stride of the first dimension of `A`
+* @param {integer} strideA2 - stride of the second dimension of `A`
+* @param {NonNegativeInteger} offsetA - starting index for `A`
+* @returns {Float64Array} `A`
+*
+* @example
+* var Float64Array = require( '@stdlib/array/float64' );
+*
+* var A = new Float64Array( [ 1.0, 2.0, 3.0, 0.0, 1.0, 2.0, 0.0, 0.0, 1.0 ] ); // => [ [ 1.0, 2.0, 3.0 ], [ 0.0, 1.0, 2.0 ], [ 0.0, 0.0, 1.0 ] ]
+* var x = new Float64Array( [ 1.0, 2.0, 3.0 ] );
+*
+* dsyr( 'upper', 3, 1.0, x, 1, 0, A, 3, 1, 0 );
+* // A => <Float64Array>[ 2.0, 4.0, 6.0, 0.0, 5.0, 8.0, 0.0, 0.0, 10.0 ]
+*/
+function dsyr( uplo, N, alpha, x, strideX, offsetX, A, strideA1, strideA2, offsetA ) { // eslint-disable-line max-len
+	addon.ndarray( resolveUplo( uplo ), N, alpha, x, strideX, offsetX, A, strideA1, strideA2, offsetA ); // eslint-disable-line max-len
+	return A;
+}
+
+
+// EXPORTS //
+
+module.exports = dsyr;
diff --git a/lib/node_modules/@stdlib/blas/base/dsyr/manifest.json b/lib/node_modules/@stdlib/blas/base/dsyr/manifest.json
new file mode 100644
index 000000000000..05fa40f5a71c
--- /dev/null
+++ b/lib/node_modules/@stdlib/blas/base/dsyr/manifest.json
@@ -0,0 +1,319 @@
+{
+  "options": {
+    "task": "build",
+    "os": "linux",
+    "blas": "",
+    "wasm": false
+  },
+  "fields": [
+    {
+      "field": "src",
+      "resolve": true,
+      "relative": true
+    },
+    {
+      "field": "include",
+      "resolve": true,
+      "relative": true
+    },
+    {
+      "field": "libraries",
+      "resolve": false,
+      "relative": false
+    },
+    {
+      "field": "libpath",
+      "resolve": true,
+      "relative": false
+    }
+  ],
+  "confs": [
+    {
+      "task": "build",
+      "os": "win",
+      "blas": "openblas",
+      "wasm": false,
+      "src": [
+        "./src/dsyr_cblas.c"
+      ],
+      "include": [
+        "./include"
+      ],
+      "libraries": [
+        "-lopenblas",
+        "-lpthread"
+      ],
+      "libpath": [],
+      "dependencies": [
+        "@stdlib/blas/base/shared",
+        "@stdlib/napi/export",
+        "@stdlib/napi/argv",
+        "@stdlib/napi/argv-int64",
+        "@stdlib/napi/argv-int32",
+        "@stdlib/napi/argv-strided-float64array",
+        "@stdlib/napi/argv-strided-float64array2d",
+        "@stdlib/napi/argv-double"
+      ]
+    },
+    {
+      "task": "benchmark",
+      "os": "win",
+      "blas": "openblas",
+      "wasm": false,
+      "src": [
+        "./src/dsyr_cblas.c"
+      ],
+      "include": [
+        "./include"
+      ],
+      "libraries": [
+        "-lopenblas",
+        "-lpthread"
+      ],
+      "libpath": [],
+      "dependencies": [
+        "@stdlib/blas/base/shared"
+      ]
+    },
+    {
+      "task": "examples",
+      "os": "win",
+      "blas": "openblas",
+      "wasm": false,
+      "src": [
+        "./src/dsyr_cblas.c"
+      ],
+      "include": [
+        "./include"
+      ],
+      "libraries": [
+        "-lopenblas",
+        "-lpthread"
+      ],
+      "libpath": [],
+      "dependencies": [
+        "@stdlib/blas/base/shared"
+      ]
+    },
+
+    {
+      "task": "build",
+      "os": "mac",
+      "blas": "apple_accelerate_framework",
+      "wasm": false,
+      "src": [
+        "./src/dsyr_cblas.c"
+      ],
+      "include": [
+        "./include"
+      ],
+      "libraries": [
+        "-lblas"
+      ],
+      "libpath": [],
+      "dependencies": [
+        "@stdlib/blas/base/shared",
+        "@stdlib/napi/export",
+        "@stdlib/napi/argv",
+        "@stdlib/napi/argv-int64",
+        "@stdlib/napi/argv-int32",
+        "@stdlib/napi/argv-strided-float64array",
+        "@stdlib/napi/argv-strided-float64array2d",
+        "@stdlib/napi/argv-double"
+      ]
+    },
+    {
+      "task": "benchmark",
+      "os": "mac",
+      "blas": "apple_accelerate_framework",
+      "wasm": false,
+      "src": [
+        "./src/dsyr_cblas.c"
+      ],
+      "include": [
+        "./include"
+      ],
+      "libraries": [
+        "-lblas"
+      ],
+      "libpath": [],
+      "dependencies": [
+        "@stdlib/blas/base/shared"
+      ]
+    },
+    {
+      "task": "examples",
+      "os": "mac",
+      "blas": "apple_accelerate_framework",
+      "wasm": false,
+      "src": [
+        "./src/dsyr_cblas.c"
+      ],
+      "include": [
+        "./include"
+      ],
+      "libraries": [
+        "-lblas"
+      ],
+      "libpath": [],
+      "dependencies": [
+        "@stdlib/blas/base/shared"
+      ]
+    },
+
+    {
+      "task": "build",
+      "os": "mac",
+      "blas": "openblas",
+      "wasm": false,
+      "src": [
+        "./src/dsyr_cblas.c"
+      ],
+      "include": [
+        "./include"
+      ],
+      "libraries": [
+        "-lopenblas",
+        "-lpthread"
+      ],
+      "libpath": [],
+      "dependencies": [
+        "@stdlib/blas/base/shared",
+        "@stdlib/napi/export",
+        "@stdlib/napi/argv",
+        "@stdlib/napi/argv-int64",
+        "@stdlib/napi/argv-int32",
+        "@stdlib/napi/argv-strided-float64array",
+        "@stdlib/napi/argv-strided-float64array2d",
+        "@stdlib/napi/argv-double"
+      ]
+    },
+    {
+      "task": "benchmark",
+      "os": "mac",
+      "blas": "openblas",
+      "wasm": false,
+      "src": [
+        "./src/dsyr_cblas.c"
+      ],
+      "include": [
+        "./include"
+      ],
+      "libraries": [
+        "-lopenblas",
+        "-lpthread"
+      ],
+      "libpath": [],
+      "dependencies": [
+        "@stdlib/blas/base/shared"
+      ]
+    },
+    {
+      "task": "examples",
+      "os": "mac",
+      "blas": "openblas",
+      "wasm": false,
+      "src": [
+        "./src/dsyr_cblas.c"
+      ],
+      "include": [
+        "./include"
+      ],
+      "libraries": [
+        "-lopenblas",
+        "-lpthread"
+      ],
+      "libpath": [],
+      "dependencies": [
+        "@stdlib/blas/base/shared"
+      ]
+    },
+
+    {
+      "task": "build",
+      "os": "linux",
+      "blas": "",
+      "wasm": false,
+      "src": [
+        "./src/dsyr.c"
+      ],
+      "include": [
+        "./include"
+      ],
+      "libraries": [],
+      "libpath": [],
+      "dependencies": [
+        "@stdlib/blas/base/shared",
+        "@stdlib/napi/export",
+        "@stdlib/napi/argv",
+        "@stdlib/napi/argv-int64",
+        "@stdlib/napi/argv-int32",
+        "@stdlib/napi/argv-strided-float64array",
+        "@stdlib/napi/argv-strided-float64array2d",
+        "@stdlib/napi/argv-double",
+        "@stdlib/strided/base/stride2offset",
+        "@stdlib/ndarray/base/assert/is-row-major"
+      ]
+    },
+    {
+      "task": "benchmark",
+      "os": "linux",
+      "blas": "",
+      "wasm": false,
+      "src": [
+        "./src/dsyr.c"
+      ],
+      "include": [
+        "./include"
+      ],
+      "libraries": [],
+      "libpath": [],
+      "dependencies": [
+        "@stdlib/blas/base/shared",
+        "@stdlib/blas/ext/base/sfill",
+        "@stdlib/math/base/special/floor",
+        "@stdlib/strided/base/stride2offset",
+        "@stdlib/ndarray/base/assert/is-row-major"
+      ]
+    },
+    {
+      "task": "examples",
+      "os": "linux",
+      "blas": "",
+      "wasm": false,
+      "src": [
+        "./src/dsyr.c"
+      ],
+      "include": [
+        "./include"
+      ],
+      "libraries": [],
+      "libpath": [],
+      "dependencies": [
+        "@stdlib/blas/base/shared",
+        "@stdlib/strided/base/stride2offset",
+        "@stdlib/ndarray/base/assert/is-row-major"
+      ]
+    },
+
+    {
+      "task": "build",
+      "os": "",
+      "blas": "",
+      "wasm": true,
+      "src": [
+        "./src/dsyr.c"
+      ],
+      "include": [
+        "./include"
+      ],
+      "libraries": [],
+      "libpath": [],
+      "dependencies": [
+        "@stdlib/blas/base/shared",
+        "@stdlib/strided/base/stride2offset",
+        "@stdlib/ndarray/base/assert/is-row-major"
+      ]
+    }
+  ]
+}
diff --git a/lib/node_modules/@stdlib/blas/base/dsyr/package.json b/lib/node_modules/@stdlib/blas/base/dsyr/package.json
index 9c3c693ea93c..ab37bcb25b13 100644
--- a/lib/node_modules/@stdlib/blas/base/dsyr/package.json
+++ b/lib/node_modules/@stdlib/blas/base/dsyr/package.json
@@ -14,11 +14,14 @@
     }
   ],
   "main": "./lib",
+  "gypfile": true,
   "directories": {
     "benchmark": "./benchmark",
     "doc": "./docs",
     "example": "./examples",
+    "include": "./include",
     "lib": "./lib",
+    "src": "./src",
     "test": "./test"
   },
   "types": "./docs/types",
diff --git a/lib/node_modules/@stdlib/blas/base/dsyr/src/Makefile b/lib/node_modules/@stdlib/blas/base/dsyr/src/Makefile
new file mode 100644
index 000000000000..7733b6180cb4
--- /dev/null
+++ b/lib/node_modules/@stdlib/blas/base/dsyr/src/Makefile
@@ -0,0 +1,70 @@
+#/
+# @license Apache-2.0
+#
+# Copyright (c) 2025 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
+
+
+# RULES #
+
+#/
+# Removes generated files for building an add-on.
+#
+# @example
+# make clean-addon
+#/
+clean-addon:
+	$(QUIET) -rm -f *.o *.node
+
+.PHONY: clean-addon
+
+#/
+# Removes generated files.
+#
+# @example
+# make clean
+#/
+clean: clean-addon
+
+.PHONY: clean
diff --git a/lib/node_modules/@stdlib/blas/base/dsyr/src/addon.c b/lib/node_modules/@stdlib/blas/base/dsyr/src/addon.c
new file mode 100644
index 000000000000..fe6089114973
--- /dev/null
+++ b/lib/node_modules/@stdlib/blas/base/dsyr/src/addon.c
@@ -0,0 +1,86 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 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/blas/base/dsyr.h"
+#include "stdlib/blas/base/shared.h"
+#include "stdlib/napi/export.h"
+#include "stdlib/napi/argv.h"
+#include "stdlib/napi/argv_int64.h"
+#include "stdlib/napi/argv_int32.h"
+#include "stdlib/napi/argv_double.h"
+#include "stdlib/napi/argv_strided_float64array.h"
+#include "stdlib/napi/argv_strided_float64array2d.h"
+#include <node_api.h>
+
+/**
+* Receives JavaScript callback invocation data.
+*
+* @param env    environment under which the function is invoked
+* @param info   callback data
+* @return       Node-API value
+*/
+static napi_value addon( napi_env env, napi_callback_info info ) {
+	STDLIB_NAPI_ARGV( env, info, argv, argc, 8 );
+
+	STDLIB_NAPI_ARGV_INT32( env, order, argv, 0 );
+	STDLIB_NAPI_ARGV_INT32( env, uplo, argv, 1 );
+
+	STDLIB_NAPI_ARGV_INT64( env, N, argv, 2 );
+	STDLIB_NAPI_ARGV_INT64( env, strideX, argv, 5 );
+	STDLIB_NAPI_ARGV_INT64( env, LDA, argv, 7 );
+
+	STDLIB_NAPI_ARGV_DOUBLE( env, alpha, argv, 3 );
+
+	STDLIB_NAPI_ARGV_STRIDED_FLOAT64ARRAY( env, X, N, strideX, argv, 4 );
+	STDLIB_NAPI_ARGV_STRIDED_FLOAT64ARRAY( env, A, ((N-1)*LDA) + N, 1, argv, 6 );
+
+	API_SUFFIX(c_dsyr)( order, uplo, N, alpha, X, strideX, A, LDA );
+
+	return NULL;
+}
+
+/**
+* Receives JavaScript callback invocation data.
+*
+* @param env    environment under which the function is invoked
+* @param info   callback data
+* @return       Node-API value
+*/
+static napi_value addon_method( napi_env env, napi_callback_info info ) {
+	STDLIB_NAPI_ARGV( env, info, argv, argc, 10 );
+
+	STDLIB_NAPI_ARGV_INT32( env, uplo, argv, 0 );
+
+	STDLIB_NAPI_ARGV_INT64( env, N, argv, 1 );
+	STDLIB_NAPI_ARGV_INT64( env, strideX, argv, 4 );
+	STDLIB_NAPI_ARGV_INT64( env, offsetX, argv, 5 );
+	STDLIB_NAPI_ARGV_INT64( env, strideA1, argv, 7 );
+	STDLIB_NAPI_ARGV_INT64( env, strideA2, argv, 8 );
+	STDLIB_NAPI_ARGV_INT64( env, offsetA, argv, 9 );
+
+	STDLIB_NAPI_ARGV_DOUBLE( env, alpha, argv, 2 );
+
+	STDLIB_NAPI_ARGV_STRIDED_FLOAT64ARRAY( env, X, N, strideX, argv, 3 );
+	STDLIB_NAPI_ARGV_STRIDED_FLOAT64ARRAY2D( env, A, N, N, strideA1, strideA2, argv, 6 );
+
+	API_SUFFIX(c_dsyr_ndarray)( uplo, N, alpha, X, strideX, offsetX, A, strideA1, strideA2, offsetA );
+
+	return NULL;
+}
+
+STDLIB_NAPI_MODULE_EXPORT_FCN_WITH_METHOD( addon, "ndarray", addon_method )
diff --git a/lib/node_modules/@stdlib/blas/base/dsyr/src/dsyr.c b/lib/node_modules/@stdlib/blas/base/dsyr/src/dsyr.c
new file mode 100644
index 000000000000..c1ce804e3f1d
--- /dev/null
+++ b/lib/node_modules/@stdlib/blas/base/dsyr/src/dsyr.c
@@ -0,0 +1,131 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 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/blas/base/dsyr.h"
+#include "stdlib/blas/base/shared.h"
+#include "stdlib/strided/base/stride2offset.h"
+#include "stdlib/ndarray/base/assert/is_row_major.h"
+
+/**
+* Performs the symmetric rank 1 operation `A = α*x*x^T + A`.
+*
+* @param order    storage layout
+* @param uplo     specifies whether the upper or lower triangular part of the symmetric matrix `A` should be referenced
+* @param N        number of elements along each dimension of `A`
+* @param alpha    scalar
+* @param X        input vector
+* @param strideX  `X` stride length
+* @param A        input matrix
+* @param LDA      stride of the first dimension of `A` (a.k.a., leading dimension of the matrix `A`)
+*/
+void API_SUFFIX(c_dsyr)( const CBLAS_LAYOUT order, const CBLAS_UPLO uplo, const CBLAS_INT N, const double alpha, const double *X, const CBLAS_INT strideX, double *A, const CBLAS_INT LDA ) {
+	CBLAS_INT sa1;
+	CBLAS_INT sa2;
+	CBLAS_INT ox;
+
+	if ( N == 0 || alpha == 0.0 ) {
+		return;
+	}
+	if ( order == CblasColMajor ) {
+		sa1 = 1;
+		sa2 = LDA;
+	} else { // order === 'row-major'
+		sa1 = LDA;
+		sa2 = 1;
+	}
+	ox = STDLIB_BLAS_BASE_STRIDE2OFFSET( N, strideX );
+	API_SUFFIX(c_dsyr_ndarray)( uplo, N, alpha, X, strideX, ox, A, sa1, sa2, 0 );
+	return;
+}
+
+/**
+* Performs the symmetric rank 1 operation `A = α*x*x^T + A` using alternative indexing semantics.
+*
+* @param uplo      specifies whether the upper or lower triangular part of the symmetric matrix `A` should be referenced
+* @param N         number of elements along each dimension of `A`
+* @param alpha     scalar
+* @param X         input vector
+* @param strideX   `X` stride length
+* @param offsetX   starting index of `X`
+* @param A         input matrix
+* @param strideA1  stride of the first dimension of `A`
+* @param strideA2  stride of the second dimension of `A`
+* @param offsetA   starting index of `A`
+*/
+void API_SUFFIX(c_dsyr_ndarray)( const CBLAS_UPLO uplo, const CBLAS_INT N, const double alpha, const double *X, const CBLAS_INT strideX, const CBLAS_INT offsetX, double *A, const CBLAS_INT strideA1, const CBLAS_INT strideA2, const CBLAS_INT offsetA ) {
+	CBLAS_INT isrm;
+	CBLAS_INT ix0;
+	CBLAS_INT ix1;
+	CBLAS_INT sa0;
+	CBLAS_INT sa1;
+	CBLAS_INT i0;
+	CBLAS_INT i1;
+	CBLAS_INT oa;
+	CBLAS_INT ox;
+	double tmp;
+
+	int64_t strides[] = { strideA1, strideA2 };
+	if ( N == 0 || alpha == 0.0 ) {
+		return;
+	}
+	isrm = stdlib_ndarray_is_row_major( 2, strides );
+	if ( isrm ) {
+		// For row-major matrices, the last dimension has the fastest changing index...
+		sa0 = strideA2; // stride for innermost loop
+		sa1 = strideA1; // stride for outermost loop
+	} else { // isColMajor
+		// For column-major matrices, the first dimension has the fastest changing index...
+		sa0 = strideA1; // stride for innermost loop
+		sa1 = strideA2; // stride for outermost loop
+	}
+	ox = offsetX;
+	if (
+		( isrm && uplo == CblasLower ) ||
+		( !isrm && uplo == CblasUpper )
+	) {
+		ix1 = ox;
+		for ( i1 = 0; i1 < N; i1++ ) {
+			if ( X[ ix1 ] != 0.0 ) {
+				tmp = alpha * X[ ix1 ];
+				oa = offsetA + (sa1*i1);
+				ix0 = ox;
+				for ( i0 = 0; i0 <= i1; i0++ ) {
+					A[ oa+(sa0*i0) ] += X[ ix0 ] * tmp;
+					ix0 += strideX;
+				}
+			}
+			ix1 += strideX;
+		}
+		return;
+	}
+	// ( isrm && uplo == 'CblasUpper' ) || ( !isrm && uplo === 'CblasLower' )
+	ix1 = ox;
+	for ( i1 = 0; i1 < N; i1++ ) {
+		if ( X[ ix1 ] != 0.0 ) {
+			tmp = alpha * X[ ix1 ];
+			oa = offsetA + (sa1*i1);
+			ix0 = ix1;
+			for ( i0 = i1; i0 < N; i0++ ) {
+				A[ oa+(sa0*i0) ] += X[ ix0 ] * tmp;
+				ix0 += strideX;
+			}
+		}
+		ix1 += strideX;
+	}
+	return;
+}
diff --git a/lib/node_modules/@stdlib/blas/base/dsyr/src/dsyr_cblas.c b/lib/node_modules/@stdlib/blas/base/dsyr/src/dsyr_cblas.c
new file mode 100644
index 000000000000..83e431fb07a9
--- /dev/null
+++ b/lib/node_modules/@stdlib/blas/base/dsyr/src/dsyr_cblas.c
@@ -0,0 +1,37 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 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/blas/base/dsyr.h"
+#include "stdlib/blas/base/dsyr_cblas.h"
+#include "stdlib/blas/base/shared.h"
+
+/**
+* Performs the symmetric rank 1 operation `A = α*x*x^T + A`.
+*
+* @param order    storage layout
+* @param uplo     specifies whether the upper or lower triangular part of the symmetric matrix `A` should be referenced
+* @param N        number of elements along each dimension of `A`
+* @param alpha    scalar
+* @param x        input vector
+* @param strideX  `X` stride length
+* @param A        input matrix
+* @param LDA      stride of the first dimension of `A` (a.k.a., leading dimension of the matrix `A`)
+*/
+void API_SUFFIX(c_dsyr)( const CBLAS_LAYOUT order, const CBLAS_UPLO uplo, const CBLAS_INT N, const double alpha, const double *X, const CBLAS_INT strideX, double *A, const CBLAS_INT LDA ) {
+	API_SUFFIX(cblas_dsyr)( order, uplo, N, alpha, X, strideX, A, LDA );
+}
diff --git a/lib/node_modules/@stdlib/blas/base/dsyr/test/test.dsyr.native.js b/lib/node_modules/@stdlib/blas/base/dsyr/test/test.dsyr.native.js
new file mode 100644
index 000000000000..75d3591652c0
--- /dev/null
+++ b/lib/node_modules/@stdlib/blas/base/dsyr/test/test.dsyr.native.js
@@ -0,0 +1,300 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 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.
+*/
+
+/* eslint-disable max-len */
+
+'use strict';
+
+// MODULES //
+
+var resolve = require( 'path' ).resolve;
+var tape = require( 'tape' );
+var Float64Array = require( '@stdlib/array/float64' );
+var str2enum = require( '@stdlib/blas/base/matrix-triangle-str2enum' );
+var str2enumLayout = require( '@stdlib/blas/base/layout-str2enum' );
+var tryRequire = require( '@stdlib/utils/try-require' );
+
+
+// FIXTURES //
+
+var ru = require( './fixtures/row_major_u.json' );
+var rl = require( './fixtures/row_major_l.json' );
+var rxp = require( './fixtures/row_major_xp.json' );
+var rxn = require( './fixtures/row_major_xn.json' );
+
+var cu = require( './fixtures/column_major_u.json' );
+var cl = require( './fixtures/column_major_l.json' );
+var cxp = require( './fixtures/column_major_xp.json' );
+var cxn = require( './fixtures/column_major_xn.json' );
+
+
+// VARIABLES //
+
+var dsyr = tryRequire( resolve( __dirname, './../lib/dsyr.native.js' ) );
+var opts = {
+	'skip': ( dsyr instanceof Error )
+};
+
+
+// TESTS //
+
+tape( 'main export is a function', opts, function test( t ) {
+	t.ok( true, __filename );
+	t.strictEqual( typeof dsyr, 'function', 'main export is a function' );
+	t.end();
+});
+
+tape( 'the function has an arity of 8', opts, function test( t ) {
+	t.strictEqual( dsyr.length, 8, 'returns expected value' );
+	t.end();
+});
+
+tape( 'the function performs the symmetric rank 1 operation `A = α*x*x^T + A` (row-major, upper)', opts, function test( t ) {
+	var expected;
+	var data;
+	var out;
+	var a;
+	var x;
+
+	data = ru;
+
+	a = new Float64Array( data.A );
+	x = new Float64Array( data.x );
+
+	expected = new Float64Array( data.A_out );
+
+	out = dsyr( str2enumLayout( data.order ), str2enum( data.uplo ), data.N, data.alpha, x, data.strideX, a, data.lda );
+	t.strictEqual( out, a, 'returns expected value' );
+	t.deepEqual( out, expected, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function performs the symmetric rank 1 operation `A = α*x*x^T + A` (column-major, upper)', opts, function test( t ) {
+	var expected;
+	var data;
+	var out;
+	var a;
+	var x;
+
+	data = cu;
+
+	a = new Float64Array( data.A );
+	x = new Float64Array( data.x );
+
+	expected = new Float64Array( data.A_out );
+
+	out = dsyr( str2enumLayout( data.order ), str2enum( data.uplo ), data.N, data.alpha, x, data.strideX, a, data.lda );
+	t.strictEqual( out, a, 'returns expected value' );
+	t.deepEqual( out, expected, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function performs the symmetric rank 1 operation `A = α*x*x^T + A` (row-major, lower)', opts, function test( t ) {
+	var expected;
+	var data;
+	var out;
+	var a;
+	var x;
+
+	data = rl;
+
+	a = new Float64Array( data.A );
+	x = new Float64Array( data.x );
+
+	expected = new Float64Array( data.A_out );
+
+	out = dsyr( str2enumLayout( data.order ), str2enum( data.uplo ), data.N, data.alpha, x, data.strideX, a, data.lda );
+	t.strictEqual( out, a, 'returns expected value' );
+	t.deepEqual( out, expected, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function performs the symmetric rank 1 operation `A = α*x*x^T + A` (column-major, lower)', opts, function test( t ) {
+	var expected;
+	var data;
+	var out;
+	var a;
+	var x;
+
+	data = cl;
+
+	a = new Float64Array( data.A );
+	x = new Float64Array( data.x );
+
+	expected = new Float64Array( data.A_out );
+
+	out = dsyr( str2enumLayout( data.order ), str2enum( data.uplo ), data.N, data.alpha, x, data.strideX, a, data.lda );
+	t.strictEqual( out, a, 'returns expected value' );
+	t.deepEqual( out, expected, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function returns a reference to the input matrix `A`', opts, function test( t ) {
+	var data;
+	var out;
+	var a;
+	var x;
+
+	data = ru;
+
+	a = new Float64Array( data.A );
+	x = new Float64Array( data.x );
+
+	out = dsyr( str2enumLayout( data.order ), str2enum( data.uplo ), data.N, data.alpha, x, data.strideX, a, data.lda );
+	t.strictEqual( out, a, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'if `N` is zero or the scalar constant is zero, the function returns the input matrix `A` unchanged (row-major)', opts, function test( t ) {
+	var expected;
+	var data;
+	var out;
+	var a;
+	var x;
+
+	data = rl;
+
+	a = new Float64Array( data.A );
+	x = new Float64Array( data.x );
+
+	expected = new Float64Array( data.A );
+
+	out = dsyr( str2enumLayout( data.order ), str2enum( data.uplo ), 0, data.alpha, x, data.strideX, a, data.lda );
+	t.strictEqual( out, a, 'returns expected value' );
+	t.deepEqual( a, expected, 'returns expected value' );
+
+	out = dsyr( str2enumLayout( data.order ), str2enum( data.uplo ), data.N, 0.0, x, data.strideX, a, data.lda );
+	t.strictEqual( out, a, 'returns expected value' );
+	t.deepEqual( a, expected, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'if `N` is zero or the scalar constant is zero, the function returns the input matrix `A` unchanged (column-major)', opts, function test( t ) {
+	var expected;
+	var data;
+	var out;
+	var a;
+	var x;
+
+	data = cl;
+
+	a = new Float64Array( data.A );
+	x = new Float64Array( data.x );
+
+	expected = new Float64Array( data.A );
+
+	out = dsyr( str2enumLayout( data.order ), str2enum( data.uplo ), 0, data.alpha, x, data.strideX, a, data.lda );
+	t.strictEqual( out, a, 'returns expected value' );
+	t.deepEqual( a, expected, 'returns expected value' );
+
+	out = dsyr( str2enumLayout( data.order ), str2enum( data.uplo ), data.N, 0.0, x, data.strideX, a, data.lda );
+	t.strictEqual( out, a, 'returns expected value' );
+	t.deepEqual( a, expected, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function supports specifying an `x` stride (row-major)', opts, function test( t ) {
+	var expected;
+	var data;
+	var out;
+	var a;
+	var x;
+
+	data = rxp;
+
+	a = new Float64Array( data.A );
+	x = new Float64Array( data.x );
+
+	expected = new Float64Array( data.A_out );
+
+	out = dsyr( str2enumLayout( data.order ), str2enum( data.uplo ), data.N, data.alpha, x, data.strideX, a, data.lda );
+	t.strictEqual( out, a, 'returns expected value' );
+	t.deepEqual( out, expected, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function supports specifying an `x` stride (column-major)', opts, function test( t ) {
+	var expected;
+	var data;
+	var out;
+	var a;
+	var x;
+
+	data = cxp;
+
+	a = new Float64Array( data.A );
+	x = new Float64Array( data.x );
+
+	expected = new Float64Array( data.A_out );
+
+	out = dsyr( str2enumLayout( data.order ), str2enum( data.uplo ), data.N, data.alpha, x, data.strideX, a, data.lda );
+	t.strictEqual( out, a, 'returns expected value' );
+	t.deepEqual( out, expected, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function supports specifying a negative `x` stride (row-major)', opts, function test( t ) {
+	var expected;
+	var data;
+	var out;
+	var a;
+	var x;
+
+	data = rxn;
+
+	a = new Float64Array( data.A );
+	x = new Float64Array( data.x );
+
+	expected = new Float64Array( data.A_out );
+
+	out = dsyr( str2enumLayout( data.order ), str2enum( data.uplo ), data.N, data.alpha, x, data.strideX, a, data.lda );
+	t.strictEqual( out, a, 'returns expected value' );
+	t.deepEqual( out, expected, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function supports specifying a negative `x` stride (column-major)', opts, function test( t ) {
+	var expected;
+	var data;
+	var out;
+	var a;
+	var x;
+
+	data = cxn;
+
+	a = new Float64Array( data.A );
+	x = new Float64Array( data.x );
+
+	expected = new Float64Array( data.A_out );
+
+	out = dsyr( str2enumLayout( data.order ), str2enum( data.uplo ), data.N, data.alpha, x, data.strideX, a, data.lda );
+	t.strictEqual( out, a, 'returns expected value' );
+	t.deepEqual( out, expected, 'returns expected value' );
+
+	t.end();
+});
diff --git a/lib/node_modules/@stdlib/blas/base/dsyr/test/test.ndarray.native.js b/lib/node_modules/@stdlib/blas/base/dsyr/test/test.ndarray.native.js
new file mode 100644
index 000000000000..a2b341fe4498
--- /dev/null
+++ b/lib/node_modules/@stdlib/blas/base/dsyr/test/test.ndarray.native.js
@@ -0,0 +1,563 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2025 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.
+*/
+
+/* eslint-disable max-len */
+
+'use strict';
+
+// MODULES //
+
+var resolve = require( 'path' ).resolve;
+var tape = require( 'tape' );
+var Float64Array = require( '@stdlib/array/float64' );
+var str2enumMatrixTriangle = require( '@stdlib/blas/base/matrix-triangle-str2enum' );
+var tryRequire = require( '@stdlib/utils/try-require' );
+
+
+// FIXTURES //
+
+var ru = require( './fixtures/row_major_u.json' );
+var rl = require( './fixtures/row_major_l.json' );
+var rxp = require( './fixtures/row_major_xp.json' );
+var rxn = require( './fixtures/row_major_xn.json' );
+var roa = require( './fixtures/row_major_oa.json' );
+var rsa1sa2 = require( './fixtures/row_major_sa1_sa2.json' );
+var rsa1nsa2 = require( './fixtures/row_major_sa1n_sa2.json' );
+var rsa1sa2n = require( './fixtures/row_major_sa1_sa2n.json' );
+var rsa1nsa2n = require( './fixtures/row_major_sa1n_sa2n.json' );
+var rcap = require( './fixtures/row_major_complex_access_pattern.json' );
+
+var cu = require( './fixtures/column_major_u.json' );
+var cl = require( './fixtures/column_major_l.json' );
+var cxp = require( './fixtures/column_major_xp.json' );
+var cxn = require( './fixtures/column_major_xn.json' );
+var coa = require( './fixtures/column_major_oa.json' );
+var csa1sa2 = require( './fixtures/column_major_sa1_sa2.json' );
+var csa1nsa2 = require( './fixtures/column_major_sa1n_sa2.json' );
+var csa1sa2n = require( './fixtures/column_major_sa1_sa2n.json' );
+var csa1nsa2n = require( './fixtures/column_major_sa1n_sa2n.json' );
+var ccap = require( './fixtures/column_major_complex_access_pattern.json' );
+
+
+// VARIABLES //
+
+var dsyr = tryRequire( resolve( __dirname, './../lib/ndarray.native.js' ) );
+var opts = {
+	'skip': ( dsyr instanceof Error )
+};
+
+
+// TESTS //
+
+tape( 'main export is a function', opts, function test( t ) {
+	t.ok( true, __filename );
+	t.strictEqual( typeof dsyr, 'function', 'main export is a function' );
+	t.end();
+});
+
+tape( 'the function has an arity of 10', opts, function test( t ) {
+	t.strictEqual( dsyr.length, 10, 'returns expected value' );
+	t.end();
+});
+
+tape( 'the function performs the symmetric rank 1 operation `A = α*x*x^T + A` (row-major, upper)', opts, function test( t ) {
+	var expected;
+	var data;
+	var out;
+	var a;
+	var x;
+
+	data = ru;
+
+	a = new Float64Array( data.A );
+	x = new Float64Array( data.x );
+
+	expected = new Float64Array( data.A_out );
+
+	out = dsyr( str2enumMatrixTriangle( data.uplo ), data.N, data.alpha, x, data.strideX, data.offsetX, a, data.strideA1, data.strideA2, data.offsetA );
+	t.strictEqual( out, a, 'returns expected value' );
+	t.deepEqual( out, expected, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function performs the symmetric rank 1 operation `A = α*x*x^T + A` (column-major, upper)', opts, function test( t ) {
+	var expected;
+	var data;
+	var out;
+	var a;
+	var x;
+
+	data = cu;
+
+	a = new Float64Array( data.A );
+	x = new Float64Array( data.x );
+
+	expected = new Float64Array( data.A_out );
+
+	out = dsyr( str2enumMatrixTriangle( data.uplo ), data.N, data.alpha, x, data.strideX, data.offsetX, a, data.strideA1, data.strideA2, data.offsetA );
+	t.strictEqual( out, a, 'returns expected value' );
+	t.deepEqual( out, expected, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function performs the symmetric rank 1 operation `A = α*x*x^T + A` (row-major, lower)', opts, function test( t ) {
+	var expected;
+	var data;
+	var out;
+	var a;
+	var x;
+
+	data = rl;
+
+	a = new Float64Array( data.A );
+	x = new Float64Array( data.x );
+
+	expected = new Float64Array( data.A_out );
+
+	out = dsyr( str2enumMatrixTriangle( data.uplo ), data.N, data.alpha, x, data.strideX, data.offsetX, a, data.strideA1, data.strideA2, data.offsetA );
+	t.strictEqual( out, a, 'returns expected value' );
+	t.deepEqual( out, expected, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function performs the symmetric rank 1 operation `A = α*x*x^T + A` (column-major, lower)', opts, function test( t ) {
+	var expected;
+	var data;
+	var out;
+	var a;
+	var x;
+
+	data = cl;
+
+	a = new Float64Array( data.A );
+	x = new Float64Array( data.x );
+
+	expected = new Float64Array( data.A_out );
+
+	out = dsyr( str2enumMatrixTriangle( data.uplo ), data.N, data.alpha, x, data.strideX, data.offsetX, a, data.strideA1, data.strideA2, data.offsetA );
+	t.strictEqual( out, a, 'returns expected value' );
+	t.deepEqual( out, expected, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function returns a reference to the input matrix `A`', opts, function test( t ) {
+	var data;
+	var out;
+	var a;
+	var x;
+
+	data = ru;
+
+	a = new Float64Array( data.A );
+	x = new Float64Array( data.x );
+
+	out = dsyr( str2enumMatrixTriangle( data.uplo ), data.N, data.alpha, x, data.strideX, data.offsetX, a, data.strideA1, data.strideA2, data.offsetA );
+	t.strictEqual( out, a, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'if `N` is zero or the scalar constant is zero, the function returns the input matrix `A` unchanged (row-major)', opts, function test( t ) {
+	var expected;
+	var data;
+	var out;
+	var a;
+	var x;
+
+	data = rl;
+
+	a = new Float64Array( data.A );
+	x = new Float64Array( data.x );
+
+	expected = new Float64Array( data.A );
+
+	out = dsyr( str2enumMatrixTriangle( data.uplo ), 0, data.alpha, x, data.strideX, data.offsetX, a, data.strideA1, data.strideA2, data.offsetA );
+	t.strictEqual( out, a, 'returns expected value' );
+	t.deepEqual( a, expected, 'returns expected value' );
+
+	out = dsyr( str2enumMatrixTriangle( data.uplo ), data.N, 0.0, x, data.strideX, data.offsetX, a, data.strideA1, data.strideA2, data.offsetA );
+	t.strictEqual( out, a, 'returns expected value' );
+	t.deepEqual( a, expected, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'if `N` is zero or the scalar constant is zero, the function returns the input matrix `A` unchanged (column-major)', opts, function test( t ) {
+	var expected;
+	var data;
+	var out;
+	var a;
+	var x;
+
+	data = cl;
+
+	a = new Float64Array( data.A );
+	x = new Float64Array( data.x );
+
+	expected = new Float64Array( data.A );
+
+	out = dsyr( str2enumMatrixTriangle( data.uplo ), 0, data.alpha, x, data.strideX, data.offsetX, a, data.strideA1, data.strideA2, data.offsetA );
+	t.strictEqual( out, a, 'returns expected value' );
+	t.deepEqual( a, expected, 'returns expected value' );
+
+	out = dsyr( str2enumMatrixTriangle( data.uplo ), data.N, 0.0, x, data.strideX, data.offsetX, a, data.strideA1, data.strideA2, data.offsetA );
+	t.strictEqual( out, a, 'returns expected value' );
+	t.deepEqual( a, expected, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function supports specifying the strides of the first and second dimensions of `A` (row-major)', opts, function test( t ) {
+	var expected;
+	var data;
+	var out;
+	var a;
+	var x;
+
+	data = rsa1sa2;
+
+	a = new Float64Array( data.A );
+	x = new Float64Array( data.x );
+
+	expected = new Float64Array( data.A_out );
+
+	out = dsyr( str2enumMatrixTriangle( data.uplo ), data.N, data.alpha, x, data.strideX, data.offsetX, a, data.strideA1, data.strideA2, data.offsetA );
+	t.strictEqual( out, a, 'returns expected value' );
+	t.deepEqual( out, expected, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function supports specifying the strides of the first and second dimensions of `A` (column-major)', opts, function test( t ) {
+	var expected;
+	var data;
+	var out;
+	var a;
+	var x;
+
+	data = csa1sa2;
+
+	a = new Float64Array( data.A );
+	x = new Float64Array( data.x );
+
+	expected = new Float64Array( data.A_out );
+
+	out = dsyr( str2enumMatrixTriangle( data.uplo ), data.N, data.alpha, x, data.strideX, data.offsetX, a, data.strideA1, data.strideA2, data.offsetA );
+	t.strictEqual( out, a, 'returns expected value' );
+	t.deepEqual( out, expected, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function supports a negative stride for the first dimension of `A` (row-major)', opts, function test( t ) {
+	var expected;
+	var data;
+	var out;
+	var a;
+	var x;
+
+	data = rsa1nsa2;
+
+	a = new Float64Array( data.A );
+	x = new Float64Array( data.x );
+
+	expected = new Float64Array( data.A_out );
+
+	out = dsyr( str2enumMatrixTriangle( data.uplo ), data.N, data.alpha, x, data.strideX, data.offsetX, a, data.strideA1, data.strideA2, data.offsetA );
+	t.strictEqual( out, a, 'returns expected value' );
+	t.deepEqual( out, expected, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function supports a negative stride for the first dimension of `A` (column-major)', opts, function test( t ) {
+	var expected;
+	var data;
+	var out;
+	var a;
+	var x;
+
+	data = csa1nsa2;
+
+	a = new Float64Array( data.A );
+	x = new Float64Array( data.x );
+
+	expected = new Float64Array( data.A_out );
+
+	out = dsyr( str2enumMatrixTriangle( data.uplo ), data.N, data.alpha, x, data.strideX, data.offsetX, a, data.strideA1, data.strideA2, data.offsetA );
+	t.strictEqual( out, a, 'returns expected value' );
+	t.deepEqual( out, expected, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function supports a negative stride for the second dimension of `A` (row-major)', opts, function test( t ) {
+	var expected;
+	var data;
+	var out;
+	var a;
+	var x;
+
+	data = rsa1sa2n;
+
+	a = new Float64Array( data.A );
+	x = new Float64Array( data.x );
+
+	expected = new Float64Array( data.A_out );
+
+	out = dsyr( str2enumMatrixTriangle( data.uplo ), data.N, data.alpha, x, data.strideX, data.offsetX, a, data.strideA1, data.strideA2, data.offsetA );
+	t.strictEqual( out, a, 'returns expected value' );
+	t.deepEqual( out, expected, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function supports a negative stride for the second dimension of `A` (column-major)', opts, function test( t ) {
+	var expected;
+	var data;
+	var out;
+	var a;
+	var x;
+
+	data = csa1sa2n;
+
+	a = new Float64Array( data.A );
+	x = new Float64Array( data.x );
+
+	expected = new Float64Array( data.A_out );
+
+	out = dsyr( str2enumMatrixTriangle( data.uplo ), data.N, data.alpha, x, data.strideX, data.offsetX, a, data.strideA1, data.strideA2, data.offsetA );
+	t.strictEqual( out, a, 'returns expected value' );
+	t.deepEqual( out, expected, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function supports negative strides for both dimensions of `A` (row-major)', opts, function test( t ) {
+	var expected;
+	var data;
+	var out;
+	var a;
+	var x;
+
+	data = rsa1nsa2n;
+
+	a = new Float64Array( data.A );
+	x = new Float64Array( data.x );
+
+	expected = new Float64Array( data.A_out );
+
+	out = dsyr( str2enumMatrixTriangle( data.uplo ), data.N, data.alpha, x, data.strideX, data.offsetX, a, data.strideA1, data.strideA2, data.offsetA );
+	t.strictEqual( out, a, 'returns expected value' );
+	t.deepEqual( out, expected, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function supports negative strides for both dimensions of `A` (column-major)', opts, function test( t ) {
+	var expected;
+	var data;
+	var out;
+	var a;
+	var x;
+
+	data = csa1nsa2n;
+
+	a = new Float64Array( data.A );
+	x = new Float64Array( data.x );
+
+	expected = new Float64Array( data.A_out );
+
+	out = dsyr( str2enumMatrixTriangle( data.uplo ), data.N, data.alpha, x, data.strideX, data.offsetX, a, data.strideA1, data.strideA2, data.offsetA );
+	t.strictEqual( out, a, 'returns expected value' );
+	t.deepEqual( out, expected, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function supports specifying an `A` offset (row-major)', opts, function test( t ) {
+	var expected;
+	var data;
+	var out;
+	var a;
+	var x;
+
+	data = roa;
+
+	a = new Float64Array( data.A );
+	x = new Float64Array( data.x );
+
+	expected = new Float64Array( data.A_out );
+
+	out = dsyr( str2enumMatrixTriangle( data.uplo ), data.N, data.alpha, x, data.strideX, data.offsetX, a, data.strideA1, data.strideA2, data.offsetA );
+	t.strictEqual( out, a, 'returns expected value' );
+	t.deepEqual( out, expected, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function supports specifying an `A` offset (column-major)', opts, function test( t ) {
+	var expected;
+	var data;
+	var out;
+	var a;
+	var x;
+
+	data = coa;
+
+	a = new Float64Array( data.A );
+	x = new Float64Array( data.x );
+
+	expected = new Float64Array( data.A_out );
+
+	out = dsyr( str2enumMatrixTriangle( data.uplo ), data.N, data.alpha, x, data.strideX, data.offsetX, a, data.strideA1, data.strideA2, data.offsetA );
+	t.strictEqual( out, a, 'returns expected value' );
+	t.deepEqual( out, expected, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function supports specifying an `x` stride (row-major)', opts, function test( t ) {
+	var expected;
+	var data;
+	var out;
+	var a;
+	var x;
+
+	data = rxp;
+
+	a = new Float64Array( data.A );
+	x = new Float64Array( data.x );
+
+	expected = new Float64Array( data.A_out );
+
+	out = dsyr( str2enumMatrixTriangle( data.uplo ), data.N, data.alpha, x, data.strideX, data.offsetX, a, data.strideA1, data.strideA2, data.offsetA );
+	t.strictEqual( out, a, 'returns expected value' );
+	t.deepEqual( out, expected, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function supports specifying an `x` stride (column-major)', opts, function test( t ) {
+	var expected;
+	var data;
+	var out;
+	var a;
+	var x;
+
+	data = cxp;
+
+	a = new Float64Array( data.A );
+	x = new Float64Array( data.x );
+
+	expected = new Float64Array( data.A_out );
+
+	out = dsyr( str2enumMatrixTriangle( data.uplo ), data.N, data.alpha, x, data.strideX, data.offsetX, a, data.strideA1, data.strideA2, data.offsetA );
+	t.strictEqual( out, a, 'returns expected value' );
+	t.deepEqual( out, expected, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function supports specifying a negative `x` stride (row-major)', opts, function test( t ) {
+	var expected;
+	var data;
+	var out;
+	var a;
+	var x;
+
+	data = rxn;
+
+	a = new Float64Array( data.A );
+	x = new Float64Array( data.x );
+
+	expected = new Float64Array( data.A_out );
+
+	out = dsyr( str2enumMatrixTriangle( data.uplo ), data.N, data.alpha, x, data.strideX, data.offsetX, a, data.strideA1, data.strideA2, data.offsetA );
+	t.strictEqual( out, a, 'returns expected value' );
+	t.deepEqual( out, expected, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function supports specifying a negative `x` stride (column-major)', opts, function test( t ) {
+	var expected;
+	var data;
+	var out;
+	var a;
+	var x;
+
+	data = cxn;
+
+	a = new Float64Array( data.A );
+	x = new Float64Array( data.x );
+
+	expected = new Float64Array( data.A_out );
+
+	out = dsyr( str2enumMatrixTriangle( data.uplo ), data.N, data.alpha, x, data.strideX, data.offsetX, a, data.strideA1, data.strideA2, data.offsetA );
+	t.strictEqual( out, a, 'returns expected value' );
+	t.deepEqual( out, expected, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function supports complex access patterns (row-major)', opts, function test( t ) {
+	var expected;
+	var data;
+	var out;
+	var a;
+	var x;
+
+	data = rcap;
+
+	a = new Float64Array( data.A );
+	x = new Float64Array( data.x );
+
+	expected = new Float64Array( data.A_out );
+
+	out = dsyr( str2enumMatrixTriangle( data.uplo ), data.N, data.alpha, x, data.strideX, data.offsetX, a, data.strideA1, data.strideA2, data.offsetA );
+	t.strictEqual( out, a, 'returns expected value' );
+	t.deepEqual( out, expected, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function supports complex access patterns (column-major)', opts, function test( t ) {
+	var expected;
+	var data;
+	var out;
+	var a;
+	var x;
+
+	data = ccap;
+
+	a = new Float64Array( data.A );
+	x = new Float64Array( data.x );
+
+	expected = new Float64Array( data.A_out );
+
+	out = dsyr( str2enumMatrixTriangle( data.uplo ), data.N, data.alpha, x, data.strideX, data.offsetX, a, data.strideA1, data.strideA2, data.offsetA );
+	t.strictEqual( out, a, 'returns expected value' );
+	t.deepEqual( out, expected, 'returns expected value' );
+
+	t.end();
+});