From 8f8b69878f9cd4b4b6456530b2372af8ff314f3d Mon Sep 17 00:00:00 2001
From: headlessNode <harriskhan047@outlook.com>
Date: Thu, 19 Mar 2026 00:32:17 +0500
Subject: [PATCH 01/20] feat: add ndarray/base/assign-scalar

---
type: pre_commit_static_analysis_report
description: Results of running static analysis checks when committing changes.
report:
  - task: lint_filenames
    status: passed
  - task: lint_editorconfig
    status: passed
  - task: lint_markdown
    status: passed
  - task: lint_package_json
    status: passed
  - task: lint_repl_help
    status: passed
  - task: lint_javascript_src
    status: passed
  - task: lint_javascript_cli
    status: na
  - task: lint_javascript_examples
    status: passed
  - task: lint_javascript_tests
    status: passed
  - task: lint_javascript_benchmarks
    status: passed
  - task: lint_python
    status: na
  - task: lint_r
    status: na
  - task: lint_c_src
    status: na
  - task: lint_c_examples
    status: na
  - task: lint_c_benchmarks
    status: na
  - task: lint_c_tests_fixtures
    status: na
  - task: lint_shell
    status: na
  - task: lint_typescript_declarations
    status: passed
  - task: lint_typescript_tests
    status: passed
  - task: lint_license_headers
    status: passed
---
---
 .../ndarray/base/assign-scalar/README.md      |  173 +++
 .../benchmark.10d_blocked_columnmajor.js      |  145 ++
 .../benchmark.10d_blocked_rowmajor.js         |  145 ++
 .../benchmark/benchmark.10d_columnmajor.js    |  145 ++
 .../benchmark/benchmark.10d_rowmajor.js       |  145 ++
 .../benchmark/benchmark.11d_columnmajor.js    |  145 ++
 .../benchmark/benchmark.11d_rowmajor.js       |  145 ++
 .../benchmark/benchmark.1d_columnmajor.js     |  134 ++
 .../benchmark/benchmark.1d_rowmajor.js        |  134 ++
 .../benchmark.2d_blocked_columnmajor.js       |  146 ++
 .../benchmark.2d_blocked_rowmajor.js          |  146 ++
 .../benchmark/benchmark.2d_columnmajor.js     |  146 ++
 .../benchmark/benchmark.2d_rowmajor.js        |  146 ++
 .../benchmark.2d_rowmajor_accessors.js        |  174 +++
 ...benchmark.2d_rowmajor_accessors_complex.js |  182 +++
 .../benchmark.3d_blocked_columnmajor.js       |  146 ++
 .../benchmark.3d_blocked_rowmajor.js          |  146 ++
 .../benchmark/benchmark.3d_columnmajor.js     |  146 ++
 .../benchmark/benchmark.3d_rowmajor.js        |  146 ++
 .../benchmark.4d_blocked_columnmajor.js       |  145 ++
 .../benchmark.4d_blocked_rowmajor.js          |  145 ++
 .../benchmark/benchmark.4d_columnmajor.js     |  145 ++
 .../benchmark/benchmark.4d_rowmajor.js        |  145 ++
 .../benchmark.5d_blocked_columnmajor.js       |  145 ++
 .../benchmark.5d_blocked_rowmajor.js          |  145 ++
 .../benchmark/benchmark.5d_columnmajor.js     |  145 ++
 .../benchmark/benchmark.5d_rowmajor.js        |  145 ++
 .../benchmark.6d_blocked_columnmajor.js       |  145 ++
 .../benchmark.6d_blocked_rowmajor.js          |  145 ++
 .../benchmark/benchmark.6d_columnmajor.js     |  145 ++
 .../benchmark/benchmark.6d_rowmajor.js        |  145 ++
 .../benchmark.7d_blocked_columnmajor.js       |  145 ++
 .../benchmark.7d_blocked_rowmajor.js          |  145 ++
 .../benchmark/benchmark.7d_columnmajor.js     |  145 ++
 .../benchmark/benchmark.7d_rowmajor.js        |  145 ++
 .../benchmark.8d_blocked_columnmajor.js       |  145 ++
 .../benchmark.8d_blocked_rowmajor.js          |  145 ++
 .../benchmark/benchmark.8d_columnmajor.js     |  145 ++
 .../benchmark/benchmark.8d_rowmajor.js        |  145 ++
 .../benchmark.9d_blocked_columnmajor.js       |  145 ++
 .../benchmark.9d_blocked_rowmajor.js          |  145 ++
 .../benchmark/benchmark.9d_columnmajor.js     |  145 ++
 .../benchmark/benchmark.9d_rowmajor.js        |  145 ++
 .../ndarray/base/assign-scalar/docs/repl.txt  |   62 +
 .../base/assign-scalar/docs/types/index.d.ts  |   67 +
 .../base/assign-scalar/docs/types/test.ts     |   56 +
 .../base/assign-scalar/examples/index.js      |   42 +
 .../ndarray/base/assign-scalar/lib/0d.js      |   92 ++
 .../base/assign-scalar/lib/0d_accessors.js    |  113 ++
 .../ndarray/base/assign-scalar/lib/10d.js     |  221 +++
 .../base/assign-scalar/lib/10d_accessors.js   |  248 ++++
 .../base/assign-scalar/lib/10d_blocked.js     |  325 +++++
 .../lib/10d_blocked_accessors.js              |  352 +++++
 .../ndarray/base/assign-scalar/lib/1d.js      |  118 ++
 .../base/assign-scalar/lib/1d_accessors.js    |  145 ++
 .../ndarray/base/assign-scalar/lib/2d.js      |  139 ++
 .../base/assign-scalar/lib/2d_accessors.js    |  166 +++
 .../base/assign-scalar/lib/2d_blocked.js      |  171 +++
 .../assign-scalar/lib/2d_blocked_accessors.js |  198 +++
 .../ndarray/base/assign-scalar/lib/3d.js      |  149 ++
 .../base/assign-scalar/lib/3d_accessors.js    |  176 +++
 .../base/assign-scalar/lib/3d_blocked.js      |  192 +++
 .../assign-scalar/lib/3d_blocked_accessors.js |  219 +++
 .../ndarray/base/assign-scalar/lib/4d.js      |  159 +++
 .../base/assign-scalar/lib/4d_accessors.js    |  186 +++
 .../base/assign-scalar/lib/4d_blocked.js      |  211 +++
 .../assign-scalar/lib/4d_blocked_accessors.js |  238 ++++
 .../ndarray/base/assign-scalar/lib/5d.js      |  169 +++
 .../base/assign-scalar/lib/5d_accessors.js    |  196 +++
 .../base/assign-scalar/lib/5d_blocked.js      |  230 +++
 .../assign-scalar/lib/5d_blocked_accessors.js |  257 ++++
 .../ndarray/base/assign-scalar/lib/6d.js      |  181 +++
 .../base/assign-scalar/lib/6d_accessors.js    |  208 +++
 .../base/assign-scalar/lib/6d_blocked.js      |  249 ++++
 .../assign-scalar/lib/6d_blocked_accessors.js |  276 ++++
 .../ndarray/base/assign-scalar/lib/7d.js      |  191 +++
 .../base/assign-scalar/lib/7d_accessors.js    |  218 +++
 .../base/assign-scalar/lib/7d_blocked.js      |  268 ++++
 .../assign-scalar/lib/7d_blocked_accessors.js |  295 ++++
 .../ndarray/base/assign-scalar/lib/8d.js      |  201 +++
 .../base/assign-scalar/lib/8d_accessors.js    |  228 +++
 .../base/assign-scalar/lib/8d_blocked.js      |  287 ++++
 .../assign-scalar/lib/8d_blocked_accessors.js |  314 ++++
 .../ndarray/base/assign-scalar/lib/9d.js      |  211 +++
 .../base/assign-scalar/lib/9d_accessors.js    |  238 ++++
 .../base/assign-scalar/lib/9d_blocked.js      |  306 ++++
 .../assign-scalar/lib/9d_blocked_accessors.js |  333 +++++
 .../ndarray/base/assign-scalar/lib/index.js   |   72 +
 .../ndarray/base/assign-scalar/lib/main.js    |  339 +++++
 .../ndarray/base/assign-scalar/lib/nd.js      |  139 ++
 .../base/assign-scalar/lib/nd_accessors.js    |  166 +++
 .../ndarray/base/assign-scalar/package.json   |   62 +
 .../base/assign-scalar/test/test.0d.js        |   79 +
 .../base/assign-scalar/test/test.1d.js        |  126 ++
 .../base/assign-scalar/test/test.2d.js        | 1133 +++++++++++++++
 .../base/assign-scalar/test/test.3d.js        | 1269 +++++++++++++++++
 .../ndarray/base/assign-scalar/test/test.js   |   33 +
 97 files changed, 18634 insertions(+)
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/assign-scalar/README.md
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.10d_blocked_columnmajor.js
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.10d_blocked_rowmajor.js
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.10d_columnmajor.js
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.10d_rowmajor.js
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.11d_columnmajor.js
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.11d_rowmajor.js
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.1d_columnmajor.js
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.1d_rowmajor.js
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.2d_blocked_columnmajor.js
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.2d_blocked_rowmajor.js
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.2d_columnmajor.js
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.2d_rowmajor.js
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.2d_rowmajor_accessors.js
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.2d_rowmajor_accessors_complex.js
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.3d_blocked_columnmajor.js
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.3d_blocked_rowmajor.js
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.3d_columnmajor.js
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.3d_rowmajor.js
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.4d_blocked_columnmajor.js
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.4d_blocked_rowmajor.js
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.4d_columnmajor.js
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.4d_rowmajor.js
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.5d_blocked_columnmajor.js
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.5d_blocked_rowmajor.js
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.5d_columnmajor.js
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.5d_rowmajor.js
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.6d_blocked_columnmajor.js
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.6d_blocked_rowmajor.js
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.6d_columnmajor.js
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.6d_rowmajor.js
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.7d_blocked_columnmajor.js
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.7d_blocked_rowmajor.js
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.7d_columnmajor.js
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.7d_rowmajor.js
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.8d_blocked_columnmajor.js
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.8d_blocked_rowmajor.js
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.8d_columnmajor.js
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.8d_rowmajor.js
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.9d_blocked_columnmajor.js
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.9d_blocked_rowmajor.js
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.9d_columnmajor.js
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.9d_rowmajor.js
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/assign-scalar/docs/repl.txt
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/assign-scalar/docs/types/index.d.ts
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/assign-scalar/docs/types/test.ts
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/assign-scalar/examples/index.js
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/0d.js
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/0d_accessors.js
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/10d.js
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/10d_accessors.js
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/10d_blocked.js
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/10d_blocked_accessors.js
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/1d.js
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/1d_accessors.js
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/2d.js
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/2d_accessors.js
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/2d_blocked.js
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/2d_blocked_accessors.js
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/3d.js
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/3d_accessors.js
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/3d_blocked.js
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/3d_blocked_accessors.js
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/4d.js
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/4d_accessors.js
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/4d_blocked.js
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/4d_blocked_accessors.js
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/5d.js
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/5d_accessors.js
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/5d_blocked.js
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/5d_blocked_accessors.js
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/6d.js
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/6d_accessors.js
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/6d_blocked.js
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/6d_blocked_accessors.js
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/7d.js
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/7d_accessors.js
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/7d_blocked.js
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/7d_blocked_accessors.js
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/8d.js
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/8d_accessors.js
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/8d_blocked.js
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/8d_blocked_accessors.js
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/9d.js
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/9d_accessors.js
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/9d_blocked.js
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/9d_blocked_accessors.js
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/index.js
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/main.js
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/nd.js
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/nd_accessors.js
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/assign-scalar/package.json
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/assign-scalar/test/test.0d.js
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/assign-scalar/test/test.1d.js
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/assign-scalar/test/test.2d.js
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/assign-scalar/test/test.3d.js
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/assign-scalar/test/test.js

diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/README.md b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/README.md
new file mode 100644
index 000000000000..295998b725f6
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/README.md
@@ -0,0 +1,173 @@
+<!--
+
+@license Apache-2.0
+
+Copyright (c) 2026 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.
+
+-->
+
+# assignScalar
+
+> Assign a scalar value to every element of an output [ndarray][@stdlib/ndarray/base/ctor].
+
+<section class="intro">
+
+</section>
+
+<!-- /.intro -->
+
+<section class="usage">
+
+## Usage
+
+```javascript
+var assignScalar = require( '@stdlib/ndarray/base/assign-scalar' );
+```
+
+#### assignScalar( arrays )
+
+Assigns a scalar value to every element of an output [ndarray][@stdlib/ndarray/base/ctor].
+
+<!-- eslint-disable max-len -->
+
+```javascript
+var scalar2ndarray = require( '@stdlib/ndarray/from-scalar' );
+var Float64Array = require( '@stdlib/array/float64' );
+
+// Create a zero-dimensional ndarray containing the scalar value:
+var x = scalar2ndarray( 5.0, {
+    'dtype': 'float64'
+});
+
+// Create a data buffer:
+var ybuf = new Float64Array( 6 );
+
+// Define the shape of the output array:
+var shape = [ 3, 1, 2 ];
+
+// Define the array strides:
+var sy = [ 2, 2, 1 ];
+
+// Define the index offset:
+var oy = 0;
+
+// Create the output ndarray-like object:
+var y = {
+    'dtype': 'float64',
+    'data': ybuf,
+    'shape': shape,
+    'strides': sy,
+    'offset': oy,
+    'order': 'row-major'
+};
+
+// Assign the scalar value:
+assignScalar( [ x, y ] );
+
+console.log( y.data );
+// => <Float64Array>[ 5.0, 5.0, 5.0, 5.0, 5.0, 5.0 ]
+```
+
+The function accepts the following arguments:
+
+-   **arrays**: array-like object containing a zero-dimensional input [ndarray][@stdlib/ndarray/base/ctor] and an output [ndarray][@stdlib/ndarray/base/ctor].
+
+Each provided [ndarray][@stdlib/ndarray/base/ctor] should be an object with the following properties:
+
+-   **dtype**: data type.
+-   **data**: data buffer.
+-   **shape**: dimensions.
+-   **strides**: stride lengths.
+-   **offset**: index offset.
+-   **order**: specifies whether an ndarray is row-major (C-style) or column major (Fortran-style).
+
+</section>
+
+<!-- /.usage -->
+
+<section class="notes">
+
+## Notes
+
+-   For very high-dimensional ndarrays which are non-contiguous, one should consider copying the underlying data to contiguous memory before performing the operation in order to achieve better performance.
+
+</section>
+
+<!-- /.notes -->
+
+<section class="examples">
+
+## Examples
+
+<!-- eslint no-undef: "error" -->
+
+```javascript
+var scalar2ndarray = require( '@stdlib/ndarray/from-scalar' );
+var filledarray = require( '@stdlib/array/filled' );
+var ndarray2array = require( '@stdlib/ndarray/base/to-array' );
+var assignScalar = require( '@stdlib/ndarray/base/assign-scalar' );
+
+var x = scalar2ndarray( 10.0, {
+    'dtype': 'generic'
+});
+console.log( ndarray2array( x.data, x.shape, x.strides, x.offset, x.order ) );
+
+var y = {
+    'dtype': 'generic',
+    'data': filledarray( 0, 10, 'generic' ),
+    'shape': [ 5, 2 ],
+    'strides': [ 2, 1 ],
+    'offset': 0,
+    'order': 'row-major'
+};
+console.log( ndarray2array( y.data, y.shape, y.strides, y.offset, y.order ) );
+
+assignScalar( [ x, y ] );
+console.log( ndarray2array( y.data, y.shape, y.strides, y.offset, y.order ) );
+```
+
+</section>
+
+<!-- /.examples -->
+
+<!-- Section to include cited references. If references are included, add a horizontal rule *before* the section. Make sure to keep an empty line after the `section` element and another before the `/section` close. -->
+
+<section class="references">
+
+</section>
+
+<!-- /.references -->
+
+<!-- Section for related `stdlib` packages. Do not manually edit this section, as it is automatically populated. -->
+
+<section class="related">
+
+</section>
+
+<!-- /.related -->
+
+<!-- Section for all links. Make sure to keep an empty line after the `section` element and another before the `/section` close. -->
+
+<section class="links">
+
+[@stdlib/ndarray/base/ctor]: https://github.com/stdlib-js/stdlib/tree/develop/lib/node_modules/%40stdlib/ndarray/base/ctor
+
+<!-- <related-links> -->
+
+<!-- </related-links> -->
+
+</section>
+
+<!-- /.links -->
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.10d_blocked_columnmajor.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.10d_blocked_columnmajor.js
new file mode 100644
index 000000000000..9c228cef9659
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.10d_blocked_columnmajor.js
@@ -0,0 +1,145 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2026 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 bench = require( '@stdlib/bench' );
+var isnan = require( '@stdlib/math/base/assert/is-nan' );
+var pow = require( '@stdlib/math/base/special/pow' );
+var floor = require( '@stdlib/math/base/special/floor' );
+var filledarray = require( '@stdlib/array/filled' );
+var shape2strides = require( '@stdlib/ndarray/base/shape2strides' );
+var format = require( '@stdlib/string/format' );
+var pkg = require( './../package.json' ).name;
+var assignScalar = require( './../lib/10d_blocked.js' );
+
+
+// VARIABLES //
+
+var types = [ 'float64' ];
+var order = 'column-major';
+
+
+// FUNCTIONS //
+
+/**
+* Creates a benchmark function.
+*
+* @private
+* @param {PositiveInteger} len - ndarray length
+* @param {NonNegativeIntegerArray} shape - ndarray shape
+* @param {string} xtype - input ndarray data type
+* @param {string} ytype - output ndarray data type
+* @returns {Function} benchmark function
+*/
+function createBenchmark( len, shape, xtype, ytype ) {
+	var x;
+	var y;
+
+	y = filledarray( 0.0, len, ytype );
+	x = {
+		'dtype': xtype,
+		'data': [ 10.0 ],
+		'shape': [],
+		'strides': [ 0 ],
+		'offset': 0,
+		'order': order
+	};
+	y = {
+		'dtype': ytype,
+		'data': y,
+		'shape': shape,
+		'strides': shape2strides( shape, order ),
+		'offset': 0,
+		'order': order
+	};
+	return benchmark;
+
+	/**
+	* Benchmark function.
+	*
+	* @private
+	* @param {Benchmark} b - benchmark instance
+	*/
+	function benchmark( b ) {
+		var i;
+
+		b.tic();
+		for ( i = 0; i < b.iterations; i++ ) {
+			assignScalar( x, y );
+			if ( isnan( y.data[ i%len ] ) ) {
+				b.fail( 'should not return NaN' );
+			}
+		}
+		b.toc();
+		if ( isnan( y.data[ i%len ] ) ) {
+			b.fail( 'should not return NaN' );
+		}
+		b.pass( 'benchmark finished' );
+		b.end();
+	}
+}
+
+
+// MAIN //
+
+/**
+* Main execution sequence.
+*
+* @private
+*/
+function main() {
+	var len;
+	var min;
+	var max;
+	var sh;
+	var t1;
+	var t2;
+	var f;
+	var i;
+	var j;
+
+	min = 1; // 10^min
+	max = 6; // 10^max
+
+	for ( j = 0; j < types.length; j++ ) {
+		t1 = types[ j ];
+		t2 = types[ j ];
+		for ( i = min; i <= max; i++ ) {
+			len = pow( 10, i );
+
+			sh = [ len/2, 2, 1, 1, 1, 1, 1, 1, 1, 1 ];
+			f = createBenchmark( len, sh, t1, t2 );
+			bench( format( '%s::blocked:ndims=%d,len=%d,shape=[%s],xorder=%s,yorder=%s,xtype=%s,ytype=%s', pkg, sh.length, len, sh.join( ',' ), order, order, t1, t2 ), f );
+
+			sh = [ 1, 1, 1, 1, 1, 1, 1, 1, 2, len/2 ];
+			f = createBenchmark( len, sh, t1, t2 );
+			bench( format( '%s::blocked:ndims=%d,len=%d,shape=[%s],xorder=%s,yorder=%s,xtype=%s,ytype=%s', pkg, sh.length, len, sh.join( ',' ), order, order, t1, t2 ), f );
+
+			len = floor( pow( len, 1.0/10.0 ) );
+			sh = [ len, len, len, len, len, len, len, len, len, len ];
+			len *= pow( len, 9 );
+			f = createBenchmark( len, sh, t1, t2 );
+			bench( format( '%s::blocked:ndims=%d,len=%d,shape=[%s],xorder=%s,yorder=%s,xtype=%s,ytype=%s', pkg, sh.length, len, sh.join( ',' ), order, order, t1, t2 ), f );
+		}
+	}
+}
+
+main();
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.10d_blocked_rowmajor.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.10d_blocked_rowmajor.js
new file mode 100644
index 000000000000..3b77bae66878
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.10d_blocked_rowmajor.js
@@ -0,0 +1,145 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2026 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 bench = require( '@stdlib/bench' );
+var isnan = require( '@stdlib/math/base/assert/is-nan' );
+var pow = require( '@stdlib/math/base/special/pow' );
+var floor = require( '@stdlib/math/base/special/floor' );
+var filledarray = require( '@stdlib/array/filled' );
+var shape2strides = require( '@stdlib/ndarray/base/shape2strides' );
+var format = require( '@stdlib/string/format' );
+var pkg = require( './../package.json' ).name;
+var assignScalar = require( './../lib/10d_blocked.js' );
+
+
+// VARIABLES //
+
+var types = [ 'float64' ];
+var order = 'row-major';
+
+
+// FUNCTIONS //
+
+/**
+* Creates a benchmark function.
+*
+* @private
+* @param {PositiveInteger} len - ndarray length
+* @param {NonNegativeIntegerArray} shape - ndarray shape
+* @param {string} xtype - input ndarray data type
+* @param {string} ytype - output ndarray data type
+* @returns {Function} benchmark function
+*/
+function createBenchmark( len, shape, xtype, ytype ) {
+	var x;
+	var y;
+
+	y = filledarray( 0.0, len, ytype );
+	x = {
+		'dtype': xtype,
+		'data': [ 10.0 ],
+		'shape': [],
+		'strides': [ 0 ],
+		'offset': 0,
+		'order': order
+	};
+	y = {
+		'dtype': ytype,
+		'data': y,
+		'shape': shape,
+		'strides': shape2strides( shape, order ),
+		'offset': 0,
+		'order': order
+	};
+	return benchmark;
+
+	/**
+	* Benchmark function.
+	*
+	* @private
+	* @param {Benchmark} b - benchmark instance
+	*/
+	function benchmark( b ) {
+		var i;
+
+		b.tic();
+		for ( i = 0; i < b.iterations; i++ ) {
+			assignScalar( x, y );
+			if ( isnan( y.data[ i%len ] ) ) {
+				b.fail( 'should not return NaN' );
+			}
+		}
+		b.toc();
+		if ( isnan( y.data[ i%len ] ) ) {
+			b.fail( 'should not return NaN' );
+		}
+		b.pass( 'benchmark finished' );
+		b.end();
+	}
+}
+
+
+// MAIN //
+
+/**
+* Main execution sequence.
+*
+* @private
+*/
+function main() {
+	var len;
+	var min;
+	var max;
+	var sh;
+	var t1;
+	var t2;
+	var f;
+	var i;
+	var j;
+
+	min = 1; // 10^min
+	max = 6; // 10^max
+
+	for ( j = 0; j < types.length; j++ ) {
+		t1 = types[ j ];
+		t2 = types[ j ];
+		for ( i = min; i <= max; i++ ) {
+			len = pow( 10, i );
+
+			sh = [ len/2, 2, 1, 1, 1, 1, 1, 1, 1, 1 ];
+			f = createBenchmark( len, sh, t1, t2 );
+			bench( format( '%s::blocked:ndims=%d,len=%d,shape=[%s],xorder=%s,yorder=%s,xtype=%s,ytype=%s', pkg, sh.length, len, sh.join( ',' ), order, order, t1, t2 ), f );
+
+			sh = [ 1, 1, 1, 1, 1, 1, 1, 1, 2, len/2 ];
+			f = createBenchmark( len, sh, t1, t2 );
+			bench( format( '%s::blocked:ndims=%d,len=%d,shape=[%s],xorder=%s,yorder=%s,xtype=%s,ytype=%s', pkg, sh.length, len, sh.join( ',' ), order, order, t1, t2 ), f );
+
+			len = floor( pow( len, 1.0/10.0 ) );
+			sh = [ len, len, len, len, len, len, len, len, len, len ];
+			len *= pow( len, 9 );
+			f = createBenchmark( len, sh, t1, t2 );
+			bench( format( '%s::blocked:ndims=%d,len=%d,shape=[%s],xorder=%s,yorder=%s,xtype=%s,ytype=%s', pkg, sh.length, len, sh.join( ',' ), order, order, t1, t2 ), f );
+		}
+	}
+}
+
+main();
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.10d_columnmajor.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.10d_columnmajor.js
new file mode 100644
index 000000000000..8e43383c4eea
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.10d_columnmajor.js
@@ -0,0 +1,145 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2026 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 bench = require( '@stdlib/bench' );
+var isnan = require( '@stdlib/math/base/assert/is-nan' );
+var pow = require( '@stdlib/math/base/special/pow' );
+var floor = require( '@stdlib/math/base/special/floor' );
+var filledarray = require( '@stdlib/array/filled' );
+var shape2strides = require( '@stdlib/ndarray/base/shape2strides' );
+var format = require( '@stdlib/string/format' );
+var pkg = require( './../package.json' ).name;
+var assignScalar = require( './../lib/10d.js' );
+
+
+// VARIABLES //
+
+var types = [ 'float64' ];
+var order = 'column-major';
+
+
+// FUNCTIONS //
+
+/**
+* Creates a benchmark function.
+*
+* @private
+* @param {PositiveInteger} len - ndarray length
+* @param {NonNegativeIntegerArray} shape - ndarray shape
+* @param {string} xtype - input ndarray data type
+* @param {string} ytype - output ndarray data type
+* @returns {Function} benchmark function
+*/
+function createBenchmark( len, shape, xtype, ytype ) {
+	var x;
+	var y;
+
+	y = filledarray( 0.0, len, ytype );
+	x = {
+		'dtype': xtype,
+		'data': [ 10.0 ],
+		'shape': [],
+		'strides': [ 0 ],
+		'offset': 0,
+		'order': order
+	};
+	y = {
+		'dtype': ytype,
+		'data': y,
+		'shape': shape,
+		'strides': shape2strides( shape, order ),
+		'offset': 0,
+		'order': order
+	};
+	return benchmark;
+
+	/**
+	* Benchmark function.
+	*
+	* @private
+	* @param {Benchmark} b - benchmark instance
+	*/
+	function benchmark( b ) {
+		var i;
+
+		b.tic();
+		for ( i = 0; i < b.iterations; i++ ) {
+			assignScalar( x, y );
+			if ( isnan( y.data[ i%len ] ) ) {
+				b.fail( 'should not return NaN' );
+			}
+		}
+		b.toc();
+		if ( isnan( y.data[ i%len ] ) ) {
+			b.fail( 'should not return NaN' );
+		}
+		b.pass( 'benchmark finished' );
+		b.end();
+	}
+}
+
+
+// MAIN //
+
+/**
+* Main execution sequence.
+*
+* @private
+*/
+function main() {
+	var len;
+	var min;
+	var max;
+	var sh;
+	var t1;
+	var t2;
+	var f;
+	var i;
+	var j;
+
+	min = 1; // 10^min
+	max = 6; // 10^max
+
+	for ( j = 0; j < types.length; j++ ) {
+		t1 = types[ j ];
+		t2 = types[ j ];
+		for ( i = min; i <= max; i++ ) {
+			len = pow( 10, i );
+
+			sh = [ len/2, 2, 1, 1, 1, 1, 1, 1, 1, 1 ];
+			f = createBenchmark( len, sh, t1, t2 );
+			bench( format( '%s:ndims=%d,len=%d,shape=[%s],xorder=%s,yorder=%s,xtype=%s,ytype=%s', pkg, sh.length, len, sh.join( ',' ), order, order, t1, t2 ), f );
+
+			sh = [ 1, 1, 1, 1, 1, 1, 1, 1, 2, len/2 ];
+			f = createBenchmark( len, sh, t1, t2 );
+			bench( format( '%s:ndims=%d,len=%d,shape=[%s],xorder=%s,yorder=%s,xtype=%s,ytype=%s', pkg, sh.length, len, sh.join( ',' ), order, order, t1, t2 ), f );
+
+			len = floor( pow( len, 1.0/10.0 ) );
+			sh = [ len, len, len, len, len, len, len, len, len, len ];
+			len *= pow( len, 9 );
+			f = createBenchmark( len, sh, t1, t2 );
+			bench( format( '%s:ndims=%d,len=%d,shape=[%s],xorder=%s,yorder=%s,xtype=%s,ytype=%s', pkg, sh.length, len, sh.join( ',' ), order, order, t1, t2 ), f );
+		}
+	}
+}
+
+main();
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.10d_rowmajor.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.10d_rowmajor.js
new file mode 100644
index 000000000000..bda8225eb29c
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.10d_rowmajor.js
@@ -0,0 +1,145 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2026 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 bench = require( '@stdlib/bench' );
+var isnan = require( '@stdlib/math/base/assert/is-nan' );
+var pow = require( '@stdlib/math/base/special/pow' );
+var floor = require( '@stdlib/math/base/special/floor' );
+var filledarray = require( '@stdlib/array/filled' );
+var shape2strides = require( '@stdlib/ndarray/base/shape2strides' );
+var format = require( '@stdlib/string/format' );
+var pkg = require( './../package.json' ).name;
+var assignScalar = require( './../lib/10d.js' );
+
+
+// VARIABLES //
+
+var types = [ 'float64' ];
+var order = 'row-major';
+
+
+// FUNCTIONS //
+
+/**
+* Creates a benchmark function.
+*
+* @private
+* @param {PositiveInteger} len - ndarray length
+* @param {NonNegativeIntegerArray} shape - ndarray shape
+* @param {string} xtype - input ndarray data type
+* @param {string} ytype - output ndarray data type
+* @returns {Function} benchmark function
+*/
+function createBenchmark( len, shape, xtype, ytype ) {
+	var x;
+	var y;
+
+	y = filledarray( 0.0, len, ytype );
+	x = {
+		'dtype': xtype,
+		'data': [ 10.0 ],
+		'shape': [],
+		'strides': [ 0 ],
+		'offset': 0,
+		'order': order
+	};
+	y = {
+		'dtype': ytype,
+		'data': y,
+		'shape': shape,
+		'strides': shape2strides( shape, order ),
+		'offset': 0,
+		'order': order
+	};
+	return benchmark;
+
+	/**
+	* Benchmark function.
+	*
+	* @private
+	* @param {Benchmark} b - benchmark instance
+	*/
+	function benchmark( b ) {
+		var i;
+
+		b.tic();
+		for ( i = 0; i < b.iterations; i++ ) {
+			assignScalar( x, y );
+			if ( isnan( y.data[ i%len ] ) ) {
+				b.fail( 'should not return NaN' );
+			}
+		}
+		b.toc();
+		if ( isnan( y.data[ i%len ] ) ) {
+			b.fail( 'should not return NaN' );
+		}
+		b.pass( 'benchmark finished' );
+		b.end();
+	}
+}
+
+
+// MAIN //
+
+/**
+* Main execution sequence.
+*
+* @private
+*/
+function main() {
+	var len;
+	var min;
+	var max;
+	var sh;
+	var t1;
+	var t2;
+	var f;
+	var i;
+	var j;
+
+	min = 1; // 10^min
+	max = 6; // 10^max
+
+	for ( j = 0; j < types.length; j++ ) {
+		t1 = types[ j ];
+		t2 = types[ j ];
+		for ( i = min; i <= max; i++ ) {
+			len = pow( 10, i );
+
+			sh = [ len/2, 2, 1, 1, 1, 1, 1, 1, 1, 1 ];
+			f = createBenchmark( len, sh, t1, t2 );
+			bench( format( '%s:ndims=%d,len=%d,shape=[%s],xorder=%s,yorder=%s,xtype=%s,ytype=%s', pkg, sh.length, len, sh.join( ',' ), order, order, t1, t2 ), f );
+
+			sh = [ 1, 1, 1, 1, 1, 1, 1, 1, 2, len/2 ];
+			f = createBenchmark( len, sh, t1, t2 );
+			bench( format( '%s:ndims=%d,len=%d,shape=[%s],xorder=%s,yorder=%s,xtype=%s,ytype=%s', pkg, sh.length, len, sh.join( ',' ), order, order, t1, t2 ), f );
+
+			len = floor( pow( len, 1.0/10.0 ) );
+			sh = [ len, len, len, len, len, len, len, len, len, len ];
+			len *= pow( len, 9 );
+			f = createBenchmark( len, sh, t1, t2 );
+			bench( format( '%s:ndims=%d,len=%d,shape=[%s],xorder=%s,yorder=%s,xtype=%s,ytype=%s', pkg, sh.length, len, sh.join( ',' ), order, order, t1, t2 ), f );
+		}
+	}
+}
+
+main();
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.11d_columnmajor.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.11d_columnmajor.js
new file mode 100644
index 000000000000..55a07c367ce8
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.11d_columnmajor.js
@@ -0,0 +1,145 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2026 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 bench = require( '@stdlib/bench' );
+var isnan = require( '@stdlib/math/base/assert/is-nan' );
+var pow = require( '@stdlib/math/base/special/pow' );
+var floor = require( '@stdlib/math/base/special/floor' );
+var filledarray = require( '@stdlib/array/filled' );
+var shape2strides = require( '@stdlib/ndarray/base/shape2strides' );
+var format = require( '@stdlib/string/format' );
+var pkg = require( './../package.json' ).name;
+var assignScalar = require( './../lib/nd.js' );
+
+
+// VARIABLES //
+
+var types = [ 'float64' ];
+var order = 'column-major';
+
+
+// FUNCTIONS //
+
+/**
+* Creates a benchmark function.
+*
+* @private
+* @param {PositiveInteger} len - ndarray length
+* @param {NonNegativeIntegerArray} shape - ndarray shape
+* @param {string} xtype - input ndarray data type
+* @param {string} ytype - output ndarray data type
+* @returns {Function} benchmark function
+*/
+function createBenchmark( len, shape, xtype, ytype ) {
+	var x;
+	var y;
+
+	y = filledarray( 0.0, len, ytype );
+	x = {
+		'dtype': xtype,
+		'data': [ 10.0 ],
+		'shape': [],
+		'strides': [ 0 ],
+		'offset': 0,
+		'order': order
+	};
+	y = {
+		'dtype': ytype,
+		'data': y,
+		'shape': shape,
+		'strides': shape2strides( shape, order ),
+		'offset': 0,
+		'order': order
+	};
+	return benchmark;
+
+	/**
+	* Benchmark function.
+	*
+	* @private
+	* @param {Benchmark} b - benchmark instance
+	*/
+	function benchmark( b ) {
+		var i;
+
+		b.tic();
+		for ( i = 0; i < b.iterations; i++ ) {
+			assignScalar( x, y );
+			if ( isnan( y.data[ i%len ] ) ) {
+				b.fail( 'should not return NaN' );
+			}
+		}
+		b.toc();
+		if ( isnan( y.data[ i%len ] ) ) {
+			b.fail( 'should not return NaN' );
+		}
+		b.pass( 'benchmark finished' );
+		b.end();
+	}
+}
+
+
+// MAIN //
+
+/**
+* Main execution sequence.
+*
+* @private
+*/
+function main() {
+	var len;
+	var min;
+	var max;
+	var sh;
+	var t1;
+	var t2;
+	var f;
+	var i;
+	var j;
+
+	min = 1; // 10^min
+	max = 6; // 10^max
+
+	for ( j = 0; j < types.length; j++ ) {
+		t1 = types[ j ];
+		t2 = types[ j ];
+		for ( i = min; i <= max; i++ ) {
+			len = pow( 10, i );
+
+			sh = [ len/2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1 ];
+			f = createBenchmark( len, sh, t1, t2 );
+			bench( format( '%s:ndims=%d,len=%d,shape=[%s],xorder=%s,yorder=%s,xtype=%s,ytype=%s', pkg, sh.length, len, sh.join( ',' ), order, order, t1, t2 ), f );
+
+			sh = [ 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, len/2 ];
+			f = createBenchmark( len, sh, t1, t2 );
+			bench( format( '%s:ndims=%d,len=%d,shape=[%s],xorder=%s,yorder=%s,xtype=%s,ytype=%s', pkg, sh.length, len, sh.join( ',' ), order, order, t1, t2 ), f );
+
+			len = floor( pow( len, 1.0/11.0 ) );
+			sh = [ len, len, len, len, len, len, len, len, len, len, len ];
+			len *= pow( len, 10 );
+			f = createBenchmark( len, sh, t1, t2 );
+			bench( format( '%s:ndims=%d,len=%d,shape=[%s],xorder=%s,yorder=%s,xtype=%s,ytype=%s', pkg, sh.length, len, sh.join( ',' ), order, order, t1, t2 ), f );
+		}
+	}
+}
+
+main();
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.11d_rowmajor.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.11d_rowmajor.js
new file mode 100644
index 000000000000..9c38dd55c81e
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.11d_rowmajor.js
@@ -0,0 +1,145 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2026 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 bench = require( '@stdlib/bench' );
+var isnan = require( '@stdlib/math/base/assert/is-nan' );
+var pow = require( '@stdlib/math/base/special/pow' );
+var floor = require( '@stdlib/math/base/special/floor' );
+var filledarray = require( '@stdlib/array/filled' );
+var shape2strides = require( '@stdlib/ndarray/base/shape2strides' );
+var format = require( '@stdlib/string/format' );
+var pkg = require( './../package.json' ).name;
+var assignScalar = require( './../lib/nd.js' );
+
+
+// VARIABLES //
+
+var types = [ 'float64' ];
+var order = 'row-major';
+
+
+// FUNCTIONS //
+
+/**
+* Creates a benchmark function.
+*
+* @private
+* @param {PositiveInteger} len - ndarray length
+* @param {NonNegativeIntegerArray} shape - ndarray shape
+* @param {string} xtype - input ndarray data type
+* @param {string} ytype - output ndarray data type
+* @returns {Function} benchmark function
+*/
+function createBenchmark( len, shape, xtype, ytype ) {
+	var x;
+	var y;
+
+	y = filledarray( 0.0, len, ytype );
+	x = {
+		'dtype': xtype,
+		'data': [ 10.0 ],
+		'shape': [],
+		'strides': [ 0 ],
+		'offset': 0,
+		'order': order
+	};
+	y = {
+		'dtype': ytype,
+		'data': y,
+		'shape': shape,
+		'strides': shape2strides( shape, order ),
+		'offset': 0,
+		'order': order
+	};
+	return benchmark;
+
+	/**
+	* Benchmark function.
+	*
+	* @private
+	* @param {Benchmark} b - benchmark instance
+	*/
+	function benchmark( b ) {
+		var i;
+
+		b.tic();
+		for ( i = 0; i < b.iterations; i++ ) {
+			assignScalar( x, y );
+			if ( isnan( y.data[ i%len ] ) ) {
+				b.fail( 'should not return NaN' );
+			}
+		}
+		b.toc();
+		if ( isnan( y.data[ i%len ] ) ) {
+			b.fail( 'should not return NaN' );
+		}
+		b.pass( 'benchmark finished' );
+		b.end();
+	}
+}
+
+
+// MAIN //
+
+/**
+* Main execution sequence.
+*
+* @private
+*/
+function main() {
+	var len;
+	var min;
+	var max;
+	var sh;
+	var t1;
+	var t2;
+	var f;
+	var i;
+	var j;
+
+	min = 1; // 10^min
+	max = 6; // 10^max
+
+	for ( j = 0; j < types.length; j++ ) {
+		t1 = types[ j ];
+		t2 = types[ j ];
+		for ( i = min; i <= max; i++ ) {
+			len = pow( 10, i );
+
+			sh = [ len/2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1 ];
+			f = createBenchmark( len, sh, t1, t2 );
+			bench( format( '%s:ndims=%d,len=%d,shape=[%s],xorder=%s,yorder=%s,xtype=%s,ytype=%s', pkg, sh.length, len, sh.join( ',' ), order, order, t1, t2 ), f );
+
+			sh = [ 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, len/2 ];
+			f = createBenchmark( len, sh, t1, t2 );
+			bench( format( '%s:ndims=%d,len=%d,shape=[%s],xorder=%s,yorder=%s,xtype=%s,ytype=%s', pkg, sh.length, len, sh.join( ',' ), order, order, t1, t2 ), f );
+
+			len = floor( pow( len, 1.0/11.0 ) );
+			sh = [ len, len, len, len, len, len, len, len, len, len, len ];
+			len *= pow( len, 10 );
+			f = createBenchmark( len, sh, t1, t2 );
+			bench( format( '%s:ndims=%d,len=%d,shape=[%s],xorder=%s,yorder=%s,xtype=%s,ytype=%s', pkg, sh.length, len, sh.join( ',' ), order, order, t1, t2 ), f );
+		}
+	}
+}
+
+main();
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.1d_columnmajor.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.1d_columnmajor.js
new file mode 100644
index 000000000000..d742352f7bf1
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.1d_columnmajor.js
@@ -0,0 +1,134 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2026 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 bench = require( '@stdlib/bench' );
+var isnan = require( '@stdlib/math/base/assert/is-nan' );
+var pow = require( '@stdlib/math/base/special/pow' );
+var filledarray = require( '@stdlib/array/filled' );
+var shape2strides = require( '@stdlib/ndarray/base/shape2strides' );
+var format = require( '@stdlib/string/format' );
+var pkg = require( './../package.json' ).name;
+var assignScalar = require( './../lib' );
+
+
+// VARIABLES //
+
+var types = [ 'float64' ];
+var order = 'column-major';
+
+
+// FUNCTIONS //
+
+/**
+* Creates a benchmark function.
+*
+* @private
+* @param {PositiveInteger} len - ndarray length
+* @param {NonNegativeIntegerArray} shape - ndarray shape
+* @param {string} xtype - input ndarray data type
+* @param {string} ytype - output ndarray data type
+* @returns {Function} benchmark function
+*/
+function createBenchmark( len, shape, xtype, ytype ) {
+	var x;
+	var y;
+
+	y = filledarray( 0.0, len, ytype );
+	x = {
+		'dtype': xtype,
+		'data': [ 10.0 ],
+		'shape': [],
+		'strides': [ 0 ],
+		'offset': 0,
+		'order': order
+	};
+	y = {
+		'dtype': ytype,
+		'data': y,
+		'shape': shape,
+		'strides': shape2strides( shape, order ),
+		'offset': 0,
+		'order': order
+	};
+	return benchmark;
+
+	/**
+	* Benchmark function.
+	*
+	* @private
+	* @param {Benchmark} b - benchmark instance
+	*/
+	function benchmark( b ) {
+		var i;
+
+		b.tic();
+		for ( i = 0; i < b.iterations; i++ ) {
+			assignScalar( [ x, y ] );
+			if ( isnan( y.data[ i%len ] ) ) {
+				b.fail( 'should not return NaN' );
+			}
+		}
+		b.toc();
+		if ( isnan( y.data[ i%len ] ) ) {
+			b.fail( 'should not return NaN' );
+		}
+		b.pass( 'benchmark finished' );
+		b.end();
+	}
+}
+
+
+// MAIN //
+
+/**
+* Main execution sequence.
+*
+* @private
+*/
+function main() {
+	var len;
+	var min;
+	var max;
+	var sh;
+	var t1;
+	var t2;
+	var f;
+	var i;
+	var j;
+
+	min = 1; // 10^min
+	max = 6; // 10^max
+
+	for ( j = 0; j < types.length; j++ ) {
+		t1 = types[ j ];
+		t2 = types[ j ];
+		for ( i = min; i <= max; i++ ) {
+			len = pow( 10, i );
+
+			sh = [ len ];
+			f = createBenchmark( len, sh, t1, t2 );
+			bench( format( '%s:ndims=%d,len=%d,shape=[%s],xorder=%s,yorder=%s,xtype=%s,ytype=%s', pkg, sh.length, len, sh.join( ',' ), order, order, t1, t2 ), f );
+		}
+	}
+}
+
+main();
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.1d_rowmajor.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.1d_rowmajor.js
new file mode 100644
index 000000000000..8d6671e3accd
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.1d_rowmajor.js
@@ -0,0 +1,134 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2026 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 bench = require( '@stdlib/bench' );
+var isnan = require( '@stdlib/math/base/assert/is-nan' );
+var pow = require( '@stdlib/math/base/special/pow' );
+var filledarray = require( '@stdlib/array/filled' );
+var shape2strides = require( '@stdlib/ndarray/base/shape2strides' );
+var format = require( '@stdlib/string/format' );
+var pkg = require( './../package.json' ).name;
+var assignScalar = require( './../lib' );
+
+
+// VARIABLES //
+
+var types = [ 'float64' ];
+var order = 'row-major';
+
+
+// FUNCTIONS //
+
+/**
+* Creates a benchmark function.
+*
+* @private
+* @param {PositiveInteger} len - ndarray length
+* @param {NonNegativeIntegerArray} shape - ndarray shape
+* @param {string} xtype - input ndarray data type
+* @param {string} ytype - output ndarray data type
+* @returns {Function} benchmark function
+*/
+function createBenchmark( len, shape, xtype, ytype ) {
+	var x;
+	var y;
+
+	y = filledarray( 0.0, len, ytype );
+	x = {
+		'dtype': xtype,
+		'data': [ 10.0 ],
+		'shape': [],
+		'strides': [ 0 ],
+		'offset': 0,
+		'order': order
+	};
+	y = {
+		'dtype': ytype,
+		'data': y,
+		'shape': shape,
+		'strides': shape2strides( shape, order ),
+		'offset': 0,
+		'order': order
+	};
+	return benchmark;
+
+	/**
+	* Benchmark function.
+	*
+	* @private
+	* @param {Benchmark} b - benchmark instance
+	*/
+	function benchmark( b ) {
+		var i;
+
+		b.tic();
+		for ( i = 0; i < b.iterations; i++ ) {
+			assignScalar( [ x, y ] );
+			if ( isnan( y.data[ i%len ] ) ) {
+				b.fail( 'should not return NaN' );
+			}
+		}
+		b.toc();
+		if ( isnan( y.data[ i%len ] ) ) {
+			b.fail( 'should not return NaN' );
+		}
+		b.pass( 'benchmark finished' );
+		b.end();
+	}
+}
+
+
+// MAIN //
+
+/**
+* Main execution sequence.
+*
+* @private
+*/
+function main() {
+	var len;
+	var min;
+	var max;
+	var sh;
+	var t1;
+	var t2;
+	var f;
+	var i;
+	var j;
+
+	min = 1; // 10^min
+	max = 6; // 10^max
+
+	for ( j = 0; j < types.length; j++ ) {
+		t1 = types[ j ];
+		t2 = types[ j ];
+		for ( i = min; i <= max; i++ ) {
+			len = pow( 10, i );
+
+			sh = [ len ];
+			f = createBenchmark( len, sh, t1, t2 );
+			bench( format( '%s:ndims=%d,len=%d,shape=[%s],xorder=%s,yorder=%s,xtype=%s,ytype=%s', pkg, sh.length, len, sh.join( ',' ), order, order, t1, t2 ), f );
+		}
+	}
+}
+
+main();
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.2d_blocked_columnmajor.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.2d_blocked_columnmajor.js
new file mode 100644
index 000000000000..5f5f109ba9c1
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.2d_blocked_columnmajor.js
@@ -0,0 +1,146 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2026 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 bench = require( '@stdlib/bench' );
+var isnan = require( '@stdlib/math/base/assert/is-nan' );
+var pow = require( '@stdlib/math/base/special/pow' );
+var floor = require( '@stdlib/math/base/special/floor' );
+var sqrt = require( '@stdlib/math/base/special/sqrt' );
+var filledarray = require( '@stdlib/array/filled' );
+var shape2strides = require( '@stdlib/ndarray/base/shape2strides' );
+var format = require( '@stdlib/string/format' );
+var pkg = require( './../package.json' ).name;
+var assignScalar = require( './../lib/2d_blocked.js' );
+
+
+// VARIABLES //
+
+var types = [ 'float64' ];
+var order = 'column-major';
+
+
+// FUNCTIONS //
+
+/**
+* Creates a benchmark function.
+*
+* @private
+* @param {PositiveInteger} len - ndarray length
+* @param {NonNegativeIntegerArray} shape - ndarray shape
+* @param {string} xtype - input ndarray data type
+* @param {string} ytype - output ndarray data type
+* @returns {Function} benchmark function
+*/
+function createBenchmark( len, shape, xtype, ytype ) {
+	var x;
+	var y;
+
+	y = filledarray( 0.0, len, ytype );
+	x = {
+		'dtype': xtype,
+		'data': [ 10.0 ],
+		'shape': [],
+		'strides': [ 0 ],
+		'offset': 0,
+		'order': order
+	};
+	y = {
+		'dtype': ytype,
+		'data': y,
+		'shape': shape,
+		'strides': shape2strides( shape, order ),
+		'offset': 0,
+		'order': order
+	};
+	return benchmark;
+
+	/**
+	* Benchmark function.
+	*
+	* @private
+	* @param {Benchmark} b - benchmark instance
+	*/
+	function benchmark( b ) {
+		var i;
+
+		b.tic();
+		for ( i = 0; i < b.iterations; i++ ) {
+			assignScalar( x, y );
+			if ( isnan( y.data[ i%len ] ) ) {
+				b.fail( 'should not return NaN' );
+			}
+		}
+		b.toc();
+		if ( isnan( y.data[ i%len ] ) ) {
+			b.fail( 'should not return NaN' );
+		}
+		b.pass( 'benchmark finished' );
+		b.end();
+	}
+}
+
+
+// MAIN //
+
+/**
+* Main execution sequence.
+*
+* @private
+*/
+function main() {
+	var len;
+	var min;
+	var max;
+	var sh;
+	var t1;
+	var t2;
+	var f;
+	var i;
+	var j;
+
+	min = 1; // 10^min
+	max = 6; // 10^max
+
+	for ( j = 0; j < types.length; j++ ) {
+		t1 = types[ j ];
+		t2 = types[ j ];
+		for ( i = min; i <= max; i++ ) {
+			len = pow( 10, i );
+
+			sh = [ len/2, 2 ];
+			f = createBenchmark( len, sh, t1, t2 );
+			bench( format( '%s::blocked:ndims=%d,len=%d,shape=[%s],xorder=%s,yorder=%s,xtype=%s,ytype=%s', pkg, sh.length, len, sh.join( ',' ), order, order, t1, t2 ), f );
+
+			sh = [ 2, len/2 ];
+			f = createBenchmark( len, sh, t1, t2 );
+			bench( format( '%s::blocked:ndims=%d,len=%d,shape=[%s],xorder=%s,yorder=%s,xtype=%s,ytype=%s', pkg, sh.length, len, sh.join( ',' ), order, order, t1, t2 ), f );
+
+			len = floor( sqrt( len ) );
+			sh = [ len, len ];
+			len *= len;
+			f = createBenchmark( len, sh, t1, t2 );
+			bench( format( '%s::blocked:ndims=%d,len=%d,shape=[%s],xorder=%s,yorder=%s,xtype=%s,ytype=%s', pkg, sh.length, len, sh.join( ',' ), order, order, t1, t2 ), f );
+		}
+	}
+}
+
+main();
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.2d_blocked_rowmajor.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.2d_blocked_rowmajor.js
new file mode 100644
index 000000000000..9f322e61c151
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.2d_blocked_rowmajor.js
@@ -0,0 +1,146 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2026 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 bench = require( '@stdlib/bench' );
+var isnan = require( '@stdlib/math/base/assert/is-nan' );
+var pow = require( '@stdlib/math/base/special/pow' );
+var floor = require( '@stdlib/math/base/special/floor' );
+var sqrt = require( '@stdlib/math/base/special/sqrt' );
+var filledarray = require( '@stdlib/array/filled' );
+var shape2strides = require( '@stdlib/ndarray/base/shape2strides' );
+var format = require( '@stdlib/string/format' );
+var pkg = require( './../package.json' ).name;
+var assignScalar = require( './../lib/2d_blocked.js' );
+
+
+// VARIABLES //
+
+var types = [ 'float64' ];
+var order = 'row-major';
+
+
+// FUNCTIONS //
+
+/**
+* Creates a benchmark function.
+*
+* @private
+* @param {PositiveInteger} len - ndarray length
+* @param {NonNegativeIntegerArray} shape - ndarray shape
+* @param {string} xtype - input ndarray data type
+* @param {string} ytype - output ndarray data type
+* @returns {Function} benchmark function
+*/
+function createBenchmark( len, shape, xtype, ytype ) {
+	var x;
+	var y;
+
+	y = filledarray( 0.0, len, ytype );
+	x = {
+		'dtype': xtype,
+		'data': [ 10.0 ],
+		'shape': [],
+		'strides': [ 0 ],
+		'offset': 0,
+		'order': order
+	};
+	y = {
+		'dtype': ytype,
+		'data': y,
+		'shape': shape,
+		'strides': shape2strides( shape, order ),
+		'offset': 0,
+		'order': order
+	};
+	return benchmark;
+
+	/**
+	* Benchmark function.
+	*
+	* @private
+	* @param {Benchmark} b - benchmark instance
+	*/
+	function benchmark( b ) {
+		var i;
+
+		b.tic();
+		for ( i = 0; i < b.iterations; i++ ) {
+			assignScalar( x, y );
+			if ( isnan( y.data[ i%len ] ) ) {
+				b.fail( 'should not return NaN' );
+			}
+		}
+		b.toc();
+		if ( isnan( y.data[ i%len ] ) ) {
+			b.fail( 'should not return NaN' );
+		}
+		b.pass( 'benchmark finished' );
+		b.end();
+	}
+}
+
+
+// MAIN //
+
+/**
+* Main execution sequence.
+*
+* @private
+*/
+function main() {
+	var len;
+	var min;
+	var max;
+	var sh;
+	var t1;
+	var t2;
+	var f;
+	var i;
+	var j;
+
+	min = 1; // 10^min
+	max = 6; // 10^max
+
+	for ( j = 0; j < types.length; j++ ) {
+		t1 = types[ j ];
+		t2 = types[ j ];
+		for ( i = min; i <= max; i++ ) {
+			len = pow( 10, i );
+
+			sh = [ len/2, 2 ];
+			f = createBenchmark( len, sh, t1, t2 );
+			bench( format( '%s::blocked:ndims=%d,len=%d,shape=[%s],xorder=%s,yorder=%s,xtype=%s,ytype=%s', pkg, sh.length, len, sh.join( ',' ), order, order, t1, t2 ), f );
+
+			sh = [ 2, len/2 ];
+			f = createBenchmark( len, sh, t1, t2 );
+			bench( format( '%s::blocked:ndims=%d,len=%d,shape=[%s],xorder=%s,yorder=%s,xtype=%s,ytype=%s', pkg, sh.length, len, sh.join( ',' ), order, order, t1, t2 ), f );
+
+			len = floor( sqrt( len ) );
+			sh = [ len, len ];
+			len *= len;
+			f = createBenchmark( len, sh, t1, t2 );
+			bench( format( '%s::blocked:ndims=%d,len=%d,shape=[%s],xorder=%s,yorder=%s,xtype=%s,ytype=%s', pkg, sh.length, len, sh.join( ',' ), order, order, t1, t2 ), f );
+		}
+	}
+}
+
+main();
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.2d_columnmajor.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.2d_columnmajor.js
new file mode 100644
index 000000000000..c15dae8b042d
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.2d_columnmajor.js
@@ -0,0 +1,146 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2026 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 bench = require( '@stdlib/bench' );
+var isnan = require( '@stdlib/math/base/assert/is-nan' );
+var pow = require( '@stdlib/math/base/special/pow' );
+var floor = require( '@stdlib/math/base/special/floor' );
+var sqrt = require( '@stdlib/math/base/special/sqrt' );
+var filledarray = require( '@stdlib/array/filled' );
+var shape2strides = require( '@stdlib/ndarray/base/shape2strides' );
+var format = require( '@stdlib/string/format' );
+var pkg = require( './../package.json' ).name;
+var assignScalar = require( './../lib/2d.js' );
+
+
+// VARIABLES //
+
+var types = [ 'float64' ];
+var order = 'column-major';
+
+
+// FUNCTIONS //
+
+/**
+* Creates a benchmark function.
+*
+* @private
+* @param {PositiveInteger} len - ndarray length
+* @param {NonNegativeIntegerArray} shape - ndarray shape
+* @param {string} xtype - input ndarray data type
+* @param {string} ytype - output ndarray data type
+* @returns {Function} benchmark function
+*/
+function createBenchmark( len, shape, xtype, ytype ) {
+	var x;
+	var y;
+
+	y = filledarray( 0.0, len, ytype );
+	x = {
+		'dtype': xtype,
+		'data': [ 10.0 ],
+		'shape': [],
+		'strides': [ 0 ],
+		'offset': 0,
+		'order': order
+	};
+	y = {
+		'dtype': ytype,
+		'data': y,
+		'shape': shape,
+		'strides': shape2strides( shape, order ),
+		'offset': 0,
+		'order': order
+	};
+	return benchmark;
+
+	/**
+	* Benchmark function.
+	*
+	* @private
+	* @param {Benchmark} b - benchmark instance
+	*/
+	function benchmark( b ) {
+		var i;
+
+		b.tic();
+		for ( i = 0; i < b.iterations; i++ ) {
+			assignScalar( x, y );
+			if ( isnan( y.data[ i%len ] ) ) {
+				b.fail( 'should not return NaN' );
+			}
+		}
+		b.toc();
+		if ( isnan( y.data[ i%len ] ) ) {
+			b.fail( 'should not return NaN' );
+		}
+		b.pass( 'benchmark finished' );
+		b.end();
+	}
+}
+
+
+// MAIN //
+
+/**
+* Main execution sequence.
+*
+* @private
+*/
+function main() {
+	var len;
+	var min;
+	var max;
+	var sh;
+	var t1;
+	var t2;
+	var f;
+	var i;
+	var j;
+
+	min = 1; // 10^min
+	max = 6; // 10^max
+
+	for ( j = 0; j < types.length; j++ ) {
+		t1 = types[ j ];
+		t2 = types[ j ];
+		for ( i = min; i <= max; i++ ) {
+			len = pow( 10, i );
+
+			sh = [ len/2, 2 ];
+			f = createBenchmark( len, sh, t1, t2 );
+			bench( format( '%s:ndims=%d,len=%d,shape=[%s],xorder=%s,yorder=%s,xtype=%s,ytype=%s', pkg, sh.length, len, sh.join( ',' ), order, order, t1, t2 ), f );
+
+			sh = [ 2, len/2 ];
+			f = createBenchmark( len, sh, t1, t2 );
+			bench( format( '%s:ndims=%d,len=%d,shape=[%s],xorder=%s,yorder=%s,xtype=%s,ytype=%s', pkg, sh.length, len, sh.join( ',' ), order, order, t1, t2 ), f );
+
+			len = floor( sqrt( len ) );
+			sh = [ len, len ];
+			len *= len;
+			f = createBenchmark( len, sh, t1, t2 );
+			bench( format( '%s:ndims=%d,len=%d,shape=[%s],xorder=%s,yorder=%s,xtype=%s,ytype=%s', pkg, sh.length, len, sh.join( ',' ), order, order, t1, t2 ), f );
+		}
+	}
+}
+
+main();
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.2d_rowmajor.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.2d_rowmajor.js
new file mode 100644
index 000000000000..534a975fe112
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.2d_rowmajor.js
@@ -0,0 +1,146 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2026 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 bench = require( '@stdlib/bench' );
+var isnan = require( '@stdlib/math/base/assert/is-nan' );
+var pow = require( '@stdlib/math/base/special/pow' );
+var floor = require( '@stdlib/math/base/special/floor' );
+var sqrt = require( '@stdlib/math/base/special/sqrt' );
+var filledarray = require( '@stdlib/array/filled' );
+var shape2strides = require( '@stdlib/ndarray/base/shape2strides' );
+var format = require( '@stdlib/string/format' );
+var pkg = require( './../package.json' ).name;
+var assignScalar = require( './../lib/2d.js' );
+
+
+// VARIABLES //
+
+var types = [ 'float64' ];
+var order = 'row-major';
+
+
+// FUNCTIONS //
+
+/**
+* Creates a benchmark function.
+*
+* @private
+* @param {PositiveInteger} len - ndarray length
+* @param {NonNegativeIntegerArray} shape - ndarray shape
+* @param {string} xtype - input ndarray data type
+* @param {string} ytype - output ndarray data type
+* @returns {Function} benchmark function
+*/
+function createBenchmark( len, shape, xtype, ytype ) {
+	var x;
+	var y;
+
+	y = filledarray( 0.0, len, ytype );
+	x = {
+		'dtype': xtype,
+		'data': [ 10.0 ],
+		'shape': [],
+		'strides': [ 0 ],
+		'offset': 0,
+		'order': order
+	};
+	y = {
+		'dtype': ytype,
+		'data': y,
+		'shape': shape,
+		'strides': shape2strides( shape, order ),
+		'offset': 0,
+		'order': order
+	};
+	return benchmark;
+
+	/**
+	* Benchmark function.
+	*
+	* @private
+	* @param {Benchmark} b - benchmark instance
+	*/
+	function benchmark( b ) {
+		var i;
+
+		b.tic();
+		for ( i = 0; i < b.iterations; i++ ) {
+			assignScalar( x, y );
+			if ( isnan( y.data[ i%len ] ) ) {
+				b.fail( 'should not return NaN' );
+			}
+		}
+		b.toc();
+		if ( isnan( y.data[ i%len ] ) ) {
+			b.fail( 'should not return NaN' );
+		}
+		b.pass( 'benchmark finished' );
+		b.end();
+	}
+}
+
+
+// MAIN //
+
+/**
+* Main execution sequence.
+*
+* @private
+*/
+function main() {
+	var len;
+	var min;
+	var max;
+	var sh;
+	var t1;
+	var t2;
+	var f;
+	var i;
+	var j;
+
+	min = 1; // 10^min
+	max = 6; // 10^max
+
+	for ( j = 0; j < types.length; j++ ) {
+		t1 = types[ j ];
+		t2 = types[ j ];
+		for ( i = min; i <= max; i++ ) {
+			len = pow( 10, i );
+
+			sh = [ len/2, 2 ];
+			f = createBenchmark( len, sh, t1, t2 );
+			bench( format( '%s:ndims=%d,len=%d,shape=[%s],xorder=%s,yorder=%s,xtype=%s,ytype=%s', pkg, sh.length, len, sh.join( ',' ), order, order, t1, t2 ), f );
+
+			sh = [ 2, len/2 ];
+			f = createBenchmark( len, sh, t1, t2 );
+			bench( format( '%s:ndims=%d,len=%d,shape=[%s],xorder=%s,yorder=%s,xtype=%s,ytype=%s', pkg, sh.length, len, sh.join( ',' ), order, order, t1, t2 ), f );
+
+			len = floor( sqrt( len ) );
+			sh = [ len, len ];
+			len *= len;
+			f = createBenchmark( len, sh, t1, t2 );
+			bench( format( '%s:ndims=%d,len=%d,shape=[%s],xorder=%s,yorder=%s,xtype=%s,ytype=%s', pkg, sh.length, len, sh.join( ',' ), order, order, t1, t2 ), f );
+		}
+	}
+}
+
+main();
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.2d_rowmajor_accessors.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.2d_rowmajor_accessors.js
new file mode 100644
index 000000000000..70b175a97a62
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.2d_rowmajor_accessors.js
@@ -0,0 +1,174 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2026 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 bench = require( '@stdlib/bench' );
+var isnan = require( '@stdlib/math/base/assert/is-nan' );
+var pow = require( '@stdlib/math/base/special/pow' );
+var floor = require( '@stdlib/math/base/special/floor' );
+var sqrt = require( '@stdlib/math/base/special/sqrt' );
+var filledarray = require( '@stdlib/array/filled' );
+var shape2strides = require( '@stdlib/ndarray/base/shape2strides' );
+var format = require( '@stdlib/string/format' );
+var pkg = require( './../package.json' ).name;
+var assignScalar = require( './../lib/2d_accessors.js' );
+
+
+// VARIABLES //
+
+var types = [ 'float64' ];
+var order = 'row-major';
+
+
+// FUNCTIONS //
+
+/**
+* Returns an array data buffer element.
+*
+* @private
+* @param {Collection} buf - data buffer
+* @param {NonNegativeInteger} idx - element index
+* @returns {*} element
+*/
+function get( buf, idx ) {
+	return buf[ idx ];
+}
+
+/**
+* Sets an array data buffer element.
+*
+* @private
+* @param {Collection} buf - data buffer
+* @param {NonNegativeInteger} idx - element index
+* @param {*} value - value to set
+*/
+function set( buf, idx, value ) {
+	buf[ idx ] = value;
+}
+
+/**
+* Creates a benchmark function.
+*
+* @private
+* @param {PositiveInteger} len - ndarray length
+* @param {NonNegativeIntegerArray} shape - ndarray shape
+* @param {string} xtype - input ndarray data type
+* @param {string} ytype - output ndarray data type
+* @returns {Function} benchmark function
+*/
+function createBenchmark( len, shape, xtype, ytype ) {
+	var x;
+	var y;
+
+	y = filledarray( 0.0, len, ytype );
+	x = {
+		'dtype': xtype,
+		'data': [ 10.0 ],
+		'shape': [],
+		'strides': [ 0 ],
+		'offset': 0,
+		'order': order,
+		'accessorProtocol': true,
+		'accessors': [ get, set ]
+	};
+	y = {
+		'dtype': ytype,
+		'data': y,
+		'shape': shape,
+		'strides': shape2strides( shape, order ),
+		'offset': 0,
+		'order': order,
+		'accessorProtocol': true,
+		'accessors': [ get, set ]
+	};
+	return benchmark;
+
+	/**
+	* Benchmark function.
+	*
+	* @private
+	* @param {Benchmark} b - benchmark instance
+	*/
+	function benchmark( b ) {
+		var i;
+
+		b.tic();
+		for ( i = 0; i < b.iterations; i++ ) {
+			assignScalar( x, y );
+			if ( isnan( y.data[ i%len ] ) ) {
+				b.fail( 'should not return NaN' );
+			}
+		}
+		b.toc();
+		if ( isnan( y.data[ i%len ] ) ) {
+			b.fail( 'should not return NaN' );
+		}
+		b.pass( 'benchmark finished' );
+		b.end();
+	}
+}
+
+
+// MAIN //
+
+/**
+* Main execution sequence.
+*
+* @private
+*/
+function main() {
+	var len;
+	var min;
+	var max;
+	var sh;
+	var t1;
+	var t2;
+	var f;
+	var i;
+	var j;
+
+	min = 1; // 10^min
+	max = 6; // 10^max
+
+	for ( j = 0; j < types.length; j++ ) {
+		t1 = types[ j ];
+		t2 = types[ j ];
+		for ( i = min; i <= max; i++ ) {
+			len = pow( 10, i );
+
+			sh = [ len/2, 2 ];
+			f = createBenchmark( len, sh, t1, t2 );
+			bench( format( '%s::accessors:ndims=%d,len=%d,shape=[%s],xorder=%s,yorder=%s,xtype=%s,ytype=%s', pkg, sh.length, len, sh.join( ',' ), order, order, t1, t2 ), f );
+
+			sh = [ 2, len/2 ];
+			f = createBenchmark( len, sh, t1, t2 );
+			bench( format( '%s::accessors:ndims=%d,len=%d,shape=[%s],xorder=%s,yorder=%s,xtype=%s,ytype=%s', pkg, sh.length, len, sh.join( ',' ), order, order, t1, t2 ), f );
+
+			len = floor( sqrt( len ) );
+			sh = [ len, len ];
+			len *= len;
+			f = createBenchmark( len, sh, t1, t2 );
+			bench( format( '%s::accessors:ndims=%d,len=%d,shape=[%s],xorder=%s,yorder=%s,xtype=%s,ytype=%s', pkg, sh.length, len, sh.join( ',' ), order, order, t1, t2 ), f );
+		}
+	}
+}
+
+main();
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.2d_rowmajor_accessors_complex.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.2d_rowmajor_accessors_complex.js
new file mode 100644
index 000000000000..543a880b726d
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.2d_rowmajor_accessors_complex.js
@@ -0,0 +1,182 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2026 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 bench = require( '@stdlib/bench' );
+var isnan = require( '@stdlib/math/base/assert/is-nan' );
+var pow = require( '@stdlib/math/base/special/pow' );
+var floor = require( '@stdlib/math/base/special/floor' );
+var sqrt = require( '@stdlib/math/base/special/sqrt' );
+var filledarray = require( '@stdlib/array/filled' );
+var ctors = require( '@stdlib/array/typed-complex-ctors' );
+var shape2strides = require( '@stdlib/ndarray/base/shape2strides' );
+var format = require( '@stdlib/string/format' );
+var pkg = require( './../package.json' ).name;
+var assignScalar = require( './../lib/2d_accessors.js' );
+
+
+// VARIABLES //
+
+var types = [ 'complex64' ];
+var order = 'row-major';
+var abtype = {
+	'complex64': 'float32',
+	'complex128': 'float64'
+};
+
+
+// FUNCTIONS //
+
+/**
+* Returns an array data buffer element.
+*
+* @private
+* @param {Collection} buf - data buffer
+* @param {NonNegativeInteger} idx - element index
+* @returns {*} element
+*/
+function get( buf, idx ) {
+	return buf.get( idx );
+}
+
+/**
+* Sets an array data buffer element.
+*
+* @private
+* @param {Collection} buf - data buffer
+* @param {NonNegativeInteger} idx - element index
+* @param {*} value - value to set
+*/
+function set( buf, idx, value ) {
+	buf.set( value, idx );
+}
+
+/**
+* Creates a benchmark function.
+*
+* @private
+* @param {PositiveInteger} len - ndarray length
+* @param {NonNegativeIntegerArray} shape - ndarray shape
+* @param {string} xtype - input ndarray data type
+* @param {string} ytype - output ndarray data type
+* @returns {Function} benchmark function
+*/
+function createBenchmark( len, shape, xtype, ytype ) {
+	var xbuf;
+	var ybuf;
+	var x;
+	var y;
+
+	xbuf = filledarray( 10.0, 2, abtype[ xtype ] );
+	ybuf = filledarray( 0.0, len*2, abtype[ ytype ] );
+	x = {
+		'dtype': xtype,
+		'data': new ( ctors( xtype ) )( xbuf.buffer ),
+		'shape': [],
+		'strides': [ 0 ],
+		'offset': 0,
+		'order': order,
+		'accessorProtocol': true,
+		'accessors': [ get, set ]
+	};
+	y = {
+		'dtype': ytype,
+		'data': new ( ctors( ytype ) )( ybuf.buffer ),
+		'shape': shape,
+		'strides': shape2strides( shape, order ),
+		'offset': 0,
+		'order': order,
+		'accessorProtocol': true,
+		'accessors': [ get, set ]
+	};
+	return benchmark;
+
+	/**
+	* Benchmark function.
+	*
+	* @private
+	* @param {Benchmark} b - benchmark instance
+	*/
+	function benchmark( b ) {
+		var i;
+
+		b.tic();
+		for ( i = 0; i < b.iterations; i++ ) {
+			assignScalar( x, y );
+			if ( isnan( ybuf[ i%len ] ) ) {
+				b.fail( 'should not return NaN' );
+			}
+		}
+		b.toc();
+		if ( isnan( ybuf[ i%len ] ) ) {
+			b.fail( 'should not return NaN' );
+		}
+		b.pass( 'benchmark finished' );
+		b.end();
+	}
+}
+
+
+// MAIN //
+
+/**
+* Main execution sequence.
+*
+* @private
+*/
+function main() {
+	var len;
+	var min;
+	var max;
+	var sh;
+	var t1;
+	var t2;
+	var f;
+	var i;
+	var j;
+
+	min = 1; // 10^min
+	max = 5; // 10^max
+
+	for ( j = 0; j < types.length; j++ ) {
+		t1 = types[ j ];
+		t2 = types[ j ];
+		for ( i = min; i <= max; i++ ) {
+			len = pow( 10, i );
+
+			sh = [ len/2, 2 ];
+			f = createBenchmark( len, sh, t1, t2 );
+			bench( format( '%s::accessors:ndims=%d,len=%d,shape=[%s],xorder=%s,yorder=%s,xtype=%s,ytype=%s', pkg, sh.length, len, sh.join( ',' ), order, order, t1, t2 ), f );
+
+			sh = [ 2, len/2 ];
+			f = createBenchmark( len, sh, t1, t2 );
+			bench( format( '%s::accessors:ndims=%d,len=%d,shape=[%s],xorder=%s,yorder=%s,xtype=%s,ytype=%s', pkg, sh.length, len, sh.join( ',' ), order, order, t1, t2 ), f );
+
+			len = floor( sqrt( len ) );
+			sh = [ len, len ];
+			len *= len;
+			f = createBenchmark( len, sh, t1, t2 );
+			bench( format( '%s::accessors:ndims=%d,len=%d,shape=[%s],xorder=%s,yorder=%s,xtype=%s,ytype=%s', pkg, sh.length, len, sh.join( ',' ), order, order, t1, t2 ), f );
+		}
+	}
+}
+
+main();
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.3d_blocked_columnmajor.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.3d_blocked_columnmajor.js
new file mode 100644
index 000000000000..47843d6e9dfb
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.3d_blocked_columnmajor.js
@@ -0,0 +1,146 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2026 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 bench = require( '@stdlib/bench' );
+var isnan = require( '@stdlib/math/base/assert/is-nan' );
+var pow = require( '@stdlib/math/base/special/pow' );
+var floor = require( '@stdlib/math/base/special/floor' );
+var cbrt = require( '@stdlib/math/base/special/cbrt' );
+var filledarray = require( '@stdlib/array/filled' );
+var shape2strides = require( '@stdlib/ndarray/base/shape2strides' );
+var format = require( '@stdlib/string/format' );
+var pkg = require( './../package.json' ).name;
+var assignScalar = require( './../lib/3d_blocked.js' );
+
+
+// VARIABLES //
+
+var types = [ 'float64' ];
+var order = 'column-major';
+
+
+// FUNCTIONS //
+
+/**
+* Creates a benchmark function.
+*
+* @private
+* @param {PositiveInteger} len - ndarray length
+* @param {NonNegativeIntegerArray} shape - ndarray shape
+* @param {string} xtype - input ndarray data type
+* @param {string} ytype - output ndarray data type
+* @returns {Function} benchmark function
+*/
+function createBenchmark( len, shape, xtype, ytype ) {
+	var x;
+	var y;
+
+	y = filledarray( 0.0, len, ytype );
+	x = {
+		'dtype': xtype,
+		'data': [ 10.0 ],
+		'shape': [],
+		'strides': [ 0 ],
+		'offset': 0,
+		'order': order
+	};
+	y = {
+		'dtype': ytype,
+		'data': y,
+		'shape': shape,
+		'strides': shape2strides( shape, order ),
+		'offset': 0,
+		'order': order
+	};
+	return benchmark;
+
+	/**
+	* Benchmark function.
+	*
+	* @private
+	* @param {Benchmark} b - benchmark instance
+	*/
+	function benchmark( b ) {
+		var i;
+
+		b.tic();
+		for ( i = 0; i < b.iterations; i++ ) {
+			assignScalar( x, y );
+			if ( isnan( y.data[ i%len ] ) ) {
+				b.fail( 'should not return NaN' );
+			}
+		}
+		b.toc();
+		if ( isnan( y.data[ i%len ] ) ) {
+			b.fail( 'should not return NaN' );
+		}
+		b.pass( 'benchmark finished' );
+		b.end();
+	}
+}
+
+
+// MAIN //
+
+/**
+* Main execution sequence.
+*
+* @private
+*/
+function main() {
+	var len;
+	var min;
+	var max;
+	var sh;
+	var t1;
+	var t2;
+	var f;
+	var i;
+	var j;
+
+	min = 1; // 10^min
+	max = 6; // 10^max
+
+	for ( j = 0; j < types.length; j++ ) {
+		t1 = types[ j ];
+		t2 = types[ j ];
+		for ( i = min; i <= max; i++ ) {
+			len = pow( 10, i );
+
+			sh = [ len/2, 2, 1 ];
+			f = createBenchmark( len, sh, t1, t2 );
+			bench( format( '%s::blocked:ndims=%d,len=%d,shape=[%s],xorder=%s,yorder=%s,xtype=%s,ytype=%s', pkg, sh.length, len, sh.join( ',' ), order, order, t1, t2 ), f );
+
+			sh = [ 1, 2, len/2 ];
+			f = createBenchmark( len, sh, t1, t2 );
+			bench( format( '%s::blocked:ndims=%d,len=%d,shape=[%s],xorder=%s,yorder=%s,xtype=%s,ytype=%s', pkg, sh.length, len, sh.join( ',' ), order, order, t1, t2 ), f );
+
+			len = floor( cbrt( len ) );
+			sh = [ len, len, len ];
+			len *= len * len;
+			f = createBenchmark( len, sh, t1, t2 );
+			bench( format( '%s::blocked:ndims=%d,len=%d,shape=[%s],xorder=%s,yorder=%s,xtype=%s,ytype=%s', pkg, sh.length, len, sh.join( ',' ), order, order, t1, t2 ), f );
+		}
+	}
+}
+
+main();
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.3d_blocked_rowmajor.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.3d_blocked_rowmajor.js
new file mode 100644
index 000000000000..78a862ea7f8a
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.3d_blocked_rowmajor.js
@@ -0,0 +1,146 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2026 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 bench = require( '@stdlib/bench' );
+var isnan = require( '@stdlib/math/base/assert/is-nan' );
+var pow = require( '@stdlib/math/base/special/pow' );
+var floor = require( '@stdlib/math/base/special/floor' );
+var cbrt = require( '@stdlib/math/base/special/cbrt' );
+var filledarray = require( '@stdlib/array/filled' );
+var shape2strides = require( '@stdlib/ndarray/base/shape2strides' );
+var format = require( '@stdlib/string/format' );
+var pkg = require( './../package.json' ).name;
+var assignScalar = require( './../lib/3d_blocked.js' );
+
+
+// VARIABLES //
+
+var types = [ 'float64' ];
+var order = 'row-major';
+
+
+// FUNCTIONS //
+
+/**
+* Creates a benchmark function.
+*
+* @private
+* @param {PositiveInteger} len - ndarray length
+* @param {NonNegativeIntegerArray} shape - ndarray shape
+* @param {string} xtype - input ndarray data type
+* @param {string} ytype - output ndarray data type
+* @returns {Function} benchmark function
+*/
+function createBenchmark( len, shape, xtype, ytype ) {
+	var x;
+	var y;
+
+	y = filledarray( 0.0, len, ytype );
+	x = {
+		'dtype': xtype,
+		'data': [ 10.0 ],
+		'shape': [],
+		'strides': [ 0 ],
+		'offset': 0,
+		'order': order
+	};
+	y = {
+		'dtype': ytype,
+		'data': y,
+		'shape': shape,
+		'strides': shape2strides( shape, order ),
+		'offset': 0,
+		'order': order
+	};
+	return benchmark;
+
+	/**
+	* Benchmark function.
+	*
+	* @private
+	* @param {Benchmark} b - benchmark instance
+	*/
+	function benchmark( b ) {
+		var i;
+
+		b.tic();
+		for ( i = 0; i < b.iterations; i++ ) {
+			assignScalar( x, y );
+			if ( isnan( y.data[ i%len ] ) ) {
+				b.fail( 'should not return NaN' );
+			}
+		}
+		b.toc();
+		if ( isnan( y.data[ i%len ] ) ) {
+			b.fail( 'should not return NaN' );
+		}
+		b.pass( 'benchmark finished' );
+		b.end();
+	}
+}
+
+
+// MAIN //
+
+/**
+* Main execution sequence.
+*
+* @private
+*/
+function main() {
+	var len;
+	var min;
+	var max;
+	var sh;
+	var t1;
+	var t2;
+	var f;
+	var i;
+	var j;
+
+	min = 1; // 10^min
+	max = 6; // 10^max
+
+	for ( j = 0; j < types.length; j++ ) {
+		t1 = types[ j ];
+		t2 = types[ j ];
+		for ( i = min; i <= max; i++ ) {
+			len = pow( 10, i );
+
+			sh = [ len/2, 2, 1 ];
+			f = createBenchmark( len, sh, t1, t2 );
+			bench( format( '%s::blocked:ndims=%d,len=%d,shape=[%s],xorder=%s,yorder=%s,xtype=%s,ytype=%s', pkg, sh.length, len, sh.join( ',' ), order, order, t1, t2 ), f );
+
+			sh = [ 1, 2, len/2 ];
+			f = createBenchmark( len, sh, t1, t2 );
+			bench( format( '%s::blocked:ndims=%d,len=%d,shape=[%s],xorder=%s,yorder=%s,xtype=%s,ytype=%s', pkg, sh.length, len, sh.join( ',' ), order, order, t1, t2 ), f );
+
+			len = floor( cbrt( len ) );
+			sh = [ len, len, len ];
+			len *= len * len;
+			f = createBenchmark( len, sh, t1, t2 );
+			bench( format( '%s::blocked:ndims=%d,len=%d,shape=[%s],xorder=%s,yorder=%s,xtype=%s,ytype=%s', pkg, sh.length, len, sh.join( ',' ), order, order, t1, t2 ), f );
+		}
+	}
+}
+
+main();
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.3d_columnmajor.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.3d_columnmajor.js
new file mode 100644
index 000000000000..da98b577d065
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.3d_columnmajor.js
@@ -0,0 +1,146 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2026 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 bench = require( '@stdlib/bench' );
+var isnan = require( '@stdlib/math/base/assert/is-nan' );
+var pow = require( '@stdlib/math/base/special/pow' );
+var floor = require( '@stdlib/math/base/special/floor' );
+var cbrt = require( '@stdlib/math/base/special/cbrt' );
+var filledarray = require( '@stdlib/array/filled' );
+var shape2strides = require( '@stdlib/ndarray/base/shape2strides' );
+var format = require( '@stdlib/string/format' );
+var pkg = require( './../package.json' ).name;
+var assignScalar = require( './../lib/3d.js' );
+
+
+// VARIABLES //
+
+var types = [ 'float64' ];
+var order = 'column-major';
+
+
+// FUNCTIONS //
+
+/**
+* Creates a benchmark function.
+*
+* @private
+* @param {PositiveInteger} len - ndarray length
+* @param {NonNegativeIntegerArray} shape - ndarray shape
+* @param {string} xtype - input ndarray data type
+* @param {string} ytype - output ndarray data type
+* @returns {Function} benchmark function
+*/
+function createBenchmark( len, shape, xtype, ytype ) {
+	var x;
+	var y;
+
+	y = filledarray( 0.0, len, ytype );
+	x = {
+		'dtype': xtype,
+		'data': [ 10.0 ],
+		'shape': [],
+		'strides': [ 0 ],
+		'offset': 0,
+		'order': order
+	};
+	y = {
+		'dtype': ytype,
+		'data': y,
+		'shape': shape,
+		'strides': shape2strides( shape, order ),
+		'offset': 0,
+		'order': order
+	};
+	return benchmark;
+
+	/**
+	* Benchmark function.
+	*
+	* @private
+	* @param {Benchmark} b - benchmark instance
+	*/
+	function benchmark( b ) {
+		var i;
+
+		b.tic();
+		for ( i = 0; i < b.iterations; i++ ) {
+			assignScalar( x, y );
+			if ( isnan( y.data[ i%len ] ) ) {
+				b.fail( 'should not return NaN' );
+			}
+		}
+		b.toc();
+		if ( isnan( y.data[ i%len ] ) ) {
+			b.fail( 'should not return NaN' );
+		}
+		b.pass( 'benchmark finished' );
+		b.end();
+	}
+}
+
+
+// MAIN //
+
+/**
+* Main execution sequence.
+*
+* @private
+*/
+function main() {
+	var len;
+	var min;
+	var max;
+	var sh;
+	var t1;
+	var t2;
+	var f;
+	var i;
+	var j;
+
+	min = 1; // 10^min
+	max = 6; // 10^max
+
+	for ( j = 0; j < types.length; j++ ) {
+		t1 = types[ j ];
+		t2 = types[ j ];
+		for ( i = min; i <= max; i++ ) {
+			len = pow( 10, i );
+
+			sh = [ len/2, 2, 1 ];
+			f = createBenchmark( len, sh, t1, t2 );
+			bench( format( '%s:ndims=%d,len=%d,shape=[%s],xorder=%s,yorder=%s,xtype=%s,ytype=%s', pkg, sh.length, len, sh.join( ',' ), order, order, t1, t2 ), f );
+
+			sh = [ 1, 2, len/2 ];
+			f = createBenchmark( len, sh, t1, t2 );
+			bench( format( '%s:ndims=%d,len=%d,shape=[%s],xorder=%s,yorder=%s,xtype=%s,ytype=%s', pkg, sh.length, len, sh.join( ',' ), order, order, t1, t2 ), f );
+
+			len = floor( cbrt( len ) );
+			sh = [ len, len, len ];
+			len *= len * len;
+			f = createBenchmark( len, sh, t1, t2 );
+			bench( format( '%s:ndims=%d,len=%d,shape=[%s],xorder=%s,yorder=%s,xtype=%s,ytype=%s', pkg, sh.length, len, sh.join( ',' ), order, order, t1, t2 ), f );
+		}
+	}
+}
+
+main();
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.3d_rowmajor.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.3d_rowmajor.js
new file mode 100644
index 000000000000..5d3895066ade
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.3d_rowmajor.js
@@ -0,0 +1,146 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2026 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 bench = require( '@stdlib/bench' );
+var isnan = require( '@stdlib/math/base/assert/is-nan' );
+var pow = require( '@stdlib/math/base/special/pow' );
+var floor = require( '@stdlib/math/base/special/floor' );
+var cbrt = require( '@stdlib/math/base/special/cbrt' );
+var filledarray = require( '@stdlib/array/filled' );
+var shape2strides = require( '@stdlib/ndarray/base/shape2strides' );
+var format = require( '@stdlib/string/format' );
+var pkg = require( './../package.json' ).name;
+var assignScalar = require( './../lib/3d.js' );
+
+
+// VARIABLES //
+
+var types = [ 'float64' ];
+var order = 'row-major';
+
+
+// FUNCTIONS //
+
+/**
+* Creates a benchmark function.
+*
+* @private
+* @param {PositiveInteger} len - ndarray length
+* @param {NonNegativeIntegerArray} shape - ndarray shape
+* @param {string} xtype - input ndarray data type
+* @param {string} ytype - output ndarray data type
+* @returns {Function} benchmark function
+*/
+function createBenchmark( len, shape, xtype, ytype ) {
+	var x;
+	var y;
+
+	y = filledarray( 0.0, len, ytype );
+	x = {
+		'dtype': xtype,
+		'data': [ 10.0 ],
+		'shape': [],
+		'strides': [ 0 ],
+		'offset': 0,
+		'order': order
+	};
+	y = {
+		'dtype': ytype,
+		'data': y,
+		'shape': shape,
+		'strides': shape2strides( shape, order ),
+		'offset': 0,
+		'order': order
+	};
+	return benchmark;
+
+	/**
+	* Benchmark function.
+	*
+	* @private
+	* @param {Benchmark} b - benchmark instance
+	*/
+	function benchmark( b ) {
+		var i;
+
+		b.tic();
+		for ( i = 0; i < b.iterations; i++ ) {
+			assignScalar( x, y );
+			if ( isnan( y.data[ i%len ] ) ) {
+				b.fail( 'should not return NaN' );
+			}
+		}
+		b.toc();
+		if ( isnan( y.data[ i%len ] ) ) {
+			b.fail( 'should not return NaN' );
+		}
+		b.pass( 'benchmark finished' );
+		b.end();
+	}
+}
+
+
+// MAIN //
+
+/**
+* Main execution sequence.
+*
+* @private
+*/
+function main() {
+	var len;
+	var min;
+	var max;
+	var sh;
+	var t1;
+	var t2;
+	var f;
+	var i;
+	var j;
+
+	min = 1; // 10^min
+	max = 6; // 10^max
+
+	for ( j = 0; j < types.length; j++ ) {
+		t1 = types[ j ];
+		t2 = types[ j ];
+		for ( i = min; i <= max; i++ ) {
+			len = pow( 10, i );
+
+			sh = [ len/2, 2, 1 ];
+			f = createBenchmark( len, sh, t1, t2 );
+			bench( format( '%s:ndims=%d,len=%d,shape=[%s],xorder=%s,yorder=%s,xtype=%s,ytype=%s', pkg, sh.length, len, sh.join( ',' ), order, order, t1, t2 ), f );
+
+			sh = [ 1, 2, len/2 ];
+			f = createBenchmark( len, sh, t1, t2 );
+			bench( format( '%s:ndims=%d,len=%d,shape=[%s],xorder=%s,yorder=%s,xtype=%s,ytype=%s', pkg, sh.length, len, sh.join( ',' ), order, order, t1, t2 ), f );
+
+			len = floor( cbrt( len ) );
+			sh = [ len, len, len ];
+			len *= len * len;
+			f = createBenchmark( len, sh, t1, t2 );
+			bench( format( '%s:ndims=%d,len=%d,shape=[%s],xorder=%s,yorder=%s,xtype=%s,ytype=%s', pkg, sh.length, len, sh.join( ',' ), order, order, t1, t2 ), f );
+		}
+	}
+}
+
+main();
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.4d_blocked_columnmajor.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.4d_blocked_columnmajor.js
new file mode 100644
index 000000000000..2c451d6c3c29
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.4d_blocked_columnmajor.js
@@ -0,0 +1,145 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2026 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 bench = require( '@stdlib/bench' );
+var isnan = require( '@stdlib/math/base/assert/is-nan' );
+var pow = require( '@stdlib/math/base/special/pow' );
+var floor = require( '@stdlib/math/base/special/floor' );
+var filledarray = require( '@stdlib/array/filled' );
+var shape2strides = require( '@stdlib/ndarray/base/shape2strides' );
+var format = require( '@stdlib/string/format' );
+var pkg = require( './../package.json' ).name;
+var assignScalar = require( './../lib/4d_blocked.js' );
+
+
+// VARIABLES //
+
+var types = [ 'float64' ];
+var order = 'column-major';
+
+
+// FUNCTIONS //
+
+/**
+* Creates a benchmark function.
+*
+* @private
+* @param {PositiveInteger} len - ndarray length
+* @param {NonNegativeIntegerArray} shape - ndarray shape
+* @param {string} xtype - input ndarray data type
+* @param {string} ytype - output ndarray data type
+* @returns {Function} benchmark function
+*/
+function createBenchmark( len, shape, xtype, ytype ) {
+	var x;
+	var y;
+
+	y = filledarray( 0.0, len, ytype );
+	x = {
+		'dtype': xtype,
+		'data': [ 10.0 ],
+		'shape': [],
+		'strides': [ 0 ],
+		'offset': 0,
+		'order': order
+	};
+	y = {
+		'dtype': ytype,
+		'data': y,
+		'shape': shape,
+		'strides': shape2strides( shape, order ),
+		'offset': 0,
+		'order': order
+	};
+	return benchmark;
+
+	/**
+	* Benchmark function.
+	*
+	* @private
+	* @param {Benchmark} b - benchmark instance
+	*/
+	function benchmark( b ) {
+		var i;
+
+		b.tic();
+		for ( i = 0; i < b.iterations; i++ ) {
+			assignScalar( x, y );
+			if ( isnan( y.data[ i%len ] ) ) {
+				b.fail( 'should not return NaN' );
+			}
+		}
+		b.toc();
+		if ( isnan( y.data[ i%len ] ) ) {
+			b.fail( 'should not return NaN' );
+		}
+		b.pass( 'benchmark finished' );
+		b.end();
+	}
+}
+
+
+// MAIN //
+
+/**
+* Main execution sequence.
+*
+* @private
+*/
+function main() {
+	var len;
+	var min;
+	var max;
+	var sh;
+	var t1;
+	var t2;
+	var f;
+	var i;
+	var j;
+
+	min = 1; // 10^min
+	max = 6; // 10^max
+
+	for ( j = 0; j < types.length; j++ ) {
+		t1 = types[ j ];
+		t2 = types[ j ];
+		for ( i = min; i <= max; i++ ) {
+			len = pow( 10, i );
+
+			sh = [ len/2, 2, 1, 1 ];
+			f = createBenchmark( len, sh, t1, t2 );
+			bench( format( '%s::blocked:ndims=%d,len=%d,shape=[%s],xorder=%s,yorder=%s,xtype=%s,ytype=%s', pkg, sh.length, len, sh.join( ',' ), order, order, t1, t2 ), f );
+
+			sh = [ 1, 1, 2, len/2 ];
+			f = createBenchmark( len, sh, t1, t2 );
+			bench( format( '%s::blocked:ndims=%d,len=%d,shape=[%s],xorder=%s,yorder=%s,xtype=%s,ytype=%s', pkg, sh.length, len, sh.join( ',' ), order, order, t1, t2 ), f );
+
+			len = floor( pow( len, 1.0/4.0 ) );
+			sh = [ len, len, len, len ];
+			len *= len * len * len;
+			f = createBenchmark( len, sh, t1, t2 );
+			bench( format( '%s::blocked:ndims=%d,len=%d,shape=[%s],xorder=%s,yorder=%s,xtype=%s,ytype=%s', pkg, sh.length, len, sh.join( ',' ), order, order, t1, t2 ), f );
+		}
+	}
+}
+
+main();
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.4d_blocked_rowmajor.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.4d_blocked_rowmajor.js
new file mode 100644
index 000000000000..7d9e1414f931
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.4d_blocked_rowmajor.js
@@ -0,0 +1,145 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2026 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 bench = require( '@stdlib/bench' );
+var isnan = require( '@stdlib/math/base/assert/is-nan' );
+var pow = require( '@stdlib/math/base/special/pow' );
+var floor = require( '@stdlib/math/base/special/floor' );
+var filledarray = require( '@stdlib/array/filled' );
+var shape2strides = require( '@stdlib/ndarray/base/shape2strides' );
+var format = require( '@stdlib/string/format' );
+var pkg = require( './../package.json' ).name;
+var assignScalar = require( './../lib/4d_blocked.js' );
+
+
+// VARIABLES //
+
+var types = [ 'float64' ];
+var order = 'row-major';
+
+
+// FUNCTIONS //
+
+/**
+* Creates a benchmark function.
+*
+* @private
+* @param {PositiveInteger} len - ndarray length
+* @param {NonNegativeIntegerArray} shape - ndarray shape
+* @param {string} xtype - input ndarray data type
+* @param {string} ytype - output ndarray data type
+* @returns {Function} benchmark function
+*/
+function createBenchmark( len, shape, xtype, ytype ) {
+	var x;
+	var y;
+
+	y = filledarray( 0.0, len, ytype );
+	x = {
+		'dtype': xtype,
+		'data': [ 10.0 ],
+		'shape': [],
+		'strides': [ 0 ],
+		'offset': 0,
+		'order': order
+	};
+	y = {
+		'dtype': ytype,
+		'data': y,
+		'shape': shape,
+		'strides': shape2strides( shape, order ),
+		'offset': 0,
+		'order': order
+	};
+	return benchmark;
+
+	/**
+	* Benchmark function.
+	*
+	* @private
+	* @param {Benchmark} b - benchmark instance
+	*/
+	function benchmark( b ) {
+		var i;
+
+		b.tic();
+		for ( i = 0; i < b.iterations; i++ ) {
+			assignScalar( x, y );
+			if ( isnan( y.data[ i%len ] ) ) {
+				b.fail( 'should not return NaN' );
+			}
+		}
+		b.toc();
+		if ( isnan( y.data[ i%len ] ) ) {
+			b.fail( 'should not return NaN' );
+		}
+		b.pass( 'benchmark finished' );
+		b.end();
+	}
+}
+
+
+// MAIN //
+
+/**
+* Main execution sequence.
+*
+* @private
+*/
+function main() {
+	var len;
+	var min;
+	var max;
+	var sh;
+	var t1;
+	var t2;
+	var f;
+	var i;
+	var j;
+
+	min = 1; // 10^min
+	max = 6; // 10^max
+
+	for ( j = 0; j < types.length; j++ ) {
+		t1 = types[ j ];
+		t2 = types[ j ];
+		for ( i = min; i <= max; i++ ) {
+			len = pow( 10, i );
+
+			sh = [ len/2, 2, 1, 1 ];
+			f = createBenchmark( len, sh, t1, t2 );
+			bench( format( '%s::blocked:ndims=%d,len=%d,shape=[%s],xorder=%s,yorder=%s,xtype=%s,ytype=%s', pkg, sh.length, len, sh.join( ',' ), order, order, t1, t2 ), f );
+
+			sh = [ 1, 1, 2, len/2 ];
+			f = createBenchmark( len, sh, t1, t2 );
+			bench( format( '%s::blocked:ndims=%d,len=%d,shape=[%s],xorder=%s,yorder=%s,xtype=%s,ytype=%s', pkg, sh.length, len, sh.join( ',' ), order, order, t1, t2 ), f );
+
+			len = floor( pow( len, 1.0/4.0 ) );
+			sh = [ len, len, len, len ];
+			len *= len * len * len;
+			f = createBenchmark( len, sh, t1, t2 );
+			bench( format( '%s::blocked:ndims=%d,len=%d,shape=[%s],xorder=%s,yorder=%s,xtype=%s,ytype=%s', pkg, sh.length, len, sh.join( ',' ), order, order, t1, t2 ), f );
+		}
+	}
+}
+
+main();
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.4d_columnmajor.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.4d_columnmajor.js
new file mode 100644
index 000000000000..a20b9237d5ab
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.4d_columnmajor.js
@@ -0,0 +1,145 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2026 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 bench = require( '@stdlib/bench' );
+var isnan = require( '@stdlib/math/base/assert/is-nan' );
+var pow = require( '@stdlib/math/base/special/pow' );
+var floor = require( '@stdlib/math/base/special/floor' );
+var filledarray = require( '@stdlib/array/filled' );
+var shape2strides = require( '@stdlib/ndarray/base/shape2strides' );
+var format = require( '@stdlib/string/format' );
+var pkg = require( './../package.json' ).name;
+var assignScalar = require( './../lib/4d.js' );
+
+
+// VARIABLES //
+
+var types = [ 'float64' ];
+var order = 'column-major';
+
+
+// FUNCTIONS //
+
+/**
+* Creates a benchmark function.
+*
+* @private
+* @param {PositiveInteger} len - ndarray length
+* @param {NonNegativeIntegerArray} shape - ndarray shape
+* @param {string} xtype - input ndarray data type
+* @param {string} ytype - output ndarray data type
+* @returns {Function} benchmark function
+*/
+function createBenchmark( len, shape, xtype, ytype ) {
+	var x;
+	var y;
+
+	y = filledarray( 0.0, len, ytype );
+	x = {
+		'dtype': xtype,
+		'data': [ 10.0 ],
+		'shape': [],
+		'strides': [ 0 ],
+		'offset': 0,
+		'order': order
+	};
+	y = {
+		'dtype': ytype,
+		'data': y,
+		'shape': shape,
+		'strides': shape2strides( shape, order ),
+		'offset': 0,
+		'order': order
+	};
+	return benchmark;
+
+	/**
+	* Benchmark function.
+	*
+	* @private
+	* @param {Benchmark} b - benchmark instance
+	*/
+	function benchmark( b ) {
+		var i;
+
+		b.tic();
+		for ( i = 0; i < b.iterations; i++ ) {
+			assignScalar( x, y );
+			if ( isnan( y.data[ i%len ] ) ) {
+				b.fail( 'should not return NaN' );
+			}
+		}
+		b.toc();
+		if ( isnan( y.data[ i%len ] ) ) {
+			b.fail( 'should not return NaN' );
+		}
+		b.pass( 'benchmark finished' );
+		b.end();
+	}
+}
+
+
+// MAIN //
+
+/**
+* Main execution sequence.
+*
+* @private
+*/
+function main() {
+	var len;
+	var min;
+	var max;
+	var sh;
+	var t1;
+	var t2;
+	var f;
+	var i;
+	var j;
+
+	min = 1; // 10^min
+	max = 6; // 10^max
+
+	for ( j = 0; j < types.length; j++ ) {
+		t1 = types[ j ];
+		t2 = types[ j ];
+		for ( i = min; i <= max; i++ ) {
+			len = pow( 10, i );
+
+			sh = [ len/2, 2, 1, 1 ];
+			f = createBenchmark( len, sh, t1, t2 );
+			bench( format( '%s:ndims=%d,len=%d,shape=[%s],xorder=%s,yorder=%s,xtype=%s,ytype=%s', pkg, sh.length, len, sh.join( ',' ), order, order, t1, t2 ), f );
+
+			sh = [ 1, 1, 2, len/2 ];
+			f = createBenchmark( len, sh, t1, t2 );
+			bench( format( '%s:ndims=%d,len=%d,shape=[%s],xorder=%s,yorder=%s,xtype=%s,ytype=%s', pkg, sh.length, len, sh.join( ',' ), order, order, t1, t2 ), f );
+
+			len = floor( pow( len, 1.0/4.0 ) );
+			sh = [ len, len, len, len ];
+			len *= len * len * len;
+			f = createBenchmark( len, sh, t1, t2 );
+			bench( format( '%s:ndims=%d,len=%d,shape=[%s],xorder=%s,yorder=%s,xtype=%s,ytype=%s', pkg, sh.length, len, sh.join( ',' ), order, order, t1, t2 ), f );
+		}
+	}
+}
+
+main();
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.4d_rowmajor.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.4d_rowmajor.js
new file mode 100644
index 000000000000..139186e2fb8d
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.4d_rowmajor.js
@@ -0,0 +1,145 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2026 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 bench = require( '@stdlib/bench' );
+var isnan = require( '@stdlib/math/base/assert/is-nan' );
+var pow = require( '@stdlib/math/base/special/pow' );
+var floor = require( '@stdlib/math/base/special/floor' );
+var filledarray = require( '@stdlib/array/filled' );
+var shape2strides = require( '@stdlib/ndarray/base/shape2strides' );
+var format = require( '@stdlib/string/format' );
+var pkg = require( './../package.json' ).name;
+var assignScalar = require( './../lib/4d.js' );
+
+
+// VARIABLES //
+
+var types = [ 'float64' ];
+var order = 'row-major';
+
+
+// FUNCTIONS //
+
+/**
+* Creates a benchmark function.
+*
+* @private
+* @param {PositiveInteger} len - ndarray length
+* @param {NonNegativeIntegerArray} shape - ndarray shape
+* @param {string} xtype - input ndarray data type
+* @param {string} ytype - output ndarray data type
+* @returns {Function} benchmark function
+*/
+function createBenchmark( len, shape, xtype, ytype ) {
+	var x;
+	var y;
+
+	y = filledarray( 0.0, len, ytype );
+	x = {
+		'dtype': xtype,
+		'data': [ 10.0 ],
+		'shape': [],
+		'strides': [ 0 ],
+		'offset': 0,
+		'order': order
+	};
+	y = {
+		'dtype': ytype,
+		'data': y,
+		'shape': shape,
+		'strides': shape2strides( shape, order ),
+		'offset': 0,
+		'order': order
+	};
+	return benchmark;
+
+	/**
+	* Benchmark function.
+	*
+	* @private
+	* @param {Benchmark} b - benchmark instance
+	*/
+	function benchmark( b ) {
+		var i;
+
+		b.tic();
+		for ( i = 0; i < b.iterations; i++ ) {
+			assignScalar( x, y );
+			if ( isnan( y.data[ i%len ] ) ) {
+				b.fail( 'should not return NaN' );
+			}
+		}
+		b.toc();
+		if ( isnan( y.data[ i%len ] ) ) {
+			b.fail( 'should not return NaN' );
+		}
+		b.pass( 'benchmark finished' );
+		b.end();
+	}
+}
+
+
+// MAIN //
+
+/**
+* Main execution sequence.
+*
+* @private
+*/
+function main() {
+	var len;
+	var min;
+	var max;
+	var sh;
+	var t1;
+	var t2;
+	var f;
+	var i;
+	var j;
+
+	min = 1; // 10^min
+	max = 6; // 10^max
+
+	for ( j = 0; j < types.length; j++ ) {
+		t1 = types[ j ];
+		t2 = types[ j ];
+		for ( i = min; i <= max; i++ ) {
+			len = pow( 10, i );
+
+			sh = [ len/2, 2, 1, 1 ];
+			f = createBenchmark( len, sh, t1, t2 );
+			bench( format( '%s:ndims=%d,len=%d,shape=[%s],xorder=%s,yorder=%s,xtype=%s,ytype=%s', pkg, sh.length, len, sh.join( ',' ), order, order, t1, t2 ), f );
+
+			sh = [ 1, 1, 2, len/2 ];
+			f = createBenchmark( len, sh, t1, t2 );
+			bench( format( '%s:ndims=%d,len=%d,shape=[%s],xorder=%s,yorder=%s,xtype=%s,ytype=%s', pkg, sh.length, len, sh.join( ',' ), order, order, t1, t2 ), f );
+
+			len = floor( pow( len, 1.0/4.0 ) );
+			sh = [ len, len, len, len ];
+			len *= len * len * len;
+			f = createBenchmark( len, sh, t1, t2 );
+			bench( format( '%s:ndims=%d,len=%d,shape=[%s],xorder=%s,yorder=%s,xtype=%s,ytype=%s', pkg, sh.length, len, sh.join( ',' ), order, order, t1, t2 ), f );
+		}
+	}
+}
+
+main();
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.5d_blocked_columnmajor.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.5d_blocked_columnmajor.js
new file mode 100644
index 000000000000..e2bc2b67d417
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.5d_blocked_columnmajor.js
@@ -0,0 +1,145 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2026 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 bench = require( '@stdlib/bench' );
+var isnan = require( '@stdlib/math/base/assert/is-nan' );
+var pow = require( '@stdlib/math/base/special/pow' );
+var floor = require( '@stdlib/math/base/special/floor' );
+var filledarray = require( '@stdlib/array/filled' );
+var shape2strides = require( '@stdlib/ndarray/base/shape2strides' );
+var format = require( '@stdlib/string/format' );
+var pkg = require( './../package.json' ).name;
+var assignScalar = require( './../lib/5d_blocked.js' );
+
+
+// VARIABLES //
+
+var types = [ 'float64' ];
+var order = 'column-major';
+
+
+// FUNCTIONS //
+
+/**
+* Creates a benchmark function.
+*
+* @private
+* @param {PositiveInteger} len - ndarray length
+* @param {NonNegativeIntegerArray} shape - ndarray shape
+* @param {string} xtype - input ndarray data type
+* @param {string} ytype - output ndarray data type
+* @returns {Function} benchmark function
+*/
+function createBenchmark( len, shape, xtype, ytype ) {
+	var x;
+	var y;
+
+	y = filledarray( 0.0, len, ytype );
+	x = {
+		'dtype': xtype,
+		'data': [ 10.0 ],
+		'shape': [],
+		'strides': [ 0 ],
+		'offset': 0,
+		'order': order
+	};
+	y = {
+		'dtype': ytype,
+		'data': y,
+		'shape': shape,
+		'strides': shape2strides( shape, order ),
+		'offset': 0,
+		'order': order
+	};
+	return benchmark;
+
+	/**
+	* Benchmark function.
+	*
+	* @private
+	* @param {Benchmark} b - benchmark instance
+	*/
+	function benchmark( b ) {
+		var i;
+
+		b.tic();
+		for ( i = 0; i < b.iterations; i++ ) {
+			assignScalar( x, y );
+			if ( isnan( y.data[ i%len ] ) ) {
+				b.fail( 'should not return NaN' );
+			}
+		}
+		b.toc();
+		if ( isnan( y.data[ i%len ] ) ) {
+			b.fail( 'should not return NaN' );
+		}
+		b.pass( 'benchmark finished' );
+		b.end();
+	}
+}
+
+
+// MAIN //
+
+/**
+* Main execution sequence.
+*
+* @private
+*/
+function main() {
+	var len;
+	var min;
+	var max;
+	var sh;
+	var t1;
+	var t2;
+	var f;
+	var i;
+	var j;
+
+	min = 1; // 10^min
+	max = 6; // 10^max
+
+	for ( j = 0; j < types.length; j++ ) {
+		t1 = types[ j ];
+		t2 = types[ j ];
+		for ( i = min; i <= max; i++ ) {
+			len = pow( 10, i );
+
+			sh = [ len/2, 2, 1, 1, 1 ];
+			f = createBenchmark( len, sh, t1, t2 );
+			bench( format( '%s::blocked:ndims=%d,len=%d,shape=[%s],xorder=%s,yorder=%s,xtype=%s,ytype=%s', pkg, sh.length, len, sh.join( ',' ), order, order, t1, t2 ), f );
+
+			sh = [ 1, 1, 1, 2, len/2 ];
+			f = createBenchmark( len, sh, t1, t2 );
+			bench( format( '%s::blocked:ndims=%d,len=%d,shape=[%s],xorder=%s,yorder=%s,xtype=%s,ytype=%s', pkg, sh.length, len, sh.join( ',' ), order, order, t1, t2 ), f );
+
+			len = floor( pow( len, 1.0/5.0 ) );
+			sh = [ len, len, len, len, len ];
+			len *= pow( len, 4 );
+			f = createBenchmark( len, sh, t1, t2 );
+			bench( format( '%s::blocked:ndims=%d,len=%d,shape=[%s],xorder=%s,yorder=%s,xtype=%s,ytype=%s', pkg, sh.length, len, sh.join( ',' ), order, order, t1, t2 ), f );
+		}
+	}
+}
+
+main();
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.5d_blocked_rowmajor.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.5d_blocked_rowmajor.js
new file mode 100644
index 000000000000..245bd03b5ab7
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.5d_blocked_rowmajor.js
@@ -0,0 +1,145 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2026 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 bench = require( '@stdlib/bench' );
+var isnan = require( '@stdlib/math/base/assert/is-nan' );
+var pow = require( '@stdlib/math/base/special/pow' );
+var floor = require( '@stdlib/math/base/special/floor' );
+var filledarray = require( '@stdlib/array/filled' );
+var shape2strides = require( '@stdlib/ndarray/base/shape2strides' );
+var format = require( '@stdlib/string/format' );
+var pkg = require( './../package.json' ).name;
+var assignScalar = require( './../lib/5d_blocked.js' );
+
+
+// VARIABLES //
+
+var types = [ 'float64' ];
+var order = 'row-major';
+
+
+// FUNCTIONS //
+
+/**
+* Creates a benchmark function.
+*
+* @private
+* @param {PositiveInteger} len - ndarray length
+* @param {NonNegativeIntegerArray} shape - ndarray shape
+* @param {string} xtype - input ndarray data type
+* @param {string} ytype - output ndarray data type
+* @returns {Function} benchmark function
+*/
+function createBenchmark( len, shape, xtype, ytype ) {
+	var x;
+	var y;
+
+	y = filledarray( 0.0, len, ytype );
+	x = {
+		'dtype': xtype,
+		'data': [ 10.0 ],
+		'shape': [],
+		'strides': [ 0 ],
+		'offset': 0,
+		'order': order
+	};
+	y = {
+		'dtype': ytype,
+		'data': y,
+		'shape': shape,
+		'strides': shape2strides( shape, order ),
+		'offset': 0,
+		'order': order
+	};
+	return benchmark;
+
+	/**
+	* Benchmark function.
+	*
+	* @private
+	* @param {Benchmark} b - benchmark instance
+	*/
+	function benchmark( b ) {
+		var i;
+
+		b.tic();
+		for ( i = 0; i < b.iterations; i++ ) {
+			assignScalar( x, y );
+			if ( isnan( y.data[ i%len ] ) ) {
+				b.fail( 'should not return NaN' );
+			}
+		}
+		b.toc();
+		if ( isnan( y.data[ i%len ] ) ) {
+			b.fail( 'should not return NaN' );
+		}
+		b.pass( 'benchmark finished' );
+		b.end();
+	}
+}
+
+
+// MAIN //
+
+/**
+* Main execution sequence.
+*
+* @private
+*/
+function main() {
+	var len;
+	var min;
+	var max;
+	var sh;
+	var t1;
+	var t2;
+	var f;
+	var i;
+	var j;
+
+	min = 1; // 10^min
+	max = 6; // 10^max
+
+	for ( j = 0; j < types.length; j++ ) {
+		t1 = types[ j ];
+		t2 = types[ j ];
+		for ( i = min; i <= max; i++ ) {
+			len = pow( 10, i );
+
+			sh = [ len/2, 2, 1, 1, 1 ];
+			f = createBenchmark( len, sh, t1, t2 );
+			bench( format( '%s::blocked:ndims=%d,len=%d,shape=[%s],xorder=%s,yorder=%s,xtype=%s,ytype=%s', pkg, sh.length, len, sh.join( ',' ), order, order, t1, t2 ), f );
+
+			sh = [ 1, 1, 1, 2, len/2 ];
+			f = createBenchmark( len, sh, t1, t2 );
+			bench( format( '%s::blocked:ndims=%d,len=%d,shape=[%s],xorder=%s,yorder=%s,xtype=%s,ytype=%s', pkg, sh.length, len, sh.join( ',' ), order, order, t1, t2 ), f );
+
+			len = floor( pow( len, 1.0/5.0 ) );
+			sh = [ len, len, len, len, len ];
+			len *= pow( len, 4 );
+			f = createBenchmark( len, sh, t1, t2 );
+			bench( format( '%s::blocked:ndims=%d,len=%d,shape=[%s],xorder=%s,yorder=%s,xtype=%s,ytype=%s', pkg, sh.length, len, sh.join( ',' ), order, order, t1, t2 ), f );
+		}
+	}
+}
+
+main();
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.5d_columnmajor.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.5d_columnmajor.js
new file mode 100644
index 000000000000..72eb50dc31eb
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.5d_columnmajor.js
@@ -0,0 +1,145 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2026 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 bench = require( '@stdlib/bench' );
+var isnan = require( '@stdlib/math/base/assert/is-nan' );
+var pow = require( '@stdlib/math/base/special/pow' );
+var floor = require( '@stdlib/math/base/special/floor' );
+var filledarray = require( '@stdlib/array/filled' );
+var shape2strides = require( '@stdlib/ndarray/base/shape2strides' );
+var format = require( '@stdlib/string/format' );
+var pkg = require( './../package.json' ).name;
+var assignScalar = require( './../lib/5d.js' );
+
+
+// VARIABLES //
+
+var types = [ 'float64' ];
+var order = 'column-major';
+
+
+// FUNCTIONS //
+
+/**
+* Creates a benchmark function.
+*
+* @private
+* @param {PositiveInteger} len - ndarray length
+* @param {NonNegativeIntegerArray} shape - ndarray shape
+* @param {string} xtype - input ndarray data type
+* @param {string} ytype - output ndarray data type
+* @returns {Function} benchmark function
+*/
+function createBenchmark( len, shape, xtype, ytype ) {
+	var x;
+	var y;
+
+	y = filledarray( 0.0, len, ytype );
+	x = {
+		'dtype': xtype,
+		'data': [ 10.0 ],
+		'shape': [],
+		'strides': [ 0 ],
+		'offset': 0,
+		'order': order
+	};
+	y = {
+		'dtype': ytype,
+		'data': y,
+		'shape': shape,
+		'strides': shape2strides( shape, order ),
+		'offset': 0,
+		'order': order
+	};
+	return benchmark;
+
+	/**
+	* Benchmark function.
+	*
+	* @private
+	* @param {Benchmark} b - benchmark instance
+	*/
+	function benchmark( b ) {
+		var i;
+
+		b.tic();
+		for ( i = 0; i < b.iterations; i++ ) {
+			assignScalar( x, y );
+			if ( isnan( y.data[ i%len ] ) ) {
+				b.fail( 'should not return NaN' );
+			}
+		}
+		b.toc();
+		if ( isnan( y.data[ i%len ] ) ) {
+			b.fail( 'should not return NaN' );
+		}
+		b.pass( 'benchmark finished' );
+		b.end();
+	}
+}
+
+
+// MAIN //
+
+/**
+* Main execution sequence.
+*
+* @private
+*/
+function main() {
+	var len;
+	var min;
+	var max;
+	var sh;
+	var t1;
+	var t2;
+	var f;
+	var i;
+	var j;
+
+	min = 1; // 10^min
+	max = 6; // 10^max
+
+	for ( j = 0; j < types.length; j++ ) {
+		t1 = types[ j ];
+		t2 = types[ j ];
+		for ( i = min; i <= max; i++ ) {
+			len = pow( 10, i );
+
+			sh = [ len/2, 2, 1, 1, 1 ];
+			f = createBenchmark( len, sh, t1, t2 );
+			bench( format( '%s:ndims=%d,len=%d,shape=[%s],xorder=%s,yorder=%s,xtype=%s,ytype=%s', pkg, sh.length, len, sh.join( ',' ), order, order, t1, t2 ), f );
+
+			sh = [ 1, 1, 1, 2, len/2 ];
+			f = createBenchmark( len, sh, t1, t2 );
+			bench( format( '%s:ndims=%d,len=%d,shape=[%s],xorder=%s,yorder=%s,xtype=%s,ytype=%s', pkg, sh.length, len, sh.join( ',' ), order, order, t1, t2 ), f );
+
+			len = floor( pow( len, 1.0/5.0 ) );
+			sh = [ len, len, len, len, len ];
+			len *= pow( len, 4 );
+			f = createBenchmark( len, sh, t1, t2 );
+			bench( format( '%s:ndims=%d,len=%d,shape=[%s],xorder=%s,yorder=%s,xtype=%s,ytype=%s', pkg, sh.length, len, sh.join( ',' ), order, order, t1, t2 ), f );
+		}
+	}
+}
+
+main();
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.5d_rowmajor.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.5d_rowmajor.js
new file mode 100644
index 000000000000..e9930c2b6c91
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.5d_rowmajor.js
@@ -0,0 +1,145 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2026 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 bench = require( '@stdlib/bench' );
+var isnan = require( '@stdlib/math/base/assert/is-nan' );
+var pow = require( '@stdlib/math/base/special/pow' );
+var floor = require( '@stdlib/math/base/special/floor' );
+var filledarray = require( '@stdlib/array/filled' );
+var shape2strides = require( '@stdlib/ndarray/base/shape2strides' );
+var format = require( '@stdlib/string/format' );
+var pkg = require( './../package.json' ).name;
+var assignScalar = require( './../lib/5d.js' );
+
+
+// VARIABLES //
+
+var types = [ 'float64' ];
+var order = 'row-major';
+
+
+// FUNCTIONS //
+
+/**
+* Creates a benchmark function.
+*
+* @private
+* @param {PositiveInteger} len - ndarray length
+* @param {NonNegativeIntegerArray} shape - ndarray shape
+* @param {string} xtype - input ndarray data type
+* @param {string} ytype - output ndarray data type
+* @returns {Function} benchmark function
+*/
+function createBenchmark( len, shape, xtype, ytype ) {
+	var x;
+	var y;
+
+	y = filledarray( 0.0, len, ytype );
+	x = {
+		'dtype': xtype,
+		'data': [ 10.0 ],
+		'shape': [],
+		'strides': [ 0 ],
+		'offset': 0,
+		'order': order
+	};
+	y = {
+		'dtype': ytype,
+		'data': y,
+		'shape': shape,
+		'strides': shape2strides( shape, order ),
+		'offset': 0,
+		'order': order
+	};
+	return benchmark;
+
+	/**
+	* Benchmark function.
+	*
+	* @private
+	* @param {Benchmark} b - benchmark instance
+	*/
+	function benchmark( b ) {
+		var i;
+
+		b.tic();
+		for ( i = 0; i < b.iterations; i++ ) {
+			assignScalar( x, y );
+			if ( isnan( y.data[ i%len ] ) ) {
+				b.fail( 'should not return NaN' );
+			}
+		}
+		b.toc();
+		if ( isnan( y.data[ i%len ] ) ) {
+			b.fail( 'should not return NaN' );
+		}
+		b.pass( 'benchmark finished' );
+		b.end();
+	}
+}
+
+
+// MAIN //
+
+/**
+* Main execution sequence.
+*
+* @private
+*/
+function main() {
+	var len;
+	var min;
+	var max;
+	var sh;
+	var t1;
+	var t2;
+	var f;
+	var i;
+	var j;
+
+	min = 1; // 10^min
+	max = 6; // 10^max
+
+	for ( j = 0; j < types.length; j++ ) {
+		t1 = types[ j ];
+		t2 = types[ j ];
+		for ( i = min; i <= max; i++ ) {
+			len = pow( 10, i );
+
+			sh = [ len/2, 2, 1, 1, 1 ];
+			f = createBenchmark( len, sh, t1, t2 );
+			bench( format( '%s:ndims=%d,len=%d,shape=[%s],xorder=%s,yorder=%s,xtype=%s,ytype=%s', pkg, sh.length, len, sh.join( ',' ), order, order, t1, t2 ), f );
+
+			sh = [ 1, 1, 1, 2, len/2 ];
+			f = createBenchmark( len, sh, t1, t2 );
+			bench( format( '%s:ndims=%d,len=%d,shape=[%s],xorder=%s,yorder=%s,xtype=%s,ytype=%s', pkg, sh.length, len, sh.join( ',' ), order, order, t1, t2 ), f );
+
+			len = floor( pow( len, 1.0/5.0 ) );
+			sh = [ len, len, len, len, len ];
+			len *= pow( len, 4 );
+			f = createBenchmark( len, sh, t1, t2 );
+			bench( format( '%s:ndims=%d,len=%d,shape=[%s],xorder=%s,yorder=%s,xtype=%s,ytype=%s', pkg, sh.length, len, sh.join( ',' ), order, order, t1, t2 ), f );
+		}
+	}
+}
+
+main();
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.6d_blocked_columnmajor.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.6d_blocked_columnmajor.js
new file mode 100644
index 000000000000..fe15cb8f2344
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.6d_blocked_columnmajor.js
@@ -0,0 +1,145 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2026 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 bench = require( '@stdlib/bench' );
+var isnan = require( '@stdlib/math/base/assert/is-nan' );
+var pow = require( '@stdlib/math/base/special/pow' );
+var floor = require( '@stdlib/math/base/special/floor' );
+var filledarray = require( '@stdlib/array/filled' );
+var shape2strides = require( '@stdlib/ndarray/base/shape2strides' );
+var format = require( '@stdlib/string/format' );
+var pkg = require( './../package.json' ).name;
+var assignScalar = require( './../lib/6d_blocked.js' );
+
+
+// VARIABLES //
+
+var types = [ 'float64' ];
+var order = 'column-major';
+
+
+// FUNCTIONS //
+
+/**
+* Creates a benchmark function.
+*
+* @private
+* @param {PositiveInteger} len - ndarray length
+* @param {NonNegativeIntegerArray} shape - ndarray shape
+* @param {string} xtype - input ndarray data type
+* @param {string} ytype - output ndarray data type
+* @returns {Function} benchmark function
+*/
+function createBenchmark( len, shape, xtype, ytype ) {
+	var x;
+	var y;
+
+	y = filledarray( 0.0, len, ytype );
+	x = {
+		'dtype': xtype,
+		'data': [ 10.0 ],
+		'shape': [],
+		'strides': [ 0 ],
+		'offset': 0,
+		'order': order
+	};
+	y = {
+		'dtype': ytype,
+		'data': y,
+		'shape': shape,
+		'strides': shape2strides( shape, order ),
+		'offset': 0,
+		'order': order
+	};
+	return benchmark;
+
+	/**
+	* Benchmark function.
+	*
+	* @private
+	* @param {Benchmark} b - benchmark instance
+	*/
+	function benchmark( b ) {
+		var i;
+
+		b.tic();
+		for ( i = 0; i < b.iterations; i++ ) {
+			assignScalar( x, y );
+			if ( isnan( y.data[ i%len ] ) ) {
+				b.fail( 'should not return NaN' );
+			}
+		}
+		b.toc();
+		if ( isnan( y.data[ i%len ] ) ) {
+			b.fail( 'should not return NaN' );
+		}
+		b.pass( 'benchmark finished' );
+		b.end();
+	}
+}
+
+
+// MAIN //
+
+/**
+* Main execution sequence.
+*
+* @private
+*/
+function main() {
+	var len;
+	var min;
+	var max;
+	var sh;
+	var t1;
+	var t2;
+	var f;
+	var i;
+	var j;
+
+	min = 1; // 10^min
+	max = 6; // 10^max
+
+	for ( j = 0; j < types.length; j++ ) {
+		t1 = types[ j ];
+		t2 = types[ j ];
+		for ( i = min; i <= max; i++ ) {
+			len = pow( 10, i );
+
+			sh = [ len/2, 2, 1, 1, 1, 1 ];
+			f = createBenchmark( len, sh, t1, t2 );
+			bench( format( '%s::blocked:ndims=%d,len=%d,shape=[%s],xorder=%s,yorder=%s,xtype=%s,ytype=%s', pkg, sh.length, len, sh.join( ',' ), order, order, t1, t2 ), f );
+
+			sh = [ 1, 1, 1, 1, 2, len/2 ];
+			f = createBenchmark( len, sh, t1, t2 );
+			bench( format( '%s::blocked:ndims=%d,len=%d,shape=[%s],xorder=%s,yorder=%s,xtype=%s,ytype=%s', pkg, sh.length, len, sh.join( ',' ), order, order, t1, t2 ), f );
+
+			len = floor( pow( len, 1.0/6.0 ) );
+			sh = [ len, len, len, len, len, len ];
+			len *= pow( len, 5 );
+			f = createBenchmark( len, sh, t1, t2 );
+			bench( format( '%s::blocked:ndims=%d,len=%d,shape=[%s],xorder=%s,yorder=%s,xtype=%s,ytype=%s', pkg, sh.length, len, sh.join( ',' ), order, order, t1, t2 ), f );
+		}
+	}
+}
+
+main();
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.6d_blocked_rowmajor.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.6d_blocked_rowmajor.js
new file mode 100644
index 000000000000..b9634cdda249
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.6d_blocked_rowmajor.js
@@ -0,0 +1,145 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2026 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 bench = require( '@stdlib/bench' );
+var isnan = require( '@stdlib/math/base/assert/is-nan' );
+var pow = require( '@stdlib/math/base/special/pow' );
+var floor = require( '@stdlib/math/base/special/floor' );
+var filledarray = require( '@stdlib/array/filled' );
+var shape2strides = require( '@stdlib/ndarray/base/shape2strides' );
+var format = require( '@stdlib/string/format' );
+var pkg = require( './../package.json' ).name;
+var assignScalar = require( './../lib/6d_blocked.js' );
+
+
+// VARIABLES //
+
+var types = [ 'float64' ];
+var order = 'row-major';
+
+
+// FUNCTIONS //
+
+/**
+* Creates a benchmark function.
+*
+* @private
+* @param {PositiveInteger} len - ndarray length
+* @param {NonNegativeIntegerArray} shape - ndarray shape
+* @param {string} xtype - input ndarray data type
+* @param {string} ytype - output ndarray data type
+* @returns {Function} benchmark function
+*/
+function createBenchmark( len, shape, xtype, ytype ) {
+	var x;
+	var y;
+
+	y = filledarray( 0.0, len, ytype );
+	x = {
+		'dtype': xtype,
+		'data': [ 10.0 ],
+		'shape': [],
+		'strides': [ 0 ],
+		'offset': 0,
+		'order': order
+	};
+	y = {
+		'dtype': ytype,
+		'data': y,
+		'shape': shape,
+		'strides': shape2strides( shape, order ),
+		'offset': 0,
+		'order': order
+	};
+	return benchmark;
+
+	/**
+	* Benchmark function.
+	*
+	* @private
+	* @param {Benchmark} b - benchmark instance
+	*/
+	function benchmark( b ) {
+		var i;
+
+		b.tic();
+		for ( i = 0; i < b.iterations; i++ ) {
+			assignScalar( x, y );
+			if ( isnan( y.data[ i%len ] ) ) {
+				b.fail( 'should not return NaN' );
+			}
+		}
+		b.toc();
+		if ( isnan( y.data[ i%len ] ) ) {
+			b.fail( 'should not return NaN' );
+		}
+		b.pass( 'benchmark finished' );
+		b.end();
+	}
+}
+
+
+// MAIN //
+
+/**
+* Main execution sequence.
+*
+* @private
+*/
+function main() {
+	var len;
+	var min;
+	var max;
+	var sh;
+	var t1;
+	var t2;
+	var f;
+	var i;
+	var j;
+
+	min = 1; // 10^min
+	max = 6; // 10^max
+
+	for ( j = 0; j < types.length; j++ ) {
+		t1 = types[ j ];
+		t2 = types[ j ];
+		for ( i = min; i <= max; i++ ) {
+			len = pow( 10, i );
+
+			sh = [ len/2, 2, 1, 1, 1, 1 ];
+			f = createBenchmark( len, sh, t1, t2 );
+			bench( format( '%s::blocked:ndims=%d,len=%d,shape=[%s],xorder=%s,yorder=%s,xtype=%s,ytype=%s', pkg, sh.length, len, sh.join( ',' ), order, order, t1, t2 ), f );
+
+			sh = [ 1, 1, 1, 1, 2, len/2 ];
+			f = createBenchmark( len, sh, t1, t2 );
+			bench( format( '%s::blocked:ndims=%d,len=%d,shape=[%s],xorder=%s,yorder=%s,xtype=%s,ytype=%s', pkg, sh.length, len, sh.join( ',' ), order, order, t1, t2 ), f );
+
+			len = floor( pow( len, 1.0/6.0 ) );
+			sh = [ len, len, len, len, len, len ];
+			len *= pow( len, 5 );
+			f = createBenchmark( len, sh, t1, t2 );
+			bench( format( '%s::blocked:ndims=%d,len=%d,shape=[%s],xorder=%s,yorder=%s,xtype=%s,ytype=%s', pkg, sh.length, len, sh.join( ',' ), order, order, t1, t2 ), f );
+		}
+	}
+}
+
+main();
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.6d_columnmajor.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.6d_columnmajor.js
new file mode 100644
index 000000000000..d033f6e17738
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.6d_columnmajor.js
@@ -0,0 +1,145 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2026 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 bench = require( '@stdlib/bench' );
+var isnan = require( '@stdlib/math/base/assert/is-nan' );
+var pow = require( '@stdlib/math/base/special/pow' );
+var floor = require( '@stdlib/math/base/special/floor' );
+var filledarray = require( '@stdlib/array/filled' );
+var shape2strides = require( '@stdlib/ndarray/base/shape2strides' );
+var format = require( '@stdlib/string/format' );
+var pkg = require( './../package.json' ).name;
+var assignScalar = require( './../lib/6d.js' );
+
+
+// VARIABLES //
+
+var types = [ 'float64' ];
+var order = 'column-major';
+
+
+// FUNCTIONS //
+
+/**
+* Creates a benchmark function.
+*
+* @private
+* @param {PositiveInteger} len - ndarray length
+* @param {NonNegativeIntegerArray} shape - ndarray shape
+* @param {string} xtype - input ndarray data type
+* @param {string} ytype - output ndarray data type
+* @returns {Function} benchmark function
+*/
+function createBenchmark( len, shape, xtype, ytype ) {
+	var x;
+	var y;
+
+	y = filledarray( 0.0, len, ytype );
+	x = {
+		'dtype': xtype,
+		'data': [ 10.0 ],
+		'shape': [],
+		'strides': [ 0 ],
+		'offset': 0,
+		'order': order
+	};
+	y = {
+		'dtype': ytype,
+		'data': y,
+		'shape': shape,
+		'strides': shape2strides( shape, order ),
+		'offset': 0,
+		'order': order
+	};
+	return benchmark;
+
+	/**
+	* Benchmark function.
+	*
+	* @private
+	* @param {Benchmark} b - benchmark instance
+	*/
+	function benchmark( b ) {
+		var i;
+
+		b.tic();
+		for ( i = 0; i < b.iterations; i++ ) {
+			assignScalar( x, y );
+			if ( isnan( y.data[ i%len ] ) ) {
+				b.fail( 'should not return NaN' );
+			}
+		}
+		b.toc();
+		if ( isnan( y.data[ i%len ] ) ) {
+			b.fail( 'should not return NaN' );
+		}
+		b.pass( 'benchmark finished' );
+		b.end();
+	}
+}
+
+
+// MAIN //
+
+/**
+* Main execution sequence.
+*
+* @private
+*/
+function main() {
+	var len;
+	var min;
+	var max;
+	var sh;
+	var t1;
+	var t2;
+	var f;
+	var i;
+	var j;
+
+	min = 1; // 10^min
+	max = 6; // 10^max
+
+	for ( j = 0; j < types.length; j++ ) {
+		t1 = types[ j ];
+		t2 = types[ j ];
+		for ( i = min; i <= max; i++ ) {
+			len = pow( 10, i );
+
+			sh = [ len/2, 2, 1, 1, 1, 1 ];
+			f = createBenchmark( len, sh, t1, t2 );
+			bench( format( '%s:ndims=%d,len=%d,shape=[%s],xorder=%s,yorder=%s,xtype=%s,ytype=%s', pkg, sh.length, len, sh.join( ',' ), order, order, t1, t2 ), f );
+
+			sh = [ 1, 1, 1, 1, 2, len/2 ];
+			f = createBenchmark( len, sh, t1, t2 );
+			bench( format( '%s:ndims=%d,len=%d,shape=[%s],xorder=%s,yorder=%s,xtype=%s,ytype=%s', pkg, sh.length, len, sh.join( ',' ), order, order, t1, t2 ), f );
+
+			len = floor( pow( len, 1.0/6.0 ) );
+			sh = [ len, len, len, len, len, len ];
+			len *= pow( len, 5 );
+			f = createBenchmark( len, sh, t1, t2 );
+			bench( format( '%s:ndims=%d,len=%d,shape=[%s],xorder=%s,yorder=%s,xtype=%s,ytype=%s', pkg, sh.length, len, sh.join( ',' ), order, order, t1, t2 ), f );
+		}
+	}
+}
+
+main();
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.6d_rowmajor.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.6d_rowmajor.js
new file mode 100644
index 000000000000..75089b10fb9b
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.6d_rowmajor.js
@@ -0,0 +1,145 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2026 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 bench = require( '@stdlib/bench' );
+var isnan = require( '@stdlib/math/base/assert/is-nan' );
+var pow = require( '@stdlib/math/base/special/pow' );
+var floor = require( '@stdlib/math/base/special/floor' );
+var filledarray = require( '@stdlib/array/filled' );
+var shape2strides = require( '@stdlib/ndarray/base/shape2strides' );
+var format = require( '@stdlib/string/format' );
+var pkg = require( './../package.json' ).name;
+var assignScalar = require( './../lib/6d.js' );
+
+
+// VARIABLES //
+
+var types = [ 'float64' ];
+var order = 'row-major';
+
+
+// FUNCTIONS //
+
+/**
+* Creates a benchmark function.
+*
+* @private
+* @param {PositiveInteger} len - ndarray length
+* @param {NonNegativeIntegerArray} shape - ndarray shape
+* @param {string} xtype - input ndarray data type
+* @param {string} ytype - output ndarray data type
+* @returns {Function} benchmark function
+*/
+function createBenchmark( len, shape, xtype, ytype ) {
+	var x;
+	var y;
+
+	y = filledarray( 0.0, len, ytype );
+	x = {
+		'dtype': xtype,
+		'data': [ 10.0 ],
+		'shape': [],
+		'strides': [ 0 ],
+		'offset': 0,
+		'order': order
+	};
+	y = {
+		'dtype': ytype,
+		'data': y,
+		'shape': shape,
+		'strides': shape2strides( shape, order ),
+		'offset': 0,
+		'order': order
+	};
+	return benchmark;
+
+	/**
+	* Benchmark function.
+	*
+	* @private
+	* @param {Benchmark} b - benchmark instance
+	*/
+	function benchmark( b ) {
+		var i;
+
+		b.tic();
+		for ( i = 0; i < b.iterations; i++ ) {
+			assignScalar( x, y );
+			if ( isnan( y.data[ i%len ] ) ) {
+				b.fail( 'should not return NaN' );
+			}
+		}
+		b.toc();
+		if ( isnan( y.data[ i%len ] ) ) {
+			b.fail( 'should not return NaN' );
+		}
+		b.pass( 'benchmark finished' );
+		b.end();
+	}
+}
+
+
+// MAIN //
+
+/**
+* Main execution sequence.
+*
+* @private
+*/
+function main() {
+	var len;
+	var min;
+	var max;
+	var sh;
+	var t1;
+	var t2;
+	var f;
+	var i;
+	var j;
+
+	min = 1; // 10^min
+	max = 6; // 10^max
+
+	for ( j = 0; j < types.length; j++ ) {
+		t1 = types[ j ];
+		t2 = types[ j ];
+		for ( i = min; i <= max; i++ ) {
+			len = pow( 10, i );
+
+			sh = [ len/2, 2, 1, 1, 1, 1 ];
+			f = createBenchmark( len, sh, t1, t2 );
+			bench( format( '%s:ndims=%d,len=%d,shape=[%s],xorder=%s,yorder=%s,xtype=%s,ytype=%s', pkg, sh.length, len, sh.join( ',' ), order, order, t1, t2 ), f );
+
+			sh = [ 1, 1, 1, 1, 2, len/2 ];
+			f = createBenchmark( len, sh, t1, t2 );
+			bench( format( '%s:ndims=%d,len=%d,shape=[%s],xorder=%s,yorder=%s,xtype=%s,ytype=%s', pkg, sh.length, len, sh.join( ',' ), order, order, t1, t2 ), f );
+
+			len = floor( pow( len, 1.0/6.0 ) );
+			sh = [ len, len, len, len, len, len ];
+			len *= pow( len, 5 );
+			f = createBenchmark( len, sh, t1, t2 );
+			bench( format( '%s:ndims=%d,len=%d,shape=[%s],xorder=%s,yorder=%s,xtype=%s,ytype=%s', pkg, sh.length, len, sh.join( ',' ), order, order, t1, t2 ), f );
+		}
+	}
+}
+
+main();
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.7d_blocked_columnmajor.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.7d_blocked_columnmajor.js
new file mode 100644
index 000000000000..6698447da16c
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.7d_blocked_columnmajor.js
@@ -0,0 +1,145 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2026 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 bench = require( '@stdlib/bench' );
+var isnan = require( '@stdlib/math/base/assert/is-nan' );
+var pow = require( '@stdlib/math/base/special/pow' );
+var floor = require( '@stdlib/math/base/special/floor' );
+var filledarray = require( '@stdlib/array/filled' );
+var shape2strides = require( '@stdlib/ndarray/base/shape2strides' );
+var format = require( '@stdlib/string/format' );
+var pkg = require( './../package.json' ).name;
+var assignScalar = require( './../lib/7d_blocked.js' );
+
+
+// VARIABLES //
+
+var types = [ 'float64' ];
+var order = 'column-major';
+
+
+// FUNCTIONS //
+
+/**
+* Creates a benchmark function.
+*
+* @private
+* @param {PositiveInteger} len - ndarray length
+* @param {NonNegativeIntegerArray} shape - ndarray shape
+* @param {string} xtype - input ndarray data type
+* @param {string} ytype - output ndarray data type
+* @returns {Function} benchmark function
+*/
+function createBenchmark( len, shape, xtype, ytype ) {
+	var x;
+	var y;
+
+	y = filledarray( 0.0, len, ytype );
+	x = {
+		'dtype': xtype,
+		'data': [ 10.0 ],
+		'shape': [],
+		'strides': [ 0 ],
+		'offset': 0,
+		'order': order
+	};
+	y = {
+		'dtype': ytype,
+		'data': y,
+		'shape': shape,
+		'strides': shape2strides( shape, order ),
+		'offset': 0,
+		'order': order
+	};
+	return benchmark;
+
+	/**
+	* Benchmark function.
+	*
+	* @private
+	* @param {Benchmark} b - benchmark instance
+	*/
+	function benchmark( b ) {
+		var i;
+
+		b.tic();
+		for ( i = 0; i < b.iterations; i++ ) {
+			assignScalar( x, y );
+			if ( isnan( y.data[ i%len ] ) ) {
+				b.fail( 'should not return NaN' );
+			}
+		}
+		b.toc();
+		if ( isnan( y.data[ i%len ] ) ) {
+			b.fail( 'should not return NaN' );
+		}
+		b.pass( 'benchmark finished' );
+		b.end();
+	}
+}
+
+
+// MAIN //
+
+/**
+* Main execution sequence.
+*
+* @private
+*/
+function main() {
+	var len;
+	var min;
+	var max;
+	var sh;
+	var t1;
+	var t2;
+	var f;
+	var i;
+	var j;
+
+	min = 1; // 10^min
+	max = 6; // 10^max
+
+	for ( j = 0; j < types.length; j++ ) {
+		t1 = types[ j ];
+		t2 = types[ j ];
+		for ( i = min; i <= max; i++ ) {
+			len = pow( 10, i );
+
+			sh = [ len/2, 2, 1, 1, 1, 1, 1 ];
+			f = createBenchmark( len, sh, t1, t2 );
+			bench( format( '%s::blocked:ndims=%d,len=%d,shape=[%s],xorder=%s,yorder=%s,xtype=%s,ytype=%s', pkg, sh.length, len, sh.join( ',' ), order, order, t1, t2 ), f );
+
+			sh = [ 1, 1, 1, 1, 1, 2, len/2 ];
+			f = createBenchmark( len, sh, t1, t2 );
+			bench( format( '%s::blocked:ndims=%d,len=%d,shape=[%s],xorder=%s,yorder=%s,xtype=%s,ytype=%s', pkg, sh.length, len, sh.join( ',' ), order, order, t1, t2 ), f );
+
+			len = floor( pow( len, 1.0/7.0 ) );
+			sh = [ len, len, len, len, len, len, len ];
+			len *= pow( len, 6 );
+			f = createBenchmark( len, sh, t1, t2 );
+			bench( format( '%s::blocked:ndims=%d,len=%d,shape=[%s],xorder=%s,yorder=%s,xtype=%s,ytype=%s', pkg, sh.length, len, sh.join( ',' ), order, order, t1, t2 ), f );
+		}
+	}
+}
+
+main();
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.7d_blocked_rowmajor.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.7d_blocked_rowmajor.js
new file mode 100644
index 000000000000..43b1b64a9ac8
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.7d_blocked_rowmajor.js
@@ -0,0 +1,145 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2026 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 bench = require( '@stdlib/bench' );
+var isnan = require( '@stdlib/math/base/assert/is-nan' );
+var pow = require( '@stdlib/math/base/special/pow' );
+var floor = require( '@stdlib/math/base/special/floor' );
+var filledarray = require( '@stdlib/array/filled' );
+var shape2strides = require( '@stdlib/ndarray/base/shape2strides' );
+var format = require( '@stdlib/string/format' );
+var pkg = require( './../package.json' ).name;
+var assignScalar = require( './../lib/7d_blocked.js' );
+
+
+// VARIABLES //
+
+var types = [ 'float64' ];
+var order = 'row-major';
+
+
+// FUNCTIONS //
+
+/**
+* Creates a benchmark function.
+*
+* @private
+* @param {PositiveInteger} len - ndarray length
+* @param {NonNegativeIntegerArray} shape - ndarray shape
+* @param {string} xtype - input ndarray data type
+* @param {string} ytype - output ndarray data type
+* @returns {Function} benchmark function
+*/
+function createBenchmark( len, shape, xtype, ytype ) {
+	var x;
+	var y;
+
+	y = filledarray( 0.0, len, ytype );
+	x = {
+		'dtype': xtype,
+		'data': [ 10.0 ],
+		'shape': [],
+		'strides': [ 0 ],
+		'offset': 0,
+		'order': order
+	};
+	y = {
+		'dtype': ytype,
+		'data': y,
+		'shape': shape,
+		'strides': shape2strides( shape, order ),
+		'offset': 0,
+		'order': order
+	};
+	return benchmark;
+
+	/**
+	* Benchmark function.
+	*
+	* @private
+	* @param {Benchmark} b - benchmark instance
+	*/
+	function benchmark( b ) {
+		var i;
+
+		b.tic();
+		for ( i = 0; i < b.iterations; i++ ) {
+			assignScalar( x, y );
+			if ( isnan( y.data[ i%len ] ) ) {
+				b.fail( 'should not return NaN' );
+			}
+		}
+		b.toc();
+		if ( isnan( y.data[ i%len ] ) ) {
+			b.fail( 'should not return NaN' );
+		}
+		b.pass( 'benchmark finished' );
+		b.end();
+	}
+}
+
+
+// MAIN //
+
+/**
+* Main execution sequence.
+*
+* @private
+*/
+function main() {
+	var len;
+	var min;
+	var max;
+	var sh;
+	var t1;
+	var t2;
+	var f;
+	var i;
+	var j;
+
+	min = 1; // 10^min
+	max = 6; // 10^max
+
+	for ( j = 0; j < types.length; j++ ) {
+		t1 = types[ j ];
+		t2 = types[ j ];
+		for ( i = min; i <= max; i++ ) {
+			len = pow( 10, i );
+
+			sh = [ len/2, 2, 1, 1, 1, 1, 1 ];
+			f = createBenchmark( len, sh, t1, t2 );
+			bench( format( '%s::blocked:ndims=%d,len=%d,shape=[%s],xorder=%s,yorder=%s,xtype=%s,ytype=%s', pkg, sh.length, len, sh.join( ',' ), order, order, t1, t2 ), f );
+
+			sh = [ 1, 1, 1, 1, 1, 2, len/2 ];
+			f = createBenchmark( len, sh, t1, t2 );
+			bench( format( '%s::blocked:ndims=%d,len=%d,shape=[%s],xorder=%s,yorder=%s,xtype=%s,ytype=%s', pkg, sh.length, len, sh.join( ',' ), order, order, t1, t2 ), f );
+
+			len = floor( pow( len, 1.0/7.0 ) );
+			sh = [ len, len, len, len, len, len, len ];
+			len *= pow( len, 6 );
+			f = createBenchmark( len, sh, t1, t2 );
+			bench( format( '%s::blocked:ndims=%d,len=%d,shape=[%s],xorder=%s,yorder=%s,xtype=%s,ytype=%s', pkg, sh.length, len, sh.join( ',' ), order, order, t1, t2 ), f );
+		}
+	}
+}
+
+main();
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.7d_columnmajor.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.7d_columnmajor.js
new file mode 100644
index 000000000000..f8f436a00a43
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.7d_columnmajor.js
@@ -0,0 +1,145 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2026 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 bench = require( '@stdlib/bench' );
+var isnan = require( '@stdlib/math/base/assert/is-nan' );
+var pow = require( '@stdlib/math/base/special/pow' );
+var floor = require( '@stdlib/math/base/special/floor' );
+var filledarray = require( '@stdlib/array/filled' );
+var shape2strides = require( '@stdlib/ndarray/base/shape2strides' );
+var format = require( '@stdlib/string/format' );
+var pkg = require( './../package.json' ).name;
+var assignScalar = require( './../lib/7d.js' );
+
+
+// VARIABLES //
+
+var types = [ 'float64' ];
+var order = 'column-major';
+
+
+// FUNCTIONS //
+
+/**
+* Creates a benchmark function.
+*
+* @private
+* @param {PositiveInteger} len - ndarray length
+* @param {NonNegativeIntegerArray} shape - ndarray shape
+* @param {string} xtype - input ndarray data type
+* @param {string} ytype - output ndarray data type
+* @returns {Function} benchmark function
+*/
+function createBenchmark( len, shape, xtype, ytype ) {
+	var x;
+	var y;
+
+	y = filledarray( 0.0, len, ytype );
+	x = {
+		'dtype': xtype,
+		'data': [ 10.0 ],
+		'shape': [],
+		'strides': [ 0 ],
+		'offset': 0,
+		'order': order
+	};
+	y = {
+		'dtype': ytype,
+		'data': y,
+		'shape': shape,
+		'strides': shape2strides( shape, order ),
+		'offset': 0,
+		'order': order
+	};
+	return benchmark;
+
+	/**
+	* Benchmark function.
+	*
+	* @private
+	* @param {Benchmark} b - benchmark instance
+	*/
+	function benchmark( b ) {
+		var i;
+
+		b.tic();
+		for ( i = 0; i < b.iterations; i++ ) {
+			assignScalar( x, y );
+			if ( isnan( y.data[ i%len ] ) ) {
+				b.fail( 'should not return NaN' );
+			}
+		}
+		b.toc();
+		if ( isnan( y.data[ i%len ] ) ) {
+			b.fail( 'should not return NaN' );
+		}
+		b.pass( 'benchmark finished' );
+		b.end();
+	}
+}
+
+
+// MAIN //
+
+/**
+* Main execution sequence.
+*
+* @private
+*/
+function main() {
+	var len;
+	var min;
+	var max;
+	var sh;
+	var t1;
+	var t2;
+	var f;
+	var i;
+	var j;
+
+	min = 1; // 10^min
+	max = 6; // 10^max
+
+	for ( j = 0; j < types.length; j++ ) {
+		t1 = types[ j ];
+		t2 = types[ j ];
+		for ( i = min; i <= max; i++ ) {
+			len = pow( 10, i );
+
+			sh = [ len/2, 2, 1, 1, 1, 1, 1 ];
+			f = createBenchmark( len, sh, t1, t2 );
+			bench( format( '%s:ndims=%d,len=%d,shape=[%s],xorder=%s,yorder=%s,xtype=%s,ytype=%s', pkg, sh.length, len, sh.join( ',' ), order, order, t1, t2 ), f );
+
+			sh = [ 1, 1, 1, 1, 1, 2, len/2 ];
+			f = createBenchmark( len, sh, t1, t2 );
+			bench( format( '%s:ndims=%d,len=%d,shape=[%s],xorder=%s,yorder=%s,xtype=%s,ytype=%s', pkg, sh.length, len, sh.join( ',' ), order, order, t1, t2 ), f );
+
+			len = floor( pow( len, 1.0/7.0 ) );
+			sh = [ len, len, len, len, len, len, len ];
+			len *= pow( len, 6 );
+			f = createBenchmark( len, sh, t1, t2 );
+			bench( format( '%s:ndims=%d,len=%d,shape=[%s],xorder=%s,yorder=%s,xtype=%s,ytype=%s', pkg, sh.length, len, sh.join( ',' ), order, order, t1, t2 ), f );
+		}
+	}
+}
+
+main();
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.7d_rowmajor.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.7d_rowmajor.js
new file mode 100644
index 000000000000..c0d030f03862
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.7d_rowmajor.js
@@ -0,0 +1,145 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2026 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 bench = require( '@stdlib/bench' );
+var isnan = require( '@stdlib/math/base/assert/is-nan' );
+var pow = require( '@stdlib/math/base/special/pow' );
+var floor = require( '@stdlib/math/base/special/floor' );
+var filledarray = require( '@stdlib/array/filled' );
+var shape2strides = require( '@stdlib/ndarray/base/shape2strides' );
+var format = require( '@stdlib/string/format' );
+var pkg = require( './../package.json' ).name;
+var assignScalar = require( './../lib/7d.js' );
+
+
+// VARIABLES //
+
+var types = [ 'float64' ];
+var order = 'row-major';
+
+
+// FUNCTIONS //
+
+/**
+* Creates a benchmark function.
+*
+* @private
+* @param {PositiveInteger} len - ndarray length
+* @param {NonNegativeIntegerArray} shape - ndarray shape
+* @param {string} xtype - input ndarray data type
+* @param {string} ytype - output ndarray data type
+* @returns {Function} benchmark function
+*/
+function createBenchmark( len, shape, xtype, ytype ) {
+	var x;
+	var y;
+
+	y = filledarray( 0.0, len, ytype );
+	x = {
+		'dtype': xtype,
+		'data': [ 10.0 ],
+		'shape': [],
+		'strides': [ 0 ],
+		'offset': 0,
+		'order': order
+	};
+	y = {
+		'dtype': ytype,
+		'data': y,
+		'shape': shape,
+		'strides': shape2strides( shape, order ),
+		'offset': 0,
+		'order': order
+	};
+	return benchmark;
+
+	/**
+	* Benchmark function.
+	*
+	* @private
+	* @param {Benchmark} b - benchmark instance
+	*/
+	function benchmark( b ) {
+		var i;
+
+		b.tic();
+		for ( i = 0; i < b.iterations; i++ ) {
+			assignScalar( x, y );
+			if ( isnan( y.data[ i%len ] ) ) {
+				b.fail( 'should not return NaN' );
+			}
+		}
+		b.toc();
+		if ( isnan( y.data[ i%len ] ) ) {
+			b.fail( 'should not return NaN' );
+		}
+		b.pass( 'benchmark finished' );
+		b.end();
+	}
+}
+
+
+// MAIN //
+
+/**
+* Main execution sequence.
+*
+* @private
+*/
+function main() {
+	var len;
+	var min;
+	var max;
+	var sh;
+	var t1;
+	var t2;
+	var f;
+	var i;
+	var j;
+
+	min = 1; // 10^min
+	max = 6; // 10^max
+
+	for ( j = 0; j < types.length; j++ ) {
+		t1 = types[ j ];
+		t2 = types[ j ];
+		for ( i = min; i <= max; i++ ) {
+			len = pow( 10, i );
+
+			sh = [ len/2, 2, 1, 1, 1, 1, 1 ];
+			f = createBenchmark( len, sh, t1, t2 );
+			bench( format( '%s:ndims=%d,len=%d,shape=[%s],xorder=%s,yorder=%s,xtype=%s,ytype=%s', pkg, sh.length, len, sh.join( ',' ), order, order, t1, t2 ), f );
+
+			sh = [ 1, 1, 1, 1, 1, 2, len/2 ];
+			f = createBenchmark( len, sh, t1, t2 );
+			bench( format( '%s:ndims=%d,len=%d,shape=[%s],xorder=%s,yorder=%s,xtype=%s,ytype=%s', pkg, sh.length, len, sh.join( ',' ), order, order, t1, t2 ), f );
+
+			len = floor( pow( len, 1.0/7.0 ) );
+			sh = [ len, len, len, len, len, len, len ];
+			len *= pow( len, 6 );
+			f = createBenchmark( len, sh, t1, t2 );
+			bench( format( '%s:ndims=%d,len=%d,shape=[%s],xorder=%s,yorder=%s,xtype=%s,ytype=%s', pkg, sh.length, len, sh.join( ',' ), order, order, t1, t2 ), f );
+		}
+	}
+}
+
+main();
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.8d_blocked_columnmajor.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.8d_blocked_columnmajor.js
new file mode 100644
index 000000000000..23b43dda0d1b
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.8d_blocked_columnmajor.js
@@ -0,0 +1,145 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2026 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 bench = require( '@stdlib/bench' );
+var isnan = require( '@stdlib/math/base/assert/is-nan' );
+var pow = require( '@stdlib/math/base/special/pow' );
+var floor = require( '@stdlib/math/base/special/floor' );
+var filledarray = require( '@stdlib/array/filled' );
+var shape2strides = require( '@stdlib/ndarray/base/shape2strides' );
+var format = require( '@stdlib/string/format' );
+var pkg = require( './../package.json' ).name;
+var assignScalar = require( './../lib/8d_blocked.js' );
+
+
+// VARIABLES //
+
+var types = [ 'float64' ];
+var order = 'column-major';
+
+
+// FUNCTIONS //
+
+/**
+* Creates a benchmark function.
+*
+* @private
+* @param {PositiveInteger} len - ndarray length
+* @param {NonNegativeIntegerArray} shape - ndarray shape
+* @param {string} xtype - input ndarray data type
+* @param {string} ytype - output ndarray data type
+* @returns {Function} benchmark function
+*/
+function createBenchmark( len, shape, xtype, ytype ) {
+	var x;
+	var y;
+
+	y = filledarray( 0.0, len, ytype );
+	x = {
+		'dtype': xtype,
+		'data': [ 10.0 ],
+		'shape': [],
+		'strides': [ 0 ],
+		'offset': 0,
+		'order': order
+	};
+	y = {
+		'dtype': ytype,
+		'data': y,
+		'shape': shape,
+		'strides': shape2strides( shape, order ),
+		'offset': 0,
+		'order': order
+	};
+	return benchmark;
+
+	/**
+	* Benchmark function.
+	*
+	* @private
+	* @param {Benchmark} b - benchmark instance
+	*/
+	function benchmark( b ) {
+		var i;
+
+		b.tic();
+		for ( i = 0; i < b.iterations; i++ ) {
+			assignScalar( x, y );
+			if ( isnan( y.data[ i%len ] ) ) {
+				b.fail( 'should not return NaN' );
+			}
+		}
+		b.toc();
+		if ( isnan( y.data[ i%len ] ) ) {
+			b.fail( 'should not return NaN' );
+		}
+		b.pass( 'benchmark finished' );
+		b.end();
+	}
+}
+
+
+// MAIN //
+
+/**
+* Main execution sequence.
+*
+* @private
+*/
+function main() {
+	var len;
+	var min;
+	var max;
+	var sh;
+	var t1;
+	var t2;
+	var f;
+	var i;
+	var j;
+
+	min = 1; // 10^min
+	max = 6; // 10^max
+
+	for ( j = 0; j < types.length; j++ ) {
+		t1 = types[ j ];
+		t2 = types[ j ];
+		for ( i = min; i <= max; i++ ) {
+			len = pow( 10, i );
+
+			sh = [ len/2, 2, 1, 1, 1, 1, 1, 1 ];
+			f = createBenchmark( len, sh, t1, t2 );
+			bench( format( '%s::blocked:ndims=%d,len=%d,shape=[%s],xorder=%s,yorder=%s,xtype=%s,ytype=%s', pkg, sh.length, len, sh.join( ',' ), order, order, t1, t2 ), f );
+
+			sh = [ 1, 1, 1, 1, 1, 1, 2, len/2 ];
+			f = createBenchmark( len, sh, t1, t2 );
+			bench( format( '%s::blocked:ndims=%d,len=%d,shape=[%s],xorder=%s,yorder=%s,xtype=%s,ytype=%s', pkg, sh.length, len, sh.join( ',' ), order, order, t1, t2 ), f );
+
+			len = floor( pow( len, 1.0/8.0 ) );
+			sh = [ len, len, len, len, len, len, len, len ];
+			len *= pow( len, 7 );
+			f = createBenchmark( len, sh, t1, t2 );
+			bench( format( '%s::blocked:ndims=%d,len=%d,shape=[%s],xorder=%s,yorder=%s,xtype=%s,ytype=%s', pkg, sh.length, len, sh.join( ',' ), order, order, t1, t2 ), f );
+		}
+	}
+}
+
+main();
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.8d_blocked_rowmajor.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.8d_blocked_rowmajor.js
new file mode 100644
index 000000000000..0d01971bb9e9
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.8d_blocked_rowmajor.js
@@ -0,0 +1,145 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2026 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 bench = require( '@stdlib/bench' );
+var isnan = require( '@stdlib/math/base/assert/is-nan' );
+var pow = require( '@stdlib/math/base/special/pow' );
+var floor = require( '@stdlib/math/base/special/floor' );
+var filledarray = require( '@stdlib/array/filled' );
+var shape2strides = require( '@stdlib/ndarray/base/shape2strides' );
+var format = require( '@stdlib/string/format' );
+var pkg = require( './../package.json' ).name;
+var assignScalar = require( './../lib/8d_blocked.js' );
+
+
+// VARIABLES //
+
+var types = [ 'float64' ];
+var order = 'row-major';
+
+
+// FUNCTIONS //
+
+/**
+* Creates a benchmark function.
+*
+* @private
+* @param {PositiveInteger} len - ndarray length
+* @param {NonNegativeIntegerArray} shape - ndarray shape
+* @param {string} xtype - input ndarray data type
+* @param {string} ytype - output ndarray data type
+* @returns {Function} benchmark function
+*/
+function createBenchmark( len, shape, xtype, ytype ) {
+	var x;
+	var y;
+
+	y = filledarray( 0.0, len, ytype );
+	x = {
+		'dtype': xtype,
+		'data': [ 10.0 ],
+		'shape': [],
+		'strides': [ 0 ],
+		'offset': 0,
+		'order': order
+	};
+	y = {
+		'dtype': ytype,
+		'data': y,
+		'shape': shape,
+		'strides': shape2strides( shape, order ),
+		'offset': 0,
+		'order': order
+	};
+	return benchmark;
+
+	/**
+	* Benchmark function.
+	*
+	* @private
+	* @param {Benchmark} b - benchmark instance
+	*/
+	function benchmark( b ) {
+		var i;
+
+		b.tic();
+		for ( i = 0; i < b.iterations; i++ ) {
+			assignScalar( x, y );
+			if ( isnan( y.data[ i%len ] ) ) {
+				b.fail( 'should not return NaN' );
+			}
+		}
+		b.toc();
+		if ( isnan( y.data[ i%len ] ) ) {
+			b.fail( 'should not return NaN' );
+		}
+		b.pass( 'benchmark finished' );
+		b.end();
+	}
+}
+
+
+// MAIN //
+
+/**
+* Main execution sequence.
+*
+* @private
+*/
+function main() {
+	var len;
+	var min;
+	var max;
+	var sh;
+	var t1;
+	var t2;
+	var f;
+	var i;
+	var j;
+
+	min = 1; // 10^min
+	max = 6; // 10^max
+
+	for ( j = 0; j < types.length; j++ ) {
+		t1 = types[ j ];
+		t2 = types[ j ];
+		for ( i = min; i <= max; i++ ) {
+			len = pow( 10, i );
+
+			sh = [ len/2, 2, 1, 1, 1, 1, 1, 1 ];
+			f = createBenchmark( len, sh, t1, t2 );
+			bench( format( '%s::blocked:ndims=%d,len=%d,shape=[%s],xorder=%s,yorder=%s,xtype=%s,ytype=%s', pkg, sh.length, len, sh.join( ',' ), order, order, t1, t2 ), f );
+
+			sh = [ 1, 1, 1, 1, 1, 1, 2, len/2 ];
+			f = createBenchmark( len, sh, t1, t2 );
+			bench( format( '%s::blocked:ndims=%d,len=%d,shape=[%s],xorder=%s,yorder=%s,xtype=%s,ytype=%s', pkg, sh.length, len, sh.join( ',' ), order, order, t1, t2 ), f );
+
+			len = floor( pow( len, 1.0/8.0 ) );
+			sh = [ len, len, len, len, len, len, len, len ];
+			len *= pow( len, 7 );
+			f = createBenchmark( len, sh, t1, t2 );
+			bench( format( '%s::blocked:ndims=%d,len=%d,shape=[%s],xorder=%s,yorder=%s,xtype=%s,ytype=%s', pkg, sh.length, len, sh.join( ',' ), order, order, t1, t2 ), f );
+		}
+	}
+}
+
+main();
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.8d_columnmajor.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.8d_columnmajor.js
new file mode 100644
index 000000000000..b47fc11fb084
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.8d_columnmajor.js
@@ -0,0 +1,145 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2026 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 bench = require( '@stdlib/bench' );
+var isnan = require( '@stdlib/math/base/assert/is-nan' );
+var pow = require( '@stdlib/math/base/special/pow' );
+var floor = require( '@stdlib/math/base/special/floor' );
+var filledarray = require( '@stdlib/array/filled' );
+var shape2strides = require( '@stdlib/ndarray/base/shape2strides' );
+var format = require( '@stdlib/string/format' );
+var pkg = require( './../package.json' ).name;
+var assignScalar = require( './../lib/8d.js' );
+
+
+// VARIABLES //
+
+var types = [ 'float64' ];
+var order = 'column-major';
+
+
+// FUNCTIONS //
+
+/**
+* Creates a benchmark function.
+*
+* @private
+* @param {PositiveInteger} len - ndarray length
+* @param {NonNegativeIntegerArray} shape - ndarray shape
+* @param {string} xtype - input ndarray data type
+* @param {string} ytype - output ndarray data type
+* @returns {Function} benchmark function
+*/
+function createBenchmark( len, shape, xtype, ytype ) {
+	var x;
+	var y;
+
+	y = filledarray( 0.0, len, ytype );
+	x = {
+		'dtype': xtype,
+		'data': [ 10.0 ],
+		'shape': [],
+		'strides': [ 0 ],
+		'offset': 0,
+		'order': order
+	};
+	y = {
+		'dtype': ytype,
+		'data': y,
+		'shape': shape,
+		'strides': shape2strides( shape, order ),
+		'offset': 0,
+		'order': order
+	};
+	return benchmark;
+
+	/**
+	* Benchmark function.
+	*
+	* @private
+	* @param {Benchmark} b - benchmark instance
+	*/
+	function benchmark( b ) {
+		var i;
+
+		b.tic();
+		for ( i = 0; i < b.iterations; i++ ) {
+			assignScalar( x, y );
+			if ( isnan( y.data[ i%len ] ) ) {
+				b.fail( 'should not return NaN' );
+			}
+		}
+		b.toc();
+		if ( isnan( y.data[ i%len ] ) ) {
+			b.fail( 'should not return NaN' );
+		}
+		b.pass( 'benchmark finished' );
+		b.end();
+	}
+}
+
+
+// MAIN //
+
+/**
+* Main execution sequence.
+*
+* @private
+*/
+function main() {
+	var len;
+	var min;
+	var max;
+	var sh;
+	var t1;
+	var t2;
+	var f;
+	var i;
+	var j;
+
+	min = 1; // 10^min
+	max = 6; // 10^max
+
+	for ( j = 0; j < types.length; j++ ) {
+		t1 = types[ j ];
+		t2 = types[ j ];
+		for ( i = min; i <= max; i++ ) {
+			len = pow( 10, i );
+
+			sh = [ len/2, 2, 1, 1, 1, 1, 1, 1 ];
+			f = createBenchmark( len, sh, t1, t2 );
+			bench( format( '%s:ndims=%d,len=%d,shape=[%s],xorder=%s,yorder=%s,xtype=%s,ytype=%s', pkg, sh.length, len, sh.join( ',' ), order, order, t1, t2 ), f );
+
+			sh = [ 1, 1, 1, 1, 1, 1, 2, len/2 ];
+			f = createBenchmark( len, sh, t1, t2 );
+			bench( format( '%s:ndims=%d,len=%d,shape=[%s],xorder=%s,yorder=%s,xtype=%s,ytype=%s', pkg, sh.length, len, sh.join( ',' ), order, order, t1, t2 ), f );
+
+			len = floor( pow( len, 1.0/8.0 ) );
+			sh = [ len, len, len, len, len, len, len, len ];
+			len *= pow( len, 7 );
+			f = createBenchmark( len, sh, t1, t2 );
+			bench( format( '%s:ndims=%d,len=%d,shape=[%s],xorder=%s,yorder=%s,xtype=%s,ytype=%s', pkg, sh.length, len, sh.join( ',' ), order, order, t1, t2 ), f );
+		}
+	}
+}
+
+main();
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.8d_rowmajor.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.8d_rowmajor.js
new file mode 100644
index 000000000000..62acf986a619
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.8d_rowmajor.js
@@ -0,0 +1,145 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2026 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 bench = require( '@stdlib/bench' );
+var isnan = require( '@stdlib/math/base/assert/is-nan' );
+var pow = require( '@stdlib/math/base/special/pow' );
+var floor = require( '@stdlib/math/base/special/floor' );
+var filledarray = require( '@stdlib/array/filled' );
+var shape2strides = require( '@stdlib/ndarray/base/shape2strides' );
+var format = require( '@stdlib/string/format' );
+var pkg = require( './../package.json' ).name;
+var assignScalar = require( './../lib/8d.js' );
+
+
+// VARIABLES //
+
+var types = [ 'float64' ];
+var order = 'row-major';
+
+
+// FUNCTIONS //
+
+/**
+* Creates a benchmark function.
+*
+* @private
+* @param {PositiveInteger} len - ndarray length
+* @param {NonNegativeIntegerArray} shape - ndarray shape
+* @param {string} xtype - input ndarray data type
+* @param {string} ytype - output ndarray data type
+* @returns {Function} benchmark function
+*/
+function createBenchmark( len, shape, xtype, ytype ) {
+	var x;
+	var y;
+
+	y = filledarray( 0.0, len, ytype );
+	x = {
+		'dtype': xtype,
+		'data': [ 10.0 ],
+		'shape': [],
+		'strides': [ 0 ],
+		'offset': 0,
+		'order': order
+	};
+	y = {
+		'dtype': ytype,
+		'data': y,
+		'shape': shape,
+		'strides': shape2strides( shape, order ),
+		'offset': 0,
+		'order': order
+	};
+	return benchmark;
+
+	/**
+	* Benchmark function.
+	*
+	* @private
+	* @param {Benchmark} b - benchmark instance
+	*/
+	function benchmark( b ) {
+		var i;
+
+		b.tic();
+		for ( i = 0; i < b.iterations; i++ ) {
+			assignScalar( x, y );
+			if ( isnan( y.data[ i%len ] ) ) {
+				b.fail( 'should not return NaN' );
+			}
+		}
+		b.toc();
+		if ( isnan( y.data[ i%len ] ) ) {
+			b.fail( 'should not return NaN' );
+		}
+		b.pass( 'benchmark finished' );
+		b.end();
+	}
+}
+
+
+// MAIN //
+
+/**
+* Main execution sequence.
+*
+* @private
+*/
+function main() {
+	var len;
+	var min;
+	var max;
+	var sh;
+	var t1;
+	var t2;
+	var f;
+	var i;
+	var j;
+
+	min = 1; // 10^min
+	max = 6; // 10^max
+
+	for ( j = 0; j < types.length; j++ ) {
+		t1 = types[ j ];
+		t2 = types[ j ];
+		for ( i = min; i <= max; i++ ) {
+			len = pow( 10, i );
+
+			sh = [ len/2, 2, 1, 1, 1, 1, 1, 1 ];
+			f = createBenchmark( len, sh, t1, t2 );
+			bench( format( '%s:ndims=%d,len=%d,shape=[%s],xorder=%s,yorder=%s,xtype=%s,ytype=%s', pkg, sh.length, len, sh.join( ',' ), order, order, t1, t2 ), f );
+
+			sh = [ 1, 1, 1, 1, 1, 1, 2, len/2 ];
+			f = createBenchmark( len, sh, t1, t2 );
+			bench( format( '%s:ndims=%d,len=%d,shape=[%s],xorder=%s,yorder=%s,xtype=%s,ytype=%s', pkg, sh.length, len, sh.join( ',' ), order, order, t1, t2 ), f );
+
+			len = floor( pow( len, 1.0/8.0 ) );
+			sh = [ len, len, len, len, len, len, len, len ];
+			len *= pow( len, 7 );
+			f = createBenchmark( len, sh, t1, t2 );
+			bench( format( '%s:ndims=%d,len=%d,shape=[%s],xorder=%s,yorder=%s,xtype=%s,ytype=%s', pkg, sh.length, len, sh.join( ',' ), order, order, t1, t2 ), f );
+		}
+	}
+}
+
+main();
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.9d_blocked_columnmajor.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.9d_blocked_columnmajor.js
new file mode 100644
index 000000000000..2d805c5d63f1
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.9d_blocked_columnmajor.js
@@ -0,0 +1,145 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2026 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 bench = require( '@stdlib/bench' );
+var isnan = require( '@stdlib/math/base/assert/is-nan' );
+var pow = require( '@stdlib/math/base/special/pow' );
+var floor = require( '@stdlib/math/base/special/floor' );
+var filledarray = require( '@stdlib/array/filled' );
+var shape2strides = require( '@stdlib/ndarray/base/shape2strides' );
+var format = require( '@stdlib/string/format' );
+var pkg = require( './../package.json' ).name;
+var assignScalar = require( './../lib/9d_blocked.js' );
+
+
+// VARIABLES //
+
+var types = [ 'float64' ];
+var order = 'column-major';
+
+
+// FUNCTIONS //
+
+/**
+* Creates a benchmark function.
+*
+* @private
+* @param {PositiveInteger} len - ndarray length
+* @param {NonNegativeIntegerArray} shape - ndarray shape
+* @param {string} xtype - input ndarray data type
+* @param {string} ytype - output ndarray data type
+* @returns {Function} benchmark function
+*/
+function createBenchmark( len, shape, xtype, ytype ) {
+	var x;
+	var y;
+
+	y = filledarray( 0.0, len, ytype );
+	x = {
+		'dtype': xtype,
+		'data': [ 10.0 ],
+		'shape': [],
+		'strides': [ 0 ],
+		'offset': 0,
+		'order': order
+	};
+	y = {
+		'dtype': ytype,
+		'data': y,
+		'shape': shape,
+		'strides': shape2strides( shape, order ),
+		'offset': 0,
+		'order': order
+	};
+	return benchmark;
+
+	/**
+	* Benchmark function.
+	*
+	* @private
+	* @param {Benchmark} b - benchmark instance
+	*/
+	function benchmark( b ) {
+		var i;
+
+		b.tic();
+		for ( i = 0; i < b.iterations; i++ ) {
+			assignScalar( x, y );
+			if ( isnan( y.data[ i%len ] ) ) {
+				b.fail( 'should not return NaN' );
+			}
+		}
+		b.toc();
+		if ( isnan( y.data[ i%len ] ) ) {
+			b.fail( 'should not return NaN' );
+		}
+		b.pass( 'benchmark finished' );
+		b.end();
+	}
+}
+
+
+// MAIN //
+
+/**
+* Main execution sequence.
+*
+* @private
+*/
+function main() {
+	var len;
+	var min;
+	var max;
+	var sh;
+	var t1;
+	var t2;
+	var f;
+	var i;
+	var j;
+
+	min = 1; // 10^min
+	max = 6; // 10^max
+
+	for ( j = 0; j < types.length; j++ ) {
+		t1 = types[ j ];
+		t2 = types[ j ];
+		for ( i = min; i <= max; i++ ) {
+			len = pow( 10, i );
+
+			sh = [ len/2, 2, 1, 1, 1, 1, 1, 1, 1 ];
+			f = createBenchmark( len, sh, t1, t2 );
+			bench( format( '%s::blocked:ndims=%d,len=%d,shape=[%s],xorder=%s,yorder=%s,xtype=%s,ytype=%s', pkg, sh.length, len, sh.join( ',' ), order, order, t1, t2 ), f );
+
+			sh = [ 1, 1, 1, 1, 1, 1, 1, 2, len/2 ];
+			f = createBenchmark( len, sh, t1, t2 );
+			bench( format( '%s::blocked:ndims=%d,len=%d,shape=[%s],xorder=%s,yorder=%s,xtype=%s,ytype=%s', pkg, sh.length, len, sh.join( ',' ), order, order, t1, t2 ), f );
+
+			len = floor( pow( len, 1.0/9.0 ) );
+			sh = [ len, len, len, len, len, len, len, len, len ];
+			len *= pow( len, 8 );
+			f = createBenchmark( len, sh, t1, t2 );
+			bench( format( '%s::blocked:ndims=%d,len=%d,shape=[%s],xorder=%s,yorder=%s,xtype=%s,ytype=%s', pkg, sh.length, len, sh.join( ',' ), order, order, t1, t2 ), f );
+		}
+	}
+}
+
+main();
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.9d_blocked_rowmajor.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.9d_blocked_rowmajor.js
new file mode 100644
index 000000000000..5f669af6ac67
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.9d_blocked_rowmajor.js
@@ -0,0 +1,145 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2026 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 bench = require( '@stdlib/bench' );
+var isnan = require( '@stdlib/math/base/assert/is-nan' );
+var pow = require( '@stdlib/math/base/special/pow' );
+var floor = require( '@stdlib/math/base/special/floor' );
+var filledarray = require( '@stdlib/array/filled' );
+var shape2strides = require( '@stdlib/ndarray/base/shape2strides' );
+var format = require( '@stdlib/string/format' );
+var pkg = require( './../package.json' ).name;
+var assignScalar = require( './../lib/9d_blocked.js' );
+
+
+// VARIABLES //
+
+var types = [ 'float64' ];
+var order = 'row-major';
+
+
+// FUNCTIONS //
+
+/**
+* Creates a benchmark function.
+*
+* @private
+* @param {PositiveInteger} len - ndarray length
+* @param {NonNegativeIntegerArray} shape - ndarray shape
+* @param {string} xtype - input ndarray data type
+* @param {string} ytype - output ndarray data type
+* @returns {Function} benchmark function
+*/
+function createBenchmark( len, shape, xtype, ytype ) {
+	var x;
+	var y;
+
+	y = filledarray( 0.0, len, ytype );
+	x = {
+		'dtype': xtype,
+		'data': [ 10.0 ],
+		'shape': [],
+		'strides': [ 0 ],
+		'offset': 0,
+		'order': order
+	};
+	y = {
+		'dtype': ytype,
+		'data': y,
+		'shape': shape,
+		'strides': shape2strides( shape, order ),
+		'offset': 0,
+		'order': order
+	};
+	return benchmark;
+
+	/**
+	* Benchmark function.
+	*
+	* @private
+	* @param {Benchmark} b - benchmark instance
+	*/
+	function benchmark( b ) {
+		var i;
+
+		b.tic();
+		for ( i = 0; i < b.iterations; i++ ) {
+			assignScalar( x, y );
+			if ( isnan( y.data[ i%len ] ) ) {
+				b.fail( 'should not return NaN' );
+			}
+		}
+		b.toc();
+		if ( isnan( y.data[ i%len ] ) ) {
+			b.fail( 'should not return NaN' );
+		}
+		b.pass( 'benchmark finished' );
+		b.end();
+	}
+}
+
+
+// MAIN //
+
+/**
+* Main execution sequence.
+*
+* @private
+*/
+function main() {
+	var len;
+	var min;
+	var max;
+	var sh;
+	var t1;
+	var t2;
+	var f;
+	var i;
+	var j;
+
+	min = 1; // 10^min
+	max = 6; // 10^max
+
+	for ( j = 0; j < types.length; j++ ) {
+		t1 = types[ j ];
+		t2 = types[ j ];
+		for ( i = min; i <= max; i++ ) {
+			len = pow( 10, i );
+
+			sh = [ len/2, 2, 1, 1, 1, 1, 1, 1, 1 ];
+			f = createBenchmark( len, sh, t1, t2 );
+			bench( format( '%s::blocked:ndims=%d,len=%d,shape=[%s],xorder=%s,yorder=%s,xtype=%s,ytype=%s', pkg, sh.length, len, sh.join( ',' ), order, order, t1, t2 ), f );
+
+			sh = [ 1, 1, 1, 1, 1, 1, 1, 2, len/2 ];
+			f = createBenchmark( len, sh, t1, t2 );
+			bench( format( '%s::blocked:ndims=%d,len=%d,shape=[%s],xorder=%s,yorder=%s,xtype=%s,ytype=%s', pkg, sh.length, len, sh.join( ',' ), order, order, t1, t2 ), f );
+
+			len = floor( pow( len, 1.0/9.0 ) );
+			sh = [ len, len, len, len, len, len, len, len, len ];
+			len *= pow( len, 8 );
+			f = createBenchmark( len, sh, t1, t2 );
+			bench( format( '%s::blocked:ndims=%d,len=%d,shape=[%s],xorder=%s,yorder=%s,xtype=%s,ytype=%s', pkg, sh.length, len, sh.join( ',' ), order, order, t1, t2 ), f );
+		}
+	}
+}
+
+main();
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.9d_columnmajor.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.9d_columnmajor.js
new file mode 100644
index 000000000000..970f547d70d4
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.9d_columnmajor.js
@@ -0,0 +1,145 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2026 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 bench = require( '@stdlib/bench' );
+var isnan = require( '@stdlib/math/base/assert/is-nan' );
+var pow = require( '@stdlib/math/base/special/pow' );
+var floor = require( '@stdlib/math/base/special/floor' );
+var filledarray = require( '@stdlib/array/filled' );
+var shape2strides = require( '@stdlib/ndarray/base/shape2strides' );
+var format = require( '@stdlib/string/format' );
+var pkg = require( './../package.json' ).name;
+var assignScalar = require( './../lib/9d.js' );
+
+
+// VARIABLES //
+
+var types = [ 'float64' ];
+var order = 'column-major';
+
+
+// FUNCTIONS //
+
+/**
+* Creates a benchmark function.
+*
+* @private
+* @param {PositiveInteger} len - ndarray length
+* @param {NonNegativeIntegerArray} shape - ndarray shape
+* @param {string} xtype - input ndarray data type
+* @param {string} ytype - output ndarray data type
+* @returns {Function} benchmark function
+*/
+function createBenchmark( len, shape, xtype, ytype ) {
+	var x;
+	var y;
+
+	y = filledarray( 0.0, len, ytype );
+	x = {
+		'dtype': xtype,
+		'data': [ 10.0 ],
+		'shape': [],
+		'strides': [ 0 ],
+		'offset': 0,
+		'order': order
+	};
+	y = {
+		'dtype': ytype,
+		'data': y,
+		'shape': shape,
+		'strides': shape2strides( shape, order ),
+		'offset': 0,
+		'order': order
+	};
+	return benchmark;
+
+	/**
+	* Benchmark function.
+	*
+	* @private
+	* @param {Benchmark} b - benchmark instance
+	*/
+	function benchmark( b ) {
+		var i;
+
+		b.tic();
+		for ( i = 0; i < b.iterations; i++ ) {
+			assignScalar( x, y );
+			if ( isnan( y.data[ i%len ] ) ) {
+				b.fail( 'should not return NaN' );
+			}
+		}
+		b.toc();
+		if ( isnan( y.data[ i%len ] ) ) {
+			b.fail( 'should not return NaN' );
+		}
+		b.pass( 'benchmark finished' );
+		b.end();
+	}
+}
+
+
+// MAIN //
+
+/**
+* Main execution sequence.
+*
+* @private
+*/
+function main() {
+	var len;
+	var min;
+	var max;
+	var sh;
+	var t1;
+	var t2;
+	var f;
+	var i;
+	var j;
+
+	min = 1; // 10^min
+	max = 6; // 10^max
+
+	for ( j = 0; j < types.length; j++ ) {
+		t1 = types[ j ];
+		t2 = types[ j ];
+		for ( i = min; i <= max; i++ ) {
+			len = pow( 10, i );
+
+			sh = [ len/2, 2, 1, 1, 1, 1, 1, 1, 1 ];
+			f = createBenchmark( len, sh, t1, t2 );
+			bench( format( '%s:ndims=%d,len=%d,shape=[%s],xorder=%s,yorder=%s,xtype=%s,ytype=%s', pkg, sh.length, len, sh.join( ',' ), order, order, t1, t2 ), f );
+
+			sh = [ 1, 1, 1, 1, 1, 1, 1, 2, len/2 ];
+			f = createBenchmark( len, sh, t1, t2 );
+			bench( format( '%s:ndims=%d,len=%d,shape=[%s],xorder=%s,yorder=%s,xtype=%s,ytype=%s', pkg, sh.length, len, sh.join( ',' ), order, order, t1, t2 ), f );
+
+			len = floor( pow( len, 1.0/9.0 ) );
+			sh = [ len, len, len, len, len, len, len, len, len ];
+			len *= pow( len, 8 );
+			f = createBenchmark( len, sh, t1, t2 );
+			bench( format( '%s:ndims=%d,len=%d,shape=[%s],xorder=%s,yorder=%s,xtype=%s,ytype=%s', pkg, sh.length, len, sh.join( ',' ), order, order, t1, t2 ), f );
+		}
+	}
+}
+
+main();
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.9d_rowmajor.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.9d_rowmajor.js
new file mode 100644
index 000000000000..601a4321f97d
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.9d_rowmajor.js
@@ -0,0 +1,145 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2026 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 bench = require( '@stdlib/bench' );
+var isnan = require( '@stdlib/math/base/assert/is-nan' );
+var pow = require( '@stdlib/math/base/special/pow' );
+var floor = require( '@stdlib/math/base/special/floor' );
+var filledarray = require( '@stdlib/array/filled' );
+var shape2strides = require( '@stdlib/ndarray/base/shape2strides' );
+var format = require( '@stdlib/string/format' );
+var pkg = require( './../package.json' ).name;
+var assignScalar = require( './../lib/9d.js' );
+
+
+// VARIABLES //
+
+var types = [ 'float64' ];
+var order = 'row-major';
+
+
+// FUNCTIONS //
+
+/**
+* Creates a benchmark function.
+*
+* @private
+* @param {PositiveInteger} len - ndarray length
+* @param {NonNegativeIntegerArray} shape - ndarray shape
+* @param {string} xtype - input ndarray data type
+* @param {string} ytype - output ndarray data type
+* @returns {Function} benchmark function
+*/
+function createBenchmark( len, shape, xtype, ytype ) {
+	var x;
+	var y;
+
+	y = filledarray( 0.0, len, ytype );
+	x = {
+		'dtype': xtype,
+		'data': [ 10.0 ],
+		'shape': [],
+		'strides': [ 0 ],
+		'offset': 0,
+		'order': order
+	};
+	y = {
+		'dtype': ytype,
+		'data': y,
+		'shape': shape,
+		'strides': shape2strides( shape, order ),
+		'offset': 0,
+		'order': order
+	};
+	return benchmark;
+
+	/**
+	* Benchmark function.
+	*
+	* @private
+	* @param {Benchmark} b - benchmark instance
+	*/
+	function benchmark( b ) {
+		var i;
+
+		b.tic();
+		for ( i = 0; i < b.iterations; i++ ) {
+			assignScalar( x, y );
+			if ( isnan( y.data[ i%len ] ) ) {
+				b.fail( 'should not return NaN' );
+			}
+		}
+		b.toc();
+		if ( isnan( y.data[ i%len ] ) ) {
+			b.fail( 'should not return NaN' );
+		}
+		b.pass( 'benchmark finished' );
+		b.end();
+	}
+}
+
+
+// MAIN //
+
+/**
+* Main execution sequence.
+*
+* @private
+*/
+function main() {
+	var len;
+	var min;
+	var max;
+	var sh;
+	var t1;
+	var t2;
+	var f;
+	var i;
+	var j;
+
+	min = 1; // 10^min
+	max = 6; // 10^max
+
+	for ( j = 0; j < types.length; j++ ) {
+		t1 = types[ j ];
+		t2 = types[ j ];
+		for ( i = min; i <= max; i++ ) {
+			len = pow( 10, i );
+
+			sh = [ len/2, 2, 1, 1, 1, 1, 1, 1, 1 ];
+			f = createBenchmark( len, sh, t1, t2 );
+			bench( format( '%s:ndims=%d,len=%d,shape=[%s],xorder=%s,yorder=%s,xtype=%s,ytype=%s', pkg, sh.length, len, sh.join( ',' ), order, order, t1, t2 ), f );
+
+			sh = [ 1, 1, 1, 1, 1, 1, 1, 2, len/2 ];
+			f = createBenchmark( len, sh, t1, t2 );
+			bench( format( '%s:ndims=%d,len=%d,shape=[%s],xorder=%s,yorder=%s,xtype=%s,ytype=%s', pkg, sh.length, len, sh.join( ',' ), order, order, t1, t2 ), f );
+
+			len = floor( pow( len, 1.0/9.0 ) );
+			sh = [ len, len, len, len, len, len, len, len, len ];
+			len *= pow( len, 8 );
+			f = createBenchmark( len, sh, t1, t2 );
+			bench( format( '%s:ndims=%d,len=%d,shape=[%s],xorder=%s,yorder=%s,xtype=%s,ytype=%s', pkg, sh.length, len, sh.join( ',' ), order, order, t1, t2 ), f );
+		}
+	}
+}
+
+main();
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/docs/repl.txt b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/docs/repl.txt
new file mode 100644
index 000000000000..dcc976bea72e
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/docs/repl.txt
@@ -0,0 +1,62 @@
+
+{{alias}}( arrays )
+    Assigns a scalar value to every element of an output ndarray.
+
+    Each provided "ndarray" should be an object with the following properties:
+
+    - dtype: data type.
+    - data: data buffer.
+    - shape: dimensions.
+    - strides: stride lengths.
+    - offset: index offset.
+    - order: specifies whether an ndarray is row-major (C-style) or
+    column-major (Fortran-style).
+
+    Parameters
+    ----------
+    arrays: ArrayLikeObject<ndarray>
+        Array-like object containing a zero-dimensional input ndarray and one
+        output ndarray.
+
+    Examples
+    --------
+    // Define ndarray data and meta data...
+    > var xbuf = new {{alias:@stdlib/array/float64}}( [ 5.0 ] );
+    > var ybuf = new {{alias:@stdlib/array/float64}}( [ 0.0, 0.0, 0.0, 0.0 ] );
+    > var dtype = 'float64';
+    > var shape = [ 2, 2 ];
+    > var sy = [ 2, 1 ];
+    > var oy = 0;
+    > var order = 'row-major';
+
+    // Using ndarrays...
+    > var x = {{alias:@stdlib/ndarray/from-scalar}}( 5.0, { 'dtype': dtype } );
+    > var y = {{alias:@stdlib/ndarray/ctor}}( dtype, ybuf, shape, sy, oy, order );
+    > {{alias}}( [ x, y ] );
+    > y.data
+    <Float64Array>[ 5.0, 5.0, 5.0, 5.0 ]
+
+    // Using minimal ndarray-like objects...
+    > x = {
+    ...     'dtype': dtype,
+    ...     'data': xbuf,
+    ...     'shape': [],
+    ...     'strides': [ 0 ],
+    ...     'offset': 0,
+    ...     'order': order
+    ... };
+    > y = {
+    ...     'dtype': dtype,
+    ...     'data': ybuf,
+    ...     'shape': shape,
+    ...     'strides': sy,
+    ...     'offset': oy,
+    ...     'order': order
+    ... };
+    > {{alias}}( [ x, y ] );
+    > y.data
+    <Float64Array>[ 5.0, 5.0, 5.0, 5.0 ]
+
+    See Also
+    --------
+
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/docs/types/index.d.ts b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/docs/types/index.d.ts
new file mode 100644
index 000000000000..1c2e2ead1c68
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/docs/types/index.d.ts
@@ -0,0 +1,67 @@
+/*
+* @license Apache-2.0
+*
+* Copyright (c) 2026 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.
+*/
+
+// TypeScript Version: 4.1
+
+/// <reference types="@stdlib/types"/>
+
+import { ArrayLike } from '@stdlib/types/array';
+import { ndarray } from '@stdlib/types/ndarray';
+
+/**
+* Assigns a scalar value to every element of an output ndarray.
+*
+* @param arrays - array-like object containing a zero-dimensional input ndarray and one output ndarray
+*
+* @example
+* var Float64Array = require( '@stdlib/array/float64' );
+* var scalar2ndarray = require( '@stdlib/ndarray/from-scalar' );
+* var ndarray = require( '@stdlib/ndarray/ctor' );
+*
+* // Create a zero-dimensional ndarray containing the scalar value:
+* var x = scalar2ndarray( 5.0, {
+*     'dtype': 'float64'
+* });
+*
+* // Create a data buffer:
+* var ybuf = new Float64Array( 4 );
+*
+* // Define the shape of the output array:
+* var shape = [ 2, 2 ];
+*
+* // Define the array strides:
+* var sy = [ 2, 1 ];
+*
+* // Define the index offset:
+* var oy = 0;
+*
+* // Create the output ndarray:
+* var y = ndarray( 'float64', ybuf, shape, sy, oy, 'row-major' );
+*
+* // Assign the scalar value:
+* assignScalar( [ x, y ] );
+*
+* console.log( y.data );
+* // => <Float64Array>[ 5.0, 5.0, 5.0, 5.0 ]
+*/
+declare function assignScalar( arrays: ArrayLike<ndarray> ): void;
+
+
+// EXPORTS //
+
+export = assignScalar;
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/docs/types/test.ts b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/docs/types/test.ts
new file mode 100644
index 000000000000..7e4286217ec9
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/docs/types/test.ts
@@ -0,0 +1,56 @@
+/*
+* @license Apache-2.0
+*
+* Copyright (c) 2026 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.
+*/
+
+import zeros = require( '@stdlib/ndarray/zeros' );
+import scalar2ndarray = require( '@stdlib/ndarray/from-scalar' );
+import assignScalar = require( './index' );
+
+
+// TESTS //
+
+// The function returns `undefined`...
+{
+	const x = scalar2ndarray( 5.0, { 'dtype': 'float64' } );
+	const y = zeros( [ 2, 2 ] );
+	const arrays = [ x, y ];
+
+	assignScalar( arrays ); // $ExpectType void
+}
+
+// The compiler throws an error if the function is provided a first argument which is not an array-like object containing ndarray-like objects...
+{
+	assignScalar( '5' ); // $ExpectError
+	assignScalar( 5 ); // $ExpectError
+	assignScalar( true ); // $ExpectError
+	assignScalar( false ); // $ExpectError
+	assignScalar( null ); // $ExpectError
+	assignScalar( undefined ); // $ExpectError
+	assignScalar( {} ); // $ExpectError
+	assignScalar( [ 1 ] ); // $ExpectError
+	assignScalar( ( x: number ): number => x ); // $ExpectError
+}
+
+// The compiler throws an error if the function is provided an unsupported number of arguments...
+{
+	const x = scalar2ndarray( 5.0, { 'dtype': 'float64' } );
+	const y = zeros( [ 2, 2 ] );
+	const arrays = [ x, y ];
+
+	assignScalar(); // $ExpectError
+	assignScalar( arrays, 10 ); // $ExpectError
+}
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/examples/index.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/examples/index.js
new file mode 100644
index 000000000000..64cfe873ba7a
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/examples/index.js
@@ -0,0 +1,42 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2026 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';
+
+var scalar2ndarray = require( '@stdlib/ndarray/from-scalar' );
+var filledarray = require( '@stdlib/array/filled' );
+var ndarray2array = require( '@stdlib/ndarray/base/to-array' );
+var assignScalar = require( './../lib' );
+
+var x = scalar2ndarray( 10.0, {
+	'dtype': 'generic'
+});
+console.log( x.data );
+
+var y = {
+	'dtype': 'generic',
+	'data': filledarray( 0.0, 10, 'generic' ),
+	'shape': [ 5, 2 ],
+	'strides': [ 2, 1 ],
+	'offset': 0,
+	'order': 'row-major'
+};
+console.log( ndarray2array( y.data, y.shape, y.strides, y.offset, y.order ) );
+
+assignScalar( [ x, y ] );
+console.log( ndarray2array( y.data, y.shape, y.strides, y.offset, y.order ) );
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/0d.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/0d.js
new file mode 100644
index 000000000000..3a29b924a8ef
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/0d.js
@@ -0,0 +1,92 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2026 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';
+
+// MAIN //
+
+/**
+* Assigns a scalar value to every element of a zero-dimensional output ndarray.
+*
+* @private
+* @param {Object} x - object containing input ndarray meta data
+* @param {*} x.dtype - data type
+* @param {Collection} x.data - data buffer
+* @param {NonNegativeIntegerArray} x.shape - dimensions
+* @param {IntegerArray} x.strides - stride lengths
+* @param {NonNegativeInteger} x.offset - index offset
+* @param {string} x.order - specifies whether `x` is row-major (C-style) or column-major (Fortran-style)
+* @param {Object} y - object containing output ndarray meta data
+* @param {*} y.dtype - data type
+* @param {Collection} y.data - data buffer
+* @param {NonNegativeIntegerArray} y.shape - dimensions
+* @param {IntegerArray} y.strides - stride lengths
+* @param {NonNegativeInteger} y.offset - index offset
+* @param {string} y.order - specifies whether `y` is row-major (C-style) or column-major (Fortran-style)
+* @returns {void}
+*
+* @example
+* var Float64Array = require( '@stdlib/array/float64' );
+*
+* // Create data buffers:
+* var xbuf = new Float64Array( [ 2.0 ] );
+* var ybuf = new Float64Array( 1 );
+*
+* // Define the shape of the output array:
+* var shape = [ 3, 1, 2 ];
+*
+* // Define the array strides:
+* var sx = [ 0 ];
+* var sy = [ 2, 2, 1 ];
+*
+* // Define the index offsets:
+* var ox = 0;
+* var oy = 0;
+*
+* // Create the input and output ndarray-like objects:
+* var x = {
+*     'dtype': 'float64',
+*     'data': xbuf,
+*     'shape': [],
+*     'strides': sx,
+*     'offset': ox,
+*     'order': 'row-major'
+* };
+* var y = {
+*     'dtype': 'float64',
+*     'data': ybuf,
+*     'shape': shape,
+*     'strides': sy,
+*     'offset': oy,
+*     'order': 'row-major'
+* };
+*
+* // Assign scalar:
+* assign0d( x, y );
+*
+* console.log( y.data );
+* // => <Float64Array>[ 2.0 ]
+*/
+function assign0d( x, y ) {
+	y.data[ y.offset ] = x.data[ x.offset ];
+}
+
+
+// EXPORTS //
+
+module.exports = assign0d;
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/0d_accessors.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/0d_accessors.js
new file mode 100644
index 000000000000..b2fc5b680a24
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/0d_accessors.js
@@ -0,0 +1,113 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2026 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';
+
+// MAIN //
+
+/**
+* Assigns a scalar value to every element of a zero-dimensional output ndarray.
+*
+* @private
+* @param {Object} x - object containing input ndarray meta data
+* @param {*} x.dtype - data type
+* @param {Collection} x.data - data buffer
+* @param {NonNegativeIntegerArray} x.shape - dimensions
+* @param {IntegerArray} x.strides - stride lengths
+* @param {NonNegativeInteger} x.offset - index offset
+* @param {string} x.order - specifies whether `x` is row-major (C-style) or column-major (Fortran-style)
+* @param {Array<Function>} x.accessors - data buffer accessors
+* @param {Object} y - object containing output ndarray meta data
+* @param {*} y.dtype - data type
+* @param {Collection} y.data - data buffer
+* @param {NonNegativeIntegerArray} y.shape - dimensions
+* @param {IntegerArray} y.strides - stride lengths
+* @param {NonNegativeInteger} y.offset - index offset
+* @param {string} y.order - specifies whether `y` is row-major (C-style) or column-major (Fortran-style)
+* @param {Array<Function>} y.accessors - data buffer accessors
+* @returns {void}
+*
+* @example
+* var Complex64Array = require( '@stdlib/array/complex64' );
+* var Complex64 = require( '@stdlib/complex/float32/ctor' );
+* var realf = require( '@stdlib/complex/float32/real' );
+* var imagf = require( '@stdlib/complex/float32/imag' );
+*
+* // Create data buffers:
+* var xbuf = new Complex64Array( [ 3.0, 4.0 ] );
+* var ybuf = new Complex64Array( 1 );
+*
+* // Define the shape of the input and output arrays:
+* var shape = [];
+*
+* // Define the array strides:
+* var sx = [ 0 ];
+* var sy = [ 0 ];
+*
+* // Define the index offsets:
+* var ox = 0;
+* var oy = 0;
+*
+* // Define getters and setters:
+* function getter( buf, idx ) {
+*     return buf.get( idx );
+* }
+*
+* function setter( buf, idx, value ) {
+*     buf.set( value, idx );
+* }
+*
+* // Create the input and output ndarray-like objects:
+* var x = {
+*     'dtype': 'complex64',
+*     'data': xbuf,
+*     'shape': shape,
+*     'strides': sx,
+*     'offset': ox,
+*     'order': 'row-major',
+*     'accessors': [ getter, setter ]
+* };
+* var y = {
+*     'dtype': 'complex64',
+*     'data': ybuf,
+*     'shape': shape,
+*     'strides': sy,
+*     'offset': oy,
+*     'order': 'row-major',
+*     'accessors': [ getter, setter ]
+* };
+*
+* // Assign scalar:
+* assign0d( x, y );
+*
+* var v = y.data.get( 0 );
+*
+* var re = realf( v );
+* // returns 3.0
+*
+* var im = imagf( v );
+* // returns 4.0
+*/
+function assign0d( x, y ) {
+	y.accessors[ 1 ]( y.data, y.offset, x.accessors[ 0 ]( x.data, x.offset ) );
+}
+
+
+// EXPORTS //
+
+module.exports = assign0d;
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/10d.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/10d.js
new file mode 100644
index 000000000000..a405b0543d3b
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/10d.js
@@ -0,0 +1,221 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2026 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-depth, max-statements */
+
+'use strict';
+
+// MAIN //
+
+/**
+* Assigns a scalar value to every element of a ten-dimensional output ndarray.
+*
+* @private
+* @param {Object} x - object containing input ndarray meta data
+* @param {*} x.dtype - data type
+* @param {Collection} x.data - data buffer
+* @param {NonNegativeIntegerArray} x.shape - dimensions
+* @param {IntegerArray} x.strides - stride lengths
+* @param {NonNegativeInteger} x.offset - index offset
+* @param {string} x.order - specifies whether `x` is row-major (C-style) or column-major (Fortran-style)
+* @param {Object} y - object containing output ndarray meta data
+* @param {*} y.dtype - data type
+* @param {Collection} y.data - data buffer
+* @param {NonNegativeIntegerArray} y.shape - dimensions
+* @param {IntegerArray} y.strides - stride lengths
+* @param {NonNegativeInteger} y.offset - index offset
+* @param {string} y.order - specifies whether `y` is row-major (C-style) or column-major (Fortran-style)
+* @param {boolean} isRowMajor - boolean indicating if provided arrays are in row-major order
+* @returns {void}
+*
+* @example
+* var Float64Array = require( '@stdlib/array/float64' );
+*
+* // Create data buffers:
+* var xbuf = new Float64Array( [ 2.0 ] );
+* var ybuf = new Float64Array( 6 );
+*
+* // Define the shape of the output array:
+* var shape = [ 1, 1, 1, 1, 1, 1, 1, 3, 1, 2 ];
+*
+* // Define the array strides:
+* var sx = [ 0 ];
+* var sy = [ 2, 2, 2, 2, 2, 2, 2, 2, 2, 1 ];
+*
+* // Define the index offsets:
+* var ox = 0;
+* var oy = 0;
+*
+* // Create the input and output ndarray-like objects:
+* var x = {
+*     'dtype': 'float64',
+*     'data': xbuf,
+*     'shape': [],
+*     'strides': sx,
+*     'offset': ox,
+*     'order': 'row-major'
+* };
+* var y = {
+*     'dtype': 'float64',
+*     'data': ybuf,
+*     'shape': shape,
+*     'strides': sy,
+*     'offset': oy,
+*     'order': 'row-major'
+* };
+*
+* // Assign scalar:
+* assign10d( x, y, true );
+*
+* console.log( y.data );
+* // => <Float64Array>[ 2.0, 2.0, 2.0, 2.0, 2.0, 2.0 ]
+*/
+function assign10d( x, y, isRowMajor ) {
+	var xbuf;
+	var ybuf;
+	var dy0;
+	var dy1;
+	var dy2;
+	var dy3;
+	var dy4;
+	var dy5;
+	var dy6;
+	var dy7;
+	var dy8;
+	var dy9;
+	var sh;
+	var S0;
+	var S1;
+	var S2;
+	var S3;
+	var S4;
+	var S5;
+	var S6;
+	var S7;
+	var S8;
+	var S9;
+	var sy;
+	var ix;
+	var iy;
+	var i0;
+	var i1;
+	var i2;
+	var i3;
+	var i4;
+	var i5;
+	var i6;
+	var i7;
+	var i8;
+	var i9;
+
+	// Note on variable naming convention: S#, dy#, i# where # corresponds to the loop number, with `0` being the innermost loop...
+
+	// Extract loop variables for purposes of loop interchange: dimensions and loop offset (pointer) increments...
+	sh = y.shape;
+	sy = y.strides;
+	if ( isRowMajor ) {
+		// For row-major ndarrays, the last dimensions have the fastest changing indices...
+		S0 = sh[ 9 ];
+		S1 = sh[ 8 ];
+		S2 = sh[ 7 ];
+		S3 = sh[ 6 ];
+		S4 = sh[ 5 ];
+		S5 = sh[ 4 ];
+		S6 = sh[ 3 ];
+		S7 = sh[ 2 ];
+		S8 = sh[ 1 ];
+		S9 = sh[ 0 ];
+		dy0 = sy[ 9 ];
+		dy1 = sy[ 8 ] - ( S0*sy[9] );
+		dy2 = sy[ 7 ] - ( S1*sy[8] );
+		dy3 = sy[ 6 ] - ( S2*sy[7] );
+		dy4 = sy[ 5 ] - ( S3*sy[6] );
+		dy5 = sy[ 4 ] - ( S4*sy[5] );
+		dy6 = sy[ 3 ] - ( S5*sy[4] );
+		dy7 = sy[ 2 ] - ( S6*sy[3] );
+		dy8 = sy[ 1 ] - ( S7*sy[2] );
+		dy9 = sy[ 0 ] - ( S8*sy[1] );
+	} else { // order === 'column-major'
+		// For column-major ndarrays, the first dimensions have the fastest changing indices...
+		S0 = sh[ 0 ];
+		S1 = sh[ 1 ];
+		S2 = sh[ 2 ];
+		S3 = sh[ 3 ];
+		S4 = sh[ 4 ];
+		S5 = sh[ 5 ];
+		S6 = sh[ 6 ];
+		S7 = sh[ 7 ];
+		S8 = sh[ 8 ];
+		S9 = sh[ 9 ];
+		dy0 = sy[ 0 ];
+		dy1 = sy[ 1 ] - ( S0*sy[0] );
+		dy2 = sy[ 2 ] - ( S1*sy[1] );
+		dy3 = sy[ 3 ] - ( S2*sy[2] );
+		dy4 = sy[ 4 ] - ( S3*sy[3] );
+		dy5 = sy[ 5 ] - ( S4*sy[4] );
+		dy6 = sy[ 6 ] - ( S5*sy[5] );
+		dy7 = sy[ 7 ] - ( S6*sy[6] );
+		dy8 = sy[ 8 ] - ( S7*sy[7] );
+		dy9 = sy[ 9 ] - ( S8*sy[8] );
+	}
+	// Set the pointers to the first indexed elements in the respective ndarrays...
+	ix = x.offset;
+	iy = y.offset;
+
+	// Cache references to the input and output ndarray buffers...
+	xbuf = x.data;
+	ybuf = y.data;
+
+	// Iterate over the ndarray dimensions...
+	for ( i9 = 0; i9 < S9; i9++ ) {
+		for ( i8 = 0; i8 < S8; i8++ ) {
+			for ( i7 = 0; i7 < S7; i7++ ) {
+				for ( i6 = 0; i6 < S6; i6++ ) {
+					for ( i5 = 0; i5 < S5; i5++ ) {
+						for ( i4 = 0; i4 < S4; i4++ ) {
+							for ( i3 = 0; i3 < S3; i3++ ) {
+								for ( i2 = 0; i2 < S2; i2++ ) {
+									for ( i1 = 0; i1 < S1; i1++ ) {
+										for ( i0 = 0; i0 < S0; i0++ ) {
+											ybuf[ iy ] = xbuf[ ix ];
+											iy += dy0;
+										}
+										iy += dy1;
+									}
+									iy += dy2;
+								}
+								iy += dy3;
+							}
+							iy += dy4;
+						}
+						iy += dy5;
+					}
+					iy += dy6;
+				}
+				iy += dy7;
+			}
+			iy += dy8;
+		}
+		iy += dy9;
+	}
+}
+
+
+// EXPORTS //
+
+module.exports = assign10d;
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/10d_accessors.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/10d_accessors.js
new file mode 100644
index 000000000000..08c0b2b8fd23
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/10d_accessors.js
@@ -0,0 +1,248 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2026 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-depth, max-statements */
+
+'use strict';
+
+// MAIN //
+
+/**
+* Assigns a scalar value to every element of a ten-dimensional output ndarray.
+*
+* @private
+* @param {Object} x - object containing input ndarray meta data
+* @param {*} x.dtype - data type
+* @param {Collection} x.data - data buffer
+* @param {NonNegativeIntegerArray} x.shape - dimensions
+* @param {IntegerArray} x.strides - stride lengths
+* @param {NonNegativeInteger} x.offset - index offset
+* @param {string} x.order - specifies whether `x` is row-major (C-style) or column-major (Fortran-style)
+* @param {Array<Function>} x.accessors - data buffer accessors
+* @param {Object} y - object containing output ndarray meta data
+* @param {*} y.dtype - data type
+* @param {Collection} y.data - data buffer
+* @param {NonNegativeIntegerArray} y.shape - dimensions
+* @param {IntegerArray} y.strides - stride lengths
+* @param {NonNegativeInteger} y.offset - index offset
+* @param {string} y.order - specifies whether `y` is row-major (C-style) or column-major (Fortran-style)
+* @param {Array<Function>} y.accessors - data buffer accessors
+* @param {boolean} isRowMajor - boolean indicating if provided arrays are in row-major order
+* @returns {void}
+*
+* @example
+* var Complex64Array = require( '@stdlib/array/complex64' );
+* var Complex64 = require( '@stdlib/complex/float32/ctor' );
+* var realf = require( '@stdlib/complex/float32/real' );
+* var imagf = require( '@stdlib/complex/float32/imag' );
+*
+* // Create data buffers:
+* var xbuf = new Complex64Array( [ 2.0, 2.0 ] );
+* var ybuf = new Complex64Array( 6 );
+*
+* // Define the shape of the output array:
+* var shape = [ 1, 1, 1, 1, 1, 1, 1, 3, 1, 2 ];
+*
+* // Define the array strides:
+* var sx = [ 0 ];
+* var sy = [ 2, 2, 2, 2, 2, 2, 2, 2, 2, 1 ];
+*
+* // Define the index offsets:
+* var ox = 0;
+* var oy = 0;
+*
+* // Define getters and setters:
+* function getter( buf, idx ) {
+*     return buf.get( idx );
+* }
+*
+* function setter( buf, idx, value ) {
+*     buf.set( value, idx );
+* }
+*
+* // Create the input and output ndarray-like objects:
+* var x = {
+*     'dtype': 'complex64',
+*     'data': xbuf,
+*     'shape': [],
+*     'strides': sx,
+*     'offset': ox,
+*     'order': 'row-major',
+*     'accessors': [ getter, setter ]
+* };
+* var y = {
+*     'dtype': 'complex64',
+*     'data': ybuf,
+*     'shape': shape,
+*     'strides': sy,
+*     'offset': oy,
+*     'order': 'row-major',
+*     'accessors': [ getter, setter ]
+* };
+*
+* // Assign scalar:
+* assign10d( x, y, true );
+*
+* var v = y.data.get( 0 );
+*
+* var re = realf( v );
+* // returns 2.0
+*
+* var im = imagf( v );
+* // returns 2.0
+*/
+function assign10d( x, y, isRowMajor ) {
+	var xbuf;
+	var ybuf;
+	var get;
+	var set;
+	var dy0;
+	var dy1;
+	var dy2;
+	var dy3;
+	var dy4;
+	var dy5;
+	var dy6;
+	var dy7;
+	var dy8;
+	var dy9;
+	var sh;
+	var S0;
+	var S1;
+	var S2;
+	var S3;
+	var S4;
+	var S5;
+	var S6;
+	var S7;
+	var S8;
+	var S9;
+	var sy;
+	var ix;
+	var iy;
+	var i0;
+	var i1;
+	var i2;
+	var i3;
+	var i4;
+	var i5;
+	var i6;
+	var i7;
+	var i8;
+	var i9;
+
+	// Note on variable naming convention: S#, dy#, i# where # corresponds to the loop number, with `0` being the innermost loop...
+
+	// Extract loop variables for purposes of loop interchange: dimensions and loop offset (pointer) increments...
+	sh = y.shape;
+	sy = y.strides;
+	if ( isRowMajor ) {
+		// For row-major ndarrays, the last dimensions have the fastest changing indices...
+		S0 = sh[ 9 ];
+		S1 = sh[ 8 ];
+		S2 = sh[ 7 ];
+		S3 = sh[ 6 ];
+		S4 = sh[ 5 ];
+		S5 = sh[ 4 ];
+		S6 = sh[ 3 ];
+		S7 = sh[ 2 ];
+		S8 = sh[ 1 ];
+		S9 = sh[ 0 ];
+		dy0 = sy[ 9 ];
+		dy1 = sy[ 8 ] - ( S0*sy[9] );
+		dy2 = sy[ 7 ] - ( S1*sy[8] );
+		dy3 = sy[ 6 ] - ( S2*sy[7] );
+		dy4 = sy[ 5 ] - ( S3*sy[6] );
+		dy5 = sy[ 4 ] - ( S4*sy[5] );
+		dy6 = sy[ 3 ] - ( S5*sy[4] );
+		dy7 = sy[ 2 ] - ( S6*sy[3] );
+		dy8 = sy[ 1 ] - ( S7*sy[2] );
+		dy9 = sy[ 0 ] - ( S8*sy[1] );
+	} else { // order === 'column-major'
+		// For column-major ndarrays, the first dimensions have the fastest changing indices...
+		S0 = sh[ 0 ];
+		S1 = sh[ 1 ];
+		S2 = sh[ 2 ];
+		S3 = sh[ 3 ];
+		S4 = sh[ 4 ];
+		S5 = sh[ 5 ];
+		S6 = sh[ 6 ];
+		S7 = sh[ 7 ];
+		S8 = sh[ 8 ];
+		S9 = sh[ 9 ];
+		dy0 = sy[ 0 ];
+		dy1 = sy[ 1 ] - ( S0*sy[0] );
+		dy2 = sy[ 2 ] - ( S1*sy[1] );
+		dy3 = sy[ 3 ] - ( S2*sy[2] );
+		dy4 = sy[ 4 ] - ( S3*sy[3] );
+		dy5 = sy[ 5 ] - ( S4*sy[4] );
+		dy6 = sy[ 6 ] - ( S5*sy[5] );
+		dy7 = sy[ 7 ] - ( S6*sy[6] );
+		dy8 = sy[ 8 ] - ( S7*sy[7] );
+		dy9 = sy[ 9 ] - ( S8*sy[8] );
+	}
+	// Set the pointers to the first indexed elements in the respective ndarrays...
+	ix = x.offset;
+	iy = y.offset;
+
+	// Cache references to the input and output ndarray buffers...
+	xbuf = x.data;
+	ybuf = y.data;
+
+	// Cache accessors:
+	get = x.accessors[0];
+	set = y.accessors[1];
+
+	// Iterate over the ndarray dimensions...
+	for ( i9 = 0; i9 < S9; i9++ ) {
+		for ( i8 = 0; i8 < S8; i8++ ) {
+			for ( i7 = 0; i7 < S7; i7++ ) {
+				for ( i6 = 0; i6 < S6; i6++ ) {
+					for ( i5 = 0; i5 < S5; i5++ ) {
+						for ( i4 = 0; i4 < S4; i4++ ) {
+							for ( i3 = 0; i3 < S3; i3++ ) {
+								for ( i2 = 0; i2 < S2; i2++ ) {
+									for ( i1 = 0; i1 < S1; i1++ ) {
+										for ( i0 = 0; i0 < S0; i0++ ) {
+											set( ybuf, iy, get( xbuf, ix ) );
+											iy += dy0;
+										}
+										iy += dy1;
+									}
+									iy += dy2;
+								}
+								iy += dy3;
+							}
+							iy += dy4;
+						}
+						iy += dy5;
+					}
+					iy += dy6;
+				}
+				iy += dy7;
+			}
+			iy += dy8;
+		}
+		iy += dy9;
+	}
+}
+
+
+// EXPORTS //
+
+module.exports = assign10d;
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/10d_blocked.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/10d_blocked.js
new file mode 100644
index 000000000000..762cf1dbf04b
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/10d_blocked.js
@@ -0,0 +1,325 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2026 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-depth, max-len */
+
+'use strict';
+
+// MODULES //
+
+var loopOrder = require( '@stdlib/ndarray/base/nullary-loop-interchange-order' );
+var blockSize = require( '@stdlib/ndarray/base/nullary-tiling-block-size' );
+
+
+// MAIN //
+
+/**
+* Assigns a scalar value to every element of a ten-dimensional output ndarray via loop blocking.
+*
+* @private
+* @param {Object} x - object containing input ndarray meta data
+* @param {*} x.dtype - data type
+* @param {Collection} x.data - data buffer
+* @param {NonNegativeIntegerArray} x.shape - dimensions
+* @param {IntegerArray} x.strides - stride lengths
+* @param {NonNegativeInteger} x.offset - index offset
+* @param {string} x.order - specifies whether `x` is row-major (C-style) or column-major (Fortran-style)
+* @param {Object} y - object containing output ndarray meta data
+* @param {*} y.dtype - data type
+* @param {Collection} y.data - data buffer
+* @param {NonNegativeIntegerArray} y.shape - dimensions
+* @param {IntegerArray} y.strides - stride lengths
+* @param {NonNegativeInteger} y.offset - index offset
+* @param {string} y.order - specifies whether `y` is row-major (C-style) or column-major (Fortran-style)
+* @returns {void}
+*
+* @example
+* var Float64Array = require( '@stdlib/array/float64' );
+*
+* // Create data buffers:
+* var xbuf = new Float64Array( [ 2.0 ] );
+* var ybuf = new Float64Array( 6 );
+*
+* // Define the shape of the output array:
+* var shape = [ 1, 1, 1, 1, 1, 1, 1, 3, 1, 2 ];
+*
+* // Define the array strides:
+* var sx = [ 0 ];
+* var sy = [ 2, 2, 2, 2, 2, 2, 2, 2, 2, 1 ];
+*
+* // Define the index offsets:
+* var ox = 0;
+* var oy = 0;
+*
+* // Create the input and output ndarray-like objects:
+* var x = {
+*     'dtype': 'float64',
+*     'data': xbuf,
+*     'shape': [],
+*     'strides': sx,
+*     'offset': ox,
+*     'order': 'row-major'
+* };
+* var y = {
+*     'dtype': 'float64',
+*     'data': ybuf,
+*     'shape': shape,
+*     'strides': sy,
+*     'offset': oy,
+*     'order': 'row-major'
+* };
+*
+* // Assign scalar:
+* blockedassign10d( x, y );
+*
+* console.log( y.data );
+* // => <Float64Array>[ 2.0, 2.0, 2.0, 2.0, 2.0, 2.0 ]
+*/
+function blockedassign10d( x, y ) { // eslint-disable-line max-statements, max-lines-per-function
+	var bsize;
+	var xbuf;
+	var ybuf;
+	var dy0;
+	var dy1;
+	var dy2;
+	var dy3;
+	var dy4;
+	var dy5;
+	var dy6;
+	var dy7;
+	var dy8;
+	var dy9;
+	var oy1;
+	var oy2;
+	var oy3;
+	var oy4;
+	var oy5;
+	var oy6;
+	var oy7;
+	var oy8;
+	var oy9;
+	var sh;
+	var s0;
+	var s1;
+	var s2;
+	var s3;
+	var s4;
+	var s5;
+	var s6;
+	var s7;
+	var s8;
+	var s9;
+	var sy;
+	var oy;
+	var ix;
+	var iy;
+	var i0;
+	var i1;
+	var i2;
+	var i3;
+	var i4;
+	var i5;
+	var i6;
+	var i7;
+	var i8;
+	var i9;
+	var j0;
+	var j1;
+	var j2;
+	var j3;
+	var j4;
+	var j5;
+	var j6;
+	var j7;
+	var j8;
+	var j9;
+	var o;
+
+	// Note on variable naming convention: s#, dy#, i#, j# where # corresponds to the loop number, with `0` being the innermost loop...
+
+	// Resolve the loop interchange order:
+	o = loopOrder( y.shape, y.strides );
+	sh = o.sh;
+	sy = o.sx;
+
+	// Determine the block size:
+	bsize = blockSize( y.dtype );
+
+	// Cache the indices of the first indexed elements in the respective ndarrays...
+	ix = x.offset;
+	oy = y.offset;
+
+	// Cache references to the input and output ndarray buffers...
+	xbuf = x.data;
+	ybuf = y.data;
+
+	// Cache the offset increment for the innermost loop...
+	dy0 = sy[0];
+
+	// Iterate over blocks...
+	for ( j9 = sh[9]; j9 > 0; ) {
+		if ( j9 < bsize ) {
+			s9 = j9;
+			j9 = 0;
+		} else {
+			s9 = bsize;
+			j9 -= bsize;
+		}
+		oy9 = oy + ( j9*sy[9] );
+		for ( j8 = sh[8]; j8 > 0; ) {
+			if ( j8 < bsize ) {
+				s8 = j8;
+				j8 = 0;
+			} else {
+				s8 = bsize;
+				j8 -= bsize;
+			}
+			dy9 = sy[9] - ( s8*sy[8] );
+			oy8 = oy9 + ( j8*sy[8] );
+			for ( j7 = sh[7]; j7 > 0; ) {
+				if ( j7 < bsize ) {
+					s7 = j7;
+					j7 = 0;
+				} else {
+					s7 = bsize;
+					j7 -= bsize;
+				}
+				dy8 = sy[8] - ( s7*sy[7] );
+				oy7 = oy8 + ( j7*sy[7] );
+				for ( j6 = sh[6]; j6 > 0; ) {
+					if ( j6 < bsize ) {
+						s6 = j6;
+						j6 = 0;
+					} else {
+						s6 = bsize;
+						j6 -= bsize;
+					}
+					dy7 = sy[7] - ( s6*sy[6] );
+					oy6 = oy7 + ( j6*sy[6] );
+					for ( j5 = sh[5]; j5 > 0; ) {
+						if ( j5 < bsize ) {
+							s5 = j5;
+							j5 = 0;
+						} else {
+							s5 = bsize;
+							j5 -= bsize;
+						}
+						dy6 = sy[6] - ( s5*sy[5] );
+						oy5 = oy6 + ( j5*sy[5] );
+						for ( j4 = sh[4]; j4 > 0; ) {
+							if ( j4 < bsize ) {
+								s4 = j4;
+								j4 = 0;
+							} else {
+								s4 = bsize;
+								j4 -= bsize;
+							}
+							dy5 = sy[5] - ( s4*sy[4] );
+							oy4 = oy5 + ( j4*sy[4] );
+							for ( j3 = sh[3]; j3 > 0; ) {
+								if ( j3 < bsize ) {
+									s3 = j3;
+									j3 = 0;
+								} else {
+									s3 = bsize;
+									j3 -= bsize;
+								}
+								dy4 = sy[4] - ( s3*sy[3] );
+								oy3 = oy4 + ( j3*sy[3] );
+								for ( j2 = sh[2]; j2 > 0; ) {
+									if ( j2 < bsize ) {
+										s2 = j2;
+										j2 = 0;
+									} else {
+										s2 = bsize;
+										j2 -= bsize;
+									}
+									dy3 = sy[3] - ( s2*sy[2] );
+									oy2 = oy3 + ( j2*sy[2] );
+									for ( j1 = sh[1]; j1 > 0; ) {
+										if ( j1 < bsize ) {
+											s1 = j1;
+											j1 = 0;
+										} else {
+											s1 = bsize;
+											j1 -= bsize;
+										}
+										dy2 = sy[2] - ( s1*sy[1] );
+										oy1 = oy2 + ( j1*sy[1] );
+										for ( j0 = sh[0]; j0 > 0; ) {
+											if ( j0 < bsize ) {
+												s0 = j0;
+												j0 = 0;
+											} else {
+												s0 = bsize;
+												j0 -= bsize;
+											}
+											// Compute the index offset for the first output ndarray element in the current block...
+											iy = oy1 + ( j0*sy[0] );
+
+											// Compute the loop offset increment...
+											dy1 = sy[1] - ( s0*sy[0] );
+
+											// Iterate over the ndarray dimensions...
+											for ( i9 = 0; i9 < s9; i9++ ) {
+												for ( i8 = 0; i8 < s8; i8++ ) {
+													for ( i7 = 0; i7 < s7; i7++ ) {
+														for ( i6 = 0; i6 < s6; i6++ ) {
+															for ( i5 = 0; i5 < s5; i5++ ) {
+																for ( i4 = 0; i4 < s4; i4++ ) {
+																	for ( i3 = 0; i3 < s3; i3++ ) {
+																		for ( i2 = 0; i2 < s2; i2++ ) {
+																			for ( i1 = 0; i1 < s1; i1++ ) {
+																				for ( i0 = 0; i0 < s0; i0++ ) {
+																					ybuf[ iy ] = xbuf[ ix ];
+																					iy += dy0;
+																				}
+																				iy += dy1;
+																			}
+																			iy += dy2;
+																		}
+																		iy += dy3;
+																	}
+																	iy += dy4;
+																}
+																iy += dy5;
+															}
+															iy += dy6;
+														}
+														iy += dy7;
+													}
+													iy += dy8;
+												}
+												iy += dy9;
+											}
+										}
+									}
+								}
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+}
+
+
+// EXPORTS //
+
+module.exports = blockedassign10d;
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/10d_blocked_accessors.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/10d_blocked_accessors.js
new file mode 100644
index 000000000000..1b756ff47051
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/10d_blocked_accessors.js
@@ -0,0 +1,352 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2026 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-depth, max-len */
+
+'use strict';
+
+// MODULES //
+
+var loopOrder = require( '@stdlib/ndarray/base/nullary-loop-interchange-order' );
+var blockSize = require( '@stdlib/ndarray/base/nullary-tiling-block-size' );
+
+
+// MAIN //
+
+/**
+* Assigns a scalar value to every element of a ten-dimensional output ndarray via loop blocking.
+*
+* @private
+* @param {Object} x - object containing input ndarray meta data
+* @param {*} x.dtype - data type
+* @param {Collection} x.data - data buffer
+* @param {NonNegativeIntegerArray} x.shape - dimensions
+* @param {IntegerArray} x.strides - stride lengths
+* @param {NonNegativeInteger} x.offset - index offset
+* @param {string} x.order - specifies whether `x` is row-major (C-style) or column-major (Fortran-style)
+* @param {Array<Function>} x.accessors - data buffer accessors
+* @param {Object} y - object containing output ndarray meta data
+* @param {*} y.dtype - data type
+* @param {Collection} y.data - data buffer
+* @param {NonNegativeIntegerArray} y.shape - dimensions
+* @param {IntegerArray} y.strides - stride lengths
+* @param {NonNegativeInteger} y.offset - index offset
+* @param {string} y.order - specifies whether `y` is row-major (C-style) or column-major (Fortran-style)
+* @param {Array<Function>} y.accessors - data buffer accessors
+* @returns {void}
+*
+* @example
+* var Complex64Array = require( '@stdlib/array/complex64' );
+* var Complex64 = require( '@stdlib/complex/float32/ctor' );
+* var realf = require( '@stdlib/complex/float32/real' );
+* var imagf = require( '@stdlib/complex/float32/imag' );
+*
+* // Create data buffers:
+* var xbuf = new Complex64Array( [ 2.0, 2.0 ] );
+* var ybuf = new Complex64Array( 6 );
+*
+* // Define the shape of the output array:
+* var shape = [ 1, 1, 1, 1, 1, 1, 1, 3, 1, 2 ];
+*
+* // Define the array strides:
+* var sx = [ 0 ];
+* var sy = [ 2, 2, 2, 2, 2, 2, 2, 2, 2, 1 ];
+*
+* // Define the index offsets:
+* var ox = 0;
+* var oy = 0;
+*
+* // Define getters and setters:
+* function getter( buf, idx ) {
+*     return buf.get( idx );
+* }
+*
+* function setter( buf, idx, value ) {
+*     buf.set( value, idx );
+* }
+*
+* // Create the input and output ndarray-like objects:
+* var x = {
+*     'dtype': 'complex64',
+*     'data': xbuf,
+*     'shape': [],
+*     'strides': sx,
+*     'offset': ox,
+*     'order': 'row-major',
+*     'accessors': [ getter, setter ]
+* };
+* var y = {
+*     'dtype': 'complex64',
+*     'data': ybuf,
+*     'shape': shape,
+*     'strides': sy,
+*     'offset': oy,
+*     'order': 'row-major',
+*     'accessors': [ getter, setter ]
+* };
+*
+* // Assign scalar:
+* blockedassign10d( x, y );
+*
+* var v = y.data.get( 0 );
+*
+* var re = realf( v );
+* // returns 2.0
+*
+* var im = imagf( v );
+* // returns 2.0
+*/
+function blockedassign10d( x, y ) { // eslint-disable-line max-statements, max-lines-per-function
+	var bsize;
+	var xbuf;
+	var ybuf;
+	var get;
+	var set;
+	var dy0;
+	var dy1;
+	var dy2;
+	var dy3;
+	var dy4;
+	var dy5;
+	var dy6;
+	var dy7;
+	var dy8;
+	var dy9;
+	var oy1;
+	var oy2;
+	var oy3;
+	var oy4;
+	var oy5;
+	var oy6;
+	var oy7;
+	var oy8;
+	var oy9;
+	var sh;
+	var s0;
+	var s1;
+	var s2;
+	var s3;
+	var s4;
+	var s5;
+	var s6;
+	var s7;
+	var s8;
+	var s9;
+	var sy;
+	var oy;
+	var ix;
+	var iy;
+	var i0;
+	var i1;
+	var i2;
+	var i3;
+	var i4;
+	var i5;
+	var i6;
+	var i7;
+	var i8;
+	var i9;
+	var j0;
+	var j1;
+	var j2;
+	var j3;
+	var j4;
+	var j5;
+	var j6;
+	var j7;
+	var j8;
+	var j9;
+	var o;
+
+	// Note on variable naming convention: s#, dy#, i#, j# where # corresponds to the loop number, with `0` being the innermost loop...
+
+	// Resolve the loop interchange order:
+	o = loopOrder( y.shape, y.strides );
+	sh = o.sh;
+	sy = o.sx;
+
+	// Determine the block size:
+	bsize = blockSize( y.dtype );
+
+	// Cache the indices of the first indexed elements in the respective ndarrays...
+	ix = x.offset;
+	oy = y.offset;
+
+	// Cache references to the input and output ndarray buffers...
+	xbuf = x.data;
+	ybuf = y.data;
+
+	// Cache the offset increment for the innermost loop...
+	dy0 = sy[0];
+
+	// Cache accessors:
+	get = x.accessors[0];
+	set = y.accessors[1];
+
+	// Iterate over blocks...
+	for ( j9 = sh[9]; j9 > 0; ) {
+		if ( j9 < bsize ) {
+			s9 = j9;
+			j9 = 0;
+		} else {
+			s9 = bsize;
+			j9 -= bsize;
+		}
+		oy9 = oy + ( j9*sy[9] );
+		for ( j8 = sh[8]; j8 > 0; ) {
+			if ( j8 < bsize ) {
+				s8 = j8;
+				j8 = 0;
+			} else {
+				s8 = bsize;
+				j8 -= bsize;
+			}
+			dy9 = sy[9] - ( s8*sy[8] );
+			oy8 = oy9 + ( j8*sy[8] );
+			for ( j7 = sh[7]; j7 > 0; ) {
+				if ( j7 < bsize ) {
+					s7 = j7;
+					j7 = 0;
+				} else {
+					s7 = bsize;
+					j7 -= bsize;
+				}
+				dy8 = sy[8] - ( s7*sy[7] );
+				oy7 = oy8 + ( j7*sy[7] );
+				for ( j6 = sh[6]; j6 > 0; ) {
+					if ( j6 < bsize ) {
+						s6 = j6;
+						j6 = 0;
+					} else {
+						s6 = bsize;
+						j6 -= bsize;
+					}
+					dy7 = sy[7] - ( s6*sy[6] );
+					oy6 = oy7 + ( j6*sy[6] );
+					for ( j5 = sh[5]; j5 > 0; ) {
+						if ( j5 < bsize ) {
+							s5 = j5;
+							j5 = 0;
+						} else {
+							s5 = bsize;
+							j5 -= bsize;
+						}
+						dy6 = sy[6] - ( s5*sy[5] );
+						oy5 = oy6 + ( j5*sy[5] );
+						for ( j4 = sh[4]; j4 > 0; ) {
+							if ( j4 < bsize ) {
+								s4 = j4;
+								j4 = 0;
+							} else {
+								s4 = bsize;
+								j4 -= bsize;
+							}
+							dy5 = sy[5] - ( s4*sy[4] );
+							oy4 = oy5 + ( j4*sy[4] );
+							for ( j3 = sh[3]; j3 > 0; ) {
+								if ( j3 < bsize ) {
+									s3 = j3;
+									j3 = 0;
+								} else {
+									s3 = bsize;
+									j3 -= bsize;
+								}
+								dy4 = sy[4] - ( s3*sy[3] );
+								oy3 = oy4 + ( j3*sy[3] );
+								for ( j2 = sh[2]; j2 > 0; ) {
+									if ( j2 < bsize ) {
+										s2 = j2;
+										j2 = 0;
+									} else {
+										s2 = bsize;
+										j2 -= bsize;
+									}
+									dy3 = sy[3] - ( s2*sy[2] );
+									oy2 = oy3 + ( j2*sy[2] );
+									for ( j1 = sh[1]; j1 > 0; ) {
+										if ( j1 < bsize ) {
+											s1 = j1;
+											j1 = 0;
+										} else {
+											s1 = bsize;
+											j1 -= bsize;
+										}
+										dy2 = sy[2] - ( s1*sy[1] );
+										oy1 = oy2 + ( j1*sy[1] );
+										for ( j0 = sh[0]; j0 > 0; ) {
+											if ( j0 < bsize ) {
+												s0 = j0;
+												j0 = 0;
+											} else {
+												s0 = bsize;
+												j0 -= bsize;
+											}
+											// Compute the index offset for the first output ndarray element in the current block...
+											iy = oy1 + ( j0*sy[0] );
+
+											// Compute the loop offset increment...
+											dy1 = sy[1] - ( s0*sy[0] );
+
+											// Iterate over the ndarray dimensions...
+											for ( i9 = 0; i9 < s9; i9++ ) {
+												for ( i8 = 0; i8 < s8; i8++ ) {
+													for ( i7 = 0; i7 < s7; i7++ ) {
+														for ( i6 = 0; i6 < s6; i6++ ) {
+															for ( i5 = 0; i5 < s5; i5++ ) {
+																for ( i4 = 0; i4 < s4; i4++ ) {
+																	for ( i3 = 0; i3 < s3; i3++ ) {
+																		for ( i2 = 0; i2 < s2; i2++ ) {
+																			for ( i1 = 0; i1 < s1; i1++ ) {
+																				for ( i0 = 0; i0 < s0; i0++ ) {
+																					set( ybuf, iy, get( xbuf, ix ) );
+																					iy += dy0;
+																				}
+																				iy += dy1;
+																			}
+																			iy += dy2;
+																		}
+																		iy += dy3;
+																	}
+																	iy += dy4;
+																}
+																iy += dy5;
+															}
+															iy += dy6;
+														}
+														iy += dy7;
+													}
+													iy += dy8;
+												}
+												iy += dy9;
+											}
+										}
+									}
+								}
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+}
+
+
+// EXPORTS //
+
+module.exports = blockedassign10d;
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/1d.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/1d.js
new file mode 100644
index 000000000000..8666835c8591
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/1d.js
@@ -0,0 +1,118 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2026 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';
+
+// MAIN //
+
+/**
+* Assigns a scalar value to every element of a one-dimensional output ndarray.
+*
+* @private
+* @param {Object} x - object containing input ndarray meta data
+* @param {*} x.dtype - data type
+* @param {Collection} x.data - data buffer
+* @param {NonNegativeIntegerArray} x.shape - dimensions
+* @param {IntegerArray} x.strides - stride lengths
+* @param {NonNegativeInteger} x.offset - index offset
+* @param {string} x.order - specifies whether `x` is row-major (C-style) or column-major (Fortran-style)
+* @param {Object} y - object containing output ndarray meta data
+* @param {*} y.dtype - data type
+* @param {Collection} y.data - data buffer
+* @param {NonNegativeIntegerArray} y.shape - dimensions
+* @param {IntegerArray} y.strides - stride lengths
+* @param {NonNegativeInteger} y.offset - index offset
+* @param {string} y.order - specifies whether `y` is row-major (C-style) or column-major (Fortran-style)
+* @returns {void}
+*
+* @example
+* var Float64Array = require( '@stdlib/array/float64' );
+*
+* // Create data buffers:
+* var xbuf = new Float64Array( [ 2.0 ] );
+* var ybuf = new Float64Array( 6 );
+*
+* // Define the shape of the output array:
+* var shape = [ 6 ];
+*
+* // Define the array strides:
+* var sx = [ 0 ];
+* var sy = [ 1 ];
+*
+* // Define the index offsets:
+* var ox = 0;
+* var oy = 0;
+*
+* // Create the input and output ndarray-like objects:
+* var x = {
+*     'dtype': 'float64',
+*     'data': xbuf,
+*     'shape': [],
+*     'strides': sx,
+*     'offset': ox,
+*     'order': 'row-major'
+* };
+* var y = {
+*     'dtype': 'float64',
+*     'data': ybuf,
+*     'shape': shape,
+*     'strides': sy,
+*     'offset': oy,
+*     'order': 'row-major'
+* };
+*
+* // Assign scalar:
+* assign1d( x, y );
+*
+* console.log( y.data );
+* // => <Float64Array>[ 2.0, 2.0, 2.0, 2.0, 2.0, 2.0 ]
+*/
+function assign1d( x, y ) {
+	var xbuf;
+	var ybuf;
+	var dy0;
+	var S0;
+	var ix;
+	var iy;
+	var i0;
+
+	// Note on variable naming convention: S#, dy#, i# where # corresponds to the loop number, with `0` being the innermost loop...
+
+	// Extract loop variables: dimensions and loop offset (pointer) increments...
+	S0 = y.shape[ 0 ];
+	dy0 = y.strides[ 0 ];
+
+	// Set the pointers to the first indexed elements in the respective ndarrays...
+	ix = x.offset;
+	iy = y.offset;
+
+	// Cache references to the input and output ndarray buffers...
+	xbuf = x.data;
+	ybuf = y.data;
+
+	// Iterate over the ndarray dimensions...
+	for ( i0 = 0; i0 < S0; i0++ ) {
+		ybuf[ iy ] = xbuf[ ix ];
+		iy += dy0;
+	}
+}
+
+
+// EXPORTS //
+
+module.exports = assign1d;
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/1d_accessors.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/1d_accessors.js
new file mode 100644
index 000000000000..f67844523203
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/1d_accessors.js
@@ -0,0 +1,145 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2026 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';
+
+// MAIN //
+
+/**
+* Assigns a scalar value to every element of a one-dimensional output ndarray.
+*
+* @private
+* @param {Object} x - object containing input ndarray meta data
+* @param {*} x.dtype - data type
+* @param {Collection} x.data - data buffer
+* @param {NonNegativeIntegerArray} x.shape - dimensions
+* @param {IntegerArray} x.strides - stride lengths
+* @param {NonNegativeInteger} x.offset - index offset
+* @param {string} x.order - specifies whether `x` is row-major (C-style) or column-major (Fortran-style)
+* @param {Array<Function>} x.accessors - data buffer accessors
+* @param {Object} y - object containing output ndarray meta data
+* @param {*} y.dtype - data type
+* @param {Collection} y.data - data buffer
+* @param {NonNegativeIntegerArray} y.shape - dimensions
+* @param {IntegerArray} y.strides - stride lengths
+* @param {NonNegativeInteger} y.offset - index offset
+* @param {string} y.order - specifies whether `y` is row-major (C-style) or column-major (Fortran-style)
+* @param {Array<Function>} y.accessors - data buffer accessors
+* @returns {void}
+*
+* @example
+* var Complex64Array = require( '@stdlib/array/complex64' );
+* var Complex64 = require( '@stdlib/complex/float32/ctor' );
+* var realf = require( '@stdlib/complex/float32/real' );
+* var imagf = require( '@stdlib/complex/float32/imag' );
+*
+* // Create data buffers:
+* var xbuf = new Complex64Array( [ 1.0, 2.0 ] );
+* var ybuf = new Complex64Array( 4 );
+*
+* // Define the shape of the output array:
+* var shape = [ 4 ];
+*
+* // Define the array strides:
+* var sx = [ 0 ];
+* var sy = [ 1 ];
+*
+* // Define the index offsets:
+* var ox = 0;
+* var oy = 0;
+*
+* // Define getters and setters:
+* function getter( buf, idx ) {
+*     return buf.get( idx );
+* }
+*
+* function setter( buf, idx, value ) {
+*     buf.set( value, idx );
+* }
+*
+* // Create the input and output ndarray-like objects:
+* var x = {
+*     'dtype': 'complex64',
+*     'data': xbuf,
+*     'shape': [],
+*     'strides': sx,
+*     'offset': ox,
+*     'order': 'row-major',
+*     'accessors': [ getter, setter ]
+* };
+* var y = {
+*     'dtype': 'complex64',
+*     'data': ybuf,
+*     'shape': shape,
+*     'strides': sy,
+*     'offset': oy,
+*     'order': 'row-major',
+*     'accessors': [ getter, setter ]
+* };
+*
+* // Assign scalar:
+* assign1d( x, y );
+*
+* var v = y.data.get( 0 );
+*
+* var re = realf( v );
+* // returns 1.0
+*
+* var im = imagf( v );
+* // returns 2.0
+*/
+function assign1d( x, y ) {
+	var xbuf;
+	var ybuf;
+	var get;
+	var set;
+	var dy0;
+	var S0;
+	var ix;
+	var iy;
+	var i0;
+
+	// Note on variable naming convention: S#, dy#, i# where # corresponds to the loop number, with `0` being the innermost loop...
+
+	// Extract loop variables: dimensions and loop offset (pointer) increments...
+	S0 = y.shape[ 0 ];
+	dy0 = y.strides[ 0 ];
+
+	// Set the pointers to the first indexed elements in the respective ndarrays...
+	ix = x.offset;
+	iy = y.offset;
+
+	// Cache references to the input and output ndarray buffers...
+	xbuf = x.data;
+	ybuf = y.data;
+
+	// Cache accessors:
+	get = x.accessors[ 0 ];
+	set = y.accessors[ 1 ];
+
+	// Iterate over the ndarray dimensions...
+	for ( i0 = 0; i0 < S0; i0++ ) {
+		set( ybuf, iy, get( xbuf, ix ) );
+		iy += dy0;
+	}
+}
+
+
+// EXPORTS //
+
+module.exports = assign1d;
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/2d.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/2d.js
new file mode 100644
index 000000000000..585e58d51713
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/2d.js
@@ -0,0 +1,139 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2026 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';
+
+// MAIN //
+
+/**
+* Assigns a scalar value to every element of a two-dimensional output ndarray.
+*
+* @private
+* @param {Object} x - object containing input ndarray meta data
+* @param {*} x.dtype - data type
+* @param {Collection} x.data - data buffer
+* @param {NonNegativeIntegerArray} x.shape - dimensions
+* @param {IntegerArray} x.strides - stride lengths
+* @param {NonNegativeInteger} x.offset - index offset
+* @param {string} x.order - specifies whether `x` is row-major (C-style) or column-major (Fortran-style)
+* @param {Object} y - object containing output ndarray meta data
+* @param {*} y.dtype - data type
+* @param {Collection} y.data - data buffer
+* @param {NonNegativeIntegerArray} y.shape - dimensions
+* @param {IntegerArray} y.strides - stride lengths
+* @param {NonNegativeInteger} y.offset - index offset
+* @param {string} y.order - specifies whether `y` is row-major (C-style) or column-major (Fortran-style)
+* @param {boolean} isRowMajor - boolean indicating if provided arrays are in row-major order
+* @returns {void}
+*
+* @example
+* var Float64Array = require( '@stdlib/array/float64' );
+*
+* // Create data buffers:
+* var xbuf = new Float64Array( [ 2.0 ] );
+* var ybuf = new Float64Array( 6 );
+*
+* // Define the shape of the output array:
+* var shape = [ 3, 2 ];
+*
+* // Define the array strides:
+* var sx = [ 0 ];
+* var sy = [ 2, 1 ];
+*
+* // Define the index offsets:
+* var ox = 0;
+* var oy = 0;
+*
+* // Create the input and output ndarray-like objects:
+* var x = {
+*     'dtype': 'float64',
+*     'data': xbuf,
+*     'shape': [],
+*     'strides': sx,
+*     'offset': ox,
+*     'order': 'row-major'
+* };
+* var y = {
+*     'dtype': 'float64',
+*     'data': ybuf,
+*     'shape': shape,
+*     'strides': sy,
+*     'offset': oy,
+*     'order': 'row-major'
+* };
+*
+* // Assign scalar:
+* assign2d( x, y, true );
+*
+* console.log( y.data );
+* // => <Float64Array>[ 2.0, 2.0, 2.0, 2.0, 2.0, 2.0 ]
+*/
+function assign2d( x, y, isRowMajor ) {
+	var xbuf;
+	var ybuf;
+	var dy0;
+	var dy1;
+	var sh;
+	var S0;
+	var S1;
+	var sy;
+	var ix;
+	var iy;
+	var i0;
+	var i1;
+
+	// Note on variable naming convention: S#, dy#, i# where # corresponds to the loop number, with `0` being the innermost loop...
+
+	// Extract loop variables for purposes of loop interchange: dimensions and loop offset (pointer) increments...
+	sh = y.shape;
+	sy = y.strides;
+	if ( isRowMajor ) {
+		// For row-major ndarrays, the last dimensions have the fastest changing indices...
+		S0 = sh[ 1 ];
+		S1 = sh[ 0 ];
+		dy0 = sy[ 1 ];
+		dy1 = sy[ 0 ] - ( S0*sy[1] );
+	} else { // order === 'column-major'
+		// For column-major ndarrays, the first dimensions have the fastest changing indices...
+		S0 = sh[ 0 ];
+		S1 = sh[ 1 ];
+		dy0 = sy[ 0 ];
+		dy1 = sy[ 1 ] - ( S0*sy[0] );
+	}
+	// Set the pointers to the first indexed elements in the respective ndarrays...
+	ix = x.offset;
+	iy = y.offset;
+
+	// Cache references to the input and output ndarray buffers...
+	xbuf = x.data;
+	ybuf = y.data;
+
+	// Iterate over the ndarray dimensions...
+	for ( i1 = 0; i1 < S1; i1++ ) {
+		for ( i0 = 0; i0 < S0; i0++ ) {
+			ybuf[ iy ] = xbuf[ ix ];
+			iy += dy0;
+		}
+		iy += dy1;
+	}
+}
+
+
+// EXPORTS //
+
+module.exports = assign2d;
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/2d_accessors.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/2d_accessors.js
new file mode 100644
index 000000000000..e9fed639a1f6
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/2d_accessors.js
@@ -0,0 +1,166 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2026 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';
+
+// MAIN //
+
+/**
+* Assigns a scalar value to every element of a two-dimensional output ndarray.
+*
+* @private
+* @param {Object} x - object containing input ndarray meta data
+* @param {*} x.dtype - data type
+* @param {Collection} x.data - data buffer
+* @param {NonNegativeIntegerArray} x.shape - dimensions
+* @param {IntegerArray} x.strides - stride lengths
+* @param {NonNegativeInteger} x.offset - index offset
+* @param {string} x.order - specifies whether `x` is row-major (C-style) or column-major (Fortran-style)
+* @param {Array<Function>} x.accessors - data buffer accessors
+* @param {Object} y - object containing output ndarray meta data
+* @param {*} y.dtype - data type
+* @param {Collection} y.data - data buffer
+* @param {NonNegativeIntegerArray} y.shape - dimensions
+* @param {IntegerArray} y.strides - stride lengths
+* @param {NonNegativeInteger} y.offset - index offset
+* @param {string} y.order - specifies whether `y` is row-major (C-style) or column-major (Fortran-style)
+* @param {Array<Function>} y.accessors - data buffer accessors
+* @param {boolean} isRowMajor - boolean indicating if provided arrays are in row-major order
+* @returns {void}
+*
+* @example
+* var Complex64Array = require( '@stdlib/array/complex64' );
+* var Complex64 = require( '@stdlib/complex/float32/ctor' );
+* var realf = require( '@stdlib/complex/float32/real' );
+* var imagf = require( '@stdlib/complex/float32/imag' );
+*
+* // Create data buffers:
+* var xbuf = new Complex64Array( [ 1.0, 2.0 ] );
+* var ybuf = new Complex64Array( 4 );
+*
+* // Define the shape of the output array:
+* var shape = [ 2, 2 ];
+*
+* // Define the array strides:
+* var sx = [ 0 ];
+* var sy = [ 2, 1 ];
+*
+* // Define the index offsets:
+* var ox = 0;
+* var oy = 0;
+*
+* // Define getters and setters:
+* function getter( buf, idx ) {
+*     return buf.get( idx );
+* }
+*
+* function setter( buf, idx, value ) {
+*     buf.set( value, idx );
+* }
+*
+* // Create the input and output ndarray-like objects:
+* var x = {
+*     'dtype': 'complex64',
+*     'data': xbuf,
+*     'shape': [],
+*     'strides': sx,
+*     'offset': ox,
+*     'order': 'row-major',
+*     'accessors': [ getter, setter ]
+* };
+* var y = {
+*     'dtype': 'complex64',
+*     'data': ybuf,
+*     'shape': shape,
+*     'strides': sy,
+*     'offset': oy,
+*     'order': 'row-major',
+*     'accessors': [ getter, setter ]
+* };
+*
+* // Assign scalar:
+* assign2d( x, y, true );
+*
+* var v = y.data.get( 0 );
+*
+* var re = realf( v );
+* // returns 1.0
+*
+* var im = imagf( v );
+* // returns 2.0
+*/
+function assign2d( x, y, isRowMajor ) {
+	var xbuf;
+	var ybuf;
+	var get;
+	var set;
+	var dy0;
+	var dy1;
+	var sh;
+	var S0;
+	var S1;
+	var sy;
+	var ix;
+	var iy;
+	var i0;
+	var i1;
+
+	// Note on variable naming convention: S#, dy#, i# where # corresponds to the loop number, with `0` being the innermost loop...
+
+	// Extract loop variables for purposes of loop interchange: dimensions and loop offset (pointer) increments...
+	sh = y.shape;
+	sy = y.strides;
+	if ( isRowMajor ) {
+		// For row-major ndarrays, the last dimensions have the fastest changing indices...
+		S0 = sh[ 1 ];
+		S1 = sh[ 0 ];
+		dy0 = sy[ 1 ];
+		dy1 = sy[ 0 ] - ( S0*sy[1] );
+	} else { // order === 'column-major'
+		// For column-major ndarrays, the first dimensions have the fastest changing indices...
+		S0 = sh[ 0 ];
+		S1 = sh[ 1 ];
+		dy0 = sy[ 0 ];
+		dy1 = sy[ 1 ] - ( S0*sy[0] );
+	}
+	// Set the pointers to the first indexed elements in the respective ndarrays...
+	ix = x.offset;
+	iy = y.offset;
+
+	// Cache references to the input and output ndarray buffers...
+	xbuf = x.data;
+	ybuf = y.data;
+
+	// Cache accessors:
+	get = x.accessors[ 0 ];
+	set = y.accessors[ 1 ];
+
+	// Iterate over the ndarray dimensions...
+	for ( i1 = 0; i1 < S1; i1++ ) {
+		for ( i0 = 0; i0 < S0; i0++ ) {
+			set( ybuf, iy, get( xbuf, ix ) );
+			iy += dy0;
+		}
+		iy += dy1;
+	}
+}
+
+
+// EXPORTS //
+
+module.exports = assign2d;
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/2d_blocked.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/2d_blocked.js
new file mode 100644
index 000000000000..3b27f5fe1e71
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/2d_blocked.js
@@ -0,0 +1,171 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2026 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 loopOrder = require( '@stdlib/ndarray/base/nullary-loop-interchange-order' );
+var blockSize = require( '@stdlib/ndarray/base/nullary-tiling-block-size' );
+
+
+// MAIN //
+
+/**
+* Assigns a scalar value to every element of a two-dimensional output ndarray via loop blocking.
+*
+* @private
+* @param {Object} x - object containing input ndarray meta data
+* @param {*} x.dtype - data type
+* @param {Collection} x.data - data buffer
+* @param {NonNegativeIntegerArray} x.shape - dimensions
+* @param {IntegerArray} x.strides - stride lengths
+* @param {NonNegativeInteger} x.offset - index offset
+* @param {string} x.order - specifies whether `x` is row-major (C-style) or column-major (Fortran-style)
+* @param {Object} y - object containing output ndarray meta data
+* @param {*} y.dtype - data type
+* @param {Collection} y.data - data buffer
+* @param {NonNegativeIntegerArray} y.shape - dimensions
+* @param {IntegerArray} y.strides - stride lengths
+* @param {NonNegativeInteger} y.offset - index offset
+* @param {string} y.order - specifies whether `y` is row-major (C-style) or column-major (Fortran-style)
+* @returns {void}
+*
+* @example
+* var Float64Array = require( '@stdlib/array/float64' );
+*
+* // Create data buffers:
+* var xbuf = new Float64Array( [ 2.0 ] );
+* var ybuf = new Float64Array( 6 );
+*
+* // Define the shape of the output array:
+* var shape = [ 3, 2 ];
+*
+* // Define the array strides:
+* var sx = [ 0 ];
+* var sy = [ 2, 1 ];
+*
+* // Define the index offsets:
+* var ox = 0;
+* var oy = 0;
+*
+* // Create the input and output ndarray-like objects:
+* var x = {
+*     'dtype': 'float64',
+*     'data': xbuf,
+*     'shape': [],
+*     'strides': sx,
+*     'offset': ox,
+*     'order': 'row-major'
+* };
+* var y = {
+*     'dtype': 'float64',
+*     'data': ybuf,
+*     'shape': shape,
+*     'strides': sy,
+*     'offset': oy,
+*     'order': 'row-major'
+* };
+*
+* // Assign scalar:
+* blockedassign2d( x, y );
+*
+* console.log( y.data );
+* // => <Float64Array>[ 2.0, 2.0, 2.0, 2.0, 2.0, 2.0 ]
+*/
+function blockedassign2d( x, y ) {
+	var bsize;
+	var xbuf;
+	var ybuf;
+	var dy0;
+	var dy1;
+	var oy1;
+	var sh;
+	var s0;
+	var s1;
+	var sy;
+	var oy;
+	var ix;
+	var iy;
+	var i0;
+	var i1;
+	var j0;
+	var j1;
+	var o;
+
+	// Note on variable naming convention: s#, dy#, i#, j# where # corresponds to the loop number, with `0` being the innermost loop...
+
+	// Resolve the loop interchange order:
+	o = loopOrder( y.shape, y.strides );
+	sh = o.sh;
+	sy = o.sx;
+
+	// Determine the block size:
+	bsize = blockSize( y.dtype );
+
+	// Cache the indices of the first indexed elements in the respective ndarrays...
+	ix = x.offset;
+	oy = y.offset;
+
+	// Cache references to the input and output ndarray buffers...
+	xbuf = x.data;
+	ybuf = y.data;
+
+	// Cache the offset increment for the innermost loop...
+	dy0 = sy[0];
+
+	// Iterate over blocks...
+	for ( j1 = sh[1]; j1 > 0; ) {
+		if ( j1 < bsize ) {
+			s1 = j1;
+			j1 = 0;
+		} else {
+			s1 = bsize;
+			j1 -= bsize;
+		}
+		oy1 = oy + ( j1*sy[1] );
+		for ( j0 = sh[0]; j0 > 0; ) {
+			if ( j0 < bsize ) {
+				s0 = j0;
+				j0 = 0;
+			} else {
+				s0 = bsize;
+				j0 -= bsize;
+			}
+			// Compute the index offset for the first output ndarray element in the current block...
+			iy = oy1 + ( j0*sy[0] );
+
+			// Compute the loop offset increment...
+			dy1 = sy[1] - ( s0*sy[0] );
+
+			// Iterate over the ndarray dimensions...
+			for ( i1 = 0; i1 < s1; i1++ ) {
+				for ( i0 = 0; i0 < s0; i0++ ) {
+					ybuf[ iy ] = xbuf[ ix ];
+					iy += dy0;
+				}
+				iy += dy1;
+			}
+		}
+	}
+}
+
+
+// EXPORTS //
+
+module.exports = blockedassign2d;
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/2d_blocked_accessors.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/2d_blocked_accessors.js
new file mode 100644
index 000000000000..3d80d5ef0049
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/2d_blocked_accessors.js
@@ -0,0 +1,198 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2026 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 loopOrder = require( '@stdlib/ndarray/base/nullary-loop-interchange-order' );
+var blockSize = require( '@stdlib/ndarray/base/nullary-tiling-block-size' );
+
+
+// MAIN //
+
+/**
+* Assigns a scalar value to every element of a two-dimensional output ndarray via loop blocking.
+*
+* @private
+* @param {Object} x - object containing input ndarray meta data
+* @param {*} x.dtype - data type
+* @param {Collection} x.data - data buffer
+* @param {NonNegativeIntegerArray} x.shape - dimensions
+* @param {IntegerArray} x.strides - stride lengths
+* @param {NonNegativeInteger} x.offset - index offset
+* @param {string} x.order - specifies whether `x` is row-major (C-style) or column-major (Fortran-style)
+* @param {Array<Function>} x.accessors - data buffer accessors
+* @param {Object} y - object containing output ndarray meta data
+* @param {*} y.dtype - data type
+* @param {Collection} y.data - data buffer
+* @param {NonNegativeIntegerArray} y.shape - dimensions
+* @param {IntegerArray} y.strides - stride lengths
+* @param {NonNegativeInteger} y.offset - index offset
+* @param {string} y.order - specifies whether `y` is row-major (C-style) or column-major (Fortran-style)
+* @param {Array<Function>} y.accessors - data buffer accessors
+* @returns {void}
+*
+* @example
+* var Complex64Array = require( '@stdlib/array/complex64' );
+* var Complex64 = require( '@stdlib/complex/float32/ctor' );
+* var realf = require( '@stdlib/complex/float32/real' );
+* var imagf = require( '@stdlib/complex/float32/imag' );
+*
+* // Create data buffers:
+* var xbuf = new Complex64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 ] );
+* var ybuf = new Complex64Array( 4 );
+*
+* // Define the shape of the input and output arrays:
+* var shape = [ 2, 2 ];
+*
+* // Define the array strides:
+* var sx = [ 2, 1 ];
+* var sy = [ 2, 1 ];
+*
+* // Define the index offsets:
+* var ox = 0;
+* var oy = 0;
+*
+* // Define getters and setters:
+* function getter( buf, idx ) {
+*     return buf.get( idx );
+* }
+*
+* function setter( buf, idx, value ) {
+*     buf.set( value, idx );
+* }
+*
+* // Create the input and output ndarray-like objects:
+* var x = {
+*     'dtype': 'complex64',
+*     'data': xbuf,
+*     'shape': shape,
+*     'strides': sx,
+*     'offset': ox,
+*     'order': 'row-major',
+*     'accessors': [ getter, setter ]
+* };
+* var y = {
+*     'dtype': 'complex64',
+*     'data': ybuf,
+*     'shape': shape,
+*     'strides': sy,
+*     'offset': oy,
+*     'order': 'row-major',
+*     'accessors': [ getter, setter ]
+* };
+*
+* // Copy elements:
+* blockedassign2d( x, y );
+*
+* var v = y.data.get( 0 );
+*
+* var re = realf( v );
+* // returns 1.0
+*
+* var im = imagf( v );
+* // returns 2.0
+*/
+function blockedassign2d( x, y ) {
+	var bsize;
+	var xbuf;
+	var ybuf;
+	var get;
+	var set;
+	var dy0;
+	var dy1;
+	var oy1;
+	var sh;
+	var s0;
+	var s1;
+	var sy;
+	var oy;
+	var ix;
+	var iy;
+	var i0;
+	var i1;
+	var j0;
+	var j1;
+	var o;
+
+	// Note on variable naming convention: s#, dy#, i#, j# where # corresponds to the loop number, with `0` being the innermost loop...
+
+	// Resolve the loop interchange order:
+	o = loopOrder( y.shape, y.strides );
+	sh = o.sh;
+	sy = o.sx;
+
+	// Determine the block size:
+	bsize = blockSize( y.dtype );
+
+	// Cache the indices of the first indexed elements in the respective ndarrays...
+	ix = x.offset;
+	oy = y.offset;
+
+	// Cache references to the input and output ndarray buffers...
+	xbuf = x.data;
+	ybuf = y.data;
+
+	// Cache the offset increment for the innermost loop...
+	dy0 = sy[0];
+
+	// Cache accessors:
+	get = x.accessors[0];
+	set = y.accessors[1];
+
+	// Iterate over blocks...
+	for ( j1 = sh[1]; j1 > 0; ) {
+		if ( j1 < bsize ) {
+			s1 = j1;
+			j1 = 0;
+		} else {
+			s1 = bsize;
+			j1 -= bsize;
+		}
+		oy1 = oy + ( j1*sy[1] );
+		for ( j0 = sh[0]; j0 > 0; ) {
+			if ( j0 < bsize ) {
+				s0 = j0;
+				j0 = 0;
+			} else {
+				s0 = bsize;
+				j0 -= bsize;
+			}
+			// Compute the index offset for the first output ndarray element in the current block...
+			iy = oy1 + ( j0*sy[0] );
+
+			// Compute the loop offset increment...
+			dy1 = sy[1] - ( s0*sy[0] );
+
+			// Iterate over the ndarray dimensions...
+			for ( i1 = 0; i1 < s1; i1++ ) {
+				for ( i0 = 0; i0 < s0; i0++ ) {
+					set( ybuf, iy, get( xbuf, ix ) );
+					iy += dy0;
+				}
+				iy += dy1;
+			}
+		}
+	}
+}
+
+
+// EXPORTS //
+
+module.exports = blockedassign2d;
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/3d.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/3d.js
new file mode 100644
index 000000000000..50b64e00e4e6
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/3d.js
@@ -0,0 +1,149 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2026 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';
+
+// MAIN //
+
+/**
+* Assigns a scalar value to every element of a three-dimensional output ndarray.
+*
+* @private
+* @param {Object} x - object containing input ndarray meta data
+* @param {*} x.dtype - data type
+* @param {Collection} x.data - data buffer
+* @param {NonNegativeIntegerArray} x.shape - dimensions
+* @param {IntegerArray} x.strides - stride lengths
+* @param {NonNegativeInteger} x.offset - index offset
+* @param {string} x.order - specifies whether `x` is row-major (C-style) or column-major (Fortran-style)
+* @param {Object} y - object containing output ndarray meta data
+* @param {*} y.dtype - data type
+* @param {Collection} y.data - data buffer
+* @param {NonNegativeIntegerArray} y.shape - dimensions
+* @param {IntegerArray} y.strides - stride lengths
+* @param {NonNegativeInteger} y.offset - index offset
+* @param {string} y.order - specifies whether `y` is row-major (C-style) or column-major (Fortran-style)
+* @param {boolean} isRowMajor - boolean indicating if provided arrays are in row-major order
+* @returns {void}
+*
+* @example
+* var Float64Array = require( '@stdlib/array/float64' );
+*
+* // Create data buffers:
+* var xbuf = new Float64Array( [ 2.0 ] );
+* var ybuf = new Float64Array( 6 );
+*
+* // Define the shape of the output array:
+* var shape = [ 3, 1, 2 ];
+*
+* // Define the array strides:
+* var sx = [ 0 ];
+* var sy = [ 2, 2, 1 ];
+*
+* // Define the index offsets:
+* var ox = 0;
+* var oy = 0;
+*
+* // Create the input and output ndarray-like objects:
+* var x = {
+*     'dtype': 'float64',
+*     'data': xbuf,
+*     'shape': [],
+*     'strides': sx,
+*     'offset': ox,
+*     'order': 'row-major'
+* };
+* var y = {
+*     'dtype': 'float64',
+*     'data': ybuf,
+*     'shape': shape,
+*     'strides': sy,
+*     'offset': oy,
+*     'order': 'row-major'
+* };
+*
+* // Assign scalar:
+* assign3d( x, y, true );
+*
+* console.log( y.data );
+* // => <Float64Array>[ 2.0, 2.0, 2.0, 2.0, 2.0, 2.0 ]
+*/
+function assign3d( x, y, isRowMajor ) {
+	var xbuf;
+	var ybuf;
+	var dy0;
+	var dy1;
+	var dy2;
+	var sh;
+	var S0;
+	var S1;
+	var S2;
+	var sy;
+	var ix;
+	var iy;
+	var i0;
+	var i1;
+	var i2;
+
+	// Note on variable naming convention: S#, dy#, i# where # corresponds to the loop number, with `0` being the innermost loop...
+
+	// Extract loop variables for purposes of loop interchange: dimensions and loop offset (pointer) increments...
+	sh = y.shape;
+	sy = y.strides;
+	if ( isRowMajor ) {
+		// For row-major ndarrays, the last dimensions have the fastest changing indices...
+		S0 = sh[ 2 ];
+		S1 = sh[ 1 ];
+		S2 = sh[ 0 ];
+		dy0 = sy[ 2 ];
+		dy1 = sy[ 1 ] - ( S0*sy[2] );
+		dy2 = sy[ 0 ] - ( S1*sy[1] );
+	} else { // order === 'column-major'
+		// For column-major ndarrays, the first dimensions have the fastest changing indices...
+		S0 = sh[ 0 ];
+		S1 = sh[ 1 ];
+		S2 = sh[ 2 ];
+		dy0 = sy[ 0 ];
+		dy1 = sy[ 1 ] - ( S0*sy[0] );
+		dy2 = sy[ 2 ] - ( S1*sy[1] );
+	}
+	// Set the pointers to the first indexed elements in the respective ndarrays...
+	ix = x.offset;
+	iy = y.offset;
+
+	// Cache references to the input and output ndarray buffers...
+	xbuf = x.data;
+	ybuf = y.data;
+
+	// Iterate over the ndarray dimensions...
+	for ( i2 = 0; i2 < S2; i2++ ) {
+		for ( i1 = 0; i1 < S1; i1++ ) {
+			for ( i0 = 0; i0 < S0; i0++ ) {
+				ybuf[ iy ] = xbuf[ ix ];
+				iy += dy0;
+			}
+			iy += dy1;
+		}
+		iy += dy2;
+	}
+}
+
+
+// EXPORTS //
+
+module.exports = assign3d;
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/3d_accessors.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/3d_accessors.js
new file mode 100644
index 000000000000..1157a487bb92
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/3d_accessors.js
@@ -0,0 +1,176 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2026 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';
+
+// MAIN //
+
+/**
+* Assigns a scalar value to every element of a three-dimensional output ndarray.
+*
+* @private
+* @param {Object} x - object containing input ndarray meta data
+* @param {*} x.dtype - data type
+* @param {Collection} x.data - data buffer
+* @param {NonNegativeIntegerArray} x.shape - dimensions
+* @param {IntegerArray} x.strides - stride lengths
+* @param {NonNegativeInteger} x.offset - index offset
+* @param {string} x.order - specifies whether `x` is row-major (C-style) or column-major (Fortran-style)
+* @param {Array<Function>} x.accessors - data buffer accessors
+* @param {Object} y - object containing output ndarray meta data
+* @param {*} y.dtype - data type
+* @param {Collection} y.data - data buffer
+* @param {NonNegativeIntegerArray} y.shape - dimensions
+* @param {IntegerArray} y.strides - stride lengths
+* @param {NonNegativeInteger} y.offset - index offset
+* @param {string} y.order - specifies whether `y` is row-major (C-style) or column-major (Fortran-style)
+* @param {Array<Function>} y.accessors - data buffer accessors
+* @param {boolean} isRowMajor - boolean indicating if provided arrays are in row-major order
+* @returns {void}
+*
+* @example
+* var Complex64Array = require( '@stdlib/array/complex64' );
+* var Complex64 = require( '@stdlib/complex/float32/ctor' );
+* var realf = require( '@stdlib/complex/float32/real' );
+* var imagf = require( '@stdlib/complex/float32/imag' );
+*
+* // Create data buffers:
+* var xbuf = new Complex64Array( [ 2.0, 2.0 ] );
+* var ybuf = new Complex64Array( 6 );
+*
+* // Define the shape of the output array:
+* var shape = [ 3, 1, 2 ];
+*
+* // Define the array strides:
+* var sx = [ 0 ];
+* var sy = [ 2, 2, 1 ];
+*
+* // Define the index offsets:
+* var ox = 0;
+* var oy = 0;
+*
+* // Define getters and setters:
+* function getter( buf, idx ) {
+*     return buf.get( idx );
+* }
+*
+* function setter( buf, idx, value ) {
+*     buf.set( value, idx );
+* }
+*
+* // Create the input and output ndarray-like objects:
+* var x = {
+*     'dtype': 'complex64',
+*     'data': xbuf,
+*     'shape': [],
+*     'strides': sx,
+*     'offset': ox,
+*     'order': 'row-major',
+*     'accessors': [ getter, setter ]
+* };
+* var y = {
+*     'dtype': 'complex64',
+*     'data': ybuf,
+*     'shape': shape,
+*     'strides': sy,
+*     'offset': oy,
+*     'order': 'row-major',
+*     'accessors': [ getter, setter ]
+* };
+*
+* // Assign scalar:
+* assign3d( x, y, true );
+*
+* var v = y.data.get( 0 );
+*
+* var re = realf( v );
+* // returns 2.0
+*
+* var im = imagf( v );
+* // returns 2.0
+*/
+function assign3d( x, y, isRowMajor ) {
+	var xbuf;
+	var ybuf;
+	var get;
+	var set;
+	var dy0;
+	var dy1;
+	var dy2;
+	var sh;
+	var S0;
+	var S1;
+	var S2;
+	var sy;
+	var ix;
+	var iy;
+	var i0;
+	var i1;
+	var i2;
+
+	// Note on variable naming convention: S#, dy#, i# where # corresponds to the loop number, with `0` being the innermost loop...
+
+	// Extract loop variables for purposes of loop interchange: dimensions and loop offset (pointer) increments...
+	sh = y.shape;
+	sy = y.strides;
+	if ( isRowMajor ) {
+		// For row-major ndarrays, the last dimensions have the fastest changing indices...
+		S0 = sh[ 2 ];
+		S1 = sh[ 1 ];
+		S2 = sh[ 0 ];
+		dy0 = sy[ 2 ];
+		dy1 = sy[ 1 ] - ( S0*sy[2] );
+		dy2 = sy[ 0 ] - ( S1*sy[1] );
+	} else { // order === 'column-major'
+		// For column-major ndarrays, the first dimensions have the fastest changing indices...
+		S0 = sh[ 0 ];
+		S1 = sh[ 1 ];
+		S2 = sh[ 2 ];
+		dy0 = sy[ 0 ];
+		dy1 = sy[ 1 ] - ( S0*sy[0] );
+		dy2 = sy[ 2 ] - ( S1*sy[1] );
+	}
+	// Set the pointers to the first indexed elements in the respective ndarrays...
+	ix = x.offset;
+	iy = y.offset;
+
+	// Cache references to the input and output ndarray buffers...
+	xbuf = x.data;
+	ybuf = y.data;
+
+	// Cache accessors:
+	get = x.accessors[ 0 ];
+	set = y.accessors[ 1 ];
+
+	// Iterate over the ndarray dimensions...
+	for ( i2 = 0; i2 < S2; i2++ ) {
+		for ( i1 = 0; i1 < S1; i1++ ) {
+			for ( i0 = 0; i0 < S0; i0++ ) {
+				set( ybuf, iy, get( xbuf, ix ) );
+				iy += dy0;
+			}
+			iy += dy1;
+		}
+		iy += dy2;
+	}
+}
+
+
+// EXPORTS //
+
+module.exports = assign3d;
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/3d_blocked.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/3d_blocked.js
new file mode 100644
index 000000000000..04eda54aa149
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/3d_blocked.js
@@ -0,0 +1,192 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2026 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-depth */
+
+'use strict';
+
+// MODULES //
+
+var loopOrder = require( '@stdlib/ndarray/base/nullary-loop-interchange-order' );
+var blockSize = require( '@stdlib/ndarray/base/nullary-tiling-block-size' );
+
+
+// MAIN //
+
+/**
+* Assigns a scalar value to every element of a three-dimensional output ndarray via loop blocking.
+*
+* @private
+* @param {Object} x - object containing input ndarray meta data
+* @param {*} x.dtype - data type
+* @param {Collection} x.data - data buffer
+* @param {NonNegativeIntegerArray} x.shape - dimensions
+* @param {IntegerArray} x.strides - stride lengths
+* @param {NonNegativeInteger} x.offset - index offset
+* @param {string} x.order - specifies whether `x` is row-major (C-style) or column-major (Fortran-style)
+* @param {Object} y - object containing output ndarray meta data
+* @param {*} y.dtype - data type
+* @param {Collection} y.data - data buffer
+* @param {NonNegativeIntegerArray} y.shape - dimensions
+* @param {IntegerArray} y.strides - stride lengths
+* @param {NonNegativeInteger} y.offset - index offset
+* @param {string} y.order - specifies whether `y` is row-major (C-style) or column-major (Fortran-style)
+* @returns {void}
+*
+* @example
+* var Float64Array = require( '@stdlib/array/float64' );
+*
+* // Create data buffers:
+* var xbuf = new Float64Array( [ 2.0 ] );
+* var ybuf = new Float64Array( 6 );
+*
+* // Define the shape of the output array:
+* var shape = [ 3, 1, 2 ];
+*
+* // Define the array strides:
+* var sx = [ 0 ];
+* var sy = [ 2, 2, 1 ];
+*
+* // Define the index offsets:
+* var ox = 0;
+* var oy = 0;
+*
+* // Create the input and output ndarray-like objects:
+* var x = {
+*     'dtype': 'float64',
+*     'data': xbuf,
+*     'shape': [],
+*     'strides': sx,
+*     'offset': ox,
+*     'order': 'row-major'
+* };
+* var y = {
+*     'dtype': 'float64',
+*     'data': ybuf,
+*     'shape': shape,
+*     'strides': sy,
+*     'offset': oy,
+*     'order': 'row-major'
+* };
+*
+* // Assign scalar:
+* blockedassign3d( x, y );
+*
+* console.log( y.data );
+* // => <Float64Array>[ 2.0, 2.0, 2.0, 2.0, 2.0, 2.0 ]
+*/
+function blockedassign3d( x, y ) {
+	var bsize;
+	var xbuf;
+	var ybuf;
+	var dy0;
+	var dy1;
+	var dy2;
+	var oy1;
+	var oy2;
+	var sh;
+	var s0;
+	var s1;
+	var s2;
+	var sy;
+	var oy;
+	var ix;
+	var iy;
+	var i0;
+	var i1;
+	var i2;
+	var j0;
+	var j1;
+	var j2;
+	var o;
+
+	// Note on variable naming convention: s#, dy#, i#, j# where # corresponds to the loop number, with `0` being the innermost loop...
+
+	// Resolve the loop interchange order:
+	o = loopOrder( y.shape, y.strides );
+	sh = o.sh;
+	sy = o.sx;
+
+	// Determine the block size:
+	bsize = blockSize( y.dtype );
+
+	// Cache the indices of the first indexed elements in the respective ndarrays...
+	ix = x.offset;
+	oy = y.offset;
+
+	// Cache references to the input and output ndarray buffers...
+	xbuf = x.data;
+	ybuf = y.data;
+
+	// Cache the offset increment for the innermost loop...
+	dy0 = sy[0];
+
+	// Iterate over blocks...
+	for ( j2 = sh[2]; j2 > 0; ) {
+		if ( j2 < bsize ) {
+			s2 = j2;
+			j2 = 0;
+		} else {
+			s2 = bsize;
+			j2 -= bsize;
+		}
+		oy2 = oy + ( j2*sy[2] );
+		for ( j1 = sh[1]; j1 > 0; ) {
+			if ( j1 < bsize ) {
+				s1 = j1;
+				j1 = 0;
+			} else {
+				s1 = bsize;
+				j1 -= bsize;
+			}
+			dy2 = sy[2] - ( s1*sy[1] );
+			oy1 = oy2 + ( j1*sy[1] );
+			for ( j0 = sh[0]; j0 > 0; ) {
+				if ( j0 < bsize ) {
+					s0 = j0;
+					j0 = 0;
+				} else {
+					s0 = bsize;
+					j0 -= bsize;
+				}
+				// Compute the index offset for the first output ndarray element in the current block...
+				iy = oy1 + ( j0*sy[0] );
+
+				// Compute the loop offset increment...
+				dy1 = sy[1] - ( s0*sy[0] );
+
+				// Iterate over the ndarray dimensions...
+				for ( i2 = 0; i2 < s2; i2++ ) {
+					for ( i1 = 0; i1 < s1; i1++ ) {
+						for ( i0 = 0; i0 < s0; i0++ ) {
+							ybuf[ iy ] = xbuf[ ix ];
+							iy += dy0;
+						}
+						iy += dy1;
+					}
+					iy += dy2;
+				}
+			}
+		}
+	}
+}
+
+
+// EXPORTS //
+
+module.exports = blockedassign3d;
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/3d_blocked_accessors.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/3d_blocked_accessors.js
new file mode 100644
index 000000000000..9d5dccc1579a
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/3d_blocked_accessors.js
@@ -0,0 +1,219 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2026 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-depth */
+
+'use strict';
+
+// MODULES //
+
+var loopOrder = require( '@stdlib/ndarray/base/nullary-loop-interchange-order' );
+var blockSize = require( '@stdlib/ndarray/base/nullary-tiling-block-size' );
+
+
+// MAIN //
+
+/**
+* Assigns a scalar value to every element of a three-dimensional output ndarray via loop blocking.
+*
+* @private
+* @param {Object} x - object containing input ndarray meta data
+* @param {*} x.dtype - data type
+* @param {Collection} x.data - data buffer
+* @param {NonNegativeIntegerArray} x.shape - dimensions
+* @param {IntegerArray} x.strides - stride lengths
+* @param {NonNegativeInteger} x.offset - index offset
+* @param {string} x.order - specifies whether `x` is row-major (C-style) or column-major (Fortran-style)
+* @param {Array<Function>} x.accessors - data buffer accessors
+* @param {Object} y - object containing output ndarray meta data
+* @param {*} y.dtype - data type
+* @param {Collection} y.data - data buffer
+* @param {NonNegativeIntegerArray} y.shape - dimensions
+* @param {IntegerArray} y.strides - stride lengths
+* @param {NonNegativeInteger} y.offset - index offset
+* @param {string} y.order - specifies whether `y` is row-major (C-style) or column-major (Fortran-style)
+* @param {Array<Function>} y.accessors - data buffer accessors
+* @returns {void}
+*
+* @example
+* var Complex64Array = require( '@stdlib/array/complex64' );
+* var Complex64 = require( '@stdlib/complex/float32/ctor' );
+* var realf = require( '@stdlib/complex/float32/real' );
+* var imagf = require( '@stdlib/complex/float32/imag' );
+*
+* // Create data buffers:
+* var xbuf = new Complex64Array( [ 2.0, 2.0 ] );
+* var ybuf = new Complex64Array( 6 );
+*
+* // Define the shape of the input and output arrays:
+* var shape = [ 3, 1, 2 ];
+*
+* // Define the array strides:
+* var sx = [ 0 ];
+* var sy = [ 2, 2, 1 ];
+*
+* // Define the index offsets:
+* var ox = 0;
+* var oy = 0;
+*
+* // Define getters and setters:
+* function getter( buf, idx ) {
+*     return buf.get( idx );
+* }
+*
+* function setter( buf, idx, value ) {
+*     buf.set( value, idx );
+* }
+*
+* // Create the input and output ndarray-like objects:
+* var x = {
+*     'dtype': 'complex64',
+*     'data': xbuf,
+*     'shape': [],
+*     'strides': sx,
+*     'offset': ox,
+*     'order': 'row-major',
+*     'accessors': [ getter, setter ]
+* };
+* var y = {
+*     'dtype': 'complex64',
+*     'data': ybuf,
+*     'shape': shape,
+*     'strides': sy,
+*     'offset': oy,
+*     'order': 'row-major',
+*     'accessors': [ getter, setter ]
+* };
+*
+* // Copy elements:
+* blockedassign3d( x, y );
+*
+* var v = y.data.get( 0 );
+*
+* var re = realf( v );
+* // returns 2.0
+*
+* var im = imagf( v );
+* // returns 2.0
+*/
+function blockedassign3d( x, y ) {
+	var bsize;
+	var xbuf;
+	var ybuf;
+	var get;
+	var set;
+	var dy0;
+	var dy1;
+	var dy2;
+	var oy1;
+	var oy2;
+	var sh;
+	var s0;
+	var s1;
+	var s2;
+	var sy;
+	var oy;
+	var ix;
+	var iy;
+	var i0;
+	var i1;
+	var i2;
+	var j0;
+	var j1;
+	var j2;
+	var o;
+
+	// Note on variable naming convention: s#, dy#, i#, j# where # corresponds to the loop number, with `0` being the innermost loop...
+
+	// Resolve the loop interchange order:
+	o = loopOrder( y.shape, y.strides );
+	sh = o.sh;
+	sy = o.sx;
+
+	// Determine the block size:
+	bsize = blockSize( y.dtype );
+
+	// Cache the indices of the first indexed elements in the respective ndarrays...
+	ix = x.offset;
+	oy = y.offset;
+
+	// Cache references to the input and output ndarray buffers...
+	xbuf = x.data;
+	ybuf = y.data;
+
+	// Cache the offset increment for the innermost loop...
+	dy0 = sy[0];
+
+	// Cache accessors:
+	get = x.accessors[0];
+	set = y.accessors[1];
+
+	// Iterate over blocks...
+	for ( j2 = sh[2]; j2 > 0; ) {
+		if ( j2 < bsize ) {
+			s2 = j2;
+			j2 = 0;
+		} else {
+			s2 = bsize;
+			j2 -= bsize;
+		}
+		oy2 = oy + ( j2*sy[2] );
+		for ( j1 = sh[1]; j1 > 0; ) {
+			if ( j1 < bsize ) {
+				s1 = j1;
+				j1 = 0;
+			} else {
+				s1 = bsize;
+				j1 -= bsize;
+			}
+			dy2 = sy[2] - ( s1*sy[1] );
+			oy1 = oy2 + ( j1*sy[1] );
+			for ( j0 = sh[0]; j0 > 0; ) {
+				if ( j0 < bsize ) {
+					s0 = j0;
+					j0 = 0;
+				} else {
+					s0 = bsize;
+					j0 -= bsize;
+				}
+				// Compute the index offset for the first output ndarray element in the current block...
+				iy = oy1 + ( j0*sy[0] );
+
+				// Compute the loop offset increment...
+				dy1 = sy[1] - ( s0*sy[0] );
+
+				// Iterate over the ndarray dimensions...
+				for ( i2 = 0; i2 < s2; i2++ ) {
+					for ( i1 = 0; i1 < s1; i1++ ) {
+						for ( i0 = 0; i0 < s0; i0++ ) {
+							set( ybuf, iy, get( xbuf, ix ) );
+							iy += dy0;
+						}
+						iy += dy1;
+					}
+					iy += dy2;
+				}
+			}
+		}
+	}
+}
+
+
+// EXPORTS //
+
+module.exports = blockedassign3d;
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/4d.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/4d.js
new file mode 100644
index 000000000000..60f14a631a8f
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/4d.js
@@ -0,0 +1,159 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2026 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';
+
+// MAIN //
+
+/**
+* Assigns a scalar value to every element of a four-dimensional output ndarray.
+*
+* @private
+* @param {Object} x - object containing input ndarray meta data
+* @param {*} x.dtype - data type
+* @param {Collection} x.data - data buffer
+* @param {NonNegativeIntegerArray} x.shape - dimensions
+* @param {IntegerArray} x.strides - stride lengths
+* @param {NonNegativeInteger} x.offset - index offset
+* @param {string} x.order - specifies whether `x` is row-major (C-style) or column-major (Fortran-style)
+* @param {Object} y - object containing output ndarray meta data
+* @param {*} y.dtype - data type
+* @param {Collection} y.data - data buffer
+* @param {NonNegativeIntegerArray} y.shape - dimensions
+* @param {IntegerArray} y.strides - stride lengths
+* @param {NonNegativeInteger} y.offset - index offset
+* @param {string} y.order - specifies whether `y` is row-major (C-style) or column-major (Fortran-style)
+* @param {boolean} isRowMajor - boolean indicating if provided arrays are in row-major order
+* @returns {void}
+*
+* @example
+* var Float64Array = require( '@stdlib/array/float64' );
+*
+* // Create data buffers:
+* var xbuf = new Float64Array( [ 2.0 ] );
+* var ybuf = new Float64Array( 6 );
+*
+* // Define the shape of the output array:
+* var shape = [ 1, 3, 1, 2 ];
+*
+* // Define the array strides:
+* var sx = [ 0 ];
+* var sy = [ 2, 2, 2, 1 ];
+*
+* // Define the index offsets:
+* var ox = 0;
+* var oy = 0;
+*
+* // Create the input and output ndarray-like objects:
+* var x = {
+*     'dtype': 'float64',
+*     'data': xbuf,
+*     'shape': [],
+*     'strides': sx,
+*     'offset': ox,
+*     'order': 'row-major'
+* };
+* var y = {
+*     'dtype': 'float64',
+*     'data': ybuf,
+*     'shape': shape,
+*     'strides': sy,
+*     'offset': oy,
+*     'order': 'row-major'
+* };
+*
+* // Assign scalar:
+* assign4d( x, y, true );
+*
+* console.log( y.data );
+* // => <Float64Array>[ 2.0, 2.0, 2.0, 2.0, 2.0, 2.0 ]
+*/
+function assign4d( x, y, isRowMajor ) {
+	var xbuf;
+	var ybuf;
+	var dy0;
+	var dy1;
+	var dy2;
+	var dy3;
+	var sh;
+	var S0;
+	var S1;
+	var S2;
+	var S3;
+	var sy;
+	var ix;
+	var iy;
+	var i0;
+	var i1;
+	var i2;
+	var i3;
+
+	// Note on variable naming convention: S#, dy#, i# where # corresponds to the loop number, with `0` being the innermost loop...
+
+	// Extract loop variables for purposes of loop interchange: dimensions and loop offset (pointer) increments...
+	sh = y.shape;
+	sy = y.strides;
+	if ( isRowMajor ) {
+		// For row-major ndarrays, the last dimensions have the fastest changing indices...
+		S0 = sh[ 3 ];
+		S1 = sh[ 2 ];
+		S2 = sh[ 1 ];
+		S3 = sh[ 0 ];
+		dy0 = sy[ 3 ];
+		dy1 = sy[ 2 ] - ( S0*sy[3] );
+		dy2 = sy[ 1 ] - ( S1*sy[2] );
+		dy3 = sy[ 0 ] - ( S2*sy[1] );
+	} else { // order === 'column-major'
+		// For column-major ndarrays, the first dimensions have the fastest changing indices...
+		S0 = sh[ 0 ];
+		S1 = sh[ 1 ];
+		S2 = sh[ 2 ];
+		S3 = sh[ 3 ];
+		dy0 = sy[ 0 ];
+		dy1 = sy[ 1 ] - ( S0*sy[0] );
+		dy2 = sy[ 2 ] - ( S1*sy[1] );
+		dy3 = sy[ 3 ] - ( S2*sy[2] );
+	}
+	// Set the pointers to the first indexed elements in the respective ndarrays...
+	ix = x.offset;
+	iy = y.offset;
+
+	// Cache references to the input and output ndarray buffers...
+	xbuf = x.data;
+	ybuf = y.data;
+
+	// Iterate over the ndarray dimensions...
+	for ( i3 = 0; i3 < S3; i3++ ) {
+		for ( i2 = 0; i2 < S2; i2++ ) {
+			for ( i1 = 0; i1 < S1; i1++ ) {
+				for ( i0 = 0; i0 < S0; i0++ ) {
+					ybuf[ iy ] = xbuf[ ix ];
+					iy += dy0;
+				}
+				iy += dy1;
+			}
+			iy += dy2;
+		}
+		iy += dy3;
+	}
+}
+
+
+// EXPORTS //
+
+module.exports = assign4d;
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/4d_accessors.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/4d_accessors.js
new file mode 100644
index 000000000000..07d7a2e04bb6
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/4d_accessors.js
@@ -0,0 +1,186 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2026 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';
+
+// MAIN //
+
+/**
+* Assigns a scalar value to every element of a four-dimensional output ndarray.
+*
+* @private
+* @param {Object} x - object containing input ndarray meta data
+* @param {*} x.dtype - data type
+* @param {Collection} x.data - data buffer
+* @param {NonNegativeIntegerArray} x.shape - dimensions
+* @param {IntegerArray} x.strides - stride lengths
+* @param {NonNegativeInteger} x.offset - index offset
+* @param {string} x.order - specifies whether `x` is row-major (C-style) or column-major (Fortran-style)
+* @param {Array<Function>} x.accessors - data buffer accessors
+* @param {Object} y - object containing output ndarray meta data
+* @param {*} y.dtype - data type
+* @param {Collection} y.data - data buffer
+* @param {NonNegativeIntegerArray} y.shape - dimensions
+* @param {IntegerArray} y.strides - stride lengths
+* @param {NonNegativeInteger} y.offset - index offset
+* @param {string} y.order - specifies whether `y` is row-major (C-style) or column-major (Fortran-style)
+* @param {Array<Function>} y.accessors - data buffer accessors
+* @param {boolean} isRowMajor - boolean indicating if provided arrays are in row-major order
+* @returns {void}
+*
+* @example
+* var Complex64Array = require( '@stdlib/array/complex64' );
+* var Complex64 = require( '@stdlib/complex/float32/ctor' );
+* var realf = require( '@stdlib/complex/float32/real' );
+* var imagf = require( '@stdlib/complex/float32/imag' );
+*
+* // Create data buffers:
+* var xbuf = new Complex64Array( [ 2.0, 2.0 ] );
+* var ybuf = new Complex64Array( 6 );
+*
+* // Define the shape of the output array:
+* var shape = [ 1, 3, 1, 2 ];
+*
+* // Define the array strides:
+* var sx = [ 0 ];
+* var sy = [ 2, 2, 2, 1 ];
+*
+* // Define the index offsets:
+* var ox = 0;
+* var oy = 0;
+*
+* // Define getters and setters:
+* function getter( buf, idx ) {
+*     return buf.get( idx );
+* }
+*
+* function setter( buf, idx, value ) {
+*     buf.set( value, idx );
+* }
+*
+* // Create the input and output ndarray-like objects:
+* var x = {
+*     'dtype': 'complex64',
+*     'data': xbuf,
+*     'shape': [],
+*     'strides': sx,
+*     'offset': ox,
+*     'order': 'row-major',
+*     'accessors': [ getter, setter ]
+* };
+* var y = {
+*     'dtype': 'complex64',
+*     'data': ybuf,
+*     'shape': shape,
+*     'strides': sy,
+*     'offset': oy,
+*     'order': 'row-major',
+*     'accessors': [ getter, setter ]
+* };
+*
+* // Assign scalar:
+* assign4d( x, y, true );
+*
+* var v = y.data.get( 0 );
+*
+* var re = realf( v );
+* // returns 2.0
+*
+* var im = imagf( v );
+* // returns 2.0
+*/
+function assign4d( x, y, isRowMajor ) {
+	var xbuf;
+	var ybuf;
+	var get;
+	var set;
+	var dy0;
+	var dy1;
+	var dy2;
+	var dy3;
+	var sh;
+	var S0;
+	var S1;
+	var S2;
+	var S3;
+	var sy;
+	var ix;
+	var iy;
+	var i0;
+	var i1;
+	var i2;
+	var i3;
+
+	// Note on variable naming convention: S#, dy#, i# where # corresponds to the loop number, with `0` being the innermost loop...
+
+	// Extract loop variables for purposes of loop interchange: dimensions and loop offset (pointer) increments...
+	sh = y.shape;
+	sy = y.strides;
+	if ( isRowMajor ) {
+		// For row-major ndarrays, the last dimensions have the fastest changing indices...
+		S0 = sh[ 3 ];
+		S1 = sh[ 2 ];
+		S2 = sh[ 1 ];
+		S3 = sh[ 0 ];
+		dy0 = sy[ 3 ];
+		dy1 = sy[ 2 ] - ( S0*sy[3] );
+		dy2 = sy[ 1 ] - ( S1*sy[2] );
+		dy3 = sy[ 0 ] - ( S2*sy[1] );
+	} else { // order === 'column-major'
+		// For column-major ndarrays, the first dimensions have the fastest changing indices...
+		S0 = sh[ 0 ];
+		S1 = sh[ 1 ];
+		S2 = sh[ 2 ];
+		S3 = sh[ 3 ];
+		dy0 = sy[ 0 ];
+		dy1 = sy[ 1 ] - ( S0*sy[0] );
+		dy2 = sy[ 2 ] - ( S1*sy[1] );
+		dy3 = sy[ 3 ] - ( S2*sy[2] );
+	}
+	// Set the pointers to the first indexed elements in the respective ndarrays...
+	ix = x.offset;
+	iy = y.offset;
+
+	// Cache references to the input and output ndarray buffers...
+	xbuf = x.data;
+	ybuf = y.data;
+
+	// Cache accessors:
+	get = x.accessors[0];
+	set = y.accessors[1];
+
+	// Iterate over the ndarray dimensions...
+	for ( i3 = 0; i3 < S3; i3++ ) {
+		for ( i2 = 0; i2 < S2; i2++ ) {
+			for ( i1 = 0; i1 < S1; i1++ ) {
+				for ( i0 = 0; i0 < S0; i0++ ) {
+					set( ybuf, iy, get( xbuf, ix ) );
+					iy += dy0;
+				}
+				iy += dy1;
+			}
+			iy += dy2;
+		}
+		iy += dy3;
+	}
+}
+
+
+// EXPORTS //
+
+module.exports = assign4d;
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/4d_blocked.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/4d_blocked.js
new file mode 100644
index 000000000000..3c68e156e078
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/4d_blocked.js
@@ -0,0 +1,211 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2026 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-depth */
+
+'use strict';
+
+// MODULES //
+
+var loopOrder = require( '@stdlib/ndarray/base/nullary-loop-interchange-order' );
+var blockSize = require( '@stdlib/ndarray/base/nullary-tiling-block-size' );
+
+
+// MAIN //
+
+/**
+* Assigns a scalar value to every element of a four-dimensional output ndarray via loop blocking.
+*
+* @private
+* @param {Object} x - object containing input ndarray meta data
+* @param {*} x.dtype - data type
+* @param {Collection} x.data - data buffer
+* @param {NonNegativeIntegerArray} x.shape - dimensions
+* @param {IntegerArray} x.strides - stride lengths
+* @param {NonNegativeInteger} x.offset - index offset
+* @param {string} x.order - specifies whether `x` is row-major (C-style) or column-major (Fortran-style)
+* @param {Object} y - object containing output ndarray meta data
+* @param {*} y.dtype - data type
+* @param {Collection} y.data - data buffer
+* @param {NonNegativeIntegerArray} y.shape - dimensions
+* @param {IntegerArray} y.strides - stride lengths
+* @param {NonNegativeInteger} y.offset - index offset
+* @param {string} y.order - specifies whether `y` is row-major (C-style) or column-major (Fortran-style)
+* @returns {void}
+*
+* @example
+* var Float64Array = require( '@stdlib/array/float64' );
+*
+* // Create data buffers:
+* var xbuf = new Float64Array( [ 2.0 ] );
+* var ybuf = new Float64Array( 6 );
+*
+* // Define the shape of the output array:
+* var shape = [ 1, 3, 1, 2 ];
+*
+* // Define the array strides:
+* var sx = [ 0 ];
+* var sy = [ 2, 2, 2, 1 ];
+*
+* // Define the index offsets:
+* var ox = 0;
+* var oy = 0;
+*
+* // Create the input and output ndarray-like objects:
+* var x = {
+*     'dtype': 'float64',
+*     'data': xbuf,
+*     'shape': [],
+*     'strides': sx,
+*     'offset': ox,
+*     'order': 'row-major'
+* };
+* var y = {
+*     'dtype': 'float64',
+*     'data': ybuf,
+*     'shape': shape,
+*     'strides': sy,
+*     'offset': oy,
+*     'order': 'row-major'
+* };
+*
+* // Assign scalar:
+* blockedassign4d( x, y );
+*
+* console.log( y.data );
+* // => <Float64Array>[ 2.0, 2.0, 2.0, 2.0, 2.0, 2.0 ]
+*/
+function blockedassign4d( x, y ) {
+	var bsize;
+	var xbuf;
+	var ybuf;
+	var dy0;
+	var dy1;
+	var dy2;
+	var dy3;
+	var oy1;
+	var oy2;
+	var oy3;
+	var sh;
+	var s0;
+	var s1;
+	var s2;
+	var s3;
+	var sy;
+	var oy;
+	var ix;
+	var iy;
+	var i0;
+	var i1;
+	var i2;
+	var i3;
+	var j0;
+	var j1;
+	var j2;
+	var j3;
+	var o;
+
+	// Note on variable naming convention: s#, dy#, i#, j# where # corresponds to the loop number, with `0` being the innermost loop...
+
+	// Resolve the loop interchange order:
+	o = loopOrder( y.shape, y.strides );
+	sh = o.sh;
+	sy = o.sx;
+
+	// Determine the block size:
+	bsize = blockSize( y.dtype );
+
+	// Cache the indices of the first indexed elements in the respective ndarrays...
+	ix = x.offset;
+	oy = y.offset;
+
+	// Cache references to the input and output ndarray buffers...
+	xbuf = x.data;
+	ybuf = y.data;
+
+	// Cache the offset increment for the innermost loop...
+	dy0 = sy[0];
+
+	// Iterate over blocks...
+	for ( j3 = sh[3]; j3 > 0; ) {
+		if ( j3 < bsize ) {
+			s3 = j3;
+			j3 = 0;
+		} else {
+			s3 = bsize;
+			j3 -= bsize;
+		}
+		oy3 = oy + ( j3*sy[3] );
+		for ( j2 = sh[2]; j2 > 0; ) {
+			if ( j2 < bsize ) {
+				s2 = j2;
+				j2 = 0;
+			} else {
+				s2 = bsize;
+				j2 -= bsize;
+			}
+			dy3 = sy[3] - ( s2*sy[2] );
+			oy2 = oy3 + ( j2*sy[2] );
+			for ( j1 = sh[1]; j1 > 0; ) {
+				if ( j1 < bsize ) {
+					s1 = j1;
+					j1 = 0;
+				} else {
+					s1 = bsize;
+					j1 -= bsize;
+				}
+				dy2 = sy[2] - ( s1*sy[1] );
+				oy1 = oy2 + ( j1*sy[1] );
+				for ( j0 = sh[0]; j0 > 0; ) {
+					if ( j0 < bsize ) {
+						s0 = j0;
+						j0 = 0;
+					} else {
+						s0 = bsize;
+						j0 -= bsize;
+					}
+					// Compute the index offset for the first output ndarray element in the current block...
+					iy = oy1 + ( j0*sy[0] );
+
+					// Compute the loop offset increment...
+					dy1 = sy[1] - ( s0*sy[0] );
+
+					// Iterate over the ndarray dimensions...
+					for ( i3 = 0; i3 < s3; i3++ ) {
+						for ( i2 = 0; i2 < s2; i2++ ) {
+							for ( i1 = 0; i1 < s1; i1++ ) {
+								for ( i0 = 0; i0 < s0; i0++ ) {
+									ybuf[ iy ] = xbuf[ ix ];
+									iy += dy0;
+								}
+								iy += dy1;
+							}
+							iy += dy2;
+						}
+						iy += dy3;
+					}
+				}
+			}
+		}
+	}
+}
+
+
+// EXPORTS //
+
+module.exports = blockedassign4d;
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/4d_blocked_accessors.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/4d_blocked_accessors.js
new file mode 100644
index 000000000000..3d47475350b0
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/4d_blocked_accessors.js
@@ -0,0 +1,238 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2026 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-depth */
+
+'use strict';
+
+// MODULES //
+
+var loopOrder = require( '@stdlib/ndarray/base/nullary-loop-interchange-order' );
+var blockSize = require( '@stdlib/ndarray/base/nullary-tiling-block-size' );
+
+
+// MAIN //
+
+/**
+* Assigns a scalar value to every element of a four-dimensional output ndarray via loop blocking.
+*
+* @private
+* @param {Object} x - object containing input ndarray meta data
+* @param {*} x.dtype - data type
+* @param {Collection} x.data - data buffer
+* @param {NonNegativeIntegerArray} x.shape - dimensions
+* @param {IntegerArray} x.strides - stride lengths
+* @param {NonNegativeInteger} x.offset - index offset
+* @param {string} x.order - specifies whether `x` is row-major (C-style) or column-major (Fortran-style)
+* @param {Array<Function>} x.accessors - data buffer accessors
+* @param {Object} y - object containing output ndarray meta data
+* @param {*} y.dtype - data type
+* @param {Collection} y.data - data buffer
+* @param {NonNegativeIntegerArray} y.shape - dimensions
+* @param {IntegerArray} y.strides - stride lengths
+* @param {NonNegativeInteger} y.offset - index offset
+* @param {string} y.order - specifies whether `y` is row-major (C-style) or column-major (Fortran-style)
+* @param {Array<Function>} y.accessors - data buffer accessors
+* @returns {void}
+*
+* @example
+* var Complex64Array = require( '@stdlib/array/complex64' );
+* var Complex64 = require( '@stdlib/complex/float32/ctor' );
+* var realf = require( '@stdlib/complex/float32/real' );
+* var imagf = require( '@stdlib/complex/float32/imag' );
+*
+* // Create data buffers:
+* var xbuf = new Complex64Array( [ 2.0, 2.0 ] );
+* var ybuf = new Complex64Array( 6 );
+*
+* // Define the shape of the output array:
+* var shape = [ 1, 3, 1, 2 ];
+*
+* // Define the array strides:
+* var sx = [ 0 ];
+* var sy = [ 2, 2, 2, 1 ];
+*
+* // Define the index offsets:
+* var ox = 0;
+* var oy = 0;
+*
+* // Define getters and setters:
+* function getter( buf, idx ) {
+*     return buf.get( idx );
+* }
+*
+* function setter( buf, idx, value ) {
+*     buf.set( value, idx );
+* }
+*
+* // Create the input and output ndarray-like objects:
+* var x = {
+*     'dtype': 'complex64',
+*     'data': xbuf,
+*     'shape': [],
+*     'strides': sx,
+*     'offset': ox,
+*     'order': 'row-major',
+*     'accessors': [ getter, setter ]
+* };
+* var y = {
+*     'dtype': 'complex64',
+*     'data': ybuf,
+*     'shape': shape,
+*     'strides': sy,
+*     'offset': oy,
+*     'order': 'row-major',
+*     'accessors': [ getter, setter ]
+* };
+*
+* // Assign scalar:
+* blockedassign4d( x, y );
+*
+* var v = y.data.get( 0 );
+*
+* var re = realf( v );
+* // returns 2.0
+*
+* var im = imagf( v );
+* // returns 2.0
+*/
+function blockedassign4d( x, y ) {
+	var bsize;
+	var xbuf;
+	var ybuf;
+	var get;
+	var set;
+	var dy0;
+	var dy1;
+	var dy2;
+	var dy3;
+	var oy1;
+	var oy2;
+	var oy3;
+	var sh;
+	var s0;
+	var s1;
+	var s2;
+	var s3;
+	var sy;
+	var oy;
+	var ix;
+	var iy;
+	var i0;
+	var i1;
+	var i2;
+	var i3;
+	var j0;
+	var j1;
+	var j2;
+	var j3;
+	var o;
+
+	// Note on variable naming convention: s#, dy#, i#, j# where # corresponds to the loop number, with `0` being the innermost loop...
+
+	// Resolve the loop interchange order:
+	o = loopOrder( y.shape, y.strides );
+	sh = o.sh;
+	sy = o.sx;
+
+	// Determine the block size:
+	bsize = blockSize( y.dtype );
+
+	// Cache the indices of the first indexed elements in the respective ndarrays...
+	ix = x.offset;
+	oy = y.offset;
+
+	// Cache references to the input and output ndarray buffers...
+	xbuf = x.data;
+	ybuf = y.data;
+
+	// Cache the offset increment for the innermost loop...
+	dy0 = sy[0];
+
+	// Cache accessors:
+	get = x.accessors[0];
+	set = y.accessors[1];
+
+	// Iterate over blocks...
+	for ( j3 = sh[3]; j3 > 0; ) {
+		if ( j3 < bsize ) {
+			s3 = j3;
+			j3 = 0;
+		} else {
+			s3 = bsize;
+			j3 -= bsize;
+		}
+		oy3 = oy + ( j3*sy[3] );
+		for ( j2 = sh[2]; j2 > 0; ) {
+			if ( j2 < bsize ) {
+				s2 = j2;
+				j2 = 0;
+			} else {
+				s2 = bsize;
+				j2 -= bsize;
+			}
+			dy3 = sy[3] - ( s2*sy[2] );
+			oy2 = oy3 + ( j2*sy[2] );
+			for ( j1 = sh[1]; j1 > 0; ) {
+				if ( j1 < bsize ) {
+					s1 = j1;
+					j1 = 0;
+				} else {
+					s1 = bsize;
+					j1 -= bsize;
+				}
+				dy2 = sy[2] - ( s1*sy[1] );
+				oy1 = oy2 + ( j1*sy[1] );
+				for ( j0 = sh[0]; j0 > 0; ) {
+					if ( j0 < bsize ) {
+						s0 = j0;
+						j0 = 0;
+					} else {
+						s0 = bsize;
+						j0 -= bsize;
+					}
+					// Compute the index offset for the first output ndarray element in the current block...
+					iy = oy1 + ( j0*sy[0] );
+
+					// Compute the loop offset increment...
+					dy1 = sy[1] - ( s0*sy[0] );
+
+					// Iterate over the ndarray dimensions...
+					for ( i3 = 0; i3 < s3; i3++ ) {
+						for ( i2 = 0; i2 < s2; i2++ ) {
+							for ( i1 = 0; i1 < s1; i1++ ) {
+								for ( i0 = 0; i0 < s0; i0++ ) {
+									set( ybuf, iy, get( xbuf, ix ) );
+									iy += dy0;
+								}
+								iy += dy1;
+							}
+							iy += dy2;
+						}
+						iy += dy3;
+					}
+				}
+			}
+		}
+	}
+}
+
+
+// EXPORTS //
+
+module.exports = blockedassign4d;
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/5d.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/5d.js
new file mode 100644
index 000000000000..bf3e34d0c396
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/5d.js
@@ -0,0 +1,169 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2026 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';
+
+// MAIN //
+
+/**
+* Assigns a scalar value to every element of a five-dimensional output ndarray.
+*
+* @private
+* @param {Object} x - object containing input ndarray meta data
+* @param {*} x.dtype - data type
+* @param {Collection} x.data - data buffer
+* @param {NonNegativeIntegerArray} x.shape - dimensions
+* @param {IntegerArray} x.strides - stride lengths
+* @param {NonNegativeInteger} x.offset - index offset
+* @param {string} x.order - specifies whether `x` is row-major (C-style) or column-major (Fortran-style)
+* @param {Object} y - object containing output ndarray meta data
+* @param {*} y.dtype - data type
+* @param {Collection} y.data - data buffer
+* @param {NonNegativeIntegerArray} y.shape - dimensions
+* @param {IntegerArray} y.strides - stride lengths
+* @param {NonNegativeInteger} y.offset - index offset
+* @param {string} y.order - specifies whether `y` is row-major (C-style) or column-major (Fortran-style)
+* @param {boolean} isRowMajor - boolean indicating if provided arrays are in row-major order
+* @returns {void}
+*
+* @example
+* var Float64Array = require( '@stdlib/array/float64' );
+*
+* // Create data buffers:
+* var xbuf = new Float64Array( [ 2.0 ] );
+* var ybuf = new Float64Array( 6 );
+*
+* // Define the shape of the output array:
+* var shape = [ 1, 1, 3, 1, 2 ];
+*
+* // Define the array strides:
+* var sx = [ 0 ];
+* var sy = [ 2, 2, 2, 2, 1 ];
+*
+* // Define the index offsets:
+* var ox = 0;
+* var oy = 0;
+*
+* // Create the input and output ndarray-like objects:
+* var x = {
+*     'dtype': 'float64',
+*     'data': xbuf,
+*     'shape': [],
+*     'strides': sx,
+*     'offset': ox,
+*     'order': 'row-major'
+* };
+* var y = {
+*     'dtype': 'float64',
+*     'data': ybuf,
+*     'shape': shape,
+*     'strides': sy,
+*     'offset': oy,
+*     'order': 'row-major'
+* };
+*
+* // Assign scalar:
+* assign5d( x, y, true );
+*
+* console.log( y.data );
+* // => <Float64Array>[ 2.0, 2.0, 2.0, 2.0, 2.0, 2.0 ]
+*/
+function assign5d( x, y, isRowMajor ) {
+	var xbuf;
+	var ybuf;
+	var dy0;
+	var dy1;
+	var dy2;
+	var dy3;
+	var dy4;
+	var sh;
+	var S0;
+	var S1;
+	var S2;
+	var S3;
+	var S4;
+	var sy;
+	var ix;
+	var iy;
+	var i0;
+	var i1;
+	var i2;
+	var i3;
+	var i4;
+
+	// Note on variable naming convention: S#, dy#, i# where # corresponds to the loop number, with `0` being the innermost loop...
+
+	// Extract loop variables for purposes of loop interchange: dimensions and loop offset (pointer) increments...
+	sh = y.shape;
+	sy = y.strides;
+	if ( isRowMajor ) {
+		// For row-major ndarrays, the last dimensions have the fastest changing indices...
+		S0 = sh[ 4 ];
+		S1 = sh[ 3 ];
+		S2 = sh[ 2 ];
+		S3 = sh[ 1 ];
+		S4 = sh[ 0 ];
+		dy0 = sy[ 4 ];
+		dy1 = sy[ 3 ] - ( S0*sy[4] );
+		dy2 = sy[ 2 ] - ( S1*sy[3] );
+		dy3 = sy[ 1 ] - ( S2*sy[2] );
+		dy4 = sy[ 0 ] - ( S3*sy[1] );
+	} else { // order === 'column-major'
+		// For column-major ndarrays, the first dimensions have the fastest changing indices...
+		S0 = sh[ 0 ];
+		S1 = sh[ 1 ];
+		S2 = sh[ 2 ];
+		S3 = sh[ 3 ];
+		S4 = sh[ 4 ];
+		dy0 = sy[ 0 ];
+		dy1 = sy[ 1 ] - ( S0*sy[0] );
+		dy2 = sy[ 2 ] - ( S1*sy[1] );
+		dy3 = sy[ 3 ] - ( S2*sy[2] );
+		dy4 = sy[ 4 ] - ( S3*sy[3] );
+	}
+	// Set the pointers to the first indexed elements in the respective ndarrays...
+	ix = x.offset;
+	iy = y.offset;
+
+	// Cache references to the input and output ndarray buffers...
+	xbuf = x.data;
+	ybuf = y.data;
+
+	// Iterate over the ndarray dimensions...
+	for ( i4 = 0; i4 < S4; i4++ ) {
+		for ( i3 = 0; i3 < S3; i3++ ) {
+			for ( i2 = 0; i2 < S2; i2++ ) {
+				for ( i1 = 0; i1 < S1; i1++ ) {
+					for ( i0 = 0; i0 < S0; i0++ ) {
+						ybuf[ iy ] = xbuf[ ix ];
+						iy += dy0;
+					}
+					iy += dy1;
+				}
+				iy += dy2;
+			}
+			iy += dy3;
+		}
+		iy += dy4;
+	}
+}
+
+
+// EXPORTS //
+
+module.exports = assign5d;
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/5d_accessors.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/5d_accessors.js
new file mode 100644
index 000000000000..4b1efd900875
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/5d_accessors.js
@@ -0,0 +1,196 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2026 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';
+
+// MAIN //
+
+/**
+* Assigns a scalar value to every element of a five-dimensional output ndarray.
+*
+* @private
+* @param {Object} x - object containing input ndarray meta data
+* @param {*} x.dtype - data type
+* @param {Collection} x.data - data buffer
+* @param {NonNegativeIntegerArray} x.shape - dimensions
+* @param {IntegerArray} x.strides - stride lengths
+* @param {NonNegativeInteger} x.offset - index offset
+* @param {string} x.order - specifies whether `x` is row-major (C-style) or column-major (Fortran-style)
+* @param {Array<Function>} x.accessors - data buffer accessors
+* @param {Object} y - object containing output ndarray meta data
+* @param {*} y.dtype - data type
+* @param {Collection} y.data - data buffer
+* @param {NonNegativeIntegerArray} y.shape - dimensions
+* @param {IntegerArray} y.strides - stride lengths
+* @param {NonNegativeInteger} y.offset - index offset
+* @param {string} y.order - specifies whether `y` is row-major (C-style) or column-major (Fortran-style)
+* @param {Array<Function>} y.accessors - data buffer accessors
+* @param {boolean} isRowMajor - boolean indicating if provided arrays are in row-major order
+* @returns {void}
+*
+* @example
+* var Complex64Array = require( '@stdlib/array/complex64' );
+* var Complex64 = require( '@stdlib/complex/float32/ctor' );
+* var realf = require( '@stdlib/complex/float32/real' );
+* var imagf = require( '@stdlib/complex/float32/imag' );
+*
+* // Create data buffers:
+* var xbuf = new Complex64Array( [ 2.0, 2.0 ] );
+* var ybuf = new Complex64Array( 6 );
+*
+* // Define the shape of the output array:
+* var shape = [ 1, 1, 3, 1, 2 ];
+*
+* // Define the array strides:
+* var sx = [ 0 ];
+* var sy = [ 2, 2, 2, 2, 1 ];
+*
+* // Define the index offsets:
+* var ox = 0;
+* var oy = 0;
+*
+* // Define getters and setters:
+* function getter( buf, idx ) {
+*     return buf.get( idx );
+* }
+*
+* function setter( buf, idx, value ) {
+*     buf.set( value, idx );
+* }
+*
+* // Create the input and output ndarray-like objects:
+* var x = {
+*     'dtype': 'complex64',
+*     'data': xbuf,
+*     'shape': [],
+*     'strides': sx,
+*     'offset': ox,
+*     'order': 'row-major',
+*     'accessors': [ getter, setter ]
+* };
+* var y = {
+*     'dtype': 'complex64',
+*     'data': ybuf,
+*     'shape': shape,
+*     'strides': sy,
+*     'offset': oy,
+*     'order': 'row-major',
+*     'accessors': [ getter, setter ]
+* };
+*
+* // Assign scalar:
+* assign5d( x, y, true );
+*
+* var v = y.data.get( 0 );
+*
+* var re = realf( v );
+* // returns 2.0
+*
+* var im = imagf( v );
+* // returns 2.0
+*/
+function assign5d( x, y, isRowMajor ) {
+	var xbuf;
+	var ybuf;
+	var get;
+	var set;
+	var dy0;
+	var dy1;
+	var dy2;
+	var dy3;
+	var dy4;
+	var sh;
+	var S0;
+	var S1;
+	var S2;
+	var S3;
+	var S4;
+	var sy;
+	var ix;
+	var iy;
+	var i0;
+	var i1;
+	var i2;
+	var i3;
+	var i4;
+
+	// Note on variable naming convention: S#, dy#, i# where # corresponds to the loop number, with `0` being the innermost loop...
+
+	// Extract loop variables for purposes of loop interchange: dimensions and loop offset (pointer) increments...
+	sh = y.shape;
+	sy = y.strides;
+	if ( isRowMajor ) {
+		// For row-major ndarrays, the last dimensions have the fastest changing indices...
+		S0 = sh[ 4 ];
+		S1 = sh[ 3 ];
+		S2 = sh[ 2 ];
+		S3 = sh[ 1 ];
+		S4 = sh[ 0 ];
+		dy0 = sy[ 4 ];
+		dy1 = sy[ 3 ] - ( S0*sy[4] );
+		dy2 = sy[ 2 ] - ( S1*sy[3] );
+		dy3 = sy[ 1 ] - ( S2*sy[2] );
+		dy4 = sy[ 0 ] - ( S3*sy[1] );
+	} else { // order === 'column-major'
+		// For column-major ndarrays, the first dimensions have the fastest changing indices...
+		S0 = sh[ 0 ];
+		S1 = sh[ 1 ];
+		S2 = sh[ 2 ];
+		S3 = sh[ 3 ];
+		S4 = sh[ 4 ];
+		dy0 = sy[ 0 ];
+		dy1 = sy[ 1 ] - ( S0*sy[0] );
+		dy2 = sy[ 2 ] - ( S1*sy[1] );
+		dy3 = sy[ 3 ] - ( S2*sy[2] );
+		dy4 = sy[ 4 ] - ( S3*sy[3] );
+	}
+	// Set the pointers to the first indexed elements in the respective ndarrays...
+	ix = x.offset;
+	iy = y.offset;
+
+	// Cache references to the input and output ndarray buffers...
+	xbuf = x.data;
+	ybuf = y.data;
+
+	// Cache accessors:
+	get = x.accessors[0];
+	set = y.accessors[1];
+
+	// Iterate over the ndarray dimensions...
+	for ( i4 = 0; i4 < S4; i4++ ) {
+		for ( i3 = 0; i3 < S3; i3++ ) {
+			for ( i2 = 0; i2 < S2; i2++ ) {
+				for ( i1 = 0; i1 < S1; i1++ ) {
+					for ( i0 = 0; i0 < S0; i0++ ) {
+						set( ybuf, iy, get( xbuf, ix ) );
+						iy += dy0;
+					}
+					iy += dy1;
+				}
+				iy += dy2;
+			}
+			iy += dy3;
+		}
+		iy += dy4;
+	}
+}
+
+
+// EXPORTS //
+
+module.exports = assign5d;
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/5d_blocked.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/5d_blocked.js
new file mode 100644
index 000000000000..62e81c45e202
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/5d_blocked.js
@@ -0,0 +1,230 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2026 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-depth */
+
+'use strict';
+
+// MODULES //
+
+var loopOrder = require( '@stdlib/ndarray/base/nullary-loop-interchange-order' );
+var blockSize = require( '@stdlib/ndarray/base/nullary-tiling-block-size' );
+
+
+// MAIN //
+
+/**
+* Assigns a scalar value to every element of a five-dimensional output ndarray via loop blocking.
+*
+* @private
+* @param {Object} x - object containing input ndarray meta data
+* @param {*} x.dtype - data type
+* @param {Collection} x.data - data buffer
+* @param {NonNegativeIntegerArray} x.shape - dimensions
+* @param {IntegerArray} x.strides - stride lengths
+* @param {NonNegativeInteger} x.offset - index offset
+* @param {string} x.order - specifies whether `x` is row-major (C-style) or column-major (Fortran-style)
+* @param {Object} y - object containing output ndarray meta data
+* @param {*} y.dtype - data type
+* @param {Collection} y.data - data buffer
+* @param {NonNegativeIntegerArray} y.shape - dimensions
+* @param {IntegerArray} y.strides - stride lengths
+* @param {NonNegativeInteger} y.offset - index offset
+* @param {string} y.order - specifies whether `y` is row-major (C-style) or column-major (Fortran-style)
+* @returns {void}
+*
+* @example
+* var Float64Array = require( '@stdlib/array/float64' );
+*
+* // Create data buffers:
+* var xbuf = new Float64Array( [ 2.0 ] );
+* var ybuf = new Float64Array( 6 );
+*
+* // Define the shape of the output array:
+* var shape = [ 1, 1, 3, 1, 2 ];
+*
+* // Define the array strides:
+* var sx = [ 0 ];
+* var sy = [ 2, 2, 2, 2, 1 ];
+*
+* // Define the index offsets:
+* var ox = 0;
+* var oy = 0;
+*
+* // Create the input and output ndarray-like objects:
+* var x = {
+*     'dtype': 'float64',
+*     'data': xbuf,
+*     'shape': [],
+*     'strides': sx,
+*     'offset': ox,
+*     'order': 'row-major'
+* };
+* var y = {
+*     'dtype': 'float64',
+*     'data': ybuf,
+*     'shape': shape,
+*     'strides': sy,
+*     'offset': oy,
+*     'order': 'row-major'
+* };
+*
+* // Assign scalar:
+* blockedassign5d( x, y );
+*
+* console.log( y.data );
+* // => <Float64Array>[ 2.0, 2.0, 2.0, 2.0, 2.0, 2.0 ]
+*/
+function blockedassign5d( x, y ) {
+	var bsize;
+	var xbuf;
+	var ybuf;
+	var dy0;
+	var dy1;
+	var dy2;
+	var dy3;
+	var dy4;
+	var oy1;
+	var oy2;
+	var oy3;
+	var oy4;
+	var sh;
+	var s0;
+	var s1;
+	var s2;
+	var s3;
+	var s4;
+	var sy;
+	var oy;
+	var ix;
+	var iy;
+	var i0;
+	var i1;
+	var i2;
+	var i3;
+	var i4;
+	var j0;
+	var j1;
+	var j2;
+	var j3;
+	var j4;
+	var o;
+
+	// Note on variable naming convention: s#, dy#, i#, j# where # corresponds to the loop number, with `0` being the innermost loop...
+
+	// Resolve the loop interchange order:
+	o = loopOrder( y.shape, y.strides );
+	sh = o.sh;
+	sy = o.sx;
+
+	// Determine the block size:
+	bsize = blockSize( y.dtype );
+
+	// Cache the indices of the first indexed elements in the respective ndarrays...
+	ix = x.offset;
+	oy = y.offset;
+
+	// Cache references to the input and output ndarray buffers...
+	xbuf = x.data;
+	ybuf = y.data;
+
+	// Cache the offset increment for the innermost loop...
+	dy0 = sy[0];
+
+	// Iterate over blocks...
+	for ( j4 = sh[4]; j4 > 0; ) {
+		if ( j4 < bsize ) {
+			s4 = j4;
+			j4 = 0;
+		} else {
+			s4 = bsize;
+			j4 -= bsize;
+		}
+		oy4 = oy + ( j4*sy[4] );
+		for ( j3 = sh[3]; j3 > 0; ) {
+			if ( j3 < bsize ) {
+				s3 = j3;
+				j3 = 0;
+			} else {
+				s3 = bsize;
+				j3 -= bsize;
+			}
+			dy4 = sy[4] - ( s3*sy[3] );
+			oy3 = oy4 + ( j3*sy[3] );
+			for ( j2 = sh[2]; j2 > 0; ) {
+				if ( j2 < bsize ) {
+					s2 = j2;
+					j2 = 0;
+				} else {
+					s2 = bsize;
+					j2 -= bsize;
+				}
+				dy3 = sy[3] - ( s2*sy[2] );
+				oy2 = oy3 + ( j2*sy[2] );
+				for ( j1 = sh[1]; j1 > 0; ) {
+					if ( j1 < bsize ) {
+						s1 = j1;
+						j1 = 0;
+					} else {
+						s1 = bsize;
+						j1 -= bsize;
+					}
+					dy2 = sy[2] - ( s1*sy[1] );
+					oy1 = oy2 + ( j1*sy[1] );
+					for ( j0 = sh[0]; j0 > 0; ) {
+						if ( j0 < bsize ) {
+							s0 = j0;
+							j0 = 0;
+						} else {
+							s0 = bsize;
+							j0 -= bsize;
+						}
+						// Compute the index offset for the first output ndarray element in the current block...
+						iy = oy1 + ( j0*sy[0] );
+
+						// Compute the loop offset increment...
+						dy1 = sy[1] - ( s0*sy[0] );
+
+						// Iterate over the ndarray dimensions...
+						for ( i4 = 0; i4 < s4; i4++ ) {
+							for ( i3 = 0; i3 < s3; i3++ ) {
+								for ( i2 = 0; i2 < s2; i2++ ) {
+									for ( i1 = 0; i1 < s1; i1++ ) {
+										for ( i0 = 0; i0 < s0; i0++ ) {
+											ybuf[ iy ] = xbuf[ ix ];
+											iy += dy0;
+										}
+										iy += dy1;
+									}
+									iy += dy2;
+								}
+								iy += dy3;
+							}
+							iy += dy4;
+						}
+					}
+				}
+			}
+		}
+	}
+}
+
+
+// EXPORTS //
+
+module.exports = blockedassign5d;
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/5d_blocked_accessors.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/5d_blocked_accessors.js
new file mode 100644
index 000000000000..21d382e217ce
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/5d_blocked_accessors.js
@@ -0,0 +1,257 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2026 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-depth */
+
+'use strict';
+
+// MODULES //
+
+var loopOrder = require( '@stdlib/ndarray/base/nullary-loop-interchange-order' );
+var blockSize = require( '@stdlib/ndarray/base/nullary-tiling-block-size' );
+
+
+// MAIN //
+
+/**
+* Assigns a scalar value to every element of a five-dimensional output ndarray via loop blocking.
+*
+* @private
+* @param {Object} x - object containing input ndarray meta data
+* @param {*} x.dtype - data type
+* @param {Collection} x.data - data buffer
+* @param {NonNegativeIntegerArray} x.shape - dimensions
+* @param {IntegerArray} x.strides - stride lengths
+* @param {NonNegativeInteger} x.offset - index offset
+* @param {string} x.order - specifies whether `x` is row-major (C-style) or column-major (Fortran-style)
+* @param {Array<Function>} x.accessors - data buffer accessors
+* @param {Object} y - object containing output ndarray meta data
+* @param {*} y.dtype - data type
+* @param {Collection} y.data - data buffer
+* @param {NonNegativeIntegerArray} y.shape - dimensions
+* @param {IntegerArray} y.strides - stride lengths
+* @param {NonNegativeInteger} y.offset - index offset
+* @param {string} y.order - specifies whether `y` is row-major (C-style) or column-major (Fortran-style)
+* @param {Array<Function>} y.accessors - data buffer accessors
+* @returns {void}
+*
+* @example
+* var Complex64Array = require( '@stdlib/array/complex64' );
+* var Complex64 = require( '@stdlib/complex/float32/ctor' );
+* var realf = require( '@stdlib/complex/float32/real' );
+* var imagf = require( '@stdlib/complex/float32/imag' );
+*
+* // Create data buffers:
+* var xbuf = new Complex64Array( [ 2.0, 2.0 ] );
+* var ybuf = new Complex64Array( 6 );
+*
+* // Define the shape of the output array:
+* var shape = [ 1, 1, 3, 1, 2 ];
+*
+* // Define the array strides:
+* var sx = [ 0 ];
+* var sy = [ 2, 2, 2, 2, 1 ];
+*
+* // Define the index offsets:
+* var ox = 0;
+* var oy = 0;
+*
+* // Define getters and setters:
+* function getter( buf, idx ) {
+*     return buf.get( idx );
+* }
+*
+* function setter( buf, idx, value ) {
+*     buf.set( value, idx );
+* }
+*
+* // Create the input and output ndarray-like objects:
+* var x = {
+*     'dtype': 'complex64',
+*     'data': xbuf,
+*     'shape': [],
+*     'strides': sx,
+*     'offset': ox,
+*     'order': 'row-major',
+*     'accessors': [ getter, setter ]
+* };
+* var y = {
+*     'dtype': 'complex64',
+*     'data': ybuf,
+*     'shape': shape,
+*     'strides': sy,
+*     'offset': oy,
+*     'order': 'row-major',
+*     'accessors': [ getter, setter ]
+* };
+*
+* // Assign scalar:
+* blockedassign5d( x, y );
+*
+* var v = y.data.get( 0 );
+*
+* var re = realf( v );
+* // returns 2.0
+*
+* var im = imagf( v );
+* // returns 2.0
+*/
+function blockedassign5d( x, y ) {
+	var bsize;
+	var xbuf;
+	var ybuf;
+	var get;
+	var set;
+	var dy0;
+	var dy1;
+	var dy2;
+	var dy3;
+	var dy4;
+	var oy1;
+	var oy2;
+	var oy3;
+	var oy4;
+	var sh;
+	var s0;
+	var s1;
+	var s2;
+	var s3;
+	var s4;
+	var sy;
+	var oy;
+	var ix;
+	var iy;
+	var i0;
+	var i1;
+	var i2;
+	var i3;
+	var i4;
+	var j0;
+	var j1;
+	var j2;
+	var j3;
+	var j4;
+	var o;
+
+	// Note on variable naming convention: s#, dy#, i#, j# where # corresponds to the loop number, with `0` being the innermost loop...
+
+	// Resolve the loop interchange order:
+	o = loopOrder( y.shape, y.strides );
+	sh = o.sh;
+	sy = o.sx;
+
+	// Determine the block size:
+	bsize = blockSize( y.dtype );
+
+	// Cache the indices of the first indexed elements in the respective ndarrays...
+	ix = x.offset;
+	oy = y.offset;
+
+	// Cache references to the input and output ndarray buffers...
+	xbuf = x.data;
+	ybuf = y.data;
+
+	// Cache the offset increment for the innermost loop...
+	dy0 = sy[0];
+
+	// Cache accessors:
+	get = x.accessors[0];
+	set = y.accessors[1];
+
+	// Iterate over blocks...
+	for ( j4 = sh[4]; j4 > 0; ) {
+		if ( j4 < bsize ) {
+			s4 = j4;
+			j4 = 0;
+		} else {
+			s4 = bsize;
+			j4 -= bsize;
+		}
+		oy4 = oy + ( j4*sy[4] );
+		for ( j3 = sh[3]; j3 > 0; ) {
+			if ( j3 < bsize ) {
+				s3 = j3;
+				j3 = 0;
+			} else {
+				s3 = bsize;
+				j3 -= bsize;
+			}
+			dy4 = sy[4] - ( s3*sy[3] );
+			oy3 = oy4 + ( j3*sy[3] );
+			for ( j2 = sh[2]; j2 > 0; ) {
+				if ( j2 < bsize ) {
+					s2 = j2;
+					j2 = 0;
+				} else {
+					s2 = bsize;
+					j2 -= bsize;
+				}
+				dy3 = sy[3] - ( s2*sy[2] );
+				oy2 = oy3 + ( j2*sy[2] );
+				for ( j1 = sh[1]; j1 > 0; ) {
+					if ( j1 < bsize ) {
+						s1 = j1;
+						j1 = 0;
+					} else {
+						s1 = bsize;
+						j1 -= bsize;
+					}
+					dy2 = sy[2] - ( s1*sy[1] );
+					oy1 = oy2 + ( j1*sy[1] );
+					for ( j0 = sh[0]; j0 > 0; ) {
+						if ( j0 < bsize ) {
+							s0 = j0;
+							j0 = 0;
+						} else {
+							s0 = bsize;
+							j0 -= bsize;
+						}
+						// Compute the index offset for the first output ndarray element in the current block...
+						iy = oy1 + ( j0*sy[0] );
+
+						// Compute the loop offset increment...
+						dy1 = sy[1] - ( s0*sy[0] );
+
+						// Iterate over the ndarray dimensions...
+						for ( i4 = 0; i4 < s4; i4++ ) {
+							for ( i3 = 0; i3 < s3; i3++ ) {
+								for ( i2 = 0; i2 < s2; i2++ ) {
+									for ( i1 = 0; i1 < s1; i1++ ) {
+										for ( i0 = 0; i0 < s0; i0++ ) {
+											set( ybuf, iy, get( xbuf, ix ) );
+											iy += dy0;
+										}
+										iy += dy1;
+									}
+									iy += dy2;
+								}
+								iy += dy3;
+							}
+							iy += dy4;
+						}
+					}
+				}
+			}
+		}
+	}
+}
+
+
+// EXPORTS //
+
+module.exports = blockedassign5d;
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/6d.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/6d.js
new file mode 100644
index 000000000000..eda1a19e3ca5
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/6d.js
@@ -0,0 +1,181 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2026 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-depth */
+
+'use strict';
+
+// MAIN //
+
+/**
+* Assigns a scalar value to every element of a six-dimensional output ndarray.
+*
+* @private
+* @param {Object} x - object containing input ndarray meta data
+* @param {*} x.dtype - data type
+* @param {Collection} x.data - data buffer
+* @param {NonNegativeIntegerArray} x.shape - dimensions
+* @param {IntegerArray} x.strides - stride lengths
+* @param {NonNegativeInteger} x.offset - index offset
+* @param {string} x.order - specifies whether `x` is row-major (C-style) or column-major (Fortran-style)
+* @param {Object} y - object containing output ndarray meta data
+* @param {*} y.dtype - data type
+* @param {Collection} y.data - data buffer
+* @param {NonNegativeIntegerArray} y.shape - dimensions
+* @param {IntegerArray} y.strides - stride lengths
+* @param {NonNegativeInteger} y.offset - index offset
+* @param {string} y.order - specifies whether `y` is row-major (C-style) or column-major (Fortran-style)
+* @param {boolean} isRowMajor - boolean indicating if provided arrays are in row-major order
+* @returns {void}
+*
+* @example
+* var Float64Array = require( '@stdlib/array/float64' );
+*
+* // Create data buffers:
+* var xbuf = new Float64Array( [ 2.0 ] );
+* var ybuf = new Float64Array( 6 );
+*
+* // Define the shape of the output array:
+* var shape = [ 1, 1, 1, 3, 1, 2 ];
+*
+* // Define the array strides:
+* var sx = [ 0 ];
+* var sy = [ 2, 2, 2, 2, 2, 1 ];
+*
+* // Define the index offsets:
+* var ox = 0;
+* var oy = 0;
+*
+* // Create the input and output ndarray-like objects:
+* var x = {
+*     'dtype': 'float64',
+*     'data': xbuf,
+*     'shape': [],
+*     'strides': sx,
+*     'offset': ox,
+*     'order': 'row-major'
+* };
+* var y = {
+*     'dtype': 'float64',
+*     'data': ybuf,
+*     'shape': shape,
+*     'strides': sy,
+*     'offset': oy,
+*     'order': 'row-major'
+* };
+*
+* // Assign scalar:
+* assign6d( x, y, true );
+*
+* console.log( y.data );
+* // => <Float64Array>[ 2.0, 2.0, 2.0, 2.0, 2.0, 2.0 ]
+*/
+function assign6d( x, y, isRowMajor ) {
+	var xbuf;
+	var ybuf;
+	var dy0;
+	var dy1;
+	var dy2;
+	var dy3;
+	var dy4;
+	var dy5;
+	var sh;
+	var S0;
+	var S1;
+	var S2;
+	var S3;
+	var S4;
+	var S5;
+	var sy;
+	var ix;
+	var iy;
+	var i0;
+	var i1;
+	var i2;
+	var i3;
+	var i4;
+	var i5;
+
+	// Note on variable naming convention: S#, dy#, i# where # corresponds to the loop number, with `0` being the innermost loop...
+
+	// Extract loop variables for purposes of loop interchange: dimensions and loop offset (pointer) increments...
+	sh = y.shape;
+	sy = y.strides;
+	if ( isRowMajor ) {
+		// For row-major ndarrays, the last dimensions have the fastest changing indices...
+		S0 = sh[ 5 ];
+		S1 = sh[ 4 ];
+		S2 = sh[ 3 ];
+		S3 = sh[ 2 ];
+		S4 = sh[ 1 ];
+		S5 = sh[ 0 ];
+		dy0 = sy[ 5 ];
+		dy1 = sy[ 4 ] - ( S0*sy[5] );
+		dy2 = sy[ 3 ] - ( S1*sy[4] );
+		dy3 = sy[ 2 ] - ( S2*sy[3] );
+		dy4 = sy[ 1 ] - ( S3*sy[2] );
+		dy5 = sy[ 0 ] - ( S4*sy[1] );
+	} else { // order === 'column-major'
+		// For column-major ndarrays, the first dimensions have the fastest changing indices...
+		S0 = sh[ 0 ];
+		S1 = sh[ 1 ];
+		S2 = sh[ 2 ];
+		S3 = sh[ 3 ];
+		S4 = sh[ 4 ];
+		S5 = sh[ 5 ];
+		dy0 = sy[ 0 ];
+		dy1 = sy[ 1 ] - ( S0*sy[0] );
+		dy2 = sy[ 2 ] - ( S1*sy[1] );
+		dy3 = sy[ 3 ] - ( S2*sy[2] );
+		dy4 = sy[ 4 ] - ( S3*sy[3] );
+		dy5 = sy[ 5 ] - ( S4*sy[4] );
+	}
+	// Set the pointers to the first indexed elements in the respective ndarrays...
+	ix = x.offset;
+	iy = y.offset;
+
+	// Cache references to the input and output ndarray buffers...
+	xbuf = x.data;
+	ybuf = y.data;
+
+	// Iterate over the ndarray dimensions...
+	for ( i5 = 0; i5 < S5; i5++ ) {
+		for ( i4 = 0; i4 < S4; i4++ ) {
+			for ( i3 = 0; i3 < S3; i3++ ) {
+				for ( i2 = 0; i2 < S2; i2++ ) {
+					for ( i1 = 0; i1 < S1; i1++ ) {
+						for ( i0 = 0; i0 < S0; i0++ ) {
+							ybuf[ iy ] = xbuf[ ix ];
+							iy += dy0;
+						}
+						iy += dy1;
+					}
+					iy += dy2;
+				}
+				iy += dy3;
+			}
+			iy += dy4;
+		}
+		iy += dy5;
+	}
+}
+
+
+// EXPORTS //
+
+module.exports = assign6d;
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/6d_accessors.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/6d_accessors.js
new file mode 100644
index 000000000000..f48ba877f20e
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/6d_accessors.js
@@ -0,0 +1,208 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2026 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-depth */
+
+'use strict';
+
+// MAIN //
+
+/**
+* Assigns a scalar value to every element of a six-dimensional output ndarray.
+*
+* @private
+* @param {Object} x - object containing input ndarray meta data
+* @param {*} x.dtype - data type
+* @param {Collection} x.data - data buffer
+* @param {NonNegativeIntegerArray} x.shape - dimensions
+* @param {IntegerArray} x.strides - stride lengths
+* @param {NonNegativeInteger} x.offset - index offset
+* @param {string} x.order - specifies whether `x` is row-major (C-style) or column-major (Fortran-style)
+* @param {Array<Function>} x.accessors - data buffer accessors
+* @param {Object} y - object containing output ndarray meta data
+* @param {*} y.dtype - data type
+* @param {Collection} y.data - data buffer
+* @param {NonNegativeIntegerArray} y.shape - dimensions
+* @param {IntegerArray} y.strides - stride lengths
+* @param {NonNegativeInteger} y.offset - index offset
+* @param {string} y.order - specifies whether `y` is row-major (C-style) or column-major (Fortran-style)
+* @param {Array<Function>} y.accessors - data buffer accessors
+* @param {boolean} isRowMajor - boolean indicating if provided arrays are in row-major order
+* @returns {void}
+*
+* @example
+* var Complex64Array = require( '@stdlib/array/complex64' );
+* var Complex64 = require( '@stdlib/complex/float32/ctor' );
+* var realf = require( '@stdlib/complex/float32/real' );
+* var imagf = require( '@stdlib/complex/float32/imag' );
+*
+* // Create data buffers:
+* var xbuf = new Complex64Array( [ 2.0, 2.0 ] );
+* var ybuf = new Complex64Array( 6 );
+*
+* // Define the shape of the output array:
+* var shape = [ 1, 1, 1, 3, 1, 2 ];
+*
+* // Define the array strides:
+* var sx = [ 0 ];
+* var sy = [ 2, 2, 2, 2, 2, 1 ];
+*
+* // Define the index offsets:
+* var ox = 0;
+* var oy = 0;
+*
+* // Define getters and setters:
+* function getter( buf, idx ) {
+*     return buf.get( idx );
+* }
+*
+* function setter( buf, idx, value ) {
+*     buf.set( value, idx );
+* }
+*
+* // Create the input and output ndarray-like objects:
+* var x = {
+*     'dtype': 'complex64',
+*     'data': xbuf,
+*     'shape': [],
+*     'strides': sx,
+*     'offset': ox,
+*     'order': 'row-major',
+*     'accessors': [ getter, setter ]
+* };
+* var y = {
+*     'dtype': 'complex64',
+*     'data': ybuf,
+*     'shape': shape,
+*     'strides': sy,
+*     'offset': oy,
+*     'order': 'row-major',
+*     'accessors': [ getter, setter ]
+* };
+*
+* // Assign scalar:
+* assign6d( x, y, true );
+*
+* var v = y.data.get( 0 );
+*
+* var re = realf( v );
+* // returns 2.0
+*
+* var im = imagf( v );
+* // returns 2.0
+*/
+function assign6d( x, y, isRowMajor ) {
+	var xbuf;
+	var ybuf;
+	var get;
+	var set;
+	var dy0;
+	var dy1;
+	var dy2;
+	var dy3;
+	var dy4;
+	var dy5;
+	var sh;
+	var S0;
+	var S1;
+	var S2;
+	var S3;
+	var S4;
+	var S5;
+	var sy;
+	var ix;
+	var iy;
+	var i0;
+	var i1;
+	var i2;
+	var i3;
+	var i4;
+	var i5;
+
+	// Note on variable naming convention: S#, dy#, i# where # corresponds to the loop number, with `0` being the innermost loop...
+
+	// Extract loop variables for purposes of loop interchange: dimensions and loop offset (pointer) increments...
+	sh = y.shape;
+	sy = y.strides;
+	if ( isRowMajor ) {
+		// For row-major ndarrays, the last dimensions have the fastest changing indices...
+		S0 = sh[ 5 ];
+		S1 = sh[ 4 ];
+		S2 = sh[ 3 ];
+		S3 = sh[ 2 ];
+		S4 = sh[ 1 ];
+		S5 = sh[ 0 ];
+		dy0 = sy[ 5 ];
+		dy1 = sy[ 4 ] - ( S0*sy[5] );
+		dy2 = sy[ 3 ] - ( S1*sy[4] );
+		dy3 = sy[ 2 ] - ( S2*sy[3] );
+		dy4 = sy[ 1 ] - ( S3*sy[2] );
+		dy5 = sy[ 0 ] - ( S4*sy[1] );
+	} else { // order === 'column-major'
+		// For column-major ndarrays, the first dimensions have the fastest changing indices...
+		S0 = sh[ 0 ];
+		S1 = sh[ 1 ];
+		S2 = sh[ 2 ];
+		S3 = sh[ 3 ];
+		S4 = sh[ 4 ];
+		S5 = sh[ 5 ];
+		dy0 = sy[ 0 ];
+		dy1 = sy[ 1 ] - ( S0*sy[0] );
+		dy2 = sy[ 2 ] - ( S1*sy[1] );
+		dy3 = sy[ 3 ] - ( S2*sy[2] );
+		dy4 = sy[ 4 ] - ( S3*sy[3] );
+		dy5 = sy[ 5 ] - ( S4*sy[4] );
+	}
+	// Set the pointers to the first indexed elements in the respective ndarrays...
+	ix = x.offset;
+	iy = y.offset;
+
+	// Cache references to the input and output ndarray buffers...
+	xbuf = x.data;
+	ybuf = y.data;
+
+	// Cache accessors:
+	get = x.accessors[0];
+	set = y.accessors[1];
+
+	// Iterate over the ndarray dimensions...
+	for ( i5 = 0; i5 < S5; i5++ ) {
+		for ( i4 = 0; i4 < S4; i4++ ) {
+			for ( i3 = 0; i3 < S3; i3++ ) {
+				for ( i2 = 0; i2 < S2; i2++ ) {
+					for ( i1 = 0; i1 < S1; i1++ ) {
+						for ( i0 = 0; i0 < S0; i0++ ) {
+							set( ybuf, iy, get( xbuf, ix ) );
+							iy += dy0;
+						}
+						iy += dy1;
+					}
+					iy += dy2;
+				}
+				iy += dy3;
+			}
+			iy += dy4;
+		}
+		iy += dy5;
+	}
+}
+
+
+// EXPORTS //
+
+module.exports = assign6d;
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/6d_blocked.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/6d_blocked.js
new file mode 100644
index 000000000000..0739fcfa224a
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/6d_blocked.js
@@ -0,0 +1,249 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2026 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-depth */
+
+'use strict';
+
+// MODULES //
+
+var loopOrder = require( '@stdlib/ndarray/base/nullary-loop-interchange-order' );
+var blockSize = require( '@stdlib/ndarray/base/nullary-tiling-block-size' );
+
+
+// MAIN //
+
+/**
+* Assigns a scalar value to every element of a six-dimensional output ndarray via loop blocking.
+*
+* @private
+* @param {Object} x - object containing input ndarray meta data
+* @param {*} x.dtype - data type
+* @param {Collection} x.data - data buffer
+* @param {NonNegativeIntegerArray} x.shape - dimensions
+* @param {IntegerArray} x.strides - stride lengths
+* @param {NonNegativeInteger} x.offset - index offset
+* @param {string} x.order - specifies whether `x` is row-major (C-style) or column-major (Fortran-style)
+* @param {Object} y - object containing output ndarray meta data
+* @param {*} y.dtype - data type
+* @param {Collection} y.data - data buffer
+* @param {NonNegativeIntegerArray} y.shape - dimensions
+* @param {IntegerArray} y.strides - stride lengths
+* @param {NonNegativeInteger} y.offset - index offset
+* @param {string} y.order - specifies whether `y` is row-major (C-style) or column-major (Fortran-style)
+* @returns {void}
+*
+* @example
+* var Float64Array = require( '@stdlib/array/float64' );
+*
+* // Create data buffers:
+* var xbuf = new Float64Array( [ 2.0 ] );
+* var ybuf = new Float64Array( 6 );
+*
+* // Define the shape of the output array:
+* var shape = [ 1, 1, 1, 3, 1, 2 ];
+*
+* // Define the array strides:
+* var sx = [ 0 ];
+* var sy = [ 2, 2, 2, 2, 2, 1 ];
+*
+* // Define the index offsets:
+* var ox = 0;
+* var oy = 0;
+*
+* // Create the input and output ndarray-like objects:
+* var x = {
+*     'dtype': 'float64',
+*     'data': xbuf,
+*     'shape': [],
+*     'strides': sx,
+*     'offset': ox,
+*     'order': 'row-major'
+* };
+* var y = {
+*     'dtype': 'float64',
+*     'data': ybuf,
+*     'shape': shape,
+*     'strides': sy,
+*     'offset': oy,
+*     'order': 'row-major'
+* };
+*
+* // Assign scalar:
+* blockedassign6d( x, y );
+*
+* console.log( y.data );
+* // => <Float64Array>[ 2.0, 2.0, 2.0, 2.0, 2.0, 2.0 ]
+*/
+function blockedassign6d( x, y ) { // eslint-disable-line max-statements
+	var bsize;
+	var xbuf;
+	var ybuf;
+	var dy0;
+	var dy1;
+	var dy2;
+	var dy3;
+	var dy4;
+	var dy5;
+	var oy1;
+	var oy2;
+	var oy3;
+	var oy4;
+	var oy5;
+	var sh;
+	var s0;
+	var s1;
+	var s2;
+	var s3;
+	var s4;
+	var s5;
+	var sy;
+	var oy;
+	var ix;
+	var iy;
+	var i0;
+	var i1;
+	var i2;
+	var i3;
+	var i4;
+	var i5;
+	var j0;
+	var j1;
+	var j2;
+	var j3;
+	var j4;
+	var j5;
+	var o;
+
+	// Note on variable naming convention: s#, dy#, i#, j# where # corresponds to the loop number, with `0` being the innermost loop...
+
+	// Resolve the loop interchange order:
+	o = loopOrder( y.shape, y.strides );
+	sh = o.sh;
+	sy = o.sx;
+
+	// Determine the block size:
+	bsize = blockSize( y.dtype );
+
+	// Cache the indices of the first indexed elements in the respective ndarrays...
+	ix = x.offset;
+	oy = y.offset;
+
+	// Cache references to the input and output ndarray buffers...
+	xbuf = x.data;
+	ybuf = y.data;
+
+	// Cache the offset increment for the innermost loop...
+	dy0 = sy[0];
+
+	// Iterate over blocks...
+	for ( j5 = sh[5]; j5 > 0; ) {
+		if ( j5 < bsize ) {
+			s5 = j5;
+			j5 = 0;
+		} else {
+			s5 = bsize;
+			j5 -= bsize;
+		}
+		oy5 = oy + ( j5*sy[5] );
+		for ( j4 = sh[4]; j4 > 0; ) {
+			if ( j4 < bsize ) {
+				s4 = j4;
+				j4 = 0;
+			} else {
+				s4 = bsize;
+				j4 -= bsize;
+			}
+			dy5 = sy[5] - ( s4*sy[4] );
+			oy4 = oy5 + ( j4*sy[4] );
+			for ( j3 = sh[3]; j3 > 0; ) {
+				if ( j3 < bsize ) {
+					s3 = j3;
+					j3 = 0;
+				} else {
+					s3 = bsize;
+					j3 -= bsize;
+				}
+				dy4 = sy[4] - ( s3*sy[3] );
+				oy3 = oy4 + ( j3*sy[3] );
+				for ( j2 = sh[2]; j2 > 0; ) {
+					if ( j2 < bsize ) {
+						s2 = j2;
+						j2 = 0;
+					} else {
+						s2 = bsize;
+						j2 -= bsize;
+					}
+					dy3 = sy[3] - ( s2*sy[2] );
+					oy2 = oy3 + ( j2*sy[2] );
+					for ( j1 = sh[1]; j1 > 0; ) {
+						if ( j1 < bsize ) {
+							s1 = j1;
+							j1 = 0;
+						} else {
+							s1 = bsize;
+							j1 -= bsize;
+						}
+						dy2 = sy[2] - ( s1*sy[1] );
+						oy1 = oy2 + ( j1*sy[1] );
+						for ( j0 = sh[0]; j0 > 0; ) {
+							if ( j0 < bsize ) {
+								s0 = j0;
+								j0 = 0;
+							} else {
+								s0 = bsize;
+								j0 -= bsize;
+							}
+							// Compute the index offset for the first output ndarray element in the current block...
+							iy = oy1 + ( j0*sy[0] );
+
+							// Compute the loop offset increment...
+							dy1 = sy[1] - ( s0*sy[0] );
+
+							// Iterate over the ndarray dimensions...
+							for ( i5 = 0; i5 < s5; i5++ ) {
+								for ( i4 = 0; i4 < s4; i4++ ) {
+									for ( i3 = 0; i3 < s3; i3++ ) {
+										for ( i2 = 0; i2 < s2; i2++ ) {
+											for ( i1 = 0; i1 < s1; i1++ ) {
+												for ( i0 = 0; i0 < s0; i0++ ) {
+													ybuf[ iy ] = xbuf[ ix ];
+													iy += dy0;
+												}
+												iy += dy1;
+											}
+											iy += dy2;
+										}
+										iy += dy3;
+									}
+									iy += dy4;
+								}
+								iy += dy5;
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+}
+
+
+// EXPORTS //
+
+module.exports = blockedassign6d;
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/6d_blocked_accessors.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/6d_blocked_accessors.js
new file mode 100644
index 000000000000..25b6c5d1e4af
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/6d_blocked_accessors.js
@@ -0,0 +1,276 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2026 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-depth, max-len */
+
+'use strict';
+
+// MODULES //
+
+var loopOrder = require( '@stdlib/ndarray/base/nullary-loop-interchange-order' );
+var blockSize = require( '@stdlib/ndarray/base/nullary-tiling-block-size' );
+
+
+// MAIN //
+
+/**
+* Assigns a scalar value to every element of a six-dimensional output ndarray via loop blocking.
+*
+* @private
+* @param {Object} x - object containing input ndarray meta data
+* @param {*} x.dtype - data type
+* @param {Collection} x.data - data buffer
+* @param {NonNegativeIntegerArray} x.shape - dimensions
+* @param {IntegerArray} x.strides - stride lengths
+* @param {NonNegativeInteger} x.offset - index offset
+* @param {string} x.order - specifies whether `x` is row-major (C-style) or column-major (Fortran-style)
+* @param {Array<Function>} x.accessors - data buffer accessors
+* @param {Object} y - object containing output ndarray meta data
+* @param {*} y.dtype - data type
+* @param {Collection} y.data - data buffer
+* @param {NonNegativeIntegerArray} y.shape - dimensions
+* @param {IntegerArray} y.strides - stride lengths
+* @param {NonNegativeInteger} y.offset - index offset
+* @param {string} y.order - specifies whether `y` is row-major (C-style) or column-major (Fortran-style)
+* @param {Array<Function>} y.accessors - data buffer accessors
+* @returns {void}
+*
+* @example
+* var Complex64Array = require( '@stdlib/array/complex64' );
+* var Complex64 = require( '@stdlib/complex/float32/ctor' );
+* var realf = require( '@stdlib/complex/float32/real' );
+* var imagf = require( '@stdlib/complex/float32/imag' );
+*
+* // Create data buffers:
+* var xbuf = new Complex64Array( [ 2.0, 2.0 ] );
+* var ybuf = new Complex64Array( 6 );
+*
+* // Define the shape of the output array:
+* var shape = [ 1, 1, 1, 3, 1, 2 ];
+*
+* // Define the array strides:
+* var sx = [ 0 ];
+* var sy = [ 2, 2, 2, 2, 2, 1 ];
+*
+* // Define the index offsets:
+* var ox = 0;
+* var oy = 0;
+*
+* // Define getters and setters:
+* function getter( buf, idx ) {
+*     return buf.get( idx );
+* }
+*
+* function setter( buf, idx, value ) {
+*     buf.set( value, idx );
+* }
+*
+* // Create the input and output ndarray-like objects:
+* var x = {
+*     'dtype': 'complex64',
+*     'data': xbuf,
+*     'shape': [],
+*     'strides': sx,
+*     'offset': ox,
+*     'order': 'row-major',
+*     'accessors': [ getter, setter ]
+* };
+* var y = {
+*     'dtype': 'complex64',
+*     'data': ybuf,
+*     'shape': shape,
+*     'strides': sy,
+*     'offset': oy,
+*     'order': 'row-major',
+*     'accessors': [ getter, setter ]
+* };
+*
+* // Assign scalar:
+* blockedassign6d( x, y );
+*
+* var v = y.data.get( 0 );
+*
+* var re = realf( v );
+* // returns 2.0
+*
+* var im = imagf( v );
+* // returns 2.0
+*/
+function blockedassign6d( x, y ) { // eslint-disable-line max-statements
+	var bsize;
+	var xbuf;
+	var ybuf;
+	var get;
+	var set;
+	var dy0;
+	var dy1;
+	var dy2;
+	var dy3;
+	var dy4;
+	var dy5;
+	var oy1;
+	var oy2;
+	var oy3;
+	var oy4;
+	var oy5;
+	var sh;
+	var s0;
+	var s1;
+	var s2;
+	var s3;
+	var s4;
+	var s5;
+	var sy;
+	var oy;
+	var ix;
+	var iy;
+	var i0;
+	var i1;
+	var i2;
+	var i3;
+	var i4;
+	var i5;
+	var j0;
+	var j1;
+	var j2;
+	var j3;
+	var j4;
+	var j5;
+	var o;
+
+	// Note on variable naming convention: s#, dy#, i#, j# where # corresponds to the loop number, with `0` being the innermost loop...
+
+	// Resolve the loop interchange order:
+	o = loopOrder( y.shape, y.strides );
+	sh = o.sh;
+	sy = o.sx;
+
+	// Determine the block size:
+	bsize = blockSize( y.dtype );
+
+	// Cache the indices of the first indexed elements in the respective ndarrays...
+	ix = x.offset;
+	oy = y.offset;
+
+	// Cache references to the input and output ndarray buffers...
+	xbuf = x.data;
+	ybuf = y.data;
+
+	// Cache the offset increment for the innermost loop...
+	dy0 = sy[0];
+
+	// Cache accessors:
+	get = x.accessors[0];
+	set = y.accessors[1];
+
+	// Iterate over blocks...
+	for ( j5 = sh[5]; j5 > 0; ) {
+		if ( j5 < bsize ) {
+			s5 = j5;
+			j5 = 0;
+		} else {
+			s5 = bsize;
+			j5 -= bsize;
+		}
+		oy5 = oy + ( j5*sy[5] );
+		for ( j4 = sh[4]; j4 > 0; ) {
+			if ( j4 < bsize ) {
+				s4 = j4;
+				j4 = 0;
+			} else {
+				s4 = bsize;
+				j4 -= bsize;
+			}
+			dy5 = sy[5] - ( s4*sy[4] );
+			oy4 = oy5 + ( j4*sy[4] );
+			for ( j3 = sh[3]; j3 > 0; ) {
+				if ( j3 < bsize ) {
+					s3 = j3;
+					j3 = 0;
+				} else {
+					s3 = bsize;
+					j3 -= bsize;
+				}
+				dy4 = sy[4] - ( s3*sy[3] );
+				oy3 = oy4 + ( j3*sy[3] );
+				for ( j2 = sh[2]; j2 > 0; ) {
+					if ( j2 < bsize ) {
+						s2 = j2;
+						j2 = 0;
+					} else {
+						s2 = bsize;
+						j2 -= bsize;
+					}
+					dy3 = sy[3] - ( s2*sy[2] );
+					oy2 = oy3 + ( j2*sy[2] );
+					for ( j1 = sh[1]; j1 > 0; ) {
+						if ( j1 < bsize ) {
+							s1 = j1;
+							j1 = 0;
+						} else {
+							s1 = bsize;
+							j1 -= bsize;
+						}
+						dy2 = sy[2] - ( s1*sy[1] );
+						oy1 = oy2 + ( j1*sy[1] );
+						for ( j0 = sh[0]; j0 > 0; ) {
+							if ( j0 < bsize ) {
+								s0 = j0;
+								j0 = 0;
+							} else {
+								s0 = bsize;
+								j0 -= bsize;
+							}
+							// Compute the index offset for the first output ndarray element in the current block...
+							iy = oy1 + ( j0*sy[0] );
+
+							// Compute the loop offset increment...
+							dy1 = sy[1] - ( s0*sy[0] );
+
+							// Iterate over the ndarray dimensions...
+							for ( i5 = 0; i5 < s5; i5++ ) {
+								for ( i4 = 0; i4 < s4; i4++ ) {
+									for ( i3 = 0; i3 < s3; i3++ ) {
+										for ( i2 = 0; i2 < s2; i2++ ) {
+											for ( i1 = 0; i1 < s1; i1++ ) {
+												for ( i0 = 0; i0 < s0; i0++ ) {
+													set( ybuf, iy, get( xbuf, ix ) );
+													iy += dy0;
+												}
+												iy += dy1;
+											}
+											iy += dy2;
+										}
+										iy += dy3;
+									}
+									iy += dy4;
+								}
+								iy += dy5;
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+}
+
+
+// EXPORTS //
+
+module.exports = blockedassign6d;
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/7d.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/7d.js
new file mode 100644
index 000000000000..ca7c41e086f0
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/7d.js
@@ -0,0 +1,191 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2026 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-depth */
+
+'use strict';
+
+// MAIN //
+
+/**
+* Assigns a scalar value to every element of a seven-dimensional output ndarray.
+*
+* @private
+* @param {Object} x - object containing input ndarray meta data
+* @param {*} x.dtype - data type
+* @param {Collection} x.data - data buffer
+* @param {NonNegativeIntegerArray} x.shape - dimensions
+* @param {IntegerArray} x.strides - stride lengths
+* @param {NonNegativeInteger} x.offset - index offset
+* @param {string} x.order - specifies whether `x` is row-major (C-style) or column-major (Fortran-style)
+* @param {Object} y - object containing output ndarray meta data
+* @param {*} y.dtype - data type
+* @param {Collection} y.data - data buffer
+* @param {NonNegativeIntegerArray} y.shape - dimensions
+* @param {IntegerArray} y.strides - stride lengths
+* @param {NonNegativeInteger} y.offset - index offset
+* @param {string} y.order - specifies whether `y` is row-major (C-style) or column-major (Fortran-style)
+* @param {boolean} isRowMajor - boolean indicating if provided arrays are in row-major order
+* @returns {void}
+*
+* @example
+* var Float64Array = require( '@stdlib/array/float64' );
+*
+* // Create data buffers:
+* var xbuf = new Float64Array( [ 2.0 ] );
+* var ybuf = new Float64Array( 6 );
+*
+* // Define the shape of the output array:
+* var shape = [ 1, 1, 1, 1, 3, 1, 2 ];
+*
+* // Define the array strides:
+* var sx = [ 0 ];
+* var sy = [ 2, 2, 2, 2, 2, 2, 1 ];
+*
+* // Define the index offsets:
+* var ox = 0;
+* var oy = 0;
+*
+* // Create the input and output ndarray-like objects:
+* var x = {
+*     'dtype': 'float64',
+*     'data': xbuf,
+*     'shape': [],
+*     'strides': sx,
+*     'offset': ox,
+*     'order': 'row-major'
+* };
+* var y = {
+*     'dtype': 'float64',
+*     'data': ybuf,
+*     'shape': shape,
+*     'strides': sy,
+*     'offset': oy,
+*     'order': 'row-major'
+* };
+*
+* // Assign scalar:
+* assign7d( x, y, true );
+*
+* console.log( y.data );
+* // => <Float64Array>[ 2.0, 2.0, 2.0, 2.0, 2.0, 2.0 ]
+*/
+function assign7d( x, y, isRowMajor ) {
+	var xbuf;
+	var ybuf;
+	var dy0;
+	var dy1;
+	var dy2;
+	var dy3;
+	var dy4;
+	var dy5;
+	var dy6;
+	var sh;
+	var S0;
+	var S1;
+	var S2;
+	var S3;
+	var S4;
+	var S5;
+	var S6;
+	var sy;
+	var ix;
+	var iy;
+	var i0;
+	var i1;
+	var i2;
+	var i3;
+	var i4;
+	var i5;
+	var i6;
+
+	// Note on variable naming convention: S#, dy#, i# where # corresponds to the loop number, with `0` being the innermost loop...
+
+	// Extract loop variables for purposes of loop interchange: dimensions and loop offset (pointer) increments...
+	sh = y.shape;
+	sy = y.strides;
+	if ( isRowMajor ) {
+		// For row-major ndarrays, the last dimensions have the fastest changing indices...
+		S0 = sh[ 6 ];
+		S1 = sh[ 5 ];
+		S2 = sh[ 4 ];
+		S3 = sh[ 3 ];
+		S4 = sh[ 2 ];
+		S5 = sh[ 1 ];
+		S6 = sh[ 0 ];
+		dy0 = sy[ 6 ];
+		dy1 = sy[ 5 ] - ( S0*sy[6] );
+		dy2 = sy[ 4 ] - ( S1*sy[5] );
+		dy3 = sy[ 3 ] - ( S2*sy[4] );
+		dy4 = sy[ 2 ] - ( S3*sy[3] );
+		dy5 = sy[ 1 ] - ( S4*sy[2] );
+		dy6 = sy[ 0 ] - ( S5*sy[1] );
+	} else { // order === 'column-major'
+		// For column-major ndarrays, the first dimensions have the fastest changing indices...
+		S0 = sh[ 0 ];
+		S1 = sh[ 1 ];
+		S2 = sh[ 2 ];
+		S3 = sh[ 3 ];
+		S4 = sh[ 4 ];
+		S5 = sh[ 5 ];
+		S6 = sh[ 6 ];
+		dy0 = sy[ 0 ];
+		dy1 = sy[ 1 ] - ( S0*sy[0] );
+		dy2 = sy[ 2 ] - ( S1*sy[1] );
+		dy3 = sy[ 3 ] - ( S2*sy[2] );
+		dy4 = sy[ 4 ] - ( S3*sy[3] );
+		dy5 = sy[ 5 ] - ( S4*sy[4] );
+		dy6 = sy[ 6 ] - ( S5*sy[5] );
+	}
+	// Set the pointers to the first indexed elements in the respective ndarrays...
+	ix = x.offset;
+	iy = y.offset;
+
+	// Cache references to the input and output ndarray buffers...
+	xbuf = x.data;
+	ybuf = y.data;
+
+	// Iterate over the ndarray dimensions...
+	for ( i6 = 0; i6 < S6; i6++ ) {
+		for ( i5 = 0; i5 < S5; i5++ ) {
+			for ( i4 = 0; i4 < S4; i4++ ) {
+				for ( i3 = 0; i3 < S3; i3++ ) {
+					for ( i2 = 0; i2 < S2; i2++ ) {
+						for ( i1 = 0; i1 < S1; i1++ ) {
+							for ( i0 = 0; i0 < S0; i0++ ) {
+								ybuf[ iy ] = xbuf[ ix ];
+								iy += dy0;
+							}
+							iy += dy1;
+						}
+						iy += dy2;
+					}
+					iy += dy3;
+				}
+				iy += dy4;
+			}
+			iy += dy5;
+		}
+		iy += dy6;
+	}
+}
+
+
+// EXPORTS //
+
+module.exports = assign7d;
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/7d_accessors.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/7d_accessors.js
new file mode 100644
index 000000000000..c1c3d622e389
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/7d_accessors.js
@@ -0,0 +1,218 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2026 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-depth */
+
+'use strict';
+
+// MAIN //
+
+/**
+* Assigns a scalar value to every element of a seven-dimensional output ndarray.
+*
+* @private
+* @param {Object} x - object containing input ndarray meta data
+* @param {*} x.dtype - data type
+* @param {Collection} x.data - data buffer
+* @param {NonNegativeIntegerArray} x.shape - dimensions
+* @param {IntegerArray} x.strides - stride lengths
+* @param {NonNegativeInteger} x.offset - index offset
+* @param {string} x.order - specifies whether `x` is row-major (C-style) or column-major (Fortran-style)
+* @param {Array<Function>} x.accessors - data buffer accessors
+* @param {Object} y - object containing output ndarray meta data
+* @param {*} y.dtype - data type
+* @param {Collection} y.data - data buffer
+* @param {NonNegativeIntegerArray} y.shape - dimensions
+* @param {IntegerArray} y.strides - stride lengths
+* @param {NonNegativeInteger} y.offset - index offset
+* @param {string} y.order - specifies whether `y` is row-major (C-style) or column-major (Fortran-style)
+* @param {Array<Function>} y.accessors - data buffer accessors
+* @param {boolean} isRowMajor - boolean indicating if provided arrays are in row-major order
+* @returns {void}
+*
+* @example
+* var Complex64Array = require( '@stdlib/array/complex64' );
+* var Complex64 = require( '@stdlib/complex/float32/ctor' );
+* var realf = require( '@stdlib/complex/float32/real' );
+* var imagf = require( '@stdlib/complex/float32/imag' );
+*
+* // Create data buffers:
+* var xbuf = new Complex64Array( [ 2.0, 2.0 ] );
+* var ybuf = new Complex64Array( 6 );
+*
+* // Define the shape of the output array:
+* var shape = [ 1, 1, 1, 1, 3, 1, 2 ];
+*
+* // Define the array strides:
+* var sx = [ 0 ];
+* var sy = [ 2, 2, 2, 2, 2, 2, 1 ];
+*
+* // Define the index offsets:
+* var ox = 0;
+* var oy = 0;
+*
+* // Define getters and setters:
+* function getter( buf, idx ) {
+*     return buf.get( idx );
+* }
+*
+* function setter( buf, idx, value ) {
+*     buf.set( value, idx );
+* }
+*
+* // Create the input and output ndarray-like objects:
+* var x = {
+*     'dtype': 'complex64',
+*     'data': xbuf,
+*     'shape': [],
+*     'strides': sx,
+*     'offset': ox,
+*     'order': 'row-major',
+*     'accessors': [ getter, setter ]
+* };
+* var y = {
+*     'dtype': 'complex64',
+*     'data': ybuf,
+*     'shape': shape,
+*     'strides': sy,
+*     'offset': oy,
+*     'order': 'row-major',
+*     'accessors': [ getter, setter ]
+* };
+*
+* // Assign scalar:
+* assign7d( x, y, true );
+*
+* var v = y.data.get( 0 );
+*
+* var re = realf( v );
+* // returns 2.0
+*
+* var im = imagf( v );
+* // returns 2.0
+*/
+function assign7d( x, y, isRowMajor ) {
+	var xbuf;
+	var ybuf;
+	var get;
+	var set;
+	var dy0;
+	var dy1;
+	var dy2;
+	var dy3;
+	var dy4;
+	var dy5;
+	var dy6;
+	var sh;
+	var S0;
+	var S1;
+	var S2;
+	var S3;
+	var S4;
+	var S5;
+	var S6;
+	var sy;
+	var ix;
+	var iy;
+	var i0;
+	var i1;
+	var i2;
+	var i3;
+	var i4;
+	var i5;
+	var i6;
+
+	// Note on variable naming convention: S#, dy#, i# where # corresponds to the loop number, with `0` being the innermost loop...
+
+	// Extract loop variables for purposes of loop interchange: dimensions and loop offset (pointer) increments...
+	sh = y.shape;
+	sy = y.strides;
+	if ( isRowMajor ) {
+		// For row-major ndarrays, the last dimensions have the fastest changing indices...
+		S0 = sh[ 6 ];
+		S1 = sh[ 5 ];
+		S2 = sh[ 4 ];
+		S3 = sh[ 3 ];
+		S4 = sh[ 2 ];
+		S5 = sh[ 1 ];
+		S6 = sh[ 0 ];
+		dy0 = sy[ 6 ];
+		dy1 = sy[ 5 ] - ( S0*sy[6] );
+		dy2 = sy[ 4 ] - ( S1*sy[5] );
+		dy3 = sy[ 3 ] - ( S2*sy[4] );
+		dy4 = sy[ 2 ] - ( S3*sy[3] );
+		dy5 = sy[ 1 ] - ( S4*sy[2] );
+		dy6 = sy[ 0 ] - ( S5*sy[1] );
+	} else { // order === 'column-major'
+		// For column-major ndarrays, the first dimensions have the fastest changing indices...
+		S0 = sh[ 0 ];
+		S1 = sh[ 1 ];
+		S2 = sh[ 2 ];
+		S3 = sh[ 3 ];
+		S4 = sh[ 4 ];
+		S5 = sh[ 5 ];
+		S6 = sh[ 6 ];
+		dy0 = sy[ 0 ];
+		dy1 = sy[ 1 ] - ( S0*sy[0] );
+		dy2 = sy[ 2 ] - ( S1*sy[1] );
+		dy3 = sy[ 3 ] - ( S2*sy[2] );
+		dy4 = sy[ 4 ] - ( S3*sy[3] );
+		dy5 = sy[ 5 ] - ( S4*sy[4] );
+		dy6 = sy[ 6 ] - ( S5*sy[5] );
+	}
+	// Set the pointers to the first indexed elements in the respective ndarrays...
+	ix = x.offset;
+	iy = y.offset;
+
+	// Cache references to the input and output ndarray buffers...
+	xbuf = x.data;
+	ybuf = y.data;
+
+	// Cache accessors:
+	get = x.accessors[0];
+	set = y.accessors[1];
+
+	// Iterate over the ndarray dimensions...
+	for ( i6 = 0; i6 < S6; i6++ ) {
+		for ( i5 = 0; i5 < S5; i5++ ) {
+			for ( i4 = 0; i4 < S4; i4++ ) {
+				for ( i3 = 0; i3 < S3; i3++ ) {
+					for ( i2 = 0; i2 < S2; i2++ ) {
+						for ( i1 = 0; i1 < S1; i1++ ) {
+							for ( i0 = 0; i0 < S0; i0++ ) {
+								set( ybuf, iy, get( xbuf, ix ) );
+								iy += dy0;
+							}
+							iy += dy1;
+						}
+						iy += dy2;
+					}
+					iy += dy3;
+				}
+				iy += dy4;
+			}
+			iy += dy5;
+		}
+		iy += dy6;
+	}
+}
+
+
+// EXPORTS //
+
+module.exports = assign7d;
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/7d_blocked.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/7d_blocked.js
new file mode 100644
index 000000000000..d11393f446c5
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/7d_blocked.js
@@ -0,0 +1,268 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2026 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-depth, max-len */
+
+'use strict';
+
+// MODULES //
+
+var loopOrder = require( '@stdlib/ndarray/base/nullary-loop-interchange-order' );
+var blockSize = require( '@stdlib/ndarray/base/nullary-tiling-block-size' );
+
+
+// MAIN //
+
+/**
+* Assigns a scalar value to every element of a seven-dimensional output ndarray via loop blocking.
+*
+* @private
+* @param {Object} x - object containing input ndarray meta data
+* @param {*} x.dtype - data type
+* @param {Collection} x.data - data buffer
+* @param {NonNegativeIntegerArray} x.shape - dimensions
+* @param {IntegerArray} x.strides - stride lengths
+* @param {NonNegativeInteger} x.offset - index offset
+* @param {string} x.order - specifies whether `x` is row-major (C-style) or column-major (Fortran-style)
+* @param {Object} y - object containing output ndarray meta data
+* @param {*} y.dtype - data type
+* @param {Collection} y.data - data buffer
+* @param {NonNegativeIntegerArray} y.shape - dimensions
+* @param {IntegerArray} y.strides - stride lengths
+* @param {NonNegativeInteger} y.offset - index offset
+* @param {string} y.order - specifies whether `y` is row-major (C-style) or column-major (Fortran-style)
+* @returns {void}
+*
+* @example
+* var Float64Array = require( '@stdlib/array/float64' );
+*
+* // Create data buffers:
+* var xbuf = new Float64Array( [ 2.0 ] );
+* var ybuf = new Float64Array( 6 );
+*
+* // Define the shape of the output array:
+* var shape = [ 1, 1, 1, 1, 3, 1, 2 ];
+*
+* // Define the array strides:
+* var sx = [ 0 ];
+* var sy = [ 2, 2, 2, 2, 2, 2, 1 ];
+*
+* // Define the index offsets:
+* var ox = 0;
+* var oy = 0;
+*
+* // Create the input and output ndarray-like objects:
+* var x = {
+*     'dtype': 'float64',
+*     'data': xbuf,
+*     'shape': [],
+*     'strides': sx,
+*     'offset': ox,
+*     'order': 'row-major'
+* };
+* var y = {
+*     'dtype': 'float64',
+*     'data': ybuf,
+*     'shape': shape,
+*     'strides': sy,
+*     'offset': oy,
+*     'order': 'row-major'
+* };
+*
+* // Assign scalar:
+* blockedassign7d( x, y );
+*
+* console.log( y.data );
+* // => <Float64Array>[ 2.0, 2.0, 2.0, 2.0, 2.0, 2.0 ]
+*/
+function blockedassign7d( x, y ) { // eslint-disable-line max-statements
+	var bsize;
+	var xbuf;
+	var ybuf;
+	var dy0;
+	var dy1;
+	var dy2;
+	var dy3;
+	var dy4;
+	var dy5;
+	var dy6;
+	var oy1;
+	var oy2;
+	var oy3;
+	var oy4;
+	var oy5;
+	var oy6;
+	var sh;
+	var s0;
+	var s1;
+	var s2;
+	var s3;
+	var s4;
+	var s5;
+	var s6;
+	var sy;
+	var oy;
+	var ix;
+	var iy;
+	var i0;
+	var i1;
+	var i2;
+	var i3;
+	var i4;
+	var i5;
+	var i6;
+	var j0;
+	var j1;
+	var j2;
+	var j3;
+	var j4;
+	var j5;
+	var j6;
+	var o;
+
+	// Note on variable naming convention: s#, dy#, i#, j# where # corresponds to the loop number, with `0` being the innermost loop...
+
+	// Resolve the loop interchange order:
+	o = loopOrder( y.shape, y.strides );
+	sh = o.sh;
+	sy = o.sx;
+
+	// Determine the block size:
+	bsize = blockSize( y.dtype );
+
+	// Cache the indices of the first indexed elements in the respective ndarrays...
+	ix = x.offset;
+	oy = y.offset;
+
+	// Cache references to the input and output ndarray buffers...
+	xbuf = x.data;
+	ybuf = y.data;
+
+	// Cache the offset increment for the innermost loop...
+	dy0 = sy[0];
+
+	// Iterate over blocks...
+	for ( j6 = sh[6]; j6 > 0; ) {
+		if ( j6 < bsize ) {
+			s6 = j6;
+			j6 = 0;
+		} else {
+			s6 = bsize;
+			j6 -= bsize;
+		}
+		oy6 = oy + ( j6*sy[6] );
+		for ( j5 = sh[5]; j5 > 0; ) {
+			if ( j5 < bsize ) {
+				s5 = j5;
+				j5 = 0;
+			} else {
+				s5 = bsize;
+				j5 -= bsize;
+			}
+			dy6 = sy[6] - ( s5*sy[5] );
+			oy5 = oy6 + ( j5*sy[5] );
+			for ( j4 = sh[4]; j4 > 0; ) {
+				if ( j4 < bsize ) {
+					s4 = j4;
+					j4 = 0;
+				} else {
+					s4 = bsize;
+					j4 -= bsize;
+				}
+				dy5 = sy[5] - ( s4*sy[4] );
+				oy4 = oy5 + ( j4*sy[4] );
+				for ( j3 = sh[3]; j3 > 0; ) {
+					if ( j3 < bsize ) {
+						s3 = j3;
+						j3 = 0;
+					} else {
+						s3 = bsize;
+						j3 -= bsize;
+					}
+					dy4 = sy[4] - ( s3*sy[3] );
+					oy3 = oy4 + ( j3*sy[3] );
+					for ( j2 = sh[2]; j2 > 0; ) {
+						if ( j2 < bsize ) {
+							s2 = j2;
+							j2 = 0;
+						} else {
+							s2 = bsize;
+							j2 -= bsize;
+						}
+						dy3 = sy[3] - ( s2*sy[2] );
+						oy2 = oy3 + ( j2*sy[2] );
+						for ( j1 = sh[1]; j1 > 0; ) {
+							if ( j1 < bsize ) {
+								s1 = j1;
+								j1 = 0;
+							} else {
+								s1 = bsize;
+								j1 -= bsize;
+							}
+							dy2 = sy[2] - ( s1*sy[1] );
+							oy1 = oy2 + ( j1*sy[1] );
+							for ( j0 = sh[0]; j0 > 0; ) {
+								if ( j0 < bsize ) {
+									s0 = j0;
+									j0 = 0;
+								} else {
+									s0 = bsize;
+									j0 -= bsize;
+								}
+								// Compute the index offset for the first output ndarray element in the current block...
+								iy = oy1 + ( j0*sy[0] );
+
+								// Compute the loop offset increment...
+								dy1 = sy[1] - ( s0*sy[0] );
+
+								// Iterate over the ndarray dimensions...
+								for ( i6 = 0; i6 < s6; i6++ ) {
+									for ( i5 = 0; i5 < s5; i5++ ) {
+										for ( i4 = 0; i4 < s4; i4++ ) {
+											for ( i3 = 0; i3 < s3; i3++ ) {
+												for ( i2 = 0; i2 < s2; i2++ ) {
+													for ( i1 = 0; i1 < s1; i1++ ) {
+														for ( i0 = 0; i0 < s0; i0++ ) {
+															ybuf[ iy ] = xbuf[ ix ];
+															iy += dy0;
+														}
+														iy += dy1;
+													}
+													iy += dy2;
+												}
+												iy += dy3;
+											}
+											iy += dy4;
+										}
+										iy += dy5;
+									}
+									iy += dy6;
+								}
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+}
+
+
+// EXPORTS //
+
+module.exports = blockedassign7d;
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/7d_blocked_accessors.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/7d_blocked_accessors.js
new file mode 100644
index 000000000000..c4be0e7c4b57
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/7d_blocked_accessors.js
@@ -0,0 +1,295 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2026 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-depth, max-len */
+
+'use strict';
+
+// MODULES //
+
+var loopOrder = require( '@stdlib/ndarray/base/nullary-loop-interchange-order' );
+var blockSize = require( '@stdlib/ndarray/base/nullary-tiling-block-size' );
+
+
+// MAIN //
+
+/**
+* Assigns a scalar value to every element of a seven-dimensional output ndarray via loop blocking.
+*
+* @private
+* @param {Object} x - object containing input ndarray meta data
+* @param {*} x.dtype - data type
+* @param {Collection} x.data - data buffer
+* @param {NonNegativeIntegerArray} x.shape - dimensions
+* @param {IntegerArray} x.strides - stride lengths
+* @param {NonNegativeInteger} x.offset - index offset
+* @param {string} x.order - specifies whether `x` is row-major (C-style) or column-major (Fortran-style)
+* @param {Array<Function>} x.accessors - data buffer accessors
+* @param {Object} y - object containing output ndarray meta data
+* @param {*} y.dtype - data type
+* @param {Collection} y.data - data buffer
+* @param {NonNegativeIntegerArray} y.shape - dimensions
+* @param {IntegerArray} y.strides - stride lengths
+* @param {NonNegativeInteger} y.offset - index offset
+* @param {string} y.order - specifies whether `y` is row-major (C-style) or column-major (Fortran-style)
+* @param {Array<Function>} y.accessors - data buffer accessors
+* @returns {void}
+*
+* @example
+* var Complex64Array = require( '@stdlib/array/complex64' );
+* var Complex64 = require( '@stdlib/complex/float32/ctor' );
+* var realf = require( '@stdlib/complex/float32/real' );
+* var imagf = require( '@stdlib/complex/float32/imag' );
+*
+* // Create data buffers:
+* var xbuf = new Complex64Array( [ 2.0, 2.0 ] );
+* var ybuf = new Complex64Array( 6 );
+*
+* // Define the shape of the output array:
+* var shape = [ 1, 1, 1, 1, 3, 1, 2 ];
+*
+* // Define the array strides:
+* var sx = [ 0 ];
+* var sy = [ 2, 2, 2, 2, 2, 2, 1 ];
+*
+* // Define the index offsets:
+* var ox = 0;
+* var oy = 0;
+*
+* // Define getters and setters:
+* function getter( buf, idx ) {
+*     return buf.get( idx );
+* }
+*
+* function setter( buf, idx, value ) {
+*     buf.set( value, idx );
+* }
+*
+* // Create the input and output ndarray-like objects:
+* var x = {
+*     'dtype': 'complex64',
+*     'data': xbuf,
+*     'shape': [],
+*     'strides': sx,
+*     'offset': ox,
+*     'order': 'row-major',
+*     'accessors': [ getter, setter ]
+* };
+* var y = {
+*     'dtype': 'complex64',
+*     'data': ybuf,
+*     'shape': shape,
+*     'strides': sy,
+*     'offset': oy,
+*     'order': 'row-major',
+*     'accessors': [ getter, setter ]
+* };
+*
+* // Assign scalar:
+* blockedassign7d( x, y );
+*
+* var v = y.data.get( 0 );
+*
+* var re = realf( v );
+* // returns 2.0
+*
+* var im = imagf( v );
+* // returns 2.0
+*/
+function blockedassign7d( x, y ) { // eslint-disable-line max-statements
+	var bsize;
+	var xbuf;
+	var ybuf;
+	var get;
+	var set;
+	var dy0;
+	var dy1;
+	var dy2;
+	var dy3;
+	var dy4;
+	var dy5;
+	var dy6;
+	var oy1;
+	var oy2;
+	var oy3;
+	var oy4;
+	var oy5;
+	var oy6;
+	var sh;
+	var s0;
+	var s1;
+	var s2;
+	var s3;
+	var s4;
+	var s5;
+	var s6;
+	var sy;
+	var oy;
+	var ix;
+	var iy;
+	var i0;
+	var i1;
+	var i2;
+	var i3;
+	var i4;
+	var i5;
+	var i6;
+	var j0;
+	var j1;
+	var j2;
+	var j3;
+	var j4;
+	var j5;
+	var j6;
+	var o;
+
+	// Note on variable naming convention: s#, dy#, i#, j# where # corresponds to the loop number, with `0` being the innermost loop...
+
+	// Resolve the loop interchange order:
+	o = loopOrder( y.shape, y.strides );
+	sh = o.sh;
+	sy = o.sx;
+
+	// Determine the block size:
+	bsize = blockSize( y.dtype );
+
+	// Cache the indices of the first indexed elements in the respective ndarrays...
+	ix = x.offset;
+	oy = y.offset;
+
+	// Cache references to the input and output ndarray buffers...
+	xbuf = x.data;
+	ybuf = y.data;
+
+	// Cache the offset increment for the innermost loop...
+	dy0 = sy[0];
+
+	// Cache accessors:
+	get = x.accessors[0];
+	set = y.accessors[1];
+
+	// Iterate over blocks...
+	for ( j6 = sh[6]; j6 > 0; ) {
+		if ( j6 < bsize ) {
+			s6 = j6;
+			j6 = 0;
+		} else {
+			s6 = bsize;
+			j6 -= bsize;
+		}
+		oy6 = oy + ( j6*sy[6] );
+		for ( j5 = sh[5]; j5 > 0; ) {
+			if ( j5 < bsize ) {
+				s5 = j5;
+				j5 = 0;
+			} else {
+				s5 = bsize;
+				j5 -= bsize;
+			}
+			dy6 = sy[6] - ( s5*sy[5] );
+			oy5 = oy6 + ( j5*sy[5] );
+			for ( j4 = sh[4]; j4 > 0; ) {
+				if ( j4 < bsize ) {
+					s4 = j4;
+					j4 = 0;
+				} else {
+					s4 = bsize;
+					j4 -= bsize;
+				}
+				dy5 = sy[5] - ( s4*sy[4] );
+				oy4 = oy5 + ( j4*sy[4] );
+				for ( j3 = sh[3]; j3 > 0; ) {
+					if ( j3 < bsize ) {
+						s3 = j3;
+						j3 = 0;
+					} else {
+						s3 = bsize;
+						j3 -= bsize;
+					}
+					dy4 = sy[4] - ( s3*sy[3] );
+					oy3 = oy4 + ( j3*sy[3] );
+					for ( j2 = sh[2]; j2 > 0; ) {
+						if ( j2 < bsize ) {
+							s2 = j2;
+							j2 = 0;
+						} else {
+							s2 = bsize;
+							j2 -= bsize;
+						}
+						dy3 = sy[3] - ( s2*sy[2] );
+						oy2 = oy3 + ( j2*sy[2] );
+						for ( j1 = sh[1]; j1 > 0; ) {
+							if ( j1 < bsize ) {
+								s1 = j1;
+								j1 = 0;
+							} else {
+								s1 = bsize;
+								j1 -= bsize;
+							}
+							dy2 = sy[2] - ( s1*sy[1] );
+							oy1 = oy2 + ( j1*sy[1] );
+							for ( j0 = sh[0]; j0 > 0; ) {
+								if ( j0 < bsize ) {
+									s0 = j0;
+									j0 = 0;
+								} else {
+									s0 = bsize;
+									j0 -= bsize;
+								}
+								// Compute the index offset for the first output ndarray element in the current block...
+								iy = oy1 + ( j0*sy[0] );
+
+								// Compute the loop offset increment...
+								dy1 = sy[1] - ( s0*sy[0] );
+
+								// Iterate over the ndarray dimensions...
+								for ( i6 = 0; i6 < s6; i6++ ) {
+									for ( i5 = 0; i5 < s5; i5++ ) {
+										for ( i4 = 0; i4 < s4; i4++ ) {
+											for ( i3 = 0; i3 < s3; i3++ ) {
+												for ( i2 = 0; i2 < s2; i2++ ) {
+													for ( i1 = 0; i1 < s1; i1++ ) {
+														for ( i0 = 0; i0 < s0; i0++ ) {
+															set( ybuf, iy, get( xbuf, ix ) );
+															iy += dy0;
+														}
+														iy += dy1;
+													}
+													iy += dy2;
+												}
+												iy += dy3;
+											}
+											iy += dy4;
+										}
+										iy += dy5;
+									}
+									iy += dy6;
+								}
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+}
+
+
+// EXPORTS //
+
+module.exports = blockedassign7d;
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/8d.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/8d.js
new file mode 100644
index 000000000000..314e414f5629
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/8d.js
@@ -0,0 +1,201 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2026 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-depth */
+
+'use strict';
+
+// MAIN //
+
+/**
+* Assigns a scalar value to every element of an eight-dimensional output ndarray.
+*
+* @private
+* @param {Object} x - object containing input ndarray meta data
+* @param {*} x.dtype - data type
+* @param {Collection} x.data - data buffer
+* @param {NonNegativeIntegerArray} x.shape - dimensions
+* @param {IntegerArray} x.strides - stride lengths
+* @param {NonNegativeInteger} x.offset - index offset
+* @param {string} x.order - specifies whether `x` is row-major (C-style) or column-major (Fortran-style)
+* @param {Object} y - object containing output ndarray meta data
+* @param {*} y.dtype - data type
+* @param {Collection} y.data - data buffer
+* @param {NonNegativeIntegerArray} y.shape - dimensions
+* @param {IntegerArray} y.strides - stride lengths
+* @param {NonNegativeInteger} y.offset - index offset
+* @param {string} y.order - specifies whether `y` is row-major (C-style) or column-major (Fortran-style)
+* @param {boolean} isRowMajor - boolean indicating if provided arrays are in row-major order
+* @returns {void}
+*
+* @example
+* var Float64Array = require( '@stdlib/array/float64' );
+*
+* // Create data buffers:
+* var xbuf = new Float64Array( [ 2.0 ] );
+* var ybuf = new Float64Array( 6 );
+*
+* // Define the shape of the output array:
+* var shape = [ 1, 1, 1, 1, 1, 3, 1, 2 ];
+*
+* // Define the array strides:
+* var sx = [ 0 ];
+* var sy = [ 2, 2, 2, 2, 2, 2, 2, 1 ];
+*
+* // Define the index offsets:
+* var ox = 0;
+* var oy = 0;
+*
+* // Create the input and output ndarray-like objects:
+* var x = {
+*     'dtype': 'float64',
+*     'data': xbuf,
+*     'shape': [],
+*     'strides': sx,
+*     'offset': ox,
+*     'order': 'row-major'
+* };
+* var y = {
+*     'dtype': 'float64',
+*     'data': ybuf,
+*     'shape': shape,
+*     'strides': sy,
+*     'offset': oy,
+*     'order': 'row-major'
+* };
+*
+* // Assign scalar:
+* assign8d( x, y, true );
+*
+* console.log( y.data );
+* // => <Float64Array>[ 2.0, 2.0, 2.0, 2.0, 2.0, 2.0 ]
+*/
+function assign8d( x, y, isRowMajor ) {
+	var xbuf;
+	var ybuf;
+	var dy0;
+	var dy1;
+	var dy2;
+	var dy3;
+	var dy4;
+	var dy5;
+	var dy6;
+	var dy7;
+	var sh;
+	var S0;
+	var S1;
+	var S2;
+	var S3;
+	var S4;
+	var S5;
+	var S6;
+	var S7;
+	var sy;
+	var ix;
+	var iy;
+	var i0;
+	var i1;
+	var i2;
+	var i3;
+	var i4;
+	var i5;
+	var i6;
+	var i7;
+
+	// Note on variable naming convention: S#, dy#, i# where # corresponds to the loop number, with `0` being the innermost loop...
+
+	// Extract loop variables for purposes of loop interchange: dimensions and loop offset (pointer) increments...
+	sh = y.shape;
+	sy = y.strides;
+	if ( isRowMajor ) {
+		// For row-major ndarrays, the last dimensions have the fastest changing indices...
+		S0 = sh[ 7 ];
+		S1 = sh[ 6 ];
+		S2 = sh[ 5 ];
+		S3 = sh[ 4 ];
+		S4 = sh[ 3 ];
+		S5 = sh[ 2 ];
+		S6 = sh[ 1 ];
+		S7 = sh[ 0 ];
+		dy0 = sy[ 7 ];
+		dy1 = sy[ 6 ] - ( S0*sy[7] );
+		dy2 = sy[ 5 ] - ( S1*sy[6] );
+		dy3 = sy[ 4 ] - ( S2*sy[5] );
+		dy4 = sy[ 3 ] - ( S3*sy[4] );
+		dy5 = sy[ 2 ] - ( S4*sy[3] );
+		dy6 = sy[ 1 ] - ( S5*sy[2] );
+		dy7 = sy[ 0 ] - ( S6*sy[1] );
+	} else { // order === 'column-major'
+		// For column-major ndarrays, the first dimensions have the fastest changing indices...
+		S0 = sh[ 0 ];
+		S1 = sh[ 1 ];
+		S2 = sh[ 2 ];
+		S3 = sh[ 3 ];
+		S4 = sh[ 4 ];
+		S5 = sh[ 5 ];
+		S6 = sh[ 6 ];
+		S7 = sh[ 7 ];
+		dy0 = sy[ 0 ];
+		dy1 = sy[ 1 ] - ( S0*sy[0] );
+		dy2 = sy[ 2 ] - ( S1*sy[1] );
+		dy3 = sy[ 3 ] - ( S2*sy[2] );
+		dy4 = sy[ 4 ] - ( S3*sy[3] );
+		dy5 = sy[ 5 ] - ( S4*sy[4] );
+		dy6 = sy[ 6 ] - ( S5*sy[5] );
+		dy7 = sy[ 7 ] - ( S6*sy[6] );
+	}
+	// Set the pointers to the first indexed elements in the respective ndarrays...
+	ix = x.offset;
+	iy = y.offset;
+
+	// Cache references to the input and output ndarray buffers...
+	xbuf = x.data;
+	ybuf = y.data;
+
+	// Iterate over the ndarray dimensions...
+	for ( i7 = 0; i7 < S7; i7++ ) {
+		for ( i6 = 0; i6 < S6; i6++ ) {
+			for ( i5 = 0; i5 < S5; i5++ ) {
+				for ( i4 = 0; i4 < S4; i4++ ) {
+					for ( i3 = 0; i3 < S3; i3++ ) {
+						for ( i2 = 0; i2 < S2; i2++ ) {
+							for ( i1 = 0; i1 < S1; i1++ ) {
+								for ( i0 = 0; i0 < S0; i0++ ) {
+									ybuf[ iy ] = xbuf[ ix ];
+									iy += dy0;
+								}
+								iy += dy1;
+							}
+							iy += dy2;
+						}
+						iy += dy3;
+					}
+					iy += dy4;
+				}
+				iy += dy5;
+			}
+			iy += dy6;
+		}
+		iy += dy7;
+	}
+}
+
+
+// EXPORTS //
+
+module.exports = assign8d;
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/8d_accessors.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/8d_accessors.js
new file mode 100644
index 000000000000..e7ed9e51ee23
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/8d_accessors.js
@@ -0,0 +1,228 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2026 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-depth */
+
+'use strict';
+
+// MAIN //
+
+/**
+* Assigns a scalar value to every element of an eight-dimensional output ndarray.
+*
+* @private
+* @param {Object} x - object containing input ndarray meta data
+* @param {*} x.dtype - data type
+* @param {Collection} x.data - data buffer
+* @param {NonNegativeIntegerArray} x.shape - dimensions
+* @param {IntegerArray} x.strides - stride lengths
+* @param {NonNegativeInteger} x.offset - index offset
+* @param {string} x.order - specifies whether `x` is row-major (C-style) or column-major (Fortran-style)
+* @param {Array<Function>} x.accessors - data buffer accessors
+* @param {Object} y - object containing output ndarray meta data
+* @param {*} y.dtype - data type
+* @param {Collection} y.data - data buffer
+* @param {NonNegativeIntegerArray} y.shape - dimensions
+* @param {IntegerArray} y.strides - stride lengths
+* @param {NonNegativeInteger} y.offset - index offset
+* @param {string} y.order - specifies whether `y` is row-major (C-style) or column-major (Fortran-style)
+* @param {Array<Function>} y.accessors - data buffer accessors
+* @param {boolean} isRowMajor - boolean indicating if provided arrays are in row-major order
+* @returns {void}
+*
+* @example
+* var Complex64Array = require( '@stdlib/array/complex64' );
+* var Complex64 = require( '@stdlib/complex/float32/ctor' );
+* var realf = require( '@stdlib/complex/float32/real' );
+* var imagf = require( '@stdlib/complex/float32/imag' );
+*
+* // Create data buffers:
+* var xbuf = new Complex64Array( [ 2.0, 2.0 ] );
+* var ybuf = new Complex64Array( 6 );
+*
+* // Define the shape of the output array:
+* var shape = [ 1, 1, 1, 1, 1, 3, 1, 2 ];
+*
+* // Define the array strides:
+* var sx = [ 0 ];
+* var sy = [ 2, 2, 2, 2, 2, 2, 2, 1 ];
+*
+* // Define the index offsets:
+* var ox = 0;
+* var oy = 0;
+*
+* // Define getters and setters:
+* function getter( buf, idx ) {
+*     return buf.get( idx );
+* }
+*
+* function setter( buf, idx, value ) {
+*     buf.set( value, idx );
+* }
+*
+* // Create the input and output ndarray-like objects:
+* var x = {
+*     'dtype': 'complex64',
+*     'data': xbuf,
+*     'shape': [],
+*     'strides': sx,
+*     'offset': ox,
+*     'order': 'row-major',
+*     'accessors': [ getter, setter ]
+* };
+* var y = {
+*     'dtype': 'complex64',
+*     'data': ybuf,
+*     'shape': shape,
+*     'strides': sy,
+*     'offset': oy,
+*     'order': 'row-major',
+*     'accessors': [ getter, setter ]
+* };
+*
+* // Assign scalar:
+* assign8d( x, y, true );
+*
+* var v = y.data.get( 0 );
+*
+* var re = realf( v );
+* // returns 2.0
+*
+* var im = imagf( v );
+* // returns 2.0
+*/
+function assign8d( x, y, isRowMajor ) {
+	var xbuf;
+	var ybuf;
+	var get;
+	var set;
+	var dy0;
+	var dy1;
+	var dy2;
+	var dy3;
+	var dy4;
+	var dy5;
+	var dy6;
+	var dy7;
+	var sh;
+	var S0;
+	var S1;
+	var S2;
+	var S3;
+	var S4;
+	var S5;
+	var S6;
+	var S7;
+	var sy;
+	var ix;
+	var iy;
+	var i0;
+	var i1;
+	var i2;
+	var i3;
+	var i4;
+	var i5;
+	var i6;
+	var i7;
+
+	// Note on variable naming convention: S#, dy#, i# where # corresponds to the loop number, with `0` being the innermost loop...
+
+	// Extract loop variables for purposes of loop interchange: dimensions and loop offset (pointer) increments...
+	sh = y.shape;
+	sy = y.strides;
+	if ( isRowMajor ) {
+		// For row-major ndarrays, the last dimensions have the fastest changing indices...
+		S0 = sh[ 7 ];
+		S1 = sh[ 6 ];
+		S2 = sh[ 5 ];
+		S3 = sh[ 4 ];
+		S4 = sh[ 3 ];
+		S5 = sh[ 2 ];
+		S6 = sh[ 1 ];
+		S7 = sh[ 0 ];
+		dy0 = sy[ 7 ];
+		dy1 = sy[ 6 ] - ( S0*sy[7] );
+		dy2 = sy[ 5 ] - ( S1*sy[6] );
+		dy3 = sy[ 4 ] - ( S2*sy[5] );
+		dy4 = sy[ 3 ] - ( S3*sy[4] );
+		dy5 = sy[ 2 ] - ( S4*sy[3] );
+		dy6 = sy[ 1 ] - ( S5*sy[2] );
+		dy7 = sy[ 0 ] - ( S6*sy[1] );
+	} else { // order === 'column-major'
+		// For column-major ndarrays, the first dimensions have the fastest changing indices...
+		S0 = sh[ 0 ];
+		S1 = sh[ 1 ];
+		S2 = sh[ 2 ];
+		S3 = sh[ 3 ];
+		S4 = sh[ 4 ];
+		S5 = sh[ 5 ];
+		S6 = sh[ 6 ];
+		S7 = sh[ 7 ];
+		dy0 = sy[ 0 ];
+		dy1 = sy[ 1 ] - ( S0*sy[0] );
+		dy2 = sy[ 2 ] - ( S1*sy[1] );
+		dy3 = sy[ 3 ] - ( S2*sy[2] );
+		dy4 = sy[ 4 ] - ( S3*sy[3] );
+		dy5 = sy[ 5 ] - ( S4*sy[4] );
+		dy6 = sy[ 6 ] - ( S5*sy[5] );
+		dy7 = sy[ 7 ] - ( S6*sy[6] );
+	}
+	// Set the pointers to the first indexed elements in the respective ndarrays...
+	ix = x.offset;
+	iy = y.offset;
+
+	// Cache references to the input and output ndarray buffers...
+	xbuf = x.data;
+	ybuf = y.data;
+
+	// Cache accessors:
+	get = x.accessors[0];
+	set = y.accessors[1];
+
+	// Iterate over the ndarray dimensions...
+	for ( i7 = 0; i7 < S7; i7++ ) {
+		for ( i6 = 0; i6 < S6; i6++ ) {
+			for ( i5 = 0; i5 < S5; i5++ ) {
+				for ( i4 = 0; i4 < S4; i4++ ) {
+					for ( i3 = 0; i3 < S3; i3++ ) {
+						for ( i2 = 0; i2 < S2; i2++ ) {
+							for ( i1 = 0; i1 < S1; i1++ ) {
+								for ( i0 = 0; i0 < S0; i0++ ) {
+									set( ybuf, iy, get( xbuf, ix ) );
+									iy += dy0;
+								}
+								iy += dy1;
+							}
+							iy += dy2;
+						}
+						iy += dy3;
+					}
+					iy += dy4;
+				}
+				iy += dy5;
+			}
+			iy += dy6;
+		}
+		iy += dy7;
+	}
+}
+
+
+// EXPORTS //
+
+module.exports = assign8d;
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/8d_blocked.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/8d_blocked.js
new file mode 100644
index 000000000000..6d2d3bf1b3c6
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/8d_blocked.js
@@ -0,0 +1,287 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2026 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-depth, max-len */
+
+'use strict';
+
+// MODULES //
+
+var loopOrder = require( '@stdlib/ndarray/base/nullary-loop-interchange-order' );
+var blockSize = require( '@stdlib/ndarray/base/nullary-tiling-block-size' );
+
+
+// MAIN //
+
+/**
+* Assigns elements in an eight-dimensional input ndarray to elements in an equivalently shaped output ndarray via loop blocking.
+*
+* @private
+* @param {Object} x - object containing input ndarray meta data
+* @param {*} x.dtype - data type
+* @param {Collection} x.data - data buffer
+* @param {NonNegativeIntegerArray} x.shape - dimensions
+* @param {IntegerArray} x.strides - stride lengths
+* @param {NonNegativeInteger} x.offset - index offset
+* @param {string} x.order - specifies whether `x` is row-major (C-style) or column-major (Fortran-style)
+* @param {Object} y - object containing output ndarray meta data
+* @param {*} y.dtype - data type
+* @param {Collection} y.data - data buffer
+* @param {NonNegativeIntegerArray} y.shape - dimensions
+* @param {IntegerArray} y.strides - stride lengths
+* @param {NonNegativeInteger} y.offset - index offset
+* @param {string} y.order - specifies whether `y` is row-major (C-style) or column-major (Fortran-style)
+* @returns {void}
+*
+* @example
+* var Float64Array = require( '@stdlib/array/float64' );
+*
+* // Create data buffers:
+* var xbuf = new Float64Array( [ 2.0 ] );
+* var ybuf = new Float64Array( 6 );
+*
+* // Define the shape of the output array:
+* var shape = [ 1, 1, 1, 1, 1, 3, 1, 2 ];
+*
+* // Define the array strides:
+* var sx = [ 0 ];
+* var sy = [ 2, 2, 2, 2, 2, 2, 2, 1 ];
+*
+* // Define the index offsets:
+* var ox = 0;
+* var oy = 0;
+*
+* // Create the input and output ndarray-like objects:
+* var x = {
+*     'dtype': 'float64',
+*     'data': xbuf,
+*     'shape': [],
+*     'strides': sx,
+*     'offset': ox,
+*     'order': 'row-major'
+* };
+* var y = {
+*     'dtype': 'float64',
+*     'data': ybuf,
+*     'shape': shape,
+*     'strides': sy,
+*     'offset': oy,
+*     'order': 'row-major'
+* };
+*
+* // Assign scalar:
+* blockedassign8d( x, y );
+*
+* console.log( y.data );
+* // => <Float64Array>[ 2.0, 2.0, 2.0, 2.0, 2.0, 2.0 ]
+*/
+function blockedassign8d( x, y ) { // eslint-disable-line max-statements
+	var bsize;
+	var xbuf;
+	var ybuf;
+	var dy0;
+	var dy1;
+	var dy2;
+	var dy3;
+	var dy4;
+	var dy5;
+	var dy6;
+	var dy7;
+	var oy1;
+	var oy2;
+	var oy3;
+	var oy4;
+	var oy5;
+	var oy6;
+	var oy7;
+	var sh;
+	var s0;
+	var s1;
+	var s2;
+	var s3;
+	var s4;
+	var s5;
+	var s6;
+	var s7;
+	var sy;
+	var oy;
+	var ix;
+	var iy;
+	var i0;
+	var i1;
+	var i2;
+	var i3;
+	var i4;
+	var i5;
+	var i6;
+	var i7;
+	var j0;
+	var j1;
+	var j2;
+	var j3;
+	var j4;
+	var j5;
+	var j6;
+	var j7;
+	var o;
+
+	// Note on variable naming convention: s#, dy#, i#, j# where # corresponds to the loop number, with `0` being the innermost loop...
+
+	// Resolve the loop interchange order:
+	o = loopOrder( y.shape, y.strides );
+	sh = o.sh;
+	sy = o.sx;
+
+	// Determine the block size:
+	bsize = blockSize( y.dtype );
+
+	// Cache the indices of the first indexed elements in the respective ndarrays...
+	ix = x.offset;
+	oy = y.offset;
+
+	// Cache references to the input and output ndarray buffers...
+	xbuf = x.data;
+	ybuf = y.data;
+
+	// Cache the offset increment for the innermost loop...
+	dy0 = sy[0];
+
+	// Iterate over blocks...
+	for ( j7 = sh[7]; j7 > 0; ) {
+		if ( j7 < bsize ) {
+			s7 = j7;
+			j7 = 0;
+		} else {
+			s7 = bsize;
+			j7 -= bsize;
+		}
+		oy7 = oy + ( j7*sy[7] );
+		for ( j6 = sh[6]; j6 > 0; ) {
+			if ( j6 < bsize ) {
+				s6 = j6;
+				j6 = 0;
+			} else {
+				s6 = bsize;
+				j6 -= bsize;
+			}
+			dy7 = sy[7] - ( s6*sy[6] );
+			oy6 = oy7 + ( j6*sy[6] );
+			for ( j5 = sh[5]; j5 > 0; ) {
+				if ( j5 < bsize ) {
+					s5 = j5;
+					j5 = 0;
+				} else {
+					s5 = bsize;
+					j5 -= bsize;
+				}
+				dy6 = sy[6] - ( s5*sy[5] );
+				oy5 = oy6 + ( j5*sy[5] );
+				for ( j4 = sh[4]; j4 > 0; ) {
+					if ( j4 < bsize ) {
+						s4 = j4;
+						j4 = 0;
+					} else {
+						s4 = bsize;
+						j4 -= bsize;
+					}
+					dy5 = sy[5] - ( s4*sy[4] );
+					oy4 = oy5 + ( j4*sy[4] );
+					for ( j3 = sh[3]; j3 > 0; ) {
+						if ( j3 < bsize ) {
+							s3 = j3;
+							j3 = 0;
+						} else {
+							s3 = bsize;
+							j3 -= bsize;
+						}
+						dy4 = sy[4] - ( s3*sy[3] );
+						oy3 = oy4 + ( j3*sy[3] );
+						for ( j2 = sh[2]; j2 > 0; ) {
+							if ( j2 < bsize ) {
+								s2 = j2;
+								j2 = 0;
+							} else {
+								s2 = bsize;
+								j2 -= bsize;
+							}
+							dy3 = sy[3] - ( s2*sy[2] );
+							oy2 = oy3 + ( j2*sy[2] );
+							for ( j1 = sh[1]; j1 > 0; ) {
+								if ( j1 < bsize ) {
+									s1 = j1;
+									j1 = 0;
+								} else {
+									s1 = bsize;
+									j1 -= bsize;
+								}
+								dy2 = sy[2] - ( s1*sy[1] );
+								oy1 = oy2 + ( j1*sy[1] );
+								for ( j0 = sh[0]; j0 > 0; ) {
+									if ( j0 < bsize ) {
+										s0 = j0;
+										j0 = 0;
+									} else {
+										s0 = bsize;
+										j0 -= bsize;
+									}
+									// Compute the index offset for the first output ndarray element in the current block...
+									iy = oy1 + ( j0*sy[0] );
+
+									// Compute the loop offset increment...
+									dy1 = sy[1] - ( s0*sy[0] );
+
+									// Iterate over the ndarray dimensions...
+									for ( i7 = 0; i7 < s7; i7++ ) {
+										for ( i6 = 0; i6 < s6; i6++ ) {
+											for ( i5 = 0; i5 < s5; i5++ ) {
+												for ( i4 = 0; i4 < s4; i4++ ) {
+													for ( i3 = 0; i3 < s3; i3++ ) {
+														for ( i2 = 0; i2 < s2; i2++ ) {
+															for ( i1 = 0; i1 < s1; i1++ ) {
+																for ( i0 = 0; i0 < s0; i0++ ) {
+																	ybuf[ iy ] = xbuf[ ix ];
+																	iy += dy0;
+																}
+																iy += dy1;
+															}
+															iy += dy2;
+														}
+														iy += dy3;
+													}
+													iy += dy4;
+												}
+												iy += dy5;
+											}
+											iy += dy6;
+										}
+										iy += dy7;
+									}
+								}
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+}
+
+
+// EXPORTS //
+
+module.exports = blockedassign8d;
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/8d_blocked_accessors.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/8d_blocked_accessors.js
new file mode 100644
index 000000000000..c2bba1ed2e8c
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/8d_blocked_accessors.js
@@ -0,0 +1,314 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2026 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-depth, max-len */
+
+'use strict';
+
+// MODULES //
+
+var loopOrder = require( '@stdlib/ndarray/base/nullary-loop-interchange-order' );
+var blockSize = require( '@stdlib/ndarray/base/nullary-tiling-block-size' );
+
+
+// MAIN //
+
+/**
+* Assigns elements in an eight-dimensional input ndarray to elements in an equivalently shaped output ndarray via loop blocking.
+*
+* @private
+* @param {Object} x - object containing input ndarray meta data
+* @param {*} x.dtype - data type
+* @param {Collection} x.data - data buffer
+* @param {NonNegativeIntegerArray} x.shape - dimensions
+* @param {IntegerArray} x.strides - stride lengths
+* @param {NonNegativeInteger} x.offset - index offset
+* @param {string} x.order - specifies whether `x` is row-major (C-style) or column-major (Fortran-style)
+* @param {Array<Function>} x.accessors - data buffer accessors
+* @param {Object} y - object containing output ndarray meta data
+* @param {*} y.dtype - data type
+* @param {Collection} y.data - data buffer
+* @param {NonNegativeIntegerArray} y.shape - dimensions
+* @param {IntegerArray} y.strides - stride lengths
+* @param {NonNegativeInteger} y.offset - index offset
+* @param {string} y.order - specifies whether `y` is row-major (C-style) or column-major (Fortran-style)
+* @param {Array<Function>} y.accessors - data buffer accessors
+* @returns {void}
+*
+* @example
+* var Complex64Array = require( '@stdlib/array/complex64' );
+* var Complex64 = require( '@stdlib/complex/float32/ctor' );
+* var realf = require( '@stdlib/complex/float32/real' );
+* var imagf = require( '@stdlib/complex/float32/imag' );
+*
+* // Create data buffers:
+* var xbuf = new Complex64Array( [ 2.0, 2.0 ] );
+* var ybuf = new Complex64Array( 6 );
+*
+* // Define the shape of the output array:
+* var shape = [ 1, 1, 1, 1, 1, 3, 1, 2 ];
+*
+* // Define the array strides:
+* var sx = [ 0 ];
+* var sy = [ 2, 2, 2, 2, 2, 2, 2, 1 ];
+*
+* // Define the index offsets:
+* var ox = 0;
+* var oy = 0;
+*
+* // Define getters and setters:
+* function getter( buf, idx ) {
+*     return buf.get( idx );
+* }
+*
+* function setter( buf, idx, value ) {
+*     buf.set( value, idx );
+* }
+*
+* // Create the input and output ndarray-like objects:
+* var x = {
+*     'dtype': 'complex64',
+*     'data': xbuf,
+*     'shape': [],
+*     'strides': sx,
+*     'offset': ox,
+*     'order': 'row-major',
+*     'accessors': [ getter, setter ]
+* };
+* var y = {
+*     'dtype': 'complex64',
+*     'data': ybuf,
+*     'shape': shape,
+*     'strides': sy,
+*     'offset': oy,
+*     'order': 'row-major',
+*     'accessors': [ getter, setter ]
+* };
+*
+* // Assign scalar:
+* blockedassign8d( x, y );
+*
+* var v = y.data.get( 0 );
+*
+* var re = realf( v );
+* // returns 2.0
+*
+* var im = imagf( v );
+* // returns 2.0
+*/
+function blockedassign8d( x, y ) { // eslint-disable-line max-statements
+	var bsize;
+	var xbuf;
+	var ybuf;
+	var get;
+	var set;
+	var dy0;
+	var dy1;
+	var dy2;
+	var dy3;
+	var dy4;
+	var dy5;
+	var dy6;
+	var dy7;
+	var oy1;
+	var oy2;
+	var oy3;
+	var oy4;
+	var oy5;
+	var oy6;
+	var oy7;
+	var sh;
+	var s0;
+	var s1;
+	var s2;
+	var s3;
+	var s4;
+	var s5;
+	var s6;
+	var s7;
+	var sy;
+	var oy;
+	var ix;
+	var iy;
+	var i0;
+	var i1;
+	var i2;
+	var i3;
+	var i4;
+	var i5;
+	var i6;
+	var i7;
+	var j0;
+	var j1;
+	var j2;
+	var j3;
+	var j4;
+	var j5;
+	var j6;
+	var j7;
+	var o;
+
+	// Note on variable naming convention: s#, dy#, i#, j# where # corresponds to the loop number, with `0` being the innermost loop...
+
+	// Resolve the loop interchange order:
+	o = loopOrder( y.shape, y.strides );
+	sh = o.sh;
+	sy = o.sx;
+
+	// Determine the block size:
+	bsize = blockSize( y.dtype );
+
+	// Cache the indices of the first indexed elements in the respective ndarrays...
+	ix = x.offset;
+	oy = y.offset;
+
+	// Cache references to the input and output ndarray buffers...
+	xbuf = x.data;
+	ybuf = y.data;
+
+	// Cache the offset increment for the innermost loop...
+	dy0 = sy[0];
+
+	// Cache accessors:
+	get = x.accessors[0];
+	set = y.accessors[1];
+
+	// Iterate over blocks...
+	for ( j7 = sh[7]; j7 > 0; ) {
+		if ( j7 < bsize ) {
+			s7 = j7;
+			j7 = 0;
+		} else {
+			s7 = bsize;
+			j7 -= bsize;
+		}
+		oy7 = oy + ( j7*sy[7] );
+		for ( j6 = sh[6]; j6 > 0; ) {
+			if ( j6 < bsize ) {
+				s6 = j6;
+				j6 = 0;
+			} else {
+				s6 = bsize;
+				j6 -= bsize;
+			}
+			dy7 = sy[7] - ( s6*sy[6] );
+			oy6 = oy7 + ( j6*sy[6] );
+			for ( j5 = sh[5]; j5 > 0; ) {
+				if ( j5 < bsize ) {
+					s5 = j5;
+					j5 = 0;
+				} else {
+					s5 = bsize;
+					j5 -= bsize;
+				}
+				dy6 = sy[6] - ( s5*sy[5] );
+				oy5 = oy6 + ( j5*sy[5] );
+				for ( j4 = sh[4]; j4 > 0; ) {
+					if ( j4 < bsize ) {
+						s4 = j4;
+						j4 = 0;
+					} else {
+						s4 = bsize;
+						j4 -= bsize;
+					}
+					dy5 = sy[5] - ( s4*sy[4] );
+					oy4 = oy5 + ( j4*sy[4] );
+					for ( j3 = sh[3]; j3 > 0; ) {
+						if ( j3 < bsize ) {
+							s3 = j3;
+							j3 = 0;
+						} else {
+							s3 = bsize;
+							j3 -= bsize;
+						}
+						dy4 = sy[4] - ( s3*sy[3] );
+						oy3 = oy4 + ( j3*sy[3] );
+						for ( j2 = sh[2]; j2 > 0; ) {
+							if ( j2 < bsize ) {
+								s2 = j2;
+								j2 = 0;
+							} else {
+								s2 = bsize;
+								j2 -= bsize;
+							}
+							dy3 = sy[3] - ( s2*sy[2] );
+							oy2 = oy3 + ( j2*sy[2] );
+							for ( j1 = sh[1]; j1 > 0; ) {
+								if ( j1 < bsize ) {
+									s1 = j1;
+									j1 = 0;
+								} else {
+									s1 = bsize;
+									j1 -= bsize;
+								}
+								dy2 = sy[2] - ( s1*sy[1] );
+								oy1 = oy2 + ( j1*sy[1] );
+								for ( j0 = sh[0]; j0 > 0; ) {
+									if ( j0 < bsize ) {
+										s0 = j0;
+										j0 = 0;
+									} else {
+										s0 = bsize;
+										j0 -= bsize;
+									}
+									// Compute the index offset for the first output ndarray element in the current block...
+									iy = oy1 + ( j0*sy[0] );
+
+									// Compute the loop offset increment...
+									dy1 = sy[1] - ( s0*sy[0] );
+
+									// Iterate over the ndarray dimensions...
+									for ( i7 = 0; i7 < s7; i7++ ) {
+										for ( i6 = 0; i6 < s6; i6++ ) {
+											for ( i5 = 0; i5 < s5; i5++ ) {
+												for ( i4 = 0; i4 < s4; i4++ ) {
+													for ( i3 = 0; i3 < s3; i3++ ) {
+														for ( i2 = 0; i2 < s2; i2++ ) {
+															for ( i1 = 0; i1 < s1; i1++ ) {
+																for ( i0 = 0; i0 < s0; i0++ ) {
+																	set( ybuf, iy, get( xbuf, ix ) );
+																	iy += dy0;
+																}
+																iy += dy1;
+															}
+															iy += dy2;
+														}
+														iy += dy3;
+													}
+													iy += dy4;
+												}
+												iy += dy5;
+											}
+											iy += dy6;
+										}
+										iy += dy7;
+									}
+								}
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+}
+
+
+// EXPORTS //
+
+module.exports = blockedassign8d;
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/9d.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/9d.js
new file mode 100644
index 000000000000..0d88a5e89c1f
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/9d.js
@@ -0,0 +1,211 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2026 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-depth */
+
+'use strict';
+
+// MAIN //
+
+/**
+* Assigns a scalar value to every element of a nine-dimensional output ndarray.
+*
+* @private
+* @param {Object} x - object containing input ndarray meta data
+* @param {*} x.dtype - data type
+* @param {Collection} x.data - data buffer
+* @param {NonNegativeIntegerArray} x.shape - dimensions
+* @param {IntegerArray} x.strides - stride lengths
+* @param {NonNegativeInteger} x.offset - index offset
+* @param {string} x.order - specifies whether `x` is row-major (C-style) or column-major (Fortran-style)
+* @param {Object} y - object containing output ndarray meta data
+* @param {*} y.dtype - data type
+* @param {Collection} y.data - data buffer
+* @param {NonNegativeIntegerArray} y.shape - dimensions
+* @param {IntegerArray} y.strides - stride lengths
+* @param {NonNegativeInteger} y.offset - index offset
+* @param {string} y.order - specifies whether `y` is row-major (C-style) or column-major (Fortran-style)
+* @param {boolean} isRowMajor - boolean indicating if provided arrays are in row-major order
+* @returns {void}
+*
+* @example
+* var Float64Array = require( '@stdlib/array/float64' );
+*
+* // Create data buffers:
+* var xbuf = new Float64Array( [ 2.0 ] );
+* var ybuf = new Float64Array( 6 );
+*
+* // Define the shape of the output array:
+* var shape = [ 1, 1, 1, 1, 1, 1, 3, 1, 2 ];
+*
+* // Define the array strides:
+* var sx = [ 0 ];
+* var sy = [ 2, 2, 2, 2, 2, 2, 2, 2, 1 ];
+*
+* // Define the index offsets:
+* var ox = 0;
+* var oy = 0;
+*
+* // Create the input and output ndarray-like objects:
+* var x = {
+*     'dtype': 'float64',
+*     'data': xbuf,
+*     'shape': [],
+*     'strides': sx,
+*     'offset': ox,
+*     'order': 'row-major'
+* };
+* var y = {
+*     'dtype': 'float64',
+*     'data': ybuf,
+*     'shape': shape,
+*     'strides': sy,
+*     'offset': oy,
+*     'order': 'row-major'
+* };
+*
+* // Assign scalar:
+* assign9d( x, y, true );
+*
+* console.log( y.data );
+* // => <Float64Array>[ 2.0, 2.0, 2.0, 2.0, 2.0, 2.0 ]
+*/
+function assign9d( x, y, isRowMajor ) {
+	var xbuf;
+	var ybuf;
+	var dy0;
+	var dy1;
+	var dy2;
+	var dy3;
+	var dy4;
+	var dy5;
+	var dy6;
+	var dy7;
+	var dy8;
+	var sh;
+	var S0;
+	var S1;
+	var S2;
+	var S3;
+	var S4;
+	var S5;
+	var S6;
+	var S7;
+	var S8;
+	var sy;
+	var ix;
+	var iy;
+	var i0;
+	var i1;
+	var i2;
+	var i3;
+	var i4;
+	var i5;
+	var i6;
+	var i7;
+	var i8;
+
+	// Note on variable naming convention: S#, dy#, i# where # corresponds to the loop number, with `0` being the innermost loop...
+
+	// Extract loop variables for purposes of loop interchange: dimensions and loop offset (pointer) increments...
+	sh = y.shape;
+	sy = y.strides;
+	if ( isRowMajor ) {
+		// For row-major ndarrays, the last dimensions have the fastest changing indices...
+		S0 = sh[ 8 ];
+		S1 = sh[ 7 ];
+		S2 = sh[ 6 ];
+		S3 = sh[ 5 ];
+		S4 = sh[ 4 ];
+		S5 = sh[ 3 ];
+		S6 = sh[ 2 ];
+		S7 = sh[ 1 ];
+		S8 = sh[ 0 ];
+		dy0 = sy[ 8 ];
+		dy1 = sy[ 7 ] - ( S0*sy[8] );
+		dy2 = sy[ 6 ] - ( S1*sy[7] );
+		dy3 = sy[ 5 ] - ( S2*sy[6] );
+		dy4 = sy[ 4 ] - ( S3*sy[5] );
+		dy5 = sy[ 3 ] - ( S4*sy[4] );
+		dy6 = sy[ 2 ] - ( S5*sy[3] );
+		dy7 = sy[ 1 ] - ( S6*sy[2] );
+		dy8 = sy[ 0 ] - ( S7*sy[1] );
+	} else { // order === 'column-major'
+		// For column-major ndarrays, the first dimensions have the fastest changing indices...
+		S0 = sh[ 0 ];
+		S1 = sh[ 1 ];
+		S2 = sh[ 2 ];
+		S3 = sh[ 3 ];
+		S4 = sh[ 4 ];
+		S5 = sh[ 5 ];
+		S6 = sh[ 6 ];
+		S7 = sh[ 7 ];
+		S8 = sh[ 8 ];
+		dy0 = sy[ 0 ];
+		dy1 = sy[ 1 ] - ( S0*sy[0] );
+		dy2 = sy[ 2 ] - ( S1*sy[1] );
+		dy3 = sy[ 3 ] - ( S2*sy[2] );
+		dy4 = sy[ 4 ] - ( S3*sy[3] );
+		dy5 = sy[ 5 ] - ( S4*sy[4] );
+		dy6 = sy[ 6 ] - ( S5*sy[5] );
+		dy7 = sy[ 7 ] - ( S6*sy[6] );
+		dy8 = sy[ 8 ] - ( S7*sy[7] );
+	}
+	// Set the pointers to the first indexed elements in the respective ndarrays...
+	ix = x.offset;
+	iy = y.offset;
+
+	// Cache references to the input and output ndarray buffers...
+	xbuf = x.data;
+	ybuf = y.data;
+
+	// Iterate over the ndarray dimensions...
+	for ( i8 = 0; i8 < S8; i8++ ) {
+		for ( i7 = 0; i7 < S7; i7++ ) {
+			for ( i6 = 0; i6 < S6; i6++ ) {
+				for ( i5 = 0; i5 < S5; i5++ ) {
+					for ( i4 = 0; i4 < S4; i4++ ) {
+						for ( i3 = 0; i3 < S3; i3++ ) {
+							for ( i2 = 0; i2 < S2; i2++ ) {
+								for ( i1 = 0; i1 < S1; i1++ ) {
+									for ( i0 = 0; i0 < S0; i0++ ) {
+										ybuf[ iy ] = xbuf[ ix ];
+										iy += dy0;
+									}
+									iy += dy1;
+								}
+								iy += dy2;
+							}
+							iy += dy3;
+						}
+						iy += dy4;
+					}
+					iy += dy5;
+				}
+				iy += dy6;
+			}
+			iy += dy7;
+		}
+		iy += dy8;
+	}
+}
+
+
+// EXPORTS //
+
+module.exports = assign9d;
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/9d_accessors.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/9d_accessors.js
new file mode 100644
index 000000000000..94eee11942b5
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/9d_accessors.js
@@ -0,0 +1,238 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2026 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-depth */
+
+'use strict';
+
+// MAIN //
+
+/**
+* Assigns a scalar value to every element of a nine-dimensional output ndarray.
+*
+* @private
+* @param {Object} x - object containing input ndarray meta data
+* @param {*} x.dtype - data type
+* @param {Collection} x.data - data buffer
+* @param {NonNegativeIntegerArray} x.shape - dimensions
+* @param {IntegerArray} x.strides - stride lengths
+* @param {NonNegativeInteger} x.offset - index offset
+* @param {string} x.order - specifies whether `x` is row-major (C-style) or column-major (Fortran-style)
+* @param {Array<Function>} x.accessors - data buffer accessors
+* @param {Object} y - object containing output ndarray meta data
+* @param {*} y.dtype - data type
+* @param {Collection} y.data - data buffer
+* @param {NonNegativeIntegerArray} y.shape - dimensions
+* @param {IntegerArray} y.strides - stride lengths
+* @param {NonNegativeInteger} y.offset - index offset
+* @param {string} y.order - specifies whether `y` is row-major (C-style) or column-major (Fortran-style)
+* @param {Array<Function>} y.accessors - data buffer accessors
+* @param {boolean} isRowMajor - boolean indicating if provided arrays are in row-major order
+* @returns {void}
+*
+* @example
+* var Complex64Array = require( '@stdlib/array/complex64' );
+* var Complex64 = require( '@stdlib/complex/float32/ctor' );
+* var realf = require( '@stdlib/complex/float32/real' );
+* var imagf = require( '@stdlib/complex/float32/imag' );
+*
+* // Create data buffers:
+* var xbuf = new Complex64Array( [ 2.0, 2.0 ] );
+* var ybuf = new Complex64Array( 6 );
+*
+* // Define the shape of the output array:
+* var shape = [ 1, 1, 1, 1, 1, 1, 3, 1, 2 ];
+*
+* // Define the array strides:
+* var sx = [ 0 ];
+* var sy = [ 2, 2, 2, 2, 2, 2, 2, 2, 1 ];
+*
+* // Define the index offsets:
+* var ox = 0;
+* var oy = 0;
+*
+* // Define getters and setters:
+* function getter( buf, idx ) {
+*     return buf.get( idx );
+* }
+*
+* function setter( buf, idx, value ) {
+*     buf.set( value, idx );
+* }
+*
+* // Create the input and output ndarray-like objects:
+* var x = {
+*     'dtype': 'complex64',
+*     'data': xbuf,
+*     'shape': [],
+*     'strides': sx,
+*     'offset': ox,
+*     'order': 'row-major',
+*     'accessors': [ getter, setter ]
+* };
+* var y = {
+*     'dtype': 'complex64',
+*     'data': ybuf,
+*     'shape': shape,
+*     'strides': sy,
+*     'offset': oy,
+*     'order': 'row-major',
+*     'accessors': [ getter, setter ]
+* };
+*
+* // Assign scalar:
+* assign9d( x, y, true );
+*
+* var v = y.data.get( 0 );
+*
+* var re = realf( v );
+* // returns 2.0
+*
+* var im = imagf( v );
+* // returns 2.0
+*/
+function assign9d( x, y, isRowMajor ) {
+	var xbuf;
+	var ybuf;
+	var get;
+	var set;
+	var dy0;
+	var dy1;
+	var dy2;
+	var dy3;
+	var dy4;
+	var dy5;
+	var dy6;
+	var dy7;
+	var dy8;
+	var sh;
+	var S0;
+	var S1;
+	var S2;
+	var S3;
+	var S4;
+	var S5;
+	var S6;
+	var S7;
+	var S8;
+	var sy;
+	var ix;
+	var iy;
+	var i0;
+	var i1;
+	var i2;
+	var i3;
+	var i4;
+	var i5;
+	var i6;
+	var i7;
+	var i8;
+
+	// Note on variable naming convention: S#, dy#, i# where # corresponds to the loop number, with `0` being the innermost loop...
+
+	// Extract loop variables for purposes of loop interchange: dimensions and loop offset (pointer) increments...
+	sh = y.shape;
+	sy = y.strides;
+	if ( isRowMajor ) {
+		// For row-major ndarrays, the last dimensions have the fastest changing indices...
+		S0 = sh[ 8 ];
+		S1 = sh[ 7 ];
+		S2 = sh[ 6 ];
+		S3 = sh[ 5 ];
+		S4 = sh[ 4 ];
+		S5 = sh[ 3 ];
+		S6 = sh[ 2 ];
+		S7 = sh[ 1 ];
+		S8 = sh[ 0 ];
+		dy0 = sy[ 8 ];
+		dy1 = sy[ 7 ] - ( S0*sy[8] );
+		dy2 = sy[ 6 ] - ( S1*sy[7] );
+		dy3 = sy[ 5 ] - ( S2*sy[6] );
+		dy4 = sy[ 4 ] - ( S3*sy[5] );
+		dy5 = sy[ 3 ] - ( S4*sy[4] );
+		dy6 = sy[ 2 ] - ( S5*sy[3] );
+		dy7 = sy[ 1 ] - ( S6*sy[2] );
+		dy8 = sy[ 0 ] - ( S7*sy[1] );
+	} else { // order === 'column-major'
+		// For column-major ndarrays, the first dimensions have the fastest changing indices...
+		S0 = sh[ 0 ];
+		S1 = sh[ 1 ];
+		S2 = sh[ 2 ];
+		S3 = sh[ 3 ];
+		S4 = sh[ 4 ];
+		S5 = sh[ 5 ];
+		S6 = sh[ 6 ];
+		S7 = sh[ 7 ];
+		S8 = sh[ 8 ];
+		dy0 = sy[ 0 ];
+		dy1 = sy[ 1 ] - ( S0*sy[0] );
+		dy2 = sy[ 2 ] - ( S1*sy[1] );
+		dy3 = sy[ 3 ] - ( S2*sy[2] );
+		dy4 = sy[ 4 ] - ( S3*sy[3] );
+		dy5 = sy[ 5 ] - ( S4*sy[4] );
+		dy6 = sy[ 6 ] - ( S5*sy[5] );
+		dy7 = sy[ 7 ] - ( S6*sy[6] );
+		dy8 = sy[ 8 ] - ( S7*sy[7] );
+	}
+	// Set the pointers to the first indexed elements in the respective ndarrays...
+	ix = x.offset;
+	iy = y.offset;
+
+	// Cache references to the input and output ndarray buffers...
+	xbuf = x.data;
+	ybuf = y.data;
+
+	// Cache accessors:
+	get = x.accessors[0];
+	set = y.accessors[1];
+
+	// Iterate over the ndarray dimensions...
+	for ( i8 = 0; i8 < S8; i8++ ) {
+		for ( i7 = 0; i7 < S7; i7++ ) {
+			for ( i6 = 0; i6 < S6; i6++ ) {
+				for ( i5 = 0; i5 < S5; i5++ ) {
+					for ( i4 = 0; i4 < S4; i4++ ) {
+						for ( i3 = 0; i3 < S3; i3++ ) {
+							for ( i2 = 0; i2 < S2; i2++ ) {
+								for ( i1 = 0; i1 < S1; i1++ ) {
+									for ( i0 = 0; i0 < S0; i0++ ) {
+										set( ybuf, iy, get( xbuf, ix ) );
+										iy += dy0;
+									}
+									iy += dy1;
+								}
+								iy += dy2;
+							}
+							iy += dy3;
+						}
+						iy += dy4;
+					}
+					iy += dy5;
+				}
+				iy += dy6;
+			}
+			iy += dy7;
+		}
+		iy += dy8;
+	}
+}
+
+
+// EXPORTS //
+
+module.exports = assign9d;
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/9d_blocked.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/9d_blocked.js
new file mode 100644
index 000000000000..aceb1c13cb79
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/9d_blocked.js
@@ -0,0 +1,306 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2026 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-depth, max-len */
+
+'use strict';
+
+// MODULES //
+
+var loopOrder = require( '@stdlib/ndarray/base/nullary-loop-interchange-order' );
+var blockSize = require( '@stdlib/ndarray/base/nullary-tiling-block-size' );
+
+
+// MAIN //
+
+/**
+* Assigns a scalar value to every element of a nine-dimensional output ndarray via loop blocking.
+*
+* @private
+* @param {Object} x - object containing input ndarray meta data
+* @param {*} x.dtype - data type
+* @param {Collection} x.data - data buffer
+* @param {NonNegativeIntegerArray} x.shape - dimensions
+* @param {IntegerArray} x.strides - stride lengths
+* @param {NonNegativeInteger} x.offset - index offset
+* @param {string} x.order - specifies whether `x` is row-major (C-style) or column-major (Fortran-style)
+* @param {Object} y - object containing output ndarray meta data
+* @param {*} y.dtype - data type
+* @param {Collection} y.data - data buffer
+* @param {NonNegativeIntegerArray} y.shape - dimensions
+* @param {IntegerArray} y.strides - stride lengths
+* @param {NonNegativeInteger} y.offset - index offset
+* @param {string} y.order - specifies whether `y` is row-major (C-style) or column-major (Fortran-style)
+* @returns {void}
+*
+* @example
+* var Float64Array = require( '@stdlib/array/float64' );
+*
+* // Create data buffers:
+* var xbuf = new Float64Array( [ 2.0 ] );
+* var ybuf = new Float64Array( 6 );
+*
+* // Define the shape of the output array:
+* var shape = [ 1, 1, 1, 1, 1, 1, 3, 1, 2 ];
+*
+* // Define the array strides:
+* var sx = [ 0 ];
+* var sy = [ 2, 2, 2, 2, 2, 2, 2, 2, 1 ];
+*
+* // Define the index offsets:
+* var ox = 0;
+* var oy = 0;
+*
+* // Create the input and output ndarray-like objects:
+* var x = {
+*     'dtype': 'float64',
+*     'data': xbuf,
+*     'shape': [],
+*     'strides': sx,
+*     'offset': ox,
+*     'order': 'row-major'
+* };
+* var y = {
+*     'dtype': 'float64',
+*     'data': ybuf,
+*     'shape': shape,
+*     'strides': sy,
+*     'offset': oy,
+*     'order': 'row-major'
+* };
+*
+* // Assign scalar:
+* blockedassign9d( x, y );
+*
+* console.log( y.data );
+* // => <Float64Array>[ 2.0, 2.0, 2.0, 2.0, 2.0, 2.0 ]
+*/
+function blockedassign9d( x, y ) { // eslint-disable-line max-statements
+	var bsize;
+	var xbuf;
+	var ybuf;
+	var dy0;
+	var dy1;
+	var dy2;
+	var dy3;
+	var dy4;
+	var dy5;
+	var dy6;
+	var dy7;
+	var dy8;
+	var oy1;
+	var oy2;
+	var oy3;
+	var oy4;
+	var oy5;
+	var oy6;
+	var oy7;
+	var oy8;
+	var sh;
+	var s0;
+	var s1;
+	var s2;
+	var s3;
+	var s4;
+	var s5;
+	var s6;
+	var s7;
+	var s8;
+	var sy;
+	var oy;
+	var ix;
+	var iy;
+	var i0;
+	var i1;
+	var i2;
+	var i3;
+	var i4;
+	var i5;
+	var i6;
+	var i7;
+	var i8;
+	var j0;
+	var j1;
+	var j2;
+	var j3;
+	var j4;
+	var j5;
+	var j6;
+	var j7;
+	var j8;
+	var o;
+
+	// Note on variable naming convention: s#, dy#, i#, j# where # corresponds to the loop number, with `0` being the innermost loop...
+
+	// Resolve the loop interchange order:
+	o = loopOrder( y.shape, y.strides );
+	sh = o.sh;
+	sy = o.sx;
+
+	// Determine the block size:
+	bsize = blockSize( y.dtype );
+
+	// Cache the indices of the first indexed elements in the respective ndarrays...
+	ix = x.offset;
+	oy = y.offset;
+
+	// Cache references to the input and output ndarray buffers...
+	xbuf = x.data;
+	ybuf = y.data;
+
+	// Cache the offset increment for the innermost loop...
+	dy0 = sy[0];
+
+	// Iterate over blocks...
+	for ( j8 = sh[8]; j8 > 0; ) {
+		if ( j8 < bsize ) {
+			s8 = j8;
+			j8 = 0;
+		} else {
+			s8 = bsize;
+			j8 -= bsize;
+		}
+		oy8 = oy + ( j8*sy[8] );
+		for ( j7 = sh[7]; j7 > 0; ) {
+			if ( j7 < bsize ) {
+				s7 = j7;
+				j7 = 0;
+			} else {
+				s7 = bsize;
+				j7 -= bsize;
+			}
+			dy8 = sy[8] - ( s7*sy[7] );
+			oy7 = oy8 + ( j7*sy[7] );
+			for ( j6 = sh[6]; j6 > 0; ) {
+				if ( j6 < bsize ) {
+					s6 = j6;
+					j6 = 0;
+				} else {
+					s6 = bsize;
+					j6 -= bsize;
+				}
+				dy7 = sy[7] - ( s6*sy[6] );
+				oy6 = oy7 + ( j6*sy[6] );
+				for ( j5 = sh[5]; j5 > 0; ) {
+					if ( j5 < bsize ) {
+						s5 = j5;
+						j5 = 0;
+					} else {
+						s5 = bsize;
+						j5 -= bsize;
+					}
+					dy6 = sy[6] - ( s5*sy[5] );
+					oy5 = oy6 + ( j5*sy[5] );
+					for ( j4 = sh[4]; j4 > 0; ) {
+						if ( j4 < bsize ) {
+							s4 = j4;
+							j4 = 0;
+						} else {
+							s4 = bsize;
+							j4 -= bsize;
+						}
+						dy5 = sy[5] - ( s4*sy[4] );
+						oy4 = oy5 + ( j4*sy[4] );
+						for ( j3 = sh[3]; j3 > 0; ) {
+							if ( j3 < bsize ) {
+								s3 = j3;
+								j3 = 0;
+							} else {
+								s3 = bsize;
+								j3 -= bsize;
+							}
+							dy4 = sy[4] - ( s3*sy[3] );
+							oy3 = oy4 + ( j3*sy[3] );
+							for ( j2 = sh[2]; j2 > 0; ) {
+								if ( j2 < bsize ) {
+									s2 = j2;
+									j2 = 0;
+								} else {
+									s2 = bsize;
+									j2 -= bsize;
+								}
+								dy3 = sy[3] - ( s2*sy[2] );
+								oy2 = oy3 + ( j2*sy[2] );
+								for ( j1 = sh[1]; j1 > 0; ) {
+									if ( j1 < bsize ) {
+										s1 = j1;
+										j1 = 0;
+									} else {
+										s1 = bsize;
+										j1 -= bsize;
+									}
+									dy2 = sy[2] - ( s1*sy[1] );
+									oy1 = oy2 + ( j1*sy[1] );
+									for ( j0 = sh[0]; j0 > 0; ) {
+										if ( j0 < bsize ) {
+											s0 = j0;
+											j0 = 0;
+										} else {
+											s0 = bsize;
+											j0 -= bsize;
+										}
+										// Compute the index offset for the first output ndarray element in the current block...
+										iy = oy1 + ( j0*sy[0] );
+
+										// Compute the loop offset increment...
+										dy1 = sy[1] - ( s0*sy[0] );
+
+										// Iterate over the ndarray dimensions...
+										for ( i8 = 0; i8 < s8; i8++ ) {
+											for ( i7 = 0; i7 < s7; i7++ ) {
+												for ( i6 = 0; i6 < s6; i6++ ) {
+													for ( i5 = 0; i5 < s5; i5++ ) {
+														for ( i4 = 0; i4 < s4; i4++ ) {
+															for ( i3 = 0; i3 < s3; i3++ ) {
+																for ( i2 = 0; i2 < s2; i2++ ) {
+																	for ( i1 = 0; i1 < s1; i1++ ) {
+																		for ( i0 = 0; i0 < s0; i0++ ) {
+																			ybuf[ iy ] = xbuf[ ix ];
+																			iy += dy0;
+																		}
+																		iy += dy1;
+																	}
+																	iy += dy2;
+																}
+																iy += dy3;
+															}
+															iy += dy4;
+														}
+														iy += dy5;
+													}
+													iy += dy6;
+												}
+												iy += dy7;
+											}
+											iy += dy8;
+										}
+									}
+								}
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+}
+
+
+// EXPORTS //
+
+module.exports = blockedassign9d;
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/9d_blocked_accessors.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/9d_blocked_accessors.js
new file mode 100644
index 000000000000..18dac3d2b884
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/9d_blocked_accessors.js
@@ -0,0 +1,333 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2026 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-depth, max-len */
+
+'use strict';
+
+// MODULES //
+
+var loopOrder = require( '@stdlib/ndarray/base/nullary-loop-interchange-order' );
+var blockSize = require( '@stdlib/ndarray/base/nullary-tiling-block-size' );
+
+
+// MAIN //
+
+/**
+* Assigns a scalar value to every element of a nine-dimensional output ndarray via loop blocking.
+*
+* @private
+* @param {Object} x - object containing input ndarray meta data
+* @param {*} x.dtype - data type
+* @param {Collection} x.data - data buffer
+* @param {NonNegativeIntegerArray} x.shape - dimensions
+* @param {IntegerArray} x.strides - stride lengths
+* @param {NonNegativeInteger} x.offset - index offset
+* @param {string} x.order - specifies whether `x` is row-major (C-style) or column-major (Fortran-style)
+* @param {Array<Function>} x.accessors - data buffer accessors
+* @param {Object} y - object containing output ndarray meta data
+* @param {*} y.dtype - data type
+* @param {Collection} y.data - data buffer
+* @param {NonNegativeIntegerArray} y.shape - dimensions
+* @param {IntegerArray} y.strides - stride lengths
+* @param {NonNegativeInteger} y.offset - index offset
+* @param {string} y.order - specifies whether `y` is row-major (C-style) or column-major (Fortran-style)
+* @param {Array<Function>} y.accessors - data buffer accessors
+* @returns {void}
+*
+* @example
+* var Complex64Array = require( '@stdlib/array/complex64' );
+* var Complex64 = require( '@stdlib/complex/float32/ctor' );
+* var realf = require( '@stdlib/complex/float32/real' );
+* var imagf = require( '@stdlib/complex/float32/imag' );
+*
+* // Create data buffers:
+* var xbuf = new Complex64Array( [ 2.0, 2.0 ] );
+* var ybuf = new Complex64Array( 6 );
+*
+* // Define the shape of the output array:
+* var shape = [ 1, 1, 1, 1, 1, 1, 3, 1, 2 ];
+*
+* // Define the array strides:
+* var sx = [ 0 ];
+* var sy = [ 2, 2, 2, 2, 2, 2, 2, 2, 1 ];
+*
+* // Define the index offsets:
+* var ox = 0;
+* var oy = 0;
+*
+* // Define getters and setters:
+* function getter( buf, idx ) {
+*     return buf.get( idx );
+* }
+*
+* function setter( buf, idx, value ) {
+*     buf.set( value, idx );
+* }
+*
+* // Create the input and output ndarray-like objects:
+* var x = {
+*     'dtype': 'complex64',
+*     'data': xbuf,
+*     'shape': [],
+*     'strides': sx,
+*     'offset': ox,
+*     'order': 'row-major',
+*     'accessors': [ getter, setter ]
+* };
+* var y = {
+*     'dtype': 'complex64',
+*     'data': ybuf,
+*     'shape': shape,
+*     'strides': sy,
+*     'offset': oy,
+*     'order': 'row-major',
+*     'accessors': [ getter, setter ]
+* };
+*
+* // Assign scalar:
+* blockedassign9d( x, y );
+*
+* var v = y.data.get( 0 );
+*
+* var re = realf( v );
+* // returns 2.0
+*
+* var im = imagf( v );
+* // returns 2.0
+*/
+function blockedassign9d( x, y ) { // eslint-disable-line max-statements
+	var bsize;
+	var xbuf;
+	var ybuf;
+	var get;
+	var set;
+	var dy0;
+	var dy1;
+	var dy2;
+	var dy3;
+	var dy4;
+	var dy5;
+	var dy6;
+	var dy7;
+	var dy8;
+	var oy1;
+	var oy2;
+	var oy3;
+	var oy4;
+	var oy5;
+	var oy6;
+	var oy7;
+	var oy8;
+	var sh;
+	var s0;
+	var s1;
+	var s2;
+	var s3;
+	var s4;
+	var s5;
+	var s6;
+	var s7;
+	var s8;
+	var sy;
+	var oy;
+	var ix;
+	var iy;
+	var i0;
+	var i1;
+	var i2;
+	var i3;
+	var i4;
+	var i5;
+	var i6;
+	var i7;
+	var i8;
+	var j0;
+	var j1;
+	var j2;
+	var j3;
+	var j4;
+	var j5;
+	var j6;
+	var j7;
+	var j8;
+	var o;
+
+	// Note on variable naming convention: s#, dy#, i#, j# where # corresponds to the loop number, with `0` being the innermost loop...
+
+	// Resolve the loop interchange order:
+	o = loopOrder( y.shape, y.strides );
+	sh = o.sh;
+	sy = o.sx;
+
+	// Determine the block size:
+	bsize = blockSize( y.dtype );
+
+	// Cache the indices of the first indexed elements in the respective ndarrays...
+	ix = x.offset;
+	oy = y.offset;
+
+	// Cache references to the input and output ndarray buffers...
+	xbuf = x.data;
+	ybuf = y.data;
+
+	// Cache the offset increment for the innermost loop...
+	dy0 = sy[0];
+
+	// Cache accessors:
+	get = x.accessors[0];
+	set = y.accessors[1];
+
+	// Iterate over blocks...
+	for ( j8 = sh[8]; j8 > 0; ) {
+		if ( j8 < bsize ) {
+			s8 = j8;
+			j8 = 0;
+		} else {
+			s8 = bsize;
+			j8 -= bsize;
+		}
+		oy8 = oy + ( j8*sy[8] );
+		for ( j7 = sh[7]; j7 > 0; ) {
+			if ( j7 < bsize ) {
+				s7 = j7;
+				j7 = 0;
+			} else {
+				s7 = bsize;
+				j7 -= bsize;
+			}
+			dy8 = sy[8] - ( s7*sy[7] );
+			oy7 = oy8 + ( j7*sy[7] );
+			for ( j6 = sh[6]; j6 > 0; ) {
+				if ( j6 < bsize ) {
+					s6 = j6;
+					j6 = 0;
+				} else {
+					s6 = bsize;
+					j6 -= bsize;
+				}
+				dy7 = sy[7] - ( s6*sy[6] );
+				oy6 = oy7 + ( j6*sy[6] );
+				for ( j5 = sh[5]; j5 > 0; ) {
+					if ( j5 < bsize ) {
+						s5 = j5;
+						j5 = 0;
+					} else {
+						s5 = bsize;
+						j5 -= bsize;
+					}
+					dy6 = sy[6] - ( s5*sy[5] );
+					oy5 = oy6 + ( j5*sy[5] );
+					for ( j4 = sh[4]; j4 > 0; ) {
+						if ( j4 < bsize ) {
+							s4 = j4;
+							j4 = 0;
+						} else {
+							s4 = bsize;
+							j4 -= bsize;
+						}
+						dy5 = sy[5] - ( s4*sy[4] );
+						oy4 = oy5 + ( j4*sy[4] );
+						for ( j3 = sh[3]; j3 > 0; ) {
+							if ( j3 < bsize ) {
+								s3 = j3;
+								j3 = 0;
+							} else {
+								s3 = bsize;
+								j3 -= bsize;
+							}
+							dy4 = sy[4] - ( s3*sy[3] );
+							oy3 = oy4 + ( j3*sy[3] );
+							for ( j2 = sh[2]; j2 > 0; ) {
+								if ( j2 < bsize ) {
+									s2 = j2;
+									j2 = 0;
+								} else {
+									s2 = bsize;
+									j2 -= bsize;
+								}
+								dy3 = sy[3] - ( s2*sy[2] );
+								oy2 = oy3 + ( j2*sy[2] );
+								for ( j1 = sh[1]; j1 > 0; ) {
+									if ( j1 < bsize ) {
+										s1 = j1;
+										j1 = 0;
+									} else {
+										s1 = bsize;
+										j1 -= bsize;
+									}
+									dy2 = sy[2] - ( s1*sy[1] );
+									oy1 = oy2 + ( j1*sy[1] );
+									for ( j0 = sh[0]; j0 > 0; ) {
+										if ( j0 < bsize ) {
+											s0 = j0;
+											j0 = 0;
+										} else {
+											s0 = bsize;
+											j0 -= bsize;
+										}
+										// Compute the index offset for the first output ndarray element in the current block...
+										iy = oy1 + ( j0*sy[0] );
+
+										// Compute the loop offset increment...
+										dy1 = sy[1] - ( s0*sy[0] );
+
+										// Iterate over the ndarray dimensions...
+										for ( i8 = 0; i8 < s8; i8++ ) {
+											for ( i7 = 0; i7 < s7; i7++ ) {
+												for ( i6 = 0; i6 < s6; i6++ ) {
+													for ( i5 = 0; i5 < s5; i5++ ) {
+														for ( i4 = 0; i4 < s4; i4++ ) {
+															for ( i3 = 0; i3 < s3; i3++ ) {
+																for ( i2 = 0; i2 < s2; i2++ ) {
+																	for ( i1 = 0; i1 < s1; i1++ ) {
+																		for ( i0 = 0; i0 < s0; i0++ ) {
+																			set( ybuf, iy, get( xbuf, ix ) );
+																			iy += dy0;
+																		}
+																		iy += dy1;
+																	}
+																	iy += dy2;
+																}
+																iy += dy3;
+															}
+															iy += dy4;
+														}
+														iy += dy5;
+													}
+													iy += dy6;
+												}
+												iy += dy7;
+											}
+											iy += dy8;
+										}
+									}
+								}
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+}
+
+
+// EXPORTS //
+
+module.exports = blockedassign9d;
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/index.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/index.js
new file mode 100644
index 000000000000..120b69a865b0
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/index.js
@@ -0,0 +1,72 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2026 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';
+
+/**
+* Assign a scalar value to every element of an output ndarray.
+*
+* @module @stdlib/ndarray/base/assign-scalar
+*
+* @example
+* var scalar2ndarray = require( '@stdlib/ndarray/from-scalar' );
+* var Float64Array = require( '@stdlib/array/float64' );
+* var assignScalar = require( '@stdlib/ndarray/base/assign-scalar' );
+*
+* // Create a zero-dimensional ndarray containing the scalar value:
+* var x = scalar2ndarray( 5.0, {
+*     'dtype': 'float64'
+* });
+*
+* // Create a data buffer:
+* var ybuf = new Float64Array( 12 );
+*
+* // Define the shape of the output array:
+* var shape = [ 3, 1, 2 ];
+*
+* // Define the array strides:
+* var sy = [ 4, 4, 1 ];
+*
+* // Define the index offset:
+* var oy = 1;
+*
+* // Create the output ndarray-like object:
+* var y = {
+*     'dtype': 'float64',
+*     'data': ybuf,
+*     'shape': shape,
+*     'strides': sy,
+*     'offset': oy,
+*     'order': 'row-major'
+* };
+*
+* // Assign the scalar value:
+* assignScalar( [ x, y ] );
+*
+* console.log( y.data );
+* // => <Float64Array>[ 0.0, 5.0, 5.0, 0.0, 0.0, 5.0, 5.0, 0.0, 0.0, 5.0, 5.0, 0.0 ]
+*/
+
+// MODULES //
+
+var main = require( './main.js' );
+
+
+// EXPORTS //
+
+module.exports = main;
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/main.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/main.js
new file mode 100644
index 000000000000..9c4ba0ca16f9
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/main.js
@@ -0,0 +1,339 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2026 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 isComplexDataType = require( '@stdlib/ndarray/base/assert/is-complex-floating-point-data-type' );
+var isRealDataType = require( '@stdlib/ndarray/base/assert/is-real-data-type' );
+var isBooleanArray = require( '@stdlib/array/base/assert/is-booleanarray' );
+var iterationOrder = require( '@stdlib/ndarray/base/iteration-order' );
+var castReturn = require( '@stdlib/complex/base/cast-return' );
+var complexCtors = require( '@stdlib/complex/ctors' );
+var minmaxViewBufferIndex = require( '@stdlib/ndarray/base/minmax-view-buffer-index' );
+var ndarray2object = require( '@stdlib/ndarray/base/ndarraylike2object' );
+var reinterpretBoolean = require( '@stdlib/strided/base/reinterpret-boolean' );
+var blockedaccessorassign2d = require( './2d_blocked_accessors.js' );
+var blockedaccessorassign3d = require( './3d_blocked_accessors.js' );
+var blockedaccessorassign4d = require( './4d_blocked_accessors.js' );
+var blockedaccessorassign5d = require( './5d_blocked_accessors.js' );
+var blockedaccessorassign6d = require( './6d_blocked_accessors.js' );
+var blockedaccessorassign7d = require( './7d_blocked_accessors.js' );
+var blockedaccessorassign8d = require( './8d_blocked_accessors.js' );
+var blockedaccessorassign9d = require( './9d_blocked_accessors.js' );
+var blockedaccessorassign10d = require( './10d_blocked_accessors.js' );
+var blockedassign2d = require( './2d_blocked.js' );
+var blockedassign3d = require( './3d_blocked.js' );
+var blockedassign4d = require( './4d_blocked.js' );
+var blockedassign5d = require( './5d_blocked.js' );
+var blockedassign6d = require( './6d_blocked.js' );
+var blockedassign7d = require( './7d_blocked.js' );
+var blockedassign8d = require( './8d_blocked.js' );
+var blockedassign9d = require( './9d_blocked.js' );
+var blockedassign10d = require( './10d_blocked.js' );
+var accessorassign0d = require( './0d_accessors.js' );
+var accessorassign1d = require( './1d_accessors.js' );
+var accessorassign2d = require( './2d_accessors.js' );
+var accessorassign3d = require( './3d_accessors.js' );
+var accessorassign4d = require( './4d_accessors.js' );
+var accessorassign5d = require( './5d_accessors.js' );
+var accessorassign6d = require( './6d_accessors.js' );
+var accessorassign7d = require( './7d_accessors.js' );
+var accessorassign8d = require( './8d_accessors.js' );
+var accessorassign9d = require( './9d_accessors.js' );
+var accessorassign10d = require( './10d_accessors.js' );
+var accessorassignnd = require( './nd_accessors.js' );
+var assign0d = require( './0d.js' );
+var assign1d = require( './1d.js' );
+var assign2d = require( './2d.js' );
+var assign3d = require( './3d.js' );
+var assign4d = require( './4d.js' );
+var assign5d = require( './5d.js' );
+var assign6d = require( './6d.js' );
+var assign7d = require( './7d.js' );
+var assign8d = require( './8d.js' );
+var assign9d = require( './9d.js' );
+var assign10d = require( './10d.js' );
+var assignnd = require( './nd.js' );
+
+
+// VARIABLES //
+
+var ASSIGN = [
+	assign0d,
+	assign1d,
+	assign2d,
+	assign3d,
+	assign4d,
+	assign5d,
+	assign6d,
+	assign7d,
+	assign8d,
+	assign9d,
+	assign10d
+];
+var ACCESSOR_ASSIGN = [
+	accessorassign0d,
+	accessorassign1d,
+	accessorassign2d,
+	accessorassign3d,
+	accessorassign4d,
+	accessorassign5d,
+	accessorassign6d,
+	accessorassign7d,
+	accessorassign8d,
+	accessorassign9d,
+	accessorassign10d
+];
+var BLOCKED_ASSIGN = [
+	blockedassign2d, // 0
+	blockedassign3d,
+	blockedassign4d,
+	blockedassign5d,
+	blockedassign6d,
+	blockedassign7d,
+	blockedassign8d,
+	blockedassign9d,
+	blockedassign10d // 8
+];
+var BLOCKED_ACCESSOR_ASSIGN = [
+	blockedaccessorassign2d, // 0
+	blockedaccessorassign3d,
+	blockedaccessorassign4d,
+	blockedaccessorassign5d,
+	blockedaccessorassign6d,
+	blockedaccessorassign7d,
+	blockedaccessorassign8d,
+	blockedaccessorassign9d,
+	blockedaccessorassign10d // 8
+];
+var MAX_DIMS = ASSIGN.length - 1;
+
+
+// FUNCTIONS //
+
+/**
+* Converts a boolean ndarray to an 8-bit unsigned integer ndarray.
+*
+* ## Notes
+*
+* -   The function mutates the input ndarray object.
+*
+* @private
+* @param {Object} x - input ndarray object
+* @returns {Object} output ndarray object
+*/
+function boolean2uint8( x ) {
+	x.data = reinterpretBoolean( x.data, 0 );
+	x.accessorProtocol = false;
+	return x;
+}
+
+
+// MAIN //
+
+/**
+* Assigns a scalar value to every element of an output ndarray.
+*
+* ## Notes
+*
+* -   Each provided ndarray should be an object with the following properties:
+*
+*     -   **dtype**: data type.
+*     -   **data**: data buffer.
+*     -   **shape**: dimensions.
+*     -   **strides**: stride lengths.
+*     -   **offset**: index offset.
+*     -   **order**: specifies whether an ndarray is row-major (C-style) or column major (Fortran-style).
+*
+* @param {ArrayLikeObject<Object>} arrays - array-like object containing a zero-dimensional ndarray containing the scalar value and one output ndarray
+* @returns {void}
+*
+* @example
+* var scalar2ndarray = require( '@stdlib/ndarray/from-scalar' );
+* var Float64Array = require( '@stdlib/array/float64' );
+*
+* // Create a zero-dimensional ndarray containing the scalar value:
+* var x = scalar2ndarray( 5.0, {
+*     'dtype': 'float64'
+* });
+*
+* // Create a data buffer:
+* var ybuf = new Float64Array( 12 );
+*
+* // Define the shape of the output array:
+* var shape = [ 3, 1, 2 ];
+*
+* // Define the array strides:
+* var sy = [ 4, 4, 1 ];
+*
+* // Define the index offset:
+* var oy = 1;
+*
+* // Create the output ndarray-like object:
+* var y = {
+*     'dtype': 'float64',
+*     'data': ybuf,
+*     'shape': shape,
+*     'strides': sy,
+*     'offset': oy,
+*     'order': 'row-major'
+* };
+*
+* // Assign the scalar value:
+* assignScalar( [ x, y ] );
+*
+* console.log( y.data );
+* // => <Float64Array>[ 0.0, 5.0, 5.0, 0.0, 0.0, 5.0, 5.0, 0.0, 0.0, 5.0, 5.0, 0.0 ]
+*/
+function assignScalar( arrays ) {
+	var ndims;
+	var ymmv;
+	var shy;
+	var ioy;
+	var len;
+	var sy;
+	var oy;
+	var ns;
+	var x;
+	var y;
+	var d;
+	var i;
+
+	// Unpack the ndarrays and standardize ndarray meta data:
+	x = ndarray2object( arrays[ 0 ] );
+	y = ndarray2object( arrays[ 1 ] );
+
+	// Check for known array types which can be reinterpreted for better iteration performance...
+	if ( isBooleanArray( x.data ) && isBooleanArray( y.data ) ) {
+		x = boolean2uint8( x );
+		y = boolean2uint8( y );
+	}
+	// Determine whether we are casting a real data type to a complex data type and we need to use a specialized accessor...
+	else if ( isRealDataType( x.dtype ) && isComplexDataType( y.dtype ) ) {
+		x.accessorProtocol = true;
+		x.accessors[ 0 ] = castReturn( x.accessors[ 0 ], 2, complexCtors( String( y.dtype ) ) ); // eslint-disable-line max-len
+	}
+	shy = y.shape;
+	ndims = shy.length;
+
+	// Determine whether we can avoid iteration altogether...
+	if ( ndims === 0 ) {
+		if ( x.accessorProtocol || y.accessorProtocol ) {
+			return ACCESSOR_ASSIGN[ ndims ]( x, y );
+		}
+		return ASSIGN[ ndims ]( x, y );
+	}
+	// Compute the number of elements and the number of singleton dimensions...
+	len = 1; // number of elements
+	ns = 0;  // number of singleton dimensions
+	for ( i = 0; i < ndims; i++ ) {
+		d = shy[ i ];
+
+		// Note that, if one of the dimensions is `0`, the length will be `0`...
+		len *= d;
+
+		// Check whether the current dimension is a singleton dimension...
+		if ( d === 1 ) {
+			ns += 1;
+		}
+	}
+	// Check whether we were provided an empty ndarray...
+	if ( len === 0 ) {
+		return;
+	}
+	// Determine whether the ndarray is one-dimensional and thus readily translates to a one-dimensional strided array...
+	if ( ndims === 1 ) {
+		if ( x.accessorProtocol || y.accessorProtocol ) {
+			return ACCESSOR_ASSIGN[ ndims ]( x, y );
+		}
+		return ASSIGN[ ndims ]( x, y );
+	}
+	sy = y.strides;
+
+	// Determine whether the ndarray has only **one** non-singleton dimension (e.g., ndims=4, shape=[10,1,1,1]) so that we can treat the ndarray as being equivalent to a one-dimensional strided array...
+	if ( ns === ndims-1 ) {
+		// Get the index of the non-singleton dimension...
+		for ( i = 0; i < ndims; i++ ) {
+			if ( shy[ i ] !== 1 ) {
+				break;
+			}
+		}
+		y.shape = [ shy[i] ];
+		y.strides = [ sy[i] ];
+		if ( x.accessorProtocol || y.accessorProtocol ) {
+			return ACCESSOR_ASSIGN[ 1 ]( x, y );
+		}
+		return ASSIGN[ 1 ]( x, y );
+	}
+	ioy = iterationOrder( sy ); // +/-1
+
+	// Determine whether we can avoid blocked iteration...
+	if ( ioy !== 0 ) {
+		// Determine the minimum and maximum linear indices which are accessible by the array view:
+		ymmv = minmaxViewBufferIndex( shy, sy, y.offset );
+
+		// Determine whether we can ignore shape (and strides) and treat the ndarray as a linear one-dimensional strided array...
+		if ( len === ( ymmv[1]-ymmv[0]+1 ) ) {
+			// Note: the above is equivalent to @stdlib/ndarray/base/assert/is-contiguous, but in-lined so we can retain computed values...
+			if ( ioy === 1 ) {
+				oy = ymmv[ 0 ];
+			} else {
+				oy = ymmv[ 1 ];
+			}
+			y.shape = [ len ];
+			y.strides = [ ioy ];
+			y.offset = oy;
+			if ( x.accessorProtocol || y.accessorProtocol ) {
+				return ACCESSOR_ASSIGN[ 1 ]( x, y );
+			}
+			return ASSIGN[ 1 ]( x, y );
+		}
+		// The ndarray is non-contiguous, so we cannot directly use one-dimensional array functionality...
+
+		// Determine whether we can use simple nested loops...
+		if ( ndims <= MAX_DIMS ) {
+			// So long as iteration always moves in the same direction (i.e., no mixed sign strides), we can leverage cache-optimal (i.e., normal) nested loops without resorting to blocked iteration...
+			if ( x.accessorProtocol || y.accessorProtocol ) {
+				return ACCESSOR_ASSIGN[ ndims ]( x, y );
+			}
+			return ASSIGN[ ndims ]( x, y );
+		}
+		// Fall-through to blocked iteration...
+	}
+	// At this point, we're either dealing with a non-contiguous n-dimensional array or a high dimensional n-dimensional array, so our only hope is that we can still perform blocked iteration...
+
+	// Determine whether we can perform blocked iteration...
+	if ( ndims <= MAX_DIMS ) {
+		if ( x.accessorProtocol || y.accessorProtocol ) {
+			return BLOCKED_ACCESSOR_ASSIGN[ ndims-2 ]( x, y );
+		}
+		return BLOCKED_ASSIGN[ ndims-2 ]( x, y );
+	}
+	// Fall-through to linear view iteration without regard for how data is stored in memory (i.e., take the slow path)...
+	if ( x.accessorProtocol || y.accessorProtocol ) {
+		return accessorassignnd( x, y );
+	}
+	assignnd( x, y );
+}
+
+
+// EXPORTS //
+
+module.exports = assignScalar;
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/nd.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/nd.js
new file mode 100644
index 000000000000..3fabf1e87357
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/nd.js
@@ -0,0 +1,139 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2026 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 numel = require( '@stdlib/ndarray/base/numel' );
+var vind2bind = require( '@stdlib/ndarray/base/vind2bind' );
+
+
+// VARIABLES //
+
+var MODE = 'throw';
+
+
+// MAIN //
+
+/**
+* Assigns a scalar value to every element of an n-dimensional output ndarray.
+*
+* @private
+* @param {Object} x - object containing input ndarray meta data
+* @param {*} x.dtype - data type
+* @param {Collection} x.data - data buffer
+* @param {NonNegativeIntegerArray} x.shape - dimensions
+* @param {IntegerArray} x.strides - stride lengths
+* @param {NonNegativeInteger} x.offset - index offset
+* @param {string} x.order - specifies whether \`x\` is row-major (C-style) or column-major (Fortran-style)
+* @param {Object} y - object containing output ndarray meta data
+* @param {*} y.dtype - data type
+* @param {Collection} y.data - data buffer
+* @param {NonNegativeIntegerArray} y.shape - dimensions
+* @param {IntegerArray} y.strides - stride lengths
+* @param {NonNegativeInteger} y.offset - index offset
+* @param {string} y.order - specifies whether \`y\` is row-major (C-style) or column-major (Fortran-style)
+* @returns {void}
+*
+* @example
+* var Float64Array = require( '@stdlib/array/float64' );
+*
+* // Create data buffers:
+* var xbuf = new Float64Array( [ 2.0 ] );
+* var ybuf = new Float64Array( 6 );
+*
+* // Define the shape of the output array:
+* var shape = [ 3, 1, 2 ];
+*
+* // Define the array strides:
+* var sx = [ 0 ];
+* var sy = [ 2, 2, 1 ];
+*
+* // Define the index offsets:
+* var ox = 0;
+* var oy = 0;
+*
+* // Create the input and output ndarray-like objects:
+* var x = {
+*     'dtype': 'float64',
+*     'data': xbuf,
+*     'shape': [],
+*     'strides': sx,
+*     'offset': ox,
+*     'order': 'row-major'
+* };
+* var y = {
+*     'dtype': 'float64',
+*     'data': ybuf,
+*     'shape': shape,
+*     'strides': sy,
+*     'offset': oy,
+*     'order': 'row-major'
+* };
+*
+* // Assign scalar:
+* assignnd( x, y );
+*
+* console.log( y.data );
+* // => <Float64Array>[ 2.0, 2.0, 2.0, 2.0, 2.0, 2.0 ]
+*/
+function assignnd( x, y ) {
+	var xbuf;
+	var ybuf;
+	var ordy;
+	var len;
+	var shy;
+	var sy;
+	var oy;
+	var ix;
+	var iy;
+	var i;
+
+	shy = y.shape;
+
+	// Compute the total number of elements over which to iterate:
+	len = numel( shy );
+
+	// Cache references to the input and output ndarray data buffers:
+	xbuf = x.data;
+	ybuf = y.data;
+
+	// Cache references to the respective stride arrays:
+	sy = y.strides;
+
+	// Cache the index of the first indexed element in the input ndarray:
+	ix = x.offset;
+
+	// Cache the index of the first indexed element in the output ndarray:
+	oy = y.offset;
+
+	// Cache the output array order:
+	ordy = y.order;
+
+	// Iterate over each element based on the linear **view** index, regardless as to how the data is stored in memory...
+	for ( i = 0; i < len; i++ ) {
+		iy = vind2bind( shy, sy, oy, ordy, i, MODE );
+		ybuf[ iy ] = xbuf[ ix ];
+	}
+}
+
+
+// EXPORTS //
+
+module.exports = assignnd;
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/nd_accessors.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/nd_accessors.js
new file mode 100644
index 000000000000..2b20d02725d4
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/nd_accessors.js
@@ -0,0 +1,166 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2026 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 numel = require( '@stdlib/ndarray/base/numel' );
+var vind2bind = require( '@stdlib/ndarray/base/vind2bind' );
+
+
+// VARIABLES //
+
+var MODE = 'throw';
+
+
+// MAIN //
+
+/**
+* Assigns a scalar value to every element of an n-dimensional output ndarray.
+*
+* @private
+* @param {Object} x - object containing input ndarray meta data
+* @param {*} x.dtype - data type
+* @param {Collection} x.data - data buffer
+* @param {NonNegativeIntegerArray} x.shape - dimensions
+* @param {IntegerArray} x.strides - stride lengths
+* @param {NonNegativeInteger} x.offset - index offset
+* @param {string} x.order - specifies whether \`x\` is row-major (C-style) or column-major (Fortran-style)
+* @param {Array<Function>} x.accessors - data buffer accessors
+* @param {Object} y - object containing output ndarray meta data
+* @param {*} y.dtype - data type
+* @param {Collection} y.data - data buffer
+* @param {NonNegativeIntegerArray} y.shape - dimensions
+* @param {IntegerArray} y.strides - stride lengths
+* @param {NonNegativeInteger} y.offset - index offset
+* @param {string} y.order - specifies whether \`y\` is row-major (C-style) or column-major (Fortran-style)
+* @param {Array<Function>} y.accessors - data buffer accessors
+* @returns {void}
+*
+* @example
+* var Complex64Array = require( '@stdlib/array/complex64' );
+* var Complex64 = require( '@stdlib/complex/float32/ctor' );
+* var realf = require( '@stdlib/complex/float32/real' );
+* var imagf = require( '@stdlib/complex/float32/imag' );
+*
+* // Create data buffers:
+* var xbuf = new Complex64Array( [ 2.0, 2.0 ] );
+* var ybuf = new Complex64Array( 6 );
+*
+* // Define the shape of the output array:
+* var shape = [ 3, 1, 2 ];
+*
+* // Define the array strides:
+* var sx = [ 0 ];
+* var sy = [ 2, 2, 1 ];
+*
+* // Define the index offsets:
+* var ox = 0;
+* var oy = 0;
+*
+* // Define getters and setters:
+* function getter( buf, idx ) {
+*     return buf.get( idx );
+* }
+*
+* function setter( buf, idx, value ) {
+*     buf.set( value, idx );
+* }
+*
+* // Create the input and output ndarray-like objects:
+* var x = {
+*     'dtype': 'complex64',
+*     'data': xbuf,
+*     'shape': [],
+*     'strides': sx,
+*     'offset': ox,
+*     'order': 'row-major',
+*     'accessors': [ getter, setter ]
+* };
+* var y = {
+*     'dtype': 'complex64',
+*     'data': ybuf,
+*     'shape': shape,
+*     'strides': sy,
+*     'offset': oy,
+*     'order': 'row-major',
+*     'accessors': [ getter, setter ]
+* };
+*
+* // Assign scalar:
+* assignnd( x, y );
+*
+* var v = y.data.get( 0 );
+*
+* var re = realf( v );
+* // returns 2.0
+*
+* var im = imagf( v );
+* // returns 2.0
+*/
+function assignnd( x, y ) {
+	var xbuf;
+	var ybuf;
+	var ordy;
+	var len;
+	var get;
+	var set;
+	var shy;
+	var sy;
+	var oy;
+	var ix;
+	var iy;
+	var i;
+
+	shy = y.shape;
+
+	// Compute the total number of elements over which to iterate:
+	len = numel( shy );
+
+	// Cache references to the input and output ndarray data buffers:
+	xbuf = x.data;
+	ybuf = y.data;
+
+	// Cache references to the respective stride arrays:
+	sy = y.strides;
+
+	// Cache the index of the first indexed element in the input ndarray:
+	ix = x.offset;
+
+	// Cache the index of the first indexed element in the output ndarray:
+	oy = y.offset;
+
+	// Cache the output array order:
+	ordy = y.order;
+
+	// Cache accessors:
+	get = x.accessors[0];
+	set = y.accessors[1];
+
+	// Iterate over each element based on the linear **view** index, regardless as to how the data is stored in memory...
+	for ( i = 0; i < len; i++ ) {
+		iy = vind2bind( shy, sy, oy, ordy, i, MODE );
+		set( ybuf, iy, get( xbuf, ix ) );
+	}
+}
+
+
+// EXPORTS //
+
+module.exports = assignnd;
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/package.json b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/package.json
new file mode 100644
index 000000000000..ef820a963163
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/package.json
@@ -0,0 +1,62 @@
+{
+  "name": "@stdlib/ndarray/base/assign-scalar",
+  "version": "0.0.0",
+  "description": "Assign a scalar value to every element of an output ndarray.",
+  "license": "Apache-2.0",
+  "author": {
+    "name": "The Stdlib Authors",
+    "url": "https://github.com/stdlib-js/stdlib/graphs/contributors"
+  },
+  "contributors": [
+    {
+      "name": "The Stdlib Authors",
+      "url": "https://github.com/stdlib-js/stdlib/graphs/contributors"
+    }
+  ],
+  "main": "./lib",
+  "directories": {
+    "benchmark": "./benchmark",
+    "doc": "./docs",
+    "example": "./examples",
+    "lib": "./lib",
+    "test": "./test"
+  },
+  "types": "./docs/types",
+  "scripts": {},
+  "homepage": "https://github.com/stdlib-js/stdlib",
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/stdlib-js/stdlib.git"
+  },
+  "bugs": {
+    "url": "https://github.com/stdlib-js/stdlib/issues"
+  },
+  "dependencies": {},
+  "devDependencies": {},
+  "engines": {
+    "node": ">=0.10.0",
+    "npm": ">2.7.0"
+  },
+  "os": [
+    "aix",
+    "darwin",
+    "freebsd",
+    "linux",
+    "macos",
+    "openbsd",
+    "sunos",
+    "win32",
+    "windows"
+  ],
+  "keywords": [
+    "stdlib",
+    "base",
+    "strided",
+    "array",
+    "ndarray",
+    "assign",
+    "scalar",
+    "copy"
+  ],
+  "__stdlib__": {}
+}
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/test/test.0d.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/test/test.0d.js
new file mode 100644
index 000000000000..32e82d1e2fc6
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/test/test.0d.js
@@ -0,0 +1,79 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2026 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 tape = require( 'tape' );
+var isSameComplex128Array = require( '@stdlib/assert/is-same-complex128array' );
+var isSameFloat64Array = require( '@stdlib/assert/is-same-float64array' );
+var Complex128Array = require( '@stdlib/array/complex128' );
+var Float64Array = require( '@stdlib/array/float64' );
+var Complex128 = require( '@stdlib/complex/float64/ctor' );
+var scalar2ndarray = require( '@stdlib/ndarray/from-scalar' );
+var assignScalar = require( './../lib' );
+
+
+// TESTS //
+
+tape( 'main export is a function', function test( t ) {
+	t.ok( true, __filename );
+	t.strictEqual( typeof assignScalar, 'function', 'main export is a function');
+	t.end();
+});
+
+tape( 'the function assigns a scalar value to each element of a 0-dimensional output ndarray', function test( t ) {
+	var expected;
+	var v;
+	var y;
+
+	y = scalar2ndarray( 0.0, {
+		'dtype': 'float64'
+	});
+
+	v = scalar2ndarray( 10.0, {
+		'dtype': 'float64'
+	});
+	assignScalar( [ v, y ] );
+
+	expected = new Float64Array( [ 10.0 ] );
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function assigns a scalar value to each element of a 0-dimensional output ndarray (accessors)', function test( t ) {
+	var expected;
+	var v;
+	var y;
+
+	y = scalar2ndarray( new Complex128( 0.0, 0.0 ), {
+		'dtype': 'complex128'
+	});
+
+	v = scalar2ndarray( new Complex128( 10.0, 10.0 ), {
+		'dtype': 'complex128'
+	});
+	assignScalar( [ v, y ] );
+
+	expected = new Complex128Array( [ 10.0, 10.0 ] );
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+
+	t.end();
+});
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/test/test.1d.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/test/test.1d.js
new file mode 100644
index 000000000000..ce3f230e63ff
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/test/test.1d.js
@@ -0,0 +1,126 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2026 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 tape = require( 'tape' );
+var isSameComplex128Array = require( '@stdlib/assert/is-same-complex128array' );
+var isSameFloat64Array = require( '@stdlib/assert/is-same-float64array' );
+var Complex128Array = require( '@stdlib/array/complex128' );
+var Float64Array = require( '@stdlib/array/float64' );
+var zeros = require( '@stdlib/array/zeros' );
+var Complex128 = require( '@stdlib/complex/float64/ctor' );
+var scalar2ndarray = require( '@stdlib/ndarray/from-scalar' );
+var ndarray = require( '@stdlib/ndarray/ctor' );
+var assignScalar = require( './../lib' );
+
+
+// TESTS //
+
+tape( 'main export is a function', function test( t ) {
+	t.ok( true, __filename );
+	t.strictEqual( typeof assignScalar, 'function', 'main export is a function');
+	t.end();
+});
+
+tape( 'the function assigns a scalar value to each indexed element of a 1-dimensional output ndarray', function test( t ) {
+	var expected;
+	var v;
+	var y;
+
+	y = ndarray( 'float64', zeros( 8, 'float64' ), [ 4 ], [ 2 ], 1, 'row-major' );
+
+	v = scalar2ndarray( 10.0, {
+		'dtype': 'float64'
+	});
+	assignScalar( [ v, y ] );
+
+	expected = new Float64Array([
+		0.0,
+		10.0,
+		0.0,
+		10.0,
+		0.0,
+		10.0,
+		0.0,
+		10.0
+	]);
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function assigns a scalar value to each indexed element of a 1-dimensional output ndarray (empty array)', function test( t ) {
+	var expected;
+	var v;
+	var y;
+
+	y = ndarray( 'float64', zeros( 8, 'float64' ), [ 0 ], [ 1 ], 0, 'row-major' );
+
+	v = scalar2ndarray( 10.0, {
+		'dtype': 'float64'
+	});
+	assignScalar( [ v, y ] );
+
+	expected = new Float64Array([
+		0.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0
+	]);
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function assigns a scalar value to each indexed element of a 1-dimensional output ndarray (accessors)', function test( t ) {
+	var expected;
+	var v;
+	var y;
+
+	y = ndarray( 'complex128', zeros( 6, 'complex128' ), [ 4 ], [ 1 ], 1, 'row-major' );
+
+	v = scalar2ndarray( new Complex128( 10.0, 10.0 ), {
+		'dtype': 'complex128'
+	});
+	assignScalar( [ v, y ] );
+
+	expected = new Complex128Array([
+		0.0,
+		0.0,
+		10.0,
+		10.0,
+		10.0,
+		10.0,
+		10.0,
+		10.0,
+		10.0,
+		10.0,
+		0.0,
+		0.0
+	]);
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+
+	t.end();
+});
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/test/test.2d.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/test/test.2d.js
new file mode 100644
index 000000000000..1771aeeae7ff
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/test/test.2d.js
@@ -0,0 +1,1133 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2026 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 tape = require( 'tape' );
+var isSameComplex128Array = require( '@stdlib/assert/is-same-complex128array' );
+var isSameFloat64Array = require( '@stdlib/assert/is-same-float64array' );
+var Complex128Array = require( '@stdlib/array/complex128' );
+var Float64Array = require( '@stdlib/array/float64' );
+var zeros = require( '@stdlib/array/zeros' );
+var Complex128 = require( '@stdlib/complex/float64/ctor' );
+var scalar2ndarray = require( '@stdlib/ndarray/from-scalar' );
+var ndarray = require( '@stdlib/ndarray/ctor' );
+var shape2strides = require( '@stdlib/ndarray/base/shape2strides' );
+var strides2offset = require( '@stdlib/ndarray/base/strides2offset' );
+var numel = require( '@stdlib/ndarray/base/numel' );
+var dfill = require( '@stdlib/blas/ext/base/dfill' );
+var gfill = require( '@stdlib/blas/ext/base/gfill' );
+var blockSize = require( '@stdlib/ndarray/base/nullary-tiling-block-size' );
+var assignScalar = require( './../lib' );
+
+
+// TESTS //
+
+tape( 'main export is a function', function test( t ) {
+	t.ok( true, __filename );
+	t.strictEqual( typeof assignScalar, 'function', 'main export is a function');
+	t.end();
+});
+
+tape( 'the function assigns a scalar value to each indexed element of a 2-dimensional output ndarray (row-major, singleton dimensions)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var v;
+	var y;
+
+	dt = 'float64';
+	ord = 'row-major';
+	sh = [ 4, 1 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	v = scalar2ndarray( 10.0, {
+		'dtype': dt
+	});
+	assignScalar( [ v, y ] );
+
+	expected = new Float64Array([
+		10.0,
+		10.0,
+		10.0,
+		10.0
+	]);
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function assigns a scalar value to each indexed element of a 2-dimensional output ndarray (row-major, singleton dimensions, accessors)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var v;
+	var y;
+
+	dt = 'complex128';
+	ord = 'row-major';
+	sh = [ 4, 1 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	v = scalar2ndarray( new Complex128( 10.0, 10.0 ), {
+		'dtype': dt
+	});
+	assignScalar( [ v, y ] );
+
+	expected = new Complex128Array([
+		10.0,
+		10.0,
+		10.0,
+		10.0,
+		10.0,
+		10.0,
+		10.0,
+		10.0
+	]);
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function assigns a scalar value to each indexed element of a 2-dimensional output ndarray (row-major, empty)', function test( t ) {
+	var expected;
+	var v;
+	var y;
+
+	y = ndarray( 'float64', zeros( 4, 'float64' ), [ 0, 0 ], [ 1, 1 ], 0, 'row-major' );
+
+	v = scalar2ndarray( 10.0, {
+		'dtype': 'float64'
+	});
+	assignScalar( [ v, y ] );
+
+	expected = new Float64Array([
+		0.0,
+		0.0,
+		0.0,
+		0.0
+	]);
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function assigns a scalar value to each indexed element of a 2-dimensional output ndarray (row-major, contiguous)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var v;
+	var y;
+
+	dt = 'float64';
+	ord = 'row-major';
+	sh = [ 2, 2 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	v = scalar2ndarray( 10.0, {
+		'dtype': dt
+	});
+	assignScalar( [ v, y ] );
+
+	expected = new Float64Array([
+		10.0,
+		10.0,
+		10.0,
+		10.0
+	]);
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function assigns a scalar value to each indexed element of a 2-dimensional output ndarray (row-major, contiguous, negative strides)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var v;
+	var y;
+
+	dt = 'float64';
+	ord = 'row-major';
+	sh = [ 2, 2 ];
+	st = [ -2, -1 ];
+	o = strides2offset( sh, st );
+
+	y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	v = scalar2ndarray( 10.0, {
+		'dtype': dt
+	});
+	assignScalar( [ v, y ] );
+
+	expected = new Float64Array([
+		10.0,
+		10.0,
+		10.0,
+		10.0
+	]);
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function assigns a scalar value to each indexed element of a 2-dimensional output ndarray (row-major, non-contiguous, same sign strides)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var v;
+	var y;
+
+	dt = 'float64';
+	ord = 'row-major';
+	sh = [ 2, 2 ];
+	st = [ 4, 1 ];
+	o = strides2offset( sh, st );
+
+	y = ndarray( dt, zeros( 8, dt ), sh, st, o, ord );
+
+	v = scalar2ndarray( 10.0, {
+		'dtype': dt
+	});
+	assignScalar( [ v, y ] );
+
+	expected = new Float64Array([
+		10.0,
+		10.0,
+		0.0,
+		0.0,
+		10.0,
+		10.0,
+		0.0,
+		0.0
+	]);
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function assigns a scalar value to each indexed element of a 2-dimensional output ndarray (row-major, non-contiguous, mixed sign strides)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var v;
+	var y;
+
+	dt = 'float64';
+	ord = 'row-major';
+	sh = [ 2, 2 ];
+	st = [ 4, -1 ];
+	o = strides2offset( sh, st );
+
+	y = ndarray( dt, zeros( 8, dt ), sh, st, o, ord );
+
+	v = scalar2ndarray( 10.0, {
+		'dtype': dt
+	});
+	assignScalar( [ v, y ] );
+
+	expected = new Float64Array([
+		10.0,
+		10.0,
+		0.0,
+		0.0,
+		10.0,
+		10.0,
+		0.0,
+		0.0
+	]);
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function assigns a scalar value to each indexed element of a 2-dimensional output ndarray (row-major, non-contiguous, large arrays)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var v;
+	var y;
+
+	dt = 'float64';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ bsize*2, 2 ];
+	st = [ -4, 2 ];
+	o = strides2offset( sh, st );
+
+	y = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	v = scalar2ndarray( 10.0, {
+		'dtype': dt
+	});
+	assignScalar( [ v, y ] );
+
+	expected = new Float64Array( y.length*2 );
+	dfill( y.length, 10.0, expected, st[ 1 ] );
+
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function assigns a scalar value to each indexed element of a 2-dimensional output ndarray (row-major, non-contiguous, large arrays)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var v;
+	var y;
+
+	dt = 'float64';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, bsize*2 ];
+	st = [ bsize*4, -2 ];
+	o = strides2offset( sh, st );
+
+	y = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	v = scalar2ndarray( 10.0, {
+		'dtype': dt
+	});
+	assignScalar( [ v, y ] );
+
+	expected = new Float64Array( y.length*2 );
+	dfill( y.length, 10.0, expected, st[ 1 ] );
+
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function assigns a scalar value to each indexed element of a 2-dimensional output ndarray (row-major, contiguous, accessors)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var v;
+	var y;
+
+	dt = 'complex128';
+	ord = 'row-major';
+	sh = [ 2, 2 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	v = scalar2ndarray( new Complex128( 10.0, 10.0 ), {
+		'dtype': dt
+	});
+	assignScalar( [ v, y ] );
+
+	expected = new Complex128Array([
+		10.0,
+		10.0,
+		10.0,
+		10.0,
+		10.0,
+		10.0,
+		10.0,
+		10.0
+	]);
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function assigns a scalar value to each indexed element of a 2-dimensional output ndarray (row-major, contiguous, negative strides, accessors)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var v;
+	var y;
+
+	dt = 'complex128';
+	ord = 'row-major';
+	sh = [ 2, 2 ];
+	st = [ -2, -1 ];
+	o = strides2offset( sh, st );
+
+	y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	v = scalar2ndarray( new Complex128( 10.0, 10.0 ), {
+		'dtype': dt
+	});
+	assignScalar( [ v, y ] );
+
+	expected = new Complex128Array([
+		10.0,
+		10.0,
+		10.0,
+		10.0,
+		10.0,
+		10.0,
+		10.0,
+		10.0
+	]);
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function assigns a scalar value to each indexed element of a 2-dimensional output ndarray (row-major, non-contiguous, same sign strides, accessors)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var v;
+	var y;
+
+	dt = 'complex128';
+	ord = 'row-major';
+	sh = [ 2, 2 ];
+	st = [ 4, 1 ];
+	o = strides2offset( sh, st );
+
+	y = ndarray( dt, zeros( 8, dt ), sh, st, o, ord );
+
+	v = scalar2ndarray( new Complex128( 10.0, 10.0 ), {
+		'dtype': dt
+	});
+	assignScalar( [ v, y ] );
+
+	expected = new Complex128Array([
+		10.0,
+		10.0,
+		10.0,
+		10.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0,
+		10.0,
+		10.0,
+		10.0,
+		10.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0
+	]);
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function assigns a scalar value to each indexed element of a 2-dimensional output ndarray (row-major, non-contiguous, mixed sign strides, accessors)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var v;
+	var y;
+
+	dt = 'complex128';
+	ord = 'row-major';
+	sh = [ 2, 2 ];
+	st = [ 4, -1 ];
+	o = strides2offset( sh, st );
+
+	y = ndarray( dt, zeros( 8, dt ), sh, st, o, ord );
+
+	v = scalar2ndarray( new Complex128( 10.0, 10.0 ), {
+		'dtype': dt
+	});
+	assignScalar( [ v, y ] );
+
+	expected = new Complex128Array([
+		10.0,
+		10.0,
+		10.0,
+		10.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0,
+		10.0,
+		10.0,
+		10.0,
+		10.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0
+	]);
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function assigns a scalar value to each indexed element of a 2-dimensional output ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var v;
+	var y;
+
+	dt = 'complex128';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ bsize*2, 2 ];
+	st = [ -4, 2 ];
+	o = strides2offset( sh, st );
+
+	y = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	v = scalar2ndarray( new Complex128( 10.0, 10.0 ), {
+		'dtype': dt
+	});
+	assignScalar( [ v, y ] );
+
+	expected = new Complex128Array( y.length*2 );
+	gfill( y.length, new Complex128( 10.0, 10.0 ), expected, st[ 1 ] );
+
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function assigns a scalar value to each indexed element of a 2-dimensional output ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var v;
+	var y;
+
+	dt = 'complex128';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, bsize*2 ];
+	st = [ bsize*4, -2 ];
+	o = strides2offset( sh, st );
+
+	y = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	v = scalar2ndarray( new Complex128( 10.0, 10.0 ), {
+		'dtype': dt
+	});
+	assignScalar( [ v, y ] );
+
+	expected = new Complex128Array( y.length*2 );
+	gfill( y.length, new Complex128( 10.0, 10.0 ), expected, st[ 1 ] );
+
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function assigns a scalar value to each indexed element of a 2-dimensional output ndarray (column-major, singleton dimensions)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var v;
+	var y;
+
+	dt = 'float64';
+	ord = 'column-major';
+	sh = [ 1, 4 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	v = scalar2ndarray( 10.0, {
+		'dtype': dt
+	});
+	assignScalar( [ v, y ] );
+
+	expected = new Float64Array([
+		10.0,
+		10.0,
+		10.0,
+		10.0
+	]);
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function assigns a scalar value to each indexed element of a 2-dimensional output ndarray (column-major, singleton dimensions, accessors)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var v;
+	var y;
+
+	dt = 'complex128';
+	ord = 'column-major';
+	sh = [ 4, 1 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	v = scalar2ndarray( new Complex128( 10.0, 10.0 ), {
+		'dtype': dt
+	});
+	assignScalar( [ v, y ] );
+
+	expected = new Complex128Array([
+		10.0,
+		10.0,
+		10.0,
+		10.0,
+		10.0,
+		10.0,
+		10.0,
+		10.0
+	]);
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function assigns a scalar value to each indexed element of a 2-dimensional output ndarray (column-major, empty)', function test( t ) {
+	var expected;
+	var v;
+	var y;
+
+	y = ndarray( 'float64', zeros( 4, 'float64' ), [ 0, 0 ], [ 1, 1 ], 0, 'column-major' );
+
+	v = scalar2ndarray( 10.0, {
+		'dtype': 'float64'
+	});
+	assignScalar( [ v, y ] );
+
+	expected = new Float64Array([
+		0.0,
+		0.0,
+		0.0,
+		0.0
+	]);
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function assigns a scalar value to each indexed element of a 2-dimensional output ndarray (column-major, contiguous)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var v;
+	var y;
+
+	dt = 'float64';
+	ord = 'column-major';
+	sh = [ 2, 2 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	v = scalar2ndarray( 10.0, {
+		'dtype': dt
+	});
+	assignScalar( [ v, y ] );
+
+	expected = new Float64Array([
+		10.0,
+		10.0,
+		10.0,
+		10.0
+	]);
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function assigns a scalar value to each indexed element of a 2-dimensional output ndarray (column-major, contiguous, negative strides)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var v;
+	var y;
+
+	dt = 'float64';
+	ord = 'column-major';
+	sh = [ 2, 2 ];
+	st = [ -1, -2 ];
+	o = strides2offset( sh, st );
+
+	y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	v = scalar2ndarray( 10.0, {
+		'dtype': dt
+	});
+	assignScalar( [ v, y ] );
+
+	expected = new Float64Array([
+		10.0,
+		10.0,
+		10.0,
+		10.0
+	]);
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function assigns a scalar value to each indexed element of a 2-dimensional output ndarray (column-major, non-contiguous, same sign strides)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var v;
+	var y;
+
+	dt = 'float64';
+	ord = 'column-major';
+	sh = [ 2, 2 ];
+	st = [ 1, 4 ];
+	o = strides2offset( sh, st );
+
+	y = ndarray( dt, zeros( 8, dt ), sh, st, o, ord );
+
+	v = scalar2ndarray( 10.0, {
+		'dtype': dt
+	});
+	assignScalar( [ v, y ] );
+
+	expected = new Float64Array([
+		10.0,
+		10.0,
+		0.0,
+		0.0,
+		10.0,
+		10.0,
+		0.0,
+		0.0
+	]);
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function assigns a scalar value to each indexed element of a 2-dimensional output ndarray (column-major, non-contiguous, mixed sign strides)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var v;
+	var y;
+
+	dt = 'float64';
+	ord = 'column-major';
+	sh = [ 2, 2 ];
+	st = [ 1, -4 ];
+	o = strides2offset( sh, st );
+
+	y = ndarray( dt, zeros( 8, dt ), sh, st, o, ord );
+
+	v = scalar2ndarray( 10.0, {
+		'dtype': dt
+	});
+	assignScalar( [ v, y ] );
+
+	expected = new Float64Array([
+		10.0,
+		10.0,
+		0.0,
+		0.0,
+		10.0,
+		10.0,
+		0.0,
+		0.0
+	]);
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function assigns a scalar value to each indexed element of a 2-dimensional output ndarray (column-major, non-contiguous, large arrays)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var v;
+	var y;
+
+	dt = 'float64';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ bsize*2, 2 ];
+	st = [ 2, -bsize*4 ];
+	o = strides2offset( sh, st );
+
+	y = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	v = scalar2ndarray( 10.0, {
+		'dtype': dt
+	});
+	assignScalar( [ v, y ] );
+
+	expected = new Float64Array( y.length*2 );
+	dfill( y.length, 10.0, expected, st[ 0 ] );
+
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function assigns a scalar value to each indexed element of a 2-dimensional output ndarray (column-major, non-contiguous, large arrays)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var v;
+	var y;
+
+	dt = 'float64';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, bsize*2 ];
+	st = [ -2, 4 ];
+	o = strides2offset( sh, st );
+
+	y = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	v = scalar2ndarray( 10.0, {
+		'dtype': dt
+	});
+	assignScalar( [ v, y ] );
+
+	expected = new Float64Array( y.length*2 );
+	dfill( y.length, 10.0, expected, st[ 0 ] );
+
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function assigns a scalar value to each indexed element of a 2-dimensional output ndarray (column-major, contiguous, accessors)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var v;
+	var y;
+
+	dt = 'complex128';
+	ord = 'column-major';
+	sh = [ 2, 2 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	v = scalar2ndarray( new Complex128( 10.0, 10.0 ), {
+		'dtype': dt
+	});
+	assignScalar( [ v, y ] );
+
+	expected = new Complex128Array([
+		10.0,
+		10.0,
+		10.0,
+		10.0,
+		10.0,
+		10.0,
+		10.0,
+		10.0
+	]);
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function assigns a scalar value to each indexed element of a 2-dimensional output ndarray (column-major, contiguous, negative strides, accessors)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var v;
+	var y;
+
+	dt = 'complex128';
+	ord = 'column-major';
+	sh = [ 2, 2 ];
+	st = [ -1, -2 ];
+	o = strides2offset( sh, st );
+
+	y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	v = scalar2ndarray( new Complex128( 10.0, 10.0 ), {
+		'dtype': dt
+	});
+	assignScalar( [ v, y ] );
+
+	expected = new Complex128Array([
+		10.0,
+		10.0,
+		10.0,
+		10.0,
+		10.0,
+		10.0,
+		10.0,
+		10.0
+	]);
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function assigns a scalar value to each indexed element of a 2-dimensional output ndarray (column-major, non-contiguous, same sign strides, accessors)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var v;
+	var y;
+
+	dt = 'complex128';
+	ord = 'column-major';
+	sh = [ 2, 2 ];
+	st = [ 1, 4 ];
+	o = strides2offset( sh, st );
+
+	y = ndarray( dt, zeros( 8, dt ), sh, st, o, ord );
+
+	v = scalar2ndarray( new Complex128( 10.0, 10.0 ), {
+		'dtype': dt
+	});
+	assignScalar( [ v, y ] );
+
+	expected = new Complex128Array([
+		10.0,
+		10.0,
+		10.0,
+		10.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0,
+		10.0,
+		10.0,
+		10.0,
+		10.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0
+	]);
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function assigns a scalar value to each indexed element of a 2-dimensional output ndarray (column-major, non-contiguous, mixed sign strides, accessors)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var v;
+	var y;
+
+	dt = 'complex128';
+	ord = 'column-major';
+	sh = [ 2, 2 ];
+	st = [ 1, -4 ];
+	o = strides2offset( sh, st );
+
+	y = ndarray( dt, zeros( 8, dt ), sh, st, o, ord );
+
+	v = scalar2ndarray( new Complex128( 10.0, 10.0 ), {
+		'dtype': dt
+	});
+	assignScalar( [ v, y ] );
+
+	expected = new Complex128Array([
+		10.0,
+		10.0,
+		10.0,
+		10.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0,
+		10.0,
+		10.0,
+		10.0,
+		10.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0
+	]);
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function assigns a scalar value to each indexed element of a 2-dimensional output ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var v;
+	var y;
+
+	dt = 'complex128';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ bsize*2, 2 ];
+	st = [ 2, -bsize*4 ];
+	o = strides2offset( sh, st );
+
+	y = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	v = scalar2ndarray( new Complex128( 10.0, 10.0 ), {
+		'dtype': dt
+	});
+	assignScalar( [ v, y ] );
+
+	expected = new Complex128Array( y.length*2 );
+	gfill( y.length, new Complex128( 10.0, 10.0 ), expected, st[ 0 ] );
+
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function assigns a scalar value to each indexed element of a 2-dimensional output ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var v;
+	var y;
+
+	dt = 'complex128';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, bsize*2 ];
+	st = [ -2, 4 ];
+	o = strides2offset( sh, st );
+
+	y = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	v = scalar2ndarray( new Complex128( 10.0, 10.0 ), {
+		'dtype': dt
+	});
+	assignScalar( [ v, y ] );
+
+	expected = new Complex128Array( y.length*2 );
+	gfill( y.length, new Complex128( 10.0, 10.0 ), expected, st[ 0 ] );
+
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+
+	t.end();
+});
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/test/test.3d.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/test/test.3d.js
new file mode 100644
index 000000000000..67111e4b9903
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/test/test.3d.js
@@ -0,0 +1,1269 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2026 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 tape = require( 'tape' );
+var isSameComplex128Array = require( '@stdlib/assert/is-same-complex128array' );
+var isSameFloat64Array = require( '@stdlib/assert/is-same-float64array' );
+var Complex128Array = require( '@stdlib/array/complex128' );
+var Float64Array = require( '@stdlib/array/float64' );
+var zeros = require( '@stdlib/array/zeros' );
+var Complex128 = require( '@stdlib/complex/float64/ctor' );
+var scalar2ndarray = require( '@stdlib/ndarray/from-scalar' );
+var ndarray = require( '@stdlib/ndarray/ctor' );
+var shape2strides = require( '@stdlib/ndarray/base/shape2strides' );
+var strides2offset = require( '@stdlib/ndarray/base/strides2offset' );
+var numel = require( '@stdlib/ndarray/base/numel' );
+var dfill = require( '@stdlib/blas/ext/base/dfill' );
+var gfill = require( '@stdlib/blas/ext/base/gfill' );
+var blockSize = require( '@stdlib/ndarray/base/nullary-tiling-block-size' );
+var assignScalar = require( './../lib' );
+
+
+// TESTS //
+
+tape( 'main export is a function', function test( t ) {
+	t.ok( true, __filename );
+	t.strictEqual( typeof assignScalar, 'function', 'main export is a function' );
+	t.end();
+});
+
+tape( 'the function assigns a scalar value to each indexed element of a 3-dimensional output ndarray (row-major, singleton dimensions)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var v;
+	var y;
+
+	dt = 'float64';
+	ord = 'row-major';
+	sh = [ 4, 1, 1 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	v = scalar2ndarray( 10.0, {
+		'dtype': dt
+	});
+	assignScalar( [ v, y ] );
+
+	expected = new Float64Array([
+		10.0,
+		10.0,
+		10.0,
+		10.0
+	]);
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function assigns a scalar value to each indexed element of a 3-dimensional output ndarray (row-major, singleton dimensions, accessors)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var v;
+	var y;
+
+	dt = 'complex128';
+	ord = 'row-major';
+	sh = [ 4, 1, 1 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	v = scalar2ndarray( new Complex128( 10.0, 10.0 ), {
+		'dtype': dt
+	});
+	assignScalar( [ v, y ] );
+
+	expected = new Complex128Array([
+		10.0,
+		10.0,
+		10.0,
+		10.0,
+		10.0,
+		10.0,
+		10.0,
+		10.0
+	]);
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function assigns a scalar value to each indexed element of a 3-dimensional output ndarray (row-major, empty)', function test( t ) {
+	var expected;
+	var v;
+	var y;
+
+	y = ndarray( 'float64', zeros( 4, 'float64' ), [ 0, 0, 0 ], [ 1, 1, 1 ], 0, 'row-major' );
+
+	v = scalar2ndarray( 10.0, {
+		'dtype': 'float64'
+	});
+	assignScalar( [ v, y ] );
+
+	expected = new Float64Array([
+		0.0,
+		0.0,
+		0.0,
+		0.0
+	]);
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function assigns a scalar value to each indexed element of a 3-dimensional output ndarray (row-major, contiguous)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var v;
+	var y;
+
+	dt = 'float64';
+	ord = 'row-major';
+	sh = [ 2, 1, 2 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	v = scalar2ndarray( 10.0, {
+		'dtype': dt
+	});
+	assignScalar( [ v, y ] );
+
+	expected = new Float64Array([
+		10.0,
+		10.0,
+		10.0,
+		10.0
+	]);
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function assigns a scalar value to each indexed element of a 3-dimensional output ndarray (row-major, contiguous, negative strides)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var v;
+	var y;
+
+	dt = 'float64';
+	ord = 'row-major';
+	sh = [ 2, 2, 2 ];
+	st = [ -4, -2, -1 ];
+	o = strides2offset( sh, st );
+
+	y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	v = scalar2ndarray( 10.0, {
+		'dtype': dt
+	});
+	assignScalar( [ v, y ] );
+
+	expected = new Float64Array([
+		10.0,
+		10.0,
+		10.0,
+		10.0,
+		10.0,
+		10.0,
+		10.0,
+		10.0
+	]);
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function assigns a scalar value to each indexed element of a 3-dimensional output ndarray (row-major, non-contiguous, same sign strides)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var v;
+	var y;
+
+	dt = 'float64';
+	ord = 'row-major';
+	sh = [ 2, 1, 2 ];
+	st = [ 3, 2, 1 ];
+	o = strides2offset( sh, st );
+
+	y = ndarray( dt, zeros( 6, dt ), sh, st, o, ord );
+
+	v = scalar2ndarray( 10.0, {
+		'dtype': dt
+	});
+	assignScalar( [ v, y ] );
+
+	expected = new Float64Array([
+		10.0,
+		10.0,
+		0.0,
+		10.0,
+		10.0,
+		0.0
+	]);
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function assigns a scalar value to each indexed element of a 3-dimensional output ndarray (row-major, non-contiguous, mixed sign strides)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var v;
+	var y;
+
+	dt = 'float64';
+	ord = 'row-major';
+	sh = [ 2, 1, 2 ];
+	st = [ -3, -2, 1 ];
+	o = strides2offset( sh, st );
+
+	y = ndarray( dt, zeros( 6, dt ), sh, st, o, ord );
+
+	v = scalar2ndarray( 10.0, {
+		'dtype': dt
+	});
+	assignScalar( [ v, y ] );
+
+	expected = new Float64Array([
+		10.0,
+		10.0,
+		0.0,
+		10.0,
+		10.0,
+		0.0
+	]);
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function assigns a scalar value to each indexed element of a 3-dimensional output ndarray (row-major, non-contiguous, large arrays)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var v;
+	var y;
+
+	dt = 'float64';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ bsize*2, 1, 2 ];
+	st = [ -4, -4, 2 ];
+	o = strides2offset( sh, st );
+
+	y = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	v = scalar2ndarray( 10.0, {
+		'dtype': dt
+	});
+	assignScalar( [ v, y ] );
+
+	expected = new Float64Array( y.length*2 );
+	dfill( y.length, 10.0, expected, st[ 2 ] );
+
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function assigns a scalar value to each indexed element of a 3-dimensional output ndarray (row-major, non-contiguous, large arrays)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var v;
+	var y;
+
+	dt = 'float64';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 1, bsize*2, 2 ];
+	st = [ -bsize*8, -4, 2 ];
+	o = strides2offset( sh, st );
+
+	y = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	v = scalar2ndarray( 10.0, {
+		'dtype': dt
+	});
+	assignScalar( [ v, y ] );
+
+	expected = new Float64Array( y.length*2 );
+	dfill( y.length, 10.0, expected, st[ 2 ] );
+
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function assigns a scalar value to each indexed element of a 3-dimensional output ndarray (row-major, non-contiguous, large arrays)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var v;
+	var y;
+
+	dt = 'float64';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 1, 2, bsize*2 ];
+	st = [ bsize*8, bsize*4, -2 ];
+	o = strides2offset( sh, st );
+
+	y = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	v = scalar2ndarray( 10.0, {
+		'dtype': dt
+	});
+	assignScalar( [ v, y ] );
+
+	expected = new Float64Array( y.length*2 );
+	dfill( y.length, 10.0, expected, st[ 2 ] );
+
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function assigns a scalar value to each indexed element of a 3-dimensional output ndarray (row-major, contiguous, accessors)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var v;
+	var y;
+
+	dt = 'complex128';
+	ord = 'row-major';
+	sh = [ 2, 1, 2 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	v = scalar2ndarray( new Complex128( 10.0, -10.0 ), {
+		'dtype': dt
+	});
+	assignScalar( [ v, y ] );
+
+	expected = new Complex128Array([
+		10.0,
+		-10.0,
+		10.0,
+		-10.0,
+		10.0,
+		-10.0,
+		10.0,
+		-10.0
+	]);
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function assigns a scalar value to each indexed element of a 3-dimensional output ndarray (row-major, contiguous, negative strides, accessors)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var v;
+	var y;
+
+	dt = 'complex128';
+	ord = 'row-major';
+	sh = [ 2, 2, 2 ];
+	st = [ -4, -2, -1 ];
+	o = strides2offset( sh, st );
+
+	y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	v = scalar2ndarray( new Complex128( 10.0, 10.0 ), {
+		'dtype': dt
+	});
+	assignScalar( [ v, y ] );
+
+	expected = new Complex128Array([
+		10.0,
+		10.0,
+		10.0,
+		10.0,
+		10.0,
+		10.0,
+		10.0,
+		10.0,
+		10.0,
+		10.0,
+		10.0,
+		10.0,
+		10.0,
+		10.0,
+		10.0,
+		10.0
+	]);
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function assigns a scalar value to each indexed element of a 3-dimensional output ndarray (row-major, non-contiguous, same sign strides, accessors)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var v;
+	var y;
+
+	dt = 'complex128';
+	ord = 'row-major';
+	sh = [ 2, 1, 2 ];
+	st = [ 3, 2, 1 ];
+	o = strides2offset( sh, st );
+
+	y = ndarray( dt, zeros( 6, dt ), sh, st, o, ord );
+
+	v = scalar2ndarray( new Complex128( 10.0, 10.0 ), {
+		'dtype': dt
+	});
+	assignScalar( [ v, y ] );
+
+	expected = new Complex128Array([
+		10.0,
+		10.0,
+		10.0,
+		10.0,
+		0.0,
+		0.0,
+		10.0,
+		10.0,
+		10.0,
+		10.0,
+		0.0,
+		0.0
+	]);
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function assigns a scalar value to each indexed element of a 3-dimensional output ndarray (row-major, non-contiguous, mixed sign strides, accessors)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var v;
+	var y;
+
+	dt = 'complex128';
+	ord = 'row-major';
+	sh = [ 2, 1, 2 ];
+	st = [ -3, -2, 1 ];
+	o = strides2offset( sh, st );
+
+	y = ndarray( dt, zeros( 6, dt ), sh, st, o, ord );
+
+	v = scalar2ndarray( new Complex128( 10.0, 10.0 ), {
+		'dtype': dt
+	});
+	assignScalar( [ v, y ] );
+
+	expected = new Complex128Array([
+		10.0,
+		10.0,
+		10.0,
+		10.0,
+		0.0,
+		0.0,
+		10.0,
+		10.0,
+		10.0,
+		10.0,
+		0.0,
+		0.0
+	]);
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function assigns a scalar value to each indexed element of a 3-dimensional output ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var v;
+	var y;
+
+	dt = 'complex128';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ bsize*2, 1, 2 ];
+	st = [ -4, -4, 2 ];
+	o = strides2offset( sh, st );
+
+	y = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	v = scalar2ndarray( new Complex128( 10.0, 10.0 ), {
+		'dtype': dt
+	});
+	assignScalar( [ v, y ] );
+
+	expected = new Complex128Array( y.length*2 );
+	gfill( y.length, new Complex128( 10.0, 10.0 ), expected, st[ 2 ] );
+
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function assigns a scalar value to each indexed element of a 3-dimensional output ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var v;
+	var y;
+
+	dt = 'complex128';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 1, bsize*2, 2 ];
+	st = [ -bsize*8, -4, 2 ];
+	o = strides2offset( sh, st );
+
+	y = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	v = scalar2ndarray( new Complex128( 10.0, 10.0 ), {
+		'dtype': dt
+	});
+	assignScalar( [ v, y ] );
+
+	expected = new Complex128Array( y.length*2 );
+	gfill( y.length, new Complex128( 10.0, 10.0 ), expected, st[ 2 ] );
+
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function assigns a scalar value to each indexed element of a 3-dimensional output ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var v;
+	var y;
+
+	dt = 'complex128';
+	ord = 'row-major';
+
+	bsize = blockSize( dt );
+	sh = [ 1, 2, bsize*2 ];
+	st = [ bsize*8, bsize*4, -2 ];
+	o = strides2offset( sh, st );
+
+	y = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	v = scalar2ndarray( new Complex128( 10.0, 10.0 ), {
+		'dtype': dt
+	});
+	assignScalar( [ v, y ] );
+
+	expected = new Complex128Array( y.length*2 );
+	gfill( y.length, new Complex128( 10.0, 10.0 ), expected, st[ 2 ] );
+
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function assigns a scalar value to each indexed element of a 3-dimensional output ndarray (column-major, singleton dimensions)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var v;
+	var y;
+
+	dt = 'float64';
+	ord = 'column-major';
+	sh = [ 1, 1, 4 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	v = scalar2ndarray( 10.0, {
+		'dtype': dt
+	});
+	assignScalar( [ v, y ] );
+
+	expected = new Float64Array([
+		10.0,
+		10.0,
+		10.0,
+		10.0
+	]);
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function assigns a scalar value to each indexed element of a 3-dimensional output ndarray (column-major, singleton dimensions, accessors)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var v;
+	var y;
+
+	dt = 'complex128';
+	ord = 'column-major';
+	sh = [ 1, 1, 4 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	v = scalar2ndarray( new Complex128( 10.0, 10.0 ), {
+		'dtype': dt
+	});
+	assignScalar( [ v, y ] );
+
+	expected = new Complex128Array([
+		10.0,
+		10.0,
+		10.0,
+		10.0,
+		10.0,
+		10.0,
+		10.0,
+		10.0
+	]);
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function assigns a scalar value to each indexed element of a 3-dimensional output ndarray (column-major, empty)', function test( t ) {
+	var expected;
+	var v;
+	var y;
+
+	y = ndarray( 'float64', zeros( 4, 'float64' ), [ 0, 0, 0 ], [ 1, 1, 1 ], 0, 'column-major' );
+
+	v = scalar2ndarray( 10.0, {
+		'dtype': 'float64'
+	});
+	assignScalar( [ v, y ] );
+
+	expected = new Float64Array([
+		0.0,
+		0.0,
+		0.0,
+		0.0
+	]);
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function assigns a scalar value to each indexed element of a 3-dimensional output ndarray (column-major, contiguous)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var v;
+	var y;
+
+	dt = 'float64';
+	ord = 'column-major';
+	sh = [ 2, 1, 2 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	v = scalar2ndarray( 10.0, {
+		'dtype': dt
+	});
+	assignScalar( [ v, y ] );
+
+	expected = new Float64Array([
+		10.0,
+		10.0,
+		10.0,
+		10.0
+	]);
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function assigns a scalar value to each indexed element of a 3-dimensional output ndarray (column-major, contiguous, negative strides)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var v;
+	var y;
+
+	dt = 'float64';
+	ord = 'column-major';
+	sh = [ 2, 2, 2 ];
+	st = [ -1, -2, -4 ];
+	o = strides2offset( sh, st );
+
+	y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	v = scalar2ndarray( 10.0, {
+		'dtype': dt
+	});
+	assignScalar( [ v, y ] );
+
+	expected = new Float64Array([
+		10.0,
+		10.0,
+		10.0,
+		10.0,
+		10.0,
+		10.0,
+		10.0,
+		10.0
+	]);
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function assigns a scalar value to each indexed element of a 3-dimensional output ndarray (column-major, non-contiguous, same sign strides)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var v;
+	var y;
+
+	dt = 'float64';
+	ord = 'column-major';
+	sh = [ 2, 1, 2 ];
+	st = [ 1, 2, 3 ];
+	o = strides2offset( sh, st );
+
+	y = ndarray( dt, zeros( 6, dt ), sh, st, o, ord );
+
+	v = scalar2ndarray( 10.0, {
+		'dtype': dt
+	});
+	assignScalar( [ v, y ] );
+
+	expected = new Float64Array([
+		10.0,
+		10.0,
+		0.0,
+		10.0,
+		10.0,
+		0.0
+	]);
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function assigns a scalar value to each indexed element of a 3-dimensional output ndarray (column-major, non-contiguous, mixed sign strides)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var v;
+	var y;
+
+	dt = 'float64';
+	ord = 'column-major';
+	sh = [ 2, 1, 2 ];
+	st = [ -1, -2, 3 ];
+	o = strides2offset( sh, st );
+
+	y = ndarray( dt, zeros( 6, dt ), sh, st, o, ord );
+
+	v = scalar2ndarray( 10.0, {
+		'dtype': dt
+	});
+	assignScalar( [ v, y ] );
+
+	expected = new Float64Array([
+		10.0,
+		10.0,
+		0.0,
+		10.0,
+		10.0,
+		0.0
+	]);
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function assigns a scalar value to each indexed element of a 3-dimensional output ndarray (column-major, non-contiguous, large arrays)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var v;
+	var y;
+
+	dt = 'float64';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ bsize*2, 1, 2 ];
+	st = [ -2, bsize*4, bsize*4 ];
+	o = strides2offset( sh, st );
+
+	y = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	v = scalar2ndarray( 10.0, {
+		'dtype': dt
+	});
+	assignScalar( [ v, y ] );
+
+	expected = new Float64Array( y.length*2 );
+	dfill( y.length, 10.0, expected, st[ 0 ] );
+
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function assigns a scalar value to each indexed element of a 3-dimensional output ndarray (column-major, non-contiguous, large arrays)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var v;
+	var y;
+
+	dt = 'float64';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, bsize*2, 1 ];
+	st = [ 2, -4, -bsize*8 ];
+	o = strides2offset( sh, st );
+
+	y = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	v = scalar2ndarray( 10.0, {
+		'dtype': dt
+	});
+	assignScalar( [ v, y ] );
+
+	expected = new Float64Array( y.length*2 );
+	dfill( y.length, 10.0, expected, st[ 0 ] );
+
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function assigns a scalar value to each indexed element of a 3-dimensional output ndarray (column-major, non-contiguous, large arrays)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var v;
+	var y;
+
+	dt = 'float64';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, bsize*2 ];
+	st = [ 2, -4, -4 ];
+	o = strides2offset( sh, st );
+
+	y = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	v = scalar2ndarray( 10.0, {
+		'dtype': dt
+	});
+	assignScalar( [ v, y ] );
+
+	expected = new Float64Array( y.length*2 );
+	dfill( y.length, 10.0, expected, st[ 0 ] );
+
+	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function assigns a scalar value to each indexed element of a 3-dimensional output ndarray (column-major, contiguous, accessors)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var v;
+	var y;
+
+	dt = 'complex128';
+	ord = 'column-major';
+	sh = [ 2, 1, 2 ];
+	st = shape2strides( sh, ord );
+	o = strides2offset( sh, st );
+
+	y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	v = scalar2ndarray( new Complex128( 10.0, -10.0 ), {
+		'dtype': dt
+	});
+	assignScalar( [ v, y ] );
+
+	expected = new Complex128Array([
+		10.0,
+		-10.0,
+		10.0,
+		-10.0,
+		10.0,
+		-10.0,
+		10.0,
+		-10.0
+	]);
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function assigns a scalar value to each indexed element of a 3-dimensional output ndarray (column-major, contiguous, negative strides, accessors)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var v;
+	var y;
+
+	dt = 'complex128';
+	ord = 'column-major';
+	sh = [ 2, 2, 2 ];
+	st = [ -1, -2, -4 ];
+	o = strides2offset( sh, st );
+
+	y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+
+	v = scalar2ndarray( new Complex128( 10.0, 10.0 ), {
+		'dtype': dt
+	});
+	assignScalar( [ v, y ] );
+
+	expected = new Complex128Array([
+		10.0,
+		10.0,
+		10.0,
+		10.0,
+		10.0,
+		10.0,
+		10.0,
+		10.0,
+		10.0,
+		10.0,
+		10.0,
+		10.0,
+		10.0,
+		10.0,
+		10.0,
+		10.0
+	]);
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function assigns a scalar value to each indexed element of a 3-dimensional output ndarray (column-major, non-contiguous, same sign strides, accessors)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var v;
+	var y;
+
+	dt = 'complex128';
+	ord = 'column-major';
+	sh = [ 2, 1, 2 ];
+	st = [ 1, 2, 3 ];
+	o = strides2offset( sh, st );
+
+	y = ndarray( dt, zeros( 6, dt ), sh, st, o, ord );
+
+	v = scalar2ndarray( new Complex128( 10.0, 10.0 ), {
+		'dtype': dt
+	});
+	assignScalar( [ v, y ] );
+
+	expected = new Complex128Array([
+		10.0,
+		10.0,
+		10.0,
+		10.0,
+		0.0,
+		0.0,
+		10.0,
+		10.0,
+		10.0,
+		10.0,
+		0.0,
+		0.0
+	]);
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function assigns a scalar value to each indexed element of a 3-dimensional output ndarray (column-major, non-contiguous, mixed sign strides, accessors)', function test( t ) {
+	var expected;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var v;
+	var y;
+
+	dt = 'complex128';
+	ord = 'column-major';
+	sh = [ 2, 1, 2 ];
+	st = [ -1, -2, 3 ];
+	o = strides2offset( sh, st );
+
+	y = ndarray( dt, zeros( 6, dt ), sh, st, o, ord );
+
+	v = scalar2ndarray( new Complex128( 10.0, 10.0 ), {
+		'dtype': dt
+	});
+	assignScalar( [ v, y ] );
+
+	expected = new Complex128Array([
+		10.0,
+		10.0,
+		10.0,
+		10.0,
+		0.0,
+		0.0,
+		10.0,
+		10.0,
+		10.0,
+		10.0,
+		0.0,
+		0.0
+	]);
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function assigns a scalar value to each indexed element of a 3-dimensional output ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var v;
+	var y;
+
+	dt = 'complex128';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ bsize*2, 2, 1 ];
+	st = [ 2, -bsize*4, -bsize*8 ];
+	o = strides2offset( sh, st );
+
+	y = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	v = scalar2ndarray( new Complex128( 10.0, 10.0 ), {
+		'dtype': dt
+	});
+	assignScalar( [ v, y ] );
+
+	expected = new Complex128Array( y.length*2 );
+	gfill( y.length, new Complex128( 10.0, 10.0 ), expected, st[ 0 ] );
+
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function assigns a scalar value to each indexed element of a 3-dimensional output ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var v;
+	var y;
+
+	dt = 'complex128';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, bsize*2, 1 ];
+	st = [ -2, 4, bsize*8 ];
+	o = strides2offset( sh, st );
+
+	y = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	v = scalar2ndarray( new Complex128( 10.0, 10.0 ), {
+		'dtype': dt
+	});
+	assignScalar( [ v, y ] );
+
+	expected = new Complex128Array( y.length*2 );
+	gfill( y.length, new Complex128( 10.0, 10.0 ), expected, st[ 0 ] );
+
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+
+	t.end();
+});
+
+tape( 'the function assigns a scalar value to each indexed element of a 3-dimensional output ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var expected;
+	var bsize;
+	var ord;
+	var sh;
+	var st;
+	var dt;
+	var o;
+	var v;
+	var y;
+
+	dt = 'complex128';
+	ord = 'column-major';
+
+	bsize = blockSize( dt );
+	sh = [ 2, 1, bsize*2 ];
+	st = [ 2, -4, 4 ];
+	o = strides2offset( sh, st );
+
+	y = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+
+	v = scalar2ndarray( new Complex128( 10.0, 10.0 ), {
+		'dtype': dt
+	});
+	assignScalar( [ v, y ] );
+
+	expected = new Complex128Array( y.length*2 );
+	gfill( y.length, new Complex128( 10.0, 10.0 ), expected, st[ 0 ] );
+
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+
+	t.end();
+});
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/test/test.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/test/test.js
new file mode 100644
index 000000000000..b7a624eb4aa1
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/test/test.js
@@ -0,0 +1,33 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2026 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 tape = require( 'tape' );
+var assignScalar = require( './../lib' );
+
+
+// TESTS //
+
+tape( 'main export is a function', function test( t ) {
+	t.ok( true, __filename );
+	t.strictEqual( typeof assignScalar, 'function', 'main export is a function' );
+	t.end();
+});

From 1b468e2452469b71b5bc1a3db148cbe7f90d4720 Mon Sep 17 00:00:00 2001
From: Athan <kgryte@gmail.com>
Date: Sat, 21 Mar 2026 18:16:35 -0700
Subject: [PATCH 02/20] bench: fix missing arguments and fix ndarray object
 creation

---
type: pre_commit_static_analysis_report
description: Results of running static analysis checks when committing changes.
report:
  - task: lint_filenames
    status: passed
  - task: lint_editorconfig
    status: passed
  - task: lint_markdown
    status: na
  - task: lint_package_json
    status: na
  - task: lint_repl_help
    status: na
  - task: lint_javascript_src
    status: na
  - task: lint_javascript_cli
    status: na
  - task: lint_javascript_examples
    status: na
  - task: lint_javascript_tests
    status: na
  - task: lint_javascript_benchmarks
    status: passed
  - task: lint_python
    status: na
  - task: lint_r
    status: na
  - task: lint_c_src
    status: na
  - task: lint_c_examples
    status: na
  - task: lint_c_benchmarks
    status: na
  - task: lint_c_tests_fixtures
    status: na
  - task: lint_shell
    status: na
  - task: lint_typescript_declarations
    status: passed
  - task: lint_typescript_tests
    status: na
  - task: lint_license_headers
    status: passed
---
---
 .../benchmark/benchmark.10d_blocked_columnmajor.js         | 5 ++---
 .../benchmark/benchmark.10d_blocked_rowmajor.js            | 5 ++---
 .../assign-scalar/benchmark/benchmark.10d_columnmajor.js   | 7 +++----
 .../base/assign-scalar/benchmark/benchmark.10d_rowmajor.js | 7 +++----
 .../assign-scalar/benchmark/benchmark.11d_columnmajor.js   | 5 ++---
 .../base/assign-scalar/benchmark/benchmark.11d_rowmajor.js | 5 ++---
 .../assign-scalar/benchmark/benchmark.1d_columnmajor.js    | 5 ++---
 .../base/assign-scalar/benchmark/benchmark.1d_rowmajor.js  | 5 ++---
 .../benchmark/benchmark.2d_blocked_columnmajor.js          | 5 ++---
 .../benchmark/benchmark.2d_blocked_rowmajor.js             | 5 ++---
 .../assign-scalar/benchmark/benchmark.2d_columnmajor.js    | 7 +++----
 .../base/assign-scalar/benchmark/benchmark.2d_rowmajor.js  | 7 +++----
 .../benchmark/benchmark.2d_rowmajor_accessors.js           | 7 +++----
 .../benchmark/benchmark.2d_rowmajor_accessors_complex.js   | 2 +-
 .../benchmark/benchmark.3d_blocked_columnmajor.js          | 5 ++---
 .../benchmark/benchmark.3d_blocked_rowmajor.js             | 5 ++---
 .../assign-scalar/benchmark/benchmark.3d_columnmajor.js    | 7 +++----
 .../base/assign-scalar/benchmark/benchmark.3d_rowmajor.js  | 7 +++----
 .../benchmark/benchmark.4d_blocked_columnmajor.js          | 5 ++---
 .../benchmark/benchmark.4d_blocked_rowmajor.js             | 5 ++---
 .../assign-scalar/benchmark/benchmark.4d_columnmajor.js    | 7 +++----
 .../base/assign-scalar/benchmark/benchmark.4d_rowmajor.js  | 7 +++----
 .../benchmark/benchmark.5d_blocked_columnmajor.js          | 5 ++---
 .../benchmark/benchmark.5d_blocked_rowmajor.js             | 5 ++---
 .../assign-scalar/benchmark/benchmark.5d_columnmajor.js    | 7 +++----
 .../base/assign-scalar/benchmark/benchmark.5d_rowmajor.js  | 7 +++----
 .../benchmark/benchmark.6d_blocked_columnmajor.js          | 5 ++---
 .../benchmark/benchmark.6d_blocked_rowmajor.js             | 5 ++---
 .../assign-scalar/benchmark/benchmark.6d_columnmajor.js    | 7 +++----
 .../base/assign-scalar/benchmark/benchmark.6d_rowmajor.js  | 7 +++----
 .../benchmark/benchmark.7d_blocked_columnmajor.js          | 5 ++---
 .../benchmark/benchmark.7d_blocked_rowmajor.js             | 5 ++---
 .../assign-scalar/benchmark/benchmark.7d_columnmajor.js    | 7 +++----
 .../base/assign-scalar/benchmark/benchmark.7d_rowmajor.js  | 7 +++----
 .../benchmark/benchmark.8d_blocked_columnmajor.js          | 5 ++---
 .../benchmark/benchmark.8d_blocked_rowmajor.js             | 5 ++---
 .../assign-scalar/benchmark/benchmark.8d_columnmajor.js    | 7 +++----
 .../base/assign-scalar/benchmark/benchmark.8d_rowmajor.js  | 7 +++----
 .../benchmark/benchmark.9d_blocked_columnmajor.js          | 5 ++---
 .../benchmark/benchmark.9d_blocked_rowmajor.js             | 5 ++---
 .../assign-scalar/benchmark/benchmark.9d_columnmajor.js    | 7 +++----
 .../base/assign-scalar/benchmark/benchmark.9d_rowmajor.js  | 7 +++----
 42 files changed, 102 insertions(+), 143 deletions(-)

diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.10d_blocked_columnmajor.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.10d_blocked_columnmajor.js
index 9c228cef9659..419a6ff3d642 100644
--- a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.10d_blocked_columnmajor.js
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.10d_blocked_columnmajor.js
@@ -53,10 +53,9 @@ function createBenchmark( len, shape, xtype, ytype ) {
 	var x;
 	var y;
 
-	y = filledarray( 0.0, len, ytype );
 	x = {
 		'dtype': xtype,
-		'data': [ 10.0 ],
+		'data': filledarray( 10.0, 1, xtype ),
 		'shape': [],
 		'strides': [ 0 ],
 		'offset': 0,
@@ -64,7 +63,7 @@ function createBenchmark( len, shape, xtype, ytype ) {
 	};
 	y = {
 		'dtype': ytype,
-		'data': y,
+		'data': filledarray( 0.0, len, ytype ),
 		'shape': shape,
 		'strides': shape2strides( shape, order ),
 		'offset': 0,
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.10d_blocked_rowmajor.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.10d_blocked_rowmajor.js
index 3b77bae66878..dd33241a3f1a 100644
--- a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.10d_blocked_rowmajor.js
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.10d_blocked_rowmajor.js
@@ -53,10 +53,9 @@ function createBenchmark( len, shape, xtype, ytype ) {
 	var x;
 	var y;
 
-	y = filledarray( 0.0, len, ytype );
 	x = {
 		'dtype': xtype,
-		'data': [ 10.0 ],
+		'data': filledarray( 10.0, 1, xtype ),
 		'shape': [],
 		'strides': [ 0 ],
 		'offset': 0,
@@ -64,7 +63,7 @@ function createBenchmark( len, shape, xtype, ytype ) {
 	};
 	y = {
 		'dtype': ytype,
-		'data': y,
+		'data': filledarray( 0.0, len, ytype ),
 		'shape': shape,
 		'strides': shape2strides( shape, order ),
 		'offset': 0,
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.10d_columnmajor.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.10d_columnmajor.js
index 8e43383c4eea..1a6f49c0f8dd 100644
--- a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.10d_columnmajor.js
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.10d_columnmajor.js
@@ -53,10 +53,9 @@ function createBenchmark( len, shape, xtype, ytype ) {
 	var x;
 	var y;
 
-	y = filledarray( 0.0, len, ytype );
 	x = {
 		'dtype': xtype,
-		'data': [ 10.0 ],
+		'data': filledarray( 10.0, 1, xtype ),
 		'shape': [],
 		'strides': [ 0 ],
 		'offset': 0,
@@ -64,7 +63,7 @@ function createBenchmark( len, shape, xtype, ytype ) {
 	};
 	y = {
 		'dtype': ytype,
-		'data': y,
+		'data': filledarray( 0.0, len, ytype ),
 		'shape': shape,
 		'strides': shape2strides( shape, order ),
 		'offset': 0,
@@ -83,7 +82,7 @@ function createBenchmark( len, shape, xtype, ytype ) {
 
 		b.tic();
 		for ( i = 0; i < b.iterations; i++ ) {
-			assignScalar( x, y );
+			assignScalar( x, y, order === 'row-major' );
 			if ( isnan( y.data[ i%len ] ) ) {
 				b.fail( 'should not return NaN' );
 			}
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.10d_rowmajor.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.10d_rowmajor.js
index bda8225eb29c..5aeae07a66bc 100644
--- a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.10d_rowmajor.js
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.10d_rowmajor.js
@@ -53,10 +53,9 @@ function createBenchmark( len, shape, xtype, ytype ) {
 	var x;
 	var y;
 
-	y = filledarray( 0.0, len, ytype );
 	x = {
 		'dtype': xtype,
-		'data': [ 10.0 ],
+		'data': filledarray( 10.0, 1, xtype ),
 		'shape': [],
 		'strides': [ 0 ],
 		'offset': 0,
@@ -64,7 +63,7 @@ function createBenchmark( len, shape, xtype, ytype ) {
 	};
 	y = {
 		'dtype': ytype,
-		'data': y,
+		'data': filledarray( 0.0, len, ytype ),
 		'shape': shape,
 		'strides': shape2strides( shape, order ),
 		'offset': 0,
@@ -83,7 +82,7 @@ function createBenchmark( len, shape, xtype, ytype ) {
 
 		b.tic();
 		for ( i = 0; i < b.iterations; i++ ) {
-			assignScalar( x, y );
+			assignScalar( x, y, order === 'row-major' );
 			if ( isnan( y.data[ i%len ] ) ) {
 				b.fail( 'should not return NaN' );
 			}
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.11d_columnmajor.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.11d_columnmajor.js
index 55a07c367ce8..6e95b85ecf95 100644
--- a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.11d_columnmajor.js
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.11d_columnmajor.js
@@ -53,10 +53,9 @@ function createBenchmark( len, shape, xtype, ytype ) {
 	var x;
 	var y;
 
-	y = filledarray( 0.0, len, ytype );
 	x = {
 		'dtype': xtype,
-		'data': [ 10.0 ],
+		'data': filledarray( 10.0, 1, xtype ),
 		'shape': [],
 		'strides': [ 0 ],
 		'offset': 0,
@@ -64,7 +63,7 @@ function createBenchmark( len, shape, xtype, ytype ) {
 	};
 	y = {
 		'dtype': ytype,
-		'data': y,
+		'data': filledarray( 0.0, len, ytype ),
 		'shape': shape,
 		'strides': shape2strides( shape, order ),
 		'offset': 0,
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.11d_rowmajor.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.11d_rowmajor.js
index 9c38dd55c81e..bb86b752810d 100644
--- a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.11d_rowmajor.js
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.11d_rowmajor.js
@@ -53,10 +53,9 @@ function createBenchmark( len, shape, xtype, ytype ) {
 	var x;
 	var y;
 
-	y = filledarray( 0.0, len, ytype );
 	x = {
 		'dtype': xtype,
-		'data': [ 10.0 ],
+		'data': filledarray( 10.0, 1, xtype ),
 		'shape': [],
 		'strides': [ 0 ],
 		'offset': 0,
@@ -64,7 +63,7 @@ function createBenchmark( len, shape, xtype, ytype ) {
 	};
 	y = {
 		'dtype': ytype,
-		'data': y,
+		'data': filledarray( 0.0, len, ytype ),
 		'shape': shape,
 		'strides': shape2strides( shape, order ),
 		'offset': 0,
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.1d_columnmajor.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.1d_columnmajor.js
index d742352f7bf1..f05fbc8844ea 100644
--- a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.1d_columnmajor.js
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.1d_columnmajor.js
@@ -52,10 +52,9 @@ function createBenchmark( len, shape, xtype, ytype ) {
 	var x;
 	var y;
 
-	y = filledarray( 0.0, len, ytype );
 	x = {
 		'dtype': xtype,
-		'data': [ 10.0 ],
+		'data': filledarray( 10.0, 1, xtype ),
 		'shape': [],
 		'strides': [ 0 ],
 		'offset': 0,
@@ -63,7 +62,7 @@ function createBenchmark( len, shape, xtype, ytype ) {
 	};
 	y = {
 		'dtype': ytype,
-		'data': y,
+		'data': filledarray( 0.0, len, ytype ),
 		'shape': shape,
 		'strides': shape2strides( shape, order ),
 		'offset': 0,
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.1d_rowmajor.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.1d_rowmajor.js
index 8d6671e3accd..08a85a578ec4 100644
--- a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.1d_rowmajor.js
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.1d_rowmajor.js
@@ -52,10 +52,9 @@ function createBenchmark( len, shape, xtype, ytype ) {
 	var x;
 	var y;
 
-	y = filledarray( 0.0, len, ytype );
 	x = {
 		'dtype': xtype,
-		'data': [ 10.0 ],
+		'data': filledarray( 10.0, 1, xtype ),
 		'shape': [],
 		'strides': [ 0 ],
 		'offset': 0,
@@ -63,7 +62,7 @@ function createBenchmark( len, shape, xtype, ytype ) {
 	};
 	y = {
 		'dtype': ytype,
-		'data': y,
+		'data': filledarray( 0.0, len, ytype ),
 		'shape': shape,
 		'strides': shape2strides( shape, order ),
 		'offset': 0,
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.2d_blocked_columnmajor.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.2d_blocked_columnmajor.js
index 5f5f109ba9c1..e5b8c931c8f9 100644
--- a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.2d_blocked_columnmajor.js
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.2d_blocked_columnmajor.js
@@ -54,10 +54,9 @@ function createBenchmark( len, shape, xtype, ytype ) {
 	var x;
 	var y;
 
-	y = filledarray( 0.0, len, ytype );
 	x = {
 		'dtype': xtype,
-		'data': [ 10.0 ],
+		'data': filledarray( 10.0, 1, xtype ),
 		'shape': [],
 		'strides': [ 0 ],
 		'offset': 0,
@@ -65,7 +64,7 @@ function createBenchmark( len, shape, xtype, ytype ) {
 	};
 	y = {
 		'dtype': ytype,
-		'data': y,
+		'data': filledarray( 0.0, len, ytype ),
 		'shape': shape,
 		'strides': shape2strides( shape, order ),
 		'offset': 0,
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.2d_blocked_rowmajor.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.2d_blocked_rowmajor.js
index 9f322e61c151..d8063306133c 100644
--- a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.2d_blocked_rowmajor.js
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.2d_blocked_rowmajor.js
@@ -54,10 +54,9 @@ function createBenchmark( len, shape, xtype, ytype ) {
 	var x;
 	var y;
 
-	y = filledarray( 0.0, len, ytype );
 	x = {
 		'dtype': xtype,
-		'data': [ 10.0 ],
+		'data': filledarray( 10.0, 1, xtype ),
 		'shape': [],
 		'strides': [ 0 ],
 		'offset': 0,
@@ -65,7 +64,7 @@ function createBenchmark( len, shape, xtype, ytype ) {
 	};
 	y = {
 		'dtype': ytype,
-		'data': y,
+		'data': filledarray( 0.0, len, ytype ),
 		'shape': shape,
 		'strides': shape2strides( shape, order ),
 		'offset': 0,
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.2d_columnmajor.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.2d_columnmajor.js
index c15dae8b042d..d505736099c4 100644
--- a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.2d_columnmajor.js
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.2d_columnmajor.js
@@ -54,10 +54,9 @@ function createBenchmark( len, shape, xtype, ytype ) {
 	var x;
 	var y;
 
-	y = filledarray( 0.0, len, ytype );
 	x = {
 		'dtype': xtype,
-		'data': [ 10.0 ],
+		'data': filledarray( 10.0, 1, xtype ),
 		'shape': [],
 		'strides': [ 0 ],
 		'offset': 0,
@@ -65,7 +64,7 @@ function createBenchmark( len, shape, xtype, ytype ) {
 	};
 	y = {
 		'dtype': ytype,
-		'data': y,
+		'data': filledarray( 0.0, len, ytype ),
 		'shape': shape,
 		'strides': shape2strides( shape, order ),
 		'offset': 0,
@@ -84,7 +83,7 @@ function createBenchmark( len, shape, xtype, ytype ) {
 
 		b.tic();
 		for ( i = 0; i < b.iterations; i++ ) {
-			assignScalar( x, y );
+			assignScalar( x, y, order === 'row-major' );
 			if ( isnan( y.data[ i%len ] ) ) {
 				b.fail( 'should not return NaN' );
 			}
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.2d_rowmajor.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.2d_rowmajor.js
index 534a975fe112..b7b64f981f11 100644
--- a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.2d_rowmajor.js
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.2d_rowmajor.js
@@ -54,10 +54,9 @@ function createBenchmark( len, shape, xtype, ytype ) {
 	var x;
 	var y;
 
-	y = filledarray( 0.0, len, ytype );
 	x = {
 		'dtype': xtype,
-		'data': [ 10.0 ],
+		'data': filledarray( 10.0, 1, xtype ),
 		'shape': [],
 		'strides': [ 0 ],
 		'offset': 0,
@@ -65,7 +64,7 @@ function createBenchmark( len, shape, xtype, ytype ) {
 	};
 	y = {
 		'dtype': ytype,
-		'data': y,
+		'data': filledarray( 0.0, len, ytype ),
 		'shape': shape,
 		'strides': shape2strides( shape, order ),
 		'offset': 0,
@@ -84,7 +83,7 @@ function createBenchmark( len, shape, xtype, ytype ) {
 
 		b.tic();
 		for ( i = 0; i < b.iterations; i++ ) {
-			assignScalar( x, y );
+			assignScalar( x, y, order === 'row-major' );
 			if ( isnan( y.data[ i%len ] ) ) {
 				b.fail( 'should not return NaN' );
 			}
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.2d_rowmajor_accessors.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.2d_rowmajor_accessors.js
index 70b175a97a62..b2e16dada9a9 100644
--- a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.2d_rowmajor_accessors.js
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.2d_rowmajor_accessors.js
@@ -78,10 +78,9 @@ function createBenchmark( len, shape, xtype, ytype ) {
 	var x;
 	var y;
 
-	y = filledarray( 0.0, len, ytype );
 	x = {
 		'dtype': xtype,
-		'data': [ 10.0 ],
+		'data': filledarray( 10.0, 1, xtype ),
 		'shape': [],
 		'strides': [ 0 ],
 		'offset': 0,
@@ -91,7 +90,7 @@ function createBenchmark( len, shape, xtype, ytype ) {
 	};
 	y = {
 		'dtype': ytype,
-		'data': y,
+		'data': filledarray( 0.0, len, ytype ),
 		'shape': shape,
 		'strides': shape2strides( shape, order ),
 		'offset': 0,
@@ -112,7 +111,7 @@ function createBenchmark( len, shape, xtype, ytype ) {
 
 		b.tic();
 		for ( i = 0; i < b.iterations; i++ ) {
-			assignScalar( x, y );
+			assignScalar( x, y, order === 'row-major' );
 			if ( isnan( y.data[ i%len ] ) ) {
 				b.fail( 'should not return NaN' );
 			}
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.2d_rowmajor_accessors_complex.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.2d_rowmajor_accessors_complex.js
index 543a880b726d..8d14585865f4 100644
--- a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.2d_rowmajor_accessors_complex.js
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.2d_rowmajor_accessors_complex.js
@@ -120,7 +120,7 @@ function createBenchmark( len, shape, xtype, ytype ) {
 
 		b.tic();
 		for ( i = 0; i < b.iterations; i++ ) {
-			assignScalar( x, y );
+			assignScalar( x, y, order === 'row-major' );
 			if ( isnan( ybuf[ i%len ] ) ) {
 				b.fail( 'should not return NaN' );
 			}
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.3d_blocked_columnmajor.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.3d_blocked_columnmajor.js
index 47843d6e9dfb..ceb9d10d920d 100644
--- a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.3d_blocked_columnmajor.js
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.3d_blocked_columnmajor.js
@@ -54,10 +54,9 @@ function createBenchmark( len, shape, xtype, ytype ) {
 	var x;
 	var y;
 
-	y = filledarray( 0.0, len, ytype );
 	x = {
 		'dtype': xtype,
-		'data': [ 10.0 ],
+		'data': filledarray( 10.0, 1, xtype ),
 		'shape': [],
 		'strides': [ 0 ],
 		'offset': 0,
@@ -65,7 +64,7 @@ function createBenchmark( len, shape, xtype, ytype ) {
 	};
 	y = {
 		'dtype': ytype,
-		'data': y,
+		'data': filledarray( 0.0, len, ytype ),
 		'shape': shape,
 		'strides': shape2strides( shape, order ),
 		'offset': 0,
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.3d_blocked_rowmajor.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.3d_blocked_rowmajor.js
index 78a862ea7f8a..6999fd5c04da 100644
--- a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.3d_blocked_rowmajor.js
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.3d_blocked_rowmajor.js
@@ -54,10 +54,9 @@ function createBenchmark( len, shape, xtype, ytype ) {
 	var x;
 	var y;
 
-	y = filledarray( 0.0, len, ytype );
 	x = {
 		'dtype': xtype,
-		'data': [ 10.0 ],
+		'data': filledarray( 10.0, 1, xtype ),
 		'shape': [],
 		'strides': [ 0 ],
 		'offset': 0,
@@ -65,7 +64,7 @@ function createBenchmark( len, shape, xtype, ytype ) {
 	};
 	y = {
 		'dtype': ytype,
-		'data': y,
+		'data': filledarray( 0.0, len, ytype ),
 		'shape': shape,
 		'strides': shape2strides( shape, order ),
 		'offset': 0,
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.3d_columnmajor.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.3d_columnmajor.js
index da98b577d065..a9c832545e08 100644
--- a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.3d_columnmajor.js
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.3d_columnmajor.js
@@ -54,10 +54,9 @@ function createBenchmark( len, shape, xtype, ytype ) {
 	var x;
 	var y;
 
-	y = filledarray( 0.0, len, ytype );
 	x = {
 		'dtype': xtype,
-		'data': [ 10.0 ],
+		'data': filledarray( 10.0, 1, xtype ),
 		'shape': [],
 		'strides': [ 0 ],
 		'offset': 0,
@@ -65,7 +64,7 @@ function createBenchmark( len, shape, xtype, ytype ) {
 	};
 	y = {
 		'dtype': ytype,
-		'data': y,
+		'data': filledarray( 0.0, len, ytype ),
 		'shape': shape,
 		'strides': shape2strides( shape, order ),
 		'offset': 0,
@@ -84,7 +83,7 @@ function createBenchmark( len, shape, xtype, ytype ) {
 
 		b.tic();
 		for ( i = 0; i < b.iterations; i++ ) {
-			assignScalar( x, y );
+			assignScalar( x, y, order === 'row-major' );
 			if ( isnan( y.data[ i%len ] ) ) {
 				b.fail( 'should not return NaN' );
 			}
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.3d_rowmajor.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.3d_rowmajor.js
index 5d3895066ade..49cf22585c5b 100644
--- a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.3d_rowmajor.js
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.3d_rowmajor.js
@@ -54,10 +54,9 @@ function createBenchmark( len, shape, xtype, ytype ) {
 	var x;
 	var y;
 
-	y = filledarray( 0.0, len, ytype );
 	x = {
 		'dtype': xtype,
-		'data': [ 10.0 ],
+		'data': filledarray( 10.0, 1, xtype ),
 		'shape': [],
 		'strides': [ 0 ],
 		'offset': 0,
@@ -65,7 +64,7 @@ function createBenchmark( len, shape, xtype, ytype ) {
 	};
 	y = {
 		'dtype': ytype,
-		'data': y,
+		'data': filledarray( 0.0, len, ytype ),
 		'shape': shape,
 		'strides': shape2strides( shape, order ),
 		'offset': 0,
@@ -84,7 +83,7 @@ function createBenchmark( len, shape, xtype, ytype ) {
 
 		b.tic();
 		for ( i = 0; i < b.iterations; i++ ) {
-			assignScalar( x, y );
+			assignScalar( x, y, order === 'row-major' );
 			if ( isnan( y.data[ i%len ] ) ) {
 				b.fail( 'should not return NaN' );
 			}
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.4d_blocked_columnmajor.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.4d_blocked_columnmajor.js
index 2c451d6c3c29..24edceebce4b 100644
--- a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.4d_blocked_columnmajor.js
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.4d_blocked_columnmajor.js
@@ -53,10 +53,9 @@ function createBenchmark( len, shape, xtype, ytype ) {
 	var x;
 	var y;
 
-	y = filledarray( 0.0, len, ytype );
 	x = {
 		'dtype': xtype,
-		'data': [ 10.0 ],
+		'data': filledarray( 10.0, 1, xtype ),
 		'shape': [],
 		'strides': [ 0 ],
 		'offset': 0,
@@ -64,7 +63,7 @@ function createBenchmark( len, shape, xtype, ytype ) {
 	};
 	y = {
 		'dtype': ytype,
-		'data': y,
+		'data': filledarray( 0.0, len, ytype ),
 		'shape': shape,
 		'strides': shape2strides( shape, order ),
 		'offset': 0,
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.4d_blocked_rowmajor.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.4d_blocked_rowmajor.js
index 7d9e1414f931..53385f781fe9 100644
--- a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.4d_blocked_rowmajor.js
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.4d_blocked_rowmajor.js
@@ -53,10 +53,9 @@ function createBenchmark( len, shape, xtype, ytype ) {
 	var x;
 	var y;
 
-	y = filledarray( 0.0, len, ytype );
 	x = {
 		'dtype': xtype,
-		'data': [ 10.0 ],
+		'data': filledarray( 10.0, 1, xtype ),
 		'shape': [],
 		'strides': [ 0 ],
 		'offset': 0,
@@ -64,7 +63,7 @@ function createBenchmark( len, shape, xtype, ytype ) {
 	};
 	y = {
 		'dtype': ytype,
-		'data': y,
+		'data': filledarray( 0.0, len, ytype ),
 		'shape': shape,
 		'strides': shape2strides( shape, order ),
 		'offset': 0,
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.4d_columnmajor.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.4d_columnmajor.js
index a20b9237d5ab..a666289422f5 100644
--- a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.4d_columnmajor.js
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.4d_columnmajor.js
@@ -53,10 +53,9 @@ function createBenchmark( len, shape, xtype, ytype ) {
 	var x;
 	var y;
 
-	y = filledarray( 0.0, len, ytype );
 	x = {
 		'dtype': xtype,
-		'data': [ 10.0 ],
+		'data': filledarray( 10.0, 1, xtype ),
 		'shape': [],
 		'strides': [ 0 ],
 		'offset': 0,
@@ -64,7 +63,7 @@ function createBenchmark( len, shape, xtype, ytype ) {
 	};
 	y = {
 		'dtype': ytype,
-		'data': y,
+		'data': filledarray( 0.0, len, ytype ),
 		'shape': shape,
 		'strides': shape2strides( shape, order ),
 		'offset': 0,
@@ -83,7 +82,7 @@ function createBenchmark( len, shape, xtype, ytype ) {
 
 		b.tic();
 		for ( i = 0; i < b.iterations; i++ ) {
-			assignScalar( x, y );
+			assignScalar( x, y, order === 'row-major' );
 			if ( isnan( y.data[ i%len ] ) ) {
 				b.fail( 'should not return NaN' );
 			}
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.4d_rowmajor.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.4d_rowmajor.js
index 139186e2fb8d..fbf52b593b2c 100644
--- a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.4d_rowmajor.js
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.4d_rowmajor.js
@@ -53,10 +53,9 @@ function createBenchmark( len, shape, xtype, ytype ) {
 	var x;
 	var y;
 
-	y = filledarray( 0.0, len, ytype );
 	x = {
 		'dtype': xtype,
-		'data': [ 10.0 ],
+		'data': filledarray( 10.0, 1, xtype ),
 		'shape': [],
 		'strides': [ 0 ],
 		'offset': 0,
@@ -64,7 +63,7 @@ function createBenchmark( len, shape, xtype, ytype ) {
 	};
 	y = {
 		'dtype': ytype,
-		'data': y,
+		'data': filledarray( 0.0, len, ytype ),
 		'shape': shape,
 		'strides': shape2strides( shape, order ),
 		'offset': 0,
@@ -83,7 +82,7 @@ function createBenchmark( len, shape, xtype, ytype ) {
 
 		b.tic();
 		for ( i = 0; i < b.iterations; i++ ) {
-			assignScalar( x, y );
+			assignScalar( x, y, order === 'row-major' );
 			if ( isnan( y.data[ i%len ] ) ) {
 				b.fail( 'should not return NaN' );
 			}
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.5d_blocked_columnmajor.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.5d_blocked_columnmajor.js
index e2bc2b67d417..7a31199110cf 100644
--- a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.5d_blocked_columnmajor.js
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.5d_blocked_columnmajor.js
@@ -53,10 +53,9 @@ function createBenchmark( len, shape, xtype, ytype ) {
 	var x;
 	var y;
 
-	y = filledarray( 0.0, len, ytype );
 	x = {
 		'dtype': xtype,
-		'data': [ 10.0 ],
+		'data': filledarray( 10.0, 1, xtype ),
 		'shape': [],
 		'strides': [ 0 ],
 		'offset': 0,
@@ -64,7 +63,7 @@ function createBenchmark( len, shape, xtype, ytype ) {
 	};
 	y = {
 		'dtype': ytype,
-		'data': y,
+		'data': filledarray( 0.0, len, ytype ),
 		'shape': shape,
 		'strides': shape2strides( shape, order ),
 		'offset': 0,
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.5d_blocked_rowmajor.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.5d_blocked_rowmajor.js
index 245bd03b5ab7..bcef256b0546 100644
--- a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.5d_blocked_rowmajor.js
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.5d_blocked_rowmajor.js
@@ -53,10 +53,9 @@ function createBenchmark( len, shape, xtype, ytype ) {
 	var x;
 	var y;
 
-	y = filledarray( 0.0, len, ytype );
 	x = {
 		'dtype': xtype,
-		'data': [ 10.0 ],
+		'data': filledarray( 10.0, 1, xtype ),
 		'shape': [],
 		'strides': [ 0 ],
 		'offset': 0,
@@ -64,7 +63,7 @@ function createBenchmark( len, shape, xtype, ytype ) {
 	};
 	y = {
 		'dtype': ytype,
-		'data': y,
+		'data': filledarray( 0.0, len, ytype ),
 		'shape': shape,
 		'strides': shape2strides( shape, order ),
 		'offset': 0,
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.5d_columnmajor.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.5d_columnmajor.js
index 72eb50dc31eb..6f3b2057408e 100644
--- a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.5d_columnmajor.js
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.5d_columnmajor.js
@@ -53,10 +53,9 @@ function createBenchmark( len, shape, xtype, ytype ) {
 	var x;
 	var y;
 
-	y = filledarray( 0.0, len, ytype );
 	x = {
 		'dtype': xtype,
-		'data': [ 10.0 ],
+		'data': filledarray( 10.0, 1, xtype ),
 		'shape': [],
 		'strides': [ 0 ],
 		'offset': 0,
@@ -64,7 +63,7 @@ function createBenchmark( len, shape, xtype, ytype ) {
 	};
 	y = {
 		'dtype': ytype,
-		'data': y,
+		'data': filledarray( 0.0, len, ytype ),
 		'shape': shape,
 		'strides': shape2strides( shape, order ),
 		'offset': 0,
@@ -83,7 +82,7 @@ function createBenchmark( len, shape, xtype, ytype ) {
 
 		b.tic();
 		for ( i = 0; i < b.iterations; i++ ) {
-			assignScalar( x, y );
+			assignScalar( x, y, order === 'row-major' );
 			if ( isnan( y.data[ i%len ] ) ) {
 				b.fail( 'should not return NaN' );
 			}
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.5d_rowmajor.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.5d_rowmajor.js
index e9930c2b6c91..039e1e44ada0 100644
--- a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.5d_rowmajor.js
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.5d_rowmajor.js
@@ -53,10 +53,9 @@ function createBenchmark( len, shape, xtype, ytype ) {
 	var x;
 	var y;
 
-	y = filledarray( 0.0, len, ytype );
 	x = {
 		'dtype': xtype,
-		'data': [ 10.0 ],
+		'data': filledarray( 10.0, 1, xtype ),
 		'shape': [],
 		'strides': [ 0 ],
 		'offset': 0,
@@ -64,7 +63,7 @@ function createBenchmark( len, shape, xtype, ytype ) {
 	};
 	y = {
 		'dtype': ytype,
-		'data': y,
+		'data': filledarray( 0.0, len, ytype ),
 		'shape': shape,
 		'strides': shape2strides( shape, order ),
 		'offset': 0,
@@ -83,7 +82,7 @@ function createBenchmark( len, shape, xtype, ytype ) {
 
 		b.tic();
 		for ( i = 0; i < b.iterations; i++ ) {
-			assignScalar( x, y );
+			assignScalar( x, y, order === 'row-major' );
 			if ( isnan( y.data[ i%len ] ) ) {
 				b.fail( 'should not return NaN' );
 			}
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.6d_blocked_columnmajor.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.6d_blocked_columnmajor.js
index fe15cb8f2344..6962ab41a664 100644
--- a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.6d_blocked_columnmajor.js
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.6d_blocked_columnmajor.js
@@ -53,10 +53,9 @@ function createBenchmark( len, shape, xtype, ytype ) {
 	var x;
 	var y;
 
-	y = filledarray( 0.0, len, ytype );
 	x = {
 		'dtype': xtype,
-		'data': [ 10.0 ],
+		'data': filledarray( 10.0, 1, xtype ),
 		'shape': [],
 		'strides': [ 0 ],
 		'offset': 0,
@@ -64,7 +63,7 @@ function createBenchmark( len, shape, xtype, ytype ) {
 	};
 	y = {
 		'dtype': ytype,
-		'data': y,
+		'data': filledarray( 0.0, len, ytype ),
 		'shape': shape,
 		'strides': shape2strides( shape, order ),
 		'offset': 0,
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.6d_blocked_rowmajor.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.6d_blocked_rowmajor.js
index b9634cdda249..c735e8452255 100644
--- a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.6d_blocked_rowmajor.js
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.6d_blocked_rowmajor.js
@@ -53,10 +53,9 @@ function createBenchmark( len, shape, xtype, ytype ) {
 	var x;
 	var y;
 
-	y = filledarray( 0.0, len, ytype );
 	x = {
 		'dtype': xtype,
-		'data': [ 10.0 ],
+		'data': filledarray( 10.0, 1, xtype ),
 		'shape': [],
 		'strides': [ 0 ],
 		'offset': 0,
@@ -64,7 +63,7 @@ function createBenchmark( len, shape, xtype, ytype ) {
 	};
 	y = {
 		'dtype': ytype,
-		'data': y,
+		'data': filledarray( 0.0, len, ytype ),
 		'shape': shape,
 		'strides': shape2strides( shape, order ),
 		'offset': 0,
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.6d_columnmajor.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.6d_columnmajor.js
index d033f6e17738..384971fa75c7 100644
--- a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.6d_columnmajor.js
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.6d_columnmajor.js
@@ -53,10 +53,9 @@ function createBenchmark( len, shape, xtype, ytype ) {
 	var x;
 	var y;
 
-	y = filledarray( 0.0, len, ytype );
 	x = {
 		'dtype': xtype,
-		'data': [ 10.0 ],
+		'data': filledarray( 10.0, 1, xtype ),
 		'shape': [],
 		'strides': [ 0 ],
 		'offset': 0,
@@ -64,7 +63,7 @@ function createBenchmark( len, shape, xtype, ytype ) {
 	};
 	y = {
 		'dtype': ytype,
-		'data': y,
+		'data': filledarray( 0.0, len, ytype ),
 		'shape': shape,
 		'strides': shape2strides( shape, order ),
 		'offset': 0,
@@ -83,7 +82,7 @@ function createBenchmark( len, shape, xtype, ytype ) {
 
 		b.tic();
 		for ( i = 0; i < b.iterations; i++ ) {
-			assignScalar( x, y );
+			assignScalar( x, y, order === 'row-major' );
 			if ( isnan( y.data[ i%len ] ) ) {
 				b.fail( 'should not return NaN' );
 			}
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.6d_rowmajor.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.6d_rowmajor.js
index 75089b10fb9b..45bee2fdba5a 100644
--- a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.6d_rowmajor.js
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.6d_rowmajor.js
@@ -53,10 +53,9 @@ function createBenchmark( len, shape, xtype, ytype ) {
 	var x;
 	var y;
 
-	y = filledarray( 0.0, len, ytype );
 	x = {
 		'dtype': xtype,
-		'data': [ 10.0 ],
+		'data': filledarray( 10.0, 1, xtype ),
 		'shape': [],
 		'strides': [ 0 ],
 		'offset': 0,
@@ -64,7 +63,7 @@ function createBenchmark( len, shape, xtype, ytype ) {
 	};
 	y = {
 		'dtype': ytype,
-		'data': y,
+		'data': filledarray( 0.0, len, ytype ),
 		'shape': shape,
 		'strides': shape2strides( shape, order ),
 		'offset': 0,
@@ -83,7 +82,7 @@ function createBenchmark( len, shape, xtype, ytype ) {
 
 		b.tic();
 		for ( i = 0; i < b.iterations; i++ ) {
-			assignScalar( x, y );
+			assignScalar( x, y, order === 'row-major' );
 			if ( isnan( y.data[ i%len ] ) ) {
 				b.fail( 'should not return NaN' );
 			}
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.7d_blocked_columnmajor.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.7d_blocked_columnmajor.js
index 6698447da16c..b0985bdd89c5 100644
--- a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.7d_blocked_columnmajor.js
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.7d_blocked_columnmajor.js
@@ -53,10 +53,9 @@ function createBenchmark( len, shape, xtype, ytype ) {
 	var x;
 	var y;
 
-	y = filledarray( 0.0, len, ytype );
 	x = {
 		'dtype': xtype,
-		'data': [ 10.0 ],
+		'data': filledarray( 10.0, 1, xtype ),
 		'shape': [],
 		'strides': [ 0 ],
 		'offset': 0,
@@ -64,7 +63,7 @@ function createBenchmark( len, shape, xtype, ytype ) {
 	};
 	y = {
 		'dtype': ytype,
-		'data': y,
+		'data': filledarray( 0.0, len, ytype ),
 		'shape': shape,
 		'strides': shape2strides( shape, order ),
 		'offset': 0,
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.7d_blocked_rowmajor.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.7d_blocked_rowmajor.js
index 43b1b64a9ac8..f4a72a3f4efc 100644
--- a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.7d_blocked_rowmajor.js
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.7d_blocked_rowmajor.js
@@ -53,10 +53,9 @@ function createBenchmark( len, shape, xtype, ytype ) {
 	var x;
 	var y;
 
-	y = filledarray( 0.0, len, ytype );
 	x = {
 		'dtype': xtype,
-		'data': [ 10.0 ],
+		'data': filledarray( 10.0, 1, xtype ),
 		'shape': [],
 		'strides': [ 0 ],
 		'offset': 0,
@@ -64,7 +63,7 @@ function createBenchmark( len, shape, xtype, ytype ) {
 	};
 	y = {
 		'dtype': ytype,
-		'data': y,
+		'data': filledarray( 0.0, len, ytype ),
 		'shape': shape,
 		'strides': shape2strides( shape, order ),
 		'offset': 0,
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.7d_columnmajor.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.7d_columnmajor.js
index f8f436a00a43..e593c254545c 100644
--- a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.7d_columnmajor.js
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.7d_columnmajor.js
@@ -53,10 +53,9 @@ function createBenchmark( len, shape, xtype, ytype ) {
 	var x;
 	var y;
 
-	y = filledarray( 0.0, len, ytype );
 	x = {
 		'dtype': xtype,
-		'data': [ 10.0 ],
+		'data': filledarray( 10.0, 1, xtype ),
 		'shape': [],
 		'strides': [ 0 ],
 		'offset': 0,
@@ -64,7 +63,7 @@ function createBenchmark( len, shape, xtype, ytype ) {
 	};
 	y = {
 		'dtype': ytype,
-		'data': y,
+		'data': filledarray( 0.0, len, ytype ),
 		'shape': shape,
 		'strides': shape2strides( shape, order ),
 		'offset': 0,
@@ -83,7 +82,7 @@ function createBenchmark( len, shape, xtype, ytype ) {
 
 		b.tic();
 		for ( i = 0; i < b.iterations; i++ ) {
-			assignScalar( x, y );
+			assignScalar( x, y, order === 'row-major' );
 			if ( isnan( y.data[ i%len ] ) ) {
 				b.fail( 'should not return NaN' );
 			}
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.7d_rowmajor.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.7d_rowmajor.js
index c0d030f03862..caa7ee87c9d9 100644
--- a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.7d_rowmajor.js
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.7d_rowmajor.js
@@ -53,10 +53,9 @@ function createBenchmark( len, shape, xtype, ytype ) {
 	var x;
 	var y;
 
-	y = filledarray( 0.0, len, ytype );
 	x = {
 		'dtype': xtype,
-		'data': [ 10.0 ],
+		'data': filledarray( 10.0, 1, xtype ),
 		'shape': [],
 		'strides': [ 0 ],
 		'offset': 0,
@@ -64,7 +63,7 @@ function createBenchmark( len, shape, xtype, ytype ) {
 	};
 	y = {
 		'dtype': ytype,
-		'data': y,
+		'data': filledarray( 0.0, len, ytype ),
 		'shape': shape,
 		'strides': shape2strides( shape, order ),
 		'offset': 0,
@@ -83,7 +82,7 @@ function createBenchmark( len, shape, xtype, ytype ) {
 
 		b.tic();
 		for ( i = 0; i < b.iterations; i++ ) {
-			assignScalar( x, y );
+			assignScalar( x, y, order === 'row-major' );
 			if ( isnan( y.data[ i%len ] ) ) {
 				b.fail( 'should not return NaN' );
 			}
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.8d_blocked_columnmajor.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.8d_blocked_columnmajor.js
index 23b43dda0d1b..f7cb601c30bd 100644
--- a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.8d_blocked_columnmajor.js
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.8d_blocked_columnmajor.js
@@ -53,10 +53,9 @@ function createBenchmark( len, shape, xtype, ytype ) {
 	var x;
 	var y;
 
-	y = filledarray( 0.0, len, ytype );
 	x = {
 		'dtype': xtype,
-		'data': [ 10.0 ],
+		'data': filledarray( 10.0, 1, xtype ),
 		'shape': [],
 		'strides': [ 0 ],
 		'offset': 0,
@@ -64,7 +63,7 @@ function createBenchmark( len, shape, xtype, ytype ) {
 	};
 	y = {
 		'dtype': ytype,
-		'data': y,
+		'data': filledarray( 0.0, len, ytype ),
 		'shape': shape,
 		'strides': shape2strides( shape, order ),
 		'offset': 0,
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.8d_blocked_rowmajor.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.8d_blocked_rowmajor.js
index 0d01971bb9e9..a31b2df2d28d 100644
--- a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.8d_blocked_rowmajor.js
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.8d_blocked_rowmajor.js
@@ -53,10 +53,9 @@ function createBenchmark( len, shape, xtype, ytype ) {
 	var x;
 	var y;
 
-	y = filledarray( 0.0, len, ytype );
 	x = {
 		'dtype': xtype,
-		'data': [ 10.0 ],
+		'data': filledarray( 10.0, 1, xtype ),
 		'shape': [],
 		'strides': [ 0 ],
 		'offset': 0,
@@ -64,7 +63,7 @@ function createBenchmark( len, shape, xtype, ytype ) {
 	};
 	y = {
 		'dtype': ytype,
-		'data': y,
+		'data': filledarray( 0.0, len, ytype ),
 		'shape': shape,
 		'strides': shape2strides( shape, order ),
 		'offset': 0,
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.8d_columnmajor.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.8d_columnmajor.js
index b47fc11fb084..7ecf76dc1db5 100644
--- a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.8d_columnmajor.js
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.8d_columnmajor.js
@@ -53,10 +53,9 @@ function createBenchmark( len, shape, xtype, ytype ) {
 	var x;
 	var y;
 
-	y = filledarray( 0.0, len, ytype );
 	x = {
 		'dtype': xtype,
-		'data': [ 10.0 ],
+		'data': filledarray( 10.0, 1, xtype ),
 		'shape': [],
 		'strides': [ 0 ],
 		'offset': 0,
@@ -64,7 +63,7 @@ function createBenchmark( len, shape, xtype, ytype ) {
 	};
 	y = {
 		'dtype': ytype,
-		'data': y,
+		'data': filledarray( 0.0, len, ytype ),
 		'shape': shape,
 		'strides': shape2strides( shape, order ),
 		'offset': 0,
@@ -83,7 +82,7 @@ function createBenchmark( len, shape, xtype, ytype ) {
 
 		b.tic();
 		for ( i = 0; i < b.iterations; i++ ) {
-			assignScalar( x, y );
+			assignScalar( x, y, order === 'row-major' );
 			if ( isnan( y.data[ i%len ] ) ) {
 				b.fail( 'should not return NaN' );
 			}
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.8d_rowmajor.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.8d_rowmajor.js
index 62acf986a619..2d48bd5448d1 100644
--- a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.8d_rowmajor.js
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.8d_rowmajor.js
@@ -53,10 +53,9 @@ function createBenchmark( len, shape, xtype, ytype ) {
 	var x;
 	var y;
 
-	y = filledarray( 0.0, len, ytype );
 	x = {
 		'dtype': xtype,
-		'data': [ 10.0 ],
+		'data': filledarray( 10.0, 1, xtype ),
 		'shape': [],
 		'strides': [ 0 ],
 		'offset': 0,
@@ -64,7 +63,7 @@ function createBenchmark( len, shape, xtype, ytype ) {
 	};
 	y = {
 		'dtype': ytype,
-		'data': y,
+		'data': filledarray( 0.0, len, ytype ),
 		'shape': shape,
 		'strides': shape2strides( shape, order ),
 		'offset': 0,
@@ -83,7 +82,7 @@ function createBenchmark( len, shape, xtype, ytype ) {
 
 		b.tic();
 		for ( i = 0; i < b.iterations; i++ ) {
-			assignScalar( x, y );
+			assignScalar( x, y, order === 'row-major' );
 			if ( isnan( y.data[ i%len ] ) ) {
 				b.fail( 'should not return NaN' );
 			}
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.9d_blocked_columnmajor.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.9d_blocked_columnmajor.js
index 2d805c5d63f1..644e124cbfe9 100644
--- a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.9d_blocked_columnmajor.js
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.9d_blocked_columnmajor.js
@@ -53,10 +53,9 @@ function createBenchmark( len, shape, xtype, ytype ) {
 	var x;
 	var y;
 
-	y = filledarray( 0.0, len, ytype );
 	x = {
 		'dtype': xtype,
-		'data': [ 10.0 ],
+		'data': filledarray( 10.0, 1, xtype ),
 		'shape': [],
 		'strides': [ 0 ],
 		'offset': 0,
@@ -64,7 +63,7 @@ function createBenchmark( len, shape, xtype, ytype ) {
 	};
 	y = {
 		'dtype': ytype,
-		'data': y,
+		'data': filledarray( 0.0, len, ytype ),
 		'shape': shape,
 		'strides': shape2strides( shape, order ),
 		'offset': 0,
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.9d_blocked_rowmajor.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.9d_blocked_rowmajor.js
index 5f669af6ac67..7a97230368ad 100644
--- a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.9d_blocked_rowmajor.js
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.9d_blocked_rowmajor.js
@@ -53,10 +53,9 @@ function createBenchmark( len, shape, xtype, ytype ) {
 	var x;
 	var y;
 
-	y = filledarray( 0.0, len, ytype );
 	x = {
 		'dtype': xtype,
-		'data': [ 10.0 ],
+		'data': filledarray( 10.0, 1, xtype ),
 		'shape': [],
 		'strides': [ 0 ],
 		'offset': 0,
@@ -64,7 +63,7 @@ function createBenchmark( len, shape, xtype, ytype ) {
 	};
 	y = {
 		'dtype': ytype,
-		'data': y,
+		'data': filledarray( 0.0, len, ytype ),
 		'shape': shape,
 		'strides': shape2strides( shape, order ),
 		'offset': 0,
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.9d_columnmajor.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.9d_columnmajor.js
index 970f547d70d4..47615def1e2a 100644
--- a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.9d_columnmajor.js
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.9d_columnmajor.js
@@ -53,10 +53,9 @@ function createBenchmark( len, shape, xtype, ytype ) {
 	var x;
 	var y;
 
-	y = filledarray( 0.0, len, ytype );
 	x = {
 		'dtype': xtype,
-		'data': [ 10.0 ],
+		'data': filledarray( 10.0, 1, xtype ),
 		'shape': [],
 		'strides': [ 0 ],
 		'offset': 0,
@@ -64,7 +63,7 @@ function createBenchmark( len, shape, xtype, ytype ) {
 	};
 	y = {
 		'dtype': ytype,
-		'data': y,
+		'data': filledarray( 0.0, len, ytype ),
 		'shape': shape,
 		'strides': shape2strides( shape, order ),
 		'offset': 0,
@@ -83,7 +82,7 @@ function createBenchmark( len, shape, xtype, ytype ) {
 
 		b.tic();
 		for ( i = 0; i < b.iterations; i++ ) {
-			assignScalar( x, y );
+			assignScalar( x, y, order === 'row-major' );
 			if ( isnan( y.data[ i%len ] ) ) {
 				b.fail( 'should not return NaN' );
 			}
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.9d_rowmajor.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.9d_rowmajor.js
index 601a4321f97d..24eb12c4781c 100644
--- a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.9d_rowmajor.js
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/benchmark/benchmark.9d_rowmajor.js
@@ -53,10 +53,9 @@ function createBenchmark( len, shape, xtype, ytype ) {
 	var x;
 	var y;
 
-	y = filledarray( 0.0, len, ytype );
 	x = {
 		'dtype': xtype,
-		'data': [ 10.0 ],
+		'data': filledarray( 10.0, 1, xtype ),
 		'shape': [],
 		'strides': [ 0 ],
 		'offset': 0,
@@ -64,7 +63,7 @@ function createBenchmark( len, shape, xtype, ytype ) {
 	};
 	y = {
 		'dtype': ytype,
-		'data': y,
+		'data': filledarray( 0.0, len, ytype ),
 		'shape': shape,
 		'strides': shape2strides( shape, order ),
 		'offset': 0,
@@ -83,7 +82,7 @@ function createBenchmark( len, shape, xtype, ytype ) {
 
 		b.tic();
 		for ( i = 0; i < b.iterations; i++ ) {
-			assignScalar( x, y );
+			assignScalar( x, y, order === 'row-major' );
 			if ( isnan( y.data[ i%len ] ) ) {
 				b.fail( 'should not return NaN' );
 			}

From 15e574204ce1ec48b59631cb01c546c9e7b9f9c9 Mon Sep 17 00:00:00 2001
From: Athan <kgryte@gmail.com>
Date: Sat, 21 Mar 2026 18:19:29 -0700
Subject: [PATCH 03/20] docs: update copy and examples

---
type: pre_commit_static_analysis_report
description: Results of running static analysis checks when committing changes.
report:
  - task: lint_filenames
    status: passed
  - task: lint_editorconfig
    status: passed
  - task: lint_markdown
    status: na
  - task: lint_package_json
    status: na
  - task: lint_repl_help
    status: passed
  - task: lint_javascript_src
    status: na
  - task: lint_javascript_cli
    status: na
  - task: lint_javascript_examples
    status: na
  - task: lint_javascript_tests
    status: na
  - task: lint_javascript_benchmarks
    status: na
  - task: lint_python
    status: na
  - task: lint_r
    status: na
  - task: lint_c_src
    status: na
  - task: lint_c_examples
    status: na
  - task: lint_c_benchmarks
    status: na
  - task: lint_c_tests_fixtures
    status: na
  - task: lint_shell
    status: na
  - task: lint_typescript_declarations
    status: passed
  - task: lint_typescript_tests
    status: passed
  - task: lint_license_headers
    status: passed
---
---
 .../@stdlib/ndarray/base/assign-scalar/docs/repl.txt     | 9 +++++----
 .../ndarray/base/assign-scalar/docs/types/index.d.ts     | 2 +-
 2 files changed, 6 insertions(+), 5 deletions(-)

diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/docs/repl.txt b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/docs/repl.txt
index dcc976bea72e..9ba16849b7c0 100644
--- a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/docs/repl.txt
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/docs/repl.txt
@@ -15,8 +15,8 @@
     Parameters
     ----------
     arrays: ArrayLikeObject<ndarray>
-        Array-like object containing a zero-dimensional input ndarray and one
-        output ndarray.
+        Array-like object containing a zero-dimensional input ndarray containing
+        the scalar value and one output ndarray.
 
     Examples
     --------
@@ -33,8 +33,8 @@
     > var x = {{alias:@stdlib/ndarray/from-scalar}}( 5.0, { 'dtype': dtype } );
     > var y = {{alias:@stdlib/ndarray/ctor}}( dtype, ybuf, shape, sy, oy, order );
     > {{alias}}( [ x, y ] );
-    > y.data
-    <Float64Array>[ 5.0, 5.0, 5.0, 5.0 ]
+    > y
+    <ndarray>[ [ 5.0, 5.0 ], [ 5.0, 5.0 ] ]
 
     // Using minimal ndarray-like objects...
     > x = {
@@ -45,6 +45,7 @@
     ...     'offset': 0,
     ...     'order': order
     ... };
+    > ybuf = new {{alias:@stdlib/array/float64}}( [ 0.0, 0.0, 0.0, 0.0 ] );
     > y = {
     ...     'dtype': dtype,
     ...     'data': ybuf,
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/docs/types/index.d.ts b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/docs/types/index.d.ts
index 1c2e2ead1c68..2ad8f6eaaab8 100644
--- a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/docs/types/index.d.ts
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/docs/types/index.d.ts
@@ -26,7 +26,7 @@ import { ndarray } from '@stdlib/types/ndarray';
 /**
 * Assigns a scalar value to every element of an output ndarray.
 *
-* @param arrays - array-like object containing a zero-dimensional input ndarray and one output ndarray
+* @param arrays - array-like object containing a zero-dimensional input ndarray containing the scalar value and one output ndarray
 *
 * @example
 * var Float64Array = require( '@stdlib/array/float64' );

From 576d7c245383efae3f11ae5cf3d62c5b283d6502 Mon Sep 17 00:00:00 2001
From: Athan <kgryte@gmail.com>
Date: Sat, 21 Mar 2026 18:20:13 -0700
Subject: [PATCH 04/20] docs: remove notes

---
type: pre_commit_static_analysis_report
description: Results of running static analysis checks when committing changes.
report:
  - task: lint_filenames
    status: passed
  - task: lint_editorconfig
    status: passed
  - task: lint_markdown
    status: passed
  - task: lint_package_json
    status: na
  - task: lint_repl_help
    status: na
  - task: lint_javascript_src
    status: na
  - task: lint_javascript_cli
    status: na
  - task: lint_javascript_examples
    status: na
  - task: lint_javascript_tests
    status: na
  - task: lint_javascript_benchmarks
    status: na
  - task: lint_python
    status: na
  - task: lint_r
    status: na
  - task: lint_c_src
    status: na
  - task: lint_c_examples
    status: na
  - task: lint_c_benchmarks
    status: na
  - task: lint_c_tests_fixtures
    status: na
  - task: lint_shell
    status: na
  - task: lint_typescript_declarations
    status: passed
  - task: lint_typescript_tests
    status: na
  - task: lint_license_headers
    status: passed
---
---
 lib/node_modules/@stdlib/ndarray/base/assign-scalar/README.md | 4 ----
 1 file changed, 4 deletions(-)

diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/README.md b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/README.md
index 295998b725f6..940564353b6e 100644
--- a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/README.md
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/README.md
@@ -99,10 +99,6 @@ Each provided [ndarray][@stdlib/ndarray/base/ctor] should be an object with the
 
 <section class="notes">
 
-## Notes
-
--   For very high-dimensional ndarrays which are non-contiguous, one should consider copying the underlying data to contiguous memory before performing the operation in order to achieve better performance.
-
 </section>
 
 <!-- /.notes -->

From 89dd0ff809d9e5e9d258a7b130a6629cc6c09a37 Mon Sep 17 00:00:00 2001
From: Athan <kgryte@gmail.com>
Date: Sat, 21 Mar 2026 18:20:35 -0700
Subject: [PATCH 05/20] fix: fix missing arguments and add initial complex
 ndarray kernels

---
type: pre_commit_static_analysis_report
description: Results of running static analysis checks when committing changes.
report:
  - task: lint_filenames
    status: passed
  - task: lint_editorconfig
    status: passed
  - task: lint_markdown
    status: na
  - task: lint_package_json
    status: na
  - task: lint_repl_help
    status: na
  - task: lint_javascript_src
    status: passed
  - task: lint_javascript_cli
    status: na
  - task: lint_javascript_examples
    status: na
  - task: lint_javascript_tests
    status: na
  - task: lint_javascript_benchmarks
    status: na
  - task: lint_python
    status: na
  - task: lint_r
    status: na
  - task: lint_c_src
    status: na
  - task: lint_c_examples
    status: na
  - task: lint_c_benchmarks
    status: na
  - task: lint_c_tests_fixtures
    status: na
  - task: lint_shell
    status: na
  - task: lint_typescript_declarations
    status: passed
  - task: lint_typescript_tests
    status: na
  - task: lint_license_headers
    status: passed
---
---
 .../ndarray/base/assign-scalar/lib/0d.js      |   8 +-
 .../base/assign-scalar/lib/0d_accessors.js    |  10 +-
 .../base/assign-scalar/lib/0d_complex.js      |  77 +++++++++
 .../ndarray/base/assign-scalar/lib/10d.js     |  22 +--
 .../base/assign-scalar/lib/10d_accessors.js   |  36 ++---
 .../base/assign-scalar/lib/10d_blocked.js     |  14 +-
 .../lib/10d_blocked_accessors.js              |  28 ++--
 .../ndarray/base/assign-scalar/lib/1d.js      |  14 +-
 .../base/assign-scalar/lib/1d_accessors.js    |  28 ++--
 .../assign-scalar/lib/2d_blocked_complex.js   | 152 ++++++++++++++++++
 .../base/assign-scalar/lib/2d_complex.js      | 120 ++++++++++++++
 .../ndarray/base/assign-scalar/lib/main.js    | 110 ++++++++++++-
 12 files changed, 513 insertions(+), 106 deletions(-)
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/0d_complex.js
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/2d_blocked_complex.js
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/2d_complex.js

diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/0d.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/0d.js
index 3a29b924a8ef..ba86644d5c71 100644
--- a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/0d.js
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/0d.js
@@ -47,12 +47,12 @@
 * var xbuf = new Float64Array( [ 2.0 ] );
 * var ybuf = new Float64Array( 1 );
 *
-* // Define the shape of the output array:
-* var shape = [ 3, 1, 2 ];
+* // Define the shape of the input and output arrays:
+* var shape = [];
 *
 * // Define the array strides:
 * var sx = [ 0 ];
-* var sy = [ 2, 2, 1 ];
+* var sy = [ 0 ];
 *
 * // Define the index offsets:
 * var ox = 0;
@@ -62,7 +62,7 @@
 * var x = {
 *     'dtype': 'float64',
 *     'data': xbuf,
-*     'shape': [],
+*     'shape': shape,
 *     'strides': sx,
 *     'offset': ox,
 *     'order': 'row-major'
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/0d_accessors.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/0d_accessors.js
index b2fc5b680a24..9fca8ef22a32 100644
--- a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/0d_accessors.js
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/0d_accessors.js
@@ -44,9 +44,6 @@
 *
 * @example
 * var Complex64Array = require( '@stdlib/array/complex64' );
-* var Complex64 = require( '@stdlib/complex/float32/ctor' );
-* var realf = require( '@stdlib/complex/float32/real' );
-* var imagf = require( '@stdlib/complex/float32/imag' );
 *
 * // Create data buffers:
 * var xbuf = new Complex64Array( [ 3.0, 4.0 ] );
@@ -96,12 +93,7 @@
 * assign0d( x, y );
 *
 * var v = y.data.get( 0 );
-*
-* var re = realf( v );
-* // returns 3.0
-*
-* var im = imagf( v );
-* // returns 4.0
+* // returns <Complex64>[ 3.0, 4.0 ]
 */
 function assign0d( x, y ) {
 	y.accessors[ 1 ]( y.data, y.offset, x.accessors[ 0 ]( x.data, x.offset ) );
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/0d_complex.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/0d_complex.js
new file mode 100644
index 000000000000..fa879a21efab
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/0d_complex.js
@@ -0,0 +1,77 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2026 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';
+
+// MAIN //
+
+/**
+* Assigns a scalar value to every element of a reinterpreted complex number zero-dimensional output ndarray.
+*
+* @private
+* @param {number} re - real component
+* @param {number} im - imaginary component
+* @param {Object} y - object containing output ndarray meta data
+* @param {*} y.dtype - data type
+* @param {Collection} y.data - data buffer
+* @param {NonNegativeIntegerArray} y.shape - dimensions
+* @param {IntegerArray} y.strides - stride lengths
+* @param {NonNegativeInteger} y.offset - index offset
+* @param {string} y.order - specifies whether `y` is row-major (C-style) or column-major (Fortran-style)
+* @returns {void}
+*
+* @example
+* var Float64Array = require( '@stdlib/array/float64' );
+*
+* // Create a data buffer:
+* var ybuf = new Float64Array( 2 );
+*
+* // Define the shape of the output array:
+* var shape = [];
+*
+* // Define the array strides:
+* var sy = [ 0 ];
+*
+* // Define the index offset:
+* var oy = 0;
+*
+* // Create the output ndarray-like object:
+* var y = {
+*     'dtype': 'float64',
+*     'data': ybuf,
+*     'shape': shape,
+*     'strides': sy,
+*     'offset': oy,
+*     'order': 'row-major'
+* };
+*
+* // Assign scalar:
+* assign0d( 2.0, 2.0, y );
+*
+* console.log( y.data );
+* // => <Float64Array>[ 2.0, 2.0 ]
+*/
+function assign0d( re, im, y ) {
+	y.data[ y.offset ] = re;
+	y.data[ y.offset+1 ] = im;
+}
+
+
+// EXPORTS //
+
+module.exports = assign0d;
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/10d.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/10d.js
index a405b0543d3b..eadeaef8b659 100644
--- a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/10d.js
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/10d.js
@@ -86,7 +86,6 @@
 * // => <Float64Array>[ 2.0, 2.0, 2.0, 2.0, 2.0, 2.0 ]
 */
 function assign10d( x, y, isRowMajor ) {
-	var xbuf;
 	var ybuf;
 	var dy0;
 	var dy1;
@@ -110,7 +109,6 @@ function assign10d( x, y, isRowMajor ) {
 	var S8;
 	var S9;
 	var sy;
-	var ix;
 	var iy;
 	var i0;
 	var i1;
@@ -122,6 +120,7 @@ function assign10d( x, y, isRowMajor ) {
 	var i7;
 	var i8;
 	var i9;
+	var v;
 
 	// Note on variable naming convention: S#, dy#, i# where # corresponds to the loop number, with `0` being the innermost loop...
 
@@ -140,7 +139,7 @@ function assign10d( x, y, isRowMajor ) {
 		S7 = sh[ 2 ];
 		S8 = sh[ 1 ];
 		S9 = sh[ 0 ];
-		dy0 = sy[ 9 ];
+		dy0 = sy[ 9 ];                // offset increment for innermost loop
 		dy1 = sy[ 8 ] - ( S0*sy[9] );
 		dy2 = sy[ 7 ] - ( S1*sy[8] );
 		dy3 = sy[ 6 ] - ( S2*sy[7] );
@@ -149,7 +148,7 @@ function assign10d( x, y, isRowMajor ) {
 		dy6 = sy[ 3 ] - ( S5*sy[4] );
 		dy7 = sy[ 2 ] - ( S6*sy[3] );
 		dy8 = sy[ 1 ] - ( S7*sy[2] );
-		dy9 = sy[ 0 ] - ( S8*sy[1] );
+		dy9 = sy[ 0 ] - ( S8*sy[1] ); // offset increment for outermost loop
 	} else { // order === 'column-major'
 		// For column-major ndarrays, the first dimensions have the fastest changing indices...
 		S0 = sh[ 0 ];
@@ -162,7 +161,7 @@ function assign10d( x, y, isRowMajor ) {
 		S7 = sh[ 7 ];
 		S8 = sh[ 8 ];
 		S9 = sh[ 9 ];
-		dy0 = sy[ 0 ];
+		dy0 = sy[ 0 ];                // offset increment for innermost loop
 		dy1 = sy[ 1 ] - ( S0*sy[0] );
 		dy2 = sy[ 2 ] - ( S1*sy[1] );
 		dy3 = sy[ 3 ] - ( S2*sy[2] );
@@ -171,16 +170,17 @@ function assign10d( x, y, isRowMajor ) {
 		dy6 = sy[ 6 ] - ( S5*sy[5] );
 		dy7 = sy[ 7 ] - ( S6*sy[6] );
 		dy8 = sy[ 8 ] - ( S7*sy[7] );
-		dy9 = sy[ 9 ] - ( S8*sy[8] );
+		dy9 = sy[ 9 ] - ( S8*sy[8] ); // offset increment for outermost loop
 	}
-	// Set the pointers to the first indexed elements in the respective ndarrays...
-	ix = x.offset;
+	// Set a pointer to the first indexed element in the output ndarray:
 	iy = y.offset;
 
-	// Cache references to the input and output ndarray buffers...
-	xbuf = x.data;
+	// Cache a reference to the output ndarray buffer:
 	ybuf = y.data;
 
+	// Cache the scalar value:
+	v = x.data[ x.offset ];
+
 	// Iterate over the ndarray dimensions...
 	for ( i9 = 0; i9 < S9; i9++ ) {
 		for ( i8 = 0; i8 < S8; i8++ ) {
@@ -192,7 +192,7 @@ function assign10d( x, y, isRowMajor ) {
 								for ( i2 = 0; i2 < S2; i2++ ) {
 									for ( i1 = 0; i1 < S1; i1++ ) {
 										for ( i0 = 0; i0 < S0; i0++ ) {
-											ybuf[ iy ] = xbuf[ ix ];
+											ybuf[ iy ] = v;
 											iy += dy0;
 										}
 										iy += dy1;
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/10d_accessors.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/10d_accessors.js
index 08c0b2b8fd23..c82c788b7923 100644
--- a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/10d_accessors.js
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/10d_accessors.js
@@ -47,9 +47,6 @@
 *
 * @example
 * var Complex64Array = require( '@stdlib/array/complex64' );
-* var Complex64 = require( '@stdlib/complex/float32/ctor' );
-* var realf = require( '@stdlib/complex/float32/real' );
-* var imagf = require( '@stdlib/complex/float32/imag' );
 *
 * // Create data buffers:
 * var xbuf = new Complex64Array( [ 2.0, 2.0 ] );
@@ -99,17 +96,10 @@
 * assign10d( x, y, true );
 *
 * var v = y.data.get( 0 );
-*
-* var re = realf( v );
-* // returns 2.0
-*
-* var im = imagf( v );
-* // returns 2.0
+* // returns <Complex64>[ 2.0, 2.0 ]
 */
 function assign10d( x, y, isRowMajor ) {
-	var xbuf;
 	var ybuf;
-	var get;
 	var set;
 	var dy0;
 	var dy1;
@@ -133,7 +123,6 @@ function assign10d( x, y, isRowMajor ) {
 	var S8;
 	var S9;
 	var sy;
-	var ix;
 	var iy;
 	var i0;
 	var i1;
@@ -145,6 +134,7 @@ function assign10d( x, y, isRowMajor ) {
 	var i7;
 	var i8;
 	var i9;
+	var v;
 
 	// Note on variable naming convention: S#, dy#, i# where # corresponds to the loop number, with `0` being the innermost loop...
 
@@ -163,7 +153,7 @@ function assign10d( x, y, isRowMajor ) {
 		S7 = sh[ 2 ];
 		S8 = sh[ 1 ];
 		S9 = sh[ 0 ];
-		dy0 = sy[ 9 ];
+		dy0 = sy[ 9 ];                // offset increment for innermost loop
 		dy1 = sy[ 8 ] - ( S0*sy[9] );
 		dy2 = sy[ 7 ] - ( S1*sy[8] );
 		dy3 = sy[ 6 ] - ( S2*sy[7] );
@@ -172,7 +162,7 @@ function assign10d( x, y, isRowMajor ) {
 		dy6 = sy[ 3 ] - ( S5*sy[4] );
 		dy7 = sy[ 2 ] - ( S6*sy[3] );
 		dy8 = sy[ 1 ] - ( S7*sy[2] );
-		dy9 = sy[ 0 ] - ( S8*sy[1] );
+		dy9 = sy[ 0 ] - ( S8*sy[1] ); // offset increment for outermost loop
 	} else { // order === 'column-major'
 		// For column-major ndarrays, the first dimensions have the fastest changing indices...
 		S0 = sh[ 0 ];
@@ -185,7 +175,7 @@ function assign10d( x, y, isRowMajor ) {
 		S7 = sh[ 7 ];
 		S8 = sh[ 8 ];
 		S9 = sh[ 9 ];
-		dy0 = sy[ 0 ];
+		dy0 = sy[ 0 ];                // offset increment for innermost loop
 		dy1 = sy[ 1 ] - ( S0*sy[0] );
 		dy2 = sy[ 2 ] - ( S1*sy[1] );
 		dy3 = sy[ 3 ] - ( S2*sy[2] );
@@ -194,20 +184,20 @@ function assign10d( x, y, isRowMajor ) {
 		dy6 = sy[ 6 ] - ( S5*sy[5] );
 		dy7 = sy[ 7 ] - ( S6*sy[6] );
 		dy8 = sy[ 8 ] - ( S7*sy[7] );
-		dy9 = sy[ 9 ] - ( S8*sy[8] );
+		dy9 = sy[ 9 ] - ( S8*sy[8] ); // offset increment for outermost loop
 	}
-	// Set the pointers to the first indexed elements in the respective ndarrays...
-	ix = x.offset;
+	// Set a pointer to the first indexed element in the output ndarray:
 	iy = y.offset;
 
-	// Cache references to the input and output ndarray buffers...
-	xbuf = x.data;
+	// Cache a reference to the output ndarray buffer:
 	ybuf = y.data;
 
-	// Cache accessors:
-	get = x.accessors[0];
+	// Cache the output ndarray accessor:
 	set = y.accessors[1];
 
+	// Cache the scalar value:
+	v = x.accessors[0]( x.data, x.offset );
+
 	// Iterate over the ndarray dimensions...
 	for ( i9 = 0; i9 < S9; i9++ ) {
 		for ( i8 = 0; i8 < S8; i8++ ) {
@@ -219,7 +209,7 @@ function assign10d( x, y, isRowMajor ) {
 								for ( i2 = 0; i2 < S2; i2++ ) {
 									for ( i1 = 0; i1 < S1; i1++ ) {
 										for ( i0 = 0; i0 < S0; i0++ ) {
-											set( ybuf, iy, get( xbuf, ix ) );
+											set( ybuf, iy, v );
 											iy += dy0;
 										}
 										iy += dy1;
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/10d_blocked.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/10d_blocked.js
index 762cf1dbf04b..a3b8860c0980 100644
--- a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/10d_blocked.js
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/10d_blocked.js
@@ -92,7 +92,6 @@ var blockSize = require( '@stdlib/ndarray/base/nullary-tiling-block-size' );
 */
 function blockedassign10d( x, y ) { // eslint-disable-line max-statements, max-lines-per-function
 	var bsize;
-	var xbuf;
 	var ybuf;
 	var dy0;
 	var dy1;
@@ -126,7 +125,6 @@ function blockedassign10d( x, y ) { // eslint-disable-line max-statements, max-l
 	var s9;
 	var sy;
 	var oy;
-	var ix;
 	var iy;
 	var i0;
 	var i1;
@@ -149,6 +147,7 @@ function blockedassign10d( x, y ) { // eslint-disable-line max-statements, max-l
 	var j8;
 	var j9;
 	var o;
+	var v;
 
 	// Note on variable naming convention: s#, dy#, i#, j# where # corresponds to the loop number, with `0` being the innermost loop...
 
@@ -160,17 +159,18 @@ function blockedassign10d( x, y ) { // eslint-disable-line max-statements, max-l
 	// Determine the block size:
 	bsize = blockSize( y.dtype );
 
-	// Cache the indices of the first indexed elements in the respective ndarrays...
-	ix = x.offset;
+	// Cache the index of the first indexed elements in the output ndarray:
 	oy = y.offset;
 
-	// Cache references to the input and output ndarray buffers...
-	xbuf = x.data;
+	// Cache a reference to the output ndarray buffer:
 	ybuf = y.data;
 
 	// Cache the offset increment for the innermost loop...
 	dy0 = sy[0];
 
+	// Cache the scalar value:
+	v = x.data[ x.offset ];
+
 	// Iterate over blocks...
 	for ( j9 = sh[9]; j9 > 0; ) {
 		if ( j9 < bsize ) {
@@ -286,7 +286,7 @@ function blockedassign10d( x, y ) { // eslint-disable-line max-statements, max-l
 																		for ( i2 = 0; i2 < s2; i2++ ) {
 																			for ( i1 = 0; i1 < s1; i1++ ) {
 																				for ( i0 = 0; i0 < s0; i0++ ) {
-																					ybuf[ iy ] = xbuf[ ix ];
+																					ybuf[ iy ] = v;
 																					iy += dy0;
 																				}
 																				iy += dy1;
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/10d_blocked_accessors.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/10d_blocked_accessors.js
index 1b756ff47051..03f49e36a7a3 100644
--- a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/10d_blocked_accessors.js
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/10d_blocked_accessors.js
@@ -52,9 +52,6 @@ var blockSize = require( '@stdlib/ndarray/base/nullary-tiling-block-size' );
 *
 * @example
 * var Complex64Array = require( '@stdlib/array/complex64' );
-* var Complex64 = require( '@stdlib/complex/float32/ctor' );
-* var realf = require( '@stdlib/complex/float32/real' );
-* var imagf = require( '@stdlib/complex/float32/imag' );
 *
 * // Create data buffers:
 * var xbuf = new Complex64Array( [ 2.0, 2.0 ] );
@@ -104,18 +101,11 @@ var blockSize = require( '@stdlib/ndarray/base/nullary-tiling-block-size' );
 * blockedassign10d( x, y );
 *
 * var v = y.data.get( 0 );
-*
-* var re = realf( v );
-* // returns 2.0
-*
-* var im = imagf( v );
-* // returns 2.0
+* // returns <Complex64>[ 2.0, 2.0 ]
 */
 function blockedassign10d( x, y ) { // eslint-disable-line max-statements, max-lines-per-function
 	var bsize;
-	var xbuf;
 	var ybuf;
-	var get;
 	var set;
 	var dy0;
 	var dy1;
@@ -149,7 +139,6 @@ function blockedassign10d( x, y ) { // eslint-disable-line max-statements, max-l
 	var s9;
 	var sy;
 	var oy;
-	var ix;
 	var iy;
 	var i0;
 	var i1;
@@ -172,6 +161,7 @@ function blockedassign10d( x, y ) { // eslint-disable-line max-statements, max-l
 	var j8;
 	var j9;
 	var o;
+	var v;
 
 	// Note on variable naming convention: s#, dy#, i#, j# where # corresponds to the loop number, with `0` being the innermost loop...
 
@@ -183,21 +173,21 @@ function blockedassign10d( x, y ) { // eslint-disable-line max-statements, max-l
 	// Determine the block size:
 	bsize = blockSize( y.dtype );
 
-	// Cache the indices of the first indexed elements in the respective ndarrays...
-	ix = x.offset;
+	// Cache the index of the first indexed elements in the output ndarray:
 	oy = y.offset;
 
-	// Cache references to the input and output ndarray buffers...
-	xbuf = x.data;
+	// Cache a reference to the output ndarray buffer:
 	ybuf = y.data;
 
 	// Cache the offset increment for the innermost loop...
 	dy0 = sy[0];
 
-	// Cache accessors:
-	get = x.accessors[0];
+	// Cache the output ndarray accessor:
 	set = y.accessors[1];
 
+	// Cache the scalar value:
+	v = x.accessors[0]( x.data, x.offset );
+
 	// Iterate over blocks...
 	for ( j9 = sh[9]; j9 > 0; ) {
 		if ( j9 < bsize ) {
@@ -313,7 +303,7 @@ function blockedassign10d( x, y ) { // eslint-disable-line max-statements, max-l
 																		for ( i2 = 0; i2 < s2; i2++ ) {
 																			for ( i1 = 0; i1 < s1; i1++ ) {
 																				for ( i0 = 0; i0 < s0; i0++ ) {
-																					set( ybuf, iy, get( xbuf, ix ) );
+																					set( ybuf, iy, v );
 																					iy += dy0;
 																				}
 																				iy += dy1;
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/1d.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/1d.js
index 8666835c8591..0d7ad191b3b4 100644
--- a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/1d.js
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/1d.js
@@ -83,13 +83,12 @@
 * // => <Float64Array>[ 2.0, 2.0, 2.0, 2.0, 2.0, 2.0 ]
 */
 function assign1d( x, y ) {
-	var xbuf;
 	var ybuf;
 	var dy0;
 	var S0;
-	var ix;
 	var iy;
 	var i0;
+	var v;
 
 	// Note on variable naming convention: S#, dy#, i# where # corresponds to the loop number, with `0` being the innermost loop...
 
@@ -97,17 +96,18 @@ function assign1d( x, y ) {
 	S0 = y.shape[ 0 ];
 	dy0 = y.strides[ 0 ];
 
-	// Set the pointers to the first indexed elements in the respective ndarrays...
-	ix = x.offset;
+	// Set a pointer to the first indexed elements in the output ndarray:
 	iy = y.offset;
 
-	// Cache references to the input and output ndarray buffers...
-	xbuf = x.data;
+	// Cache a reference to the output ndarray buffer:
 	ybuf = y.data;
 
+	// Cache the scalar value:
+	v = x.data[ x.offset ];
+
 	// Iterate over the ndarray dimensions...
 	for ( i0 = 0; i0 < S0; i0++ ) {
-		ybuf[ iy ] = xbuf[ ix ];
+		ybuf[ iy ] = v;
 		iy += dy0;
 	}
 }
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/1d_accessors.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/1d_accessors.js
index f67844523203..c6fa1bd36c80 100644
--- a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/1d_accessors.js
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/1d_accessors.js
@@ -44,9 +44,6 @@
 *
 * @example
 * var Complex64Array = require( '@stdlib/array/complex64' );
-* var Complex64 = require( '@stdlib/complex/float32/ctor' );
-* var realf = require( '@stdlib/complex/float32/real' );
-* var imagf = require( '@stdlib/complex/float32/imag' );
 *
 * // Create data buffers:
 * var xbuf = new Complex64Array( [ 1.0, 2.0 ] );
@@ -96,23 +93,16 @@
 * assign1d( x, y );
 *
 * var v = y.data.get( 0 );
-*
-* var re = realf( v );
-* // returns 1.0
-*
-* var im = imagf( v );
-* // returns 2.0
+* // returns <Complex64>[ 1.0, 2.0 ]
 */
 function assign1d( x, y ) {
-	var xbuf;
 	var ybuf;
-	var get;
 	var set;
 	var dy0;
 	var S0;
-	var ix;
 	var iy;
 	var i0;
+	var v;
 
 	// Note on variable naming convention: S#, dy#, i# where # corresponds to the loop number, with `0` being the innermost loop...
 
@@ -120,21 +110,21 @@ function assign1d( x, y ) {
 	S0 = y.shape[ 0 ];
 	dy0 = y.strides[ 0 ];
 
-	// Set the pointers to the first indexed elements in the respective ndarrays...
-	ix = x.offset;
+	// Set a pointer to the first indexed elements in the output ndarray:
 	iy = y.offset;
 
-	// Cache references to the input and output ndarray buffers...
-	xbuf = x.data;
+	// Cache a reference to the output ndarray buffer:
 	ybuf = y.data;
 
-	// Cache accessors:
-	get = x.accessors[ 0 ];
+	// Cache the output ndarray accessor:
 	set = y.accessors[ 1 ];
 
+	// Cache the scalar value:
+	v = x.accessors[ 0 ]( x.data, x.offset );
+
 	// Iterate over the ndarray dimensions...
 	for ( i0 = 0; i0 < S0; i0++ ) {
-		set( ybuf, iy, get( xbuf, ix ) );
+		set( ybuf, iy, v );
 		iy += dy0;
 	}
 }
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/2d_blocked_complex.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/2d_blocked_complex.js
new file mode 100644
index 000000000000..ba3f1d6238db
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/2d_blocked_complex.js
@@ -0,0 +1,152 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2026 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 loopOrder = require( '@stdlib/ndarray/base/nullary-loop-interchange-order' );
+var blockSize = require( '@stdlib/ndarray/base/nullary-tiling-block-size' );
+
+
+// MAIN //
+
+/**
+* Assigns a scalar value to every element of a reinterpreted complex number two-dimensional output ndarray via loop blocking.
+*
+* @private
+* @param {number} re - real component
+* @param {number} im - imaginary component
+* @param {Object} y - object containing output ndarray meta data
+* @param {*} y.dtype - data type
+* @param {Collection} y.data - data buffer
+* @param {NonNegativeIntegerArray} y.shape - dimensions
+* @param {IntegerArray} y.strides - stride lengths
+* @param {NonNegativeInteger} y.offset - index offset
+* @param {string} y.order - specifies whether `y` is row-major (C-style) or column-major (Fortran-style)
+* @returns {void}
+*
+* @example
+* var Float64Array = require( '@stdlib/array/float64' );
+*
+* // Create a data buffer:
+* var ybuf = new Float64Array( 12 );
+*
+* // Define the shape of the output array:
+* var shape = [ 3, 2 ];
+*
+* // Define the array strides:
+* var sy = [ 4, 2 ];
+*
+* // Define the index offset:
+* var oy = 0;
+*
+* // Create the output ndarray-like object:
+* var y = {
+*     'dtype': 'float64',
+*     'data': ybuf,
+*     'shape': shape,
+*     'strides': sy,
+*     'offset': oy,
+*     'order': 'row-major'
+* };
+*
+* // Assign scalar:
+* blockedassign2d( 2.0, 2.0, y );
+*
+* console.log( y.data );
+* // => <Float64Array>[ 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0 ]
+*/
+function blockedassign2d( re, im, y ) {
+	var bsize;
+	var ybuf;
+	var dy0;
+	var dy1;
+	var oy1;
+	var sh;
+	var s0;
+	var s1;
+	var sy;
+	var oy;
+	var iy;
+	var i0;
+	var i1;
+	var j0;
+	var j1;
+	var o;
+
+	// Note on variable naming convention: s#, dy#, i#, j# where # corresponds to the loop number, with `0` being the innermost loop...
+
+	// Resolve the loop interchange order:
+	o = loopOrder( y.shape, y.strides );
+	sh = o.sh;
+	sy = o.sx;
+
+	// Determine the block size:
+	bsize = blockSize( y.dtype );
+
+	// Cache the index of the first indexed element in the output ndarray:
+	oy = y.offset;
+
+	// Cache a reference to the output ndarray buffer:
+	ybuf = y.data;
+
+	// Cache the offset increment for the innermost loop:
+	dy0 = sy[0];
+
+	// Iterate over blocks...
+	for ( j1 = sh[1]; j1 > 0; ) {
+		if ( j1 < bsize ) {
+			s1 = j1;
+			j1 = 0;
+		} else {
+			s1 = bsize;
+			j1 -= bsize;
+		}
+		oy1 = oy + ( j1*sy[1] );
+		for ( j0 = sh[0]; j0 > 0; ) {
+			if ( j0 < bsize ) {
+				s0 = j0;
+				j0 = 0;
+			} else {
+				s0 = bsize;
+				j0 -= bsize;
+			}
+			// Compute the index offset for the first output ndarray element in the current block...
+			iy = oy1 + ( j0*sy[0] );
+
+			// Compute the loop offset increment...
+			dy1 = sy[1] - ( s0*sy[0] );
+
+			// Iterate over the ndarray dimensions...
+			for ( i1 = 0; i1 < s1; i1++ ) {
+				for ( i0 = 0; i0 < s0; i0++ ) {
+					ybuf[ iy ] = re;
+					ybuf[ iy+1 ] = im;
+					iy += dy0;
+				}
+				iy += dy1;
+			}
+		}
+	}
+}
+
+
+// EXPORTS //
+
+module.exports = blockedassign2d;
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/2d_complex.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/2d_complex.js
new file mode 100644
index 000000000000..b1d87c7edca0
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/2d_complex.js
@@ -0,0 +1,120 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2026 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';
+
+// MAIN //
+
+/**
+* Assigns a scalar value to every element of a reinterpreted complex number two-dimensional output ndarray.
+*
+* @private
+* @param {number} re - real component
+* @param {number} im - imaginary component
+* @param {Object} y - object containing output ndarray meta data
+* @param {*} y.dtype - data type
+* @param {Collection} y.data - data buffer
+* @param {NonNegativeIntegerArray} y.shape - dimensions
+* @param {IntegerArray} y.strides - stride lengths
+* @param {NonNegativeInteger} y.offset - index offset
+* @param {string} y.order - specifies whether `y` is row-major (C-style) or column-major (Fortran-style)
+* @param {boolean} isRowMajor - boolean indicating if provided arrays are in row-major order
+* @returns {void}
+*
+* @example
+* var Float64Array = require( '@stdlib/array/float64' );
+*
+* // Create a data buffer:
+* var ybuf = new Float64Array( 12 );
+*
+* // Define the shape of the output array:
+* var shape = [ 3, 2 ];
+*
+* // Define the array strides:
+* var sy = [ 4, 2 ];
+*
+* // Define the index offset:
+* var oy = 0;
+*
+* // Create the output ndarray-like object:
+* var y = {
+*     'dtype': 'float64',
+*     'data': ybuf,
+*     'shape': shape,
+*     'strides': sy,
+*     'offset': oy,
+*     'order': 'row-major'
+* };
+*
+* // Assign scalar:
+* assign2d( 2.0, 2.0, y, true );
+*
+* console.log( y.data );
+* // => <Float64Array>[ 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0 ]
+*/
+function assign2d( re, im, y, isRowMajor ) {
+	var ybuf;
+	var dy0;
+	var dy1;
+	var sh;
+	var S0;
+	var S1;
+	var sy;
+	var iy;
+	var i0;
+	var i1;
+
+	// Note on variable naming convention: S#, dy#, i# where # corresponds to the loop number, with `0` being the innermost loop...
+
+	// Extract loop variables for purposes of loop interchange: dimensions and loop offset (pointer) increments...
+	sh = y.shape;
+	sy = y.strides;
+	if ( isRowMajor ) {
+		// For row-major ndarrays, the last dimensions have the fastest changing indices...
+		S0 = sh[ 1 ];
+		S1 = sh[ 0 ];
+		dy0 = sy[ 1 ];                // offset increment for innermost loop
+		dy1 = sy[ 0 ] - ( S0*sy[1] ); // offset increment for outermost loop
+	} else { // order === 'column-major'
+		// For column-major ndarrays, the first dimensions have the fastest changing indices...
+		S0 = sh[ 0 ];
+		S1 = sh[ 1 ];
+		dy0 = sy[ 0 ];                // offset increment for innermost loop
+		dy1 = sy[ 1 ] - ( S0*sy[0] ); // offset increment for outermost loop
+	}
+	// Set a pointer to the first indexed element in the output ndarray:
+	iy = y.offset;
+
+	// Cache a reference to the output ndarray buffer:
+	ybuf = y.data;
+
+	// Iterate over the ndarray dimensions...
+	for ( i1 = 0; i1 < S1; i1++ ) {
+		for ( i0 = 0; i0 < S0; i0++ ) {
+			ybuf[ iy ] = re;
+			ybuf[ iy+1 ] = im;
+			iy += dy0;
+		}
+		iy += dy1;
+	}
+}
+
+
+// EXPORTS //
+
+module.exports = assign2d;
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/main.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/main.js
index 9c4ba0ca16f9..db5fa21820b4 100644
--- a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/main.js
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/main.js
@@ -22,13 +22,15 @@
 
 var isComplexDataType = require( '@stdlib/ndarray/base/assert/is-complex-floating-point-data-type' );
 var isRealDataType = require( '@stdlib/ndarray/base/assert/is-real-data-type' );
+var isComplexArray = require( '@stdlib/array/base/assert/is-complex-typed-array' );
 var isBooleanArray = require( '@stdlib/array/base/assert/is-booleanarray' );
 var iterationOrder = require( '@stdlib/ndarray/base/iteration-order' );
-var castReturn = require( '@stdlib/complex/base/cast-return' );
-var complexCtors = require( '@stdlib/complex/ctors' );
+var strides2order = require( '@stdlib/ndarray/base/strides2order' );
 var minmaxViewBufferIndex = require( '@stdlib/ndarray/base/minmax-view-buffer-index' );
 var ndarray2object = require( '@stdlib/ndarray/base/ndarraylike2object' );
+var reinterpretComplex = require( '@stdlib/strided/base/reinterpret-complex' );
 var reinterpretBoolean = require( '@stdlib/strided/base/reinterpret-boolean' );
+var gscal = require( '@stdlib/blas/base/gscal' );
 var blockedaccessorassign2d = require( './2d_blocked_accessors.js' );
 var blockedaccessorassign3d = require( './3d_blocked_accessors.js' );
 var blockedaccessorassign4d = require( './4d_blocked_accessors.js' );
@@ -38,6 +40,7 @@ var blockedaccessorassign7d = require( './7d_blocked_accessors.js' );
 var blockedaccessorassign8d = require( './8d_blocked_accessors.js' );
 var blockedaccessorassign9d = require( './9d_blocked_accessors.js' );
 var blockedaccessorassign10d = require( './10d_blocked_accessors.js' );
+var blockedcomplexassign2d = require( './2d_blocked_complex.js' ); // FIXME
 var blockedassign2d = require( './2d_blocked.js' );
 var blockedassign3d = require( './3d_blocked.js' );
 var blockedassign4d = require( './4d_blocked.js' );
@@ -59,6 +62,8 @@ var accessorassign8d = require( './8d_accessors.js' );
 var accessorassign9d = require( './9d_accessors.js' );
 var accessorassign10d = require( './10d_accessors.js' );
 var accessorassignnd = require( './nd_accessors.js' );
+var complexassign0d = require( './0d_complex.js' ); // FIXME: start
+var complexassign2d = require( './2d_complex.js' ); // FIXME: end
 var assign0d = require( './0d.js' );
 var assign1d = require( './1d.js' );
 var assign2d = require( './2d.js' );
@@ -101,6 +106,22 @@ var ACCESSOR_ASSIGN = [
 	accessorassign9d,
 	accessorassign10d
 ];
+var COMPLEX_ASSIGN = [ // FIXME
+	complexassign0d,
+
+	/* complexassign1d, */
+
+	complexassign2d
+
+	/* complexassign3d,
+	complexassign4d,
+	complexassign5d,
+	complexassign6d,
+	complexassign7d,
+	complexassign8d,
+	complexassign9d,
+	complexassign10d */
+];
 var BLOCKED_ASSIGN = [
 	blockedassign2d, // 0
 	blockedassign3d,
@@ -123,8 +144,27 @@ var BLOCKED_ACCESSOR_ASSIGN = [
 	blockedaccessorassign9d,
 	blockedaccessorassign10d // 8
 ];
+var BLOCKED_COMPLEX_ASSIGN = [ // FIXME
+	blockedcomplexassign2d // 0
+
+	/* blockedcomplexassign3d,
+	blockedcomplexassign4d,
+	blockedcomplexassign5d,
+	blockedcomplexassign6d,
+	blockedcomplexassign7d,
+	blockedcomplexassign8d,
+	blockedcomplexassign9d,
+	blockedcomplexassign10d // 8 */
+];
 var MAX_DIMS = ASSIGN.length - 1;
 
+// TODO: consider adding a package utility for mapping a complex dtype to its complementary real-valued counterpart
+var COMPLEX_TO_REAL = { // WARNING: this table needs to be manually updated if we add support for additional complex number dtypes
+	'complex128': 'float64',
+	'complex64': 'float32',
+	'complex32': 'float16'
+};
+
 
 // FUNCTIONS //
 
@@ -145,6 +185,27 @@ function boolean2uint8( x ) {
 	return x;
 }
 
+/**
+* Converts a complex-valued floating-point ndarray to a real-valued floating-point ndarray.
+*
+* ## Notes
+*
+* -   The function mutates the input ndarray object.
+*
+* @private
+* @param {Object} x - input ndarray object
+* @returns {Object} output ndarray object
+*/
+function complex2real( x ) {
+	var ndims = x.shape.length;
+	x.data = reinterpretComplex( x.data, 0 );
+	x.accessorProtocol = false;
+	x.dtype = COMPLEX_TO_REAL[ String( x.dtype ) ];
+	x.strides = gscal( ndims, 2, x.strides, 1 );
+	x.offset *= 2;
+	return x;
+}
+
 
 // MAIN //
 
@@ -203,14 +264,18 @@ function boolean2uint8( x ) {
 * // => <Float64Array>[ 0.0, 5.0, 5.0, 0.0, 0.0, 5.0, 5.0, 0.0, 0.0, 5.0, 5.0, 0.0 ]
 */
 function assignScalar( arrays ) {
+	var isCmplx;
 	var ndims;
 	var ymmv;
 	var shy;
 	var ioy;
 	var len;
+	var ord;
 	var sy;
 	var oy;
 	var ns;
+	var re;
+	var im;
 	var x;
 	var y;
 	var d;
@@ -224,11 +289,19 @@ function assignScalar( arrays ) {
 	if ( isBooleanArray( x.data ) && isBooleanArray( y.data ) ) {
 		x = boolean2uint8( x );
 		y = boolean2uint8( y );
+	} else if ( isComplexArray( x.data ) && isComplexArray( y.data ) ) {
+		x = complex2real( x );
+		y = complex2real( y );
+		re = x.data[ x.offset ];
+		im = x.data[ x.offset+1 ];
+		isCmplx = true;
 	}
-	// Determine whether we are casting a real data type to a complex data type and we need to use a specialized accessor...
+	// Determine whether we are casting a real data type to a complex data type and we need to use a specialized accessor (note: we don't support the other way, complex-to-real, as this is not an allowed (mostly) safe cast; note: we cannot create a specialized view for assigning only real components, as the imaginary component for each element in `y` also needs to be set to zero and while we could perform two passes, it's not clear it's worth the effort)...
 	else if ( isRealDataType( x.dtype ) && isComplexDataType( y.dtype ) ) {
-		x.accessorProtocol = true;
-		x.accessors[ 0 ] = castReturn( x.accessors[ 0 ], 2, complexCtors( String( y.dtype ) ) ); // eslint-disable-line max-len
+		y = complex2real( y );
+		re = x.data[ x.offset ];
+		im = 0.0;
+		isCmplx = true;
 	}
 	shy = y.shape;
 	ndims = shy.length;
@@ -238,6 +311,9 @@ function assignScalar( arrays ) {
 		if ( x.accessorProtocol || y.accessorProtocol ) {
 			return ACCESSOR_ASSIGN[ ndims ]( x, y );
 		}
+		if ( isCmplx ) {
+			return COMPLEX_ASSIGN[ ndims ]( re, im, y );
+		}
 		return ASSIGN[ ndims ]( x, y );
 	}
 	// Compute the number of elements and the number of singleton dimensions...
@@ -263,6 +339,9 @@ function assignScalar( arrays ) {
 		if ( x.accessorProtocol || y.accessorProtocol ) {
 			return ACCESSOR_ASSIGN[ ndims ]( x, y );
 		}
+		if ( isCmplx ) {
+			return COMPLEX_ASSIGN[ ndims ]( re, im, y );
+		}
 		return ASSIGN[ ndims ]( x, y );
 	}
 	sy = y.strides;
@@ -280,6 +359,9 @@ function assignScalar( arrays ) {
 		if ( x.accessorProtocol || y.accessorProtocol ) {
 			return ACCESSOR_ASSIGN[ 1 ]( x, y );
 		}
+		if ( isCmplx ) {
+			return COMPLEX_ASSIGN[ 1 ]( re, im, y );
+		}
 		return ASSIGN[ 1 ]( x, y );
 	}
 	ioy = iterationOrder( sy ); // +/-1
@@ -303,17 +385,25 @@ function assignScalar( arrays ) {
 			if ( x.accessorProtocol || y.accessorProtocol ) {
 				return ACCESSOR_ASSIGN[ 1 ]( x, y );
 			}
+			if ( isCmplx ) {
+				return COMPLEX_ASSIGN[ 1 ]( re, im, y );
+			}
 			return ASSIGN[ 1 ]( x, y );
 		}
 		// The ndarray is non-contiguous, so we cannot directly use one-dimensional array functionality...
 
 		// Determine whether we can use simple nested loops...
 		if ( ndims <= MAX_DIMS ) {
+			ord = strides2order( sy );
+
 			// So long as iteration always moves in the same direction (i.e., no mixed sign strides), we can leverage cache-optimal (i.e., normal) nested loops without resorting to blocked iteration...
 			if ( x.accessorProtocol || y.accessorProtocol ) {
-				return ACCESSOR_ASSIGN[ ndims ]( x, y );
+				return ACCESSOR_ASSIGN[ ndims ]( x, y, ord === 1 );
 			}
-			return ASSIGN[ ndims ]( x, y );
+			if ( isCmplx ) {
+				return COMPLEX_ASSIGN[ ndims ]( re, im, y, ord === 1 );
+			}
+			return ASSIGN[ ndims ]( x, y, ord === 1 );
 		}
 		// Fall-through to blocked iteration...
 	}
@@ -324,12 +414,18 @@ function assignScalar( arrays ) {
 		if ( x.accessorProtocol || y.accessorProtocol ) {
 			return BLOCKED_ACCESSOR_ASSIGN[ ndims-2 ]( x, y );
 		}
+		if ( isCmplx ) {
+			return BLOCKED_COMPLEX_ASSIGN[ ndims-2 ]( re, im, y );
+		}
 		return BLOCKED_ASSIGN[ ndims-2 ]( x, y );
 	}
 	// Fall-through to linear view iteration without regard for how data is stored in memory (i.e., take the slow path)...
 	if ( x.accessorProtocol || y.accessorProtocol ) {
 		return accessorassignnd( x, y );
 	}
+	if ( isCmplx ) {
+		// FIXME: return complexassignnd( re, im, y );
+	}
 	assignnd( x, y );
 }
 

From b74f00a0fe3027b0b10b3ca6c5c4dc6d6e782501 Mon Sep 17 00:00:00 2001
From: headlessNode <harriskhan047@outlook.com>
Date: Mon, 23 Mar 2026 02:20:12 +0500
Subject: [PATCH 06/20] fix: apply suggestions from code review

---
type: pre_commit_static_analysis_report
description: Results of running static analysis checks when committing changes.
report:
  - task: lint_filenames
    status: passed
  - task: lint_editorconfig
    status: passed
  - task: lint_markdown
    status: na
  - task: lint_package_json
    status: na
  - task: lint_repl_help
    status: passed
  - task: lint_javascript_src
    status: passed
  - task: lint_javascript_cli
    status: na
  - task: lint_javascript_examples
    status: na
  - task: lint_javascript_tests
    status: passed
  - task: lint_javascript_benchmarks
    status: na
  - task: lint_python
    status: na
  - task: lint_r
    status: na
  - task: lint_c_src
    status: na
  - task: lint_c_examples
    status: na
  - task: lint_c_benchmarks
    status: na
  - task: lint_c_tests_fixtures
    status: na
  - task: lint_shell
    status: na
  - task: lint_typescript_declarations
    status: passed
  - task: lint_typescript_tests
    status: na
  - task: lint_license_headers
    status: passed
---
---
 .../ndarray/base/assign-scalar/docs/repl.txt  |   1 -
 .../ndarray/base/assign-scalar/lib/0d.js      |   2 +-
 .../base/assign-scalar/lib/0d_accessors.js    |   2 +-
 .../base/assign-scalar/lib/10d_blocked.js     |   2 +-
 .../lib/10d_blocked_accessors.js              |   2 +-
 .../assign-scalar/lib/10d_blocked_complex.js  | 306 +++++++
 .../base/assign-scalar/lib/10d_complex.js     | 202 +++++
 .../base/assign-scalar/lib/1d_complex.js      |  97 ++
 .../ndarray/base/assign-scalar/lib/2d.js      |  22 +-
 .../base/assign-scalar/lib/2d_accessors.js    |  34 +-
 .../base/assign-scalar/lib/2d_blocked.js      |  16 +-
 .../assign-scalar/lib/2d_blocked_accessors.js |  38 +-
 .../ndarray/base/assign-scalar/lib/3d.js      |  22 +-
 .../base/assign-scalar/lib/3d_accessors.js    |  26 +-
 .../base/assign-scalar/lib/3d_blocked.js      |  16 +-
 .../assign-scalar/lib/3d_blocked_accessors.js |  26 +-
 .../assign-scalar/lib/3d_blocked_complex.js   | 173 ++++
 .../base/assign-scalar/lib/3d_complex.js      | 130 +++
 .../ndarray/base/assign-scalar/lib/4d.js      |  22 +-
 .../base/assign-scalar/lib/4d_accessors.js    |  28 +-
 .../base/assign-scalar/lib/4d_blocked.js      |  16 +-
 .../assign-scalar/lib/4d_blocked_accessors.js |  22 +-
 .../assign-scalar/lib/4d_blocked_complex.js   | 192 ++++
 .../base/assign-scalar/lib/4d_complex.js      | 140 +++
 .../ndarray/base/assign-scalar/lib/5d.js      |  22 +-
 .../base/assign-scalar/lib/5d_accessors.js    |  28 +-
 .../base/assign-scalar/lib/5d_blocked.js      |  16 +-
 .../assign-scalar/lib/5d_blocked_accessors.js |  22 +-
 .../assign-scalar/lib/5d_blocked_complex.js   | 211 +++++
 .../base/assign-scalar/lib/5d_complex.js      | 150 ++++
 .../ndarray/base/assign-scalar/lib/6d.js      |  22 +-
 .../base/assign-scalar/lib/6d_accessors.js    |  28 +-
 .../base/assign-scalar/lib/6d_blocked.js      |  16 +-
 .../assign-scalar/lib/6d_blocked_accessors.js |  24 +-
 .../assign-scalar/lib/6d_blocked_complex.js   | 230 +++++
 .../base/assign-scalar/lib/6d_complex.js      | 162 ++++
 .../ndarray/base/assign-scalar/lib/7d.js      |  22 +-
 .../base/assign-scalar/lib/7d_accessors.js    |  28 +-
 .../base/assign-scalar/lib/7d_blocked.js      |  16 +-
 .../assign-scalar/lib/7d_blocked_accessors.js |  22 +-
 .../assign-scalar/lib/7d_blocked_complex.js   | 249 ++++++
 .../base/assign-scalar/lib/7d_complex.js      | 172 ++++
 .../ndarray/base/assign-scalar/lib/8d.js      |  22 +-
 .../base/assign-scalar/lib/8d_accessors.js    |  28 +-
 .../base/assign-scalar/lib/8d_blocked.js      |  16 +-
 .../assign-scalar/lib/8d_blocked_accessors.js |  22 +-
 .../assign-scalar/lib/8d_blocked_complex.js   | 268 ++++++
 .../base/assign-scalar/lib/8d_complex.js      | 182 ++++
 .../ndarray/base/assign-scalar/lib/9d.js      |  22 +-
 .../base/assign-scalar/lib/9d_accessors.js    |  28 +-
 .../base/assign-scalar/lib/9d_blocked.js      |  16 +-
 .../assign-scalar/lib/9d_blocked_accessors.js |  22 +-
 .../assign-scalar/lib/9d_blocked_complex.js   | 287 ++++++
 .../base/assign-scalar/lib/9d_complex.js      | 192 ++++
 .../ndarray/base/assign-scalar/lib/main.js    |  48 +-
 .../ndarray/base/assign-scalar/lib/nd.js      |  20 +-
 .../base/assign-scalar/lib/nd_accessors.js    |  26 +-
 .../base/assign-scalar/lib/nd_complex.js      | 118 +++
 .../base/assign-scalar/test/test.0d.js        |  19 +-
 .../base/assign-scalar/test/test.1d.js        |  80 +-
 .../base/assign-scalar/test/test.2d.js        | 748 ++++++++++------
 .../base/assign-scalar/test/test.3d.js        | 834 ++++++++++++------
 62 files changed, 4994 insertions(+), 981 deletions(-)
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/10d_blocked_complex.js
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/10d_complex.js
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/1d_complex.js
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/3d_blocked_complex.js
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/3d_complex.js
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/4d_blocked_complex.js
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/4d_complex.js
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/5d_blocked_complex.js
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/5d_complex.js
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/6d_blocked_complex.js
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/6d_complex.js
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/7d_blocked_complex.js
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/7d_complex.js
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/8d_blocked_complex.js
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/8d_complex.js
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/9d_blocked_complex.js
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/9d_complex.js
 create mode 100644 lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/nd_complex.js

diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/docs/repl.txt b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/docs/repl.txt
index 9ba16849b7c0..ab77a80c1519 100644
--- a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/docs/repl.txt
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/docs/repl.txt
@@ -1,4 +1,3 @@
-
 {{alias}}( arrays )
     Assigns a scalar value to every element of an output ndarray.
 
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/0d.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/0d.js
index ba86644d5c71..6b1a6ce0a417 100644
--- a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/0d.js
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/0d.js
@@ -47,7 +47,7 @@
 * var xbuf = new Float64Array( [ 2.0 ] );
 * var ybuf = new Float64Array( 1 );
 *
-* // Define the shape of the input and output arrays:
+* // Define the shape of the output array:
 * var shape = [];
 *
 * // Define the array strides:
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/0d_accessors.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/0d_accessors.js
index 9fca8ef22a32..29f6d5151659 100644
--- a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/0d_accessors.js
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/0d_accessors.js
@@ -49,7 +49,7 @@
 * var xbuf = new Complex64Array( [ 3.0, 4.0 ] );
 * var ybuf = new Complex64Array( 1 );
 *
-* // Define the shape of the input and output arrays:
+* // Define the shape of the output array:
 * var shape = [];
 *
 * // Define the array strides:
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/10d_blocked.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/10d_blocked.js
index a3b8860c0980..df73f46558b3 100644
--- a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/10d_blocked.js
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/10d_blocked.js
@@ -165,7 +165,7 @@ function blockedassign10d( x, y ) { // eslint-disable-line max-statements, max-l
 	// Cache a reference to the output ndarray buffer:
 	ybuf = y.data;
 
-	// Cache the offset increment for the innermost loop...
+	// Cache the offset increment for the innermost loop:
 	dy0 = sy[0];
 
 	// Cache the scalar value:
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/10d_blocked_accessors.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/10d_blocked_accessors.js
index 03f49e36a7a3..b37acefa3a7a 100644
--- a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/10d_blocked_accessors.js
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/10d_blocked_accessors.js
@@ -179,7 +179,7 @@ function blockedassign10d( x, y ) { // eslint-disable-line max-statements, max-l
 	// Cache a reference to the output ndarray buffer:
 	ybuf = y.data;
 
-	// Cache the offset increment for the innermost loop...
+	// Cache the offset increment for the innermost loop:
 	dy0 = sy[0];
 
 	// Cache the output ndarray accessor:
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/10d_blocked_complex.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/10d_blocked_complex.js
new file mode 100644
index 000000000000..4c9825036b51
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/10d_blocked_complex.js
@@ -0,0 +1,306 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2026 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-depth */
+
+'use strict';
+
+// MODULES //
+
+var loopOrder = require( '@stdlib/ndarray/base/nullary-loop-interchange-order' );
+var blockSize = require( '@stdlib/ndarray/base/nullary-tiling-block-size' );
+
+
+// MAIN //
+
+/**
+* Assigns a scalar value to every element of a reinterpreted complex number ten-dimensional output ndarray via loop blocking.
+*
+* @private
+* @param {number} re - real component
+* @param {number} im - imaginary component
+* @param {Object} y - object containing output ndarray meta data
+* @param {*} y.dtype - data type
+* @param {Collection} y.data - data buffer
+* @param {NonNegativeIntegerArray} y.shape - dimensions
+* @param {IntegerArray} y.strides - stride lengths
+* @param {NonNegativeInteger} y.offset - index offset
+* @param {string} y.order - specifies whether `y` is row-major (C-style) or column-major (Fortran-style)
+* @returns {void}
+*
+* @example
+* var Float64Array = require( '@stdlib/array/float64' );
+*
+* // Create a data buffer:
+* var ybuf = new Float64Array( 12 );
+*
+* // Define the shape of the output array:
+* var shape = [ 1, 1, 1, 1, 1, 1, 1, 3, 1, 2 ];
+*
+* // Define the array strides:
+* var sy = [ 12, 12, 12, 12, 12, 12, 12, 4, 4, 2 ];
+*
+* // Define the index offset:
+* var oy = 0;
+*
+* // Create the output ndarray-like object:
+* var y = {
+*     'dtype': 'float64',
+*     'data': ybuf,
+*     'shape': shape,
+*     'strides': sy,
+*     'offset': oy,
+*     'order': 'row-major'
+* };
+*
+* // Assign scalar:
+* blockedassign10d( 2.0, 2.0, y );
+*
+* console.log( y.data );
+* // => <Float64Array>[ 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0 ]
+*/
+function blockedassign10d( re, im, y ) {
+	var bsize;
+	var ybuf;
+	var dy0;
+	var dy1;
+	var dy2;
+	var dy3;
+	var dy4;
+	var dy5;
+	var dy6;
+	var dy7;
+	var dy8;
+	var dy9;
+	var oy1;
+	var oy2;
+	var oy3;
+	var oy4;
+	var oy5;
+	var oy6;
+	var oy7;
+	var oy8;
+	var oy9;
+	var sh;
+	var s0;
+	var s1;
+	var s2;
+	var s3;
+	var s4;
+	var s5;
+	var s6;
+	var s7;
+	var s8;
+	var s9;
+	var sy;
+	var oy;
+	var iy;
+	var i0;
+	var i1;
+	var i2;
+	var i3;
+	var i4;
+	var i5;
+	var i6;
+	var i7;
+	var i8;
+	var i9;
+	var j0;
+	var j1;
+	var j2;
+	var j3;
+	var j4;
+	var j5;
+	var j6;
+	var j7;
+	var j8;
+	var j9;
+	var o;
+
+	// Note on variable naming convention: s#, dy#, i#, j# where # corresponds to the loop number, with `0` being the innermost loop...
+
+	// Resolve the loop interchange order:
+	o = loopOrder( y.shape, y.strides );
+	sh = o.sh;
+	sy = o.sx;
+
+	// Determine the block size:
+	bsize = blockSize( y.dtype );
+
+	// Cache the index of the first indexed element in the output ndarray:
+	oy = y.offset;
+
+	// Cache a reference to the output ndarray buffer:
+	ybuf = y.data;
+
+	// Cache the offset increment for the innermost loop:
+	dy0 = sy[0];
+
+	// Iterate over blocks...
+	for ( j9 = sh[9]; j9 > 0; ) {
+		if ( j9 < bsize ) {
+			s9 = j9;
+			j9 = 0;
+		} else {
+			s9 = bsize;
+			j9 -= bsize;
+		}
+		oy9 = oy + ( j9*sy[9] );
+		for ( j8 = sh[8]; j8 > 0; ) {
+			if ( j8 < bsize ) {
+				s8 = j8;
+				j8 = 0;
+			} else {
+				s8 = bsize;
+				j8 -= bsize;
+			}
+			dy9 = sy[9] - ( s8*sy[8] );
+			oy8 = oy9 + ( j8*sy[8] );
+			for ( j7 = sh[7]; j7 > 0; ) {
+				if ( j7 < bsize ) {
+					s7 = j7;
+					j7 = 0;
+				} else {
+					s7 = bsize;
+					j7 -= bsize;
+				}
+				dy8 = sy[8] - ( s7*sy[7] );
+				oy7 = oy8 + ( j7*sy[7] );
+				for ( j6 = sh[6]; j6 > 0; ) {
+					if ( j6 < bsize ) {
+						s6 = j6;
+						j6 = 0;
+					} else {
+						s6 = bsize;
+						j6 -= bsize;
+					}
+					dy7 = sy[7] - ( s6*sy[6] );
+					oy6 = oy7 + ( j6*sy[6] );
+					for ( j5 = sh[5]; j5 > 0; ) {
+						if ( j5 < bsize ) {
+							s5 = j5;
+							j5 = 0;
+						} else {
+							s5 = bsize;
+							j5 -= bsize;
+						}
+						dy6 = sy[6] - ( s5*sy[5] );
+						oy5 = oy6 + ( j5*sy[5] );
+						for ( j4 = sh[4]; j4 > 0; ) {
+							if ( j4 < bsize ) {
+								s4 = j4;
+								j4 = 0;
+							} else {
+								s4 = bsize;
+								j4 -= bsize;
+							}
+							dy5 = sy[5] - ( s4*sy[4] );
+							oy4 = oy5 + ( j4*sy[4] );
+							for ( j3 = sh[3]; j3 > 0; ) {
+								if ( j3 < bsize ) {
+									s3 = j3;
+									j3 = 0;
+								} else {
+									s3 = bsize;
+									j3 -= bsize;
+								}
+								dy4 = sy[4] - ( s3*sy[3] );
+								oy3 = oy4 + ( j3*sy[3] );
+								for ( j2 = sh[2]; j2 > 0; ) {
+									if ( j2 < bsize ) {
+										s2 = j2;
+										j2 = 0;
+									} else {
+										s2 = bsize;
+										j2 -= bsize;
+									}
+									dy3 = sy[3] - ( s2*sy[2] );
+									oy2 = oy3 + ( j2*sy[2] );
+									for ( j1 = sh[1]; j1 > 0; ) {
+										if ( j1 < bsize ) {
+											s1 = j1;
+											j1 = 0;
+										} else {
+											s1 = bsize;
+											j1 -= bsize;
+										}
+										dy2 = sy[2] - ( s1*sy[1] );
+										oy1 = oy2 + ( j1*sy[1] );
+										for ( j0 = sh[0]; j0 > 0; ) {
+											if ( j0 < bsize ) {
+												s0 = j0;
+												j0 = 0;
+											} else {
+												s0 = bsize;
+												j0 -= bsize;
+											}
+											// Compute the index offset for the first output ndarray element in the current block...
+											iy = oy1 + ( j0*sy[0] );
+
+											// Compute the loop offset increment...
+											dy1 = sy[1] - ( s0*sy[0] );
+
+											// Iterate over the ndarray dimensions...
+											for ( i9 = 0; i9 < s9; i9++ ) {
+												for ( i8 = 0; i8 < s8; i8++ ) {
+													for ( i7 = 0; i7 < s7; i7++ ) {
+														for ( i6 = 0; i6 < s6; i6++ ) {
+															for ( i5 = 0; i5 < s5; i5++ ) {
+																for ( i4 = 0; i4 < s4; i4++ ) {
+																	for ( i3 = 0; i3 < s3; i3++ ) {
+																		for ( i2 = 0; i2 < s2; i2++ ) {
+																			for ( i1 = 0; i1 < s1; i1++ ) {
+																				for ( i0 = 0; i0 < s0; i0++ ) {
+																					ybuf[ iy ] = re;
+																					ybuf[ iy+1 ] = im;
+																					iy += dy0;
+																				}
+																				iy += dy1;
+																			}
+																			iy += dy2;
+																		}
+																		iy += dy3;
+																	}
+																	iy += dy4;
+																}
+																iy += dy5;
+															}
+															iy += dy6;
+														}
+														iy += dy7;
+													}
+													iy += dy8;
+												}
+												iy += dy9;
+											}
+										}
+									}
+								}
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+}
+
+
+// EXPORTS //
+
+module.exports = blockedassign10d;
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/10d_complex.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/10d_complex.js
new file mode 100644
index 000000000000..187171d7847e
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/10d_complex.js
@@ -0,0 +1,202 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2026 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-depth */
+
+'use strict';
+
+// MAIN //
+
+/**
+* Assigns a scalar value to every element of a reinterpreted complex number ten-dimensional output ndarray.
+*
+* @private
+* @param {number} re - real component
+* @param {number} im - imaginary component
+* @param {Object} y - object containing output ndarray meta data
+* @param {*} y.dtype - data type
+* @param {Collection} y.data - data buffer
+* @param {NonNegativeIntegerArray} y.shape - dimensions
+* @param {IntegerArray} y.strides - stride lengths
+* @param {NonNegativeInteger} y.offset - index offset
+* @param {string} y.order - specifies whether `y` is row-major (C-style) or column-major (Fortran-style)
+* @param {boolean} isRowMajor - boolean indicating if provided arrays are in row-major order
+* @returns {void}
+*
+* @example
+* var Float64Array = require( '@stdlib/array/float64' );
+*
+* // Create a data buffer:
+* var ybuf = new Float64Array( 12 );
+*
+* // Define the shape of the output array:
+* var shape = [ 1, 1, 1, 1, 1, 1, 1, 3, 1, 2 ];
+*
+* // Define the array strides:
+* var sy = [ 12, 12, 12, 12, 12, 12, 12, 4, 4, 2 ];
+*
+* // Define the index offset:
+* var oy = 0;
+*
+* // Create the output ndarray-like object:
+* var y = {
+*     'dtype': 'float64',
+*     'data': ybuf,
+*     'shape': shape,
+*     'strides': sy,
+*     'offset': oy,
+*     'order': 'row-major'
+* };
+*
+* // Assign scalar:
+* assign10d( 2.0, 2.0, y, true );
+*
+* console.log( y.data );
+* // => <Float64Array>[ 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0 ]
+*/
+function assign10d( re, im, y, isRowMajor ) {
+	var ybuf;
+	var dy0;
+	var dy1;
+	var dy2;
+	var dy3;
+	var dy4;
+	var dy5;
+	var dy6;
+	var dy7;
+	var dy8;
+	var dy9;
+	var sh;
+	var S0;
+	var S1;
+	var S2;
+	var S3;
+	var S4;
+	var S5;
+	var S6;
+	var S7;
+	var S8;
+	var S9;
+	var sy;
+	var iy;
+	var i0;
+	var i1;
+	var i2;
+	var i3;
+	var i4;
+	var i5;
+	var i6;
+	var i7;
+	var i8;
+	var i9;
+
+	// Note on variable naming convention: S#, dy#, i# where # corresponds to the loop number, with `0` being the innermost loop...
+
+	// Extract loop variables for purposes of loop interchange: dimensions and loop offset (pointer) increments...
+	sh = y.shape;
+	sy = y.strides;
+	if ( isRowMajor ) {
+		// For row-major ndarrays, the last dimensions have the fastest changing indices...
+		S0 = sh[ 9 ];
+		S1 = sh[ 8 ];
+		S2 = sh[ 7 ];
+		S3 = sh[ 6 ];
+		S4 = sh[ 5 ];
+		S5 = sh[ 4 ];
+		S6 = sh[ 3 ];
+		S7 = sh[ 2 ];
+		S8 = sh[ 1 ];
+		S9 = sh[ 0 ];
+		dy0 = sy[ 9 ];                // offset increment for innermost loop
+		dy1 = sy[ 8 ] - ( S0*sy[9] );
+		dy2 = sy[ 7 ] - ( S1*sy[8] );
+		dy3 = sy[ 6 ] - ( S2*sy[7] );
+		dy4 = sy[ 5 ] - ( S3*sy[6] );
+		dy5 = sy[ 4 ] - ( S4*sy[5] );
+		dy6 = sy[ 3 ] - ( S5*sy[4] );
+		dy7 = sy[ 2 ] - ( S6*sy[3] );
+		dy8 = sy[ 1 ] - ( S7*sy[2] );
+		dy9 = sy[ 0 ] - ( S8*sy[1] ); // offset increment for outermost loop
+	} else { // order === 'column-major'
+		// For column-major ndarrays, the first dimensions have the fastest changing indices...
+		S0 = sh[ 0 ];
+		S1 = sh[ 1 ];
+		S2 = sh[ 2 ];
+		S3 = sh[ 3 ];
+		S4 = sh[ 4 ];
+		S5 = sh[ 5 ];
+		S6 = sh[ 6 ];
+		S7 = sh[ 7 ];
+		S8 = sh[ 8 ];
+		S9 = sh[ 9 ];
+		dy0 = sy[ 0 ];                // offset increment for innermost loop
+		dy1 = sy[ 1 ] - ( S0*sy[0] );
+		dy2 = sy[ 2 ] - ( S1*sy[1] );
+		dy3 = sy[ 3 ] - ( S2*sy[2] );
+		dy4 = sy[ 4 ] - ( S3*sy[3] );
+		dy5 = sy[ 5 ] - ( S4*sy[4] );
+		dy6 = sy[ 6 ] - ( S5*sy[5] );
+		dy7 = sy[ 7 ] - ( S6*sy[6] );
+		dy8 = sy[ 8 ] - ( S7*sy[7] );
+		dy9 = sy[ 9 ] - ( S8*sy[8] ); // offset increment for outermost loop
+	}
+	// Set a pointer to the first indexed element in the output ndarray:
+	iy = y.offset;
+
+	// Cache a reference to the output ndarray buffer:
+	ybuf = y.data;
+
+	// Iterate over the ndarray dimensions...
+	for ( i9 = 0; i9 < S9; i9++ ) {
+		for ( i8 = 0; i8 < S8; i8++ ) {
+			for ( i7 = 0; i7 < S7; i7++ ) {
+				for ( i6 = 0; i6 < S6; i6++ ) {
+					for ( i5 = 0; i5 < S5; i5++ ) {
+						for ( i4 = 0; i4 < S4; i4++ ) {
+							for ( i3 = 0; i3 < S3; i3++ ) {
+								for ( i2 = 0; i2 < S2; i2++ ) {
+									for ( i1 = 0; i1 < S1; i1++ ) {
+										for ( i0 = 0; i0 < S0; i0++ ) {
+											ybuf[ iy ] = re;
+											ybuf[ iy+1 ] = im;
+											iy += dy0;
+										}
+										iy += dy1;
+									}
+									iy += dy2;
+								}
+								iy += dy3;
+							}
+							iy += dy4;
+						}
+						iy += dy5;
+					}
+					iy += dy6;
+				}
+				iy += dy7;
+			}
+			iy += dy8;
+		}
+		iy += dy9;
+	}
+}
+
+
+// EXPORTS //
+
+module.exports = assign10d;
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/1d_complex.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/1d_complex.js
new file mode 100644
index 000000000000..aa510c29dd6b
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/1d_complex.js
@@ -0,0 +1,97 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2026 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';
+
+// MAIN //
+
+/**
+* Assigns a scalar value to every element of a reinterpreted complex number one-dimensional output ndarray.
+*
+* @private
+* @param {number} re - real component
+* @param {number} im - imaginary component
+* @param {Object} y - object containing output ndarray meta data
+* @param {*} y.dtype - data type
+* @param {Collection} y.data - data buffer
+* @param {NonNegativeIntegerArray} y.shape - dimensions
+* @param {IntegerArray} y.strides - stride lengths
+* @param {NonNegativeInteger} y.offset - index offset
+* @param {string} y.order - specifies whether `y` is row-major (C-style) or column-major (Fortran-style)
+* @returns {void}
+*
+* @example
+* var Float64Array = require( '@stdlib/array/float64' );
+*
+* // Create a data buffer:
+* var ybuf = new Float64Array( 12 );
+*
+* // Define the shape of the output array:
+* var shape = [ 6 ];
+*
+* // Define the array strides:
+* var sy = [ 2 ];
+*
+* // Define the index offset:
+* var oy = 0;
+*
+* // Create the output ndarray-like object:
+* var y = {
+*     'dtype': 'float64',
+*     'data': ybuf,
+*     'shape': shape,
+*     'strides': sy,
+*     'offset': oy,
+*     'order': 'row-major'
+* };
+*
+* // Assign scalar:
+* assign1d( 2.0, 2.0, y );
+*
+* console.log( y.data );
+* // => <Float64Array>[ 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0 ]
+*/
+function assign1d( re, im, y ) {
+	var ybuf;
+	var dy0;
+	var S0;
+	var iy;
+	var i0;
+
+	// Extract loop variables: dimensions and loop offset (pointer) increments:
+	S0 = y.shape[ 0 ];
+	dy0 = y.strides[ 0 ];
+
+	// Set a pointer to the first indexed element in the output ndarray:
+	iy = y.offset;
+
+	// Cache a reference to the output ndarray buffer:
+	ybuf = y.data;
+
+	// Iterate over the ndarray dimensions...
+	for ( i0 = 0; i0 < S0; i0++ ) {
+		ybuf[ iy ] = re;
+		ybuf[ iy+1 ] = im;
+		iy += dy0;
+	}
+}
+
+
+// EXPORTS //
+
+module.exports = assign1d;
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/2d.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/2d.js
index 585e58d51713..a1774bfdbded 100644
--- a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/2d.js
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/2d.js
@@ -84,7 +84,6 @@
 * // => <Float64Array>[ 2.0, 2.0, 2.0, 2.0, 2.0, 2.0 ]
 */
 function assign2d( x, y, isRowMajor ) {
-	var xbuf;
 	var ybuf;
 	var dy0;
 	var dy1;
@@ -92,10 +91,10 @@ function assign2d( x, y, isRowMajor ) {
 	var S0;
 	var S1;
 	var sy;
-	var ix;
 	var iy;
 	var i0;
 	var i1;
+	var v;
 
 	// Note on variable naming convention: S#, dy#, i# where # corresponds to the loop number, with `0` being the innermost loop...
 
@@ -106,27 +105,28 @@ function assign2d( x, y, isRowMajor ) {
 		// For row-major ndarrays, the last dimensions have the fastest changing indices...
 		S0 = sh[ 1 ];
 		S1 = sh[ 0 ];
-		dy0 = sy[ 1 ];
-		dy1 = sy[ 0 ] - ( S0*sy[1] );
+		dy0 = sy[ 1 ];                // offset increment for innermost loop
+		dy1 = sy[ 0 ] - ( S0*sy[1] ); // offset increment for outermost loop
 	} else { // order === 'column-major'
 		// For column-major ndarrays, the first dimensions have the fastest changing indices...
 		S0 = sh[ 0 ];
 		S1 = sh[ 1 ];
-		dy0 = sy[ 0 ];
-		dy1 = sy[ 1 ] - ( S0*sy[0] );
+		dy0 = sy[ 0 ];                // offset increment for innermost loop
+		dy1 = sy[ 1 ] - ( S0*sy[0] ); // offset increment for outermost loop
 	}
-	// Set the pointers to the first indexed elements in the respective ndarrays...
-	ix = x.offset;
+	// Set a pointer to the first indexed element in the output ndarray:
 	iy = y.offset;
 
-	// Cache references to the input and output ndarray buffers...
-	xbuf = x.data;
+	// Cache a reference to the output ndarray buffer:
 	ybuf = y.data;
 
+	// Cache the scalar value:
+	v = x.data[ x.offset ];
+
 	// Iterate over the ndarray dimensions...
 	for ( i1 = 0; i1 < S1; i1++ ) {
 		for ( i0 = 0; i0 < S0; i0++ ) {
-			ybuf[ iy ] = xbuf[ ix ];
+			ybuf[ iy ] = v;
 			iy += dy0;
 		}
 		iy += dy1;
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/2d_accessors.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/2d_accessors.js
index e9fed639a1f6..af8ffa3ab5b7 100644
--- a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/2d_accessors.js
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/2d_accessors.js
@@ -50,11 +50,11 @@
 * var imagf = require( '@stdlib/complex/float32/imag' );
 *
 * // Create data buffers:
-* var xbuf = new Complex64Array( [ 1.0, 2.0 ] );
-* var ybuf = new Complex64Array( 4 );
+* var xbuf = new Complex64Array( [ 2.0, 2.0 ] );
+* var ybuf = new Complex64Array( 6 );
 *
 * // Define the shape of the output array:
-* var shape = [ 2, 2 ];
+* var shape = [ 3, 2 ];
 *
 * // Define the array strides:
 * var sx = [ 0 ];
@@ -99,15 +99,13 @@
 * var v = y.data.get( 0 );
 *
 * var re = realf( v );
-* // returns 1.0
+* // returns 2.0
 *
 * var im = imagf( v );
 * // returns 2.0
 */
 function assign2d( x, y, isRowMajor ) {
-	var xbuf;
 	var ybuf;
-	var get;
 	var set;
 	var dy0;
 	var dy1;
@@ -115,10 +113,10 @@ function assign2d( x, y, isRowMajor ) {
 	var S0;
 	var S1;
 	var sy;
-	var ix;
 	var iy;
 	var i0;
 	var i1;
+	var v;
 
 	// Note on variable naming convention: S#, dy#, i# where # corresponds to the loop number, with `0` being the innermost loop...
 
@@ -129,31 +127,31 @@ function assign2d( x, y, isRowMajor ) {
 		// For row-major ndarrays, the last dimensions have the fastest changing indices...
 		S0 = sh[ 1 ];
 		S1 = sh[ 0 ];
-		dy0 = sy[ 1 ];
-		dy1 = sy[ 0 ] - ( S0*sy[1] );
+		dy0 = sy[ 1 ];                // offset increment for innermost loop
+		dy1 = sy[ 0 ] - ( S0*sy[1] ); // offset increment for outermost loop
 	} else { // order === 'column-major'
 		// For column-major ndarrays, the first dimensions have the fastest changing indices...
 		S0 = sh[ 0 ];
 		S1 = sh[ 1 ];
-		dy0 = sy[ 0 ];
-		dy1 = sy[ 1 ] - ( S0*sy[0] );
+		dy0 = sy[ 0 ];                // offset increment for innermost loop
+		dy1 = sy[ 1 ] - ( S0*sy[0] ); // offset increment for outermost loop
 	}
-	// Set the pointers to the first indexed elements in the respective ndarrays...
-	ix = x.offset;
+	// Set a pointer to the first indexed element in the output ndarray:
 	iy = y.offset;
 
-	// Cache references to the input and output ndarray buffers...
-	xbuf = x.data;
+	// Cache a reference to the output ndarray buffer:
 	ybuf = y.data;
 
-	// Cache accessors:
-	get = x.accessors[ 0 ];
+	// Cache the output accessor:
 	set = y.accessors[ 1 ];
 
+	// Cache the scalar value:
+	v = x.accessors[ 0 ]( x.data, x.offset );
+
 	// Iterate over the ndarray dimensions...
 	for ( i1 = 0; i1 < S1; i1++ ) {
 		for ( i0 = 0; i0 < S0; i0++ ) {
-			set( ybuf, iy, get( xbuf, ix ) );
+			set( ybuf, iy, v );
 			iy += dy0;
 		}
 		iy += dy1;
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/2d_blocked.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/2d_blocked.js
index 3b27f5fe1e71..0e318c0e8c32 100644
--- a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/2d_blocked.js
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/2d_blocked.js
@@ -90,7 +90,6 @@ var blockSize = require( '@stdlib/ndarray/base/nullary-tiling-block-size' );
 */
 function blockedassign2d( x, y ) {
 	var bsize;
-	var xbuf;
 	var ybuf;
 	var dy0;
 	var dy1;
@@ -100,13 +99,13 @@ function blockedassign2d( x, y ) {
 	var s1;
 	var sy;
 	var oy;
-	var ix;
 	var iy;
 	var i0;
 	var i1;
 	var j0;
 	var j1;
 	var o;
+	var v;
 
 	// Note on variable naming convention: s#, dy#, i#, j# where # corresponds to the loop number, with `0` being the innermost loop...
 
@@ -118,15 +117,16 @@ function blockedassign2d( x, y ) {
 	// Determine the block size:
 	bsize = blockSize( y.dtype );
 
-	// Cache the indices of the first indexed elements in the respective ndarrays...
-	ix = x.offset;
+	// Cache the index of the first indexed element in the output ndarray:
 	oy = y.offset;
 
-	// Cache references to the input and output ndarray buffers...
-	xbuf = x.data;
+	// Cache a reference to the output ndarray buffer:
 	ybuf = y.data;
 
-	// Cache the offset increment for the innermost loop...
+	// Cache the scalar value:
+	v = x.data[ x.offset ];
+
+	// Cache the offset increment for the innermost loop:
 	dy0 = sy[0];
 
 	// Iterate over blocks...
@@ -156,7 +156,7 @@ function blockedassign2d( x, y ) {
 			// Iterate over the ndarray dimensions...
 			for ( i1 = 0; i1 < s1; i1++ ) {
 				for ( i0 = 0; i0 < s0; i0++ ) {
-					ybuf[ iy ] = xbuf[ ix ];
+					ybuf[ iy ] = v;
 					iy += dy0;
 				}
 				iy += dy1;
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/2d_blocked_accessors.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/2d_blocked_accessors.js
index 3d80d5ef0049..224c72a5e3b3 100644
--- a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/2d_blocked_accessors.js
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/2d_blocked_accessors.js
@@ -55,14 +55,14 @@ var blockSize = require( '@stdlib/ndarray/base/nullary-tiling-block-size' );
 * var imagf = require( '@stdlib/complex/float32/imag' );
 *
 * // Create data buffers:
-* var xbuf = new Complex64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 ] );
-* var ybuf = new Complex64Array( 4 );
+* var xbuf = new Complex64Array( [ 2.0, 2.0 ] );
+* var ybuf = new Complex64Array( 6 );
 *
-* // Define the shape of the input and output arrays:
-* var shape = [ 2, 2 ];
+* // Define the shape of the output array:
+* var shape = [ 3, 2 ];
 *
 * // Define the array strides:
-* var sx = [ 2, 1 ];
+* var sx = [ 0 ];
 * var sy = [ 2, 1 ];
 *
 * // Define the index offsets:
@@ -82,7 +82,7 @@ var blockSize = require( '@stdlib/ndarray/base/nullary-tiling-block-size' );
 * var x = {
 *     'dtype': 'complex64',
 *     'data': xbuf,
-*     'shape': shape,
+*     'shape': [],
 *     'strides': sx,
 *     'offset': ox,
 *     'order': 'row-major',
@@ -98,22 +98,20 @@ var blockSize = require( '@stdlib/ndarray/base/nullary-tiling-block-size' );
 *     'accessors': [ getter, setter ]
 * };
 *
-* // Copy elements:
+* // Assign scalar:
 * blockedassign2d( x, y );
 *
 * var v = y.data.get( 0 );
 *
 * var re = realf( v );
-* // returns 1.0
+* // returns 2.0
 *
 * var im = imagf( v );
 * // returns 2.0
 */
 function blockedassign2d( x, y ) {
 	var bsize;
-	var xbuf;
 	var ybuf;
-	var get;
 	var set;
 	var dy0;
 	var dy1;
@@ -123,13 +121,13 @@ function blockedassign2d( x, y ) {
 	var s1;
 	var sy;
 	var oy;
-	var ix;
 	var iy;
 	var i0;
 	var i1;
 	var j0;
 	var j1;
 	var o;
+	var v;
 
 	// Note on variable naming convention: s#, dy#, i#, j# where # corresponds to the loop number, with `0` being the innermost loop...
 
@@ -141,20 +139,20 @@ function blockedassign2d( x, y ) {
 	// Determine the block size:
 	bsize = blockSize( y.dtype );
 
-	// Cache the indices of the first indexed elements in the respective ndarrays...
-	ix = x.offset;
+	// Cache the index of the first indexed element in the output ndarray:
 	oy = y.offset;
 
-	// Cache references to the input and output ndarray buffers...
-	xbuf = x.data;
+	// Cache a reference to the output ndarray buffer:
 	ybuf = y.data;
 
-	// Cache the offset increment for the innermost loop...
+	// Cache the offset increment for the innermost loop:
 	dy0 = sy[0];
 
-	// Cache accessors:
-	get = x.accessors[0];
-	set = y.accessors[1];
+	// Cache the output accessor:
+	set = y.accessors[ 1 ];
+
+	// Cache the scalar value:
+	v = x.accessors[ 0 ]( x.data, x.offset );
 
 	// Iterate over blocks...
 	for ( j1 = sh[1]; j1 > 0; ) {
@@ -183,7 +181,7 @@ function blockedassign2d( x, y ) {
 			// Iterate over the ndarray dimensions...
 			for ( i1 = 0; i1 < s1; i1++ ) {
 				for ( i0 = 0; i0 < s0; i0++ ) {
-					set( ybuf, iy, get( xbuf, ix ) );
+					set( ybuf, iy, v );
 					iy += dy0;
 				}
 				iy += dy1;
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/3d.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/3d.js
index 50b64e00e4e6..b5d87f88936a 100644
--- a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/3d.js
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/3d.js
@@ -84,7 +84,6 @@
 * // => <Float64Array>[ 2.0, 2.0, 2.0, 2.0, 2.0, 2.0 ]
 */
 function assign3d( x, y, isRowMajor ) {
-	var xbuf;
 	var ybuf;
 	var dy0;
 	var dy1;
@@ -94,11 +93,11 @@ function assign3d( x, y, isRowMajor ) {
 	var S1;
 	var S2;
 	var sy;
-	var ix;
 	var iy;
 	var i0;
 	var i1;
 	var i2;
+	var v;
 
 	// Note on variable naming convention: S#, dy#, i# where # corresponds to the loop number, with `0` being the innermost loop...
 
@@ -110,31 +109,32 @@ function assign3d( x, y, isRowMajor ) {
 		S0 = sh[ 2 ];
 		S1 = sh[ 1 ];
 		S2 = sh[ 0 ];
-		dy0 = sy[ 2 ];
+		dy0 = sy[ 2 ];                // offset increment for innermost loop
 		dy1 = sy[ 1 ] - ( S0*sy[2] );
-		dy2 = sy[ 0 ] - ( S1*sy[1] );
+		dy2 = sy[ 0 ] - ( S1*sy[1] ); // offset increment for outermost loop
 	} else { // order === 'column-major'
 		// For column-major ndarrays, the first dimensions have the fastest changing indices...
 		S0 = sh[ 0 ];
 		S1 = sh[ 1 ];
 		S2 = sh[ 2 ];
-		dy0 = sy[ 0 ];
+		dy0 = sy[ 0 ];                // offset increment for innermost loop
 		dy1 = sy[ 1 ] - ( S0*sy[0] );
-		dy2 = sy[ 2 ] - ( S1*sy[1] );
+		dy2 = sy[ 2 ] - ( S1*sy[1] ); // offset increment for outermost loop
 	}
-	// Set the pointers to the first indexed elements in the respective ndarrays...
-	ix = x.offset;
+	// Set a pointer to the first indexed element in the output ndarray:
 	iy = y.offset;
 
-	// Cache references to the input and output ndarray buffers...
-	xbuf = x.data;
+	// Cache a reference to the output ndarray buffer:
 	ybuf = y.data;
 
+	// Cache the scalar value:
+	v = x.data[ x.offset ];
+
 	// Iterate over the ndarray dimensions...
 	for ( i2 = 0; i2 < S2; i2++ ) {
 		for ( i1 = 0; i1 < S1; i1++ ) {
 			for ( i0 = 0; i0 < S0; i0++ ) {
-				ybuf[ iy ] = xbuf[ ix ];
+				ybuf[ iy ] = v;
 				iy += dy0;
 			}
 			iy += dy1;
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/3d_accessors.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/3d_accessors.js
index 1157a487bb92..b67b5852fb94 100644
--- a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/3d_accessors.js
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/3d_accessors.js
@@ -105,9 +105,7 @@
 * // returns 2.0
 */
 function assign3d( x, y, isRowMajor ) {
-	var xbuf;
 	var ybuf;
-	var get;
 	var set;
 	var dy0;
 	var dy1;
@@ -117,11 +115,11 @@ function assign3d( x, y, isRowMajor ) {
 	var S1;
 	var S2;
 	var sy;
-	var ix;
 	var iy;
 	var i0;
 	var i1;
 	var i2;
+	var v;
 
 	// Note on variable naming convention: S#, dy#, i# where # corresponds to the loop number, with `0` being the innermost loop...
 
@@ -133,35 +131,35 @@ function assign3d( x, y, isRowMajor ) {
 		S0 = sh[ 2 ];
 		S1 = sh[ 1 ];
 		S2 = sh[ 0 ];
-		dy0 = sy[ 2 ];
+		dy0 = sy[ 2 ];                // offset increment for innermost loop
 		dy1 = sy[ 1 ] - ( S0*sy[2] );
-		dy2 = sy[ 0 ] - ( S1*sy[1] );
+		dy2 = sy[ 0 ] - ( S1*sy[1] ); // offset increment for outermost loop
 	} else { // order === 'column-major'
 		// For column-major ndarrays, the first dimensions have the fastest changing indices...
 		S0 = sh[ 0 ];
 		S1 = sh[ 1 ];
 		S2 = sh[ 2 ];
-		dy0 = sy[ 0 ];
+		dy0 = sy[ 0 ];                // offset increment for innermost loop
 		dy1 = sy[ 1 ] - ( S0*sy[0] );
-		dy2 = sy[ 2 ] - ( S1*sy[1] );
+		dy2 = sy[ 2 ] - ( S1*sy[1] ); // offset increment for outermost loop
 	}
-	// Set the pointers to the first indexed elements in the respective ndarrays...
-	ix = x.offset;
+	// Set a pointer to the first indexed element in the output ndarray:
 	iy = y.offset;
 
-	// Cache references to the input and output ndarray buffers...
-	xbuf = x.data;
+	// Cache a reference to the output ndarray buffer:
 	ybuf = y.data;
 
-	// Cache accessors:
-	get = x.accessors[ 0 ];
+	// Cache the output accessor:
 	set = y.accessors[ 1 ];
 
+	// Cache the scalar value:
+	v = x.accessors[ 0 ]( x.data, x.offset );
+
 	// Iterate over the ndarray dimensions...
 	for ( i2 = 0; i2 < S2; i2++ ) {
 		for ( i1 = 0; i1 < S1; i1++ ) {
 			for ( i0 = 0; i0 < S0; i0++ ) {
-				set( ybuf, iy, get( xbuf, ix ) );
+				set( ybuf, iy, v );
 				iy += dy0;
 			}
 			iy += dy1;
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/3d_blocked.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/3d_blocked.js
index 04eda54aa149..e9d12bcb35d5 100644
--- a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/3d_blocked.js
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/3d_blocked.js
@@ -92,7 +92,6 @@ var blockSize = require( '@stdlib/ndarray/base/nullary-tiling-block-size' );
 */
 function blockedassign3d( x, y ) {
 	var bsize;
-	var xbuf;
 	var ybuf;
 	var dy0;
 	var dy1;
@@ -105,7 +104,6 @@ function blockedassign3d( x, y ) {
 	var s2;
 	var sy;
 	var oy;
-	var ix;
 	var iy;
 	var i0;
 	var i1;
@@ -114,6 +112,7 @@ function blockedassign3d( x, y ) {
 	var j1;
 	var j2;
 	var o;
+	var v;
 
 	// Note on variable naming convention: s#, dy#, i#, j# where # corresponds to the loop number, with `0` being the innermost loop...
 
@@ -125,15 +124,16 @@ function blockedassign3d( x, y ) {
 	// Determine the block size:
 	bsize = blockSize( y.dtype );
 
-	// Cache the indices of the first indexed elements in the respective ndarrays...
-	ix = x.offset;
+	// Cache the index of the first indexed element in the output ndarray:
 	oy = y.offset;
 
-	// Cache references to the input and output ndarray buffers...
-	xbuf = x.data;
+	// Cache a reference to the output ndarray buffer:
 	ybuf = y.data;
 
-	// Cache the offset increment for the innermost loop...
+	// Cache the scalar value:
+	v = x.data[ x.offset ];
+
+	// Cache the offset increment for the innermost loop:
 	dy0 = sy[0];
 
 	// Iterate over blocks...
@@ -174,7 +174,7 @@ function blockedassign3d( x, y ) {
 				for ( i2 = 0; i2 < s2; i2++ ) {
 					for ( i1 = 0; i1 < s1; i1++ ) {
 						for ( i0 = 0; i0 < s0; i0++ ) {
-							ybuf[ iy ] = xbuf[ ix ];
+							ybuf[ iy ] = v;
 							iy += dy0;
 						}
 						iy += dy1;
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/3d_blocked_accessors.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/3d_blocked_accessors.js
index 9d5dccc1579a..6a5c113079e8 100644
--- a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/3d_blocked_accessors.js
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/3d_blocked_accessors.js
@@ -60,7 +60,7 @@ var blockSize = require( '@stdlib/ndarray/base/nullary-tiling-block-size' );
 * var xbuf = new Complex64Array( [ 2.0, 2.0 ] );
 * var ybuf = new Complex64Array( 6 );
 *
-* // Define the shape of the input and output arrays:
+* // Define the shape of the output array:
 * var shape = [ 3, 1, 2 ];
 *
 * // Define the array strides:
@@ -100,7 +100,7 @@ var blockSize = require( '@stdlib/ndarray/base/nullary-tiling-block-size' );
 *     'accessors': [ getter, setter ]
 * };
 *
-* // Copy elements:
+* // Assign scalar:
 * blockedassign3d( x, y );
 *
 * var v = y.data.get( 0 );
@@ -113,9 +113,7 @@ var blockSize = require( '@stdlib/ndarray/base/nullary-tiling-block-size' );
 */
 function blockedassign3d( x, y ) {
 	var bsize;
-	var xbuf;
 	var ybuf;
-	var get;
 	var set;
 	var dy0;
 	var dy1;
@@ -128,7 +126,6 @@ function blockedassign3d( x, y ) {
 	var s2;
 	var sy;
 	var oy;
-	var ix;
 	var iy;
 	var i0;
 	var i1;
@@ -137,6 +134,7 @@ function blockedassign3d( x, y ) {
 	var j1;
 	var j2;
 	var o;
+	var v;
 
 	// Note on variable naming convention: s#, dy#, i#, j# where # corresponds to the loop number, with `0` being the innermost loop...
 
@@ -148,20 +146,20 @@ function blockedassign3d( x, y ) {
 	// Determine the block size:
 	bsize = blockSize( y.dtype );
 
-	// Cache the indices of the first indexed elements in the respective ndarrays...
-	ix = x.offset;
+	// Cache the index of the first indexed element in the output ndarray:
 	oy = y.offset;
 
-	// Cache references to the input and output ndarray buffers...
-	xbuf = x.data;
+	// Cache a reference to the output ndarray buffer:
 	ybuf = y.data;
 
-	// Cache the offset increment for the innermost loop...
+	// Cache the offset increment for the innermost loop:
 	dy0 = sy[0];
 
-	// Cache accessors:
-	get = x.accessors[0];
-	set = y.accessors[1];
+	// Cache the output accessor:
+	set = y.accessors[ 1 ];
+
+	// Cache the scalar value:
+	v = x.accessors[ 0 ]( x.data, x.offset );
 
 	// Iterate over blocks...
 	for ( j2 = sh[2]; j2 > 0; ) {
@@ -201,7 +199,7 @@ function blockedassign3d( x, y ) {
 				for ( i2 = 0; i2 < s2; i2++ ) {
 					for ( i1 = 0; i1 < s1; i1++ ) {
 						for ( i0 = 0; i0 < s0; i0++ ) {
-							set( ybuf, iy, get( xbuf, ix ) );
+							set( ybuf, iy, v );
 							iy += dy0;
 						}
 						iy += dy1;
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/3d_blocked_complex.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/3d_blocked_complex.js
new file mode 100644
index 000000000000..c5f071f436e9
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/3d_blocked_complex.js
@@ -0,0 +1,173 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2026 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-depth */
+
+'use strict';
+
+// MODULES //
+
+var loopOrder = require( '@stdlib/ndarray/base/nullary-loop-interchange-order' );
+var blockSize = require( '@stdlib/ndarray/base/nullary-tiling-block-size' );
+
+
+// MAIN //
+
+/**
+* Assigns a scalar value to every element of a reinterpreted complex number three-dimensional output ndarray via loop blocking.
+*
+* @private
+* @param {number} re - real component
+* @param {number} im - imaginary component
+* @param {Object} y - object containing output ndarray meta data
+* @param {*} y.dtype - data type
+* @param {Collection} y.data - data buffer
+* @param {NonNegativeIntegerArray} y.shape - dimensions
+* @param {IntegerArray} y.strides - stride lengths
+* @param {NonNegativeInteger} y.offset - index offset
+* @param {string} y.order - specifies whether `y` is row-major (C-style) or column-major (Fortran-style)
+* @returns {void}
+*
+* @example
+* var Float64Array = require( '@stdlib/array/float64' );
+*
+* // Create a data buffer:
+* var ybuf = new Float64Array( 12 );
+*
+* // Define the shape of the output array:
+* var shape = [ 3, 1, 2 ];
+*
+* // Define the array strides:
+* var sy = [ 4, 4, 2 ];
+*
+* // Define the index offset:
+* var oy = 0;
+*
+* // Create the output ndarray-like object:
+* var y = {
+*     'dtype': 'float64',
+*     'data': ybuf,
+*     'shape': shape,
+*     'strides': sy,
+*     'offset': oy,
+*     'order': 'row-major'
+* };
+*
+* // Assign scalar:
+* blockedassign3d( 2.0, 2.0, y );
+*
+* console.log( y.data );
+* // => <Float64Array>[ 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0 ]
+*/
+function blockedassign3d( re, im, y ) {
+	var bsize;
+	var ybuf;
+	var dy0;
+	var dy1;
+	var dy2;
+	var oy1;
+	var oy2;
+	var sh;
+	var s0;
+	var s1;
+	var s2;
+	var sy;
+	var oy;
+	var iy;
+	var i0;
+	var i1;
+	var i2;
+	var j0;
+	var j1;
+	var j2;
+	var o;
+
+	// Note on variable naming convention: s#, dy#, i#, j# where # corresponds to the loop number, with `0` being the innermost loop...
+
+	// Resolve the loop interchange order:
+	o = loopOrder( y.shape, y.strides );
+	sh = o.sh;
+	sy = o.sx;
+
+	// Determine the block size:
+	bsize = blockSize( y.dtype );
+
+	// Cache the index of the first indexed element in the output ndarray:
+	oy = y.offset;
+
+	// Cache a reference to the output ndarray buffer:
+	ybuf = y.data;
+
+	// Cache the offset increment for the innermost loop:
+	dy0 = sy[0];
+
+	// Iterate over blocks...
+	for ( j2 = sh[2]; j2 > 0; ) {
+		if ( j2 < bsize ) {
+			s2 = j2;
+			j2 = 0;
+		} else {
+			s2 = bsize;
+			j2 -= bsize;
+		}
+		oy2 = oy + ( j2*sy[2] );
+		for ( j1 = sh[1]; j1 > 0; ) {
+			if ( j1 < bsize ) {
+				s1 = j1;
+				j1 = 0;
+			} else {
+				s1 = bsize;
+				j1 -= bsize;
+			}
+			dy2 = sy[2] - ( s1*sy[1] );
+			oy1 = oy2 + ( j1*sy[1] );
+			for ( j0 = sh[0]; j0 > 0; ) {
+				if ( j0 < bsize ) {
+					s0 = j0;
+					j0 = 0;
+				} else {
+					s0 = bsize;
+					j0 -= bsize;
+				}
+				// Compute the index offset for the first output ndarray element in the current block...
+				iy = oy1 + ( j0*sy[0] );
+
+				// Compute the loop offset increment...
+				dy1 = sy[1] - ( s0*sy[0] );
+
+				// Iterate over the ndarray dimensions...
+				for ( i2 = 0; i2 < s2; i2++ ) {
+					for ( i1 = 0; i1 < s1; i1++ ) {
+						for ( i0 = 0; i0 < s0; i0++ ) {
+							ybuf[ iy ] = re;
+							ybuf[ iy+1 ] = im;
+							iy += dy0;
+						}
+						iy += dy1;
+					}
+					iy += dy2;
+				}
+			}
+		}
+	}
+}
+
+
+// EXPORTS //
+
+module.exports = blockedassign3d;
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/3d_complex.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/3d_complex.js
new file mode 100644
index 000000000000..8f88ace8683f
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/3d_complex.js
@@ -0,0 +1,130 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2026 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';
+
+// MAIN //
+
+/**
+* Assigns a scalar value to every element of a reinterpreted complex number three-dimensional output ndarray.
+*
+* @private
+* @param {number} re - real component
+* @param {number} im - imaginary component
+* @param {Object} y - object containing output ndarray meta data
+* @param {*} y.dtype - data type
+* @param {Collection} y.data - data buffer
+* @param {NonNegativeIntegerArray} y.shape - dimensions
+* @param {IntegerArray} y.strides - stride lengths
+* @param {NonNegativeInteger} y.offset - index offset
+* @param {string} y.order - specifies whether `y` is row-major (C-style) or column-major (Fortran-style)
+* @param {boolean} isRowMajor - boolean indicating if provided arrays are in row-major order
+* @returns {void}
+*
+* @example
+* var Float64Array = require( '@stdlib/array/float64' );
+*
+* // Create a data buffer:
+* var ybuf = new Float64Array( 12 );
+*
+* // Define the shape of the output array:
+* var shape = [ 3, 1, 2 ];
+*
+* // Define the array strides:
+* var sy = [ 4, 4, 2 ];
+*
+* // Define the index offset:
+* var oy = 0;
+*
+* // Create the output ndarray-like object:
+* var y = {
+*     'dtype': 'float64',
+*     'data': ybuf,
+*     'shape': shape,
+*     'strides': sy,
+*     'offset': oy,
+*     'order': 'row-major'
+* };
+*
+* // Assign scalar:
+* assign3d( 2.0, 2.0, y, true );
+*
+* console.log( y.data );
+* // => <Float64Array>[ 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0 ]
+*/
+function assign3d( re, im, y, isRowMajor ) {
+	var ybuf;
+	var dy0;
+	var dy1;
+	var dy2;
+	var sh;
+	var S0;
+	var S1;
+	var S2;
+	var sy;
+	var iy;
+	var i0;
+	var i1;
+	var i2;
+
+	// Note on variable naming convention: S#, dy#, i# where # corresponds to the loop number, with `0` being the innermost loop...
+
+	// Extract loop variables for purposes of loop interchange: dimensions and loop offset (pointer) increments...
+	sh = y.shape;
+	sy = y.strides;
+	if ( isRowMajor ) {
+		// For row-major ndarrays, the last dimensions have the fastest changing indices...
+		S0 = sh[ 2 ];
+		S1 = sh[ 1 ];
+		S2 = sh[ 0 ];
+		dy0 = sy[ 2 ];                // offset increment for innermost loop
+		dy1 = sy[ 1 ] - ( S0*sy[2] );
+		dy2 = sy[ 0 ] - ( S1*sy[1] ); // offset increment for outermost loop
+	} else { // order === 'column-major'
+		// For column-major ndarrays, the first dimensions have the fastest changing indices...
+		S0 = sh[ 0 ];
+		S1 = sh[ 1 ];
+		S2 = sh[ 2 ];
+		dy0 = sy[ 0 ];                // offset increment for innermost loop
+		dy1 = sy[ 1 ] - ( S0*sy[0] );
+		dy2 = sy[ 2 ] - ( S1*sy[1] ); // offset increment for outermost loop
+	}
+	// Set a pointer to the first indexed element in the output ndarray:
+	iy = y.offset;
+
+	// Cache a reference to the output ndarray buffer:
+	ybuf = y.data;
+
+	// Iterate over the ndarray dimensions...
+	for ( i2 = 0; i2 < S2; i2++ ) {
+		for ( i1 = 0; i1 < S1; i1++ ) {
+			for ( i0 = 0; i0 < S0; i0++ ) {
+				ybuf[ iy ] = re;
+				ybuf[ iy+1 ] = im;
+				iy += dy0;
+			}
+			iy += dy1;
+		}
+		iy += dy2;
+	}
+}
+
+
+// EXPORTS //
+
+module.exports = assign3d;
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/4d.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/4d.js
index 60f14a631a8f..bc5fda8e5fbb 100644
--- a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/4d.js
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/4d.js
@@ -84,7 +84,6 @@
 * // => <Float64Array>[ 2.0, 2.0, 2.0, 2.0, 2.0, 2.0 ]
 */
 function assign4d( x, y, isRowMajor ) {
-	var xbuf;
 	var ybuf;
 	var dy0;
 	var dy1;
@@ -96,12 +95,12 @@ function assign4d( x, y, isRowMajor ) {
 	var S2;
 	var S3;
 	var sy;
-	var ix;
 	var iy;
 	var i0;
 	var i1;
 	var i2;
 	var i3;
+	var v;
 
 	// Note on variable naming convention: S#, dy#, i# where # corresponds to the loop number, with `0` being the innermost loop...
 
@@ -114,35 +113,36 @@ function assign4d( x, y, isRowMajor ) {
 		S1 = sh[ 2 ];
 		S2 = sh[ 1 ];
 		S3 = sh[ 0 ];
-		dy0 = sy[ 3 ];
+		dy0 = sy[ 3 ];                // offset increment for innermost loop
 		dy1 = sy[ 2 ] - ( S0*sy[3] );
 		dy2 = sy[ 1 ] - ( S1*sy[2] );
-		dy3 = sy[ 0 ] - ( S2*sy[1] );
+		dy3 = sy[ 0 ] - ( S2*sy[1] ); // offset increment for outermost loop
 	} else { // order === 'column-major'
 		// For column-major ndarrays, the first dimensions have the fastest changing indices...
 		S0 = sh[ 0 ];
 		S1 = sh[ 1 ];
 		S2 = sh[ 2 ];
 		S3 = sh[ 3 ];
-		dy0 = sy[ 0 ];
+		dy0 = sy[ 0 ];                // offset increment for innermost loop
 		dy1 = sy[ 1 ] - ( S0*sy[0] );
 		dy2 = sy[ 2 ] - ( S1*sy[1] );
-		dy3 = sy[ 3 ] - ( S2*sy[2] );
+		dy3 = sy[ 3 ] - ( S2*sy[2] ); // offset increment for outermost loop
 	}
-	// Set the pointers to the first indexed elements in the respective ndarrays...
-	ix = x.offset;
+	// Set a pointer to the first indexed element in the output ndarray:
 	iy = y.offset;
 
-	// Cache references to the input and output ndarray buffers...
-	xbuf = x.data;
+	// Cache a reference to the output ndarray buffer:
 	ybuf = y.data;
 
+	// Cache the scalar value:
+	v = x.data[ x.offset ];
+
 	// Iterate over the ndarray dimensions...
 	for ( i3 = 0; i3 < S3; i3++ ) {
 		for ( i2 = 0; i2 < S2; i2++ ) {
 			for ( i1 = 0; i1 < S1; i1++ ) {
 				for ( i0 = 0; i0 < S0; i0++ ) {
-					ybuf[ iy ] = xbuf[ ix ];
+					ybuf[ iy ] = v;
 					iy += dy0;
 				}
 				iy += dy1;
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/4d_accessors.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/4d_accessors.js
index 07d7a2e04bb6..bc17db382768 100644
--- a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/4d_accessors.js
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/4d_accessors.js
@@ -105,9 +105,7 @@
 * // returns 2.0
 */
 function assign4d( x, y, isRowMajor ) {
-	var xbuf;
 	var ybuf;
-	var get;
 	var set;
 	var dy0;
 	var dy1;
@@ -119,12 +117,12 @@ function assign4d( x, y, isRowMajor ) {
 	var S2;
 	var S3;
 	var sy;
-	var ix;
 	var iy;
 	var i0;
 	var i1;
 	var i2;
 	var i3;
+	var v;
 
 	// Note on variable naming convention: S#, dy#, i# where # corresponds to the loop number, with `0` being the innermost loop...
 
@@ -137,39 +135,39 @@ function assign4d( x, y, isRowMajor ) {
 		S1 = sh[ 2 ];
 		S2 = sh[ 1 ];
 		S3 = sh[ 0 ];
-		dy0 = sy[ 3 ];
+		dy0 = sy[ 3 ];                // offset increment for innermost loop
 		dy1 = sy[ 2 ] - ( S0*sy[3] );
 		dy2 = sy[ 1 ] - ( S1*sy[2] );
-		dy3 = sy[ 0 ] - ( S2*sy[1] );
+		dy3 = sy[ 0 ] - ( S2*sy[1] ); // offset increment for outermost loop
 	} else { // order === 'column-major'
 		// For column-major ndarrays, the first dimensions have the fastest changing indices...
 		S0 = sh[ 0 ];
 		S1 = sh[ 1 ];
 		S2 = sh[ 2 ];
 		S3 = sh[ 3 ];
-		dy0 = sy[ 0 ];
+		dy0 = sy[ 0 ];                // offset increment for innermost loop
 		dy1 = sy[ 1 ] - ( S0*sy[0] );
 		dy2 = sy[ 2 ] - ( S1*sy[1] );
-		dy3 = sy[ 3 ] - ( S2*sy[2] );
+		dy3 = sy[ 3 ] - ( S2*sy[2] ); // offset increment for outermost loop
 	}
-	// Set the pointers to the first indexed elements in the respective ndarrays...
-	ix = x.offset;
+	// Set a pointer to the first indexed element in the output ndarray:
 	iy = y.offset;
 
-	// Cache references to the input and output ndarray buffers...
-	xbuf = x.data;
+	// Cache a reference to the output ndarray buffer:
 	ybuf = y.data;
 
-	// Cache accessors:
-	get = x.accessors[0];
-	set = y.accessors[1];
+	// Cache the output accessor:
+	set = y.accessors[ 1 ];
+
+	// Cache the scalar value:
+	v = x.accessors[ 0 ]( x.data, x.offset );
 
 	// Iterate over the ndarray dimensions...
 	for ( i3 = 0; i3 < S3; i3++ ) {
 		for ( i2 = 0; i2 < S2; i2++ ) {
 			for ( i1 = 0; i1 < S1; i1++ ) {
 				for ( i0 = 0; i0 < S0; i0++ ) {
-					set( ybuf, iy, get( xbuf, ix ) );
+					set( ybuf, iy, v );
 					iy += dy0;
 				}
 				iy += dy1;
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/4d_blocked.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/4d_blocked.js
index 3c68e156e078..767d5327c9d0 100644
--- a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/4d_blocked.js
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/4d_blocked.js
@@ -92,7 +92,6 @@ var blockSize = require( '@stdlib/ndarray/base/nullary-tiling-block-size' );
 */
 function blockedassign4d( x, y ) {
 	var bsize;
-	var xbuf;
 	var ybuf;
 	var dy0;
 	var dy1;
@@ -108,7 +107,6 @@ function blockedassign4d( x, y ) {
 	var s3;
 	var sy;
 	var oy;
-	var ix;
 	var iy;
 	var i0;
 	var i1;
@@ -119,6 +117,7 @@ function blockedassign4d( x, y ) {
 	var j2;
 	var j3;
 	var o;
+	var v;
 
 	// Note on variable naming convention: s#, dy#, i#, j# where # corresponds to the loop number, with `0` being the innermost loop...
 
@@ -130,15 +129,16 @@ function blockedassign4d( x, y ) {
 	// Determine the block size:
 	bsize = blockSize( y.dtype );
 
-	// Cache the indices of the first indexed elements in the respective ndarrays...
-	ix = x.offset;
+	// Cache the index of the first indexed element in the output ndarray:
 	oy = y.offset;
 
-	// Cache references to the input and output ndarray buffers...
-	xbuf = x.data;
+	// Cache a reference to the output ndarray buffer:
 	ybuf = y.data;
 
-	// Cache the offset increment for the innermost loop...
+	// Cache the scalar value:
+	v = x.data[ x.offset ];
+
+	// Cache the offset increment for the innermost loop:
 	dy0 = sy[0];
 
 	// Iterate over blocks...
@@ -190,7 +190,7 @@ function blockedassign4d( x, y ) {
 						for ( i2 = 0; i2 < s2; i2++ ) {
 							for ( i1 = 0; i1 < s1; i1++ ) {
 								for ( i0 = 0; i0 < s0; i0++ ) {
-									ybuf[ iy ] = xbuf[ ix ];
+									ybuf[ iy ] = v;
 									iy += dy0;
 								}
 								iy += dy1;
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/4d_blocked_accessors.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/4d_blocked_accessors.js
index 3d47475350b0..7d720b8cc71f 100644
--- a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/4d_blocked_accessors.js
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/4d_blocked_accessors.js
@@ -113,9 +113,7 @@ var blockSize = require( '@stdlib/ndarray/base/nullary-tiling-block-size' );
 */
 function blockedassign4d( x, y ) {
 	var bsize;
-	var xbuf;
 	var ybuf;
-	var get;
 	var set;
 	var dy0;
 	var dy1;
@@ -131,7 +129,6 @@ function blockedassign4d( x, y ) {
 	var s3;
 	var sy;
 	var oy;
-	var ix;
 	var iy;
 	var i0;
 	var i1;
@@ -142,6 +139,7 @@ function blockedassign4d( x, y ) {
 	var j2;
 	var j3;
 	var o;
+	var v;
 
 	// Note on variable naming convention: s#, dy#, i#, j# where # corresponds to the loop number, with `0` being the innermost loop...
 
@@ -153,20 +151,20 @@ function blockedassign4d( x, y ) {
 	// Determine the block size:
 	bsize = blockSize( y.dtype );
 
-	// Cache the indices of the first indexed elements in the respective ndarrays...
-	ix = x.offset;
+	// Cache the index of the first indexed element in the output ndarray:
 	oy = y.offset;
 
-	// Cache references to the input and output ndarray buffers...
-	xbuf = x.data;
+	// Cache a reference to the output ndarray buffer:
 	ybuf = y.data;
 
-	// Cache the offset increment for the innermost loop...
+	// Cache the offset increment for the innermost loop:
 	dy0 = sy[0];
 
-	// Cache accessors:
-	get = x.accessors[0];
-	set = y.accessors[1];
+	// Cache the output accessor:
+	set = y.accessors[ 1 ];
+
+	// Cache the scalar value:
+	v = x.accessors[ 0 ]( x.data, x.offset );
 
 	// Iterate over blocks...
 	for ( j3 = sh[3]; j3 > 0; ) {
@@ -217,7 +215,7 @@ function blockedassign4d( x, y ) {
 						for ( i2 = 0; i2 < s2; i2++ ) {
 							for ( i1 = 0; i1 < s1; i1++ ) {
 								for ( i0 = 0; i0 < s0; i0++ ) {
-									set( ybuf, iy, get( xbuf, ix ) );
+									set( ybuf, iy, v );
 									iy += dy0;
 								}
 								iy += dy1;
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/4d_blocked_complex.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/4d_blocked_complex.js
new file mode 100644
index 000000000000..ded2211e384c
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/4d_blocked_complex.js
@@ -0,0 +1,192 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2026 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-depth */
+
+'use strict';
+
+// MODULES //
+
+var loopOrder = require( '@stdlib/ndarray/base/nullary-loop-interchange-order' );
+var blockSize = require( '@stdlib/ndarray/base/nullary-tiling-block-size' );
+
+
+// MAIN //
+
+/**
+* Assigns a scalar value to every element of a reinterpreted complex number four-dimensional output ndarray via loop blocking.
+*
+* @private
+* @param {number} re - real component
+* @param {number} im - imaginary component
+* @param {Object} y - object containing output ndarray meta data
+* @param {*} y.dtype - data type
+* @param {Collection} y.data - data buffer
+* @param {NonNegativeIntegerArray} y.shape - dimensions
+* @param {IntegerArray} y.strides - stride lengths
+* @param {NonNegativeInteger} y.offset - index offset
+* @param {string} y.order - specifies whether `y` is row-major (C-style) or column-major (Fortran-style)
+* @returns {void}
+*
+* @example
+* var Float64Array = require( '@stdlib/array/float64' );
+*
+* // Create a data buffer:
+* var ybuf = new Float64Array( 12 );
+*
+* // Define the shape of the output array:
+* var shape = [ 1, 3, 1, 2 ];
+*
+* // Define the array strides:
+* var sy = [ 12, 4, 4, 2 ];
+*
+* // Define the index offset:
+* var oy = 0;
+*
+* // Create the output ndarray-like object:
+* var y = {
+*     'dtype': 'float64',
+*     'data': ybuf,
+*     'shape': shape,
+*     'strides': sy,
+*     'offset': oy,
+*     'order': 'row-major'
+* };
+*
+* // Assign scalar:
+* blockedassign4d( 2.0, 2.0, y );
+*
+* console.log( y.data );
+* // => <Float64Array>[ 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0 ]
+*/
+function blockedassign4d( re, im, y ) {
+	var bsize;
+	var ybuf;
+	var dy0;
+	var dy1;
+	var dy2;
+	var dy3;
+	var oy1;
+	var oy2;
+	var oy3;
+	var sh;
+	var s0;
+	var s1;
+	var s2;
+	var s3;
+	var sy;
+	var oy;
+	var iy;
+	var i0;
+	var i1;
+	var i2;
+	var i3;
+	var j0;
+	var j1;
+	var j2;
+	var j3;
+	var o;
+
+	// Note on variable naming convention: s#, dy#, i#, j# where # corresponds to the loop number, with `0` being the innermost loop...
+
+	// Resolve the loop interchange order:
+	o = loopOrder( y.shape, y.strides );
+	sh = o.sh;
+	sy = o.sx;
+
+	// Determine the block size:
+	bsize = blockSize( y.dtype );
+
+	// Cache the index of the first indexed element in the output ndarray:
+	oy = y.offset;
+
+	// Cache a reference to the output ndarray buffer:
+	ybuf = y.data;
+
+	// Cache the offset increment for the innermost loop:
+	dy0 = sy[0];
+
+	// Iterate over blocks...
+	for ( j3 = sh[3]; j3 > 0; ) {
+		if ( j3 < bsize ) {
+			s3 = j3;
+			j3 = 0;
+		} else {
+			s3 = bsize;
+			j3 -= bsize;
+		}
+		oy3 = oy + ( j3*sy[3] );
+		for ( j2 = sh[2]; j2 > 0; ) {
+			if ( j2 < bsize ) {
+				s2 = j2;
+				j2 = 0;
+			} else {
+				s2 = bsize;
+				j2 -= bsize;
+			}
+			dy3 = sy[3] - ( s2*sy[2] );
+			oy2 = oy3 + ( j2*sy[2] );
+			for ( j1 = sh[1]; j1 > 0; ) {
+				if ( j1 < bsize ) {
+					s1 = j1;
+					j1 = 0;
+				} else {
+					s1 = bsize;
+					j1 -= bsize;
+				}
+				dy2 = sy[2] - ( s1*sy[1] );
+				oy1 = oy2 + ( j1*sy[1] );
+				for ( j0 = sh[0]; j0 > 0; ) {
+					if ( j0 < bsize ) {
+						s0 = j0;
+						j0 = 0;
+					} else {
+						s0 = bsize;
+						j0 -= bsize;
+					}
+					// Compute the index offset for the first output ndarray element in the current block...
+					iy = oy1 + ( j0*sy[0] );
+
+					// Compute the loop offset increment...
+					dy1 = sy[1] - ( s0*sy[0] );
+
+					// Iterate over the ndarray dimensions...
+					for ( i3 = 0; i3 < s3; i3++ ) {
+						for ( i2 = 0; i2 < s2; i2++ ) {
+							for ( i1 = 0; i1 < s1; i1++ ) {
+								for ( i0 = 0; i0 < s0; i0++ ) {
+									ybuf[ iy ] = re;
+									ybuf[ iy+1 ] = im;
+									iy += dy0;
+								}
+								iy += dy1;
+							}
+							iy += dy2;
+						}
+						iy += dy3;
+					}
+				}
+			}
+		}
+	}
+}
+
+
+// EXPORTS //
+
+module.exports = blockedassign4d;
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/4d_complex.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/4d_complex.js
new file mode 100644
index 000000000000..ce522cdbad9d
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/4d_complex.js
@@ -0,0 +1,140 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2026 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';
+
+// MAIN //
+
+/**
+* Assigns a scalar value to every element of a reinterpreted complex number four-dimensional output ndarray.
+*
+* @private
+* @param {number} re - real component
+* @param {number} im - imaginary component
+* @param {Object} y - object containing output ndarray meta data
+* @param {*} y.dtype - data type
+* @param {Collection} y.data - data buffer
+* @param {NonNegativeIntegerArray} y.shape - dimensions
+* @param {IntegerArray} y.strides - stride lengths
+* @param {NonNegativeInteger} y.offset - index offset
+* @param {string} y.order - specifies whether `y` is row-major (C-style) or column-major (Fortran-style)
+* @param {boolean} isRowMajor - boolean indicating if provided arrays are in row-major order
+* @returns {void}
+*
+* @example
+* var Float64Array = require( '@stdlib/array/float64' );
+*
+* // Create a data buffer:
+* var ybuf = new Float64Array( 12 );
+*
+* // Define the shape of the output array:
+* var shape = [ 1, 3, 1, 2 ];
+*
+* // Define the array strides:
+* var sy = [ 12, 4, 4, 2 ];
+*
+* // Define the index offset:
+* var oy = 0;
+*
+* // Create the output ndarray-like object:
+* var y = {
+*     'dtype': 'float64',
+*     'data': ybuf,
+*     'shape': shape,
+*     'strides': sy,
+*     'offset': oy,
+*     'order': 'row-major'
+* };
+*
+* // Assign scalar:
+* assign4d( 2.0, 2.0, y, true );
+*
+* console.log( y.data );
+* // => <Float64Array>[ 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0 ]
+*/
+function assign4d( re, im, y, isRowMajor ) {
+	var ybuf;
+	var dy0;
+	var dy1;
+	var dy2;
+	var dy3;
+	var sh;
+	var S0;
+	var S1;
+	var S2;
+	var S3;
+	var sy;
+	var iy;
+	var i0;
+	var i1;
+	var i2;
+	var i3;
+
+	// Note on variable naming convention: S#, dy#, i# where # corresponds to the loop number, with `0` being the innermost loop...
+
+	// Extract loop variables for purposes of loop interchange: dimensions and loop offset (pointer) increments...
+	sh = y.shape;
+	sy = y.strides;
+	if ( isRowMajor ) {
+		// For row-major ndarrays, the last dimensions have the fastest changing indices...
+		S0 = sh[ 3 ];
+		S1 = sh[ 2 ];
+		S2 = sh[ 1 ];
+		S3 = sh[ 0 ];
+		dy0 = sy[ 3 ];                // offset increment for innermost loop
+		dy1 = sy[ 2 ] - ( S0*sy[3] );
+		dy2 = sy[ 1 ] - ( S1*sy[2] );
+		dy3 = sy[ 0 ] - ( S2*sy[1] ); // offset increment for outermost loop
+	} else { // order === 'column-major'
+		// For column-major ndarrays, the first dimensions have the fastest changing indices...
+		S0 = sh[ 0 ];
+		S1 = sh[ 1 ];
+		S2 = sh[ 2 ];
+		S3 = sh[ 3 ];
+		dy0 = sy[ 0 ];                // offset increment for innermost loop
+		dy1 = sy[ 1 ] - ( S0*sy[0] );
+		dy2 = sy[ 2 ] - ( S1*sy[1] );
+		dy3 = sy[ 3 ] - ( S2*sy[2] ); // offset increment for outermost loop
+	}
+	// Set a pointer to the first indexed element in the output ndarray:
+	iy = y.offset;
+
+	// Cache a reference to the output ndarray buffer:
+	ybuf = y.data;
+
+	// Iterate over the ndarray dimensions...
+	for ( i3 = 0; i3 < S3; i3++ ) {
+		for ( i2 = 0; i2 < S2; i2++ ) {
+			for ( i1 = 0; i1 < S1; i1++ ) {
+				for ( i0 = 0; i0 < S0; i0++ ) {
+					ybuf[ iy ] = re;
+					ybuf[ iy+1 ] = im;
+					iy += dy0;
+				}
+				iy += dy1;
+			}
+			iy += dy2;
+		}
+		iy += dy3;
+	}
+}
+
+
+// EXPORTS //
+
+module.exports = assign4d;
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/5d.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/5d.js
index bf3e34d0c396..115ed67584e6 100644
--- a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/5d.js
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/5d.js
@@ -84,7 +84,6 @@
 * // => <Float64Array>[ 2.0, 2.0, 2.0, 2.0, 2.0, 2.0 ]
 */
 function assign5d( x, y, isRowMajor ) {
-	var xbuf;
 	var ybuf;
 	var dy0;
 	var dy1;
@@ -98,13 +97,13 @@ function assign5d( x, y, isRowMajor ) {
 	var S3;
 	var S4;
 	var sy;
-	var ix;
 	var iy;
 	var i0;
 	var i1;
 	var i2;
 	var i3;
 	var i4;
+	var v;
 
 	// Note on variable naming convention: S#, dy#, i# where # corresponds to the loop number, with `0` being the innermost loop...
 
@@ -118,11 +117,11 @@ function assign5d( x, y, isRowMajor ) {
 		S2 = sh[ 2 ];
 		S3 = sh[ 1 ];
 		S4 = sh[ 0 ];
-		dy0 = sy[ 4 ];
+		dy0 = sy[ 4 ];                // offset increment for innermost loop
 		dy1 = sy[ 3 ] - ( S0*sy[4] );
 		dy2 = sy[ 2 ] - ( S1*sy[3] );
 		dy3 = sy[ 1 ] - ( S2*sy[2] );
-		dy4 = sy[ 0 ] - ( S3*sy[1] );
+		dy4 = sy[ 0 ] - ( S3*sy[1] ); // offset increment for outermost loop
 	} else { // order === 'column-major'
 		// For column-major ndarrays, the first dimensions have the fastest changing indices...
 		S0 = sh[ 0 ];
@@ -130,27 +129,28 @@ function assign5d( x, y, isRowMajor ) {
 		S2 = sh[ 2 ];
 		S3 = sh[ 3 ];
 		S4 = sh[ 4 ];
-		dy0 = sy[ 0 ];
+		dy0 = sy[ 0 ];                // offset increment for innermost loop
 		dy1 = sy[ 1 ] - ( S0*sy[0] );
 		dy2 = sy[ 2 ] - ( S1*sy[1] );
 		dy3 = sy[ 3 ] - ( S2*sy[2] );
-		dy4 = sy[ 4 ] - ( S3*sy[3] );
+		dy4 = sy[ 4 ] - ( S3*sy[3] ); // offset increment for outermost loop
 	}
-	// Set the pointers to the first indexed elements in the respective ndarrays...
-	ix = x.offset;
+	// Set a pointer to the first indexed element in the output ndarray:
 	iy = y.offset;
 
-	// Cache references to the input and output ndarray buffers...
-	xbuf = x.data;
+	// Cache a reference to the output ndarray buffer:
 	ybuf = y.data;
 
+	// Cache the scalar value:
+	v = x.data[ x.offset ];
+
 	// Iterate over the ndarray dimensions...
 	for ( i4 = 0; i4 < S4; i4++ ) {
 		for ( i3 = 0; i3 < S3; i3++ ) {
 			for ( i2 = 0; i2 < S2; i2++ ) {
 				for ( i1 = 0; i1 < S1; i1++ ) {
 					for ( i0 = 0; i0 < S0; i0++ ) {
-						ybuf[ iy ] = xbuf[ ix ];
+						ybuf[ iy ] = v;
 						iy += dy0;
 					}
 					iy += dy1;
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/5d_accessors.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/5d_accessors.js
index 4b1efd900875..0fb9e5230cd5 100644
--- a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/5d_accessors.js
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/5d_accessors.js
@@ -105,9 +105,7 @@
 * // returns 2.0
 */
 function assign5d( x, y, isRowMajor ) {
-	var xbuf;
 	var ybuf;
-	var get;
 	var set;
 	var dy0;
 	var dy1;
@@ -121,13 +119,13 @@ function assign5d( x, y, isRowMajor ) {
 	var S3;
 	var S4;
 	var sy;
-	var ix;
 	var iy;
 	var i0;
 	var i1;
 	var i2;
 	var i3;
 	var i4;
+	var v;
 
 	// Note on variable naming convention: S#, dy#, i# where # corresponds to the loop number, with `0` being the innermost loop...
 
@@ -141,11 +139,11 @@ function assign5d( x, y, isRowMajor ) {
 		S2 = sh[ 2 ];
 		S3 = sh[ 1 ];
 		S4 = sh[ 0 ];
-		dy0 = sy[ 4 ];
+		dy0 = sy[ 4 ];                // offset increment for innermost loop
 		dy1 = sy[ 3 ] - ( S0*sy[4] );
 		dy2 = sy[ 2 ] - ( S1*sy[3] );
 		dy3 = sy[ 1 ] - ( S2*sy[2] );
-		dy4 = sy[ 0 ] - ( S3*sy[1] );
+		dy4 = sy[ 0 ] - ( S3*sy[1] ); // offset increment for outermost loop
 	} else { // order === 'column-major'
 		// For column-major ndarrays, the first dimensions have the fastest changing indices...
 		S0 = sh[ 0 ];
@@ -153,23 +151,23 @@ function assign5d( x, y, isRowMajor ) {
 		S2 = sh[ 2 ];
 		S3 = sh[ 3 ];
 		S4 = sh[ 4 ];
-		dy0 = sy[ 0 ];
+		dy0 = sy[ 0 ];                // offset increment for innermost loop
 		dy1 = sy[ 1 ] - ( S0*sy[0] );
 		dy2 = sy[ 2 ] - ( S1*sy[1] );
 		dy3 = sy[ 3 ] - ( S2*sy[2] );
-		dy4 = sy[ 4 ] - ( S3*sy[3] );
+		dy4 = sy[ 4 ] - ( S3*sy[3] ); // offset increment for outermost loop
 	}
-	// Set the pointers to the first indexed elements in the respective ndarrays...
-	ix = x.offset;
+	// Set a pointer to the first indexed element in the output ndarray:
 	iy = y.offset;
 
-	// Cache references to the input and output ndarray buffers...
-	xbuf = x.data;
+	// Cache a reference to the output ndarray buffer:
 	ybuf = y.data;
 
-	// Cache accessors:
-	get = x.accessors[0];
-	set = y.accessors[1];
+	// Cache the output accessor:
+	set = y.accessors[ 1 ];
+
+	// Cache the scalar value:
+	v = x.accessors[ 0 ]( x.data, x.offset );
 
 	// Iterate over the ndarray dimensions...
 	for ( i4 = 0; i4 < S4; i4++ ) {
@@ -177,7 +175,7 @@ function assign5d( x, y, isRowMajor ) {
 			for ( i2 = 0; i2 < S2; i2++ ) {
 				for ( i1 = 0; i1 < S1; i1++ ) {
 					for ( i0 = 0; i0 < S0; i0++ ) {
-						set( ybuf, iy, get( xbuf, ix ) );
+						set( ybuf, iy, v );
 						iy += dy0;
 					}
 					iy += dy1;
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/5d_blocked.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/5d_blocked.js
index 62e81c45e202..810c2e4781e8 100644
--- a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/5d_blocked.js
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/5d_blocked.js
@@ -92,7 +92,6 @@ var blockSize = require( '@stdlib/ndarray/base/nullary-tiling-block-size' );
 */
 function blockedassign5d( x, y ) {
 	var bsize;
-	var xbuf;
 	var ybuf;
 	var dy0;
 	var dy1;
@@ -111,7 +110,6 @@ function blockedassign5d( x, y ) {
 	var s4;
 	var sy;
 	var oy;
-	var ix;
 	var iy;
 	var i0;
 	var i1;
@@ -124,6 +122,7 @@ function blockedassign5d( x, y ) {
 	var j3;
 	var j4;
 	var o;
+	var v;
 
 	// Note on variable naming convention: s#, dy#, i#, j# where # corresponds to the loop number, with `0` being the innermost loop...
 
@@ -135,15 +134,16 @@ function blockedassign5d( x, y ) {
 	// Determine the block size:
 	bsize = blockSize( y.dtype );
 
-	// Cache the indices of the first indexed elements in the respective ndarrays...
-	ix = x.offset;
+	// Cache the index of the first indexed element in the output ndarray:
 	oy = y.offset;
 
-	// Cache references to the input and output ndarray buffers...
-	xbuf = x.data;
+	// Cache a reference to the output ndarray buffer:
 	ybuf = y.data;
 
-	// Cache the offset increment for the innermost loop...
+	// Cache the scalar value:
+	v = x.data[ x.offset ];
+
+	// Cache the offset increment for the innermost loop:
 	dy0 = sy[0];
 
 	// Iterate over blocks...
@@ -206,7 +206,7 @@ function blockedassign5d( x, y ) {
 								for ( i2 = 0; i2 < s2; i2++ ) {
 									for ( i1 = 0; i1 < s1; i1++ ) {
 										for ( i0 = 0; i0 < s0; i0++ ) {
-											ybuf[ iy ] = xbuf[ ix ];
+											ybuf[ iy ] = v;
 											iy += dy0;
 										}
 										iy += dy1;
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/5d_blocked_accessors.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/5d_blocked_accessors.js
index 21d382e217ce..1b40bb45c0eb 100644
--- a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/5d_blocked_accessors.js
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/5d_blocked_accessors.js
@@ -113,9 +113,7 @@ var blockSize = require( '@stdlib/ndarray/base/nullary-tiling-block-size' );
 */
 function blockedassign5d( x, y ) {
 	var bsize;
-	var xbuf;
 	var ybuf;
-	var get;
 	var set;
 	var dy0;
 	var dy1;
@@ -134,7 +132,6 @@ function blockedassign5d( x, y ) {
 	var s4;
 	var sy;
 	var oy;
-	var ix;
 	var iy;
 	var i0;
 	var i1;
@@ -147,6 +144,7 @@ function blockedassign5d( x, y ) {
 	var j3;
 	var j4;
 	var o;
+	var v;
 
 	// Note on variable naming convention: s#, dy#, i#, j# where # corresponds to the loop number, with `0` being the innermost loop...
 
@@ -158,20 +156,20 @@ function blockedassign5d( x, y ) {
 	// Determine the block size:
 	bsize = blockSize( y.dtype );
 
-	// Cache the indices of the first indexed elements in the respective ndarrays...
-	ix = x.offset;
+	// Cache the index of the first indexed element in the output ndarray:
 	oy = y.offset;
 
-	// Cache references to the input and output ndarray buffers...
-	xbuf = x.data;
+	// Cache a reference to the output ndarray buffer:
 	ybuf = y.data;
 
-	// Cache the offset increment for the innermost loop...
+	// Cache the offset increment for the innermost loop:
 	dy0 = sy[0];
 
-	// Cache accessors:
-	get = x.accessors[0];
-	set = y.accessors[1];
+	// Cache the output accessor:
+	set = y.accessors[ 1 ];
+
+	// Cache the scalar value:
+	v = x.accessors[ 0 ]( x.data, x.offset );
 
 	// Iterate over blocks...
 	for ( j4 = sh[4]; j4 > 0; ) {
@@ -233,7 +231,7 @@ function blockedassign5d( x, y ) {
 								for ( i2 = 0; i2 < s2; i2++ ) {
 									for ( i1 = 0; i1 < s1; i1++ ) {
 										for ( i0 = 0; i0 < s0; i0++ ) {
-											set( ybuf, iy, get( xbuf, ix ) );
+											set( ybuf, iy, v );
 											iy += dy0;
 										}
 										iy += dy1;
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/5d_blocked_complex.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/5d_blocked_complex.js
new file mode 100644
index 000000000000..7f42810fbe97
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/5d_blocked_complex.js
@@ -0,0 +1,211 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2026 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-depth */
+
+'use strict';
+
+// MODULES //
+
+var loopOrder = require( '@stdlib/ndarray/base/nullary-loop-interchange-order' );
+var blockSize = require( '@stdlib/ndarray/base/nullary-tiling-block-size' );
+
+
+// MAIN //
+
+/**
+* Assigns a scalar value to every element of a reinterpreted complex number five-dimensional output ndarray via loop blocking.
+*
+* @private
+* @param {number} re - real component
+* @param {number} im - imaginary component
+* @param {Object} y - object containing output ndarray meta data
+* @param {*} y.dtype - data type
+* @param {Collection} y.data - data buffer
+* @param {NonNegativeIntegerArray} y.shape - dimensions
+* @param {IntegerArray} y.strides - stride lengths
+* @param {NonNegativeInteger} y.offset - index offset
+* @param {string} y.order - specifies whether `y` is row-major (C-style) or column-major (Fortran-style)
+* @returns {void}
+*
+* @example
+* var Float64Array = require( '@stdlib/array/float64' );
+*
+* // Create a data buffer:
+* var ybuf = new Float64Array( 12 );
+*
+* // Define the shape of the output array:
+* var shape = [ 1, 1, 3, 1, 2 ];
+*
+* // Define the array strides:
+* var sy = [ 12, 12, 4, 4, 2 ];
+*
+* // Define the index offset:
+* var oy = 0;
+*
+* // Create the output ndarray-like object:
+* var y = {
+*     'dtype': 'float64',
+*     'data': ybuf,
+*     'shape': shape,
+*     'strides': sy,
+*     'offset': oy,
+*     'order': 'row-major'
+* };
+*
+* // Assign scalar:
+* blockedassign5d( 2.0, 2.0, y );
+*
+* console.log( y.data );
+* // => <Float64Array>[ 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0 ]
+*/
+function blockedassign5d( re, im, y ) {
+	var bsize;
+	var ybuf;
+	var dy0;
+	var dy1;
+	var dy2;
+	var dy3;
+	var dy4;
+	var oy1;
+	var oy2;
+	var oy3;
+	var oy4;
+	var sh;
+	var s0;
+	var s1;
+	var s2;
+	var s3;
+	var s4;
+	var sy;
+	var oy;
+	var iy;
+	var i0;
+	var i1;
+	var i2;
+	var i3;
+	var i4;
+	var j0;
+	var j1;
+	var j2;
+	var j3;
+	var j4;
+	var o;
+
+	// Note on variable naming convention: s#, dy#, i#, j# where # corresponds to the loop number, with `0` being the innermost loop...
+
+	// Resolve the loop interchange order:
+	o = loopOrder( y.shape, y.strides );
+	sh = o.sh;
+	sy = o.sx;
+
+	// Determine the block size:
+	bsize = blockSize( y.dtype );
+
+	// Cache the index of the first indexed element in the output ndarray:
+	oy = y.offset;
+
+	// Cache a reference to the output ndarray buffer:
+	ybuf = y.data;
+
+	// Cache the offset increment for the innermost loop:
+	dy0 = sy[0];
+
+	// Iterate over blocks...
+	for ( j4 = sh[4]; j4 > 0; ) {
+		if ( j4 < bsize ) {
+			s4 = j4;
+			j4 = 0;
+		} else {
+			s4 = bsize;
+			j4 -= bsize;
+		}
+		oy4 = oy + ( j4*sy[4] );
+		for ( j3 = sh[3]; j3 > 0; ) {
+			if ( j3 < bsize ) {
+				s3 = j3;
+				j3 = 0;
+			} else {
+				s3 = bsize;
+				j3 -= bsize;
+			}
+			dy4 = sy[4] - ( s3*sy[3] );
+			oy3 = oy4 + ( j3*sy[3] );
+			for ( j2 = sh[2]; j2 > 0; ) {
+				if ( j2 < bsize ) {
+					s2 = j2;
+					j2 = 0;
+				} else {
+					s2 = bsize;
+					j2 -= bsize;
+				}
+				dy3 = sy[3] - ( s2*sy[2] );
+				oy2 = oy3 + ( j2*sy[2] );
+				for ( j1 = sh[1]; j1 > 0; ) {
+					if ( j1 < bsize ) {
+						s1 = j1;
+						j1 = 0;
+					} else {
+						s1 = bsize;
+						j1 -= bsize;
+					}
+					dy2 = sy[2] - ( s1*sy[1] );
+					oy1 = oy2 + ( j1*sy[1] );
+					for ( j0 = sh[0]; j0 > 0; ) {
+						if ( j0 < bsize ) {
+							s0 = j0;
+							j0 = 0;
+						} else {
+							s0 = bsize;
+							j0 -= bsize;
+						}
+						// Compute the index offset for the first output ndarray element in the current block...
+						iy = oy1 + ( j0*sy[0] );
+
+						// Compute the loop offset increment...
+						dy1 = sy[1] - ( s0*sy[0] );
+
+						// Iterate over the ndarray dimensions...
+						for ( i4 = 0; i4 < s4; i4++ ) {
+							for ( i3 = 0; i3 < s3; i3++ ) {
+								for ( i2 = 0; i2 < s2; i2++ ) {
+									for ( i1 = 0; i1 < s1; i1++ ) {
+										for ( i0 = 0; i0 < s0; i0++ ) {
+											ybuf[ iy ] = re;
+											ybuf[ iy+1 ] = im;
+											iy += dy0;
+										}
+										iy += dy1;
+									}
+									iy += dy2;
+								}
+								iy += dy3;
+							}
+							iy += dy4;
+						}
+					}
+				}
+			}
+		}
+	}
+}
+
+
+// EXPORTS //
+
+module.exports = blockedassign5d;
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/5d_complex.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/5d_complex.js
new file mode 100644
index 000000000000..20b7182fa604
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/5d_complex.js
@@ -0,0 +1,150 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2026 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';
+
+// MAIN //
+
+/**
+* Assigns a scalar value to every element of a reinterpreted complex number five-dimensional output ndarray.
+*
+* @private
+* @param {number} re - real component
+* @param {number} im - imaginary component
+* @param {Object} y - object containing output ndarray meta data
+* @param {*} y.dtype - data type
+* @param {Collection} y.data - data buffer
+* @param {NonNegativeIntegerArray} y.shape - dimensions
+* @param {IntegerArray} y.strides - stride lengths
+* @param {NonNegativeInteger} y.offset - index offset
+* @param {string} y.order - specifies whether `y` is row-major (C-style) or column-major (Fortran-style)
+* @param {boolean} isRowMajor - boolean indicating if provided arrays are in row-major order
+* @returns {void}
+*
+* @example
+* var Float64Array = require( '@stdlib/array/float64' );
+*
+* // Create a data buffer:
+* var ybuf = new Float64Array( 12 );
+*
+* // Define the shape of the output array:
+* var shape = [ 1, 1, 3, 1, 2 ];
+*
+* // Define the array strides:
+* var sy = [ 12, 12, 4, 4, 2 ];
+*
+* // Define the index offset:
+* var oy = 0;
+*
+* // Create the output ndarray-like object:
+* var y = {
+*     'dtype': 'float64',
+*     'data': ybuf,
+*     'shape': shape,
+*     'strides': sy,
+*     'offset': oy,
+*     'order': 'row-major'
+* };
+*
+* // Assign scalar:
+* assign5d( 2.0, 2.0, y, true );
+*
+* console.log( y.data );
+* // => <Float64Array>[ 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0 ]
+*/
+function assign5d( re, im, y, isRowMajor ) {
+	var ybuf;
+	var dy0;
+	var dy1;
+	var dy2;
+	var dy3;
+	var dy4;
+	var sh;
+	var S0;
+	var S1;
+	var S2;
+	var S3;
+	var S4;
+	var sy;
+	var iy;
+	var i0;
+	var i1;
+	var i2;
+	var i3;
+	var i4;
+
+	// Note on variable naming convention: S#, dy#, i# where # corresponds to the loop number, with `0` being the innermost loop...
+
+	// Extract loop variables for purposes of loop interchange: dimensions and loop offset (pointer) increments...
+	sh = y.shape;
+	sy = y.strides;
+	if ( isRowMajor ) {
+		// For row-major ndarrays, the last dimensions have the fastest changing indices...
+		S0 = sh[ 4 ];
+		S1 = sh[ 3 ];
+		S2 = sh[ 2 ];
+		S3 = sh[ 1 ];
+		S4 = sh[ 0 ];
+		dy0 = sy[ 4 ];                // offset increment for innermost loop
+		dy1 = sy[ 3 ] - ( S0*sy[4] );
+		dy2 = sy[ 2 ] - ( S1*sy[3] );
+		dy3 = sy[ 1 ] - ( S2*sy[2] );
+		dy4 = sy[ 0 ] - ( S3*sy[1] ); // offset increment for outermost loop
+	} else { // order === 'column-major'
+		// For column-major ndarrays, the first dimensions have the fastest changing indices...
+		S0 = sh[ 0 ];
+		S1 = sh[ 1 ];
+		S2 = sh[ 2 ];
+		S3 = sh[ 3 ];
+		S4 = sh[ 4 ];
+		dy0 = sy[ 0 ];                // offset increment for innermost loop
+		dy1 = sy[ 1 ] - ( S0*sy[0] );
+		dy2 = sy[ 2 ] - ( S1*sy[1] );
+		dy3 = sy[ 3 ] - ( S2*sy[2] );
+		dy4 = sy[ 4 ] - ( S3*sy[3] ); // offset increment for outermost loop
+	}
+	// Set a pointer to the first indexed element in the output ndarray:
+	iy = y.offset;
+
+	// Cache a reference to the output ndarray buffer:
+	ybuf = y.data;
+
+	// Iterate over the ndarray dimensions...
+	for ( i4 = 0; i4 < S4; i4++ ) {
+		for ( i3 = 0; i3 < S3; i3++ ) {
+			for ( i2 = 0; i2 < S2; i2++ ) {
+				for ( i1 = 0; i1 < S1; i1++ ) {
+					for ( i0 = 0; i0 < S0; i0++ ) {
+						ybuf[ iy ] = re;
+						ybuf[ iy+1 ] = im;
+						iy += dy0;
+					}
+					iy += dy1;
+				}
+				iy += dy2;
+			}
+			iy += dy3;
+		}
+		iy += dy4;
+	}
+}
+
+
+// EXPORTS //
+
+module.exports = assign5d;
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/6d.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/6d.js
index eda1a19e3ca5..5995bbe30a1c 100644
--- a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/6d.js
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/6d.js
@@ -86,7 +86,6 @@
 * // => <Float64Array>[ 2.0, 2.0, 2.0, 2.0, 2.0, 2.0 ]
 */
 function assign6d( x, y, isRowMajor ) {
-	var xbuf;
 	var ybuf;
 	var dy0;
 	var dy1;
@@ -102,7 +101,6 @@ function assign6d( x, y, isRowMajor ) {
 	var S4;
 	var S5;
 	var sy;
-	var ix;
 	var iy;
 	var i0;
 	var i1;
@@ -110,6 +108,7 @@ function assign6d( x, y, isRowMajor ) {
 	var i3;
 	var i4;
 	var i5;
+	var v;
 
 	// Note on variable naming convention: S#, dy#, i# where # corresponds to the loop number, with `0` being the innermost loop...
 
@@ -124,12 +123,12 @@ function assign6d( x, y, isRowMajor ) {
 		S3 = sh[ 2 ];
 		S4 = sh[ 1 ];
 		S5 = sh[ 0 ];
-		dy0 = sy[ 5 ];
+		dy0 = sy[ 5 ];                // offset increment for innermost loop
 		dy1 = sy[ 4 ] - ( S0*sy[5] );
 		dy2 = sy[ 3 ] - ( S1*sy[4] );
 		dy3 = sy[ 2 ] - ( S2*sy[3] );
 		dy4 = sy[ 1 ] - ( S3*sy[2] );
-		dy5 = sy[ 0 ] - ( S4*sy[1] );
+		dy5 = sy[ 0 ] - ( S4*sy[1] ); // offset increment for outermost loop
 	} else { // order === 'column-major'
 		// For column-major ndarrays, the first dimensions have the fastest changing indices...
 		S0 = sh[ 0 ];
@@ -138,21 +137,22 @@ function assign6d( x, y, isRowMajor ) {
 		S3 = sh[ 3 ];
 		S4 = sh[ 4 ];
 		S5 = sh[ 5 ];
-		dy0 = sy[ 0 ];
+		dy0 = sy[ 0 ];                // offset increment for innermost loop
 		dy1 = sy[ 1 ] - ( S0*sy[0] );
 		dy2 = sy[ 2 ] - ( S1*sy[1] );
 		dy3 = sy[ 3 ] - ( S2*sy[2] );
 		dy4 = sy[ 4 ] - ( S3*sy[3] );
-		dy5 = sy[ 5 ] - ( S4*sy[4] );
+		dy5 = sy[ 5 ] - ( S4*sy[4] ); // offset increment for outermost loop
 	}
-	// Set the pointers to the first indexed elements in the respective ndarrays...
-	ix = x.offset;
+	// Set a pointer to the first indexed element in the output ndarray:
 	iy = y.offset;
 
-	// Cache references to the input and output ndarray buffers...
-	xbuf = x.data;
+	// Cache a reference to the output ndarray buffer:
 	ybuf = y.data;
 
+	// Cache the scalar value:
+	v = x.data[ x.offset ];
+
 	// Iterate over the ndarray dimensions...
 	for ( i5 = 0; i5 < S5; i5++ ) {
 		for ( i4 = 0; i4 < S4; i4++ ) {
@@ -160,7 +160,7 @@ function assign6d( x, y, isRowMajor ) {
 				for ( i2 = 0; i2 < S2; i2++ ) {
 					for ( i1 = 0; i1 < S1; i1++ ) {
 						for ( i0 = 0; i0 < S0; i0++ ) {
-							ybuf[ iy ] = xbuf[ ix ];
+							ybuf[ iy ] = v;
 							iy += dy0;
 						}
 						iy += dy1;
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/6d_accessors.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/6d_accessors.js
index f48ba877f20e..53a00efc569e 100644
--- a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/6d_accessors.js
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/6d_accessors.js
@@ -107,9 +107,7 @@
 * // returns 2.0
 */
 function assign6d( x, y, isRowMajor ) {
-	var xbuf;
 	var ybuf;
-	var get;
 	var set;
 	var dy0;
 	var dy1;
@@ -125,7 +123,6 @@ function assign6d( x, y, isRowMajor ) {
 	var S4;
 	var S5;
 	var sy;
-	var ix;
 	var iy;
 	var i0;
 	var i1;
@@ -133,6 +130,7 @@ function assign6d( x, y, isRowMajor ) {
 	var i3;
 	var i4;
 	var i5;
+	var v;
 
 	// Note on variable naming convention: S#, dy#, i# where # corresponds to the loop number, with `0` being the innermost loop...
 
@@ -147,12 +145,12 @@ function assign6d( x, y, isRowMajor ) {
 		S3 = sh[ 2 ];
 		S4 = sh[ 1 ];
 		S5 = sh[ 0 ];
-		dy0 = sy[ 5 ];
+		dy0 = sy[ 5 ];                // offset increment for innermost loop
 		dy1 = sy[ 4 ] - ( S0*sy[5] );
 		dy2 = sy[ 3 ] - ( S1*sy[4] );
 		dy3 = sy[ 2 ] - ( S2*sy[3] );
 		dy4 = sy[ 1 ] - ( S3*sy[2] );
-		dy5 = sy[ 0 ] - ( S4*sy[1] );
+		dy5 = sy[ 0 ] - ( S4*sy[1] ); // offset increment for outermost loop
 	} else { // order === 'column-major'
 		// For column-major ndarrays, the first dimensions have the fastest changing indices...
 		S0 = sh[ 0 ];
@@ -161,24 +159,24 @@ function assign6d( x, y, isRowMajor ) {
 		S3 = sh[ 3 ];
 		S4 = sh[ 4 ];
 		S5 = sh[ 5 ];
-		dy0 = sy[ 0 ];
+		dy0 = sy[ 0 ];                // offset increment for innermost loop
 		dy1 = sy[ 1 ] - ( S0*sy[0] );
 		dy2 = sy[ 2 ] - ( S1*sy[1] );
 		dy3 = sy[ 3 ] - ( S2*sy[2] );
 		dy4 = sy[ 4 ] - ( S3*sy[3] );
-		dy5 = sy[ 5 ] - ( S4*sy[4] );
+		dy5 = sy[ 5 ] - ( S4*sy[4] ); // offset increment for outermost loop
 	}
-	// Set the pointers to the first indexed elements in the respective ndarrays...
-	ix = x.offset;
+	// Set a pointer to the first indexed element in the output ndarray:
 	iy = y.offset;
 
-	// Cache references to the input and output ndarray buffers...
-	xbuf = x.data;
+	// Cache a reference to the output ndarray buffer:
 	ybuf = y.data;
 
-	// Cache accessors:
-	get = x.accessors[0];
-	set = y.accessors[1];
+	// Cache the output accessor:
+	set = y.accessors[ 1 ];
+
+	// Cache the scalar value:
+	v = x.accessors[ 0 ]( x.data, x.offset );
 
 	// Iterate over the ndarray dimensions...
 	for ( i5 = 0; i5 < S5; i5++ ) {
@@ -187,7 +185,7 @@ function assign6d( x, y, isRowMajor ) {
 				for ( i2 = 0; i2 < S2; i2++ ) {
 					for ( i1 = 0; i1 < S1; i1++ ) {
 						for ( i0 = 0; i0 < S0; i0++ ) {
-							set( ybuf, iy, get( xbuf, ix ) );
+							set( ybuf, iy, v );
 							iy += dy0;
 						}
 						iy += dy1;
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/6d_blocked.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/6d_blocked.js
index 0739fcfa224a..775f7aac0d77 100644
--- a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/6d_blocked.js
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/6d_blocked.js
@@ -92,7 +92,6 @@ var blockSize = require( '@stdlib/ndarray/base/nullary-tiling-block-size' );
 */
 function blockedassign6d( x, y ) { // eslint-disable-line max-statements
 	var bsize;
-	var xbuf;
 	var ybuf;
 	var dy0;
 	var dy1;
@@ -114,7 +113,6 @@ function blockedassign6d( x, y ) { // eslint-disable-line max-statements
 	var s5;
 	var sy;
 	var oy;
-	var ix;
 	var iy;
 	var i0;
 	var i1;
@@ -129,6 +127,7 @@ function blockedassign6d( x, y ) { // eslint-disable-line max-statements
 	var j4;
 	var j5;
 	var o;
+	var v;
 
 	// Note on variable naming convention: s#, dy#, i#, j# where # corresponds to the loop number, with `0` being the innermost loop...
 
@@ -140,15 +139,16 @@ function blockedassign6d( x, y ) { // eslint-disable-line max-statements
 	// Determine the block size:
 	bsize = blockSize( y.dtype );
 
-	// Cache the indices of the first indexed elements in the respective ndarrays...
-	ix = x.offset;
+	// Cache the index of the first indexed element in the output ndarray:
 	oy = y.offset;
 
-	// Cache references to the input and output ndarray buffers...
-	xbuf = x.data;
+	// Cache a reference to the output ndarray buffer:
 	ybuf = y.data;
 
-	// Cache the offset increment for the innermost loop...
+	// Cache the scalar value:
+	v = x.data[ x.offset ];
+
+	// Cache the offset increment for the innermost loop:
 	dy0 = sy[0];
 
 	// Iterate over blocks...
@@ -222,7 +222,7 @@ function blockedassign6d( x, y ) { // eslint-disable-line max-statements
 										for ( i2 = 0; i2 < s2; i2++ ) {
 											for ( i1 = 0; i1 < s1; i1++ ) {
 												for ( i0 = 0; i0 < s0; i0++ ) {
-													ybuf[ iy ] = xbuf[ ix ];
+													ybuf[ iy ] = v;
 													iy += dy0;
 												}
 												iy += dy1;
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/6d_blocked_accessors.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/6d_blocked_accessors.js
index 25b6c5d1e4af..584f53295299 100644
--- a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/6d_blocked_accessors.js
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/6d_blocked_accessors.js
@@ -16,7 +16,7 @@
 * limitations under the License.
 */
 
-/* eslint-disable max-depth, max-len */
+/* eslint-disable max-depth */
 
 'use strict';
 
@@ -113,9 +113,7 @@ var blockSize = require( '@stdlib/ndarray/base/nullary-tiling-block-size' );
 */
 function blockedassign6d( x, y ) { // eslint-disable-line max-statements
 	var bsize;
-	var xbuf;
 	var ybuf;
-	var get;
 	var set;
 	var dy0;
 	var dy1;
@@ -137,7 +135,6 @@ function blockedassign6d( x, y ) { // eslint-disable-line max-statements
 	var s5;
 	var sy;
 	var oy;
-	var ix;
 	var iy;
 	var i0;
 	var i1;
@@ -152,6 +149,7 @@ function blockedassign6d( x, y ) { // eslint-disable-line max-statements
 	var j4;
 	var j5;
 	var o;
+	var v;
 
 	// Note on variable naming convention: s#, dy#, i#, j# where # corresponds to the loop number, with `0` being the innermost loop...
 
@@ -163,20 +161,20 @@ function blockedassign6d( x, y ) { // eslint-disable-line max-statements
 	// Determine the block size:
 	bsize = blockSize( y.dtype );
 
-	// Cache the indices of the first indexed elements in the respective ndarrays...
-	ix = x.offset;
+	// Cache the index of the first indexed element in the output ndarray:
 	oy = y.offset;
 
-	// Cache references to the input and output ndarray buffers...
-	xbuf = x.data;
+	// Cache a reference to the output ndarray buffer:
 	ybuf = y.data;
 
-	// Cache the offset increment for the innermost loop...
+	// Cache the offset increment for the innermost loop:
 	dy0 = sy[0];
 
-	// Cache accessors:
-	get = x.accessors[0];
-	set = y.accessors[1];
+	// Cache the output accessor:
+	set = y.accessors[ 1 ];
+
+	// Cache the scalar value:
+	v = x.accessors[ 0 ]( x.data, x.offset );
 
 	// Iterate over blocks...
 	for ( j5 = sh[5]; j5 > 0; ) {
@@ -249,7 +247,7 @@ function blockedassign6d( x, y ) { // eslint-disable-line max-statements
 										for ( i2 = 0; i2 < s2; i2++ ) {
 											for ( i1 = 0; i1 < s1; i1++ ) {
 												for ( i0 = 0; i0 < s0; i0++ ) {
-													set( ybuf, iy, get( xbuf, ix ) );
+													set( ybuf, iy, v );
 													iy += dy0;
 												}
 												iy += dy1;
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/6d_blocked_complex.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/6d_blocked_complex.js
new file mode 100644
index 000000000000..855e853401aa
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/6d_blocked_complex.js
@@ -0,0 +1,230 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2026 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-depth */
+
+'use strict';
+
+// MODULES //
+
+var loopOrder = require( '@stdlib/ndarray/base/nullary-loop-interchange-order' );
+var blockSize = require( '@stdlib/ndarray/base/nullary-tiling-block-size' );
+
+
+// MAIN //
+
+/**
+* Assigns a scalar value to every element of a reinterpreted complex number six-dimensional output ndarray via loop blocking.
+*
+* @private
+* @param {number} re - real component
+* @param {number} im - imaginary component
+* @param {Object} y - object containing output ndarray meta data
+* @param {*} y.dtype - data type
+* @param {Collection} y.data - data buffer
+* @param {NonNegativeIntegerArray} y.shape - dimensions
+* @param {IntegerArray} y.strides - stride lengths
+* @param {NonNegativeInteger} y.offset - index offset
+* @param {string} y.order - specifies whether `y` is row-major (C-style) or column-major (Fortran-style)
+* @returns {void}
+*
+* @example
+* var Float64Array = require( '@stdlib/array/float64' );
+*
+* // Create a data buffer:
+* var ybuf = new Float64Array( 12 );
+*
+* // Define the shape of the output array:
+* var shape = [ 1, 1, 1, 3, 1, 2 ];
+*
+* // Define the array strides:
+* var sy = [ 12, 12, 12, 4, 4, 2 ];
+*
+* // Define the index offset:
+* var oy = 0;
+*
+* // Create the output ndarray-like object:
+* var y = {
+*     'dtype': 'float64',
+*     'data': ybuf,
+*     'shape': shape,
+*     'strides': sy,
+*     'offset': oy,
+*     'order': 'row-major'
+* };
+*
+* // Assign scalar:
+* blockedassign6d( 2.0, 2.0, y );
+*
+* console.log( y.data );
+* // => <Float64Array>[ 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0 ]
+*/
+function blockedassign6d( re, im, y ) {
+	var bsize;
+	var ybuf;
+	var dy0;
+	var dy1;
+	var dy2;
+	var dy3;
+	var dy4;
+	var dy5;
+	var oy1;
+	var oy2;
+	var oy3;
+	var oy4;
+	var oy5;
+	var sh;
+	var s0;
+	var s1;
+	var s2;
+	var s3;
+	var s4;
+	var s5;
+	var sy;
+	var oy;
+	var iy;
+	var i0;
+	var i1;
+	var i2;
+	var i3;
+	var i4;
+	var i5;
+	var j0;
+	var j1;
+	var j2;
+	var j3;
+	var j4;
+	var j5;
+	var o;
+
+	// Note on variable naming convention: s#, dy#, i#, j# where # corresponds to the loop number, with `0` being the innermost loop...
+
+	// Resolve the loop interchange order:
+	o = loopOrder( y.shape, y.strides );
+	sh = o.sh;
+	sy = o.sx;
+
+	// Determine the block size:
+	bsize = blockSize( y.dtype );
+
+	// Cache the index of the first indexed element in the output ndarray:
+	oy = y.offset;
+
+	// Cache a reference to the output ndarray buffer:
+	ybuf = y.data;
+
+	// Cache the offset increment for the innermost loop:
+	dy0 = sy[0];
+
+	// Iterate over blocks...
+	for ( j5 = sh[5]; j5 > 0; ) {
+		if ( j5 < bsize ) {
+			s5 = j5;
+			j5 = 0;
+		} else {
+			s5 = bsize;
+			j5 -= bsize;
+		}
+		oy5 = oy + ( j5*sy[5] );
+		for ( j4 = sh[4]; j4 > 0; ) {
+			if ( j4 < bsize ) {
+				s4 = j4;
+				j4 = 0;
+			} else {
+				s4 = bsize;
+				j4 -= bsize;
+			}
+			dy5 = sy[5] - ( s4*sy[4] );
+			oy4 = oy5 + ( j4*sy[4] );
+			for ( j3 = sh[3]; j3 > 0; ) {
+				if ( j3 < bsize ) {
+					s3 = j3;
+					j3 = 0;
+				} else {
+					s3 = bsize;
+					j3 -= bsize;
+				}
+				dy4 = sy[4] - ( s3*sy[3] );
+				oy3 = oy4 + ( j3*sy[3] );
+				for ( j2 = sh[2]; j2 > 0; ) {
+					if ( j2 < bsize ) {
+						s2 = j2;
+						j2 = 0;
+					} else {
+						s2 = bsize;
+						j2 -= bsize;
+					}
+					dy3 = sy[3] - ( s2*sy[2] );
+					oy2 = oy3 + ( j2*sy[2] );
+					for ( j1 = sh[1]; j1 > 0; ) {
+						if ( j1 < bsize ) {
+							s1 = j1;
+							j1 = 0;
+						} else {
+							s1 = bsize;
+							j1 -= bsize;
+						}
+						dy2 = sy[2] - ( s1*sy[1] );
+						oy1 = oy2 + ( j1*sy[1] );
+						for ( j0 = sh[0]; j0 > 0; ) {
+							if ( j0 < bsize ) {
+								s0 = j0;
+								j0 = 0;
+							} else {
+								s0 = bsize;
+								j0 -= bsize;
+							}
+							// Compute the index offset for the first output ndarray element in the current block...
+							iy = oy1 + ( j0*sy[0] );
+
+							// Compute the loop offset increment...
+							dy1 = sy[1] - ( s0*sy[0] );
+
+							// Iterate over the ndarray dimensions...
+							for ( i5 = 0; i5 < s5; i5++ ) {
+								for ( i4 = 0; i4 < s4; i4++ ) {
+									for ( i3 = 0; i3 < s3; i3++ ) {
+										for ( i2 = 0; i2 < s2; i2++ ) {
+											for ( i1 = 0; i1 < s1; i1++ ) {
+												for ( i0 = 0; i0 < s0; i0++ ) {
+													ybuf[ iy ] = re;
+													ybuf[ iy+1 ] = im;
+													iy += dy0;
+												}
+												iy += dy1;
+											}
+											iy += dy2;
+										}
+										iy += dy3;
+									}
+									iy += dy4;
+								}
+								iy += dy5;
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+}
+
+
+// EXPORTS //
+
+module.exports = blockedassign6d;
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/6d_complex.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/6d_complex.js
new file mode 100644
index 000000000000..24c0b492cdfe
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/6d_complex.js
@@ -0,0 +1,162 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2026 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-depth */
+
+'use strict';
+
+// MAIN //
+
+/**
+* Assigns a scalar value to every element of a reinterpreted complex number six-dimensional output ndarray.
+*
+* @private
+* @param {number} re - real component
+* @param {number} im - imaginary component
+* @param {Object} y - object containing output ndarray meta data
+* @param {*} y.dtype - data type
+* @param {Collection} y.data - data buffer
+* @param {NonNegativeIntegerArray} y.shape - dimensions
+* @param {IntegerArray} y.strides - stride lengths
+* @param {NonNegativeInteger} y.offset - index offset
+* @param {string} y.order - specifies whether `y` is row-major (C-style) or column-major (Fortran-style)
+* @param {boolean} isRowMajor - boolean indicating if provided arrays are in row-major order
+* @returns {void}
+*
+* @example
+* var Float64Array = require( '@stdlib/array/float64' );
+*
+* // Create a data buffer:
+* var ybuf = new Float64Array( 12 );
+*
+* // Define the shape of the output array:
+* var shape = [ 1, 1, 1, 3, 1, 2 ];
+*
+* // Define the array strides:
+* var sy = [ 12, 12, 12, 4, 4, 2 ];
+*
+* // Define the index offset:
+* var oy = 0;
+*
+* // Create the output ndarray-like object:
+* var y = {
+*     'dtype': 'float64',
+*     'data': ybuf,
+*     'shape': shape,
+*     'strides': sy,
+*     'offset': oy,
+*     'order': 'row-major'
+* };
+*
+* // Assign scalar:
+* assign6d( 2.0, 2.0, y, true );
+*
+* console.log( y.data );
+* // => <Float64Array>[ 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0 ]
+*/
+function assign6d( re, im, y, isRowMajor ) {
+	var ybuf;
+	var dy0;
+	var dy1;
+	var dy2;
+	var dy3;
+	var dy4;
+	var dy5;
+	var sh;
+	var S0;
+	var S1;
+	var S2;
+	var S3;
+	var S4;
+	var S5;
+	var sy;
+	var iy;
+	var i0;
+	var i1;
+	var i2;
+	var i3;
+	var i4;
+	var i5;
+
+	// Note on variable naming convention: S#, dy#, i# where # corresponds to the loop number, with `0` being the innermost loop...
+
+	// Extract loop variables for purposes of loop interchange: dimensions and loop offset (pointer) increments...
+	sh = y.shape;
+	sy = y.strides;
+	if ( isRowMajor ) {
+		// For row-major ndarrays, the last dimensions have the fastest changing indices...
+		S0 = sh[ 5 ];
+		S1 = sh[ 4 ];
+		S2 = sh[ 3 ];
+		S3 = sh[ 2 ];
+		S4 = sh[ 1 ];
+		S5 = sh[ 0 ];
+		dy0 = sy[ 5 ];                // offset increment for innermost loop
+		dy1 = sy[ 4 ] - ( S0*sy[5] );
+		dy2 = sy[ 3 ] - ( S1*sy[4] );
+		dy3 = sy[ 2 ] - ( S2*sy[3] );
+		dy4 = sy[ 1 ] - ( S3*sy[2] );
+		dy5 = sy[ 0 ] - ( S4*sy[1] ); // offset increment for outermost loop
+	} else { // order === 'column-major'
+		// For column-major ndarrays, the first dimensions have the fastest changing indices...
+		S0 = sh[ 0 ];
+		S1 = sh[ 1 ];
+		S2 = sh[ 2 ];
+		S3 = sh[ 3 ];
+		S4 = sh[ 4 ];
+		S5 = sh[ 5 ];
+		dy0 = sy[ 0 ];                // offset increment for innermost loop
+		dy1 = sy[ 1 ] - ( S0*sy[0] );
+		dy2 = sy[ 2 ] - ( S1*sy[1] );
+		dy3 = sy[ 3 ] - ( S2*sy[2] );
+		dy4 = sy[ 4 ] - ( S3*sy[3] );
+		dy5 = sy[ 5 ] - ( S4*sy[4] ); // offset increment for outermost loop
+	}
+	// Set a pointer to the first indexed element in the output ndarray:
+	iy = y.offset;
+
+	// Cache a reference to the output ndarray buffer:
+	ybuf = y.data;
+
+	// Iterate over the ndarray dimensions...
+	for ( i5 = 0; i5 < S5; i5++ ) {
+		for ( i4 = 0; i4 < S4; i4++ ) {
+			for ( i3 = 0; i3 < S3; i3++ ) {
+				for ( i2 = 0; i2 < S2; i2++ ) {
+					for ( i1 = 0; i1 < S1; i1++ ) {
+						for ( i0 = 0; i0 < S0; i0++ ) {
+							ybuf[ iy ] = re;
+							ybuf[ iy+1 ] = im;
+							iy += dy0;
+						}
+						iy += dy1;
+					}
+					iy += dy2;
+				}
+				iy += dy3;
+			}
+			iy += dy4;
+		}
+		iy += dy5;
+	}
+}
+
+
+// EXPORTS //
+
+module.exports = assign6d;
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/7d.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/7d.js
index ca7c41e086f0..5191dc0fca33 100644
--- a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/7d.js
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/7d.js
@@ -86,7 +86,6 @@
 * // => <Float64Array>[ 2.0, 2.0, 2.0, 2.0, 2.0, 2.0 ]
 */
 function assign7d( x, y, isRowMajor ) {
-	var xbuf;
 	var ybuf;
 	var dy0;
 	var dy1;
@@ -104,7 +103,6 @@ function assign7d( x, y, isRowMajor ) {
 	var S5;
 	var S6;
 	var sy;
-	var ix;
 	var iy;
 	var i0;
 	var i1;
@@ -113,6 +111,7 @@ function assign7d( x, y, isRowMajor ) {
 	var i4;
 	var i5;
 	var i6;
+	var v;
 
 	// Note on variable naming convention: S#, dy#, i# where # corresponds to the loop number, with `0` being the innermost loop...
 
@@ -128,13 +127,13 @@ function assign7d( x, y, isRowMajor ) {
 		S4 = sh[ 2 ];
 		S5 = sh[ 1 ];
 		S6 = sh[ 0 ];
-		dy0 = sy[ 6 ];
+		dy0 = sy[ 6 ];                // offset increment for innermost loop
 		dy1 = sy[ 5 ] - ( S0*sy[6] );
 		dy2 = sy[ 4 ] - ( S1*sy[5] );
 		dy3 = sy[ 3 ] - ( S2*sy[4] );
 		dy4 = sy[ 2 ] - ( S3*sy[3] );
 		dy5 = sy[ 1 ] - ( S4*sy[2] );
-		dy6 = sy[ 0 ] - ( S5*sy[1] );
+		dy6 = sy[ 0 ] - ( S5*sy[1] ); // offset increment for outermost loop
 	} else { // order === 'column-major'
 		// For column-major ndarrays, the first dimensions have the fastest changing indices...
 		S0 = sh[ 0 ];
@@ -144,22 +143,23 @@ function assign7d( x, y, isRowMajor ) {
 		S4 = sh[ 4 ];
 		S5 = sh[ 5 ];
 		S6 = sh[ 6 ];
-		dy0 = sy[ 0 ];
+		dy0 = sy[ 0 ];                // offset increment for innermost loop
 		dy1 = sy[ 1 ] - ( S0*sy[0] );
 		dy2 = sy[ 2 ] - ( S1*sy[1] );
 		dy3 = sy[ 3 ] - ( S2*sy[2] );
 		dy4 = sy[ 4 ] - ( S3*sy[3] );
 		dy5 = sy[ 5 ] - ( S4*sy[4] );
-		dy6 = sy[ 6 ] - ( S5*sy[5] );
+		dy6 = sy[ 6 ] - ( S5*sy[5] ); // offset increment for outermost loop
 	}
-	// Set the pointers to the first indexed elements in the respective ndarrays...
-	ix = x.offset;
+	// Set a pointer to the first indexed element in the output ndarray:
 	iy = y.offset;
 
-	// Cache references to the input and output ndarray buffers...
-	xbuf = x.data;
+	// Cache a reference to the output ndarray buffer:
 	ybuf = y.data;
 
+	// Cache the scalar value:
+	v = x.data[ x.offset ];
+
 	// Iterate over the ndarray dimensions...
 	for ( i6 = 0; i6 < S6; i6++ ) {
 		for ( i5 = 0; i5 < S5; i5++ ) {
@@ -168,7 +168,7 @@ function assign7d( x, y, isRowMajor ) {
 					for ( i2 = 0; i2 < S2; i2++ ) {
 						for ( i1 = 0; i1 < S1; i1++ ) {
 							for ( i0 = 0; i0 < S0; i0++ ) {
-								ybuf[ iy ] = xbuf[ ix ];
+								ybuf[ iy ] = v;
 								iy += dy0;
 							}
 							iy += dy1;
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/7d_accessors.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/7d_accessors.js
index c1c3d622e389..4f1b23290bb2 100644
--- a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/7d_accessors.js
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/7d_accessors.js
@@ -107,9 +107,7 @@
 * // returns 2.0
 */
 function assign7d( x, y, isRowMajor ) {
-	var xbuf;
 	var ybuf;
-	var get;
 	var set;
 	var dy0;
 	var dy1;
@@ -127,7 +125,6 @@ function assign7d( x, y, isRowMajor ) {
 	var S5;
 	var S6;
 	var sy;
-	var ix;
 	var iy;
 	var i0;
 	var i1;
@@ -136,6 +133,7 @@ function assign7d( x, y, isRowMajor ) {
 	var i4;
 	var i5;
 	var i6;
+	var v;
 
 	// Note on variable naming convention: S#, dy#, i# where # corresponds to the loop number, with `0` being the innermost loop...
 
@@ -151,13 +149,13 @@ function assign7d( x, y, isRowMajor ) {
 		S4 = sh[ 2 ];
 		S5 = sh[ 1 ];
 		S6 = sh[ 0 ];
-		dy0 = sy[ 6 ];
+		dy0 = sy[ 6 ];                // offset increment for innermost loop
 		dy1 = sy[ 5 ] - ( S0*sy[6] );
 		dy2 = sy[ 4 ] - ( S1*sy[5] );
 		dy3 = sy[ 3 ] - ( S2*sy[4] );
 		dy4 = sy[ 2 ] - ( S3*sy[3] );
 		dy5 = sy[ 1 ] - ( S4*sy[2] );
-		dy6 = sy[ 0 ] - ( S5*sy[1] );
+		dy6 = sy[ 0 ] - ( S5*sy[1] ); // offset increment for outermost loop
 	} else { // order === 'column-major'
 		// For column-major ndarrays, the first dimensions have the fastest changing indices...
 		S0 = sh[ 0 ];
@@ -167,25 +165,25 @@ function assign7d( x, y, isRowMajor ) {
 		S4 = sh[ 4 ];
 		S5 = sh[ 5 ];
 		S6 = sh[ 6 ];
-		dy0 = sy[ 0 ];
+		dy0 = sy[ 0 ];                // offset increment for innermost loop
 		dy1 = sy[ 1 ] - ( S0*sy[0] );
 		dy2 = sy[ 2 ] - ( S1*sy[1] );
 		dy3 = sy[ 3 ] - ( S2*sy[2] );
 		dy4 = sy[ 4 ] - ( S3*sy[3] );
 		dy5 = sy[ 5 ] - ( S4*sy[4] );
-		dy6 = sy[ 6 ] - ( S5*sy[5] );
+		dy6 = sy[ 6 ] - ( S5*sy[5] ); // offset increment for outermost loop
 	}
-	// Set the pointers to the first indexed elements in the respective ndarrays...
-	ix = x.offset;
+	// Set a pointer to the first indexed element in the output ndarray:
 	iy = y.offset;
 
-	// Cache references to the input and output ndarray buffers...
-	xbuf = x.data;
+	// Cache a reference to the output ndarray buffer:
 	ybuf = y.data;
 
-	// Cache accessors:
-	get = x.accessors[0];
-	set = y.accessors[1];
+	// Cache the output accessor:
+	set = y.accessors[ 1 ];
+
+	// Cache the scalar value:
+	v = x.accessors[ 0 ]( x.data, x.offset );
 
 	// Iterate over the ndarray dimensions...
 	for ( i6 = 0; i6 < S6; i6++ ) {
@@ -195,7 +193,7 @@ function assign7d( x, y, isRowMajor ) {
 					for ( i2 = 0; i2 < S2; i2++ ) {
 						for ( i1 = 0; i1 < S1; i1++ ) {
 							for ( i0 = 0; i0 < S0; i0++ ) {
-								set( ybuf, iy, get( xbuf, ix ) );
+								set( ybuf, iy, v );
 								iy += dy0;
 							}
 							iy += dy1;
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/7d_blocked.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/7d_blocked.js
index d11393f446c5..8ca4ad1b5b4a 100644
--- a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/7d_blocked.js
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/7d_blocked.js
@@ -92,7 +92,6 @@ var blockSize = require( '@stdlib/ndarray/base/nullary-tiling-block-size' );
 */
 function blockedassign7d( x, y ) { // eslint-disable-line max-statements
 	var bsize;
-	var xbuf;
 	var ybuf;
 	var dy0;
 	var dy1;
@@ -117,7 +116,6 @@ function blockedassign7d( x, y ) { // eslint-disable-line max-statements
 	var s6;
 	var sy;
 	var oy;
-	var ix;
 	var iy;
 	var i0;
 	var i1;
@@ -134,6 +132,7 @@ function blockedassign7d( x, y ) { // eslint-disable-line max-statements
 	var j5;
 	var j6;
 	var o;
+	var v;
 
 	// Note on variable naming convention: s#, dy#, i#, j# where # corresponds to the loop number, with `0` being the innermost loop...
 
@@ -145,15 +144,16 @@ function blockedassign7d( x, y ) { // eslint-disable-line max-statements
 	// Determine the block size:
 	bsize = blockSize( y.dtype );
 
-	// Cache the indices of the first indexed elements in the respective ndarrays...
-	ix = x.offset;
+	// Cache the index of the first indexed element in the output ndarray:
 	oy = y.offset;
 
-	// Cache references to the input and output ndarray buffers...
-	xbuf = x.data;
+	// Cache a reference to the output ndarray buffer:
 	ybuf = y.data;
 
-	// Cache the offset increment for the innermost loop...
+	// Cache the scalar value:
+	v = x.data[ x.offset ];
+
+	// Cache the offset increment for the innermost loop:
 	dy0 = sy[0];
 
 	// Iterate over blocks...
@@ -238,7 +238,7 @@ function blockedassign7d( x, y ) { // eslint-disable-line max-statements
 												for ( i2 = 0; i2 < s2; i2++ ) {
 													for ( i1 = 0; i1 < s1; i1++ ) {
 														for ( i0 = 0; i0 < s0; i0++ ) {
-															ybuf[ iy ] = xbuf[ ix ];
+															ybuf[ iy ] = v;
 															iy += dy0;
 														}
 														iy += dy1;
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/7d_blocked_accessors.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/7d_blocked_accessors.js
index c4be0e7c4b57..d560420517ea 100644
--- a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/7d_blocked_accessors.js
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/7d_blocked_accessors.js
@@ -113,9 +113,7 @@ var blockSize = require( '@stdlib/ndarray/base/nullary-tiling-block-size' );
 */
 function blockedassign7d( x, y ) { // eslint-disable-line max-statements
 	var bsize;
-	var xbuf;
 	var ybuf;
-	var get;
 	var set;
 	var dy0;
 	var dy1;
@@ -140,7 +138,6 @@ function blockedassign7d( x, y ) { // eslint-disable-line max-statements
 	var s6;
 	var sy;
 	var oy;
-	var ix;
 	var iy;
 	var i0;
 	var i1;
@@ -157,6 +154,7 @@ function blockedassign7d( x, y ) { // eslint-disable-line max-statements
 	var j5;
 	var j6;
 	var o;
+	var v;
 
 	// Note on variable naming convention: s#, dy#, i#, j# where # corresponds to the loop number, with `0` being the innermost loop...
 
@@ -168,20 +166,20 @@ function blockedassign7d( x, y ) { // eslint-disable-line max-statements
 	// Determine the block size:
 	bsize = blockSize( y.dtype );
 
-	// Cache the indices of the first indexed elements in the respective ndarrays...
-	ix = x.offset;
+	// Cache the index of the first indexed element in the output ndarray:
 	oy = y.offset;
 
-	// Cache references to the input and output ndarray buffers...
-	xbuf = x.data;
+	// Cache a reference to the output ndarray buffer:
 	ybuf = y.data;
 
-	// Cache the offset increment for the innermost loop...
+	// Cache the offset increment for the innermost loop:
 	dy0 = sy[0];
 
-	// Cache accessors:
-	get = x.accessors[0];
-	set = y.accessors[1];
+	// Cache the output accessor:
+	set = y.accessors[ 1 ];
+
+	// Cache the scalar value:
+	v = x.accessors[ 0 ]( x.data, x.offset );
 
 	// Iterate over blocks...
 	for ( j6 = sh[6]; j6 > 0; ) {
@@ -265,7 +263,7 @@ function blockedassign7d( x, y ) { // eslint-disable-line max-statements
 												for ( i2 = 0; i2 < s2; i2++ ) {
 													for ( i1 = 0; i1 < s1; i1++ ) {
 														for ( i0 = 0; i0 < s0; i0++ ) {
-															set( ybuf, iy, get( xbuf, ix ) );
+															set( ybuf, iy, v );
 															iy += dy0;
 														}
 														iy += dy1;
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/7d_blocked_complex.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/7d_blocked_complex.js
new file mode 100644
index 000000000000..370a7143c8bc
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/7d_blocked_complex.js
@@ -0,0 +1,249 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2026 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-depth */
+
+'use strict';
+
+// MODULES //
+
+var loopOrder = require( '@stdlib/ndarray/base/nullary-loop-interchange-order' );
+var blockSize = require( '@stdlib/ndarray/base/nullary-tiling-block-size' );
+
+
+// MAIN //
+
+/**
+* Assigns a scalar value to every element of a reinterpreted complex number seven-dimensional output ndarray via loop blocking.
+*
+* @private
+* @param {number} re - real component
+* @param {number} im - imaginary component
+* @param {Object} y - object containing output ndarray meta data
+* @param {*} y.dtype - data type
+* @param {Collection} y.data - data buffer
+* @param {NonNegativeIntegerArray} y.shape - dimensions
+* @param {IntegerArray} y.strides - stride lengths
+* @param {NonNegativeInteger} y.offset - index offset
+* @param {string} y.order - specifies whether `y` is row-major (C-style) or column-major (Fortran-style)
+* @returns {void}
+*
+* @example
+* var Float64Array = require( '@stdlib/array/float64' );
+*
+* // Create a data buffer:
+* var ybuf = new Float64Array( 12 );
+*
+* // Define the shape of the output array:
+* var shape = [ 1, 1, 1, 1, 3, 1, 2 ];
+*
+* // Define the array strides:
+* var sy = [ 12, 12, 12, 12, 4, 4, 2 ];
+*
+* // Define the index offset:
+* var oy = 0;
+*
+* // Create the output ndarray-like object:
+* var y = {
+*     'dtype': 'float64',
+*     'data': ybuf,
+*     'shape': shape,
+*     'strides': sy,
+*     'offset': oy,
+*     'order': 'row-major'
+* };
+*
+* // Assign scalar:
+* blockedassign7d( 2.0, 2.0, y );
+*
+* console.log( y.data );
+* // => <Float64Array>[ 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0 ]
+*/
+function blockedassign7d( re, im, y ) {
+	var bsize;
+	var ybuf;
+	var dy0;
+	var dy1;
+	var dy2;
+	var dy3;
+	var dy4;
+	var dy5;
+	var dy6;
+	var oy1;
+	var oy2;
+	var oy3;
+	var oy4;
+	var oy5;
+	var oy6;
+	var sh;
+	var s0;
+	var s1;
+	var s2;
+	var s3;
+	var s4;
+	var s5;
+	var s6;
+	var sy;
+	var oy;
+	var iy;
+	var i0;
+	var i1;
+	var i2;
+	var i3;
+	var i4;
+	var i5;
+	var i6;
+	var j0;
+	var j1;
+	var j2;
+	var j3;
+	var j4;
+	var j5;
+	var j6;
+	var o;
+
+	// Note on variable naming convention: s#, dy#, i#, j# where # corresponds to the loop number, with `0` being the innermost loop...
+
+	// Resolve the loop interchange order:
+	o = loopOrder( y.shape, y.strides );
+	sh = o.sh;
+	sy = o.sx;
+
+	// Determine the block size:
+	bsize = blockSize( y.dtype );
+
+	// Cache the index of the first indexed element in the output ndarray:
+	oy = y.offset;
+
+	// Cache a reference to the output ndarray buffer:
+	ybuf = y.data;
+
+	// Cache the offset increment for the innermost loop:
+	dy0 = sy[0];
+
+	// Iterate over blocks...
+	for ( j6 = sh[6]; j6 > 0; ) {
+		if ( j6 < bsize ) {
+			s6 = j6;
+			j6 = 0;
+		} else {
+			s6 = bsize;
+			j6 -= bsize;
+		}
+		oy6 = oy + ( j6*sy[6] );
+		for ( j5 = sh[5]; j5 > 0; ) {
+			if ( j5 < bsize ) {
+				s5 = j5;
+				j5 = 0;
+			} else {
+				s5 = bsize;
+				j5 -= bsize;
+			}
+			dy6 = sy[6] - ( s5*sy[5] );
+			oy5 = oy6 + ( j5*sy[5] );
+			for ( j4 = sh[4]; j4 > 0; ) {
+				if ( j4 < bsize ) {
+					s4 = j4;
+					j4 = 0;
+				} else {
+					s4 = bsize;
+					j4 -= bsize;
+				}
+				dy5 = sy[5] - ( s4*sy[4] );
+				oy4 = oy5 + ( j4*sy[4] );
+				for ( j3 = sh[3]; j3 > 0; ) {
+					if ( j3 < bsize ) {
+						s3 = j3;
+						j3 = 0;
+					} else {
+						s3 = bsize;
+						j3 -= bsize;
+					}
+					dy4 = sy[4] - ( s3*sy[3] );
+					oy3 = oy4 + ( j3*sy[3] );
+					for ( j2 = sh[2]; j2 > 0; ) {
+						if ( j2 < bsize ) {
+							s2 = j2;
+							j2 = 0;
+						} else {
+							s2 = bsize;
+							j2 -= bsize;
+						}
+						dy3 = sy[3] - ( s2*sy[2] );
+						oy2 = oy3 + ( j2*sy[2] );
+						for ( j1 = sh[1]; j1 > 0; ) {
+							if ( j1 < bsize ) {
+								s1 = j1;
+								j1 = 0;
+							} else {
+								s1 = bsize;
+								j1 -= bsize;
+							}
+							dy2 = sy[2] - ( s1*sy[1] );
+							oy1 = oy2 + ( j1*sy[1] );
+							for ( j0 = sh[0]; j0 > 0; ) {
+								if ( j0 < bsize ) {
+									s0 = j0;
+									j0 = 0;
+								} else {
+									s0 = bsize;
+									j0 -= bsize;
+								}
+								// Compute the index offset for the first output ndarray element in the current block...
+								iy = oy1 + ( j0*sy[0] );
+
+								// Compute the loop offset increment...
+								dy1 = sy[1] - ( s0*sy[0] );
+
+								// Iterate over the ndarray dimensions...
+								for ( i6 = 0; i6 < s6; i6++ ) {
+									for ( i5 = 0; i5 < s5; i5++ ) {
+										for ( i4 = 0; i4 < s4; i4++ ) {
+											for ( i3 = 0; i3 < s3; i3++ ) {
+												for ( i2 = 0; i2 < s2; i2++ ) {
+													for ( i1 = 0; i1 < s1; i1++ ) {
+														for ( i0 = 0; i0 < s0; i0++ ) {
+															ybuf[ iy ] = re;
+															ybuf[ iy+1 ] = im;
+															iy += dy0;
+														}
+														iy += dy1;
+													}
+													iy += dy2;
+												}
+												iy += dy3;
+											}
+											iy += dy4;
+										}
+										iy += dy5;
+									}
+									iy += dy6;
+								}
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+}
+
+
+// EXPORTS //
+
+module.exports = blockedassign7d;
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/7d_complex.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/7d_complex.js
new file mode 100644
index 000000000000..e52f5c845fc4
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/7d_complex.js
@@ -0,0 +1,172 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2026 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-depth */
+
+'use strict';
+
+// MAIN //
+
+/**
+* Assigns a scalar value to every element of a reinterpreted complex number seven-dimensional output ndarray.
+*
+* @private
+* @param {number} re - real component
+* @param {number} im - imaginary component
+* @param {Object} y - object containing output ndarray meta data
+* @param {*} y.dtype - data type
+* @param {Collection} y.data - data buffer
+* @param {NonNegativeIntegerArray} y.shape - dimensions
+* @param {IntegerArray} y.strides - stride lengths
+* @param {NonNegativeInteger} y.offset - index offset
+* @param {string} y.order - specifies whether `y` is row-major (C-style) or column-major (Fortran-style)
+* @param {boolean} isRowMajor - boolean indicating if provided arrays are in row-major order
+* @returns {void}
+*
+* @example
+* var Float64Array = require( '@stdlib/array/float64' );
+*
+* // Create a data buffer:
+* var ybuf = new Float64Array( 12 );
+*
+* // Define the shape of the output array:
+* var shape = [ 1, 1, 1, 1, 3, 1, 2 ];
+*
+* // Define the array strides:
+* var sy = [ 12, 12, 12, 12, 4, 4, 2 ];
+*
+* // Define the index offset:
+* var oy = 0;
+*
+* // Create the output ndarray-like object:
+* var y = {
+*     'dtype': 'float64',
+*     'data': ybuf,
+*     'shape': shape,
+*     'strides': sy,
+*     'offset': oy,
+*     'order': 'row-major'
+* };
+*
+* // Assign scalar:
+* assign7d( 2.0, 2.0, y, true );
+*
+* console.log( y.data );
+* // => <Float64Array>[ 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0 ]
+*/
+function assign7d( re, im, y, isRowMajor ) {
+	var ybuf;
+	var dy0;
+	var dy1;
+	var dy2;
+	var dy3;
+	var dy4;
+	var dy5;
+	var dy6;
+	var sh;
+	var S0;
+	var S1;
+	var S2;
+	var S3;
+	var S4;
+	var S5;
+	var S6;
+	var sy;
+	var iy;
+	var i0;
+	var i1;
+	var i2;
+	var i3;
+	var i4;
+	var i5;
+	var i6;
+
+	// Note on variable naming convention: S#, dy#, i# where # corresponds to the loop number, with `0` being the innermost loop...
+
+	// Extract loop variables for purposes of loop interchange: dimensions and loop offset (pointer) increments...
+	sh = y.shape;
+	sy = y.strides;
+	if ( isRowMajor ) {
+		// For row-major ndarrays, the last dimensions have the fastest changing indices...
+		S0 = sh[ 6 ];
+		S1 = sh[ 5 ];
+		S2 = sh[ 4 ];
+		S3 = sh[ 3 ];
+		S4 = sh[ 2 ];
+		S5 = sh[ 1 ];
+		S6 = sh[ 0 ];
+		dy0 = sy[ 6 ];                // offset increment for innermost loop
+		dy1 = sy[ 5 ] - ( S0*sy[6] );
+		dy2 = sy[ 4 ] - ( S1*sy[5] );
+		dy3 = sy[ 3 ] - ( S2*sy[4] );
+		dy4 = sy[ 2 ] - ( S3*sy[3] );
+		dy5 = sy[ 1 ] - ( S4*sy[2] );
+		dy6 = sy[ 0 ] - ( S5*sy[1] ); // offset increment for outermost loop
+	} else { // order === 'column-major'
+		// For column-major ndarrays, the first dimensions have the fastest changing indices...
+		S0 = sh[ 0 ];
+		S1 = sh[ 1 ];
+		S2 = sh[ 2 ];
+		S3 = sh[ 3 ];
+		S4 = sh[ 4 ];
+		S5 = sh[ 5 ];
+		S6 = sh[ 6 ];
+		dy0 = sy[ 0 ];                // offset increment for innermost loop
+		dy1 = sy[ 1 ] - ( S0*sy[0] );
+		dy2 = sy[ 2 ] - ( S1*sy[1] );
+		dy3 = sy[ 3 ] - ( S2*sy[2] );
+		dy4 = sy[ 4 ] - ( S3*sy[3] );
+		dy5 = sy[ 5 ] - ( S4*sy[4] );
+		dy6 = sy[ 6 ] - ( S5*sy[5] ); // offset increment for outermost loop
+	}
+	// Set a pointer to the first indexed element in the output ndarray:
+	iy = y.offset;
+
+	// Cache a reference to the output ndarray buffer:
+	ybuf = y.data;
+
+	// Iterate over the ndarray dimensions...
+	for ( i6 = 0; i6 < S6; i6++ ) {
+		for ( i5 = 0; i5 < S5; i5++ ) {
+			for ( i4 = 0; i4 < S4; i4++ ) {
+				for ( i3 = 0; i3 < S3; i3++ ) {
+					for ( i2 = 0; i2 < S2; i2++ ) {
+						for ( i1 = 0; i1 < S1; i1++ ) {
+							for ( i0 = 0; i0 < S0; i0++ ) {
+								ybuf[ iy ] = re;
+								ybuf[ iy+1 ] = im;
+								iy += dy0;
+							}
+							iy += dy1;
+						}
+						iy += dy2;
+					}
+					iy += dy3;
+				}
+				iy += dy4;
+			}
+			iy += dy5;
+		}
+		iy += dy6;
+	}
+}
+
+
+// EXPORTS //
+
+module.exports = assign7d;
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/8d.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/8d.js
index 314e414f5629..41a0622320ab 100644
--- a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/8d.js
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/8d.js
@@ -86,7 +86,6 @@
 * // => <Float64Array>[ 2.0, 2.0, 2.0, 2.0, 2.0, 2.0 ]
 */
 function assign8d( x, y, isRowMajor ) {
-	var xbuf;
 	var ybuf;
 	var dy0;
 	var dy1;
@@ -106,7 +105,6 @@ function assign8d( x, y, isRowMajor ) {
 	var S6;
 	var S7;
 	var sy;
-	var ix;
 	var iy;
 	var i0;
 	var i1;
@@ -116,6 +114,7 @@ function assign8d( x, y, isRowMajor ) {
 	var i5;
 	var i6;
 	var i7;
+	var v;
 
 	// Note on variable naming convention: S#, dy#, i# where # corresponds to the loop number, with `0` being the innermost loop...
 
@@ -132,14 +131,14 @@ function assign8d( x, y, isRowMajor ) {
 		S5 = sh[ 2 ];
 		S6 = sh[ 1 ];
 		S7 = sh[ 0 ];
-		dy0 = sy[ 7 ];
+		dy0 = sy[ 7 ];                // offset increment for innermost loop
 		dy1 = sy[ 6 ] - ( S0*sy[7] );
 		dy2 = sy[ 5 ] - ( S1*sy[6] );
 		dy3 = sy[ 4 ] - ( S2*sy[5] );
 		dy4 = sy[ 3 ] - ( S3*sy[4] );
 		dy5 = sy[ 2 ] - ( S4*sy[3] );
 		dy6 = sy[ 1 ] - ( S5*sy[2] );
-		dy7 = sy[ 0 ] - ( S6*sy[1] );
+		dy7 = sy[ 0 ] - ( S6*sy[1] ); // offset increment for outermost loop
 	} else { // order === 'column-major'
 		// For column-major ndarrays, the first dimensions have the fastest changing indices...
 		S0 = sh[ 0 ];
@@ -150,23 +149,24 @@ function assign8d( x, y, isRowMajor ) {
 		S5 = sh[ 5 ];
 		S6 = sh[ 6 ];
 		S7 = sh[ 7 ];
-		dy0 = sy[ 0 ];
+		dy0 = sy[ 0 ];                // offset increment for innermost loop
 		dy1 = sy[ 1 ] - ( S0*sy[0] );
 		dy2 = sy[ 2 ] - ( S1*sy[1] );
 		dy3 = sy[ 3 ] - ( S2*sy[2] );
 		dy4 = sy[ 4 ] - ( S3*sy[3] );
 		dy5 = sy[ 5 ] - ( S4*sy[4] );
 		dy6 = sy[ 6 ] - ( S5*sy[5] );
-		dy7 = sy[ 7 ] - ( S6*sy[6] );
+		dy7 = sy[ 7 ] - ( S6*sy[6] ); // offset increment for outermost loop
 	}
-	// Set the pointers to the first indexed elements in the respective ndarrays...
-	ix = x.offset;
+	// Set a pointer to the first indexed element in the output ndarray:
 	iy = y.offset;
 
-	// Cache references to the input and output ndarray buffers...
-	xbuf = x.data;
+	// Cache a reference to the output ndarray buffer:
 	ybuf = y.data;
 
+	// Cache the scalar value:
+	v = x.data[ x.offset ];
+
 	// Iterate over the ndarray dimensions...
 	for ( i7 = 0; i7 < S7; i7++ ) {
 		for ( i6 = 0; i6 < S6; i6++ ) {
@@ -176,7 +176,7 @@ function assign8d( x, y, isRowMajor ) {
 						for ( i2 = 0; i2 < S2; i2++ ) {
 							for ( i1 = 0; i1 < S1; i1++ ) {
 								for ( i0 = 0; i0 < S0; i0++ ) {
-									ybuf[ iy ] = xbuf[ ix ];
+									ybuf[ iy ] = v;
 									iy += dy0;
 								}
 								iy += dy1;
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/8d_accessors.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/8d_accessors.js
index e7ed9e51ee23..9c589944d4c5 100644
--- a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/8d_accessors.js
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/8d_accessors.js
@@ -107,9 +107,7 @@
 * // returns 2.0
 */
 function assign8d( x, y, isRowMajor ) {
-	var xbuf;
 	var ybuf;
-	var get;
 	var set;
 	var dy0;
 	var dy1;
@@ -129,7 +127,6 @@ function assign8d( x, y, isRowMajor ) {
 	var S6;
 	var S7;
 	var sy;
-	var ix;
 	var iy;
 	var i0;
 	var i1;
@@ -139,6 +136,7 @@ function assign8d( x, y, isRowMajor ) {
 	var i5;
 	var i6;
 	var i7;
+	var v;
 
 	// Note on variable naming convention: S#, dy#, i# where # corresponds to the loop number, with `0` being the innermost loop...
 
@@ -155,14 +153,14 @@ function assign8d( x, y, isRowMajor ) {
 		S5 = sh[ 2 ];
 		S6 = sh[ 1 ];
 		S7 = sh[ 0 ];
-		dy0 = sy[ 7 ];
+		dy0 = sy[ 7 ];                // offset increment for innermost loop
 		dy1 = sy[ 6 ] - ( S0*sy[7] );
 		dy2 = sy[ 5 ] - ( S1*sy[6] );
 		dy3 = sy[ 4 ] - ( S2*sy[5] );
 		dy4 = sy[ 3 ] - ( S3*sy[4] );
 		dy5 = sy[ 2 ] - ( S4*sy[3] );
 		dy6 = sy[ 1 ] - ( S5*sy[2] );
-		dy7 = sy[ 0 ] - ( S6*sy[1] );
+		dy7 = sy[ 0 ] - ( S6*sy[1] ); // offset increment for outermost loop
 	} else { // order === 'column-major'
 		// For column-major ndarrays, the first dimensions have the fastest changing indices...
 		S0 = sh[ 0 ];
@@ -173,26 +171,26 @@ function assign8d( x, y, isRowMajor ) {
 		S5 = sh[ 5 ];
 		S6 = sh[ 6 ];
 		S7 = sh[ 7 ];
-		dy0 = sy[ 0 ];
+		dy0 = sy[ 0 ];                // offset increment for innermost loop
 		dy1 = sy[ 1 ] - ( S0*sy[0] );
 		dy2 = sy[ 2 ] - ( S1*sy[1] );
 		dy3 = sy[ 3 ] - ( S2*sy[2] );
 		dy4 = sy[ 4 ] - ( S3*sy[3] );
 		dy5 = sy[ 5 ] - ( S4*sy[4] );
 		dy6 = sy[ 6 ] - ( S5*sy[5] );
-		dy7 = sy[ 7 ] - ( S6*sy[6] );
+		dy7 = sy[ 7 ] - ( S6*sy[6] ); // offset increment for outermost loop
 	}
-	// Set the pointers to the first indexed elements in the respective ndarrays...
-	ix = x.offset;
+	// Set a pointer to the first indexed element in the output ndarray:
 	iy = y.offset;
 
-	// Cache references to the input and output ndarray buffers...
-	xbuf = x.data;
+	// Cache a reference to the output ndarray buffer:
 	ybuf = y.data;
 
-	// Cache accessors:
-	get = x.accessors[0];
-	set = y.accessors[1];
+	// Cache the output accessor:
+	set = y.accessors[ 1 ];
+
+	// Cache the scalar value:
+	v = x.accessors[ 0 ]( x.data, x.offset );
 
 	// Iterate over the ndarray dimensions...
 	for ( i7 = 0; i7 < S7; i7++ ) {
@@ -203,7 +201,7 @@ function assign8d( x, y, isRowMajor ) {
 						for ( i2 = 0; i2 < S2; i2++ ) {
 							for ( i1 = 0; i1 < S1; i1++ ) {
 								for ( i0 = 0; i0 < S0; i0++ ) {
-									set( ybuf, iy, get( xbuf, ix ) );
+									set( ybuf, iy, v );
 									iy += dy0;
 								}
 								iy += dy1;
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/8d_blocked.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/8d_blocked.js
index 6d2d3bf1b3c6..ec4ec74d0367 100644
--- a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/8d_blocked.js
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/8d_blocked.js
@@ -92,7 +92,6 @@ var blockSize = require( '@stdlib/ndarray/base/nullary-tiling-block-size' );
 */
 function blockedassign8d( x, y ) { // eslint-disable-line max-statements
 	var bsize;
-	var xbuf;
 	var ybuf;
 	var dy0;
 	var dy1;
@@ -120,7 +119,6 @@ function blockedassign8d( x, y ) { // eslint-disable-line max-statements
 	var s7;
 	var sy;
 	var oy;
-	var ix;
 	var iy;
 	var i0;
 	var i1;
@@ -139,6 +137,7 @@ function blockedassign8d( x, y ) { // eslint-disable-line max-statements
 	var j6;
 	var j7;
 	var o;
+	var v;
 
 	// Note on variable naming convention: s#, dy#, i#, j# where # corresponds to the loop number, with `0` being the innermost loop...
 
@@ -150,15 +149,16 @@ function blockedassign8d( x, y ) { // eslint-disable-line max-statements
 	// Determine the block size:
 	bsize = blockSize( y.dtype );
 
-	// Cache the indices of the first indexed elements in the respective ndarrays...
-	ix = x.offset;
+	// Cache the index of the first indexed element in the output ndarray:
 	oy = y.offset;
 
-	// Cache references to the input and output ndarray buffers...
-	xbuf = x.data;
+	// Cache a reference to the output ndarray buffer:
 	ybuf = y.data;
 
-	// Cache the offset increment for the innermost loop...
+	// Cache the scalar value:
+	v = x.data[ x.offset ];
+
+	// Cache the offset increment for the innermost loop:
 	dy0 = sy[0];
 
 	// Iterate over blocks...
@@ -254,7 +254,7 @@ function blockedassign8d( x, y ) { // eslint-disable-line max-statements
 														for ( i2 = 0; i2 < s2; i2++ ) {
 															for ( i1 = 0; i1 < s1; i1++ ) {
 																for ( i0 = 0; i0 < s0; i0++ ) {
-																	ybuf[ iy ] = xbuf[ ix ];
+																	ybuf[ iy ] = v;
 																	iy += dy0;
 																}
 																iy += dy1;
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/8d_blocked_accessors.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/8d_blocked_accessors.js
index c2bba1ed2e8c..43aeb6b2fb96 100644
--- a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/8d_blocked_accessors.js
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/8d_blocked_accessors.js
@@ -113,9 +113,7 @@ var blockSize = require( '@stdlib/ndarray/base/nullary-tiling-block-size' );
 */
 function blockedassign8d( x, y ) { // eslint-disable-line max-statements
 	var bsize;
-	var xbuf;
 	var ybuf;
-	var get;
 	var set;
 	var dy0;
 	var dy1;
@@ -143,7 +141,6 @@ function blockedassign8d( x, y ) { // eslint-disable-line max-statements
 	var s7;
 	var sy;
 	var oy;
-	var ix;
 	var iy;
 	var i0;
 	var i1;
@@ -162,6 +159,7 @@ function blockedassign8d( x, y ) { // eslint-disable-line max-statements
 	var j6;
 	var j7;
 	var o;
+	var v;
 
 	// Note on variable naming convention: s#, dy#, i#, j# where # corresponds to the loop number, with `0` being the innermost loop...
 
@@ -173,20 +171,20 @@ function blockedassign8d( x, y ) { // eslint-disable-line max-statements
 	// Determine the block size:
 	bsize = blockSize( y.dtype );
 
-	// Cache the indices of the first indexed elements in the respective ndarrays...
-	ix = x.offset;
+	// Cache the index of the first indexed element in the output ndarray:
 	oy = y.offset;
 
-	// Cache references to the input and output ndarray buffers...
-	xbuf = x.data;
+	// Cache a reference to the output ndarray buffer:
 	ybuf = y.data;
 
-	// Cache the offset increment for the innermost loop...
+	// Cache the offset increment for the innermost loop:
 	dy0 = sy[0];
 
-	// Cache accessors:
-	get = x.accessors[0];
-	set = y.accessors[1];
+	// Cache the output accessor:
+	set = y.accessors[ 1 ];
+
+	// Cache the scalar value:
+	v = x.accessors[ 0 ]( x.data, x.offset );
 
 	// Iterate over blocks...
 	for ( j7 = sh[7]; j7 > 0; ) {
@@ -281,7 +279,7 @@ function blockedassign8d( x, y ) { // eslint-disable-line max-statements
 														for ( i2 = 0; i2 < s2; i2++ ) {
 															for ( i1 = 0; i1 < s1; i1++ ) {
 																for ( i0 = 0; i0 < s0; i0++ ) {
-																	set( ybuf, iy, get( xbuf, ix ) );
+																	set( ybuf, iy, v );
 																	iy += dy0;
 																}
 																iy += dy1;
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/8d_blocked_complex.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/8d_blocked_complex.js
new file mode 100644
index 000000000000..d54107cbee7f
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/8d_blocked_complex.js
@@ -0,0 +1,268 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2026 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-depth */
+
+'use strict';
+
+// MODULES //
+
+var loopOrder = require( '@stdlib/ndarray/base/nullary-loop-interchange-order' );
+var blockSize = require( '@stdlib/ndarray/base/nullary-tiling-block-size' );
+
+
+// MAIN //
+
+/**
+* Assigns a scalar value to every element of a reinterpreted complex number eight-dimensional output ndarray via loop blocking.
+*
+* @private
+* @param {number} re - real component
+* @param {number} im - imaginary component
+* @param {Object} y - object containing output ndarray meta data
+* @param {*} y.dtype - data type
+* @param {Collection} y.data - data buffer
+* @param {NonNegativeIntegerArray} y.shape - dimensions
+* @param {IntegerArray} y.strides - stride lengths
+* @param {NonNegativeInteger} y.offset - index offset
+* @param {string} y.order - specifies whether `y` is row-major (C-style) or column-major (Fortran-style)
+* @returns {void}
+*
+* @example
+* var Float64Array = require( '@stdlib/array/float64' );
+*
+* // Create a data buffer:
+* var ybuf = new Float64Array( 12 );
+*
+* // Define the shape of the output array:
+* var shape = [ 1, 1, 1, 1, 1, 3, 1, 2 ];
+*
+* // Define the array strides:
+* var sy = [ 12, 12, 12, 12, 12, 4, 4, 2 ];
+*
+* // Define the index offset:
+* var oy = 0;
+*
+* // Create the output ndarray-like object:
+* var y = {
+*     'dtype': 'float64',
+*     'data': ybuf,
+*     'shape': shape,
+*     'strides': sy,
+*     'offset': oy,
+*     'order': 'row-major'
+* };
+*
+* // Assign scalar:
+* blockedassign8d( 2.0, 2.0, y );
+*
+* console.log( y.data );
+* // => <Float64Array>[ 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0 ]
+*/
+function blockedassign8d( re, im, y ) {
+	var bsize;
+	var ybuf;
+	var dy0;
+	var dy1;
+	var dy2;
+	var dy3;
+	var dy4;
+	var dy5;
+	var dy6;
+	var dy7;
+	var oy1;
+	var oy2;
+	var oy3;
+	var oy4;
+	var oy5;
+	var oy6;
+	var oy7;
+	var sh;
+	var s0;
+	var s1;
+	var s2;
+	var s3;
+	var s4;
+	var s5;
+	var s6;
+	var s7;
+	var sy;
+	var oy;
+	var iy;
+	var i0;
+	var i1;
+	var i2;
+	var i3;
+	var i4;
+	var i5;
+	var i6;
+	var i7;
+	var j0;
+	var j1;
+	var j2;
+	var j3;
+	var j4;
+	var j5;
+	var j6;
+	var j7;
+	var o;
+
+	// Note on variable naming convention: s#, dy#, i#, j# where # corresponds to the loop number, with `0` being the innermost loop...
+
+	// Resolve the loop interchange order:
+	o = loopOrder( y.shape, y.strides );
+	sh = o.sh;
+	sy = o.sx;
+
+	// Determine the block size:
+	bsize = blockSize( y.dtype );
+
+	// Cache the index of the first indexed element in the output ndarray:
+	oy = y.offset;
+
+	// Cache a reference to the output ndarray buffer:
+	ybuf = y.data;
+
+	// Cache the offset increment for the innermost loop:
+	dy0 = sy[0];
+
+	// Iterate over blocks...
+	for ( j7 = sh[7]; j7 > 0; ) {
+		if ( j7 < bsize ) {
+			s7 = j7;
+			j7 = 0;
+		} else {
+			s7 = bsize;
+			j7 -= bsize;
+		}
+		oy7 = oy + ( j7*sy[7] );
+		for ( j6 = sh[6]; j6 > 0; ) {
+			if ( j6 < bsize ) {
+				s6 = j6;
+				j6 = 0;
+			} else {
+				s6 = bsize;
+				j6 -= bsize;
+			}
+			dy7 = sy[7] - ( s6*sy[6] );
+			oy6 = oy7 + ( j6*sy[6] );
+			for ( j5 = sh[5]; j5 > 0; ) {
+				if ( j5 < bsize ) {
+					s5 = j5;
+					j5 = 0;
+				} else {
+					s5 = bsize;
+					j5 -= bsize;
+				}
+				dy6 = sy[6] - ( s5*sy[5] );
+				oy5 = oy6 + ( j5*sy[5] );
+				for ( j4 = sh[4]; j4 > 0; ) {
+					if ( j4 < bsize ) {
+						s4 = j4;
+						j4 = 0;
+					} else {
+						s4 = bsize;
+						j4 -= bsize;
+					}
+					dy5 = sy[5] - ( s4*sy[4] );
+					oy4 = oy5 + ( j4*sy[4] );
+					for ( j3 = sh[3]; j3 > 0; ) {
+						if ( j3 < bsize ) {
+							s3 = j3;
+							j3 = 0;
+						} else {
+							s3 = bsize;
+							j3 -= bsize;
+						}
+						dy4 = sy[4] - ( s3*sy[3] );
+						oy3 = oy4 + ( j3*sy[3] );
+						for ( j2 = sh[2]; j2 > 0; ) {
+							if ( j2 < bsize ) {
+								s2 = j2;
+								j2 = 0;
+							} else {
+								s2 = bsize;
+								j2 -= bsize;
+							}
+							dy3 = sy[3] - ( s2*sy[2] );
+							oy2 = oy3 + ( j2*sy[2] );
+							for ( j1 = sh[1]; j1 > 0; ) {
+								if ( j1 < bsize ) {
+									s1 = j1;
+									j1 = 0;
+								} else {
+									s1 = bsize;
+									j1 -= bsize;
+								}
+								dy2 = sy[2] - ( s1*sy[1] );
+								oy1 = oy2 + ( j1*sy[1] );
+								for ( j0 = sh[0]; j0 > 0; ) {
+									if ( j0 < bsize ) {
+										s0 = j0;
+										j0 = 0;
+									} else {
+										s0 = bsize;
+										j0 -= bsize;
+									}
+									// Compute the index offset for the first output ndarray element in the current block...
+									iy = oy1 + ( j0*sy[0] );
+
+									// Compute the loop offset increment...
+									dy1 = sy[1] - ( s0*sy[0] );
+
+									// Iterate over the ndarray dimensions...
+									for ( i7 = 0; i7 < s7; i7++ ) {
+										for ( i6 = 0; i6 < s6; i6++ ) {
+											for ( i5 = 0; i5 < s5; i5++ ) {
+												for ( i4 = 0; i4 < s4; i4++ ) {
+													for ( i3 = 0; i3 < s3; i3++ ) {
+														for ( i2 = 0; i2 < s2; i2++ ) {
+															for ( i1 = 0; i1 < s1; i1++ ) {
+																for ( i0 = 0; i0 < s0; i0++ ) {
+																	ybuf[ iy ] = re;
+																	ybuf[ iy+1 ] = im;
+																	iy += dy0;
+																}
+																iy += dy1;
+															}
+															iy += dy2;
+														}
+														iy += dy3;
+													}
+													iy += dy4;
+												}
+												iy += dy5;
+											}
+											iy += dy6;
+										}
+										iy += dy7;
+									}
+								}
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+}
+
+
+// EXPORTS //
+
+module.exports = blockedassign8d;
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/8d_complex.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/8d_complex.js
new file mode 100644
index 000000000000..e72eed9bd578
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/8d_complex.js
@@ -0,0 +1,182 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2026 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-depth */
+
+'use strict';
+
+// MAIN //
+
+/**
+* Assigns a scalar value to every element of a reinterpreted complex number eight-dimensional output ndarray.
+*
+* @private
+* @param {number} re - real component
+* @param {number} im - imaginary component
+* @param {Object} y - object containing output ndarray meta data
+* @param {*} y.dtype - data type
+* @param {Collection} y.data - data buffer
+* @param {NonNegativeIntegerArray} y.shape - dimensions
+* @param {IntegerArray} y.strides - stride lengths
+* @param {NonNegativeInteger} y.offset - index offset
+* @param {string} y.order - specifies whether `y` is row-major (C-style) or column-major (Fortran-style)
+* @param {boolean} isRowMajor - boolean indicating if provided arrays are in row-major order
+* @returns {void}
+*
+* @example
+* var Float64Array = require( '@stdlib/array/float64' );
+*
+* // Create a data buffer:
+* var ybuf = new Float64Array( 12 );
+*
+* // Define the shape of the output array:
+* var shape = [ 1, 1, 1, 1, 1, 3, 1, 2 ];
+*
+* // Define the array strides:
+* var sy = [ 12, 12, 12, 12, 12, 4, 4, 2 ];
+*
+* // Define the index offset:
+* var oy = 0;
+*
+* // Create the output ndarray-like object:
+* var y = {
+*     'dtype': 'float64',
+*     'data': ybuf,
+*     'shape': shape,
+*     'strides': sy,
+*     'offset': oy,
+*     'order': 'row-major'
+* };
+*
+* // Assign scalar:
+* assign8d( 2.0, 2.0, y, true );
+*
+* console.log( y.data );
+* // => <Float64Array>[ 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0 ]
+*/
+function assign8d( re, im, y, isRowMajor ) {
+	var ybuf;
+	var dy0;
+	var dy1;
+	var dy2;
+	var dy3;
+	var dy4;
+	var dy5;
+	var dy6;
+	var dy7;
+	var sh;
+	var S0;
+	var S1;
+	var S2;
+	var S3;
+	var S4;
+	var S5;
+	var S6;
+	var S7;
+	var sy;
+	var iy;
+	var i0;
+	var i1;
+	var i2;
+	var i3;
+	var i4;
+	var i5;
+	var i6;
+	var i7;
+
+	// Note on variable naming convention: S#, dy#, i# where # corresponds to the loop number, with `0` being the innermost loop...
+
+	// Extract loop variables for purposes of loop interchange: dimensions and loop offset (pointer) increments...
+	sh = y.shape;
+	sy = y.strides;
+	if ( isRowMajor ) {
+		// For row-major ndarrays, the last dimensions have the fastest changing indices...
+		S0 = sh[ 7 ];
+		S1 = sh[ 6 ];
+		S2 = sh[ 5 ];
+		S3 = sh[ 4 ];
+		S4 = sh[ 3 ];
+		S5 = sh[ 2 ];
+		S6 = sh[ 1 ];
+		S7 = sh[ 0 ];
+		dy0 = sy[ 7 ];                // offset increment for innermost loop
+		dy1 = sy[ 6 ] - ( S0*sy[7] );
+		dy2 = sy[ 5 ] - ( S1*sy[6] );
+		dy3 = sy[ 4 ] - ( S2*sy[5] );
+		dy4 = sy[ 3 ] - ( S3*sy[4] );
+		dy5 = sy[ 2 ] - ( S4*sy[3] );
+		dy6 = sy[ 1 ] - ( S5*sy[2] );
+		dy7 = sy[ 0 ] - ( S6*sy[1] ); // offset increment for outermost loop
+	} else { // order === 'column-major'
+		// For column-major ndarrays, the first dimensions have the fastest changing indices...
+		S0 = sh[ 0 ];
+		S1 = sh[ 1 ];
+		S2 = sh[ 2 ];
+		S3 = sh[ 3 ];
+		S4 = sh[ 4 ];
+		S5 = sh[ 5 ];
+		S6 = sh[ 6 ];
+		S7 = sh[ 7 ];
+		dy0 = sy[ 0 ];                // offset increment for innermost loop
+		dy1 = sy[ 1 ] - ( S0*sy[0] );
+		dy2 = sy[ 2 ] - ( S1*sy[1] );
+		dy3 = sy[ 3 ] - ( S2*sy[2] );
+		dy4 = sy[ 4 ] - ( S3*sy[3] );
+		dy5 = sy[ 5 ] - ( S4*sy[4] );
+		dy6 = sy[ 6 ] - ( S5*sy[5] );
+		dy7 = sy[ 7 ] - ( S6*sy[6] ); // offset increment for outermost loop
+	}
+	// Set a pointer to the first indexed element in the output ndarray:
+	iy = y.offset;
+
+	// Cache a reference to the output ndarray buffer:
+	ybuf = y.data;
+
+	// Iterate over the ndarray dimensions...
+	for ( i7 = 0; i7 < S7; i7++ ) {
+		for ( i6 = 0; i6 < S6; i6++ ) {
+			for ( i5 = 0; i5 < S5; i5++ ) {
+				for ( i4 = 0; i4 < S4; i4++ ) {
+					for ( i3 = 0; i3 < S3; i3++ ) {
+						for ( i2 = 0; i2 < S2; i2++ ) {
+							for ( i1 = 0; i1 < S1; i1++ ) {
+								for ( i0 = 0; i0 < S0; i0++ ) {
+									ybuf[ iy ] = re;
+									ybuf[ iy+1 ] = im;
+									iy += dy0;
+								}
+								iy += dy1;
+							}
+							iy += dy2;
+						}
+						iy += dy3;
+					}
+					iy += dy4;
+				}
+				iy += dy5;
+			}
+			iy += dy6;
+		}
+		iy += dy7;
+	}
+}
+
+
+// EXPORTS //
+
+module.exports = assign8d;
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/9d.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/9d.js
index 0d88a5e89c1f..9a6b2ca6cadb 100644
--- a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/9d.js
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/9d.js
@@ -86,7 +86,6 @@
 * // => <Float64Array>[ 2.0, 2.0, 2.0, 2.0, 2.0, 2.0 ]
 */
 function assign9d( x, y, isRowMajor ) {
-	var xbuf;
 	var ybuf;
 	var dy0;
 	var dy1;
@@ -108,7 +107,6 @@ function assign9d( x, y, isRowMajor ) {
 	var S7;
 	var S8;
 	var sy;
-	var ix;
 	var iy;
 	var i0;
 	var i1;
@@ -119,6 +117,7 @@ function assign9d( x, y, isRowMajor ) {
 	var i6;
 	var i7;
 	var i8;
+	var v;
 
 	// Note on variable naming convention: S#, dy#, i# where # corresponds to the loop number, with `0` being the innermost loop...
 
@@ -136,7 +135,7 @@ function assign9d( x, y, isRowMajor ) {
 		S6 = sh[ 2 ];
 		S7 = sh[ 1 ];
 		S8 = sh[ 0 ];
-		dy0 = sy[ 8 ];
+		dy0 = sy[ 8 ];                // offset increment for innermost loop
 		dy1 = sy[ 7 ] - ( S0*sy[8] );
 		dy2 = sy[ 6 ] - ( S1*sy[7] );
 		dy3 = sy[ 5 ] - ( S2*sy[6] );
@@ -144,7 +143,7 @@ function assign9d( x, y, isRowMajor ) {
 		dy5 = sy[ 3 ] - ( S4*sy[4] );
 		dy6 = sy[ 2 ] - ( S5*sy[3] );
 		dy7 = sy[ 1 ] - ( S6*sy[2] );
-		dy8 = sy[ 0 ] - ( S7*sy[1] );
+		dy8 = sy[ 0 ] - ( S7*sy[1] ); // offset increment for outermost loop
 	} else { // order === 'column-major'
 		// For column-major ndarrays, the first dimensions have the fastest changing indices...
 		S0 = sh[ 0 ];
@@ -156,7 +155,7 @@ function assign9d( x, y, isRowMajor ) {
 		S6 = sh[ 6 ];
 		S7 = sh[ 7 ];
 		S8 = sh[ 8 ];
-		dy0 = sy[ 0 ];
+		dy0 = sy[ 0 ];                // offset increment for innermost loop
 		dy1 = sy[ 1 ] - ( S0*sy[0] );
 		dy2 = sy[ 2 ] - ( S1*sy[1] );
 		dy3 = sy[ 3 ] - ( S2*sy[2] );
@@ -164,16 +163,17 @@ function assign9d( x, y, isRowMajor ) {
 		dy5 = sy[ 5 ] - ( S4*sy[4] );
 		dy6 = sy[ 6 ] - ( S5*sy[5] );
 		dy7 = sy[ 7 ] - ( S6*sy[6] );
-		dy8 = sy[ 8 ] - ( S7*sy[7] );
+		dy8 = sy[ 8 ] - ( S7*sy[7] ); // offset increment for outermost loop
 	}
-	// Set the pointers to the first indexed elements in the respective ndarrays...
-	ix = x.offset;
+	// Set a pointer to the first indexed element in the output ndarray:
 	iy = y.offset;
 
-	// Cache references to the input and output ndarray buffers...
-	xbuf = x.data;
+	// Cache a reference to the output ndarray buffer:
 	ybuf = y.data;
 
+	// Cache the scalar value:
+	v = x.data[ x.offset ];
+
 	// Iterate over the ndarray dimensions...
 	for ( i8 = 0; i8 < S8; i8++ ) {
 		for ( i7 = 0; i7 < S7; i7++ ) {
@@ -184,7 +184,7 @@ function assign9d( x, y, isRowMajor ) {
 							for ( i2 = 0; i2 < S2; i2++ ) {
 								for ( i1 = 0; i1 < S1; i1++ ) {
 									for ( i0 = 0; i0 < S0; i0++ ) {
-										ybuf[ iy ] = xbuf[ ix ];
+										ybuf[ iy ] = v;
 										iy += dy0;
 									}
 									iy += dy1;
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/9d_accessors.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/9d_accessors.js
index 94eee11942b5..cadfe2bd39b0 100644
--- a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/9d_accessors.js
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/9d_accessors.js
@@ -107,9 +107,7 @@
 * // returns 2.0
 */
 function assign9d( x, y, isRowMajor ) {
-	var xbuf;
 	var ybuf;
-	var get;
 	var set;
 	var dy0;
 	var dy1;
@@ -131,7 +129,6 @@ function assign9d( x, y, isRowMajor ) {
 	var S7;
 	var S8;
 	var sy;
-	var ix;
 	var iy;
 	var i0;
 	var i1;
@@ -142,6 +139,7 @@ function assign9d( x, y, isRowMajor ) {
 	var i6;
 	var i7;
 	var i8;
+	var v;
 
 	// Note on variable naming convention: S#, dy#, i# where # corresponds to the loop number, with `0` being the innermost loop...
 
@@ -159,7 +157,7 @@ function assign9d( x, y, isRowMajor ) {
 		S6 = sh[ 2 ];
 		S7 = sh[ 1 ];
 		S8 = sh[ 0 ];
-		dy0 = sy[ 8 ];
+		dy0 = sy[ 8 ];                // offset increment for innermost loop
 		dy1 = sy[ 7 ] - ( S0*sy[8] );
 		dy2 = sy[ 6 ] - ( S1*sy[7] );
 		dy3 = sy[ 5 ] - ( S2*sy[6] );
@@ -167,7 +165,7 @@ function assign9d( x, y, isRowMajor ) {
 		dy5 = sy[ 3 ] - ( S4*sy[4] );
 		dy6 = sy[ 2 ] - ( S5*sy[3] );
 		dy7 = sy[ 1 ] - ( S6*sy[2] );
-		dy8 = sy[ 0 ] - ( S7*sy[1] );
+		dy8 = sy[ 0 ] - ( S7*sy[1] ); // offset increment for outermost loop
 	} else { // order === 'column-major'
 		// For column-major ndarrays, the first dimensions have the fastest changing indices...
 		S0 = sh[ 0 ];
@@ -179,7 +177,7 @@ function assign9d( x, y, isRowMajor ) {
 		S6 = sh[ 6 ];
 		S7 = sh[ 7 ];
 		S8 = sh[ 8 ];
-		dy0 = sy[ 0 ];
+		dy0 = sy[ 0 ];                // offset increment for innermost loop
 		dy1 = sy[ 1 ] - ( S0*sy[0] );
 		dy2 = sy[ 2 ] - ( S1*sy[1] );
 		dy3 = sy[ 3 ] - ( S2*sy[2] );
@@ -187,19 +185,19 @@ function assign9d( x, y, isRowMajor ) {
 		dy5 = sy[ 5 ] - ( S4*sy[4] );
 		dy6 = sy[ 6 ] - ( S5*sy[5] );
 		dy7 = sy[ 7 ] - ( S6*sy[6] );
-		dy8 = sy[ 8 ] - ( S7*sy[7] );
+		dy8 = sy[ 8 ] - ( S7*sy[7] ); // offset increment for outermost loop
 	}
-	// Set the pointers to the first indexed elements in the respective ndarrays...
-	ix = x.offset;
+	// Set a pointer to the first indexed element in the output ndarray:
 	iy = y.offset;
 
-	// Cache references to the input and output ndarray buffers...
-	xbuf = x.data;
+	// Cache a reference to the output ndarray buffer:
 	ybuf = y.data;
 
-	// Cache accessors:
-	get = x.accessors[0];
-	set = y.accessors[1];
+	// Cache the output accessor:
+	set = y.accessors[ 1 ];
+
+	// Cache the scalar value:
+	v = x.accessors[ 0 ]( x.data, x.offset );
 
 	// Iterate over the ndarray dimensions...
 	for ( i8 = 0; i8 < S8; i8++ ) {
@@ -211,7 +209,7 @@ function assign9d( x, y, isRowMajor ) {
 							for ( i2 = 0; i2 < S2; i2++ ) {
 								for ( i1 = 0; i1 < S1; i1++ ) {
 									for ( i0 = 0; i0 < S0; i0++ ) {
-										set( ybuf, iy, get( xbuf, ix ) );
+										set( ybuf, iy, v );
 										iy += dy0;
 									}
 									iy += dy1;
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/9d_blocked.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/9d_blocked.js
index aceb1c13cb79..25d3ea2d9a7c 100644
--- a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/9d_blocked.js
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/9d_blocked.js
@@ -92,7 +92,6 @@ var blockSize = require( '@stdlib/ndarray/base/nullary-tiling-block-size' );
 */
 function blockedassign9d( x, y ) { // eslint-disable-line max-statements
 	var bsize;
-	var xbuf;
 	var ybuf;
 	var dy0;
 	var dy1;
@@ -123,7 +122,6 @@ function blockedassign9d( x, y ) { // eslint-disable-line max-statements
 	var s8;
 	var sy;
 	var oy;
-	var ix;
 	var iy;
 	var i0;
 	var i1;
@@ -144,6 +142,7 @@ function blockedassign9d( x, y ) { // eslint-disable-line max-statements
 	var j7;
 	var j8;
 	var o;
+	var v;
 
 	// Note on variable naming convention: s#, dy#, i#, j# where # corresponds to the loop number, with `0` being the innermost loop...
 
@@ -155,15 +154,16 @@ function blockedassign9d( x, y ) { // eslint-disable-line max-statements
 	// Determine the block size:
 	bsize = blockSize( y.dtype );
 
-	// Cache the indices of the first indexed elements in the respective ndarrays...
-	ix = x.offset;
+	// Cache the index of the first indexed element in the output ndarray:
 	oy = y.offset;
 
-	// Cache references to the input and output ndarray buffers...
-	xbuf = x.data;
+	// Cache a reference to the output ndarray buffer:
 	ybuf = y.data;
 
-	// Cache the offset increment for the innermost loop...
+	// Cache the scalar value:
+	v = x.data[ x.offset ];
+
+	// Cache the offset increment for the innermost loop:
 	dy0 = sy[0];
 
 	// Iterate over blocks...
@@ -270,7 +270,7 @@ function blockedassign9d( x, y ) { // eslint-disable-line max-statements
 																for ( i2 = 0; i2 < s2; i2++ ) {
 																	for ( i1 = 0; i1 < s1; i1++ ) {
 																		for ( i0 = 0; i0 < s0; i0++ ) {
-																			ybuf[ iy ] = xbuf[ ix ];
+																			ybuf[ iy ] = v;
 																			iy += dy0;
 																		}
 																		iy += dy1;
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/9d_blocked_accessors.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/9d_blocked_accessors.js
index 18dac3d2b884..bc0a6505d1ec 100644
--- a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/9d_blocked_accessors.js
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/9d_blocked_accessors.js
@@ -113,9 +113,7 @@ var blockSize = require( '@stdlib/ndarray/base/nullary-tiling-block-size' );
 */
 function blockedassign9d( x, y ) { // eslint-disable-line max-statements
 	var bsize;
-	var xbuf;
 	var ybuf;
-	var get;
 	var set;
 	var dy0;
 	var dy1;
@@ -146,7 +144,6 @@ function blockedassign9d( x, y ) { // eslint-disable-line max-statements
 	var s8;
 	var sy;
 	var oy;
-	var ix;
 	var iy;
 	var i0;
 	var i1;
@@ -167,6 +164,7 @@ function blockedassign9d( x, y ) { // eslint-disable-line max-statements
 	var j7;
 	var j8;
 	var o;
+	var v;
 
 	// Note on variable naming convention: s#, dy#, i#, j# where # corresponds to the loop number, with `0` being the innermost loop...
 
@@ -178,20 +176,20 @@ function blockedassign9d( x, y ) { // eslint-disable-line max-statements
 	// Determine the block size:
 	bsize = blockSize( y.dtype );
 
-	// Cache the indices of the first indexed elements in the respective ndarrays...
-	ix = x.offset;
+	// Cache the index of the first indexed element in the output ndarray:
 	oy = y.offset;
 
-	// Cache references to the input and output ndarray buffers...
-	xbuf = x.data;
+	// Cache a reference to the output ndarray buffer:
 	ybuf = y.data;
 
-	// Cache the offset increment for the innermost loop...
+	// Cache the offset increment for the innermost loop:
 	dy0 = sy[0];
 
-	// Cache accessors:
-	get = x.accessors[0];
-	set = y.accessors[1];
+	// Cache the output accessor:
+	set = y.accessors[ 1 ];
+
+	// Cache the scalar value:
+	v = x.accessors[ 0 ]( x.data, x.offset );
 
 	// Iterate over blocks...
 	for ( j8 = sh[8]; j8 > 0; ) {
@@ -297,7 +295,7 @@ function blockedassign9d( x, y ) { // eslint-disable-line max-statements
 																for ( i2 = 0; i2 < s2; i2++ ) {
 																	for ( i1 = 0; i1 < s1; i1++ ) {
 																		for ( i0 = 0; i0 < s0; i0++ ) {
-																			set( ybuf, iy, get( xbuf, ix ) );
+																			set( ybuf, iy, v );
 																			iy += dy0;
 																		}
 																		iy += dy1;
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/9d_blocked_complex.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/9d_blocked_complex.js
new file mode 100644
index 000000000000..95d20f7cedf8
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/9d_blocked_complex.js
@@ -0,0 +1,287 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2026 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-depth */
+
+'use strict';
+
+// MODULES //
+
+var loopOrder = require( '@stdlib/ndarray/base/nullary-loop-interchange-order' );
+var blockSize = require( '@stdlib/ndarray/base/nullary-tiling-block-size' );
+
+
+// MAIN //
+
+/**
+* Assigns a scalar value to every element of a reinterpreted complex number nine-dimensional output ndarray via loop blocking.
+*
+* @private
+* @param {number} re - real component
+* @param {number} im - imaginary component
+* @param {Object} y - object containing output ndarray meta data
+* @param {*} y.dtype - data type
+* @param {Collection} y.data - data buffer
+* @param {NonNegativeIntegerArray} y.shape - dimensions
+* @param {IntegerArray} y.strides - stride lengths
+* @param {NonNegativeInteger} y.offset - index offset
+* @param {string} y.order - specifies whether `y` is row-major (C-style) or column-major (Fortran-style)
+* @returns {void}
+*
+* @example
+* var Float64Array = require( '@stdlib/array/float64' );
+*
+* // Create a data buffer:
+* var ybuf = new Float64Array( 12 );
+*
+* // Define the shape of the output array:
+* var shape = [ 1, 1, 1, 1, 1, 1, 3, 1, 2 ];
+*
+* // Define the array strides:
+* var sy = [ 12, 12, 12, 12, 12, 12, 4, 4, 2 ];
+*
+* // Define the index offset:
+* var oy = 0;
+*
+* // Create the output ndarray-like object:
+* var y = {
+*     'dtype': 'float64',
+*     'data': ybuf,
+*     'shape': shape,
+*     'strides': sy,
+*     'offset': oy,
+*     'order': 'row-major'
+* };
+*
+* // Assign scalar:
+* blockedassign9d( 2.0, 2.0, y );
+*
+* console.log( y.data );
+* // => <Float64Array>[ 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0 ]
+*/
+function blockedassign9d( re, im, y ) {
+	var bsize;
+	var ybuf;
+	var dy0;
+	var dy1;
+	var dy2;
+	var dy3;
+	var dy4;
+	var dy5;
+	var dy6;
+	var dy7;
+	var dy8;
+	var oy1;
+	var oy2;
+	var oy3;
+	var oy4;
+	var oy5;
+	var oy6;
+	var oy7;
+	var oy8;
+	var sh;
+	var s0;
+	var s1;
+	var s2;
+	var s3;
+	var s4;
+	var s5;
+	var s6;
+	var s7;
+	var s8;
+	var sy;
+	var oy;
+	var iy;
+	var i0;
+	var i1;
+	var i2;
+	var i3;
+	var i4;
+	var i5;
+	var i6;
+	var i7;
+	var i8;
+	var j0;
+	var j1;
+	var j2;
+	var j3;
+	var j4;
+	var j5;
+	var j6;
+	var j7;
+	var j8;
+	var o;
+
+	// Note on variable naming convention: s#, dy#, i#, j# where # corresponds to the loop number, with `0` being the innermost loop...
+
+	// Resolve the loop interchange order:
+	o = loopOrder( y.shape, y.strides );
+	sh = o.sh;
+	sy = o.sx;
+
+	// Determine the block size:
+	bsize = blockSize( y.dtype );
+
+	// Cache the index of the first indexed element in the output ndarray:
+	oy = y.offset;
+
+	// Cache a reference to the output ndarray buffer:
+	ybuf = y.data;
+
+	// Cache the offset increment for the innermost loop:
+	dy0 = sy[0];
+
+	// Iterate over blocks...
+	for ( j8 = sh[8]; j8 > 0; ) {
+		if ( j8 < bsize ) {
+			s8 = j8;
+			j8 = 0;
+		} else {
+			s8 = bsize;
+			j8 -= bsize;
+		}
+		oy8 = oy + ( j8*sy[8] );
+		for ( j7 = sh[7]; j7 > 0; ) {
+			if ( j7 < bsize ) {
+				s7 = j7;
+				j7 = 0;
+			} else {
+				s7 = bsize;
+				j7 -= bsize;
+			}
+			dy8 = sy[8] - ( s7*sy[7] );
+			oy7 = oy8 + ( j7*sy[7] );
+			for ( j6 = sh[6]; j6 > 0; ) {
+				if ( j6 < bsize ) {
+					s6 = j6;
+					j6 = 0;
+				} else {
+					s6 = bsize;
+					j6 -= bsize;
+				}
+				dy7 = sy[7] - ( s6*sy[6] );
+				oy6 = oy7 + ( j6*sy[6] );
+				for ( j5 = sh[5]; j5 > 0; ) {
+					if ( j5 < bsize ) {
+						s5 = j5;
+						j5 = 0;
+					} else {
+						s5 = bsize;
+						j5 -= bsize;
+					}
+					dy6 = sy[6] - ( s5*sy[5] );
+					oy5 = oy6 + ( j5*sy[5] );
+					for ( j4 = sh[4]; j4 > 0; ) {
+						if ( j4 < bsize ) {
+							s4 = j4;
+							j4 = 0;
+						} else {
+							s4 = bsize;
+							j4 -= bsize;
+						}
+						dy5 = sy[5] - ( s4*sy[4] );
+						oy4 = oy5 + ( j4*sy[4] );
+						for ( j3 = sh[3]; j3 > 0; ) {
+							if ( j3 < bsize ) {
+								s3 = j3;
+								j3 = 0;
+							} else {
+								s3 = bsize;
+								j3 -= bsize;
+							}
+							dy4 = sy[4] - ( s3*sy[3] );
+							oy3 = oy4 + ( j3*sy[3] );
+							for ( j2 = sh[2]; j2 > 0; ) {
+								if ( j2 < bsize ) {
+									s2 = j2;
+									j2 = 0;
+								} else {
+									s2 = bsize;
+									j2 -= bsize;
+								}
+								dy3 = sy[3] - ( s2*sy[2] );
+								oy2 = oy3 + ( j2*sy[2] );
+								for ( j1 = sh[1]; j1 > 0; ) {
+									if ( j1 < bsize ) {
+										s1 = j1;
+										j1 = 0;
+									} else {
+										s1 = bsize;
+										j1 -= bsize;
+									}
+									dy2 = sy[2] - ( s1*sy[1] );
+									oy1 = oy2 + ( j1*sy[1] );
+									for ( j0 = sh[0]; j0 > 0; ) {
+										if ( j0 < bsize ) {
+											s0 = j0;
+											j0 = 0;
+										} else {
+											s0 = bsize;
+											j0 -= bsize;
+										}
+										// Compute the index offset for the first output ndarray element in the current block...
+										iy = oy1 + ( j0*sy[0] );
+
+										// Compute the loop offset increment...
+										dy1 = sy[1] - ( s0*sy[0] );
+
+										// Iterate over the ndarray dimensions...
+										for ( i8 = 0; i8 < s8; i8++ ) {
+											for ( i7 = 0; i7 < s7; i7++ ) {
+												for ( i6 = 0; i6 < s6; i6++ ) {
+													for ( i5 = 0; i5 < s5; i5++ ) {
+														for ( i4 = 0; i4 < s4; i4++ ) {
+															for ( i3 = 0; i3 < s3; i3++ ) {
+																for ( i2 = 0; i2 < s2; i2++ ) {
+																	for ( i1 = 0; i1 < s1; i1++ ) {
+																		for ( i0 = 0; i0 < s0; i0++ ) {
+																			ybuf[ iy ] = re;
+																			ybuf[ iy+1 ] = im;
+																			iy += dy0;
+																		}
+																		iy += dy1;
+																	}
+																	iy += dy2;
+																}
+																iy += dy3;
+															}
+															iy += dy4;
+														}
+														iy += dy5;
+													}
+													iy += dy6;
+												}
+												iy += dy7;
+											}
+											iy += dy8;
+										}
+									}
+								}
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+}
+
+
+// EXPORTS //
+
+module.exports = blockedassign9d;
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/9d_complex.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/9d_complex.js
new file mode 100644
index 000000000000..4748cff2a5b4
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/9d_complex.js
@@ -0,0 +1,192 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2026 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-depth */
+
+'use strict';
+
+// MAIN //
+
+/**
+* Assigns a scalar value to every element of a reinterpreted complex number nine-dimensional output ndarray.
+*
+* @private
+* @param {number} re - real component
+* @param {number} im - imaginary component
+* @param {Object} y - object containing output ndarray meta data
+* @param {*} y.dtype - data type
+* @param {Collection} y.data - data buffer
+* @param {NonNegativeIntegerArray} y.shape - dimensions
+* @param {IntegerArray} y.strides - stride lengths
+* @param {NonNegativeInteger} y.offset - index offset
+* @param {string} y.order - specifies whether `y` is row-major (C-style) or column-major (Fortran-style)
+* @param {boolean} isRowMajor - boolean indicating if provided arrays are in row-major order
+* @returns {void}
+*
+* @example
+* var Float64Array = require( '@stdlib/array/float64' );
+*
+* // Create a data buffer:
+* var ybuf = new Float64Array( 12 );
+*
+* // Define the shape of the output array:
+* var shape = [ 1, 1, 1, 1, 1, 1, 3, 1, 2 ];
+*
+* // Define the array strides:
+* var sy = [ 12, 12, 12, 12, 12, 12, 4, 4, 2 ];
+*
+* // Define the index offset:
+* var oy = 0;
+*
+* // Create the output ndarray-like object:
+* var y = {
+*     'dtype': 'float64',
+*     'data': ybuf,
+*     'shape': shape,
+*     'strides': sy,
+*     'offset': oy,
+*     'order': 'row-major'
+* };
+*
+* // Assign scalar:
+* assign9d( 2.0, 2.0, y, true );
+*
+* console.log( y.data );
+* // => <Float64Array>[ 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0 ]
+*/
+function assign9d( re, im, y, isRowMajor ) {
+	var ybuf;
+	var dy0;
+	var dy1;
+	var dy2;
+	var dy3;
+	var dy4;
+	var dy5;
+	var dy6;
+	var dy7;
+	var dy8;
+	var sh;
+	var S0;
+	var S1;
+	var S2;
+	var S3;
+	var S4;
+	var S5;
+	var S6;
+	var S7;
+	var S8;
+	var sy;
+	var iy;
+	var i0;
+	var i1;
+	var i2;
+	var i3;
+	var i4;
+	var i5;
+	var i6;
+	var i7;
+	var i8;
+
+	// Note on variable naming convention: S#, dy#, i# where # corresponds to the loop number, with `0` being the innermost loop...
+
+	// Extract loop variables for purposes of loop interchange: dimensions and loop offset (pointer) increments...
+	sh = y.shape;
+	sy = y.strides;
+	if ( isRowMajor ) {
+		// For row-major ndarrays, the last dimensions have the fastest changing indices...
+		S0 = sh[ 8 ];
+		S1 = sh[ 7 ];
+		S2 = sh[ 6 ];
+		S3 = sh[ 5 ];
+		S4 = sh[ 4 ];
+		S5 = sh[ 3 ];
+		S6 = sh[ 2 ];
+		S7 = sh[ 1 ];
+		S8 = sh[ 0 ];
+		dy0 = sy[ 8 ];                // offset increment for innermost loop
+		dy1 = sy[ 7 ] - ( S0*sy[8] );
+		dy2 = sy[ 6 ] - ( S1*sy[7] );
+		dy3 = sy[ 5 ] - ( S2*sy[6] );
+		dy4 = sy[ 4 ] - ( S3*sy[5] );
+		dy5 = sy[ 3 ] - ( S4*sy[4] );
+		dy6 = sy[ 2 ] - ( S5*sy[3] );
+		dy7 = sy[ 1 ] - ( S6*sy[2] );
+		dy8 = sy[ 0 ] - ( S7*sy[1] ); // offset increment for outermost loop
+	} else { // order === 'column-major'
+		// For column-major ndarrays, the first dimensions have the fastest changing indices...
+		S0 = sh[ 0 ];
+		S1 = sh[ 1 ];
+		S2 = sh[ 2 ];
+		S3 = sh[ 3 ];
+		S4 = sh[ 4 ];
+		S5 = sh[ 5 ];
+		S6 = sh[ 6 ];
+		S7 = sh[ 7 ];
+		S8 = sh[ 8 ];
+		dy0 = sy[ 0 ];                // offset increment for innermost loop
+		dy1 = sy[ 1 ] - ( S0*sy[0] );
+		dy2 = sy[ 2 ] - ( S1*sy[1] );
+		dy3 = sy[ 3 ] - ( S2*sy[2] );
+		dy4 = sy[ 4 ] - ( S3*sy[3] );
+		dy5 = sy[ 5 ] - ( S4*sy[4] );
+		dy6 = sy[ 6 ] - ( S5*sy[5] );
+		dy7 = sy[ 7 ] - ( S6*sy[6] );
+		dy8 = sy[ 8 ] - ( S7*sy[7] ); // offset increment for outermost loop
+	}
+	// Set a pointer to the first indexed element in the output ndarray:
+	iy = y.offset;
+
+	// Cache a reference to the output ndarray buffer:
+	ybuf = y.data;
+
+	// Iterate over the ndarray dimensions...
+	for ( i8 = 0; i8 < S8; i8++ ) {
+		for ( i7 = 0; i7 < S7; i7++ ) {
+			for ( i6 = 0; i6 < S6; i6++ ) {
+				for ( i5 = 0; i5 < S5; i5++ ) {
+					for ( i4 = 0; i4 < S4; i4++ ) {
+						for ( i3 = 0; i3 < S3; i3++ ) {
+							for ( i2 = 0; i2 < S2; i2++ ) {
+								for ( i1 = 0; i1 < S1; i1++ ) {
+									for ( i0 = 0; i0 < S0; i0++ ) {
+										ybuf[ iy ] = re;
+										ybuf[ iy+1 ] = im;
+										iy += dy0;
+									}
+									iy += dy1;
+								}
+								iy += dy2;
+							}
+							iy += dy3;
+						}
+						iy += dy4;
+					}
+					iy += dy5;
+				}
+				iy += dy6;
+			}
+			iy += dy7;
+		}
+		iy += dy8;
+	}
+}
+
+
+// EXPORTS //
+
+module.exports = assign9d;
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/main.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/main.js
index db5fa21820b4..d7397fc28ac8 100644
--- a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/main.js
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/main.js
@@ -40,7 +40,15 @@ var blockedaccessorassign7d = require( './7d_blocked_accessors.js' );
 var blockedaccessorassign8d = require( './8d_blocked_accessors.js' );
 var blockedaccessorassign9d = require( './9d_blocked_accessors.js' );
 var blockedaccessorassign10d = require( './10d_blocked_accessors.js' );
-var blockedcomplexassign2d = require( './2d_blocked_complex.js' ); // FIXME
+var blockedcomplexassign2d = require( './2d_blocked_complex.js' );
+var blockedcomplexassign3d = require( './3d_blocked_complex.js' );
+var blockedcomplexassign4d = require( './4d_blocked_complex.js' );
+var blockedcomplexassign5d = require( './5d_blocked_complex.js' );
+var blockedcomplexassign6d = require( './6d_blocked_complex.js' );
+var blockedcomplexassign7d = require( './7d_blocked_complex.js' );
+var blockedcomplexassign8d = require( './8d_blocked_complex.js' );
+var blockedcomplexassign9d = require( './9d_blocked_complex.js' );
+var blockedcomplexassign10d = require( './10d_blocked_complex.js' );
 var blockedassign2d = require( './2d_blocked.js' );
 var blockedassign3d = require( './3d_blocked.js' );
 var blockedassign4d = require( './4d_blocked.js' );
@@ -62,8 +70,18 @@ var accessorassign8d = require( './8d_accessors.js' );
 var accessorassign9d = require( './9d_accessors.js' );
 var accessorassign10d = require( './10d_accessors.js' );
 var accessorassignnd = require( './nd_accessors.js' );
-var complexassign0d = require( './0d_complex.js' ); // FIXME: start
-var complexassign2d = require( './2d_complex.js' ); // FIXME: end
+var complexassign0d = require( './0d_complex.js' );
+var complexassign1d = require( './1d_complex.js' );
+var complexassign2d = require( './2d_complex.js' );
+var complexassign3d = require( './3d_complex.js' );
+var complexassign4d = require( './4d_complex.js' );
+var complexassign5d = require( './5d_complex.js' );
+var complexassign6d = require( './6d_complex.js' );
+var complexassign7d = require( './7d_complex.js' );
+var complexassign8d = require( './8d_complex.js' );
+var complexassign9d = require( './9d_complex.js' );
+var complexassign10d = require( './10d_complex.js' );
+var complexassignnd = require( './nd_complex.js' );
 var assign0d = require( './0d.js' );
 var assign1d = require( './1d.js' );
 var assign2d = require( './2d.js' );
@@ -106,21 +124,18 @@ var ACCESSOR_ASSIGN = [
 	accessorassign9d,
 	accessorassign10d
 ];
-var COMPLEX_ASSIGN = [ // FIXME
+var COMPLEX_ASSIGN = [
 	complexassign0d,
-
-	/* complexassign1d, */
-
-	complexassign2d
-
-	/* complexassign3d,
+	complexassign1d,
+	complexassign2d,
+	complexassign3d,
 	complexassign4d,
 	complexassign5d,
 	complexassign6d,
 	complexassign7d,
 	complexassign8d,
 	complexassign9d,
-	complexassign10d */
+	complexassign10d
 ];
 var BLOCKED_ASSIGN = [
 	blockedassign2d, // 0
@@ -144,17 +159,16 @@ var BLOCKED_ACCESSOR_ASSIGN = [
 	blockedaccessorassign9d,
 	blockedaccessorassign10d // 8
 ];
-var BLOCKED_COMPLEX_ASSIGN = [ // FIXME
-	blockedcomplexassign2d // 0
-
-	/* blockedcomplexassign3d,
+var BLOCKED_COMPLEX_ASSIGN = [
+	blockedcomplexassign2d, // 0
+	blockedcomplexassign3d,
 	blockedcomplexassign4d,
 	blockedcomplexassign5d,
 	blockedcomplexassign6d,
 	blockedcomplexassign7d,
 	blockedcomplexassign8d,
 	blockedcomplexassign9d,
-	blockedcomplexassign10d // 8 */
+	blockedcomplexassign10d // 8
 ];
 var MAX_DIMS = ASSIGN.length - 1;
 
@@ -424,7 +438,7 @@ function assignScalar( arrays ) {
 		return accessorassignnd( x, y );
 	}
 	if ( isCmplx ) {
-		// FIXME: return complexassignnd( re, im, y );
+		return complexassignnd( re, im, y );
 	}
 	assignnd( x, y );
 }
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/nd.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/nd.js
index 3fabf1e87357..0c755eaecf50 100644
--- a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/nd.js
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/nd.js
@@ -41,14 +41,14 @@ var MODE = 'throw';
 * @param {NonNegativeIntegerArray} x.shape - dimensions
 * @param {IntegerArray} x.strides - stride lengths
 * @param {NonNegativeInteger} x.offset - index offset
-* @param {string} x.order - specifies whether \`x\` is row-major (C-style) or column-major (Fortran-style)
+* @param {string} x.order - specifies whether `x` is row-major (C-style) or column-major (Fortran-style)
 * @param {Object} y - object containing output ndarray meta data
 * @param {*} y.dtype - data type
 * @param {Collection} y.data - data buffer
 * @param {NonNegativeIntegerArray} y.shape - dimensions
 * @param {IntegerArray} y.strides - stride lengths
 * @param {NonNegativeInteger} y.offset - index offset
-* @param {string} y.order - specifies whether \`y\` is row-major (C-style) or column-major (Fortran-style)
+* @param {string} y.order - specifies whether `y` is row-major (C-style) or column-major (Fortran-style)
 * @returns {void}
 *
 * @example
@@ -94,15 +94,14 @@ var MODE = 'throw';
 * // => <Float64Array>[ 2.0, 2.0, 2.0, 2.0, 2.0, 2.0 ]
 */
 function assignnd( x, y ) {
-	var xbuf;
 	var ybuf;
 	var ordy;
 	var len;
 	var shy;
 	var sy;
 	var oy;
-	var ix;
 	var iy;
+	var v;
 	var i;
 
 	shy = y.shape;
@@ -110,26 +109,25 @@ function assignnd( x, y ) {
 	// Compute the total number of elements over which to iterate:
 	len = numel( shy );
 
-	// Cache references to the input and output ndarray data buffers:
-	xbuf = x.data;
+	// Cache a reference to the output ndarray buffer:
 	ybuf = y.data;
 
-	// Cache references to the respective stride arrays:
+	// Cache a reference to the stride array:
 	sy = y.strides;
 
-	// Cache the index of the first indexed element in the input ndarray:
-	ix = x.offset;
-
 	// Cache the index of the first indexed element in the output ndarray:
 	oy = y.offset;
 
 	// Cache the output array order:
 	ordy = y.order;
 
+	// Cache the scalar value:
+	v = x.data[ x.offset ];
+
 	// Iterate over each element based on the linear **view** index, regardless as to how the data is stored in memory...
 	for ( i = 0; i < len; i++ ) {
 		iy = vind2bind( shy, sy, oy, ordy, i, MODE );
-		ybuf[ iy ] = xbuf[ ix ];
+		ybuf[ iy ] = v;
 	}
 }
 
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/nd_accessors.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/nd_accessors.js
index 2b20d02725d4..580ed8546c88 100644
--- a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/nd_accessors.js
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/nd_accessors.js
@@ -41,7 +41,7 @@ var MODE = 'throw';
 * @param {NonNegativeIntegerArray} x.shape - dimensions
 * @param {IntegerArray} x.strides - stride lengths
 * @param {NonNegativeInteger} x.offset - index offset
-* @param {string} x.order - specifies whether \`x\` is row-major (C-style) or column-major (Fortran-style)
+* @param {string} x.order - specifies whether `x` is row-major (C-style) or column-major (Fortran-style)
 * @param {Array<Function>} x.accessors - data buffer accessors
 * @param {Object} y - object containing output ndarray meta data
 * @param {*} y.dtype - data type
@@ -49,7 +49,7 @@ var MODE = 'throw';
 * @param {NonNegativeIntegerArray} y.shape - dimensions
 * @param {IntegerArray} y.strides - stride lengths
 * @param {NonNegativeInteger} y.offset - index offset
-* @param {string} y.order - specifies whether \`y\` is row-major (C-style) or column-major (Fortran-style)
+* @param {string} y.order - specifies whether `y` is row-major (C-style) or column-major (Fortran-style)
 * @param {Array<Function>} y.accessors - data buffer accessors
 * @returns {void}
 *
@@ -115,17 +115,15 @@ var MODE = 'throw';
 * // returns 2.0
 */
 function assignnd( x, y ) {
-	var xbuf;
 	var ybuf;
 	var ordy;
 	var len;
-	var get;
 	var set;
 	var shy;
 	var sy;
 	var oy;
-	var ix;
 	var iy;
+	var v;
 	var i;
 
 	shy = y.shape;
@@ -133,30 +131,28 @@ function assignnd( x, y ) {
 	// Compute the total number of elements over which to iterate:
 	len = numel( shy );
 
-	// Cache references to the input and output ndarray data buffers:
-	xbuf = x.data;
+	// Cache a reference to the output ndarray buffer:
 	ybuf = y.data;
 
-	// Cache references to the respective stride arrays:
+	// Cache a reference to the stride array:
 	sy = y.strides;
 
-	// Cache the index of the first indexed element in the input ndarray:
-	ix = x.offset;
-
 	// Cache the index of the first indexed element in the output ndarray:
 	oy = y.offset;
 
 	// Cache the output array order:
 	ordy = y.order;
 
-	// Cache accessors:
-	get = x.accessors[0];
-	set = y.accessors[1];
+	// Cache the output accessor:
+	set = y.accessors[ 1 ];
+
+	// Cache the scalar value:
+	v = x.accessors[ 0 ]( x.data, x.offset );
 
 	// Iterate over each element based on the linear **view** index, regardless as to how the data is stored in memory...
 	for ( i = 0; i < len; i++ ) {
 		iy = vind2bind( shy, sy, oy, ordy, i, MODE );
-		set( ybuf, iy, get( xbuf, ix ) );
+		set( ybuf, iy, v );
 	}
 }
 
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/nd_complex.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/nd_complex.js
new file mode 100644
index 000000000000..846e8f8b4a62
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/nd_complex.js
@@ -0,0 +1,118 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2026 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 numel = require( '@stdlib/ndarray/base/numel' );
+var vind2bind = require( '@stdlib/ndarray/base/vind2bind' );
+
+
+// VARIABLES //
+
+var MODE = 'throw';
+
+
+// MAIN //
+
+/**
+* Assigns a scalar value to every element of a reinterpreted complex number output ndarray.
+*
+* @private
+* @param {number} re - real component
+* @param {number} im - imaginary component
+* @param {Object} y - object containing output ndarray meta data
+* @param {*} y.dtype - data type
+* @param {Collection} y.data - data buffer
+* @param {NonNegativeIntegerArray} y.shape - dimensions
+* @param {IntegerArray} y.strides - stride lengths
+* @param {NonNegativeInteger} y.offset - index offset
+* @param {string} y.order - specifies whether `y` is row-major (C-style) or column-major (Fortran-style)
+* @returns {void}
+*
+* @example
+* var Float64Array = require( '@stdlib/array/float64' );
+*
+* // Create a data buffer:
+* var ybuf = new Float64Array( 12 );
+*
+* // Define the shape of the output array:
+* var shape = [ 3, 1, 2 ];
+*
+* // Define the array strides:
+* var sy = [ 4, 4, 2 ];
+*
+* // Define the index offset:
+* var oy = 0;
+*
+* // Create the output ndarray-like object:
+* var y = {
+*     'dtype': 'float64',
+*     'data': ybuf,
+*     'shape': shape,
+*     'strides': sy,
+*     'offset': oy,
+*     'order': 'row-major'
+* };
+*
+* // Assign scalar:
+* assignnd( 2.0, 2.0, y );
+*
+* console.log( y.data );
+* // => <Float64Array>[ 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0 ]
+*/
+function assignnd( re, im, y ) {
+	var ybuf;
+	var ordy;
+	var len;
+	var sh;
+	var sy;
+	var oy;
+	var iy;
+	var i;
+
+	sh = y.shape;
+
+	// Compute the total number of elements over which to iterate:
+	len = numel( sh );
+
+	// Cache a reference to the output ndarray buffer:
+	ybuf = y.data;
+
+	// Cache a reference to the stride array:
+	sy = y.strides;
+
+	// Cache the index of the first indexed element:
+	oy = y.offset;
+
+	// Cache the array order:
+	ordy = y.order;
+
+	// Iterate over each element based on the linear **view** index, regardless as to how the data is stored in memory...
+	for ( i = 0; i < len; i++ ) {
+		iy = vind2bind( sh, sy, oy, ordy, i, MODE );
+		ybuf[ iy ] = re;
+		ybuf[ iy+1 ] = im;
+	}
+}
+
+
+// EXPORTS //
+
+module.exports = assignnd;
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/test/test.0d.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/test/test.0d.js
index 32e82d1e2fc6..6e68e77350e1 100644
--- a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/test/test.0d.js
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/test/test.0d.js
@@ -21,12 +21,11 @@
 // MODULES //
 
 var tape = require( 'tape' );
-var isSameComplex128Array = require( '@stdlib/assert/is-same-complex128array' );
 var isSameFloat64Array = require( '@stdlib/assert/is-same-float64array' );
-var Complex128Array = require( '@stdlib/array/complex128' );
+var toAccessorArray = require( '@stdlib/array/base/to-accessor-array' );
 var Float64Array = require( '@stdlib/array/float64' );
-var Complex128 = require( '@stdlib/complex/float64/ctor' );
 var scalar2ndarray = require( '@stdlib/ndarray/from-scalar' );
+var ndarray = require( '@stdlib/ndarray/ctor' );
 var assignScalar = require( './../lib' );
 
 
@@ -34,7 +33,7 @@ var assignScalar = require( './../lib' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.strictEqual( typeof assignScalar, 'function', 'main export is a function');
+	t.strictEqual( typeof assignScalar, 'function', 'main export is a function' );
 	t.end();
 });
 
@@ -59,21 +58,17 @@ tape( 'the function assigns a scalar value to each element of a 0-dimensional ou
 });
 
 tape( 'the function assigns a scalar value to each element of a 0-dimensional output ndarray (accessors)', function test( t ) {
-	var expected;
 	var v;
 	var y;
 
-	y = scalar2ndarray( new Complex128( 0.0, 0.0 ), {
-		'dtype': 'complex128'
-	});
+	y = ndarray( 'generic', toAccessorArray( [ 0.0 ] ), [], [ 0 ], 0, 'row-major' );
 
-	v = scalar2ndarray( new Complex128( 10.0, 10.0 ), {
-		'dtype': 'complex128'
+	v = scalar2ndarray( 10.0, {
+		'dtype': 'generic'
 	});
 	assignScalar( [ v, y ] );
 
-	expected = new Complex128Array( [ 10.0, 10.0 ] );
-	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.strictEqual( y.iget( 0 ), 10.0, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/test/test.1d.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/test/test.1d.js
index ce3f230e63ff..491021f43add 100644
--- a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/test/test.1d.js
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/test/test.1d.js
@@ -24,9 +24,10 @@ var tape = require( 'tape' );
 var isSameComplex128Array = require( '@stdlib/assert/is-same-complex128array' );
 var isSameFloat64Array = require( '@stdlib/assert/is-same-float64array' );
 var Complex128Array = require( '@stdlib/array/complex128' );
+var BooleanArray = require( '@stdlib/array/bool' );
 var Float64Array = require( '@stdlib/array/float64' );
+var toAccessorArray = require( '@stdlib/array/base/to-accessor-array' );
 var zeros = require( '@stdlib/array/zeros' );
-var Complex128 = require( '@stdlib/complex/float64/ctor' );
 var scalar2ndarray = require( '@stdlib/ndarray/from-scalar' );
 var ndarray = require( '@stdlib/ndarray/ctor' );
 var assignScalar = require( './../lib' );
@@ -36,7 +37,7 @@ var assignScalar = require( './../lib' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.strictEqual( typeof assignScalar, 'function', 'main export is a function');
+	t.strictEqual( typeof assignScalar, 'function', 'main export is a function' );
 	t.end();
 });
 
@@ -44,6 +45,7 @@ tape( 'the function assigns a scalar value to each indexed element of a 1-dimens
 	var expected;
 	var v;
 	var y;
+	var i;
 
 	y = ndarray( 'float64', zeros( 8, 'float64' ), [ 4 ], [ 2 ], 1, 'row-major' );
 
@@ -64,6 +66,30 @@ tape( 'the function assigns a scalar value to each indexed element of a 1-dimens
 	]);
 	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
 
+	// Bool:
+	y = ndarray( 'bool', new BooleanArray( 8 ), [ 4 ], [ 2 ], 1, 'row-major' );
+
+	v = scalar2ndarray( true, {
+		'dtype': 'bool'
+	});
+	assignScalar( [ v, y ] );
+
+	for ( i = 0; i < 4; i++ ) {
+		t.strictEqual( y.get( i ), true, 'returns expected value' );
+	}
+
+	// Real-to-complex:
+	y = ndarray( 'complex128', zeros( 8, 'complex128' ), [ 4 ], [ 2 ], 1, 'row-major' );
+
+	v = scalar2ndarray( 5.0, {
+		'dtype': 'float64'
+	});
+	assignScalar( [ v, y ] );
+
+	for ( i = 0; i < 4; i++ ) {
+		t.strictEqual( y.get( i ).toString(), '5 + 0i', 'returns expected value' );
+	}
+
 	t.end();
 });
 
@@ -71,6 +97,7 @@ tape( 'the function assigns a scalar value to each indexed element of a 1-dimens
 	var expected;
 	var v;
 	var y;
+	var i;
 
 	y = ndarray( 'float64', zeros( 8, 'float64' ), [ 0 ], [ 1 ], 0, 'row-major' );
 
@@ -91,36 +118,47 @@ tape( 'the function assigns a scalar value to each indexed element of a 1-dimens
 	]);
 	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
 
+	// Bool:
+	y = ndarray( 'bool', new BooleanArray( 8 ), [ 0 ], [ 1 ], 0, 'row-major' );
+
+	v = scalar2ndarray( true, {
+		'dtype': 'bool'
+	});
+	assignScalar( [ v, y ] );
+
+	for ( i = 0; i < 8; i++ ) {
+		t.strictEqual( y.data.get( i ), false, 'returns expected value' );
+	}
+
+	// Real-to-complex:
+	y = ndarray( 'complex128', zeros( 8, 'complex128' ), [ 0 ], [ 1 ], 0, 'row-major' );
+
+	v = scalar2ndarray( 5.0, {
+		'dtype': 'float64'
+	});
+	assignScalar( [ v, y ] );
+
+	expected = new Complex128Array( [ 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 ] ); // eslint-disable-line max-len
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+
 	t.end();
 });
 
 tape( 'the function assigns a scalar value to each indexed element of a 1-dimensional output ndarray (accessors)', function test( t ) {
-	var expected;
 	var v;
 	var y;
+	var i;
 
-	y = ndarray( 'complex128', zeros( 6, 'complex128' ), [ 4 ], [ 1 ], 1, 'row-major' );
+	y = ndarray( 'generic', toAccessorArray( zeros( 8, 'generic' ) ), [ 4 ], [ 2 ], 1, 'row-major' );
 
-	v = scalar2ndarray( new Complex128( 10.0, 10.0 ), {
-		'dtype': 'complex128'
+	v = scalar2ndarray( 10.0, {
+		'dtype': 'generic'
 	});
 	assignScalar( [ v, y ] );
 
-	expected = new Complex128Array([
-		0.0,
-		0.0,
-		10.0,
-		10.0,
-		10.0,
-		10.0,
-		10.0,
-		10.0,
-		10.0,
-		10.0,
-		0.0,
-		0.0
-	]);
-	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	for ( i = 0; i < 4; i++ ) {
+		t.strictEqual( y.get( i ), 10.0, 'returns expected value' );
+	}
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/test/test.2d.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/test/test.2d.js
index 1771aeeae7ff..7512bce71c08 100644
--- a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/test/test.2d.js
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/test/test.2d.js
@@ -16,6 +16,8 @@
 * limitations under the License.
 */
 
+/* eslint-disable max-len, max-lines */
+
 'use strict';
 
 // MODULES //
@@ -24,16 +26,16 @@ var tape = require( 'tape' );
 var isSameComplex128Array = require( '@stdlib/assert/is-same-complex128array' );
 var isSameFloat64Array = require( '@stdlib/assert/is-same-float64array' );
 var Complex128Array = require( '@stdlib/array/complex128' );
+var BooleanArray = require( '@stdlib/array/bool' );
 var Float64Array = require( '@stdlib/array/float64' );
+var toAccessorArray = require( '@stdlib/array/base/to-accessor-array' );
 var zeros = require( '@stdlib/array/zeros' );
-var Complex128 = require( '@stdlib/complex/float64/ctor' );
 var scalar2ndarray = require( '@stdlib/ndarray/from-scalar' );
 var ndarray = require( '@stdlib/ndarray/ctor' );
 var shape2strides = require( '@stdlib/ndarray/base/shape2strides' );
 var strides2offset = require( '@stdlib/ndarray/base/strides2offset' );
 var numel = require( '@stdlib/ndarray/base/numel' );
 var dfill = require( '@stdlib/blas/ext/base/dfill' );
-var gfill = require( '@stdlib/blas/ext/base/gfill' );
 var blockSize = require( '@stdlib/ndarray/base/nullary-tiling-block-size' );
 var assignScalar = require( './../lib' );
 
@@ -42,7 +44,7 @@ var assignScalar = require( './../lib' );
 
 tape( 'main export is a function', function test( t ) {
 	t.ok( true, __filename );
-	t.strictEqual( typeof assignScalar, 'function', 'main export is a function');
+	t.strictEqual( typeof assignScalar, 'function', 'main export is a function' );
 	t.end();
 });
 
@@ -55,6 +57,7 @@ tape( 'the function assigns a scalar value to each indexed element of a 2-dimens
 	var o;
 	var v;
 	var y;
+	var i;
 
 	dt = 'float64';
 	ord = 'row-major';
@@ -77,43 +80,56 @@ tape( 'the function assigns a scalar value to each indexed element of a 2-dimens
 	]);
 	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
 
+	// Bool:
+	y = ndarray( 'bool', new BooleanArray( numel( sh ) ), sh, st, o, ord );
+
+	v = scalar2ndarray( true, {
+		'dtype': 'bool'
+	});
+	assignScalar( [ v, y ] );
+
+	for ( i = 0; i < numel( sh ); i++ ) {
+		t.strictEqual( y.data.get( i ), true, 'returns expected value' );
+	}
+
+	// Real-to-complex:
+	y = ndarray( 'complex128', zeros( numel( sh ), 'complex128' ), sh, st, o, ord );
+
+	v = scalar2ndarray( 5.0, {
+		'dtype': 'float64'
+	});
+	assignScalar( [ v, y ] );
+
+	expected = new Complex128Array( [ 5.0, 0.0, 5.0, 0.0, 5.0, 0.0, 5.0, 0.0 ] );
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+
 	t.end();
 });
 
 tape( 'the function assigns a scalar value to each indexed element of a 2-dimensional output ndarray (row-major, singleton dimensions, accessors)', function test( t ) {
-	var expected;
 	var ord;
 	var sh;
 	var st;
-	var dt;
 	var o;
 	var v;
 	var y;
+	var i;
 
-	dt = 'complex128';
 	ord = 'row-major';
 	sh = [ 4, 1 ];
 	st = shape2strides( sh, ord );
 	o = strides2offset( sh, st );
 
-	y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+	y = ndarray( 'generic', toAccessorArray( zeros( numel( sh ), 'generic' ) ), sh, st, o, ord );
 
-	v = scalar2ndarray( new Complex128( 10.0, 10.0 ), {
-		'dtype': dt
+	v = scalar2ndarray( 10.0, {
+		'dtype': 'generic'
 	});
 	assignScalar( [ v, y ] );
 
-	expected = new Complex128Array([
-		10.0,
-		10.0,
-		10.0,
-		10.0,
-		10.0,
-		10.0,
-		10.0,
-		10.0
-	]);
-	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	for ( i = 0; i < numel( sh ); i++ ) {
+		t.strictEqual( y.iget( i ), 10.0, 'returns expected value' );
+	}
 
 	t.end();
 });
@@ -122,6 +138,7 @@ tape( 'the function assigns a scalar value to each indexed element of a 2-dimens
 	var expected;
 	var v;
 	var y;
+	var i;
 
 	y = ndarray( 'float64', zeros( 4, 'float64' ), [ 0, 0 ], [ 1, 1 ], 0, 'row-major' );
 
@@ -138,6 +155,29 @@ tape( 'the function assigns a scalar value to each indexed element of a 2-dimens
 	]);
 	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
 
+	// Bool:
+	y = ndarray( 'bool', new BooleanArray( 4 ), [ 0, 0 ], [ 1, 1 ], 0, 'row-major' );
+
+	v = scalar2ndarray( true, {
+		'dtype': 'bool'
+	});
+	assignScalar( [ v, y ] );
+
+	for ( i = 0; i < 4; i++ ) {
+		t.strictEqual( y.data.get( i ), false, 'returns expected value' );
+	}
+
+	// Real-to-complex:
+	y = ndarray( 'complex128', zeros( 4, 'complex128' ), [ 0, 0 ], [ 1, 1 ], 0, 'row-major' );
+
+	v = scalar2ndarray( 5.0, {
+		'dtype': 'float64'
+	});
+	assignScalar( [ v, y ] );
+
+	expected = new Complex128Array( [ 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 ] );
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+
 	t.end();
 });
 
@@ -150,6 +190,7 @@ tape( 'the function assigns a scalar value to each indexed element of a 2-dimens
 	var o;
 	var v;
 	var y;
+	var i;
 
 	dt = 'float64';
 	ord = 'row-major';
@@ -172,6 +213,29 @@ tape( 'the function assigns a scalar value to each indexed element of a 2-dimens
 	]);
 	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
 
+	// Bool:
+	y = ndarray( 'bool', new BooleanArray( numel( sh ) ), sh, st, o, ord );
+
+	v = scalar2ndarray( true, {
+		'dtype': 'bool'
+	});
+	assignScalar( [ v, y ] );
+
+	for ( i = 0; i < numel( sh ); i++ ) {
+		t.strictEqual( y.data.get( i ), true, 'returns expected value' );
+	}
+
+	// Real-to-complex:
+	y = ndarray( 'complex128', zeros( numel( sh ), 'complex128' ), sh, st, o, ord );
+
+	v = scalar2ndarray( 5.0, {
+		'dtype': 'float64'
+	});
+	assignScalar( [ v, y ] );
+
+	expected = new Complex128Array( [ 5.0, 0.0, 5.0, 0.0, 5.0, 0.0, 5.0, 0.0 ] );
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+
 	t.end();
 });
 
@@ -184,6 +248,7 @@ tape( 'the function assigns a scalar value to each indexed element of a 2-dimens
 	var o;
 	var v;
 	var y;
+	var i;
 
 	dt = 'float64';
 	ord = 'row-major';
@@ -206,6 +271,29 @@ tape( 'the function assigns a scalar value to each indexed element of a 2-dimens
 	]);
 	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
 
+	// Bool:
+	y = ndarray( 'bool', new BooleanArray( numel( sh ) ), sh, st, o, ord );
+
+	v = scalar2ndarray( true, {
+		'dtype': 'bool'
+	});
+	assignScalar( [ v, y ] );
+
+	for ( i = 0; i < numel( sh ); i++ ) {
+		t.strictEqual( y.data.get( i ), true, 'returns expected value' );
+	}
+
+	// Real-to-complex:
+	y = ndarray( 'complex128', zeros( numel( sh ), 'complex128' ), sh, st, o, ord );
+
+	v = scalar2ndarray( 5.0, {
+		'dtype': 'float64'
+	});
+	assignScalar( [ v, y ] );
+
+	expected = new Complex128Array( [ 5.0, 0.0, 5.0, 0.0, 5.0, 0.0, 5.0, 0.0 ] );
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+
 	t.end();
 });
 
@@ -218,6 +306,7 @@ tape( 'the function assigns a scalar value to each indexed element of a 2-dimens
 	var o;
 	var v;
 	var y;
+	var i;
 
 	dt = 'float64';
 	ord = 'row-major';
@@ -244,6 +333,30 @@ tape( 'the function assigns a scalar value to each indexed element of a 2-dimens
 	]);
 	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
 
+	// Bool:
+	y = ndarray( 'bool', new BooleanArray( 8 ), sh, st, o, ord );
+
+	v = scalar2ndarray( true, {
+		'dtype': 'bool'
+	});
+	assignScalar( [ v, y ] );
+
+	for ( i = 0; i < y.length; i++ ) {
+		t.strictEqual( y.iget( i ), true, 'returns expected value' );
+	}
+
+	// Real-to-complex:
+	y = ndarray( 'complex128', zeros( 8, 'complex128' ), sh, st, o, ord );
+
+	v = scalar2ndarray( 5.0, {
+		'dtype': 'float64'
+	});
+	assignScalar( [ v, y ] );
+
+	for ( i = 0; i < y.length; i++ ) {
+		t.strictEqual( y.iget( i ).toString(), '5 + 0i', 'returns expected value' );
+	}
+
 	t.end();
 });
 
@@ -256,6 +369,7 @@ tape( 'the function assigns a scalar value to each indexed element of a 2-dimens
 	var o;
 	var v;
 	var y;
+	var i;
 
 	dt = 'float64';
 	ord = 'row-major';
@@ -282,6 +396,30 @@ tape( 'the function assigns a scalar value to each indexed element of a 2-dimens
 	]);
 	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
 
+	// Bool:
+	y = ndarray( 'bool', new BooleanArray( 8 ), sh, st, o, ord );
+
+	v = scalar2ndarray( true, {
+		'dtype': 'bool'
+	});
+	assignScalar( [ v, y ] );
+
+	for ( i = 0; i < y.length; i++ ) {
+		t.strictEqual( y.iget( i ), true, 'returns expected value' );
+	}
+
+	// Real-to-complex:
+	y = ndarray( 'complex128', zeros( 8, 'complex128' ), sh, st, o, ord );
+
+	v = scalar2ndarray( 5.0, {
+		'dtype': 'float64'
+	});
+	assignScalar( [ v, y ] );
+
+	for ( i = 0; i < y.length; i++ ) {
+		t.strictEqual( y.iget( i ).toString(), '5 + 0i', 'returns expected value' );
+	}
+
 	t.end();
 });
 
@@ -295,6 +433,7 @@ tape( 'the function assigns a scalar value to each indexed element of a 2-dimens
 	var o;
 	var v;
 	var y;
+	var i;
 
 	dt = 'float64';
 	ord = 'row-major';
@@ -316,6 +455,30 @@ tape( 'the function assigns a scalar value to each indexed element of a 2-dimens
 
 	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
 
+	// Bool:
+	y = ndarray( 'bool', new BooleanArray( numel( sh )*2 ), sh, st, o, ord );
+
+	v = scalar2ndarray( true, {
+		'dtype': 'bool'
+	});
+	assignScalar( [ v, y ] );
+
+	for ( i = 0; i < y.length; i++ ) {
+		t.strictEqual( y.iget( i ), true, 'returns expected value' );
+	}
+
+	// Real-to-complex:
+	y = ndarray( 'complex128', zeros( numel( sh )*2, 'complex128' ), sh, st, o, ord );
+
+	v = scalar2ndarray( 5.0, {
+		'dtype': 'float64'
+	});
+	assignScalar( [ v, y ] );
+
+	for ( i = 0; i < y.length; i++ ) {
+		t.strictEqual( y.iget( i ).toString(), '5 + 0i', 'returns expected value' );
+	}
+
 	t.end();
 });
 
@@ -329,6 +492,7 @@ tape( 'the function assigns a scalar value to each indexed element of a 2-dimens
 	var o;
 	var v;
 	var y;
+	var i;
 
 	dt = 'float64';
 	ord = 'row-major';
@@ -350,241 +514,203 @@ tape( 'the function assigns a scalar value to each indexed element of a 2-dimens
 
 	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
 
+	// Bool:
+	y = ndarray( 'bool', new BooleanArray( numel( sh )*2 ), sh, st, o, ord );
+
+	v = scalar2ndarray( true, {
+		'dtype': 'bool'
+	});
+	assignScalar( [ v, y ] );
+
+	for ( i = 0; i < y.length; i++ ) {
+		t.strictEqual( y.iget( i ), true, 'returns expected value' );
+	}
+
+	// Real-to-complex:
+	y = ndarray( 'complex128', zeros( numel( sh )*2, 'complex128' ), sh, st, o, ord );
+
+	v = scalar2ndarray( 5.0, {
+		'dtype': 'float64'
+	});
+	assignScalar( [ v, y ] );
+
+	for ( i = 0; i < y.length; i++ ) {
+		t.strictEqual( y.iget( i ).toString(), '5 + 0i', 'returns expected value' );
+	}
+
 	t.end();
 });
 
 tape( 'the function assigns a scalar value to each indexed element of a 2-dimensional output ndarray (row-major, contiguous, accessors)', function test( t ) {
-	var expected;
 	var ord;
 	var sh;
 	var st;
-	var dt;
 	var o;
 	var v;
 	var y;
+	var i;
 
-	dt = 'complex128';
 	ord = 'row-major';
 	sh = [ 2, 2 ];
 	st = shape2strides( sh, ord );
 	o = strides2offset( sh, st );
 
-	y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+	y = ndarray( 'generic', toAccessorArray( zeros( numel( sh ), 'generic' ) ), sh, st, o, ord );
 
-	v = scalar2ndarray( new Complex128( 10.0, 10.0 ), {
-		'dtype': dt
+	v = scalar2ndarray( 10.0, {
+		'dtype': 'generic'
 	});
 	assignScalar( [ v, y ] );
 
-	expected = new Complex128Array([
-		10.0,
-		10.0,
-		10.0,
-		10.0,
-		10.0,
-		10.0,
-		10.0,
-		10.0
-	]);
-	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	for ( i = 0; i < numel( sh ); i++ ) {
+		t.strictEqual( y.iget( i ), 10.0, 'returns expected value' );
+	}
 
 	t.end();
 });
 
 tape( 'the function assigns a scalar value to each indexed element of a 2-dimensional output ndarray (row-major, contiguous, negative strides, accessors)', function test( t ) {
-	var expected;
 	var ord;
 	var sh;
 	var st;
-	var dt;
 	var o;
 	var v;
 	var y;
+	var i;
 
-	dt = 'complex128';
 	ord = 'row-major';
 	sh = [ 2, 2 ];
 	st = [ -2, -1 ];
 	o = strides2offset( sh, st );
 
-	y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+	y = ndarray( 'generic', toAccessorArray( zeros( numel( sh ), 'generic' ) ), sh, st, o, ord );
 
-	v = scalar2ndarray( new Complex128( 10.0, 10.0 ), {
-		'dtype': dt
+	v = scalar2ndarray( 10.0, {
+		'dtype': 'generic'
 	});
 	assignScalar( [ v, y ] );
 
-	expected = new Complex128Array([
-		10.0,
-		10.0,
-		10.0,
-		10.0,
-		10.0,
-		10.0,
-		10.0,
-		10.0
-	]);
-	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	for ( i = 0; i < numel( sh ); i++ ) {
+		t.strictEqual( y.iget( i ), 10.0, 'returns expected value' );
+	}
 
 	t.end();
 });
 
 tape( 'the function assigns a scalar value to each indexed element of a 2-dimensional output ndarray (row-major, non-contiguous, same sign strides, accessors)', function test( t ) {
-	var expected;
 	var ord;
 	var sh;
 	var st;
-	var dt;
 	var o;
 	var v;
 	var y;
+	var i;
 
-	dt = 'complex128';
 	ord = 'row-major';
 	sh = [ 2, 2 ];
 	st = [ 4, 1 ];
 	o = strides2offset( sh, st );
 
-	y = ndarray( dt, zeros( 8, dt ), sh, st, o, ord );
+	y = ndarray( 'generic', toAccessorArray( zeros( 8, 'generic' ) ), sh, st, o, ord );
 
-	v = scalar2ndarray( new Complex128( 10.0, 10.0 ), {
-		'dtype': dt
+	v = scalar2ndarray( 10.0, {
+		'dtype': 'generic'
 	});
 	assignScalar( [ v, y ] );
 
-	expected = new Complex128Array([
-		10.0,
-		10.0,
-		10.0,
-		10.0,
-		0.0,
-		0.0,
-		0.0,
-		0.0,
-		10.0,
-		10.0,
-		10.0,
-		10.0,
-		0.0,
-		0.0,
-		0.0,
-		0.0
-	]);
-	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	for ( i = 0; i < y.length; i++ ) {
+		t.strictEqual( y.iget( i ), 10.0, 'returns expected value' );
+	}
 
 	t.end();
 });
 
 tape( 'the function assigns a scalar value to each indexed element of a 2-dimensional output ndarray (row-major, non-contiguous, mixed sign strides, accessors)', function test( t ) {
-	var expected;
 	var ord;
 	var sh;
 	var st;
-	var dt;
 	var o;
 	var v;
 	var y;
+	var i;
 
-	dt = 'complex128';
 	ord = 'row-major';
 	sh = [ 2, 2 ];
 	st = [ 4, -1 ];
 	o = strides2offset( sh, st );
 
-	y = ndarray( dt, zeros( 8, dt ), sh, st, o, ord );
+	y = ndarray( 'generic', toAccessorArray( zeros( 8, 'generic' ) ), sh, st, o, ord );
 
-	v = scalar2ndarray( new Complex128( 10.0, 10.0 ), {
-		'dtype': dt
+	v = scalar2ndarray( 10.0, {
+		'dtype': 'generic'
 	});
 	assignScalar( [ v, y ] );
 
-	expected = new Complex128Array([
-		10.0,
-		10.0,
-		10.0,
-		10.0,
-		0.0,
-		0.0,
-		0.0,
-		0.0,
-		10.0,
-		10.0,
-		10.0,
-		10.0,
-		0.0,
-		0.0,
-		0.0,
-		0.0
-	]);
-	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	for ( i = 0; i < y.length; i++ ) {
+		t.strictEqual( y.iget( i ), 10.0, 'returns expected value' );
+	}
 
 	t.end();
 });
 
 tape( 'the function assigns a scalar value to each indexed element of a 2-dimensional output ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) {
-	var expected;
 	var bsize;
 	var ord;
 	var sh;
 	var st;
-	var dt;
 	var o;
 	var v;
 	var y;
+	var i;
 
-	dt = 'complex128';
 	ord = 'row-major';
 
-	bsize = blockSize( dt );
+	bsize = blockSize( 'float64' );
 	sh = [ bsize*2, 2 ];
 	st = [ -4, 2 ];
 	o = strides2offset( sh, st );
 
-	y = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+	y = ndarray( 'generic', toAccessorArray( zeros( numel( sh )*2, 'generic' ) ), sh, st, o, ord );
 
-	v = scalar2ndarray( new Complex128( 10.0, 10.0 ), {
-		'dtype': dt
+	v = scalar2ndarray( 10.0, {
+		'dtype': 'generic'
 	});
 	assignScalar( [ v, y ] );
 
-	expected = new Complex128Array( y.length*2 );
-	gfill( y.length, new Complex128( 10.0, 10.0 ), expected, st[ 1 ] );
-
-	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	for ( i = 0; i < y.length; i++ ) {
+		t.strictEqual( y.iget( i ), 10.0, 'returns expected value' );
+	}
 
 	t.end();
 });
 
 tape( 'the function assigns a scalar value to each indexed element of a 2-dimensional output ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) {
-	var expected;
 	var bsize;
 	var ord;
 	var sh;
 	var st;
-	var dt;
 	var o;
 	var v;
 	var y;
+	var i;
 
-	dt = 'complex128';
 	ord = 'row-major';
 
-	bsize = blockSize( dt );
+	bsize = blockSize( 'float64' );
 	sh = [ 2, bsize*2 ];
 	st = [ bsize*4, -2 ];
 	o = strides2offset( sh, st );
 
-	y = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+	y = ndarray( 'generic', toAccessorArray( zeros( numel( sh )*2, 'generic' ) ), sh, st, o, ord );
 
-	v = scalar2ndarray( new Complex128( 10.0, 10.0 ), {
-		'dtype': dt
+	v = scalar2ndarray( 10.0, {
+		'dtype': 'generic'
 	});
 	assignScalar( [ v, y ] );
 
-	expected = new Complex128Array( y.length*2 );
-	gfill( y.length, new Complex128( 10.0, 10.0 ), expected, st[ 1 ] );
-
-	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	for ( i = 0; i < y.length; i++ ) {
+		t.strictEqual( y.iget( i ), 10.0, 'returns expected value' );
+	}
 
 	t.end();
 });
@@ -598,6 +724,7 @@ tape( 'the function assigns a scalar value to each indexed element of a 2-dimens
 	var o;
 	var v;
 	var y;
+	var i;
 
 	dt = 'float64';
 	ord = 'column-major';
@@ -620,43 +747,56 @@ tape( 'the function assigns a scalar value to each indexed element of a 2-dimens
 	]);
 	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
 
+	// Bool:
+	y = ndarray( 'bool', new BooleanArray( numel( sh ) ), sh, st, o, ord );
+
+	v = scalar2ndarray( true, {
+		'dtype': 'bool'
+	});
+	assignScalar( [ v, y ] );
+
+	for ( i = 0; i < numel( sh ); i++ ) {
+		t.strictEqual( y.data.get( i ), true, 'returns expected value' );
+	}
+
+	// Real-to-complex:
+	y = ndarray( 'complex128', zeros( numel( sh ), 'complex128' ), sh, st, o, ord );
+
+	v = scalar2ndarray( 5.0, {
+		'dtype': 'float64'
+	});
+	assignScalar( [ v, y ] );
+
+	expected = new Complex128Array( [ 5.0, 0.0, 5.0, 0.0, 5.0, 0.0, 5.0, 0.0 ] );
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+
 	t.end();
 });
 
 tape( 'the function assigns a scalar value to each indexed element of a 2-dimensional output ndarray (column-major, singleton dimensions, accessors)', function test( t ) {
-	var expected;
 	var ord;
 	var sh;
 	var st;
-	var dt;
 	var o;
 	var v;
 	var y;
+	var i;
 
-	dt = 'complex128';
 	ord = 'column-major';
 	sh = [ 4, 1 ];
 	st = shape2strides( sh, ord );
 	o = strides2offset( sh, st );
 
-	y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+	y = ndarray( 'generic', toAccessorArray( zeros( numel( sh ), 'generic' ) ), sh, st, o, ord );
 
-	v = scalar2ndarray( new Complex128( 10.0, 10.0 ), {
-		'dtype': dt
+	v = scalar2ndarray( 10.0, {
+		'dtype': 'generic'
 	});
 	assignScalar( [ v, y ] );
 
-	expected = new Complex128Array([
-		10.0,
-		10.0,
-		10.0,
-		10.0,
-		10.0,
-		10.0,
-		10.0,
-		10.0
-	]);
-	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	for ( i = 0; i < numel( sh ); i++ ) {
+		t.strictEqual( y.iget( i ), 10.0, 'returns expected value' );
+	}
 
 	t.end();
 });
@@ -665,6 +805,7 @@ tape( 'the function assigns a scalar value to each indexed element of a 2-dimens
 	var expected;
 	var v;
 	var y;
+	var i;
 
 	y = ndarray( 'float64', zeros( 4, 'float64' ), [ 0, 0 ], [ 1, 1 ], 0, 'column-major' );
 
@@ -681,6 +822,29 @@ tape( 'the function assigns a scalar value to each indexed element of a 2-dimens
 	]);
 	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
 
+	// Bool:
+	y = ndarray( 'bool', new BooleanArray( 4 ), [ 0, 0 ], [ 1, 1 ], 0, 'column-major' );
+
+	v = scalar2ndarray( true, {
+		'dtype': 'bool'
+	});
+	assignScalar( [ v, y ] );
+
+	for ( i = 0; i < 4; i++ ) {
+		t.strictEqual( y.data.get( i ), false, 'returns expected value' );
+	}
+
+	// Real-to-complex:
+	y = ndarray( 'complex128', zeros( 4, 'complex128' ), [ 0, 0 ], [ 1, 1 ], 0, 'column-major' );
+
+	v = scalar2ndarray( 5.0, {
+		'dtype': 'float64'
+	});
+	assignScalar( [ v, y ] );
+
+	expected = new Complex128Array( [ 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 ] );
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+
 	t.end();
 });
 
@@ -693,6 +857,7 @@ tape( 'the function assigns a scalar value to each indexed element of a 2-dimens
 	var o;
 	var v;
 	var y;
+	var i;
 
 	dt = 'float64';
 	ord = 'column-major';
@@ -715,6 +880,29 @@ tape( 'the function assigns a scalar value to each indexed element of a 2-dimens
 	]);
 	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
 
+	// Bool:
+	y = ndarray( 'bool', new BooleanArray( numel( sh ) ), sh, st, o, ord );
+
+	v = scalar2ndarray( true, {
+		'dtype': 'bool'
+	});
+	assignScalar( [ v, y ] );
+
+	for ( i = 0; i < numel( sh ); i++ ) {
+		t.strictEqual( y.data.get( i ), true, 'returns expected value' );
+	}
+
+	// Real-to-complex:
+	y = ndarray( 'complex128', zeros( numel( sh ), 'complex128' ), sh, st, o, ord );
+
+	v = scalar2ndarray( 5.0, {
+		'dtype': 'float64'
+	});
+	assignScalar( [ v, y ] );
+
+	expected = new Complex128Array( [ 5.0, 0.0, 5.0, 0.0, 5.0, 0.0, 5.0, 0.0 ] );
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+
 	t.end();
 });
 
@@ -727,6 +915,7 @@ tape( 'the function assigns a scalar value to each indexed element of a 2-dimens
 	var o;
 	var v;
 	var y;
+	var i;
 
 	dt = 'float64';
 	ord = 'column-major';
@@ -749,6 +938,29 @@ tape( 'the function assigns a scalar value to each indexed element of a 2-dimens
 	]);
 	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
 
+	// Bool:
+	y = ndarray( 'bool', new BooleanArray( numel( sh ) ), sh, st, o, ord );
+
+	v = scalar2ndarray( true, {
+		'dtype': 'bool'
+	});
+	assignScalar( [ v, y ] );
+
+	for ( i = 0; i < numel( sh ); i++ ) {
+		t.strictEqual( y.data.get( i ), true, 'returns expected value' );
+	}
+
+	// Real-to-complex:
+	y = ndarray( 'complex128', zeros( numel( sh ), 'complex128' ), sh, st, o, ord );
+
+	v = scalar2ndarray( 5.0, {
+		'dtype': 'float64'
+	});
+	assignScalar( [ v, y ] );
+
+	expected = new Complex128Array( [ 5.0, 0.0, 5.0, 0.0, 5.0, 0.0, 5.0, 0.0 ] );
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+
 	t.end();
 });
 
@@ -761,6 +973,7 @@ tape( 'the function assigns a scalar value to each indexed element of a 2-dimens
 	var o;
 	var v;
 	var y;
+	var i;
 
 	dt = 'float64';
 	ord = 'column-major';
@@ -787,6 +1000,30 @@ tape( 'the function assigns a scalar value to each indexed element of a 2-dimens
 	]);
 	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
 
+	// Bool:
+	y = ndarray( 'bool', new BooleanArray( 8 ), sh, st, o, ord );
+
+	v = scalar2ndarray( true, {
+		'dtype': 'bool'
+	});
+	assignScalar( [ v, y ] );
+
+	for ( i = 0; i < y.length; i++ ) {
+		t.strictEqual( y.iget( i ), true, 'returns expected value' );
+	}
+
+	// Real-to-complex:
+	y = ndarray( 'complex128', zeros( 8, 'complex128' ), sh, st, o, ord );
+
+	v = scalar2ndarray( 5.0, {
+		'dtype': 'float64'
+	});
+	assignScalar( [ v, y ] );
+
+	for ( i = 0; i < y.length; i++ ) {
+		t.strictEqual( y.iget( i ).toString(), '5 + 0i', 'returns expected value' );
+	}
+
 	t.end();
 });
 
@@ -799,6 +1036,7 @@ tape( 'the function assigns a scalar value to each indexed element of a 2-dimens
 	var o;
 	var v;
 	var y;
+	var i;
 
 	dt = 'float64';
 	ord = 'column-major';
@@ -825,6 +1063,30 @@ tape( 'the function assigns a scalar value to each indexed element of a 2-dimens
 	]);
 	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
 
+	// Bool:
+	y = ndarray( 'bool', new BooleanArray( 8 ), sh, st, o, ord );
+
+	v = scalar2ndarray( true, {
+		'dtype': 'bool'
+	});
+	assignScalar( [ v, y ] );
+
+	for ( i = 0; i < y.length; i++ ) {
+		t.strictEqual( y.iget( i ), true, 'returns expected value' );
+	}
+
+	// Real-to-complex:
+	y = ndarray( 'complex128', zeros( 8, 'complex128' ), sh, st, o, ord );
+
+	v = scalar2ndarray( 5.0, {
+		'dtype': 'float64'
+	});
+	assignScalar( [ v, y ] );
+
+	for ( i = 0; i < y.length; i++ ) {
+		t.strictEqual( y.iget( i ).toString(), '5 + 0i', 'returns expected value' );
+	}
+
 	t.end();
 });
 
@@ -838,6 +1100,7 @@ tape( 'the function assigns a scalar value to each indexed element of a 2-dimens
 	var o;
 	var v;
 	var y;
+	var i;
 
 	dt = 'float64';
 	ord = 'column-major';
@@ -859,6 +1122,30 @@ tape( 'the function assigns a scalar value to each indexed element of a 2-dimens
 
 	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
 
+	// Bool:
+	y = ndarray( 'bool', new BooleanArray( numel( sh )*2 ), sh, st, o, ord );
+
+	v = scalar2ndarray( true, {
+		'dtype': 'bool'
+	});
+	assignScalar( [ v, y ] );
+
+	for ( i = 0; i < y.length; i++ ) {
+		t.strictEqual( y.iget( i ), true, 'returns expected value' );
+	}
+
+	// Real-to-complex:
+	y = ndarray( 'complex128', zeros( numel( sh )*2, 'complex128' ), sh, st, o, ord );
+
+	v = scalar2ndarray( 5.0, {
+		'dtype': 'float64'
+	});
+	assignScalar( [ v, y ] );
+
+	for ( i = 0; i < y.length; i++ ) {
+		t.strictEqual( y.iget( i ).toString(), '5 + 0i', 'returns expected value' );
+	}
+
 	t.end();
 });
 
@@ -872,6 +1159,7 @@ tape( 'the function assigns a scalar value to each indexed element of a 2-dimens
 	var o;
 	var v;
 	var y;
+	var i;
 
 	dt = 'float64';
 	ord = 'column-major';
@@ -893,241 +1181,203 @@ tape( 'the function assigns a scalar value to each indexed element of a 2-dimens
 
 	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
 
+	// Bool:
+	y = ndarray( 'bool', new BooleanArray( numel( sh )*2 ), sh, st, o, ord );
+
+	v = scalar2ndarray( true, {
+		'dtype': 'bool'
+	});
+	assignScalar( [ v, y ] );
+
+	for ( i = 0; i < y.length; i++ ) {
+		t.strictEqual( y.iget( i ), true, 'returns expected value' );
+	}
+
+	// Real-to-complex:
+	y = ndarray( 'complex128', zeros( numel( sh )*2, 'complex128' ), sh, st, o, ord );
+
+	v = scalar2ndarray( 5.0, {
+		'dtype': 'float64'
+	});
+	assignScalar( [ v, y ] );
+
+	for ( i = 0; i < y.length; i++ ) {
+		t.strictEqual( y.iget( i ).toString(), '5 + 0i', 'returns expected value' );
+	}
+
 	t.end();
 });
 
 tape( 'the function assigns a scalar value to each indexed element of a 2-dimensional output ndarray (column-major, contiguous, accessors)', function test( t ) {
-	var expected;
 	var ord;
 	var sh;
 	var st;
-	var dt;
 	var o;
 	var v;
 	var y;
+	var i;
 
-	dt = 'complex128';
 	ord = 'column-major';
 	sh = [ 2, 2 ];
 	st = shape2strides( sh, ord );
 	o = strides2offset( sh, st );
 
-	y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+	y = ndarray( 'generic', toAccessorArray( zeros( numel( sh ), 'generic' ) ), sh, st, o, ord );
 
-	v = scalar2ndarray( new Complex128( 10.0, 10.0 ), {
-		'dtype': dt
+	v = scalar2ndarray( 10.0, {
+		'dtype': 'generic'
 	});
 	assignScalar( [ v, y ] );
 
-	expected = new Complex128Array([
-		10.0,
-		10.0,
-		10.0,
-		10.0,
-		10.0,
-		10.0,
-		10.0,
-		10.0
-	]);
-	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	for ( i = 0; i < numel( sh ); i++ ) {
+		t.strictEqual( y.iget( i ), 10.0, 'returns expected value' );
+	}
 
 	t.end();
 });
 
 tape( 'the function assigns a scalar value to each indexed element of a 2-dimensional output ndarray (column-major, contiguous, negative strides, accessors)', function test( t ) {
-	var expected;
 	var ord;
 	var sh;
 	var st;
-	var dt;
 	var o;
 	var v;
 	var y;
+	var i;
 
-	dt = 'complex128';
 	ord = 'column-major';
 	sh = [ 2, 2 ];
 	st = [ -1, -2 ];
 	o = strides2offset( sh, st );
 
-	y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+	y = ndarray( 'generic', toAccessorArray( zeros( numel( sh ), 'generic' ) ), sh, st, o, ord );
 
-	v = scalar2ndarray( new Complex128( 10.0, 10.0 ), {
-		'dtype': dt
+	v = scalar2ndarray( 10.0, {
+		'dtype': 'generic'
 	});
 	assignScalar( [ v, y ] );
 
-	expected = new Complex128Array([
-		10.0,
-		10.0,
-		10.0,
-		10.0,
-		10.0,
-		10.0,
-		10.0,
-		10.0
-	]);
-	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	for ( i = 0; i < numel( sh ); i++ ) {
+		t.strictEqual( y.iget( i ), 10.0, 'returns expected value' );
+	}
 
 	t.end();
 });
 
 tape( 'the function assigns a scalar value to each indexed element of a 2-dimensional output ndarray (column-major, non-contiguous, same sign strides, accessors)', function test( t ) {
-	var expected;
 	var ord;
 	var sh;
 	var st;
-	var dt;
 	var o;
 	var v;
 	var y;
+	var i;
 
-	dt = 'complex128';
 	ord = 'column-major';
 	sh = [ 2, 2 ];
 	st = [ 1, 4 ];
 	o = strides2offset( sh, st );
 
-	y = ndarray( dt, zeros( 8, dt ), sh, st, o, ord );
+	y = ndarray( 'generic', toAccessorArray( zeros( 8, 'generic' ) ), sh, st, o, ord );
 
-	v = scalar2ndarray( new Complex128( 10.0, 10.0 ), {
-		'dtype': dt
+	v = scalar2ndarray( 10.0, {
+		'dtype': 'generic'
 	});
 	assignScalar( [ v, y ] );
 
-	expected = new Complex128Array([
-		10.0,
-		10.0,
-		10.0,
-		10.0,
-		0.0,
-		0.0,
-		0.0,
-		0.0,
-		10.0,
-		10.0,
-		10.0,
-		10.0,
-		0.0,
-		0.0,
-		0.0,
-		0.0
-	]);
-	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	for ( i = 0; i < y.length; i++ ) {
+		t.strictEqual( y.iget( i ), 10.0, 'returns expected value' );
+	}
 
 	t.end();
 });
 
 tape( 'the function assigns a scalar value to each indexed element of a 2-dimensional output ndarray (column-major, non-contiguous, mixed sign strides, accessors)', function test( t ) {
-	var expected;
 	var ord;
 	var sh;
 	var st;
-	var dt;
 	var o;
 	var v;
 	var y;
+	var i;
 
-	dt = 'complex128';
 	ord = 'column-major';
 	sh = [ 2, 2 ];
 	st = [ 1, -4 ];
 	o = strides2offset( sh, st );
 
-	y = ndarray( dt, zeros( 8, dt ), sh, st, o, ord );
+	y = ndarray( 'generic', toAccessorArray( zeros( 8, 'generic' ) ), sh, st, o, ord );
 
-	v = scalar2ndarray( new Complex128( 10.0, 10.0 ), {
-		'dtype': dt
+	v = scalar2ndarray( 10.0, {
+		'dtype': 'generic'
 	});
 	assignScalar( [ v, y ] );
 
-	expected = new Complex128Array([
-		10.0,
-		10.0,
-		10.0,
-		10.0,
-		0.0,
-		0.0,
-		0.0,
-		0.0,
-		10.0,
-		10.0,
-		10.0,
-		10.0,
-		0.0,
-		0.0,
-		0.0,
-		0.0
-	]);
-	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	for ( i = 0; i < y.length; i++ ) {
+		t.strictEqual( y.iget( i ), 10.0, 'returns expected value' );
+	}
 
 	t.end();
 });
 
 tape( 'the function assigns a scalar value to each indexed element of a 2-dimensional output ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) {
-	var expected;
 	var bsize;
 	var ord;
 	var sh;
 	var st;
-	var dt;
 	var o;
 	var v;
 	var y;
+	var i;
 
-	dt = 'complex128';
 	ord = 'column-major';
 
-	bsize = blockSize( dt );
+	bsize = blockSize( 'float64' );
 	sh = [ bsize*2, 2 ];
 	st = [ 2, -bsize*4 ];
 	o = strides2offset( sh, st );
 
-	y = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+	y = ndarray( 'generic', toAccessorArray( zeros( numel( sh )*2, 'generic' ) ), sh, st, o, ord );
 
-	v = scalar2ndarray( new Complex128( 10.0, 10.0 ), {
-		'dtype': dt
+	v = scalar2ndarray( 10.0, {
+		'dtype': 'generic'
 	});
 	assignScalar( [ v, y ] );
 
-	expected = new Complex128Array( y.length*2 );
-	gfill( y.length, new Complex128( 10.0, 10.0 ), expected, st[ 0 ] );
-
-	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	for ( i = 0; i < y.length; i++ ) {
+		t.strictEqual( y.iget( i ), 10.0, 'returns expected value' );
+	}
 
 	t.end();
 });
 
 tape( 'the function assigns a scalar value to each indexed element of a 2-dimensional output ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) {
-	var expected;
 	var bsize;
 	var ord;
 	var sh;
 	var st;
-	var dt;
 	var o;
 	var v;
 	var y;
+	var i;
 
-	dt = 'complex128';
 	ord = 'column-major';
 
-	bsize = blockSize( dt );
+	bsize = blockSize( 'float64' );
 	sh = [ 2, bsize*2 ];
 	st = [ -2, 4 ];
 	o = strides2offset( sh, st );
 
-	y = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+	y = ndarray( 'generic', toAccessorArray( zeros( numel( sh )*2, 'generic' ) ), sh, st, o, ord );
 
-	v = scalar2ndarray( new Complex128( 10.0, 10.0 ), {
-		'dtype': dt
+	v = scalar2ndarray( 10.0, {
+		'dtype': 'generic'
 	});
 	assignScalar( [ v, y ] );
 
-	expected = new Complex128Array( y.length*2 );
-	gfill( y.length, new Complex128( 10.0, 10.0 ), expected, st[ 0 ] );
-
-	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	for ( i = 0; i < y.length; i++ ) {
+		t.strictEqual( y.iget( i ), 10.0, 'returns expected value' );
+	}
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/test/test.3d.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/test/test.3d.js
index 67111e4b9903..644b587e206d 100644
--- a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/test/test.3d.js
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/test/test.3d.js
@@ -16,6 +16,8 @@
 * limitations under the License.
 */
 
+/* eslint-disable max-len, max-lines */
+
 'use strict';
 
 // MODULES //
@@ -24,16 +26,16 @@ var tape = require( 'tape' );
 var isSameComplex128Array = require( '@stdlib/assert/is-same-complex128array' );
 var isSameFloat64Array = require( '@stdlib/assert/is-same-float64array' );
 var Complex128Array = require( '@stdlib/array/complex128' );
+var BooleanArray = require( '@stdlib/array/bool' );
 var Float64Array = require( '@stdlib/array/float64' );
+var toAccessorArray = require( '@stdlib/array/base/to-accessor-array' );
 var zeros = require( '@stdlib/array/zeros' );
-var Complex128 = require( '@stdlib/complex/float64/ctor' );
 var scalar2ndarray = require( '@stdlib/ndarray/from-scalar' );
 var ndarray = require( '@stdlib/ndarray/ctor' );
 var shape2strides = require( '@stdlib/ndarray/base/shape2strides' );
 var strides2offset = require( '@stdlib/ndarray/base/strides2offset' );
 var numel = require( '@stdlib/ndarray/base/numel' );
 var dfill = require( '@stdlib/blas/ext/base/dfill' );
-var gfill = require( '@stdlib/blas/ext/base/gfill' );
 var blockSize = require( '@stdlib/ndarray/base/nullary-tiling-block-size' );
 var assignScalar = require( './../lib' );
 
@@ -55,6 +57,7 @@ tape( 'the function assigns a scalar value to each indexed element of a 3-dimens
 	var o;
 	var v;
 	var y;
+	var i;
 
 	dt = 'float64';
 	ord = 'row-major';
@@ -77,43 +80,56 @@ tape( 'the function assigns a scalar value to each indexed element of a 3-dimens
 	]);
 	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
 
+	// Bool:
+	y = ndarray( 'bool', new BooleanArray( numel( sh ) ), sh, st, o, ord );
+
+	v = scalar2ndarray( true, {
+		'dtype': 'bool'
+	});
+	assignScalar( [ v, y ] );
+
+	for ( i = 0; i < numel( sh ); i++ ) {
+		t.strictEqual( y.data.get( i ), true, 'returns expected value' );
+	}
+
+	// Real-to-complex:
+	y = ndarray( 'complex128', zeros( numel( sh ), 'complex128' ), sh, st, o, ord );
+
+	v = scalar2ndarray( 5.0, {
+		'dtype': 'float64'
+	});
+	assignScalar( [ v, y ] );
+
+	expected = new Complex128Array( [ 5.0, 0.0, 5.0, 0.0, 5.0, 0.0, 5.0, 0.0 ] );
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+
 	t.end();
 });
 
 tape( 'the function assigns a scalar value to each indexed element of a 3-dimensional output ndarray (row-major, singleton dimensions, accessors)', function test( t ) {
-	var expected;
 	var ord;
 	var sh;
 	var st;
-	var dt;
 	var o;
 	var v;
 	var y;
+	var i;
 
-	dt = 'complex128';
 	ord = 'row-major';
 	sh = [ 4, 1, 1 ];
 	st = shape2strides( sh, ord );
 	o = strides2offset( sh, st );
 
-	y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+	y = ndarray( 'generic', toAccessorArray( zeros( numel( sh ), 'generic' ) ), sh, st, o, ord );
 
-	v = scalar2ndarray( new Complex128( 10.0, 10.0 ), {
-		'dtype': dt
+	v = scalar2ndarray( 10.0, {
+		'dtype': 'generic'
 	});
 	assignScalar( [ v, y ] );
 
-	expected = new Complex128Array([
-		10.0,
-		10.0,
-		10.0,
-		10.0,
-		10.0,
-		10.0,
-		10.0,
-		10.0
-	]);
-	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	for ( i = 0; i < numel( sh ); i++ ) {
+		t.strictEqual( y.iget( i ), 10.0, 'returns expected value' );
+	}
 
 	t.end();
 });
@@ -122,6 +138,7 @@ tape( 'the function assigns a scalar value to each indexed element of a 3-dimens
 	var expected;
 	var v;
 	var y;
+	var i;
 
 	y = ndarray( 'float64', zeros( 4, 'float64' ), [ 0, 0, 0 ], [ 1, 1, 1 ], 0, 'row-major' );
 
@@ -138,6 +155,29 @@ tape( 'the function assigns a scalar value to each indexed element of a 3-dimens
 	]);
 	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
 
+	// Bool:
+	y = ndarray( 'bool', new BooleanArray( 4 ), [ 0, 0, 0 ], [ 1, 1, 1 ], 0, 'row-major' );
+
+	v = scalar2ndarray( true, {
+		'dtype': 'bool'
+	});
+	assignScalar( [ v, y ] );
+
+	for ( i = 0; i < 4; i++ ) {
+		t.strictEqual( y.data.get( i ), false, 'returns expected value' );
+	}
+
+	// Real-to-complex:
+	y = ndarray( 'complex128', zeros( 4, 'complex128' ), [ 0, 0, 0 ], [ 1, 1, 1 ], 0, 'row-major' );
+
+	v = scalar2ndarray( 5.0, {
+		'dtype': 'float64'
+	});
+	assignScalar( [ v, y ] );
+
+	expected = new Complex128Array( [ 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 ] );
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+
 	t.end();
 });
 
@@ -150,6 +190,7 @@ tape( 'the function assigns a scalar value to each indexed element of a 3-dimens
 	var o;
 	var v;
 	var y;
+	var i;
 
 	dt = 'float64';
 	ord = 'row-major';
@@ -172,6 +213,29 @@ tape( 'the function assigns a scalar value to each indexed element of a 3-dimens
 	]);
 	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
 
+	// Bool:
+	y = ndarray( 'bool', new BooleanArray( numel( sh ) ), sh, st, o, ord );
+
+	v = scalar2ndarray( true, {
+		'dtype': 'bool'
+	});
+	assignScalar( [ v, y ] );
+
+	for ( i = 0; i < numel( sh ); i++ ) {
+		t.strictEqual( y.data.get( i ), true, 'returns expected value' );
+	}
+
+	// Real-to-complex:
+	y = ndarray( 'complex128', zeros( numel( sh ), 'complex128' ), sh, st, o, ord );
+
+	v = scalar2ndarray( 5.0, {
+		'dtype': 'float64'
+	});
+	assignScalar( [ v, y ] );
+
+	expected = new Complex128Array( [ 5.0, 0.0, 5.0, 0.0, 5.0, 0.0, 5.0, 0.0 ] );
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+
 	t.end();
 });
 
@@ -184,6 +248,7 @@ tape( 'the function assigns a scalar value to each indexed element of a 3-dimens
 	var o;
 	var v;
 	var y;
+	var i;
 
 	dt = 'float64';
 	ord = 'row-major';
@@ -210,6 +275,29 @@ tape( 'the function assigns a scalar value to each indexed element of a 3-dimens
 	]);
 	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
 
+	// Bool:
+	y = ndarray( 'bool', new BooleanArray( numel( sh ) ), sh, st, o, ord );
+
+	v = scalar2ndarray( true, {
+		'dtype': 'bool'
+	});
+	assignScalar( [ v, y ] );
+
+	for ( i = 0; i < numel( sh ); i++ ) {
+		t.strictEqual( y.data.get( i ), true, 'returns expected value' );
+	}
+
+	// Real-to-complex:
+	y = ndarray( 'complex128', zeros( numel( sh ), 'complex128' ), sh, st, o, ord );
+
+	v = scalar2ndarray( 5.0, {
+		'dtype': 'float64'
+	});
+	assignScalar( [ v, y ] );
+
+	expected = new Complex128Array( [ 5.0, 0.0, 5.0, 0.0, 5.0, 0.0, 5.0, 0.0, 5.0, 0.0, 5.0, 0.0, 5.0, 0.0, 5.0, 0.0 ] );
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+
 	t.end();
 });
 
@@ -222,6 +310,7 @@ tape( 'the function assigns a scalar value to each indexed element of a 3-dimens
 	var o;
 	var v;
 	var y;
+	var i;
 
 	dt = 'float64';
 	ord = 'row-major';
@@ -246,6 +335,30 @@ tape( 'the function assigns a scalar value to each indexed element of a 3-dimens
 	]);
 	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
 
+	// Bool:
+	y = ndarray( 'bool', new BooleanArray( 6 ), sh, st, o, ord );
+
+	v = scalar2ndarray( true, {
+		'dtype': 'bool'
+	});
+	assignScalar( [ v, y ] );
+
+	for ( i = 0; i < y.length; i++ ) {
+		t.strictEqual( y.iget( i ), true, 'returns expected value' );
+	}
+
+	// Real-to-complex:
+	y = ndarray( 'complex128', zeros( 6, 'complex128' ), sh, st, o, ord );
+
+	v = scalar2ndarray( 5.0, {
+		'dtype': 'float64'
+	});
+	assignScalar( [ v, y ] );
+
+	for ( i = 0; i < y.length; i++ ) {
+		t.strictEqual( y.iget( i ).toString(), '5 + 0i', 'returns expected value' );
+	}
+
 	t.end();
 });
 
@@ -258,6 +371,7 @@ tape( 'the function assigns a scalar value to each indexed element of a 3-dimens
 	var o;
 	var v;
 	var y;
+	var i;
 
 	dt = 'float64';
 	ord = 'row-major';
@@ -282,6 +396,30 @@ tape( 'the function assigns a scalar value to each indexed element of a 3-dimens
 	]);
 	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
 
+	// Bool:
+	y = ndarray( 'bool', new BooleanArray( 6 ), sh, st, o, ord );
+
+	v = scalar2ndarray( true, {
+		'dtype': 'bool'
+	});
+	assignScalar( [ v, y ] );
+
+	for ( i = 0; i < y.length; i++ ) {
+		t.strictEqual( y.iget( i ), true, 'returns expected value' );
+	}
+
+	// Real-to-complex:
+	y = ndarray( 'complex128', zeros( 6, 'complex128' ), sh, st, o, ord );
+
+	v = scalar2ndarray( 5.0, {
+		'dtype': 'float64'
+	});
+	assignScalar( [ v, y ] );
+
+	for ( i = 0; i < y.length; i++ ) {
+		t.strictEqual( y.iget( i ).toString(), '5 + 0i', 'returns expected value' );
+	}
+
 	t.end();
 });
 
@@ -295,6 +433,7 @@ tape( 'the function assigns a scalar value to each indexed element of a 3-dimens
 	var o;
 	var v;
 	var y;
+	var i;
 
 	dt = 'float64';
 	ord = 'row-major';
@@ -316,6 +455,30 @@ tape( 'the function assigns a scalar value to each indexed element of a 3-dimens
 
 	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
 
+	// Bool:
+	y = ndarray( 'bool', new BooleanArray( numel( sh )*2 ), sh, st, o, ord );
+
+	v = scalar2ndarray( true, {
+		'dtype': 'bool'
+	});
+	assignScalar( [ v, y ] );
+
+	for ( i = 0; i < y.length; i++ ) {
+		t.strictEqual( y.iget( i ), true, 'returns expected value' );
+	}
+
+	// Real-to-complex:
+	y = ndarray( 'complex128', zeros( numel( sh )*2, 'complex128' ), sh, st, o, ord );
+
+	v = scalar2ndarray( 5.0, {
+		'dtype': 'float64'
+	});
+	assignScalar( [ v, y ] );
+
+	for ( i = 0; i < y.length; i++ ) {
+		t.strictEqual( y.iget( i ).toString(), '5 + 0i', 'returns expected value' );
+	}
+
 	t.end();
 });
 
@@ -329,6 +492,7 @@ tape( 'the function assigns a scalar value to each indexed element of a 3-dimens
 	var o;
 	var v;
 	var y;
+	var i;
 
 	dt = 'float64';
 	ord = 'row-major';
@@ -350,6 +514,30 @@ tape( 'the function assigns a scalar value to each indexed element of a 3-dimens
 
 	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
 
+	// Bool:
+	y = ndarray( 'bool', new BooleanArray( numel( sh )*2 ), sh, st, o, ord );
+
+	v = scalar2ndarray( true, {
+		'dtype': 'bool'
+	});
+	assignScalar( [ v, y ] );
+
+	for ( i = 0; i < y.length; i++ ) {
+		t.strictEqual( y.iget( i ), true, 'returns expected value' );
+	}
+
+	// Real-to-complex:
+	y = ndarray( 'complex128', zeros( numel( sh )*2, 'complex128' ), sh, st, o, ord );
+
+	v = scalar2ndarray( 5.0, {
+		'dtype': 'float64'
+	});
+	assignScalar( [ v, y ] );
+
+	for ( i = 0; i < y.length; i++ ) {
+		t.strictEqual( y.iget( i ).toString(), '5 + 0i', 'returns expected value' );
+	}
+
 	t.end();
 });
 
@@ -363,6 +551,7 @@ tape( 'the function assigns a scalar value to each indexed element of a 3-dimens
 	var o;
 	var v;
 	var y;
+	var i;
 
 	dt = 'float64';
 	ord = 'row-major';
@@ -384,275 +573,234 @@ tape( 'the function assigns a scalar value to each indexed element of a 3-dimens
 
 	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
 
+	// Bool:
+	y = ndarray( 'bool', new BooleanArray( numel( sh )*2 ), sh, st, o, ord );
+
+	v = scalar2ndarray( true, {
+		'dtype': 'bool'
+	});
+	assignScalar( [ v, y ] );
+
+	for ( i = 0; i < y.length; i++ ) {
+		t.strictEqual( y.iget( i ), true, 'returns expected value' );
+	}
+
+	// Real-to-complex:
+	y = ndarray( 'complex128', zeros( numel( sh )*2, 'complex128' ), sh, st, o, ord );
+
+	v = scalar2ndarray( 5.0, {
+		'dtype': 'float64'
+	});
+	assignScalar( [ v, y ] );
+
+	for ( i = 0; i < y.length; i++ ) {
+		t.strictEqual( y.iget( i ).toString(), '5 + 0i', 'returns expected value' );
+	}
+
 	t.end();
 });
 
 tape( 'the function assigns a scalar value to each indexed element of a 3-dimensional output ndarray (row-major, contiguous, accessors)', function test( t ) {
-	var expected;
 	var ord;
 	var sh;
 	var st;
-	var dt;
 	var o;
 	var v;
 	var y;
+	var i;
 
-	dt = 'complex128';
 	ord = 'row-major';
 	sh = [ 2, 1, 2 ];
 	st = shape2strides( sh, ord );
 	o = strides2offset( sh, st );
 
-	y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+	y = ndarray( 'generic', toAccessorArray( zeros( numel( sh ), 'generic' ) ), sh, st, o, ord );
 
-	v = scalar2ndarray( new Complex128( 10.0, -10.0 ), {
-		'dtype': dt
+	v = scalar2ndarray( 10.0, {
+		'dtype': 'generic'
 	});
 	assignScalar( [ v, y ] );
 
-	expected = new Complex128Array([
-		10.0,
-		-10.0,
-		10.0,
-		-10.0,
-		10.0,
-		-10.0,
-		10.0,
-		-10.0
-	]);
-	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	for ( i = 0; i < numel( sh ); i++ ) {
+		t.strictEqual( y.iget( i ), 10.0, 'returns expected value' );
+	}
 
 	t.end();
 });
 
 tape( 'the function assigns a scalar value to each indexed element of a 3-dimensional output ndarray (row-major, contiguous, negative strides, accessors)', function test( t ) {
-	var expected;
 	var ord;
 	var sh;
 	var st;
-	var dt;
 	var o;
 	var v;
 	var y;
+	var i;
 
-	dt = 'complex128';
 	ord = 'row-major';
 	sh = [ 2, 2, 2 ];
 	st = [ -4, -2, -1 ];
 	o = strides2offset( sh, st );
 
-	y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+	y = ndarray( 'generic', toAccessorArray( zeros( numel( sh ), 'generic' ) ), sh, st, o, ord );
 
-	v = scalar2ndarray( new Complex128( 10.0, 10.0 ), {
-		'dtype': dt
+	v = scalar2ndarray( 10.0, {
+		'dtype': 'generic'
 	});
 	assignScalar( [ v, y ] );
 
-	expected = new Complex128Array([
-		10.0,
-		10.0,
-		10.0,
-		10.0,
-		10.0,
-		10.0,
-		10.0,
-		10.0,
-		10.0,
-		10.0,
-		10.0,
-		10.0,
-		10.0,
-		10.0,
-		10.0,
-		10.0
-	]);
-	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	for ( i = 0; i < numel( sh ); i++ ) {
+		t.strictEqual( y.iget( i ), 10.0, 'returns expected value' );
+	}
 
 	t.end();
 });
 
 tape( 'the function assigns a scalar value to each indexed element of a 3-dimensional output ndarray (row-major, non-contiguous, same sign strides, accessors)', function test( t ) {
-	var expected;
 	var ord;
 	var sh;
 	var st;
-	var dt;
 	var o;
 	var v;
 	var y;
+	var i;
 
-	dt = 'complex128';
 	ord = 'row-major';
 	sh = [ 2, 1, 2 ];
 	st = [ 3, 2, 1 ];
 	o = strides2offset( sh, st );
 
-	y = ndarray( dt, zeros( 6, dt ), sh, st, o, ord );
+	y = ndarray( 'generic', toAccessorArray( zeros( 6, 'generic' ) ), sh, st, o, ord );
 
-	v = scalar2ndarray( new Complex128( 10.0, 10.0 ), {
-		'dtype': dt
+	v = scalar2ndarray( 10.0, {
+		'dtype': 'generic'
 	});
 	assignScalar( [ v, y ] );
 
-	expected = new Complex128Array([
-		10.0,
-		10.0,
-		10.0,
-		10.0,
-		0.0,
-		0.0,
-		10.0,
-		10.0,
-		10.0,
-		10.0,
-		0.0,
-		0.0
-	]);
-	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	for ( i = 0; i < y.length; i++ ) {
+		t.strictEqual( y.iget( i ), 10.0, 'returns expected value' );
+	}
 
 	t.end();
 });
 
 tape( 'the function assigns a scalar value to each indexed element of a 3-dimensional output ndarray (row-major, non-contiguous, mixed sign strides, accessors)', function test( t ) {
-	var expected;
 	var ord;
 	var sh;
 	var st;
-	var dt;
 	var o;
 	var v;
 	var y;
+	var i;
 
-	dt = 'complex128';
 	ord = 'row-major';
 	sh = [ 2, 1, 2 ];
 	st = [ -3, -2, 1 ];
 	o = strides2offset( sh, st );
 
-	y = ndarray( dt, zeros( 6, dt ), sh, st, o, ord );
+	y = ndarray( 'generic', toAccessorArray( zeros( 6, 'generic' ) ), sh, st, o, ord );
 
-	v = scalar2ndarray( new Complex128( 10.0, 10.0 ), {
-		'dtype': dt
+	v = scalar2ndarray( 10.0, {
+		'dtype': 'generic'
 	});
 	assignScalar( [ v, y ] );
 
-	expected = new Complex128Array([
-		10.0,
-		10.0,
-		10.0,
-		10.0,
-		0.0,
-		0.0,
-		10.0,
-		10.0,
-		10.0,
-		10.0,
-		0.0,
-		0.0
-	]);
-	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	for ( i = 0; i < y.length; i++ ) {
+		t.strictEqual( y.iget( i ), 10.0, 'returns expected value' );
+	}
 
 	t.end();
 });
 
 tape( 'the function assigns a scalar value to each indexed element of a 3-dimensional output ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) {
-	var expected;
 	var bsize;
 	var ord;
 	var sh;
 	var st;
-	var dt;
 	var o;
 	var v;
 	var y;
+	var i;
 
-	dt = 'complex128';
 	ord = 'row-major';
 
-	bsize = blockSize( dt );
+	bsize = blockSize( 'float64' );
 	sh = [ bsize*2, 1, 2 ];
 	st = [ -4, -4, 2 ];
 	o = strides2offset( sh, st );
 
-	y = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+	y = ndarray( 'generic', toAccessorArray( zeros( numel( sh )*2, 'generic' ) ), sh, st, o, ord );
 
-	v = scalar2ndarray( new Complex128( 10.0, 10.0 ), {
-		'dtype': dt
+	v = scalar2ndarray( 10.0, {
+		'dtype': 'generic'
 	});
 	assignScalar( [ v, y ] );
 
-	expected = new Complex128Array( y.length*2 );
-	gfill( y.length, new Complex128( 10.0, 10.0 ), expected, st[ 2 ] );
-
-	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	for ( i = 0; i < y.length; i++ ) {
+		t.strictEqual( y.iget( i ), 10.0, 'returns expected value' );
+	}
 
 	t.end();
 });
 
 tape( 'the function assigns a scalar value to each indexed element of a 3-dimensional output ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) {
-	var expected;
 	var bsize;
 	var ord;
 	var sh;
 	var st;
-	var dt;
 	var o;
 	var v;
 	var y;
+	var i;
 
-	dt = 'complex128';
 	ord = 'row-major';
 
-	bsize = blockSize( dt );
+	bsize = blockSize( 'float64' );
 	sh = [ 1, bsize*2, 2 ];
 	st = [ -bsize*8, -4, 2 ];
 	o = strides2offset( sh, st );
 
-	y = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+	y = ndarray( 'generic', toAccessorArray( zeros( numel( sh )*2, 'generic' ) ), sh, st, o, ord );
 
-	v = scalar2ndarray( new Complex128( 10.0, 10.0 ), {
-		'dtype': dt
+	v = scalar2ndarray( 10.0, {
+		'dtype': 'generic'
 	});
 	assignScalar( [ v, y ] );
 
-	expected = new Complex128Array( y.length*2 );
-	gfill( y.length, new Complex128( 10.0, 10.0 ), expected, st[ 2 ] );
-
-	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	for ( i = 0; i < y.length; i++ ) {
+		t.strictEqual( y.iget( i ), 10.0, 'returns expected value' );
+	}
 
 	t.end();
 });
 
 tape( 'the function assigns a scalar value to each indexed element of a 3-dimensional output ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) {
-	var expected;
 	var bsize;
 	var ord;
 	var sh;
 	var st;
-	var dt;
 	var o;
 	var v;
 	var y;
+	var i;
 
-	dt = 'complex128';
 	ord = 'row-major';
 
-	bsize = blockSize( dt );
+	bsize = blockSize( 'float64' );
 	sh = [ 1, 2, bsize*2 ];
 	st = [ bsize*8, bsize*4, -2 ];
 	o = strides2offset( sh, st );
 
-	y = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+	y = ndarray( 'generic', toAccessorArray( zeros( numel( sh )*2, 'generic' ) ), sh, st, o, ord );
 
-	v = scalar2ndarray( new Complex128( 10.0, 10.0 ), {
-		'dtype': dt
+	v = scalar2ndarray( 10.0, {
+		'dtype': 'generic'
 	});
 	assignScalar( [ v, y ] );
 
-	expected = new Complex128Array( y.length*2 );
-	gfill( y.length, new Complex128( 10.0, 10.0 ), expected, st[ 2 ] );
-
-	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	for ( i = 0; i < y.length; i++ ) {
+		t.strictEqual( y.iget( i ), 10.0, 'returns expected value' );
+	}
 
 	t.end();
 });
@@ -666,6 +814,7 @@ tape( 'the function assigns a scalar value to each indexed element of a 3-dimens
 	var o;
 	var v;
 	var y;
+	var i;
 
 	dt = 'float64';
 	ord = 'column-major';
@@ -688,43 +837,56 @@ tape( 'the function assigns a scalar value to each indexed element of a 3-dimens
 	]);
 	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
 
+	// Bool:
+	y = ndarray( 'bool', new BooleanArray( numel( sh ) ), sh, st, o, ord );
+
+	v = scalar2ndarray( true, {
+		'dtype': 'bool'
+	});
+	assignScalar( [ v, y ] );
+
+	for ( i = 0; i < numel( sh ); i++ ) {
+		t.strictEqual( y.data.get( i ), true, 'returns expected value' );
+	}
+
+	// Real-to-complex:
+	y = ndarray( 'complex128', zeros( numel( sh ), 'complex128' ), sh, st, o, ord );
+
+	v = scalar2ndarray( 5.0, {
+		'dtype': 'float64'
+	});
+	assignScalar( [ v, y ] );
+
+	expected = new Complex128Array( [ 5.0, 0.0, 5.0, 0.0, 5.0, 0.0, 5.0, 0.0 ] );
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+
 	t.end();
 });
 
 tape( 'the function assigns a scalar value to each indexed element of a 3-dimensional output ndarray (column-major, singleton dimensions, accessors)', function test( t ) {
-	var expected;
 	var ord;
 	var sh;
 	var st;
-	var dt;
 	var o;
 	var v;
 	var y;
+	var i;
 
-	dt = 'complex128';
 	ord = 'column-major';
 	sh = [ 1, 1, 4 ];
 	st = shape2strides( sh, ord );
 	o = strides2offset( sh, st );
 
-	y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+	y = ndarray( 'generic', toAccessorArray( zeros( numel( sh ), 'generic' ) ), sh, st, o, ord );
 
-	v = scalar2ndarray( new Complex128( 10.0, 10.0 ), {
-		'dtype': dt
+	v = scalar2ndarray( 10.0, {
+		'dtype': 'generic'
 	});
 	assignScalar( [ v, y ] );
 
-	expected = new Complex128Array([
-		10.0,
-		10.0,
-		10.0,
-		10.0,
-		10.0,
-		10.0,
-		10.0,
-		10.0
-	]);
-	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	for ( i = 0; i < numel( sh ); i++ ) {
+		t.strictEqual( y.iget( i ), 10.0, 'returns expected value' );
+	}
 
 	t.end();
 });
@@ -733,6 +895,7 @@ tape( 'the function assigns a scalar value to each indexed element of a 3-dimens
 	var expected;
 	var v;
 	var y;
+	var i;
 
 	y = ndarray( 'float64', zeros( 4, 'float64' ), [ 0, 0, 0 ], [ 1, 1, 1 ], 0, 'column-major' );
 
@@ -749,6 +912,29 @@ tape( 'the function assigns a scalar value to each indexed element of a 3-dimens
 	]);
 	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
 
+	// Bool:
+	y = ndarray( 'bool', new BooleanArray( 4 ), [ 0, 0, 0 ], [ 1, 1, 1 ], 0, 'column-major' );
+
+	v = scalar2ndarray( true, {
+		'dtype': 'bool'
+	});
+	assignScalar( [ v, y ] );
+
+	for ( i = 0; i < 4; i++ ) {
+		t.strictEqual( y.data.get( i ), false, 'returns expected value' );
+	}
+
+	// Real-to-complex:
+	y = ndarray( 'complex128', zeros( 4, 'complex128' ), [ 0, 0, 0 ], [ 1, 1, 1 ], 0, 'column-major' );
+
+	v = scalar2ndarray( 5.0, {
+		'dtype': 'float64'
+	});
+	assignScalar( [ v, y ] );
+
+	expected = new Complex128Array( [ 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 ] );
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+
 	t.end();
 });
 
@@ -761,6 +947,7 @@ tape( 'the function assigns a scalar value to each indexed element of a 3-dimens
 	var o;
 	var v;
 	var y;
+	var i;
 
 	dt = 'float64';
 	ord = 'column-major';
@@ -783,6 +970,29 @@ tape( 'the function assigns a scalar value to each indexed element of a 3-dimens
 	]);
 	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
 
+	// Bool:
+	y = ndarray( 'bool', new BooleanArray( numel( sh ) ), sh, st, o, ord );
+
+	v = scalar2ndarray( true, {
+		'dtype': 'bool'
+	});
+	assignScalar( [ v, y ] );
+
+	for ( i = 0; i < numel( sh ); i++ ) {
+		t.strictEqual( y.data.get( i ), true, 'returns expected value' );
+	}
+
+	// Real-to-complex:
+	y = ndarray( 'complex128', zeros( numel( sh ), 'complex128' ), sh, st, o, ord );
+
+	v = scalar2ndarray( 5.0, {
+		'dtype': 'float64'
+	});
+	assignScalar( [ v, y ] );
+
+	expected = new Complex128Array( [ 5.0, 0.0, 5.0, 0.0, 5.0, 0.0, 5.0, 0.0 ] );
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+
 	t.end();
 });
 
@@ -795,6 +1005,7 @@ tape( 'the function assigns a scalar value to each indexed element of a 3-dimens
 	var o;
 	var v;
 	var y;
+	var i;
 
 	dt = 'float64';
 	ord = 'column-major';
@@ -821,6 +1032,29 @@ tape( 'the function assigns a scalar value to each indexed element of a 3-dimens
 	]);
 	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
 
+	// Bool:
+	y = ndarray( 'bool', new BooleanArray( numel( sh ) ), sh, st, o, ord );
+
+	v = scalar2ndarray( true, {
+		'dtype': 'bool'
+	});
+	assignScalar( [ v, y ] );
+
+	for ( i = 0; i < numel( sh ); i++ ) {
+		t.strictEqual( y.data.get( i ), true, 'returns expected value' );
+	}
+
+	// Real-to-complex:
+	y = ndarray( 'complex128', zeros( numel( sh ), 'complex128' ), sh, st, o, ord );
+
+	v = scalar2ndarray( 5.0, {
+		'dtype': 'float64'
+	});
+	assignScalar( [ v, y ] );
+
+	expected = new Complex128Array( [ 5.0, 0.0, 5.0, 0.0, 5.0, 0.0, 5.0, 0.0, 5.0, 0.0, 5.0, 0.0, 5.0, 0.0, 5.0, 0.0 ] );
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+
 	t.end();
 });
 
@@ -833,6 +1067,7 @@ tape( 'the function assigns a scalar value to each indexed element of a 3-dimens
 	var o;
 	var v;
 	var y;
+	var i;
 
 	dt = 'float64';
 	ord = 'column-major';
@@ -857,6 +1092,30 @@ tape( 'the function assigns a scalar value to each indexed element of a 3-dimens
 	]);
 	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
 
+	// Bool:
+	y = ndarray( 'bool', new BooleanArray( 6 ), sh, st, o, ord );
+
+	v = scalar2ndarray( true, {
+		'dtype': 'bool'
+	});
+	assignScalar( [ v, y ] );
+
+	for ( i = 0; i < y.length; i++ ) {
+		t.strictEqual( y.iget( i ), true, 'returns expected value' );
+	}
+
+	// Real-to-complex:
+	y = ndarray( 'complex128', zeros( 6, 'complex128' ), sh, st, o, ord );
+
+	v = scalar2ndarray( 5.0, {
+		'dtype': 'float64'
+	});
+	assignScalar( [ v, y ] );
+
+	for ( i = 0; i < y.length; i++ ) {
+		t.strictEqual( y.iget( i ).toString(), '5 + 0i', 'returns expected value' );
+	}
+
 	t.end();
 });
 
@@ -869,6 +1128,7 @@ tape( 'the function assigns a scalar value to each indexed element of a 3-dimens
 	var o;
 	var v;
 	var y;
+	var i;
 
 	dt = 'float64';
 	ord = 'column-major';
@@ -893,6 +1153,30 @@ tape( 'the function assigns a scalar value to each indexed element of a 3-dimens
 	]);
 	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
 
+	// Bool:
+	y = ndarray( 'bool', new BooleanArray( 6 ), sh, st, o, ord );
+
+	v = scalar2ndarray( true, {
+		'dtype': 'bool'
+	});
+	assignScalar( [ v, y ] );
+
+	for ( i = 0; i < y.length; i++ ) {
+		t.strictEqual( y.iget( i ), true, 'returns expected value' );
+	}
+
+	// Real-to-complex:
+	y = ndarray( 'complex128', zeros( 6, 'complex128' ), sh, st, o, ord );
+
+	v = scalar2ndarray( 5.0, {
+		'dtype': 'float64'
+	});
+	assignScalar( [ v, y ] );
+
+	for ( i = 0; i < y.length; i++ ) {
+		t.strictEqual( y.iget( i ).toString(), '5 + 0i', 'returns expected value' );
+	}
+
 	t.end();
 });
 
@@ -906,6 +1190,7 @@ tape( 'the function assigns a scalar value to each indexed element of a 3-dimens
 	var o;
 	var v;
 	var y;
+	var i;
 
 	dt = 'float64';
 	ord = 'column-major';
@@ -927,6 +1212,30 @@ tape( 'the function assigns a scalar value to each indexed element of a 3-dimens
 
 	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
 
+	// Bool:
+	y = ndarray( 'bool', new BooleanArray( numel( sh )*2 ), sh, st, o, ord );
+
+	v = scalar2ndarray( true, {
+		'dtype': 'bool'
+	});
+	assignScalar( [ v, y ] );
+
+	for ( i = 0; i < y.length; i++ ) {
+		t.strictEqual( y.iget( i ), true, 'returns expected value' );
+	}
+
+	// Real-to-complex:
+	y = ndarray( 'complex128', zeros( numel( sh )*2, 'complex128' ), sh, st, o, ord );
+
+	v = scalar2ndarray( 5.0, {
+		'dtype': 'float64'
+	});
+	assignScalar( [ v, y ] );
+
+	for ( i = 0; i < y.length; i++ ) {
+		t.strictEqual( y.iget( i ).toString(), '5 + 0i', 'returns expected value' );
+	}
+
 	t.end();
 });
 
@@ -940,6 +1249,7 @@ tape( 'the function assigns a scalar value to each indexed element of a 3-dimens
 	var o;
 	var v;
 	var y;
+	var i;
 
 	dt = 'float64';
 	ord = 'column-major';
@@ -961,6 +1271,30 @@ tape( 'the function assigns a scalar value to each indexed element of a 3-dimens
 
 	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
 
+	// Bool:
+	y = ndarray( 'bool', new BooleanArray( numel( sh )*2 ), sh, st, o, ord );
+
+	v = scalar2ndarray( true, {
+		'dtype': 'bool'
+	});
+	assignScalar( [ v, y ] );
+
+	for ( i = 0; i < y.length; i++ ) {
+		t.strictEqual( y.iget( i ), true, 'returns expected value' );
+	}
+
+	// Real-to-complex:
+	y = ndarray( 'complex128', zeros( numel( sh )*2, 'complex128' ), sh, st, o, ord );
+
+	v = scalar2ndarray( 5.0, {
+		'dtype': 'float64'
+	});
+	assignScalar( [ v, y ] );
+
+	for ( i = 0; i < y.length; i++ ) {
+		t.strictEqual( y.iget( i ).toString(), '5 + 0i', 'returns expected value' );
+	}
+
 	t.end();
 });
 
@@ -974,6 +1308,7 @@ tape( 'the function assigns a scalar value to each indexed element of a 3-dimens
 	var o;
 	var v;
 	var y;
+	var i;
 
 	dt = 'float64';
 	ord = 'column-major';
@@ -995,275 +1330,234 @@ tape( 'the function assigns a scalar value to each indexed element of a 3-dimens
 
 	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
 
+	// Bool:
+	y = ndarray( 'bool', new BooleanArray( numel( sh )*2 ), sh, st, o, ord );
+
+	v = scalar2ndarray( true, {
+		'dtype': 'bool'
+	});
+	assignScalar( [ v, y ] );
+
+	for ( i = 0; i < y.length; i++ ) {
+		t.strictEqual( y.iget( i ), true, 'returns expected value' );
+	}
+
+	// Real-to-complex:
+	y = ndarray( 'complex128', zeros( numel( sh )*2, 'complex128' ), sh, st, o, ord );
+
+	v = scalar2ndarray( 5.0, {
+		'dtype': 'float64'
+	});
+	assignScalar( [ v, y ] );
+
+	for ( i = 0; i < y.length; i++ ) {
+		t.strictEqual( y.iget( i ).toString(), '5 + 0i', 'returns expected value' );
+	}
+
 	t.end();
 });
 
 tape( 'the function assigns a scalar value to each indexed element of a 3-dimensional output ndarray (column-major, contiguous, accessors)', function test( t ) {
-	var expected;
 	var ord;
 	var sh;
 	var st;
-	var dt;
 	var o;
 	var v;
 	var y;
+	var i;
 
-	dt = 'complex128';
 	ord = 'column-major';
 	sh = [ 2, 1, 2 ];
 	st = shape2strides( sh, ord );
 	o = strides2offset( sh, st );
 
-	y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+	y = ndarray( 'generic', toAccessorArray( zeros( numel( sh ), 'generic' ) ), sh, st, o, ord );
 
-	v = scalar2ndarray( new Complex128( 10.0, -10.0 ), {
-		'dtype': dt
+	v = scalar2ndarray( 10.0, {
+		'dtype': 'generic'
 	});
 	assignScalar( [ v, y ] );
 
-	expected = new Complex128Array([
-		10.0,
-		-10.0,
-		10.0,
-		-10.0,
-		10.0,
-		-10.0,
-		10.0,
-		-10.0
-	]);
-	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	for ( i = 0; i < numel( sh ); i++ ) {
+		t.strictEqual( y.iget( i ), 10.0, 'returns expected value' );
+	}
 
 	t.end();
 });
 
 tape( 'the function assigns a scalar value to each indexed element of a 3-dimensional output ndarray (column-major, contiguous, negative strides, accessors)', function test( t ) {
-	var expected;
 	var ord;
 	var sh;
 	var st;
-	var dt;
 	var o;
 	var v;
 	var y;
+	var i;
 
-	dt = 'complex128';
 	ord = 'column-major';
 	sh = [ 2, 2, 2 ];
 	st = [ -1, -2, -4 ];
 	o = strides2offset( sh, st );
 
-	y = ndarray( dt, zeros( numel( sh ), dt ), sh, st, o, ord );
+	y = ndarray( 'generic', toAccessorArray( zeros( numel( sh ), 'generic' ) ), sh, st, o, ord );
 
-	v = scalar2ndarray( new Complex128( 10.0, 10.0 ), {
-		'dtype': dt
+	v = scalar2ndarray( 10.0, {
+		'dtype': 'generic'
 	});
 	assignScalar( [ v, y ] );
 
-	expected = new Complex128Array([
-		10.0,
-		10.0,
-		10.0,
-		10.0,
-		10.0,
-		10.0,
-		10.0,
-		10.0,
-		10.0,
-		10.0,
-		10.0,
-		10.0,
-		10.0,
-		10.0,
-		10.0,
-		10.0
-	]);
-	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	for ( i = 0; i < numel( sh ); i++ ) {
+		t.strictEqual( y.iget( i ), 10.0, 'returns expected value' );
+	}
 
 	t.end();
 });
 
 tape( 'the function assigns a scalar value to each indexed element of a 3-dimensional output ndarray (column-major, non-contiguous, same sign strides, accessors)', function test( t ) {
-	var expected;
 	var ord;
 	var sh;
 	var st;
-	var dt;
 	var o;
 	var v;
 	var y;
+	var i;
 
-	dt = 'complex128';
 	ord = 'column-major';
 	sh = [ 2, 1, 2 ];
 	st = [ 1, 2, 3 ];
 	o = strides2offset( sh, st );
 
-	y = ndarray( dt, zeros( 6, dt ), sh, st, o, ord );
+	y = ndarray( 'generic', toAccessorArray( zeros( 6, 'generic' ) ), sh, st, o, ord );
 
-	v = scalar2ndarray( new Complex128( 10.0, 10.0 ), {
-		'dtype': dt
+	v = scalar2ndarray( 10.0, {
+		'dtype': 'generic'
 	});
 	assignScalar( [ v, y ] );
 
-	expected = new Complex128Array([
-		10.0,
-		10.0,
-		10.0,
-		10.0,
-		0.0,
-		0.0,
-		10.0,
-		10.0,
-		10.0,
-		10.0,
-		0.0,
-		0.0
-	]);
-	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	for ( i = 0; i < y.length; i++ ) {
+		t.strictEqual( y.iget( i ), 10.0, 'returns expected value' );
+	}
 
 	t.end();
 });
 
 tape( 'the function assigns a scalar value to each indexed element of a 3-dimensional output ndarray (column-major, non-contiguous, mixed sign strides, accessors)', function test( t ) {
-	var expected;
 	var ord;
 	var sh;
 	var st;
-	var dt;
 	var o;
 	var v;
 	var y;
+	var i;
 
-	dt = 'complex128';
 	ord = 'column-major';
 	sh = [ 2, 1, 2 ];
 	st = [ -1, -2, 3 ];
 	o = strides2offset( sh, st );
 
-	y = ndarray( dt, zeros( 6, dt ), sh, st, o, ord );
+	y = ndarray( 'generic', toAccessorArray( zeros( 6, 'generic' ) ), sh, st, o, ord );
 
-	v = scalar2ndarray( new Complex128( 10.0, 10.0 ), {
-		'dtype': dt
+	v = scalar2ndarray( 10.0, {
+		'dtype': 'generic'
 	});
 	assignScalar( [ v, y ] );
 
-	expected = new Complex128Array([
-		10.0,
-		10.0,
-		10.0,
-		10.0,
-		0.0,
-		0.0,
-		10.0,
-		10.0,
-		10.0,
-		10.0,
-		0.0,
-		0.0
-	]);
-	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	for ( i = 0; i < y.length; i++ ) {
+		t.strictEqual( y.iget( i ), 10.0, 'returns expected value' );
+	}
 
 	t.end();
 });
 
 tape( 'the function assigns a scalar value to each indexed element of a 3-dimensional output ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) {
-	var expected;
 	var bsize;
 	var ord;
 	var sh;
 	var st;
-	var dt;
 	var o;
 	var v;
 	var y;
+	var i;
 
-	dt = 'complex128';
 	ord = 'column-major';
 
-	bsize = blockSize( dt );
+	bsize = blockSize( 'float64' );
 	sh = [ bsize*2, 2, 1 ];
 	st = [ 2, -bsize*4, -bsize*8 ];
 	o = strides2offset( sh, st );
 
-	y = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+	y = ndarray( 'generic', toAccessorArray( zeros( numel( sh )*2, 'generic' ) ), sh, st, o, ord );
 
-	v = scalar2ndarray( new Complex128( 10.0, 10.0 ), {
-		'dtype': dt
+	v = scalar2ndarray( 10.0, {
+		'dtype': 'generic'
 	});
 	assignScalar( [ v, y ] );
 
-	expected = new Complex128Array( y.length*2 );
-	gfill( y.length, new Complex128( 10.0, 10.0 ), expected, st[ 0 ] );
-
-	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	for ( i = 0; i < y.length; i++ ) {
+		t.strictEqual( y.iget( i ), 10.0, 'returns expected value' );
+	}
 
 	t.end();
 });
 
 tape( 'the function assigns a scalar value to each indexed element of a 3-dimensional output ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) {
-	var expected;
 	var bsize;
 	var ord;
 	var sh;
 	var st;
-	var dt;
 	var o;
 	var v;
 	var y;
+	var i;
 
-	dt = 'complex128';
 	ord = 'column-major';
 
-	bsize = blockSize( dt );
+	bsize = blockSize( 'float64' );
 	sh = [ 2, bsize*2, 1 ];
 	st = [ -2, 4, bsize*8 ];
 	o = strides2offset( sh, st );
 
-	y = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+	y = ndarray( 'generic', toAccessorArray( zeros( numel( sh )*2, 'generic' ) ), sh, st, o, ord );
 
-	v = scalar2ndarray( new Complex128( 10.0, 10.0 ), {
-		'dtype': dt
+	v = scalar2ndarray( 10.0, {
+		'dtype': 'generic'
 	});
 	assignScalar( [ v, y ] );
 
-	expected = new Complex128Array( y.length*2 );
-	gfill( y.length, new Complex128( 10.0, 10.0 ), expected, st[ 0 ] );
-
-	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	for ( i = 0; i < y.length; i++ ) {
+		t.strictEqual( y.iget( i ), 10.0, 'returns expected value' );
+	}
 
 	t.end();
 });
 
 tape( 'the function assigns a scalar value to each indexed element of a 3-dimensional output ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) {
-	var expected;
 	var bsize;
 	var ord;
 	var sh;
 	var st;
-	var dt;
 	var o;
 	var v;
 	var y;
+	var i;
 
-	dt = 'complex128';
 	ord = 'column-major';
 
-	bsize = blockSize( dt );
+	bsize = blockSize( 'float64' );
 	sh = [ 2, 1, bsize*2 ];
 	st = [ 2, -4, 4 ];
 	o = strides2offset( sh, st );
 
-	y = ndarray( dt, zeros( numel( sh )*2, dt ), sh, st, o, ord );
+	y = ndarray( 'generic', toAccessorArray( zeros( numel( sh )*2, 'generic' ) ), sh, st, o, ord );
 
-	v = scalar2ndarray( new Complex128( 10.0, 10.0 ), {
-		'dtype': dt
+	v = scalar2ndarray( 10.0, {
+		'dtype': 'generic'
 	});
 	assignScalar( [ v, y ] );
 
-	expected = new Complex128Array( y.length*2 );
-	gfill( y.length, new Complex128( 10.0, 10.0 ), expected, st[ 0 ] );
-
-	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	for ( i = 0; i < y.length; i++ ) {
+		t.strictEqual( y.iget( i ), 10.0, 'returns expected value' );
+	}
 
 	t.end();
 });

From cdd0834f6af7b73212062fac749ef90bbeb962da Mon Sep 17 00:00:00 2001
From: Athan <kgryte@gmail.com>
Date: Sun, 22 Mar 2026 20:27:47 -0700
Subject: [PATCH 07/20] chore: clean-up

---
type: pre_commit_static_analysis_report
description: Results of running static analysis checks when committing changes.
report:
  - task: lint_filenames
    status: passed
  - task: lint_editorconfig
    status: passed
  - task: lint_markdown
    status: na
  - task: lint_package_json
    status: na
  - task: lint_repl_help
    status: passed
  - task: lint_javascript_src
    status: na
  - task: lint_javascript_cli
    status: na
  - task: lint_javascript_examples
    status: na
  - task: lint_javascript_tests
    status: passed
  - task: lint_javascript_benchmarks
    status: na
  - task: lint_python
    status: na
  - task: lint_r
    status: na
  - task: lint_c_src
    status: na
  - task: lint_c_examples
    status: na
  - task: lint_c_benchmarks
    status: na
  - task: lint_c_tests_fixtures
    status: na
  - task: lint_shell
    status: na
  - task: lint_typescript_declarations
    status: passed
  - task: lint_typescript_tests
    status: na
  - task: lint_license_headers
    status: passed
---
---
 .../ndarray/base/assign-scalar/docs/repl.txt  |  1 +
 .../base/assign-scalar/test/test.0d.js        | 21 ++++++++
 .../base/assign-scalar/test/test.1d.js        | 51 +++++++++++++++++--
 .../base/assign-scalar/test/test.2d.js        | 45 ++++++++++++++++
 4 files changed, 115 insertions(+), 3 deletions(-)

diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/docs/repl.txt b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/docs/repl.txt
index ab77a80c1519..9ba16849b7c0 100644
--- a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/docs/repl.txt
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/docs/repl.txt
@@ -1,3 +1,4 @@
+
 {{alias}}( arrays )
     Assigns a scalar value to every element of an output ndarray.
 
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/test/test.0d.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/test/test.0d.js
index 6e68e77350e1..85ae397ace70 100644
--- a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/test/test.0d.js
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/test/test.0d.js
@@ -22,8 +22,11 @@
 
 var tape = require( 'tape' );
 var isSameFloat64Array = require( '@stdlib/assert/is-same-float64array' );
+var isSameComplex128Array = require( '@stdlib/assert/is-same-complex128array' );
 var toAccessorArray = require( '@stdlib/array/base/to-accessor-array' );
 var Float64Array = require( '@stdlib/array/float64' );
+var Complex128Array = require( '@stdlib/array/complex128' );
+var Complex128 = require( '@stdlib/complex/float64/ctor' );
 var scalar2ndarray = require( '@stdlib/ndarray/from-scalar' );
 var ndarray = require( '@stdlib/ndarray/ctor' );
 var assignScalar = require( './../lib' );
@@ -72,3 +75,21 @@ tape( 'the function assigns a scalar value to each element of a 0-dimensional ou
 
 	t.end();
 });
+
+tape( 'the function assigns a scalar value to each element of a 0-dimensional output ndarray (complex)', function test( t ) {
+	var expected;
+	var v;
+	var y;
+
+	y = ndarray( 'complex128', new Complex128Array( [ 0.0, 0.0 ] ), [], [ 0 ], 0, 'row-major' );
+
+	v = scalar2ndarray( new Complex128( 9.0, 10.0 ), {
+		'dtype': 'complex128'
+	});
+	assignScalar( [ v, y ] );
+
+	expected = new Complex128Array( [ 9.0, 10.0 ] );
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+
+	t.end();
+});
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/test/test.1d.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/test/test.1d.js
index 491021f43add..1f40d82a6c01 100644
--- a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/test/test.1d.js
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/test/test.1d.js
@@ -30,6 +30,7 @@ var toAccessorArray = require( '@stdlib/array/base/to-accessor-array' );
 var zeros = require( '@stdlib/array/zeros' );
 var scalar2ndarray = require( '@stdlib/ndarray/from-scalar' );
 var ndarray = require( '@stdlib/ndarray/ctor' );
+var Complex128 = require( '@stdlib/complex/float64/ctor' );
 var assignScalar = require( './../lib' );
 
 
@@ -78,6 +79,34 @@ tape( 'the function assigns a scalar value to each indexed element of a 1-dimens
 		t.strictEqual( y.get( i ), true, 'returns expected value' );
 	}
 
+	// Complex:
+	y = ndarray( 'complex128', zeros( 8, 'complex128' ), [ 4 ], [ 2 ], 1, 'row-major' );
+
+	v = scalar2ndarray( new Complex128( 5.0, 6.0 ), {
+		'dtype': 'complex128'
+	});
+	assignScalar( [ v, y ] );
+
+	expected = new Complex128Array([
+		0.0, // 0
+		0.0,
+		5.0, // 1
+		6.0,
+		0.0, // 2
+		0.0,
+		5.0, // 3
+		6.0,
+		0.0, // 4
+		0.0,
+		5.0, // 5
+		6.0,
+		0.0, // 6
+		0.0,
+		5.0, // 7
+		6.0
+	]);
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+
 	// Real-to-complex:
 	y = ndarray( 'complex128', zeros( 8, 'complex128' ), [ 4 ], [ 2 ], 1, 'row-major' );
 
@@ -86,9 +115,25 @@ tape( 'the function assigns a scalar value to each indexed element of a 1-dimens
 	});
 	assignScalar( [ v, y ] );
 
-	for ( i = 0; i < 4; i++ ) {
-		t.strictEqual( y.get( i ).toString(), '5 + 0i', 'returns expected value' );
-	}
+	expected = new Complex128Array([
+		0.0, // 0
+		0.0,
+		5.0, // 1
+		0.0,
+		0.0, // 2
+		0.0,
+		5.0, // 3
+		0.0,
+		0.0, // 4
+		0.0,
+		5.0, // 5
+		0.0,
+		0.0, // 6
+		0.0,
+		5.0, // 7
+		0.0
+	]);
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/test/test.2d.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/test/test.2d.js
index 7512bce71c08..cd6752175cb9 100644
--- a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/test/test.2d.js
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/test/test.2d.js
@@ -37,6 +37,7 @@ var strides2offset = require( '@stdlib/ndarray/base/strides2offset' );
 var numel = require( '@stdlib/ndarray/base/numel' );
 var dfill = require( '@stdlib/blas/ext/base/dfill' );
 var blockSize = require( '@stdlib/ndarray/base/nullary-tiling-block-size' );
+var Complex128 = require( '@stdlib/complex/float64/ctor' );
 var assignScalar = require( './../lib' );
 
 
@@ -92,6 +93,17 @@ tape( 'the function assigns a scalar value to each indexed element of a 2-dimens
 		t.strictEqual( y.data.get( i ), true, 'returns expected value' );
 	}
 
+	// Complex:
+	y = ndarray( 'complex128', zeros( numel( sh ), 'complex128' ), sh, st, o, ord );
+
+	v = scalar2ndarray( new Complex128( 5.0, 6.0 ), {
+		'dtype': 'complex128'
+	});
+	assignScalar( [ v, y ] );
+
+	expected = new Complex128Array( [ 5.0, 6.0, 5.0, 6.0, 5.0, 6.0, 5.0, 6.0 ] );
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+
 	// Real-to-complex:
 	y = ndarray( 'complex128', zeros( numel( sh ), 'complex128' ), sh, st, o, ord );
 
@@ -167,6 +179,17 @@ tape( 'the function assigns a scalar value to each indexed element of a 2-dimens
 		t.strictEqual( y.data.get( i ), false, 'returns expected value' );
 	}
 
+	// Complex:
+	y = ndarray( 'complex128', zeros( 4, 'complex128' ), [ 0, 0 ], [ 1, 1 ], 0, 'row-major' );
+
+	v = scalar2ndarray( new Complex128( 5.0, 6.0 ), {
+		'dtype': 'complex128'
+	});
+	assignScalar( [ v, y ] );
+
+	expected = new Complex128Array( [ 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 ] );
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+
 	// Real-to-complex:
 	y = ndarray( 'complex128', zeros( 4, 'complex128' ), [ 0, 0 ], [ 1, 1 ], 0, 'row-major' );
 
@@ -225,6 +248,17 @@ tape( 'the function assigns a scalar value to each indexed element of a 2-dimens
 		t.strictEqual( y.data.get( i ), true, 'returns expected value' );
 	}
 
+	// Complex:
+	y = ndarray( 'complex128', zeros( numel( sh ), 'complex128' ), sh, st, o, ord );
+
+	v = scalar2ndarray( new Complex128( 5.0, 6.0 ), {
+		'dtype': 'complex128'
+	});
+	assignScalar( [ v, y ] );
+
+	expected = new Complex128Array( [ 5.0, 6.0, 5.0, 6.0, 5.0, 6.0, 5.0, 6.0 ] );
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+
 	// Real-to-complex:
 	y = ndarray( 'complex128', zeros( numel( sh ), 'complex128' ), sh, st, o, ord );
 
@@ -283,6 +317,17 @@ tape( 'the function assigns a scalar value to each indexed element of a 2-dimens
 		t.strictEqual( y.data.get( i ), true, 'returns expected value' );
 	}
 
+	// Complex:
+	y = ndarray( 'complex128', zeros( numel( sh ), 'complex128' ), sh, st, o, ord );
+
+	v = scalar2ndarray( new Complex128( 5.0, 6.0 ), {
+		'dtype': 'complex128'
+	});
+	assignScalar( [ v, y ] );
+
+	expected = new Complex128Array( [ 5.0, 6.0, 5.0, 6.0, 5.0, 6.0, 5.0, 6.0 ] );
+	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+
 	// Real-to-complex:
 	y = ndarray( 'complex128', zeros( numel( sh ), 'complex128' ), sh, st, o, ord );
 

From 007ab7108dd7cfe3ce99a8c16d54a3f33d02dbc2 Mon Sep 17 00:00:00 2001
From: Athan <kgryte@gmail.com>
Date: Sun, 22 Mar 2026 21:04:10 -0700
Subject: [PATCH 08/20] test: improve tests

---
type: pre_commit_static_analysis_report
description: Results of running static analysis checks when committing changes.
report:
  - task: lint_filenames
    status: passed
  - task: lint_editorconfig
    status: passed
  - task: lint_markdown
    status: na
  - task: lint_package_json
    status: na
  - task: lint_repl_help
    status: na
  - task: lint_javascript_src
    status: na
  - task: lint_javascript_cli
    status: na
  - task: lint_javascript_examples
    status: na
  - task: lint_javascript_tests
    status: passed
  - task: lint_javascript_benchmarks
    status: na
  - task: lint_python
    status: na
  - task: lint_r
    status: na
  - task: lint_c_src
    status: na
  - task: lint_c_examples
    status: na
  - task: lint_c_benchmarks
    status: na
  - task: lint_c_tests_fixtures
    status: na
  - task: lint_shell
    status: na
  - task: lint_typescript_declarations
    status: passed
  - task: lint_typescript_tests
    status: na
  - task: lint_license_headers
    status: passed
---
---
 .../base/assign-scalar/test/test.1d.js        |  63 ++++++--
 .../base/assign-scalar/test/test.2d.js        | 137 ++++++++++++++----
 2 files changed, 160 insertions(+), 40 deletions(-)

diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/test/test.1d.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/test/test.1d.js
index 1f40d82a6c01..86f6e4408ef2 100644
--- a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/test/test.1d.js
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/test/test.1d.js
@@ -21,6 +21,8 @@
 // MODULES //
 
 var tape = require( 'tape' );
+var isSameAccessorArray = require( '@stdlib/assert/is-same-accessor-array' );
+var isEqualBooleanArray = require( '@stdlib/assert/is-equal-booleanarray' );
 var isSameComplex128Array = require( '@stdlib/assert/is-same-complex128array' );
 var isSameFloat64Array = require( '@stdlib/assert/is-same-float64array' );
 var Complex128Array = require( '@stdlib/array/complex128' );
@@ -46,7 +48,6 @@ tape( 'the function assigns a scalar value to each indexed element of a 1-dimens
 	var expected;
 	var v;
 	var y;
-	var i;
 
 	y = ndarray( 'float64', zeros( 8, 'float64' ), [ 4 ], [ 2 ], 1, 'row-major' );
 
@@ -75,9 +76,13 @@ tape( 'the function assigns a scalar value to each indexed element of a 1-dimens
 	});
 	assignScalar( [ v, y ] );
 
-	for ( i = 0; i < 4; i++ ) {
-		t.strictEqual( y.get( i ), true, 'returns expected value' );
-	}
+	expected = new BooleanArray([
+		true,
+		true,
+		true,
+		true
+	]);
+	t.strictEqual( isEqualBooleanArray( y.data, expected ), true, 'returns expected value' );
 
 	// Complex:
 	y = ndarray( 'complex128', zeros( 8, 'complex128' ), [ 4 ], [ 2 ], 1, 'row-major' );
@@ -142,7 +147,6 @@ tape( 'the function assigns a scalar value to each indexed element of a 1-dimens
 	var expected;
 	var v;
 	var y;
-	var i;
 
 	y = ndarray( 'float64', zeros( 8, 'float64' ), [ 0 ], [ 1 ], 0, 'row-major' );
 
@@ -171,9 +175,17 @@ tape( 'the function assigns a scalar value to each indexed element of a 1-dimens
 	});
 	assignScalar( [ v, y ] );
 
-	for ( i = 0; i < 8; i++ ) {
-		t.strictEqual( y.data.get( i ), false, 'returns expected value' );
-	}
+	expected = new BooleanArray([
+		false,
+		false,
+		false,
+		false,
+		false,
+		false,
+		false,
+		false
+	]);
+	t.strictEqual( isEqualBooleanArray( y.data, expected ), true, 'returns expected value' );
 
 	// Real-to-complex:
 	y = ndarray( 'complex128', zeros( 8, 'complex128' ), [ 0 ], [ 1 ], 0, 'row-major' );
@@ -183,16 +195,33 @@ tape( 'the function assigns a scalar value to each indexed element of a 1-dimens
 	});
 	assignScalar( [ v, y ] );
 
-	expected = new Complex128Array( [ 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 ] ); // eslint-disable-line max-len
+	expected = new Complex128Array([
+		0.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0
+	]);
 	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
 
 	t.end();
 });
 
 tape( 'the function assigns a scalar value to each indexed element of a 1-dimensional output ndarray (accessors)', function test( t ) {
+	var expected;
 	var v;
 	var y;
-	var i;
 
 	y = ndarray( 'generic', toAccessorArray( zeros( 8, 'generic' ) ), [ 4 ], [ 2 ], 1, 'row-major' );
 
@@ -201,9 +230,17 @@ tape( 'the function assigns a scalar value to each indexed element of a 1-dimens
 	});
 	assignScalar( [ v, y ] );
 
-	for ( i = 0; i < 4; i++ ) {
-		t.strictEqual( y.get( i ), 10.0, 'returns expected value' );
-	}
+	expected = toAccessorArray([
+		0.0,
+		10.0,
+		0.0,
+		10.0,
+		0.0,
+		10.0,
+		0.0,
+		10.0
+	]);
+	t.strictEqual( isSameAccessorArray( y.data, expected ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/test/test.2d.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/test/test.2d.js
index cd6752175cb9..4e571857978d 100644
--- a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/test/test.2d.js
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/test/test.2d.js
@@ -23,6 +23,8 @@
 // MODULES //
 
 var tape = require( 'tape' );
+var isSameAccessorArray = require( '@stdlib/assert/is-same-accessor-array' );
+var isEqualBooleanArray = require( '@stdlib/assert/is-equal-booleanarray' );
 var isSameComplex128Array = require( '@stdlib/assert/is-same-complex128array' );
 var isSameFloat64Array = require( '@stdlib/assert/is-same-float64array' );
 var Complex128Array = require( '@stdlib/array/complex128' );
@@ -58,7 +60,6 @@ tape( 'the function assigns a scalar value to each indexed element of a 2-dimens
 	var o;
 	var v;
 	var y;
-	var i;
 
 	dt = 'float64';
 	ord = 'row-major';
@@ -89,9 +90,13 @@ tape( 'the function assigns a scalar value to each indexed element of a 2-dimens
 	});
 	assignScalar( [ v, y ] );
 
-	for ( i = 0; i < numel( sh ); i++ ) {
-		t.strictEqual( y.data.get( i ), true, 'returns expected value' );
-	}
+	expected = new BooleanArray([
+		true,
+		true,
+		true,
+		true
+	]);
+	t.strictEqual( isEqualBooleanArray( y.data, expected ), true, 'returns expected value' );
 
 	// Complex:
 	y = ndarray( 'complex128', zeros( numel( sh ), 'complex128' ), sh, st, o, ord );
@@ -101,7 +106,16 @@ tape( 'the function assigns a scalar value to each indexed element of a 2-dimens
 	});
 	assignScalar( [ v, y ] );
 
-	expected = new Complex128Array( [ 5.0, 6.0, 5.0, 6.0, 5.0, 6.0, 5.0, 6.0 ] );
+	expected = new Complex128Array([
+		5.0,
+		6.0,
+		5.0,
+		6.0,
+		5.0,
+		6.0,
+		5.0,
+		6.0
+	]);
 	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
 
 	// Real-to-complex:
@@ -112,20 +126,29 @@ tape( 'the function assigns a scalar value to each indexed element of a 2-dimens
 	});
 	assignScalar( [ v, y ] );
 
-	expected = new Complex128Array( [ 5.0, 0.0, 5.0, 0.0, 5.0, 0.0, 5.0, 0.0 ] );
+	expected = new Complex128Array([
+		5.0,
+		0.0,
+		5.0,
+		0.0,
+		5.0,
+		0.0,
+		5.0,
+		0.0
+	]);
 	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
 
 	t.end();
 });
 
 tape( 'the function assigns a scalar value to each indexed element of a 2-dimensional output ndarray (row-major, singleton dimensions, accessors)', function test( t ) {
+	var expected;
 	var ord;
 	var sh;
 	var st;
 	var o;
 	var v;
 	var y;
-	var i;
 
 	ord = 'row-major';
 	sh = [ 4, 1 ];
@@ -139,9 +162,13 @@ tape( 'the function assigns a scalar value to each indexed element of a 2-dimens
 	});
 	assignScalar( [ v, y ] );
 
-	for ( i = 0; i < numel( sh ); i++ ) {
-		t.strictEqual( y.iget( i ), 10.0, 'returns expected value' );
-	}
+	expected = toAccessorArray([
+		10.0,
+		10.0,
+		10.0,
+		10.0
+	]);
+	t.strictEqual( isSameAccessorArray( y.data, expected ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -150,7 +177,6 @@ tape( 'the function assigns a scalar value to each indexed element of a 2-dimens
 	var expected;
 	var v;
 	var y;
-	var i;
 
 	y = ndarray( 'float64', zeros( 4, 'float64' ), [ 0, 0 ], [ 1, 1 ], 0, 'row-major' );
 
@@ -175,9 +201,13 @@ tape( 'the function assigns a scalar value to each indexed element of a 2-dimens
 	});
 	assignScalar( [ v, y ] );
 
-	for ( i = 0; i < 4; i++ ) {
-		t.strictEqual( y.data.get( i ), false, 'returns expected value' );
-	}
+	expected = new BooleanArray([
+		false,
+		false,
+		false,
+		false
+	]);
+	t.strictEqual( isEqualBooleanArray( y.data, expected ), true, 'returns expected value' );
 
 	// Complex:
 	y = ndarray( 'complex128', zeros( 4, 'complex128' ), [ 0, 0 ], [ 1, 1 ], 0, 'row-major' );
@@ -187,7 +217,16 @@ tape( 'the function assigns a scalar value to each indexed element of a 2-dimens
 	});
 	assignScalar( [ v, y ] );
 
-	expected = new Complex128Array( [ 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 ] );
+	expected = new Complex128Array([
+		0.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0
+	]);
 	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
 
 	// Real-to-complex:
@@ -213,7 +252,6 @@ tape( 'the function assigns a scalar value to each indexed element of a 2-dimens
 	var o;
 	var v;
 	var y;
-	var i;
 
 	dt = 'float64';
 	ord = 'row-major';
@@ -244,9 +282,13 @@ tape( 'the function assigns a scalar value to each indexed element of a 2-dimens
 	});
 	assignScalar( [ v, y ] );
 
-	for ( i = 0; i < numel( sh ); i++ ) {
-		t.strictEqual( y.data.get( i ), true, 'returns expected value' );
-	}
+	expected = new BooleanArray([
+		true,
+		true,
+		true,
+		true
+	]);
+	t.strictEqual( isEqualBooleanArray( y.data, expected ), true, 'returns expected value' );
 
 	// Complex:
 	y = ndarray( 'complex128', zeros( numel( sh ), 'complex128' ), sh, st, o, ord );
@@ -256,7 +298,16 @@ tape( 'the function assigns a scalar value to each indexed element of a 2-dimens
 	});
 	assignScalar( [ v, y ] );
 
-	expected = new Complex128Array( [ 5.0, 6.0, 5.0, 6.0, 5.0, 6.0, 5.0, 6.0 ] );
+	expected = new Complex128Array([
+		5.0,
+		6.0,
+		5.0,
+		6.0,
+		5.0,
+		6.0,
+		5.0,
+		6.0
+	]);
 	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
 
 	// Real-to-complex:
@@ -267,7 +318,16 @@ tape( 'the function assigns a scalar value to each indexed element of a 2-dimens
 	});
 	assignScalar( [ v, y ] );
 
-	expected = new Complex128Array( [ 5.0, 0.0, 5.0, 0.0, 5.0, 0.0, 5.0, 0.0 ] );
+	expected = new Complex128Array([
+		5.0,
+		0.0,
+		5.0,
+		0.0,
+		5.0,
+		0.0,
+		5.0,
+		0.0
+	]);
 	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
 
 	t.end();
@@ -282,7 +342,6 @@ tape( 'the function assigns a scalar value to each indexed element of a 2-dimens
 	var o;
 	var v;
 	var y;
-	var i;
 
 	dt = 'float64';
 	ord = 'row-major';
@@ -313,9 +372,13 @@ tape( 'the function assigns a scalar value to each indexed element of a 2-dimens
 	});
 	assignScalar( [ v, y ] );
 
-	for ( i = 0; i < numel( sh ); i++ ) {
-		t.strictEqual( y.data.get( i ), true, 'returns expected value' );
-	}
+	expected = new BooleanArray([
+		true,
+		true,
+		true,
+		true
+	]);
+	t.strictEqual( isEqualBooleanArray( y.data, expected ), true, 'returns expected value' );
 
 	// Complex:
 	y = ndarray( 'complex128', zeros( numel( sh ), 'complex128' ), sh, st, o, ord );
@@ -325,7 +388,16 @@ tape( 'the function assigns a scalar value to each indexed element of a 2-dimens
 	});
 	assignScalar( [ v, y ] );
 
-	expected = new Complex128Array( [ 5.0, 6.0, 5.0, 6.0, 5.0, 6.0, 5.0, 6.0 ] );
+	expected = new Complex128Array([
+		5.0,
+		6.0,
+		5.0,
+		6.0,
+		5.0,
+		6.0,
+		5.0,
+		6.0
+	]);
 	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
 
 	// Real-to-complex:
@@ -336,12 +408,23 @@ tape( 'the function assigns a scalar value to each indexed element of a 2-dimens
 	});
 	assignScalar( [ v, y ] );
 
-	expected = new Complex128Array( [ 5.0, 0.0, 5.0, 0.0, 5.0, 0.0, 5.0, 0.0 ] );
+	expected = new Complex128Array([
+		5.0,
+		0.0,
+		5.0,
+		0.0,
+		5.0,
+		0.0,
+		5.0,
+		0.0
+	]);
 	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
 
 	t.end();
 });
 
+// FIXME: starting from here, clean up as done above using `isSame*` and `isEqual*` utilities and avoiding explicit `for` loops and ensure expected values are listed vertically rather than on a single line so that we are consistent for all tests. Furthermore, add explicit complex-complex ndarray tests, not just real-to-complex (see above). For the large array tests, we will likely need to use `zfill` and `gfill` rather than hardcode explicit expected values...
+
 tape( 'the function assigns a scalar value to each indexed element of a 2-dimensional output ndarray (row-major, non-contiguous, same sign strides)', function test( t ) {
 	var expected;
 	var ord;

From 0a6d5df0d9d55dc1041dcb9d221af567d94efe08 Mon Sep 17 00:00:00 2001
From: Athan <kgryte@gmail.com>
Date: Sun, 22 Mar 2026 21:11:59 -0700
Subject: [PATCH 09/20] docs: update comments

---
type: pre_commit_static_analysis_report
description: Results of running static analysis checks when committing changes.
report:
  - task: lint_filenames
    status: passed
  - task: lint_editorconfig
    status: passed
  - task: lint_markdown
    status: na
  - task: lint_package_json
    status: na
  - task: lint_repl_help
    status: na
  - task: lint_javascript_src
    status: passed
  - task: lint_javascript_cli
    status: na
  - task: lint_javascript_examples
    status: na
  - task: lint_javascript_tests
    status: na
  - task: lint_javascript_benchmarks
    status: na
  - task: lint_python
    status: na
  - task: lint_r
    status: na
  - task: lint_c_src
    status: na
  - task: lint_c_examples
    status: na
  - task: lint_c_benchmarks
    status: na
  - task: lint_c_tests_fixtures
    status: na
  - task: lint_shell
    status: na
  - task: lint_typescript_declarations
    status: passed
  - task: lint_typescript_tests
    status: na
  - task: lint_license_headers
    status: passed
---
---
 lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/1d.js   | 2 +-
 .../@stdlib/ndarray/base/assign-scalar/lib/1d_accessors.js      | 2 +-
 .../@stdlib/ndarray/base/assign-scalar/lib/1d_complex.js        | 2 ++
 3 files changed, 4 insertions(+), 2 deletions(-)

diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/1d.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/1d.js
index 0d7ad191b3b4..5d68662055ba 100644
--- a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/1d.js
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/1d.js
@@ -96,7 +96,7 @@ function assign1d( x, y ) {
 	S0 = y.shape[ 0 ];
 	dy0 = y.strides[ 0 ];
 
-	// Set a pointer to the first indexed elements in the output ndarray:
+	// Set a pointer to the first indexed element in the output ndarray:
 	iy = y.offset;
 
 	// Cache a reference to the output ndarray buffer:
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/1d_accessors.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/1d_accessors.js
index c6fa1bd36c80..f72c753f7fdb 100644
--- a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/1d_accessors.js
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/1d_accessors.js
@@ -110,7 +110,7 @@ function assign1d( x, y ) {
 	S0 = y.shape[ 0 ];
 	dy0 = y.strides[ 0 ];
 
-	// Set a pointer to the first indexed elements in the output ndarray:
+	// Set a pointer to the first indexed element in the output ndarray:
 	iy = y.offset;
 
 	// Cache a reference to the output ndarray buffer:
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/1d_complex.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/1d_complex.js
index aa510c29dd6b..60cb9c068d15 100644
--- a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/1d_complex.js
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/1d_complex.js
@@ -73,6 +73,8 @@ function assign1d( re, im, y ) {
 	var iy;
 	var i0;
 
+	// Note on variable naming convention: S#, dy#, i# where # corresponds to the loop number, with `0` being the innermost loop...
+
 	// Extract loop variables: dimensions and loop offset (pointer) increments:
 	S0 = y.shape[ 0 ];
 	dy0 = y.strides[ 0 ];

From 213683fa0997e3a141528d20ec2e227232b90064 Mon Sep 17 00:00:00 2001
From: Athan <kgryte@gmail.com>
Date: Sun, 22 Mar 2026 21:13:23 -0700
Subject: [PATCH 10/20] docs: use consistent punctuation

---
type: pre_commit_static_analysis_report
description: Results of running static analysis checks when committing changes.
report:
  - task: lint_filenames
    status: passed
  - task: lint_editorconfig
    status: passed
  - task: lint_markdown
    status: na
  - task: lint_package_json
    status: na
  - task: lint_repl_help
    status: na
  - task: lint_javascript_src
    status: passed
  - task: lint_javascript_cli
    status: na
  - task: lint_javascript_examples
    status: na
  - task: lint_javascript_tests
    status: na
  - task: lint_javascript_benchmarks
    status: na
  - task: lint_python
    status: na
  - task: lint_r
    status: na
  - task: lint_c_src
    status: na
  - task: lint_c_examples
    status: na
  - task: lint_c_benchmarks
    status: na
  - task: lint_c_tests_fixtures
    status: na
  - task: lint_shell
    status: na
  - task: lint_typescript_declarations
    status: passed
  - task: lint_typescript_tests
    status: na
  - task: lint_license_headers
    status: passed
---
---
 .../@stdlib/ndarray/base/assign-scalar/lib/1d_complex.js        | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/1d_complex.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/1d_complex.js
index 60cb9c068d15..90c2a287793f 100644
--- a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/1d_complex.js
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/1d_complex.js
@@ -75,7 +75,7 @@ function assign1d( re, im, y ) {
 
 	// Note on variable naming convention: S#, dy#, i# where # corresponds to the loop number, with `0` being the innermost loop...
 
-	// Extract loop variables: dimensions and loop offset (pointer) increments:
+	// Extract loop variables: dimensions and loop offset (pointer) increments...
 	S0 = y.shape[ 0 ];
 	dy0 = y.strides[ 0 ];
 

From 383a9071b0a3eba2187e584e55c44b571bf4a7b8 Mon Sep 17 00:00:00 2001
From: Athan <kgryte@gmail.com>
Date: Sun, 22 Mar 2026 21:17:49 -0700
Subject: [PATCH 11/20] docs: update examples

---
type: pre_commit_static_analysis_report
description: Results of running static analysis checks when committing changes.
report:
  - task: lint_filenames
    status: passed
  - task: lint_editorconfig
    status: passed
  - task: lint_markdown
    status: na
  - task: lint_package_json
    status: na
  - task: lint_repl_help
    status: na
  - task: lint_javascript_src
    status: passed
  - task: lint_javascript_cli
    status: na
  - task: lint_javascript_examples
    status: na
  - task: lint_javascript_tests
    status: na
  - task: lint_javascript_benchmarks
    status: na
  - task: lint_python
    status: na
  - task: lint_r
    status: na
  - task: lint_c_src
    status: na
  - task: lint_c_examples
    status: na
  - task: lint_c_benchmarks
    status: na
  - task: lint_c_tests_fixtures
    status: na
  - task: lint_shell
    status: na
  - task: lint_typescript_declarations
    status: passed
  - task: lint_typescript_tests
    status: na
  - task: lint_license_headers
    status: passed
---
---
 .../ndarray/base/assign-scalar/lib/2d_accessors.js     | 10 +---------
 .../base/assign-scalar/lib/2d_blocked_accessors.js     | 10 +---------
 2 files changed, 2 insertions(+), 18 deletions(-)

diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/2d_accessors.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/2d_accessors.js
index af8ffa3ab5b7..011166ee7046 100644
--- a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/2d_accessors.js
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/2d_accessors.js
@@ -45,9 +45,6 @@
 *
 * @example
 * var Complex64Array = require( '@stdlib/array/complex64' );
-* var Complex64 = require( '@stdlib/complex/float32/ctor' );
-* var realf = require( '@stdlib/complex/float32/real' );
-* var imagf = require( '@stdlib/complex/float32/imag' );
 *
 * // Create data buffers:
 * var xbuf = new Complex64Array( [ 2.0, 2.0 ] );
@@ -97,12 +94,7 @@
 * assign2d( x, y, true );
 *
 * var v = y.data.get( 0 );
-*
-* var re = realf( v );
-* // returns 2.0
-*
-* var im = imagf( v );
-* // returns 2.0
+* // returns <Complex64>[ 2.0, 2.0 ]
 */
 function assign2d( x, y, isRowMajor ) {
 	var ybuf;
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/2d_blocked_accessors.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/2d_blocked_accessors.js
index 224c72a5e3b3..e40b3873d2d2 100644
--- a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/2d_blocked_accessors.js
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/2d_blocked_accessors.js
@@ -50,9 +50,6 @@ var blockSize = require( '@stdlib/ndarray/base/nullary-tiling-block-size' );
 *
 * @example
 * var Complex64Array = require( '@stdlib/array/complex64' );
-* var Complex64 = require( '@stdlib/complex/float32/ctor' );
-* var realf = require( '@stdlib/complex/float32/real' );
-* var imagf = require( '@stdlib/complex/float32/imag' );
 *
 * // Create data buffers:
 * var xbuf = new Complex64Array( [ 2.0, 2.0 ] );
@@ -102,12 +99,7 @@ var blockSize = require( '@stdlib/ndarray/base/nullary-tiling-block-size' );
 * blockedassign2d( x, y );
 *
 * var v = y.data.get( 0 );
-*
-* var re = realf( v );
-* // returns 2.0
-*
-* var im = imagf( v );
-* // returns 2.0
+* // returns <Complex64>[ 2.0, 2.0 ]
 */
 function blockedassign2d( x, y ) {
 	var bsize;

From 89829930892418e6db0d821970f117152b92e2a4 Mon Sep 17 00:00:00 2001
From: Athan <kgryte@gmail.com>
Date: Mon, 23 Mar 2026 00:30:34 -0700
Subject: [PATCH 12/20] test: address failing test

---
type: pre_commit_static_analysis_report
description: Results of running static analysis checks when committing changes.
report:
  - task: lint_filenames
    status: passed
  - task: lint_editorconfig
    status: passed
  - task: lint_markdown
    status: na
  - task: lint_package_json
    status: na
  - task: lint_repl_help
    status: na
  - task: lint_javascript_src
    status: na
  - task: lint_javascript_cli
    status: na
  - task: lint_javascript_examples
    status: na
  - task: lint_javascript_tests
    status: passed
  - task: lint_javascript_benchmarks
    status: na
  - task: lint_python
    status: na
  - task: lint_r
    status: na
  - task: lint_c_src
    status: na
  - task: lint_c_examples
    status: na
  - task: lint_c_benchmarks
    status: na
  - task: lint_c_tests_fixtures
    status: na
  - task: lint_shell
    status: na
  - task: lint_typescript_declarations
    status: passed
  - task: lint_typescript_tests
    status: na
  - task: lint_license_headers
    status: passed
---
---
 .../@stdlib/ndarray/base/assign-scalar/test/test.1d.js        | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/test/test.1d.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/test/test.1d.js
index 86f6e4408ef2..ce3245c75ebb 100644
--- a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/test/test.1d.js
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/test/test.1d.js
@@ -77,9 +77,13 @@ tape( 'the function assigns a scalar value to each indexed element of a 1-dimens
 	assignScalar( [ v, y ] );
 
 	expected = new BooleanArray([
+		false,
 		true,
+		false,
 		true,
+		false,
 		true,
+		false,
 		true
 	]);
 	t.strictEqual( isEqualBooleanArray( y.data, expected ), true, 'returns expected value' );

From 99b5754803f059da5156f6e712a8f91b67d47e05 Mon Sep 17 00:00:00 2001
From: Athan <kgryte@gmail.com>
Date: Mon, 23 Mar 2026 00:38:41 -0700
Subject: [PATCH 13/20] chore: clean-up

---
type: pre_commit_static_analysis_report
description: Results of running static analysis checks when committing changes.
report:
  - task: lint_filenames
    status: passed
  - task: lint_editorconfig
    status: passed
  - task: lint_markdown
    status: na
  - task: lint_package_json
    status: na
  - task: lint_repl_help
    status: na
  - task: lint_javascript_src
    status: passed
  - task: lint_javascript_cli
    status: na
  - task: lint_javascript_examples
    status: na
  - task: lint_javascript_tests
    status: na
  - task: lint_javascript_benchmarks
    status: na
  - task: lint_python
    status: na
  - task: lint_r
    status: na
  - task: lint_c_src
    status: na
  - task: lint_c_examples
    status: na
  - task: lint_c_benchmarks
    status: na
  - task: lint_c_tests_fixtures
    status: na
  - task: lint_shell
    status: na
  - task: lint_typescript_declarations
    status: passed
  - task: lint_typescript_tests
    status: na
  - task: lint_license_headers
    status: passed
---
---
 .../@stdlib/ndarray/base/assign-scalar/lib/10d_blocked.js       | 2 +-
 .../ndarray/base/assign-scalar/lib/10d_blocked_accessors.js     | 2 +-
 .../ndarray/base/assign-scalar/lib/10d_blocked_complex.js       | 2 +-
 .../@stdlib/ndarray/base/assign-scalar/lib/10d_complex.js       | 2 +-
 4 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/10d_blocked.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/10d_blocked.js
index df73f46558b3..fe7e9a356bd9 100644
--- a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/10d_blocked.js
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/10d_blocked.js
@@ -159,7 +159,7 @@ function blockedassign10d( x, y ) { // eslint-disable-line max-statements, max-l
 	// Determine the block size:
 	bsize = blockSize( y.dtype );
 
-	// Cache the index of the first indexed elements in the output ndarray:
+	// Cache the index of the first indexed element in the output ndarray:
 	oy = y.offset;
 
 	// Cache a reference to the output ndarray buffer:
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/10d_blocked_accessors.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/10d_blocked_accessors.js
index b37acefa3a7a..37b8f8db5cd4 100644
--- a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/10d_blocked_accessors.js
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/10d_blocked_accessors.js
@@ -173,7 +173,7 @@ function blockedassign10d( x, y ) { // eslint-disable-line max-statements, max-l
 	// Determine the block size:
 	bsize = blockSize( y.dtype );
 
-	// Cache the index of the first indexed elements in the output ndarray:
+	// Cache the index of the first indexed element in the output ndarray:
 	oy = y.offset;
 
 	// Cache a reference to the output ndarray buffer:
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/10d_blocked_complex.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/10d_blocked_complex.js
index 4c9825036b51..48802a99bce1 100644
--- a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/10d_blocked_complex.js
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/10d_blocked_complex.js
@@ -74,7 +74,7 @@ var blockSize = require( '@stdlib/ndarray/base/nullary-tiling-block-size' );
 * console.log( y.data );
 * // => <Float64Array>[ 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0 ]
 */
-function blockedassign10d( re, im, y ) {
+function blockedassign10d( re, im, y ) { // eslint-disable-line max-statements, max-lines-per-function
 	var bsize;
 	var ybuf;
 	var dy0;
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/10d_complex.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/10d_complex.js
index 187171d7847e..4993a5169c68 100644
--- a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/10d_complex.js
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/10d_complex.js
@@ -69,7 +69,7 @@
 * console.log( y.data );
 * // => <Float64Array>[ 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0 ]
 */
-function assign10d( re, im, y, isRowMajor ) {
+function assign10d( re, im, y, isRowMajor ) { // eslint-disable-line max-statements
 	var ybuf;
 	var dy0;
 	var dy1;

From 59e07ca21e76e56c9873b95f69312995e893b189 Mon Sep 17 00:00:00 2001
From: Athan <kgryte@gmail.com>
Date: Mon, 23 Mar 2026 00:39:17 -0700
Subject: [PATCH 14/20] style: disable lint rule

---
type: pre_commit_static_analysis_report
description: Results of running static analysis checks when committing changes.
report:
  - task: lint_filenames
    status: passed
  - task: lint_editorconfig
    status: passed
  - task: lint_markdown
    status: na
  - task: lint_package_json
    status: na
  - task: lint_repl_help
    status: na
  - task: lint_javascript_src
    status: passed
  - task: lint_javascript_cli
    status: na
  - task: lint_javascript_examples
    status: na
  - task: lint_javascript_tests
    status: na
  - task: lint_javascript_benchmarks
    status: na
  - task: lint_python
    status: na
  - task: lint_r
    status: na
  - task: lint_c_src
    status: na
  - task: lint_c_examples
    status: na
  - task: lint_c_benchmarks
    status: na
  - task: lint_c_tests_fixtures
    status: na
  - task: lint_shell
    status: na
  - task: lint_typescript_declarations
    status: passed
  - task: lint_typescript_tests
    status: na
  - task: lint_license_headers
    status: passed
---
---
 .../ndarray/base/assign-scalar/lib/10d_blocked_complex.js       | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/10d_blocked_complex.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/10d_blocked_complex.js
index 48802a99bce1..dc98a5dad0e0 100644
--- a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/10d_blocked_complex.js
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/10d_blocked_complex.js
@@ -16,7 +16,7 @@
 * limitations under the License.
 */
 
-/* eslint-disable max-depth */
+/* eslint-disable max-depth, max-len */
 
 'use strict';
 

From 97e3ec760d73ae55cdfde8c47e0cb8ab4ea63fde Mon Sep 17 00:00:00 2001
From: Athan <kgryte@gmail.com>
Date: Mon, 23 Mar 2026 00:44:25 -0700
Subject: [PATCH 15/20] chore: clean-up

---
type: pre_commit_static_analysis_report
description: Results of running static analysis checks when committing changes.
report:
  - task: lint_filenames
    status: passed
  - task: lint_editorconfig
    status: passed
  - task: lint_markdown
    status: na
  - task: lint_package_json
    status: na
  - task: lint_repl_help
    status: na
  - task: lint_javascript_src
    status: passed
  - task: lint_javascript_cli
    status: na
  - task: lint_javascript_examples
    status: na
  - task: lint_javascript_tests
    status: na
  - task: lint_javascript_benchmarks
    status: na
  - task: lint_python
    status: na
  - task: lint_r
    status: na
  - task: lint_c_src
    status: na
  - task: lint_c_examples
    status: na
  - task: lint_c_benchmarks
    status: na
  - task: lint_c_tests_fixtures
    status: na
  - task: lint_shell
    status: na
  - task: lint_typescript_declarations
    status: passed
  - task: lint_typescript_tests
    status: na
  - task: lint_license_headers
    status: passed
---
---
 .../ndarray/base/assign-scalar/lib/3d_accessors.js     | 10 +---------
 .../base/assign-scalar/lib/3d_blocked_accessors.js     | 10 +---------
 2 files changed, 2 insertions(+), 18 deletions(-)

diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/3d_accessors.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/3d_accessors.js
index b67b5852fb94..02fed9f7a607 100644
--- a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/3d_accessors.js
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/3d_accessors.js
@@ -45,9 +45,6 @@
 *
 * @example
 * var Complex64Array = require( '@stdlib/array/complex64' );
-* var Complex64 = require( '@stdlib/complex/float32/ctor' );
-* var realf = require( '@stdlib/complex/float32/real' );
-* var imagf = require( '@stdlib/complex/float32/imag' );
 *
 * // Create data buffers:
 * var xbuf = new Complex64Array( [ 2.0, 2.0 ] );
@@ -97,12 +94,7 @@
 * assign3d( x, y, true );
 *
 * var v = y.data.get( 0 );
-*
-* var re = realf( v );
-* // returns 2.0
-*
-* var im = imagf( v );
-* // returns 2.0
+* // returns <Complex64>[ 2.0, 2.0 ]
 */
 function assign3d( x, y, isRowMajor ) {
 	var ybuf;
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/3d_blocked_accessors.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/3d_blocked_accessors.js
index 6a5c113079e8..e171cc652a8d 100644
--- a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/3d_blocked_accessors.js
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/3d_blocked_accessors.js
@@ -52,9 +52,6 @@ var blockSize = require( '@stdlib/ndarray/base/nullary-tiling-block-size' );
 *
 * @example
 * var Complex64Array = require( '@stdlib/array/complex64' );
-* var Complex64 = require( '@stdlib/complex/float32/ctor' );
-* var realf = require( '@stdlib/complex/float32/real' );
-* var imagf = require( '@stdlib/complex/float32/imag' );
 *
 * // Create data buffers:
 * var xbuf = new Complex64Array( [ 2.0, 2.0 ] );
@@ -104,12 +101,7 @@ var blockSize = require( '@stdlib/ndarray/base/nullary-tiling-block-size' );
 * blockedassign3d( x, y );
 *
 * var v = y.data.get( 0 );
-*
-* var re = realf( v );
-* // returns 2.0
-*
-* var im = imagf( v );
-* // returns 2.0
+* // returns <Complex64>[ 2.0, 2.0 ]
 */
 function blockedassign3d( x, y ) {
 	var bsize;

From b73405cdf96830c1f5f7559aea520e4d5bd84bca Mon Sep 17 00:00:00 2001
From: Athan <kgryte@gmail.com>
Date: Mon, 23 Mar 2026 00:49:24 -0700
Subject: [PATCH 16/20] chore: clean-up

---
type: pre_commit_static_analysis_report
description: Results of running static analysis checks when committing changes.
report:
  - task: lint_filenames
    status: passed
  - task: lint_editorconfig
    status: passed
  - task: lint_markdown
    status: na
  - task: lint_package_json
    status: na
  - task: lint_repl_help
    status: na
  - task: lint_javascript_src
    status: passed
  - task: lint_javascript_cli
    status: na
  - task: lint_javascript_examples
    status: na
  - task: lint_javascript_tests
    status: na
  - task: lint_javascript_benchmarks
    status: na
  - task: lint_python
    status: na
  - task: lint_r
    status: na
  - task: lint_c_src
    status: na
  - task: lint_c_examples
    status: na
  - task: lint_c_benchmarks
    status: na
  - task: lint_c_tests_fixtures
    status: na
  - task: lint_shell
    status: na
  - task: lint_typescript_declarations
    status: passed
  - task: lint_typescript_tests
    status: na
  - task: lint_license_headers
    status: passed
---
---
 .../ndarray/base/assign-scalar/lib/4d_accessors.js     | 10 +---------
 .../base/assign-scalar/lib/4d_blocked_accessors.js     | 10 +---------
 .../ndarray/base/assign-scalar/lib/5d_accessors.js     | 10 +---------
 .../base/assign-scalar/lib/5d_blocked_accessors.js     | 10 +---------
 .../ndarray/base/assign-scalar/lib/6d_accessors.js     | 10 +---------
 .../base/assign-scalar/lib/6d_blocked_accessors.js     | 10 +---------
 .../ndarray/base/assign-scalar/lib/7d_accessors.js     | 10 +---------
 .../base/assign-scalar/lib/7d_blocked_accessors.js     | 10 +---------
 .../ndarray/base/assign-scalar/lib/8d_accessors.js     | 10 +---------
 .../base/assign-scalar/lib/8d_blocked_accessors.js     | 10 +---------
 .../ndarray/base/assign-scalar/lib/9d_accessors.js     | 10 +---------
 .../base/assign-scalar/lib/9d_blocked_accessors.js     | 10 +---------
 .../ndarray/base/assign-scalar/lib/nd_accessors.js     | 10 +---------
 13 files changed, 13 insertions(+), 117 deletions(-)

diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/4d_accessors.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/4d_accessors.js
index bc17db382768..88beb1d7f2d4 100644
--- a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/4d_accessors.js
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/4d_accessors.js
@@ -45,9 +45,6 @@
 *
 * @example
 * var Complex64Array = require( '@stdlib/array/complex64' );
-* var Complex64 = require( '@stdlib/complex/float32/ctor' );
-* var realf = require( '@stdlib/complex/float32/real' );
-* var imagf = require( '@stdlib/complex/float32/imag' );
 *
 * // Create data buffers:
 * var xbuf = new Complex64Array( [ 2.0, 2.0 ] );
@@ -97,12 +94,7 @@
 * assign4d( x, y, true );
 *
 * var v = y.data.get( 0 );
-*
-* var re = realf( v );
-* // returns 2.0
-*
-* var im = imagf( v );
-* // returns 2.0
+* // returns <Complex64>[ 2.0, 2.0 ]
 */
 function assign4d( x, y, isRowMajor ) {
 	var ybuf;
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/4d_blocked_accessors.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/4d_blocked_accessors.js
index 7d720b8cc71f..99efd8bb50d0 100644
--- a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/4d_blocked_accessors.js
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/4d_blocked_accessors.js
@@ -52,9 +52,6 @@ var blockSize = require( '@stdlib/ndarray/base/nullary-tiling-block-size' );
 *
 * @example
 * var Complex64Array = require( '@stdlib/array/complex64' );
-* var Complex64 = require( '@stdlib/complex/float32/ctor' );
-* var realf = require( '@stdlib/complex/float32/real' );
-* var imagf = require( '@stdlib/complex/float32/imag' );
 *
 * // Create data buffers:
 * var xbuf = new Complex64Array( [ 2.0, 2.0 ] );
@@ -104,12 +101,7 @@ var blockSize = require( '@stdlib/ndarray/base/nullary-tiling-block-size' );
 * blockedassign4d( x, y );
 *
 * var v = y.data.get( 0 );
-*
-* var re = realf( v );
-* // returns 2.0
-*
-* var im = imagf( v );
-* // returns 2.0
+* // returns <Complex64>[ 2.0, 2.0 ]
 */
 function blockedassign4d( x, y ) {
 	var bsize;
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/5d_accessors.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/5d_accessors.js
index 0fb9e5230cd5..99f6e9cc865e 100644
--- a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/5d_accessors.js
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/5d_accessors.js
@@ -45,9 +45,6 @@
 *
 * @example
 * var Complex64Array = require( '@stdlib/array/complex64' );
-* var Complex64 = require( '@stdlib/complex/float32/ctor' );
-* var realf = require( '@stdlib/complex/float32/real' );
-* var imagf = require( '@stdlib/complex/float32/imag' );
 *
 * // Create data buffers:
 * var xbuf = new Complex64Array( [ 2.0, 2.0 ] );
@@ -97,12 +94,7 @@
 * assign5d( x, y, true );
 *
 * var v = y.data.get( 0 );
-*
-* var re = realf( v );
-* // returns 2.0
-*
-* var im = imagf( v );
-* // returns 2.0
+* // returns <Complex64>[ 2.0, 2.0 ]
 */
 function assign5d( x, y, isRowMajor ) {
 	var ybuf;
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/5d_blocked_accessors.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/5d_blocked_accessors.js
index 1b40bb45c0eb..c9eb832851b4 100644
--- a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/5d_blocked_accessors.js
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/5d_blocked_accessors.js
@@ -52,9 +52,6 @@ var blockSize = require( '@stdlib/ndarray/base/nullary-tiling-block-size' );
 *
 * @example
 * var Complex64Array = require( '@stdlib/array/complex64' );
-* var Complex64 = require( '@stdlib/complex/float32/ctor' );
-* var realf = require( '@stdlib/complex/float32/real' );
-* var imagf = require( '@stdlib/complex/float32/imag' );
 *
 * // Create data buffers:
 * var xbuf = new Complex64Array( [ 2.0, 2.0 ] );
@@ -104,12 +101,7 @@ var blockSize = require( '@stdlib/ndarray/base/nullary-tiling-block-size' );
 * blockedassign5d( x, y );
 *
 * var v = y.data.get( 0 );
-*
-* var re = realf( v );
-* // returns 2.0
-*
-* var im = imagf( v );
-* // returns 2.0
+* // returns <Complex64>[ 2.0, 2.0 ]
 */
 function blockedassign5d( x, y ) {
 	var bsize;
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/6d_accessors.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/6d_accessors.js
index 53a00efc569e..98c8f0ebea75 100644
--- a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/6d_accessors.js
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/6d_accessors.js
@@ -47,9 +47,6 @@
 *
 * @example
 * var Complex64Array = require( '@stdlib/array/complex64' );
-* var Complex64 = require( '@stdlib/complex/float32/ctor' );
-* var realf = require( '@stdlib/complex/float32/real' );
-* var imagf = require( '@stdlib/complex/float32/imag' );
 *
 * // Create data buffers:
 * var xbuf = new Complex64Array( [ 2.0, 2.0 ] );
@@ -99,12 +96,7 @@
 * assign6d( x, y, true );
 *
 * var v = y.data.get( 0 );
-*
-* var re = realf( v );
-* // returns 2.0
-*
-* var im = imagf( v );
-* // returns 2.0
+* // returns <Complex64>[ 2.0, 2.0 ]
 */
 function assign6d( x, y, isRowMajor ) {
 	var ybuf;
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/6d_blocked_accessors.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/6d_blocked_accessors.js
index 584f53295299..f7c8e9dc4cfc 100644
--- a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/6d_blocked_accessors.js
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/6d_blocked_accessors.js
@@ -52,9 +52,6 @@ var blockSize = require( '@stdlib/ndarray/base/nullary-tiling-block-size' );
 *
 * @example
 * var Complex64Array = require( '@stdlib/array/complex64' );
-* var Complex64 = require( '@stdlib/complex/float32/ctor' );
-* var realf = require( '@stdlib/complex/float32/real' );
-* var imagf = require( '@stdlib/complex/float32/imag' );
 *
 * // Create data buffers:
 * var xbuf = new Complex64Array( [ 2.0, 2.0 ] );
@@ -104,12 +101,7 @@ var blockSize = require( '@stdlib/ndarray/base/nullary-tiling-block-size' );
 * blockedassign6d( x, y );
 *
 * var v = y.data.get( 0 );
-*
-* var re = realf( v );
-* // returns 2.0
-*
-* var im = imagf( v );
-* // returns 2.0
+* // returns <Complex64>[ 2.0, 2.0 ]
 */
 function blockedassign6d( x, y ) { // eslint-disable-line max-statements
 	var bsize;
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/7d_accessors.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/7d_accessors.js
index 4f1b23290bb2..0b14be74bf2b 100644
--- a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/7d_accessors.js
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/7d_accessors.js
@@ -47,9 +47,6 @@
 *
 * @example
 * var Complex64Array = require( '@stdlib/array/complex64' );
-* var Complex64 = require( '@stdlib/complex/float32/ctor' );
-* var realf = require( '@stdlib/complex/float32/real' );
-* var imagf = require( '@stdlib/complex/float32/imag' );
 *
 * // Create data buffers:
 * var xbuf = new Complex64Array( [ 2.0, 2.0 ] );
@@ -99,12 +96,7 @@
 * assign7d( x, y, true );
 *
 * var v = y.data.get( 0 );
-*
-* var re = realf( v );
-* // returns 2.0
-*
-* var im = imagf( v );
-* // returns 2.0
+* // returns <Complex64>[ 2.0, 2.0 ]
 */
 function assign7d( x, y, isRowMajor ) {
 	var ybuf;
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/7d_blocked_accessors.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/7d_blocked_accessors.js
index d560420517ea..df41693c16c3 100644
--- a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/7d_blocked_accessors.js
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/7d_blocked_accessors.js
@@ -52,9 +52,6 @@ var blockSize = require( '@stdlib/ndarray/base/nullary-tiling-block-size' );
 *
 * @example
 * var Complex64Array = require( '@stdlib/array/complex64' );
-* var Complex64 = require( '@stdlib/complex/float32/ctor' );
-* var realf = require( '@stdlib/complex/float32/real' );
-* var imagf = require( '@stdlib/complex/float32/imag' );
 *
 * // Create data buffers:
 * var xbuf = new Complex64Array( [ 2.0, 2.0 ] );
@@ -104,12 +101,7 @@ var blockSize = require( '@stdlib/ndarray/base/nullary-tiling-block-size' );
 * blockedassign7d( x, y );
 *
 * var v = y.data.get( 0 );
-*
-* var re = realf( v );
-* // returns 2.0
-*
-* var im = imagf( v );
-* // returns 2.0
+* // returns <Complex64>[ 2.0, 2.0 ]
 */
 function blockedassign7d( x, y ) { // eslint-disable-line max-statements
 	var bsize;
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/8d_accessors.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/8d_accessors.js
index 9c589944d4c5..66af34842418 100644
--- a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/8d_accessors.js
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/8d_accessors.js
@@ -47,9 +47,6 @@
 *
 * @example
 * var Complex64Array = require( '@stdlib/array/complex64' );
-* var Complex64 = require( '@stdlib/complex/float32/ctor' );
-* var realf = require( '@stdlib/complex/float32/real' );
-* var imagf = require( '@stdlib/complex/float32/imag' );
 *
 * // Create data buffers:
 * var xbuf = new Complex64Array( [ 2.0, 2.0 ] );
@@ -99,12 +96,7 @@
 * assign8d( x, y, true );
 *
 * var v = y.data.get( 0 );
-*
-* var re = realf( v );
-* // returns 2.0
-*
-* var im = imagf( v );
-* // returns 2.0
+* // returns <Complex64>[ 2.0, 2.0 ]
 */
 function assign8d( x, y, isRowMajor ) {
 	var ybuf;
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/8d_blocked_accessors.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/8d_blocked_accessors.js
index 43aeb6b2fb96..5e01fbc5dd89 100644
--- a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/8d_blocked_accessors.js
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/8d_blocked_accessors.js
@@ -52,9 +52,6 @@ var blockSize = require( '@stdlib/ndarray/base/nullary-tiling-block-size' );
 *
 * @example
 * var Complex64Array = require( '@stdlib/array/complex64' );
-* var Complex64 = require( '@stdlib/complex/float32/ctor' );
-* var realf = require( '@stdlib/complex/float32/real' );
-* var imagf = require( '@stdlib/complex/float32/imag' );
 *
 * // Create data buffers:
 * var xbuf = new Complex64Array( [ 2.0, 2.0 ] );
@@ -104,12 +101,7 @@ var blockSize = require( '@stdlib/ndarray/base/nullary-tiling-block-size' );
 * blockedassign8d( x, y );
 *
 * var v = y.data.get( 0 );
-*
-* var re = realf( v );
-* // returns 2.0
-*
-* var im = imagf( v );
-* // returns 2.0
+* // returns <Complex64>[ 2.0, 2.0 ]
 */
 function blockedassign8d( x, y ) { // eslint-disable-line max-statements
 	var bsize;
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/9d_accessors.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/9d_accessors.js
index cadfe2bd39b0..e99d0830935a 100644
--- a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/9d_accessors.js
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/9d_accessors.js
@@ -47,9 +47,6 @@
 *
 * @example
 * var Complex64Array = require( '@stdlib/array/complex64' );
-* var Complex64 = require( '@stdlib/complex/float32/ctor' );
-* var realf = require( '@stdlib/complex/float32/real' );
-* var imagf = require( '@stdlib/complex/float32/imag' );
 *
 * // Create data buffers:
 * var xbuf = new Complex64Array( [ 2.0, 2.0 ] );
@@ -99,12 +96,7 @@
 * assign9d( x, y, true );
 *
 * var v = y.data.get( 0 );
-*
-* var re = realf( v );
-* // returns 2.0
-*
-* var im = imagf( v );
-* // returns 2.0
+* // returns <Complex64>[ 2.0, 2.0 ]
 */
 function assign9d( x, y, isRowMajor ) {
 	var ybuf;
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/9d_blocked_accessors.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/9d_blocked_accessors.js
index bc0a6505d1ec..63d9a5c40b26 100644
--- a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/9d_blocked_accessors.js
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/9d_blocked_accessors.js
@@ -52,9 +52,6 @@ var blockSize = require( '@stdlib/ndarray/base/nullary-tiling-block-size' );
 *
 * @example
 * var Complex64Array = require( '@stdlib/array/complex64' );
-* var Complex64 = require( '@stdlib/complex/float32/ctor' );
-* var realf = require( '@stdlib/complex/float32/real' );
-* var imagf = require( '@stdlib/complex/float32/imag' );
 *
 * // Create data buffers:
 * var xbuf = new Complex64Array( [ 2.0, 2.0 ] );
@@ -104,12 +101,7 @@ var blockSize = require( '@stdlib/ndarray/base/nullary-tiling-block-size' );
 * blockedassign9d( x, y );
 *
 * var v = y.data.get( 0 );
-*
-* var re = realf( v );
-* // returns 2.0
-*
-* var im = imagf( v );
-* // returns 2.0
+* // returns <Complex64>[ 2.0, 2.0 ]
 */
 function blockedassign9d( x, y ) { // eslint-disable-line max-statements
 	var bsize;
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/nd_accessors.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/nd_accessors.js
index 580ed8546c88..63af769e6615 100644
--- a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/nd_accessors.js
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/nd_accessors.js
@@ -55,9 +55,6 @@ var MODE = 'throw';
 *
 * @example
 * var Complex64Array = require( '@stdlib/array/complex64' );
-* var Complex64 = require( '@stdlib/complex/float32/ctor' );
-* var realf = require( '@stdlib/complex/float32/real' );
-* var imagf = require( '@stdlib/complex/float32/imag' );
 *
 * // Create data buffers:
 * var xbuf = new Complex64Array( [ 2.0, 2.0 ] );
@@ -107,12 +104,7 @@ var MODE = 'throw';
 * assignnd( x, y );
 *
 * var v = y.data.get( 0 );
-*
-* var re = realf( v );
-* // returns 2.0
-*
-* var im = imagf( v );
-* // returns 2.0
+* // returns <Complex64>[ 2.0, 2.0 ]
 */
 function assignnd( x, y ) {
 	var ybuf;

From 57664625900fa75574f7febb1eee27c5cb7904e2 Mon Sep 17 00:00:00 2001
From: Athan <kgryte@gmail.com>
Date: Mon, 23 Mar 2026 00:59:57 -0700
Subject: [PATCH 17/20] style: disable lint rule

---
type: pre_commit_static_analysis_report
description: Results of running static analysis checks when committing changes.
report:
  - task: lint_filenames
    status: passed
  - task: lint_editorconfig
    status: passed
  - task: lint_markdown
    status: na
  - task: lint_package_json
    status: na
  - task: lint_repl_help
    status: na
  - task: lint_javascript_src
    status: passed
  - task: lint_javascript_cli
    status: na
  - task: lint_javascript_examples
    status: na
  - task: lint_javascript_tests
    status: na
  - task: lint_javascript_benchmarks
    status: na
  - task: lint_python
    status: na
  - task: lint_r
    status: na
  - task: lint_c_src
    status: na
  - task: lint_c_examples
    status: na
  - task: lint_c_benchmarks
    status: na
  - task: lint_c_tests_fixtures
    status: na
  - task: lint_shell
    status: na
  - task: lint_typescript_declarations
    status: passed
  - task: lint_typescript_tests
    status: na
  - task: lint_license_headers
    status: passed
---
---
 .../ndarray/base/assign-scalar/lib/6d_blocked_complex.js        | 2 +-
 .../ndarray/base/assign-scalar/lib/7d_blocked_complex.js        | 2 +-
 .../ndarray/base/assign-scalar/lib/8d_blocked_complex.js        | 2 +-
 .../ndarray/base/assign-scalar/lib/9d_blocked_complex.js        | 2 +-
 4 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/6d_blocked_complex.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/6d_blocked_complex.js
index 855e853401aa..24dc36d4da2e 100644
--- a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/6d_blocked_complex.js
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/6d_blocked_complex.js
@@ -74,7 +74,7 @@ var blockSize = require( '@stdlib/ndarray/base/nullary-tiling-block-size' );
 * console.log( y.data );
 * // => <Float64Array>[ 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0 ]
 */
-function blockedassign6d( re, im, y ) {
+function blockedassign6d( re, im, y ) { // eslint-disable-line max-statements
 	var bsize;
 	var ybuf;
 	var dy0;
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/7d_blocked_complex.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/7d_blocked_complex.js
index 370a7143c8bc..d23198ffc298 100644
--- a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/7d_blocked_complex.js
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/7d_blocked_complex.js
@@ -74,7 +74,7 @@ var blockSize = require( '@stdlib/ndarray/base/nullary-tiling-block-size' );
 * console.log( y.data );
 * // => <Float64Array>[ 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0 ]
 */
-function blockedassign7d( re, im, y ) {
+function blockedassign7d( re, im, y ) { // eslint-disable-line max-statements
 	var bsize;
 	var ybuf;
 	var dy0;
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/8d_blocked_complex.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/8d_blocked_complex.js
index d54107cbee7f..a0e500925486 100644
--- a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/8d_blocked_complex.js
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/8d_blocked_complex.js
@@ -74,7 +74,7 @@ var blockSize = require( '@stdlib/ndarray/base/nullary-tiling-block-size' );
 * console.log( y.data );
 * // => <Float64Array>[ 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0 ]
 */
-function blockedassign8d( re, im, y ) {
+function blockedassign8d( re, im, y ) { // eslint-disable-line max-statements
 	var bsize;
 	var ybuf;
 	var dy0;
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/9d_blocked_complex.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/9d_blocked_complex.js
index 95d20f7cedf8..ca5c2ec49051 100644
--- a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/9d_blocked_complex.js
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/9d_blocked_complex.js
@@ -74,7 +74,7 @@ var blockSize = require( '@stdlib/ndarray/base/nullary-tiling-block-size' );
 * console.log( y.data );
 * // => <Float64Array>[ 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0, 2.0 ]
 */
-function blockedassign9d( re, im, y ) {
+function blockedassign9d( re, im, y ) { // eslint-disable-line max-statements
 	var bsize;
 	var ybuf;
 	var dy0;

From fc49689d34e828a44367e0151a099d996592f659 Mon Sep 17 00:00:00 2001
From: Athan <kgryte@gmail.com>
Date: Mon, 23 Mar 2026 01:00:48 -0700
Subject: [PATCH 18/20] style: disable lint rule

---
type: pre_commit_static_analysis_report
description: Results of running static analysis checks when committing changes.
report:
  - task: lint_filenames
    status: passed
  - task: lint_editorconfig
    status: passed
  - task: lint_markdown
    status: na
  - task: lint_package_json
    status: na
  - task: lint_repl_help
    status: na
  - task: lint_javascript_src
    status: passed
  - task: lint_javascript_cli
    status: na
  - task: lint_javascript_examples
    status: na
  - task: lint_javascript_tests
    status: na
  - task: lint_javascript_benchmarks
    status: na
  - task: lint_python
    status: na
  - task: lint_r
    status: na
  - task: lint_c_src
    status: na
  - task: lint_c_examples
    status: na
  - task: lint_c_benchmarks
    status: na
  - task: lint_c_tests_fixtures
    status: na
  - task: lint_shell
    status: na
  - task: lint_typescript_declarations
    status: passed
  - task: lint_typescript_tests
    status: na
  - task: lint_license_headers
    status: passed
---
---
 .../ndarray/base/assign-scalar/lib/7d_blocked_complex.js        | 2 +-
 .../ndarray/base/assign-scalar/lib/8d_blocked_complex.js        | 2 +-
 .../ndarray/base/assign-scalar/lib/9d_blocked_complex.js        | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/7d_blocked_complex.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/7d_blocked_complex.js
index d23198ffc298..857bb490baf0 100644
--- a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/7d_blocked_complex.js
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/7d_blocked_complex.js
@@ -16,7 +16,7 @@
 * limitations under the License.
 */
 
-/* eslint-disable max-depth */
+/* eslint-disable max-depth, max-len */
 
 'use strict';
 
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/8d_blocked_complex.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/8d_blocked_complex.js
index a0e500925486..a2720f687bd3 100644
--- a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/8d_blocked_complex.js
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/8d_blocked_complex.js
@@ -16,7 +16,7 @@
 * limitations under the License.
 */
 
-/* eslint-disable max-depth */
+/* eslint-disable max-depth, max-len */
 
 'use strict';
 
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/9d_blocked_complex.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/9d_blocked_complex.js
index ca5c2ec49051..b4ad377705ed 100644
--- a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/9d_blocked_complex.js
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/9d_blocked_complex.js
@@ -16,7 +16,7 @@
 * limitations under the License.
 */
 
-/* eslint-disable max-depth */
+/* eslint-disable max-depth, max-len */
 
 'use strict';
 

From d9599c880766ad3d14c7c9af05ab5f8acf089c6a Mon Sep 17 00:00:00 2001
From: Athan <kgryte@gmail.com>
Date: Mon, 23 Mar 2026 05:02:19 -0700
Subject: [PATCH 19/20] docs: fix examples

---
type: pre_commit_static_analysis_report
description: Results of running static analysis checks when committing changes.
report:
  - task: lint_filenames
    status: passed
  - task: lint_editorconfig
    status: passed
  - task: lint_markdown
    status: na
  - task: lint_package_json
    status: na
  - task: lint_repl_help
    status: na
  - task: lint_javascript_src
    status: passed
  - task: lint_javascript_cli
    status: na
  - task: lint_javascript_examples
    status: na
  - task: lint_javascript_tests
    status: na
  - task: lint_javascript_benchmarks
    status: na
  - task: lint_python
    status: na
  - task: lint_r
    status: na
  - task: lint_c_src
    status: na
  - task: lint_c_examples
    status: na
  - task: lint_c_benchmarks
    status: na
  - task: lint_c_tests_fixtures
    status: na
  - task: lint_shell
    status: na
  - task: lint_typescript_declarations
    status: passed
  - task: lint_typescript_tests
    status: na
  - task: lint_license_headers
    status: passed
---
---
 lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/10d.js  | 2 +-
 .../@stdlib/ndarray/base/assign-scalar/lib/10d_accessors.js     | 2 +-
 .../@stdlib/ndarray/base/assign-scalar/lib/10d_blocked.js       | 2 +-
 .../ndarray/base/assign-scalar/lib/10d_blocked_accessors.js     | 2 +-
 lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/4d.js   | 2 +-
 .../@stdlib/ndarray/base/assign-scalar/lib/4d_accessors.js      | 2 +-
 .../@stdlib/ndarray/base/assign-scalar/lib/4d_blocked.js        | 2 +-
 .../ndarray/base/assign-scalar/lib/4d_blocked_accessors.js      | 2 +-
 lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/5d.js   | 2 +-
 .../@stdlib/ndarray/base/assign-scalar/lib/5d_accessors.js      | 2 +-
 .../@stdlib/ndarray/base/assign-scalar/lib/5d_blocked.js        | 2 +-
 .../ndarray/base/assign-scalar/lib/5d_blocked_accessors.js      | 2 +-
 lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/6d.js   | 2 +-
 .../@stdlib/ndarray/base/assign-scalar/lib/6d_accessors.js      | 2 +-
 .../@stdlib/ndarray/base/assign-scalar/lib/6d_blocked.js        | 2 +-
 .../ndarray/base/assign-scalar/lib/6d_blocked_accessors.js      | 2 +-
 lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/7d.js   | 2 +-
 .../@stdlib/ndarray/base/assign-scalar/lib/7d_accessors.js      | 2 +-
 .../@stdlib/ndarray/base/assign-scalar/lib/7d_blocked.js        | 2 +-
 .../ndarray/base/assign-scalar/lib/7d_blocked_accessors.js      | 2 +-
 lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/8d.js   | 2 +-
 .../@stdlib/ndarray/base/assign-scalar/lib/8d_accessors.js      | 2 +-
 .../@stdlib/ndarray/base/assign-scalar/lib/8d_blocked.js        | 2 +-
 .../ndarray/base/assign-scalar/lib/8d_blocked_accessors.js      | 2 +-
 lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/9d.js   | 2 +-
 .../@stdlib/ndarray/base/assign-scalar/lib/9d_accessors.js      | 2 +-
 .../@stdlib/ndarray/base/assign-scalar/lib/9d_blocked.js        | 2 +-
 .../ndarray/base/assign-scalar/lib/9d_blocked_accessors.js      | 2 +-
 28 files changed, 28 insertions(+), 28 deletions(-)

diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/10d.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/10d.js
index eadeaef8b659..cdf19d0071af 100644
--- a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/10d.js
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/10d.js
@@ -55,7 +55,7 @@
 *
 * // Define the array strides:
 * var sx = [ 0 ];
-* var sy = [ 2, 2, 2, 2, 2, 2, 2, 2, 2, 1 ];
+* var sy = [ 6, 6, 6, 6, 6, 6, 6, 2, 2, 1 ];
 *
 * // Define the index offsets:
 * var ox = 0;
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/10d_accessors.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/10d_accessors.js
index c82c788b7923..5aeb9aed08e5 100644
--- a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/10d_accessors.js
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/10d_accessors.js
@@ -57,7 +57,7 @@
 *
 * // Define the array strides:
 * var sx = [ 0 ];
-* var sy = [ 2, 2, 2, 2, 2, 2, 2, 2, 2, 1 ];
+* var sy = [ 6, 6, 6, 6, 6, 6, 6, 2, 2, 1 ];
 *
 * // Define the index offsets:
 * var ox = 0;
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/10d_blocked.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/10d_blocked.js
index fe7e9a356bd9..5450361f3cbe 100644
--- a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/10d_blocked.js
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/10d_blocked.js
@@ -60,7 +60,7 @@ var blockSize = require( '@stdlib/ndarray/base/nullary-tiling-block-size' );
 *
 * // Define the array strides:
 * var sx = [ 0 ];
-* var sy = [ 2, 2, 2, 2, 2, 2, 2, 2, 2, 1 ];
+* var sy = [ 6, 6, 6, 6, 6, 6, 6, 2, 2, 1 ];
 *
 * // Define the index offsets:
 * var ox = 0;
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/10d_blocked_accessors.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/10d_blocked_accessors.js
index 37b8f8db5cd4..05bd1c496521 100644
--- a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/10d_blocked_accessors.js
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/10d_blocked_accessors.js
@@ -62,7 +62,7 @@ var blockSize = require( '@stdlib/ndarray/base/nullary-tiling-block-size' );
 *
 * // Define the array strides:
 * var sx = [ 0 ];
-* var sy = [ 2, 2, 2, 2, 2, 2, 2, 2, 2, 1 ];
+* var sy = [ 6, 6, 6, 6, 6, 6, 6, 2, 2, 1 ];
 *
 * // Define the index offsets:
 * var ox = 0;
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/4d.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/4d.js
index bc5fda8e5fbb..bc59edd1c840 100644
--- a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/4d.js
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/4d.js
@@ -53,7 +53,7 @@
 *
 * // Define the array strides:
 * var sx = [ 0 ];
-* var sy = [ 2, 2, 2, 1 ];
+* var sy = [ 6, 2, 2, 1 ];
 *
 * // Define the index offsets:
 * var ox = 0;
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/4d_accessors.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/4d_accessors.js
index 88beb1d7f2d4..854929b3f1cd 100644
--- a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/4d_accessors.js
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/4d_accessors.js
@@ -55,7 +55,7 @@
 *
 * // Define the array strides:
 * var sx = [ 0 ];
-* var sy = [ 2, 2, 2, 1 ];
+* var sy = [ 6, 2, 2, 1 ];
 *
 * // Define the index offsets:
 * var ox = 0;
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/4d_blocked.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/4d_blocked.js
index 767d5327c9d0..628f5632d9d5 100644
--- a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/4d_blocked.js
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/4d_blocked.js
@@ -60,7 +60,7 @@ var blockSize = require( '@stdlib/ndarray/base/nullary-tiling-block-size' );
 *
 * // Define the array strides:
 * var sx = [ 0 ];
-* var sy = [ 2, 2, 2, 1 ];
+* var sy = [ 6, 2, 2, 1 ];
 *
 * // Define the index offsets:
 * var ox = 0;
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/4d_blocked_accessors.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/4d_blocked_accessors.js
index 99efd8bb50d0..3b727bcda062 100644
--- a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/4d_blocked_accessors.js
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/4d_blocked_accessors.js
@@ -62,7 +62,7 @@ var blockSize = require( '@stdlib/ndarray/base/nullary-tiling-block-size' );
 *
 * // Define the array strides:
 * var sx = [ 0 ];
-* var sy = [ 2, 2, 2, 1 ];
+* var sy = [ 6, 2, 2, 1 ];
 *
 * // Define the index offsets:
 * var ox = 0;
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/5d.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/5d.js
index 115ed67584e6..e99779ea21ef 100644
--- a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/5d.js
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/5d.js
@@ -53,7 +53,7 @@
 *
 * // Define the array strides:
 * var sx = [ 0 ];
-* var sy = [ 2, 2, 2, 2, 1 ];
+* var sy = [ 6, 6, 2, 2, 1 ];
 *
 * // Define the index offsets:
 * var ox = 0;
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/5d_accessors.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/5d_accessors.js
index 99f6e9cc865e..65698144261f 100644
--- a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/5d_accessors.js
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/5d_accessors.js
@@ -55,7 +55,7 @@
 *
 * // Define the array strides:
 * var sx = [ 0 ];
-* var sy = [ 2, 2, 2, 2, 1 ];
+* var sy = [ 6, 6, 2, 2, 1 ];
 *
 * // Define the index offsets:
 * var ox = 0;
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/5d_blocked.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/5d_blocked.js
index 810c2e4781e8..88f75eb7bde4 100644
--- a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/5d_blocked.js
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/5d_blocked.js
@@ -60,7 +60,7 @@ var blockSize = require( '@stdlib/ndarray/base/nullary-tiling-block-size' );
 *
 * // Define the array strides:
 * var sx = [ 0 ];
-* var sy = [ 2, 2, 2, 2, 1 ];
+* var sy = [ 6, 6, 2, 2, 1 ];
 *
 * // Define the index offsets:
 * var ox = 0;
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/5d_blocked_accessors.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/5d_blocked_accessors.js
index c9eb832851b4..0478a3c11a1e 100644
--- a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/5d_blocked_accessors.js
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/5d_blocked_accessors.js
@@ -62,7 +62,7 @@ var blockSize = require( '@stdlib/ndarray/base/nullary-tiling-block-size' );
 *
 * // Define the array strides:
 * var sx = [ 0 ];
-* var sy = [ 2, 2, 2, 2, 1 ];
+* var sy = [ 6, 6, 2, 2, 1 ];
 *
 * // Define the index offsets:
 * var ox = 0;
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/6d.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/6d.js
index 5995bbe30a1c..f1e781446d62 100644
--- a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/6d.js
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/6d.js
@@ -55,7 +55,7 @@
 *
 * // Define the array strides:
 * var sx = [ 0 ];
-* var sy = [ 2, 2, 2, 2, 2, 1 ];
+* var sy = [ 6, 6, 6, 2, 2, 1 ];
 *
 * // Define the index offsets:
 * var ox = 0;
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/6d_accessors.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/6d_accessors.js
index 98c8f0ebea75..10a1f73d1147 100644
--- a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/6d_accessors.js
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/6d_accessors.js
@@ -57,7 +57,7 @@
 *
 * // Define the array strides:
 * var sx = [ 0 ];
-* var sy = [ 2, 2, 2, 2, 2, 1 ];
+* var sy = [ 6, 6, 6, 2, 2, 1 ];
 *
 * // Define the index offsets:
 * var ox = 0;
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/6d_blocked.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/6d_blocked.js
index 775f7aac0d77..2b9aa26c1df2 100644
--- a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/6d_blocked.js
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/6d_blocked.js
@@ -60,7 +60,7 @@ var blockSize = require( '@stdlib/ndarray/base/nullary-tiling-block-size' );
 *
 * // Define the array strides:
 * var sx = [ 0 ];
-* var sy = [ 2, 2, 2, 2, 2, 1 ];
+* var sy = [ 6, 6, 6, 2, 2, 1 ];
 *
 * // Define the index offsets:
 * var ox = 0;
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/6d_blocked_accessors.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/6d_blocked_accessors.js
index f7c8e9dc4cfc..aee2a2071037 100644
--- a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/6d_blocked_accessors.js
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/6d_blocked_accessors.js
@@ -62,7 +62,7 @@ var blockSize = require( '@stdlib/ndarray/base/nullary-tiling-block-size' );
 *
 * // Define the array strides:
 * var sx = [ 0 ];
-* var sy = [ 2, 2, 2, 2, 2, 1 ];
+* var sy = [ 6, 6, 6, 2, 2, 1 ];
 *
 * // Define the index offsets:
 * var ox = 0;
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/7d.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/7d.js
index 5191dc0fca33..ed6c1162210a 100644
--- a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/7d.js
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/7d.js
@@ -55,7 +55,7 @@
 *
 * // Define the array strides:
 * var sx = [ 0 ];
-* var sy = [ 2, 2, 2, 2, 2, 2, 1 ];
+* var sy = [ 6, 6, 6, 6, 2, 2, 1 ];
 *
 * // Define the index offsets:
 * var ox = 0;
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/7d_accessors.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/7d_accessors.js
index 0b14be74bf2b..3a5ac49551cc 100644
--- a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/7d_accessors.js
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/7d_accessors.js
@@ -57,7 +57,7 @@
 *
 * // Define the array strides:
 * var sx = [ 0 ];
-* var sy = [ 2, 2, 2, 2, 2, 2, 1 ];
+* var sy = [ 6, 6, 6, 6, 2, 2, 1 ];
 *
 * // Define the index offsets:
 * var ox = 0;
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/7d_blocked.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/7d_blocked.js
index 8ca4ad1b5b4a..d944d96e5d09 100644
--- a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/7d_blocked.js
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/7d_blocked.js
@@ -60,7 +60,7 @@ var blockSize = require( '@stdlib/ndarray/base/nullary-tiling-block-size' );
 *
 * // Define the array strides:
 * var sx = [ 0 ];
-* var sy = [ 2, 2, 2, 2, 2, 2, 1 ];
+* var sy = [ 6, 6, 6, 6, 2, 2, 1 ];
 *
 * // Define the index offsets:
 * var ox = 0;
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/7d_blocked_accessors.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/7d_blocked_accessors.js
index df41693c16c3..f2a7b7cf0ca4 100644
--- a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/7d_blocked_accessors.js
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/7d_blocked_accessors.js
@@ -62,7 +62,7 @@ var blockSize = require( '@stdlib/ndarray/base/nullary-tiling-block-size' );
 *
 * // Define the array strides:
 * var sx = [ 0 ];
-* var sy = [ 2, 2, 2, 2, 2, 2, 1 ];
+* var sy = [ 6, 6, 6, 6, 2, 2, 1 ];
 *
 * // Define the index offsets:
 * var ox = 0;
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/8d.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/8d.js
index 41a0622320ab..b09b65caea4d 100644
--- a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/8d.js
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/8d.js
@@ -55,7 +55,7 @@
 *
 * // Define the array strides:
 * var sx = [ 0 ];
-* var sy = [ 2, 2, 2, 2, 2, 2, 2, 1 ];
+* var sy = [ 6, 6, 6, 6, 6, 2, 2, 1 ];
 *
 * // Define the index offsets:
 * var ox = 0;
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/8d_accessors.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/8d_accessors.js
index 66af34842418..2611a549b8b7 100644
--- a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/8d_accessors.js
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/8d_accessors.js
@@ -57,7 +57,7 @@
 *
 * // Define the array strides:
 * var sx = [ 0 ];
-* var sy = [ 2, 2, 2, 2, 2, 2, 2, 1 ];
+* var sy = [ 6, 6, 6, 6, 6, 2, 2, 1 ];
 *
 * // Define the index offsets:
 * var ox = 0;
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/8d_blocked.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/8d_blocked.js
index ec4ec74d0367..2d64a0362fed 100644
--- a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/8d_blocked.js
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/8d_blocked.js
@@ -60,7 +60,7 @@ var blockSize = require( '@stdlib/ndarray/base/nullary-tiling-block-size' );
 *
 * // Define the array strides:
 * var sx = [ 0 ];
-* var sy = [ 2, 2, 2, 2, 2, 2, 2, 1 ];
+* var sy = [ 6, 6, 6, 6, 6, 2, 2, 1 ];
 *
 * // Define the index offsets:
 * var ox = 0;
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/8d_blocked_accessors.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/8d_blocked_accessors.js
index 5e01fbc5dd89..13605c163fa8 100644
--- a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/8d_blocked_accessors.js
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/8d_blocked_accessors.js
@@ -62,7 +62,7 @@ var blockSize = require( '@stdlib/ndarray/base/nullary-tiling-block-size' );
 *
 * // Define the array strides:
 * var sx = [ 0 ];
-* var sy = [ 2, 2, 2, 2, 2, 2, 2, 1 ];
+* var sy = [ 6, 6, 6, 6, 6, 2, 2, 1 ];
 *
 * // Define the index offsets:
 * var ox = 0;
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/9d.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/9d.js
index 9a6b2ca6cadb..1f3d65e35983 100644
--- a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/9d.js
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/9d.js
@@ -55,7 +55,7 @@
 *
 * // Define the array strides:
 * var sx = [ 0 ];
-* var sy = [ 2, 2, 2, 2, 2, 2, 2, 2, 1 ];
+* var sy = [ 6, 6, 6, 6, 6, 6, 2, 2, 1 ];
 *
 * // Define the index offsets:
 * var ox = 0;
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/9d_accessors.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/9d_accessors.js
index e99d0830935a..b378d846af85 100644
--- a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/9d_accessors.js
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/9d_accessors.js
@@ -57,7 +57,7 @@
 *
 * // Define the array strides:
 * var sx = [ 0 ];
-* var sy = [ 2, 2, 2, 2, 2, 2, 2, 2, 1 ];
+* var sy = [ 6, 6, 6, 6, 6, 6, 2, 2, 1 ];
 *
 * // Define the index offsets:
 * var ox = 0;
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/9d_blocked.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/9d_blocked.js
index 25d3ea2d9a7c..5bef751d2963 100644
--- a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/9d_blocked.js
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/9d_blocked.js
@@ -60,7 +60,7 @@ var blockSize = require( '@stdlib/ndarray/base/nullary-tiling-block-size' );
 *
 * // Define the array strides:
 * var sx = [ 0 ];
-* var sy = [ 2, 2, 2, 2, 2, 2, 2, 2, 1 ];
+* var sy = [ 6, 6, 6, 6, 6, 6, 2, 2, 1 ];
 *
 * // Define the index offsets:
 * var ox = 0;
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/9d_blocked_accessors.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/9d_blocked_accessors.js
index 63d9a5c40b26..2886cb9cf8c4 100644
--- a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/9d_blocked_accessors.js
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/lib/9d_blocked_accessors.js
@@ -62,7 +62,7 @@ var blockSize = require( '@stdlib/ndarray/base/nullary-tiling-block-size' );
 *
 * // Define the array strides:
 * var sx = [ 0 ];
-* var sy = [ 2, 2, 2, 2, 2, 2, 2, 2, 1 ];
+* var sy = [ 6, 6, 6, 6, 6, 6, 2, 2, 1 ];
 *
 * // Define the index offsets:
 * var ox = 0;

From e061bca2397a4c61e36ceb30a7be03e51e29de76 Mon Sep 17 00:00:00 2001
From: Athan <kgryte@gmail.com>
Date: Mon, 23 Mar 2026 14:03:23 -0700
Subject: [PATCH 20/20] chore: clean-up and use accessor function

---
type: pre_commit_static_analysis_report
description: Results of running static analysis checks when committing changes.
report:
  - task: lint_filenames
    status: passed
  - task: lint_editorconfig
    status: passed
  - task: lint_markdown
    status: na
  - task: lint_package_json
    status: na
  - task: lint_repl_help
    status: na
  - task: lint_javascript_src
    status: na
  - task: lint_javascript_cli
    status: na
  - task: lint_javascript_examples
    status: na
  - task: lint_javascript_tests
    status: passed
  - task: lint_javascript_benchmarks
    status: na
  - task: lint_python
    status: na
  - task: lint_r
    status: na
  - task: lint_c_src
    status: na
  - task: lint_c_examples
    status: na
  - task: lint_c_benchmarks
    status: na
  - task: lint_c_tests_fixtures
    status: na
  - task: lint_shell
    status: na
  - task: lint_typescript_declarations
    status: passed
  - task: lint_typescript_tests
    status: na
  - task: lint_license_headers
    status: passed
---
---
 .../base/assign-scalar/test/test.0d.js        |    5 +-
 .../base/assign-scalar/test/test.1d.js        |   17 +-
 .../base/assign-scalar/test/test.2d.js        |  771 ++++++++++---
 .../base/assign-scalar/test/test.3d.js        | 1014 +++++++++++++----
 4 files changed, 1433 insertions(+), 374 deletions(-)

diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/test/test.0d.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/test/test.0d.js
index 85ae397ace70..4f9ec9f8c32e 100644
--- a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/test/test.0d.js
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/test/test.0d.js
@@ -29,6 +29,7 @@ var Complex128Array = require( '@stdlib/array/complex128' );
 var Complex128 = require( '@stdlib/complex/float64/ctor' );
 var scalar2ndarray = require( '@stdlib/ndarray/from-scalar' );
 var ndarray = require( '@stdlib/ndarray/ctor' );
+var getData = require( '@stdlib/ndarray/data-buffer' );
 var assignScalar = require( './../lib' );
 
 
@@ -55,7 +56,7 @@ tape( 'the function assigns a scalar value to each element of a 0-dimensional ou
 	assignScalar( [ v, y ] );
 
 	expected = new Float64Array( [ 10.0 ] );
-	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.strictEqual( isSameFloat64Array( getData( y ), expected ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -89,7 +90,7 @@ tape( 'the function assigns a scalar value to each element of a 0-dimensional ou
 	assignScalar( [ v, y ] );
 
 	expected = new Complex128Array( [ 9.0, 10.0 ] );
-	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.strictEqual( isSameComplex128Array( getData( y ), expected ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/test/test.1d.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/test/test.1d.js
index ce3245c75ebb..4eac466d9a57 100644
--- a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/test/test.1d.js
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/test/test.1d.js
@@ -32,6 +32,7 @@ var toAccessorArray = require( '@stdlib/array/base/to-accessor-array' );
 var zeros = require( '@stdlib/array/zeros' );
 var scalar2ndarray = require( '@stdlib/ndarray/from-scalar' );
 var ndarray = require( '@stdlib/ndarray/ctor' );
+var getData = require( '@stdlib/ndarray/data-buffer' );
 var Complex128 = require( '@stdlib/complex/float64/ctor' );
 var assignScalar = require( './../lib' );
 
@@ -66,7 +67,7 @@ tape( 'the function assigns a scalar value to each indexed element of a 1-dimens
 		0.0,
 		10.0
 	]);
-	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.strictEqual( isSameFloat64Array( getData( y ), expected ), true, 'returns expected value' );
 
 	// Bool:
 	y = ndarray( 'bool', new BooleanArray( 8 ), [ 4 ], [ 2 ], 1, 'row-major' );
@@ -86,7 +87,7 @@ tape( 'the function assigns a scalar value to each indexed element of a 1-dimens
 		false,
 		true
 	]);
-	t.strictEqual( isEqualBooleanArray( y.data, expected ), true, 'returns expected value' );
+	t.strictEqual( isEqualBooleanArray( getData( y ), expected ), true, 'returns expected value' );
 
 	// Complex:
 	y = ndarray( 'complex128', zeros( 8, 'complex128' ), [ 4 ], [ 2 ], 1, 'row-major' );
@@ -114,7 +115,7 @@ tape( 'the function assigns a scalar value to each indexed element of a 1-dimens
 		5.0, // 7
 		6.0
 	]);
-	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.strictEqual( isSameComplex128Array( getData( y ), expected ), true, 'returns expected value' );
 
 	// Real-to-complex:
 	y = ndarray( 'complex128', zeros( 8, 'complex128' ), [ 4 ], [ 2 ], 1, 'row-major' );
@@ -142,7 +143,7 @@ tape( 'the function assigns a scalar value to each indexed element of a 1-dimens
 		5.0, // 7
 		0.0
 	]);
-	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.strictEqual( isSameComplex128Array( getData( y ), expected ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -169,7 +170,7 @@ tape( 'the function assigns a scalar value to each indexed element of a 1-dimens
 		0.0,
 		0.0
 	]);
-	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.strictEqual( isSameFloat64Array( getData( y ), expected ), true, 'returns expected value' );
 
 	// Bool:
 	y = ndarray( 'bool', new BooleanArray( 8 ), [ 0 ], [ 1 ], 0, 'row-major' );
@@ -189,7 +190,7 @@ tape( 'the function assigns a scalar value to each indexed element of a 1-dimens
 		false,
 		false
 	]);
-	t.strictEqual( isEqualBooleanArray( y.data, expected ), true, 'returns expected value' );
+	t.strictEqual( isEqualBooleanArray( getData( y ), expected ), true, 'returns expected value' );
 
 	// Real-to-complex:
 	y = ndarray( 'complex128', zeros( 8, 'complex128' ), [ 0 ], [ 1 ], 0, 'row-major' );
@@ -217,7 +218,7 @@ tape( 'the function assigns a scalar value to each indexed element of a 1-dimens
 		0.0,
 		0.0
 	]);
-	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.strictEqual( isSameComplex128Array( getData( y ), expected ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -244,7 +245,7 @@ tape( 'the function assigns a scalar value to each indexed element of a 1-dimens
 		0.0,
 		10.0
 	]);
-	t.strictEqual( isSameAccessorArray( y.data, expected ), true, 'returns expected value' );
+	t.strictEqual( isSameAccessorArray( getData( y ), expected ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/test/test.2d.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/test/test.2d.js
index 4e571857978d..f4b0908b5fa0 100644
--- a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/test/test.2d.js
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/test/test.2d.js
@@ -34,10 +34,13 @@ var toAccessorArray = require( '@stdlib/array/base/to-accessor-array' );
 var zeros = require( '@stdlib/array/zeros' );
 var scalar2ndarray = require( '@stdlib/ndarray/from-scalar' );
 var ndarray = require( '@stdlib/ndarray/ctor' );
+var getData = require( '@stdlib/ndarray/data-buffer' );
 var shape2strides = require( '@stdlib/ndarray/base/shape2strides' );
 var strides2offset = require( '@stdlib/ndarray/base/strides2offset' );
 var numel = require( '@stdlib/ndarray/base/numel' );
 var dfill = require( '@stdlib/blas/ext/base/dfill' );
+var gfill = require( '@stdlib/blas/ext/base/gfill' );
+var zfill = require( '@stdlib/blas/ext/base/zfill' );
 var blockSize = require( '@stdlib/ndarray/base/nullary-tiling-block-size' );
 var Complex128 = require( '@stdlib/complex/float64/ctor' );
 var assignScalar = require( './../lib' );
@@ -80,7 +83,7 @@ tape( 'the function assigns a scalar value to each indexed element of a 2-dimens
 		10.0,
 		10.0
 	]);
-	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.strictEqual( isSameFloat64Array( getData( y ), expected ), true, 'returns expected value' );
 
 	// Bool:
 	y = ndarray( 'bool', new BooleanArray( numel( sh ) ), sh, st, o, ord );
@@ -96,7 +99,7 @@ tape( 'the function assigns a scalar value to each indexed element of a 2-dimens
 		true,
 		true
 	]);
-	t.strictEqual( isEqualBooleanArray( y.data, expected ), true, 'returns expected value' );
+	t.strictEqual( isEqualBooleanArray( getData( y ), expected ), true, 'returns expected value' );
 
 	// Complex:
 	y = ndarray( 'complex128', zeros( numel( sh ), 'complex128' ), sh, st, o, ord );
@@ -116,7 +119,7 @@ tape( 'the function assigns a scalar value to each indexed element of a 2-dimens
 		5.0,
 		6.0
 	]);
-	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.strictEqual( isSameComplex128Array( getData( y ), expected ), true, 'returns expected value' );
 
 	// Real-to-complex:
 	y = ndarray( 'complex128', zeros( numel( sh ), 'complex128' ), sh, st, o, ord );
@@ -136,7 +139,7 @@ tape( 'the function assigns a scalar value to each indexed element of a 2-dimens
 		5.0,
 		0.0
 	]);
-	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.strictEqual( isSameComplex128Array( getData( y ), expected ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -168,7 +171,7 @@ tape( 'the function assigns a scalar value to each indexed element of a 2-dimens
 		10.0,
 		10.0
 	]);
-	t.strictEqual( isSameAccessorArray( y.data, expected ), true, 'returns expected value' );
+	t.strictEqual( isSameAccessorArray( getData( y ), expected ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -191,7 +194,7 @@ tape( 'the function assigns a scalar value to each indexed element of a 2-dimens
 		0.0,
 		0.0
 	]);
-	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.strictEqual( isSameFloat64Array( getData( y ), expected ), true, 'returns expected value' );
 
 	// Bool:
 	y = ndarray( 'bool', new BooleanArray( 4 ), [ 0, 0 ], [ 1, 1 ], 0, 'row-major' );
@@ -207,7 +210,7 @@ tape( 'the function assigns a scalar value to each indexed element of a 2-dimens
 		false,
 		false
 	]);
-	t.strictEqual( isEqualBooleanArray( y.data, expected ), true, 'returns expected value' );
+	t.strictEqual( isEqualBooleanArray( getData( y ), expected ), true, 'returns expected value' );
 
 	// Complex:
 	y = ndarray( 'complex128', zeros( 4, 'complex128' ), [ 0, 0 ], [ 1, 1 ], 0, 'row-major' );
@@ -227,7 +230,7 @@ tape( 'the function assigns a scalar value to each indexed element of a 2-dimens
 		0.0,
 		0.0
 	]);
-	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.strictEqual( isSameComplex128Array( getData( y ), expected ), true, 'returns expected value' );
 
 	// Real-to-complex:
 	y = ndarray( 'complex128', zeros( 4, 'complex128' ), [ 0, 0 ], [ 1, 1 ], 0, 'row-major' );
@@ -238,7 +241,7 @@ tape( 'the function assigns a scalar value to each indexed element of a 2-dimens
 	assignScalar( [ v, y ] );
 
 	expected = new Complex128Array( [ 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 ] );
-	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.strictEqual( isSameComplex128Array( getData( y ), expected ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -272,7 +275,7 @@ tape( 'the function assigns a scalar value to each indexed element of a 2-dimens
 		10.0,
 		10.0
 	]);
-	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.strictEqual( isSameFloat64Array( getData( y ), expected ), true, 'returns expected value' );
 
 	// Bool:
 	y = ndarray( 'bool', new BooleanArray( numel( sh ) ), sh, st, o, ord );
@@ -288,7 +291,7 @@ tape( 'the function assigns a scalar value to each indexed element of a 2-dimens
 		true,
 		true
 	]);
-	t.strictEqual( isEqualBooleanArray( y.data, expected ), true, 'returns expected value' );
+	t.strictEqual( isEqualBooleanArray( getData( y ), expected ), true, 'returns expected value' );
 
 	// Complex:
 	y = ndarray( 'complex128', zeros( numel( sh ), 'complex128' ), sh, st, o, ord );
@@ -308,7 +311,7 @@ tape( 'the function assigns a scalar value to each indexed element of a 2-dimens
 		5.0,
 		6.0
 	]);
-	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.strictEqual( isSameComplex128Array( getData( y ), expected ), true, 'returns expected value' );
 
 	// Real-to-complex:
 	y = ndarray( 'complex128', zeros( numel( sh ), 'complex128' ), sh, st, o, ord );
@@ -328,7 +331,7 @@ tape( 'the function assigns a scalar value to each indexed element of a 2-dimens
 		5.0,
 		0.0
 	]);
-	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.strictEqual( isSameComplex128Array( getData( y ), expected ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -362,7 +365,7 @@ tape( 'the function assigns a scalar value to each indexed element of a 2-dimens
 		10.0,
 		10.0
 	]);
-	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.strictEqual( isSameFloat64Array( getData( y ), expected ), true, 'returns expected value' );
 
 	// Bool:
 	y = ndarray( 'bool', new BooleanArray( numel( sh ) ), sh, st, o, ord );
@@ -378,7 +381,7 @@ tape( 'the function assigns a scalar value to each indexed element of a 2-dimens
 		true,
 		true
 	]);
-	t.strictEqual( isEqualBooleanArray( y.data, expected ), true, 'returns expected value' );
+	t.strictEqual( isEqualBooleanArray( getData( y ), expected ), true, 'returns expected value' );
 
 	// Complex:
 	y = ndarray( 'complex128', zeros( numel( sh ), 'complex128' ), sh, st, o, ord );
@@ -398,7 +401,7 @@ tape( 'the function assigns a scalar value to each indexed element of a 2-dimens
 		5.0,
 		6.0
 	]);
-	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.strictEqual( isSameComplex128Array( getData( y ), expected ), true, 'returns expected value' );
 
 	// Real-to-complex:
 	y = ndarray( 'complex128', zeros( numel( sh ), 'complex128' ), sh, st, o, ord );
@@ -418,13 +421,11 @@ tape( 'the function assigns a scalar value to each indexed element of a 2-dimens
 		5.0,
 		0.0
 	]);
-	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	t.strictEqual( isSameComplex128Array( getData( y ), expected ), true, 'returns expected value' );
 
 	t.end();
 });
 
-// FIXME: starting from here, clean up as done above using `isSame*` and `isEqual*` utilities and avoiding explicit `for` loops and ensure expected values are listed vertically rather than on a single line so that we are consistent for all tests. Furthermore, add explicit complex-complex ndarray tests, not just real-to-complex (see above). For the large array tests, we will likely need to use `zfill` and `gfill` rather than hardcode explicit expected values...
-
 tape( 'the function assigns a scalar value to each indexed element of a 2-dimensional output ndarray (row-major, non-contiguous, same sign strides)', function test( t ) {
 	var expected;
 	var ord;
@@ -434,7 +435,6 @@ tape( 'the function assigns a scalar value to each indexed element of a 2-dimens
 	var o;
 	var v;
 	var y;
-	var i;
 
 	dt = 'float64';
 	ord = 'row-major';
@@ -459,7 +459,7 @@ tape( 'the function assigns a scalar value to each indexed element of a 2-dimens
 		0.0,
 		0.0
 	]);
-	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.strictEqual( isSameFloat64Array( getData( y ), expected ), true, 'returns expected value' );
 
 	// Bool:
 	y = ndarray( 'bool', new BooleanArray( 8 ), sh, st, o, ord );
@@ -469,9 +469,45 @@ tape( 'the function assigns a scalar value to each indexed element of a 2-dimens
 	});
 	assignScalar( [ v, y ] );
 
-	for ( i = 0; i < y.length; i++ ) {
-		t.strictEqual( y.iget( i ), true, 'returns expected value' );
-	}
+	expected = new BooleanArray([
+		true,
+		true,
+		false,
+		false,
+		true,
+		true,
+		false,
+		false
+	]);
+	t.strictEqual( isEqualBooleanArray( getData( y ), expected ), true, 'returns expected value' );
+
+	// Complex:
+	y = ndarray( 'complex128', zeros( 8, 'complex128' ), sh, st, o, ord );
+
+	v = scalar2ndarray( new Complex128( 5.0, 6.0 ), {
+		'dtype': 'complex128'
+	});
+	assignScalar( [ v, y ] );
+
+	expected = new Complex128Array([
+		5.0,
+		6.0,
+		5.0,
+		6.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0,
+		5.0,
+		6.0,
+		5.0,
+		6.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0
+	]);
+	t.strictEqual( isSameComplex128Array( getData( y ), expected ), true, 'returns expected value' );
 
 	// Real-to-complex:
 	y = ndarray( 'complex128', zeros( 8, 'complex128' ), sh, st, o, ord );
@@ -481,9 +517,25 @@ tape( 'the function assigns a scalar value to each indexed element of a 2-dimens
 	});
 	assignScalar( [ v, y ] );
 
-	for ( i = 0; i < y.length; i++ ) {
-		t.strictEqual( y.iget( i ).toString(), '5 + 0i', 'returns expected value' );
-	}
+	expected = new Complex128Array([
+		5.0,
+		0.0,
+		5.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0,
+		5.0,
+		0.0,
+		5.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0
+	]);
+	t.strictEqual( isSameComplex128Array( getData( y ), expected ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -497,7 +549,6 @@ tape( 'the function assigns a scalar value to each indexed element of a 2-dimens
 	var o;
 	var v;
 	var y;
-	var i;
 
 	dt = 'float64';
 	ord = 'row-major';
@@ -522,7 +573,7 @@ tape( 'the function assigns a scalar value to each indexed element of a 2-dimens
 		0.0,
 		0.0
 	]);
-	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.strictEqual( isSameFloat64Array( getData( y ), expected ), true, 'returns expected value' );
 
 	// Bool:
 	y = ndarray( 'bool', new BooleanArray( 8 ), sh, st, o, ord );
@@ -532,9 +583,45 @@ tape( 'the function assigns a scalar value to each indexed element of a 2-dimens
 	});
 	assignScalar( [ v, y ] );
 
-	for ( i = 0; i < y.length; i++ ) {
-		t.strictEqual( y.iget( i ), true, 'returns expected value' );
-	}
+	expected = new BooleanArray([
+		true,
+		true,
+		false,
+		false,
+		true,
+		true,
+		false,
+		false
+	]);
+	t.strictEqual( isEqualBooleanArray( getData( y ), expected ), true, 'returns expected value' );
+
+	// Complex:
+	y = ndarray( 'complex128', zeros( 8, 'complex128' ), sh, st, o, ord );
+
+	v = scalar2ndarray( new Complex128( 5.0, 6.0 ), {
+		'dtype': 'complex128'
+	});
+	assignScalar( [ v, y ] );
+
+	expected = new Complex128Array([
+		5.0,
+		6.0,
+		5.0,
+		6.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0,
+		5.0,
+		6.0,
+		5.0,
+		6.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0
+	]);
+	t.strictEqual( isSameComplex128Array( getData( y ), expected ), true, 'returns expected value' );
 
 	// Real-to-complex:
 	y = ndarray( 'complex128', zeros( 8, 'complex128' ), sh, st, o, ord );
@@ -544,9 +631,25 @@ tape( 'the function assigns a scalar value to each indexed element of a 2-dimens
 	});
 	assignScalar( [ v, y ] );
 
-	for ( i = 0; i < y.length; i++ ) {
-		t.strictEqual( y.iget( i ).toString(), '5 + 0i', 'returns expected value' );
-	}
+	expected = new Complex128Array([
+		5.0,
+		0.0,
+		5.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0,
+		5.0,
+		0.0,
+		5.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0
+	]);
+	t.strictEqual( isSameComplex128Array( getData( y ), expected ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -561,7 +664,6 @@ tape( 'the function assigns a scalar value to each indexed element of a 2-dimens
 	var o;
 	var v;
 	var y;
-	var i;
 
 	dt = 'float64';
 	ord = 'row-major';
@@ -581,7 +683,7 @@ tape( 'the function assigns a scalar value to each indexed element of a 2-dimens
 	expected = new Float64Array( y.length*2 );
 	dfill( y.length, 10.0, expected, st[ 1 ] );
 
-	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.strictEqual( isSameFloat64Array( getData( y ), expected ), true, 'returns expected value' );
 
 	// Bool:
 	y = ndarray( 'bool', new BooleanArray( numel( sh )*2 ), sh, st, o, ord );
@@ -591,9 +693,23 @@ tape( 'the function assigns a scalar value to each indexed element of a 2-dimens
 	});
 	assignScalar( [ v, y ] );
 
-	for ( i = 0; i < y.length; i++ ) {
-		t.strictEqual( y.iget( i ), true, 'returns expected value' );
-	}
+	expected = new BooleanArray( numel( sh )*2 );
+	gfill( y.length, true, expected, st[ 1 ] );
+
+	t.strictEqual( isEqualBooleanArray( getData( y ), expected ), true, 'returns expected value' );
+
+	// Complex:
+	y = ndarray( 'complex128', zeros( numel( sh )*2, 'complex128' ), sh, st, o, ord );
+
+	v = scalar2ndarray( new Complex128( 5.0, 6.0 ), {
+		'dtype': 'complex128'
+	});
+	assignScalar( [ v, y ] );
+
+	expected = zeros( numel( sh )*2, 'complex128' );
+	zfill( y.length, new Complex128( 5.0, 6.0 ), expected, st[ 1 ] );
+
+	t.strictEqual( isSameComplex128Array( getData( y ), expected ), true, 'returns expected value' );
 
 	// Real-to-complex:
 	y = ndarray( 'complex128', zeros( numel( sh )*2, 'complex128' ), sh, st, o, ord );
@@ -603,9 +719,10 @@ tape( 'the function assigns a scalar value to each indexed element of a 2-dimens
 	});
 	assignScalar( [ v, y ] );
 
-	for ( i = 0; i < y.length; i++ ) {
-		t.strictEqual( y.iget( i ).toString(), '5 + 0i', 'returns expected value' );
-	}
+	expected = zeros( numel( sh )*2, 'complex128' );
+	zfill( y.length, new Complex128( 5.0, 0.0 ), expected, st[ 1 ] );
+
+	t.strictEqual( isSameComplex128Array( getData( y ), expected ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -620,7 +737,6 @@ tape( 'the function assigns a scalar value to each indexed element of a 2-dimens
 	var o;
 	var v;
 	var y;
-	var i;
 
 	dt = 'float64';
 	ord = 'row-major';
@@ -640,7 +756,7 @@ tape( 'the function assigns a scalar value to each indexed element of a 2-dimens
 	expected = new Float64Array( y.length*2 );
 	dfill( y.length, 10.0, expected, st[ 1 ] );
 
-	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.strictEqual( isSameFloat64Array( getData( y ), expected ), true, 'returns expected value' );
 
 	// Bool:
 	y = ndarray( 'bool', new BooleanArray( numel( sh )*2 ), sh, st, o, ord );
@@ -650,9 +766,23 @@ tape( 'the function assigns a scalar value to each indexed element of a 2-dimens
 	});
 	assignScalar( [ v, y ] );
 
-	for ( i = 0; i < y.length; i++ ) {
-		t.strictEqual( y.iget( i ), true, 'returns expected value' );
-	}
+	expected = new BooleanArray( numel( sh )*2 );
+	gfill( y.length, true, expected, st[ 1 ] );
+
+	t.strictEqual( isEqualBooleanArray( getData( y ), expected ), true, 'returns expected value' );
+
+	// Complex:
+	y = ndarray( 'complex128', zeros( numel( sh )*2, 'complex128' ), sh, st, o, ord );
+
+	v = scalar2ndarray( new Complex128( 5.0, 6.0 ), {
+		'dtype': 'complex128'
+	});
+	assignScalar( [ v, y ] );
+
+	expected = zeros( numel( sh )*2, 'complex128' );
+	zfill( y.length, new Complex128( 5.0, 6.0 ), expected, st[ 1 ] );
+
+	t.strictEqual( isSameComplex128Array( getData( y ), expected ), true, 'returns expected value' );
 
 	// Real-to-complex:
 	y = ndarray( 'complex128', zeros( numel( sh )*2, 'complex128' ), sh, st, o, ord );
@@ -662,21 +792,22 @@ tape( 'the function assigns a scalar value to each indexed element of a 2-dimens
 	});
 	assignScalar( [ v, y ] );
 
-	for ( i = 0; i < y.length; i++ ) {
-		t.strictEqual( y.iget( i ).toString(), '5 + 0i', 'returns expected value' );
-	}
+	expected = zeros( numel( sh )*2, 'complex128' );
+	zfill( y.length, new Complex128( 5.0, 0.0 ), expected, st[ 1 ] );
+
+	t.strictEqual( isSameComplex128Array( getData( y ), expected ), true, 'returns expected value' );
 
 	t.end();
 });
 
 tape( 'the function assigns a scalar value to each indexed element of a 2-dimensional output ndarray (row-major, contiguous, accessors)', function test( t ) {
+	var expected;
 	var ord;
 	var sh;
 	var st;
 	var o;
 	var v;
 	var y;
-	var i;
 
 	ord = 'row-major';
 	sh = [ 2, 2 ];
@@ -690,21 +821,25 @@ tape( 'the function assigns a scalar value to each indexed element of a 2-dimens
 	});
 	assignScalar( [ v, y ] );
 
-	for ( i = 0; i < numel( sh ); i++ ) {
-		t.strictEqual( y.iget( i ), 10.0, 'returns expected value' );
-	}
+	expected = toAccessorArray([
+		10.0,
+		10.0,
+		10.0,
+		10.0
+	]);
+	t.strictEqual( isSameAccessorArray( getData( y ), expected ), true, 'returns expected value' );
 
 	t.end();
 });
 
 tape( 'the function assigns a scalar value to each indexed element of a 2-dimensional output ndarray (row-major, contiguous, negative strides, accessors)', function test( t ) {
+	var expected;
 	var ord;
 	var sh;
 	var st;
 	var o;
 	var v;
 	var y;
-	var i;
 
 	ord = 'row-major';
 	sh = [ 2, 2 ];
@@ -718,21 +853,25 @@ tape( 'the function assigns a scalar value to each indexed element of a 2-dimens
 	});
 	assignScalar( [ v, y ] );
 
-	for ( i = 0; i < numel( sh ); i++ ) {
-		t.strictEqual( y.iget( i ), 10.0, 'returns expected value' );
-	}
+	expected = toAccessorArray([
+		10.0,
+		10.0,
+		10.0,
+		10.0
+	]);
+	t.strictEqual( isSameAccessorArray( getData( y ), expected ), true, 'returns expected value' );
 
 	t.end();
 });
 
 tape( 'the function assigns a scalar value to each indexed element of a 2-dimensional output ndarray (row-major, non-contiguous, same sign strides, accessors)', function test( t ) {
+	var expected;
 	var ord;
 	var sh;
 	var st;
 	var o;
 	var v;
 	var y;
-	var i;
 
 	ord = 'row-major';
 	sh = [ 2, 2 ];
@@ -746,21 +885,29 @@ tape( 'the function assigns a scalar value to each indexed element of a 2-dimens
 	});
 	assignScalar( [ v, y ] );
 
-	for ( i = 0; i < y.length; i++ ) {
-		t.strictEqual( y.iget( i ), 10.0, 'returns expected value' );
-	}
+	expected = toAccessorArray([
+		10.0,
+		10.0,
+		0,
+		0,
+		10.0,
+		10.0,
+		0,
+		0
+	]);
+	t.strictEqual( isSameAccessorArray( getData( y ), expected ), true, 'returns expected value' );
 
 	t.end();
 });
 
 tape( 'the function assigns a scalar value to each indexed element of a 2-dimensional output ndarray (row-major, non-contiguous, mixed sign strides, accessors)', function test( t ) {
+	var expected;
 	var ord;
 	var sh;
 	var st;
 	var o;
 	var v;
 	var y;
-	var i;
 
 	ord = 'row-major';
 	sh = [ 2, 2 ];
@@ -774,14 +921,23 @@ tape( 'the function assigns a scalar value to each indexed element of a 2-dimens
 	});
 	assignScalar( [ v, y ] );
 
-	for ( i = 0; i < y.length; i++ ) {
-		t.strictEqual( y.iget( i ), 10.0, 'returns expected value' );
-	}
+	expected = toAccessorArray([
+		10.0,
+		10.0,
+		0,
+		0,
+		10.0,
+		10.0,
+		0,
+		0
+	]);
+	t.strictEqual( isSameAccessorArray( getData( y ), expected ), true, 'returns expected value' );
 
 	t.end();
 });
 
 tape( 'the function assigns a scalar value to each indexed element of a 2-dimensional output ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var expected;
 	var bsize;
 	var ord;
 	var sh;
@@ -789,7 +945,6 @@ tape( 'the function assigns a scalar value to each indexed element of a 2-dimens
 	var o;
 	var v;
 	var y;
-	var i;
 
 	ord = 'row-major';
 
@@ -805,14 +960,16 @@ tape( 'the function assigns a scalar value to each indexed element of a 2-dimens
 	});
 	assignScalar( [ v, y ] );
 
-	for ( i = 0; i < y.length; i++ ) {
-		t.strictEqual( y.iget( i ), 10.0, 'returns expected value' );
-	}
+	expected = toAccessorArray( zeros( numel( sh )*2, 'generic' ) );
+	gfill( y.length, 10.0, expected, st[ 1 ] );
+
+	t.strictEqual( isSameAccessorArray( getData( y ), expected ), true, 'returns expected value' );
 
 	t.end();
 });
 
 tape( 'the function assigns a scalar value to each indexed element of a 2-dimensional output ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var expected;
 	var bsize;
 	var ord;
 	var sh;
@@ -820,7 +977,6 @@ tape( 'the function assigns a scalar value to each indexed element of a 2-dimens
 	var o;
 	var v;
 	var y;
-	var i;
 
 	ord = 'row-major';
 
@@ -836,9 +992,10 @@ tape( 'the function assigns a scalar value to each indexed element of a 2-dimens
 	});
 	assignScalar( [ v, y ] );
 
-	for ( i = 0; i < y.length; i++ ) {
-		t.strictEqual( y.iget( i ), 10.0, 'returns expected value' );
-	}
+	expected = toAccessorArray( zeros( numel( sh )*2, 'generic' ) );
+	gfill( y.length, 10.0, expected, st[ 1 ] );
+
+	t.strictEqual( isSameAccessorArray( getData( y ), expected ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -852,7 +1009,6 @@ tape( 'the function assigns a scalar value to each indexed element of a 2-dimens
 	var o;
 	var v;
 	var y;
-	var i;
 
 	dt = 'float64';
 	ord = 'column-major';
@@ -873,7 +1029,7 @@ tape( 'the function assigns a scalar value to each indexed element of a 2-dimens
 		10.0,
 		10.0
 	]);
-	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.strictEqual( isSameFloat64Array( getData( y ), expected ), true, 'returns expected value' );
 
 	// Bool:
 	y = ndarray( 'bool', new BooleanArray( numel( sh ) ), sh, st, o, ord );
@@ -883,9 +1039,33 @@ tape( 'the function assigns a scalar value to each indexed element of a 2-dimens
 	});
 	assignScalar( [ v, y ] );
 
-	for ( i = 0; i < numel( sh ); i++ ) {
-		t.strictEqual( y.data.get( i ), true, 'returns expected value' );
-	}
+	expected = new BooleanArray([
+		true,
+		true,
+		true,
+		true
+	]);
+	t.strictEqual( isEqualBooleanArray( getData( y ), expected ), true, 'returns expected value' );
+
+	// Complex:
+	y = ndarray( 'complex128', zeros( numel( sh ), 'complex128' ), sh, st, o, ord );
+
+	v = scalar2ndarray( new Complex128( 5.0, 6.0 ), {
+		'dtype': 'complex128'
+	});
+	assignScalar( [ v, y ] );
+
+	expected = new Complex128Array([
+		5.0,
+		6.0,
+		5.0,
+		6.0,
+		5.0,
+		6.0,
+		5.0,
+		6.0
+	]);
+	t.strictEqual( isSameComplex128Array( getData( y ), expected ), true, 'returns expected value' );
 
 	// Real-to-complex:
 	y = ndarray( 'complex128', zeros( numel( sh ), 'complex128' ), sh, st, o, ord );
@@ -895,20 +1075,29 @@ tape( 'the function assigns a scalar value to each indexed element of a 2-dimens
 	});
 	assignScalar( [ v, y ] );
 
-	expected = new Complex128Array( [ 5.0, 0.0, 5.0, 0.0, 5.0, 0.0, 5.0, 0.0 ] );
-	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	expected = new Complex128Array([
+		5.0,
+		0.0,
+		5.0,
+		0.0,
+		5.0,
+		0.0,
+		5.0,
+		0.0
+	]);
+	t.strictEqual( isSameComplex128Array( getData( y ), expected ), true, 'returns expected value' );
 
 	t.end();
 });
 
 tape( 'the function assigns a scalar value to each indexed element of a 2-dimensional output ndarray (column-major, singleton dimensions, accessors)', function test( t ) {
+	var expected;
 	var ord;
 	var sh;
 	var st;
 	var o;
 	var v;
 	var y;
-	var i;
 
 	ord = 'column-major';
 	sh = [ 4, 1 ];
@@ -922,9 +1111,13 @@ tape( 'the function assigns a scalar value to each indexed element of a 2-dimens
 	});
 	assignScalar( [ v, y ] );
 
-	for ( i = 0; i < numel( sh ); i++ ) {
-		t.strictEqual( y.iget( i ), 10.0, 'returns expected value' );
-	}
+	expected = toAccessorArray([
+		10.0,
+		10.0,
+		10.0,
+		10.0
+	]);
+	t.strictEqual( isSameAccessorArray( getData( y ), expected ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -933,7 +1126,6 @@ tape( 'the function assigns a scalar value to each indexed element of a 2-dimens
 	var expected;
 	var v;
 	var y;
-	var i;
 
 	y = ndarray( 'float64', zeros( 4, 'float64' ), [ 0, 0 ], [ 1, 1 ], 0, 'column-major' );
 
@@ -948,7 +1140,7 @@ tape( 'the function assigns a scalar value to each indexed element of a 2-dimens
 		0.0,
 		0.0
 	]);
-	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.strictEqual( isSameFloat64Array( getData( y ), expected ), true, 'returns expected value' );
 
 	// Bool:
 	y = ndarray( 'bool', new BooleanArray( 4 ), [ 0, 0 ], [ 1, 1 ], 0, 'column-major' );
@@ -958,9 +1150,33 @@ tape( 'the function assigns a scalar value to each indexed element of a 2-dimens
 	});
 	assignScalar( [ v, y ] );
 
-	for ( i = 0; i < 4; i++ ) {
-		t.strictEqual( y.data.get( i ), false, 'returns expected value' );
-	}
+	expected = new BooleanArray([
+		false,
+		false,
+		false,
+		false
+	]);
+	t.strictEqual( isEqualBooleanArray( getData( y ), expected ), true, 'returns expected value' );
+
+	// Complex:
+	y = ndarray( 'complex128', zeros( 4, 'complex128' ), [ 0, 0 ], [ 1, 1 ], 0, 'column-major' );
+
+	v = scalar2ndarray( new Complex128( 5.0, 6.0 ), {
+		'dtype': 'complex128'
+	});
+	assignScalar( [ v, y ] );
+
+	expected = new Complex128Array([
+		0.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0
+	]);
+	t.strictEqual( isSameComplex128Array( getData( y ), expected ), true, 'returns expected value' );
 
 	// Real-to-complex:
 	y = ndarray( 'complex128', zeros( 4, 'complex128' ), [ 0, 0 ], [ 1, 1 ], 0, 'column-major' );
@@ -970,8 +1186,17 @@ tape( 'the function assigns a scalar value to each indexed element of a 2-dimens
 	});
 	assignScalar( [ v, y ] );
 
-	expected = new Complex128Array( [ 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 ] );
-	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	expected = new Complex128Array([
+		0.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0
+	]);
+	t.strictEqual( isSameComplex128Array( getData( y ), expected ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -985,7 +1210,6 @@ tape( 'the function assigns a scalar value to each indexed element of a 2-dimens
 	var o;
 	var v;
 	var y;
-	var i;
 
 	dt = 'float64';
 	ord = 'column-major';
@@ -1006,7 +1230,7 @@ tape( 'the function assigns a scalar value to each indexed element of a 2-dimens
 		10.0,
 		10.0
 	]);
-	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.strictEqual( isSameFloat64Array( getData( y ), expected ), true, 'returns expected value' );
 
 	// Bool:
 	y = ndarray( 'bool', new BooleanArray( numel( sh ) ), sh, st, o, ord );
@@ -1016,9 +1240,33 @@ tape( 'the function assigns a scalar value to each indexed element of a 2-dimens
 	});
 	assignScalar( [ v, y ] );
 
-	for ( i = 0; i < numel( sh ); i++ ) {
-		t.strictEqual( y.data.get( i ), true, 'returns expected value' );
-	}
+	expected = new BooleanArray([
+		true,
+		true,
+		true,
+		true
+	]);
+	t.strictEqual( isEqualBooleanArray( getData( y ), expected ), true, 'returns expected value' );
+
+	// Complex:
+	y = ndarray( 'complex128', zeros( numel( sh ), 'complex128' ), sh, st, o, ord );
+
+	v = scalar2ndarray( new Complex128( 5.0, 6.0 ), {
+		'dtype': 'complex128'
+	});
+	assignScalar( [ v, y ] );
+
+	expected = new Complex128Array([
+		5.0,
+		6.0,
+		5.0,
+		6.0,
+		5.0,
+		6.0,
+		5.0,
+		6.0
+	]);
+	t.strictEqual( isSameComplex128Array( getData( y ), expected ), true, 'returns expected value' );
 
 	// Real-to-complex:
 	y = ndarray( 'complex128', zeros( numel( sh ), 'complex128' ), sh, st, o, ord );
@@ -1028,8 +1276,17 @@ tape( 'the function assigns a scalar value to each indexed element of a 2-dimens
 	});
 	assignScalar( [ v, y ] );
 
-	expected = new Complex128Array( [ 5.0, 0.0, 5.0, 0.0, 5.0, 0.0, 5.0, 0.0 ] );
-	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	expected = new Complex128Array([
+		5.0,
+		0.0,
+		5.0,
+		0.0,
+		5.0,
+		0.0,
+		5.0,
+		0.0
+	]);
+	t.strictEqual( isSameComplex128Array( getData( y ), expected ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -1043,7 +1300,6 @@ tape( 'the function assigns a scalar value to each indexed element of a 2-dimens
 	var o;
 	var v;
 	var y;
-	var i;
 
 	dt = 'float64';
 	ord = 'column-major';
@@ -1064,7 +1320,7 @@ tape( 'the function assigns a scalar value to each indexed element of a 2-dimens
 		10.0,
 		10.0
 	]);
-	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.strictEqual( isSameFloat64Array( getData( y ), expected ), true, 'returns expected value' );
 
 	// Bool:
 	y = ndarray( 'bool', new BooleanArray( numel( sh ) ), sh, st, o, ord );
@@ -1074,9 +1330,33 @@ tape( 'the function assigns a scalar value to each indexed element of a 2-dimens
 	});
 	assignScalar( [ v, y ] );
 
-	for ( i = 0; i < numel( sh ); i++ ) {
-		t.strictEqual( y.data.get( i ), true, 'returns expected value' );
-	}
+	expected = new BooleanArray([
+		true,
+		true,
+		true,
+		true
+	]);
+	t.strictEqual( isEqualBooleanArray( getData( y ), expected ), true, 'returns expected value' );
+
+	// Complex:
+	y = ndarray( 'complex128', zeros( numel( sh ), 'complex128' ), sh, st, o, ord );
+
+	v = scalar2ndarray( new Complex128( 5.0, 6.0 ), {
+		'dtype': 'complex128'
+	});
+	assignScalar( [ v, y ] );
+
+	expected = new Complex128Array([
+		5.0,
+		6.0,
+		5.0,
+		6.0,
+		5.0,
+		6.0,
+		5.0,
+		6.0
+	]);
+	t.strictEqual( isSameComplex128Array( getData( y ), expected ), true, 'returns expected value' );
 
 	// Real-to-complex:
 	y = ndarray( 'complex128', zeros( numel( sh ), 'complex128' ), sh, st, o, ord );
@@ -1086,8 +1366,17 @@ tape( 'the function assigns a scalar value to each indexed element of a 2-dimens
 	});
 	assignScalar( [ v, y ] );
 
-	expected = new Complex128Array( [ 5.0, 0.0, 5.0, 0.0, 5.0, 0.0, 5.0, 0.0 ] );
-	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	expected = new Complex128Array([
+		5.0,
+		0.0,
+		5.0,
+		0.0,
+		5.0,
+		0.0,
+		5.0,
+		0.0
+	]);
+	t.strictEqual( isSameComplex128Array( getData( y ), expected ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -1101,7 +1390,6 @@ tape( 'the function assigns a scalar value to each indexed element of a 2-dimens
 	var o;
 	var v;
 	var y;
-	var i;
 
 	dt = 'float64';
 	ord = 'column-major';
@@ -1126,7 +1414,7 @@ tape( 'the function assigns a scalar value to each indexed element of a 2-dimens
 		0.0,
 		0.0
 	]);
-	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.strictEqual( isSameFloat64Array( getData( y ), expected ), true, 'returns expected value' );
 
 	// Bool:
 	y = ndarray( 'bool', new BooleanArray( 8 ), sh, st, o, ord );
@@ -1136,9 +1424,45 @@ tape( 'the function assigns a scalar value to each indexed element of a 2-dimens
 	});
 	assignScalar( [ v, y ] );
 
-	for ( i = 0; i < y.length; i++ ) {
-		t.strictEqual( y.iget( i ), true, 'returns expected value' );
-	}
+	expected = new BooleanArray([
+		true,
+		true,
+		false,
+		false,
+		true,
+		true,
+		false,
+		false
+	]);
+	t.strictEqual( isEqualBooleanArray( getData( y ), expected ), true, 'returns expected value' );
+
+	// Complex:
+	y = ndarray( 'complex128', zeros( 8, 'complex128' ), sh, st, o, ord );
+
+	v = scalar2ndarray( new Complex128( 5.0, 6.0 ), {
+		'dtype': 'complex128'
+	});
+	assignScalar( [ v, y ] );
+
+	expected = new Complex128Array([
+		5.0,
+		6.0,
+		5.0,
+		6.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0,
+		5.0,
+		6.0,
+		5.0,
+		6.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0
+	]);
+	t.strictEqual( isSameComplex128Array( getData( y ), expected ), true, 'returns expected value' );
 
 	// Real-to-complex:
 	y = ndarray( 'complex128', zeros( 8, 'complex128' ), sh, st, o, ord );
@@ -1148,9 +1472,25 @@ tape( 'the function assigns a scalar value to each indexed element of a 2-dimens
 	});
 	assignScalar( [ v, y ] );
 
-	for ( i = 0; i < y.length; i++ ) {
-		t.strictEqual( y.iget( i ).toString(), '5 + 0i', 'returns expected value' );
-	}
+	expected = new Complex128Array([
+		5.0,
+		0.0,
+		5.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0,
+		5.0,
+		0.0,
+		5.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0
+	]);
+	t.strictEqual( isSameComplex128Array( getData( y ), expected ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -1164,7 +1504,6 @@ tape( 'the function assigns a scalar value to each indexed element of a 2-dimens
 	var o;
 	var v;
 	var y;
-	var i;
 
 	dt = 'float64';
 	ord = 'column-major';
@@ -1189,7 +1528,7 @@ tape( 'the function assigns a scalar value to each indexed element of a 2-dimens
 		0.0,
 		0.0
 	]);
-	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.strictEqual( isSameFloat64Array( getData( y ), expected ), true, 'returns expected value' );
 
 	// Bool:
 	y = ndarray( 'bool', new BooleanArray( 8 ), sh, st, o, ord );
@@ -1199,9 +1538,45 @@ tape( 'the function assigns a scalar value to each indexed element of a 2-dimens
 	});
 	assignScalar( [ v, y ] );
 
-	for ( i = 0; i < y.length; i++ ) {
-		t.strictEqual( y.iget( i ), true, 'returns expected value' );
-	}
+	expected = new BooleanArray([
+		true,
+		true,
+		false,
+		false,
+		true,
+		true,
+		false,
+		false
+	]);
+	t.strictEqual( isEqualBooleanArray( getData( y ), expected ), true, 'returns expected value' );
+
+	// Complex:
+	y = ndarray( 'complex128', zeros( 8, 'complex128' ), sh, st, o, ord );
+
+	v = scalar2ndarray( new Complex128( 5.0, 6.0 ), {
+		'dtype': 'complex128'
+	});
+	assignScalar( [ v, y ] );
+
+	expected = new Complex128Array([
+		5.0,
+		6.0,
+		5.0,
+		6.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0,
+		5.0,
+		6.0,
+		5.0,
+		6.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0
+	]);
+	t.strictEqual( isSameComplex128Array( getData( y ), expected ), true, 'returns expected value' );
 
 	// Real-to-complex:
 	y = ndarray( 'complex128', zeros( 8, 'complex128' ), sh, st, o, ord );
@@ -1211,9 +1586,25 @@ tape( 'the function assigns a scalar value to each indexed element of a 2-dimens
 	});
 	assignScalar( [ v, y ] );
 
-	for ( i = 0; i < y.length; i++ ) {
-		t.strictEqual( y.iget( i ).toString(), '5 + 0i', 'returns expected value' );
-	}
+	expected = new Complex128Array([
+		5.0,
+		0.0,
+		5.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0,
+		5.0,
+		0.0,
+		5.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0
+	]);
+	t.strictEqual( isSameComplex128Array( getData( y ), expected ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -1228,7 +1619,6 @@ tape( 'the function assigns a scalar value to each indexed element of a 2-dimens
 	var o;
 	var v;
 	var y;
-	var i;
 
 	dt = 'float64';
 	ord = 'column-major';
@@ -1248,7 +1638,7 @@ tape( 'the function assigns a scalar value to each indexed element of a 2-dimens
 	expected = new Float64Array( y.length*2 );
 	dfill( y.length, 10.0, expected, st[ 0 ] );
 
-	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.strictEqual( isSameFloat64Array( getData( y ), expected ), true, 'returns expected value' );
 
 	// Bool:
 	y = ndarray( 'bool', new BooleanArray( numel( sh )*2 ), sh, st, o, ord );
@@ -1258,9 +1648,23 @@ tape( 'the function assigns a scalar value to each indexed element of a 2-dimens
 	});
 	assignScalar( [ v, y ] );
 
-	for ( i = 0; i < y.length; i++ ) {
-		t.strictEqual( y.iget( i ), true, 'returns expected value' );
-	}
+	expected = new BooleanArray( numel( sh )*2 );
+	gfill( y.length, true, expected, st[ 0 ] );
+
+	t.strictEqual( isEqualBooleanArray( getData( y ), expected ), true, 'returns expected value' );
+
+	// Complex:
+	y = ndarray( 'complex128', zeros( numel( sh )*2, 'complex128' ), sh, st, o, ord );
+
+	v = scalar2ndarray( new Complex128( 5.0, 6.0 ), {
+		'dtype': 'complex128'
+	});
+	assignScalar( [ v, y ] );
+
+	expected = zeros( numel( sh )*2, 'complex128' );
+	zfill( y.length, new Complex128( 5.0, 6.0 ), expected, st[ 0 ] );
+
+	t.strictEqual( isSameComplex128Array( getData( y ), expected ), true, 'returns expected value' );
 
 	// Real-to-complex:
 	y = ndarray( 'complex128', zeros( numel( sh )*2, 'complex128' ), sh, st, o, ord );
@@ -1270,9 +1674,10 @@ tape( 'the function assigns a scalar value to each indexed element of a 2-dimens
 	});
 	assignScalar( [ v, y ] );
 
-	for ( i = 0; i < y.length; i++ ) {
-		t.strictEqual( y.iget( i ).toString(), '5 + 0i', 'returns expected value' );
-	}
+	expected = zeros( numel( sh )*2, 'complex128' );
+	zfill( y.length, new Complex128( 5.0, 0.0 ), expected, st[ 0 ] );
+
+	t.strictEqual( isSameComplex128Array( getData( y ), expected ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -1287,7 +1692,6 @@ tape( 'the function assigns a scalar value to each indexed element of a 2-dimens
 	var o;
 	var v;
 	var y;
-	var i;
 
 	dt = 'float64';
 	ord = 'column-major';
@@ -1307,7 +1711,7 @@ tape( 'the function assigns a scalar value to each indexed element of a 2-dimens
 	expected = new Float64Array( y.length*2 );
 	dfill( y.length, 10.0, expected, st[ 0 ] );
 
-	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.strictEqual( isSameFloat64Array( getData( y ), expected ), true, 'returns expected value' );
 
 	// Bool:
 	y = ndarray( 'bool', new BooleanArray( numel( sh )*2 ), sh, st, o, ord );
@@ -1317,9 +1721,23 @@ tape( 'the function assigns a scalar value to each indexed element of a 2-dimens
 	});
 	assignScalar( [ v, y ] );
 
-	for ( i = 0; i < y.length; i++ ) {
-		t.strictEqual( y.iget( i ), true, 'returns expected value' );
-	}
+	expected = new BooleanArray( numel( sh )*2 );
+	gfill( y.length, true, expected, st[ 0 ] );
+
+	t.strictEqual( isEqualBooleanArray( getData( y ), expected ), true, 'returns expected value' );
+
+	// Complex:
+	y = ndarray( 'complex128', zeros( numel( sh )*2, 'complex128' ), sh, st, o, ord );
+
+	v = scalar2ndarray( new Complex128( 5.0, 6.0 ), {
+		'dtype': 'complex128'
+	});
+	assignScalar( [ v, y ] );
+
+	expected = zeros( numel( sh )*2, 'complex128' );
+	zfill( y.length, new Complex128( 5.0, 6.0 ), expected, st[ 0 ] );
+
+	t.strictEqual( isSameComplex128Array( getData( y ), expected ), true, 'returns expected value' );
 
 	// Real-to-complex:
 	y = ndarray( 'complex128', zeros( numel( sh )*2, 'complex128' ), sh, st, o, ord );
@@ -1329,21 +1747,22 @@ tape( 'the function assigns a scalar value to each indexed element of a 2-dimens
 	});
 	assignScalar( [ v, y ] );
 
-	for ( i = 0; i < y.length; i++ ) {
-		t.strictEqual( y.iget( i ).toString(), '5 + 0i', 'returns expected value' );
-	}
+	expected = zeros( numel( sh )*2, 'complex128' );
+	zfill( y.length, new Complex128( 5.0, 0.0 ), expected, st[ 0 ] );
+
+	t.strictEqual( isSameComplex128Array( getData( y ), expected ), true, 'returns expected value' );
 
 	t.end();
 });
 
 tape( 'the function assigns a scalar value to each indexed element of a 2-dimensional output ndarray (column-major, contiguous, accessors)', function test( t ) {
+	var expected;
 	var ord;
 	var sh;
 	var st;
 	var o;
 	var v;
 	var y;
-	var i;
 
 	ord = 'column-major';
 	sh = [ 2, 2 ];
@@ -1357,21 +1776,25 @@ tape( 'the function assigns a scalar value to each indexed element of a 2-dimens
 	});
 	assignScalar( [ v, y ] );
 
-	for ( i = 0; i < numel( sh ); i++ ) {
-		t.strictEqual( y.iget( i ), 10.0, 'returns expected value' );
-	}
+	expected = toAccessorArray([
+		10.0,
+		10.0,
+		10.0,
+		10.0
+	]);
+	t.strictEqual( isSameAccessorArray( getData( y ), expected ), true, 'returns expected value' );
 
 	t.end();
 });
 
 tape( 'the function assigns a scalar value to each indexed element of a 2-dimensional output ndarray (column-major, contiguous, negative strides, accessors)', function test( t ) {
+	var expected;
 	var ord;
 	var sh;
 	var st;
 	var o;
 	var v;
 	var y;
-	var i;
 
 	ord = 'column-major';
 	sh = [ 2, 2 ];
@@ -1385,21 +1808,25 @@ tape( 'the function assigns a scalar value to each indexed element of a 2-dimens
 	});
 	assignScalar( [ v, y ] );
 
-	for ( i = 0; i < numel( sh ); i++ ) {
-		t.strictEqual( y.iget( i ), 10.0, 'returns expected value' );
-	}
+	expected = toAccessorArray([
+		10.0,
+		10.0,
+		10.0,
+		10.0
+	]);
+	t.strictEqual( isSameAccessorArray( getData( y ), expected ), true, 'returns expected value' );
 
 	t.end();
 });
 
 tape( 'the function assigns a scalar value to each indexed element of a 2-dimensional output ndarray (column-major, non-contiguous, same sign strides, accessors)', function test( t ) {
+	var expected;
 	var ord;
 	var sh;
 	var st;
 	var o;
 	var v;
 	var y;
-	var i;
 
 	ord = 'column-major';
 	sh = [ 2, 2 ];
@@ -1413,21 +1840,29 @@ tape( 'the function assigns a scalar value to each indexed element of a 2-dimens
 	});
 	assignScalar( [ v, y ] );
 
-	for ( i = 0; i < y.length; i++ ) {
-		t.strictEqual( y.iget( i ), 10.0, 'returns expected value' );
-	}
+	expected = toAccessorArray([
+		10.0,
+		10.0,
+		0,
+		0,
+		10.0,
+		10.0,
+		0,
+		0
+	]);
+	t.strictEqual( isSameAccessorArray( getData( y ), expected ), true, 'returns expected value' );
 
 	t.end();
 });
 
 tape( 'the function assigns a scalar value to each indexed element of a 2-dimensional output ndarray (column-major, non-contiguous, mixed sign strides, accessors)', function test( t ) {
+	var expected;
 	var ord;
 	var sh;
 	var st;
 	var o;
 	var v;
 	var y;
-	var i;
 
 	ord = 'column-major';
 	sh = [ 2, 2 ];
@@ -1441,14 +1876,23 @@ tape( 'the function assigns a scalar value to each indexed element of a 2-dimens
 	});
 	assignScalar( [ v, y ] );
 
-	for ( i = 0; i < y.length; i++ ) {
-		t.strictEqual( y.iget( i ), 10.0, 'returns expected value' );
-	}
+	expected = toAccessorArray([
+		10.0,
+		10.0,
+		0,
+		0,
+		10.0,
+		10.0,
+		0,
+		0
+	]);
+	t.strictEqual( isSameAccessorArray( getData( y ), expected ), true, 'returns expected value' );
 
 	t.end();
 });
 
 tape( 'the function assigns a scalar value to each indexed element of a 2-dimensional output ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var expected;
 	var bsize;
 	var ord;
 	var sh;
@@ -1456,7 +1900,6 @@ tape( 'the function assigns a scalar value to each indexed element of a 2-dimens
 	var o;
 	var v;
 	var y;
-	var i;
 
 	ord = 'column-major';
 
@@ -1472,14 +1915,16 @@ tape( 'the function assigns a scalar value to each indexed element of a 2-dimens
 	});
 	assignScalar( [ v, y ] );
 
-	for ( i = 0; i < y.length; i++ ) {
-		t.strictEqual( y.iget( i ), 10.0, 'returns expected value' );
-	}
+	expected = toAccessorArray( zeros( numel( sh )*2, 'generic' ) );
+	gfill( y.length, 10.0, expected, st[ 0 ] );
+
+	t.strictEqual( isSameAccessorArray( getData( y ), expected ), true, 'returns expected value' );
 
 	t.end();
 });
 
 tape( 'the function assigns a scalar value to each indexed element of a 2-dimensional output ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var expected;
 	var bsize;
 	var ord;
 	var sh;
@@ -1487,7 +1932,6 @@ tape( 'the function assigns a scalar value to each indexed element of a 2-dimens
 	var o;
 	var v;
 	var y;
-	var i;
 
 	ord = 'column-major';
 
@@ -1503,9 +1947,10 @@ tape( 'the function assigns a scalar value to each indexed element of a 2-dimens
 	});
 	assignScalar( [ v, y ] );
 
-	for ( i = 0; i < y.length; i++ ) {
-		t.strictEqual( y.iget( i ), 10.0, 'returns expected value' );
-	}
+	expected = toAccessorArray( zeros( numel( sh )*2, 'generic' ) );
+	gfill( y.length, 10.0, expected, st[ 0 ] );
+
+	t.strictEqual( isSameAccessorArray( getData( y ), expected ), true, 'returns expected value' );
 
 	t.end();
 });
diff --git a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/test/test.3d.js b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/test/test.3d.js
index 644b587e206d..dfff7e97f2e6 100644
--- a/lib/node_modules/@stdlib/ndarray/base/assign-scalar/test/test.3d.js
+++ b/lib/node_modules/@stdlib/ndarray/base/assign-scalar/test/test.3d.js
@@ -16,13 +16,15 @@
 * limitations under the License.
 */
 
-/* eslint-disable max-len, max-lines */
+/* eslint-disable max-lines */
 
 'use strict';
 
 // MODULES //
 
 var tape = require( 'tape' );
+var isSameAccessorArray = require( '@stdlib/assert/is-same-accessor-array' );
+var isEqualBooleanArray = require( '@stdlib/assert/is-equal-booleanarray' );
 var isSameComplex128Array = require( '@stdlib/assert/is-same-complex128array' );
 var isSameFloat64Array = require( '@stdlib/assert/is-same-float64array' );
 var Complex128Array = require( '@stdlib/array/complex128' );
@@ -32,11 +34,15 @@ var toAccessorArray = require( '@stdlib/array/base/to-accessor-array' );
 var zeros = require( '@stdlib/array/zeros' );
 var scalar2ndarray = require( '@stdlib/ndarray/from-scalar' );
 var ndarray = require( '@stdlib/ndarray/ctor' );
+var getData = require( '@stdlib/ndarray/data-buffer' );
 var shape2strides = require( '@stdlib/ndarray/base/shape2strides' );
 var strides2offset = require( '@stdlib/ndarray/base/strides2offset' );
 var numel = require( '@stdlib/ndarray/base/numel' );
 var dfill = require( '@stdlib/blas/ext/base/dfill' );
+var gfill = require( '@stdlib/blas/ext/base/gfill' );
+var zfill = require( '@stdlib/blas/ext/base/zfill' );
 var blockSize = require( '@stdlib/ndarray/base/nullary-tiling-block-size' );
+var Complex128 = require( '@stdlib/complex/float64/ctor' );
 var assignScalar = require( './../lib' );
 
 
@@ -57,7 +63,6 @@ tape( 'the function assigns a scalar value to each indexed element of a 3-dimens
 	var o;
 	var v;
 	var y;
-	var i;
 
 	dt = 'float64';
 	ord = 'row-major';
@@ -78,7 +83,7 @@ tape( 'the function assigns a scalar value to each indexed element of a 3-dimens
 		10.0,
 		10.0
 	]);
-	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.strictEqual( isSameFloat64Array( getData( y ), expected ), true, 'returns expected value' );
 
 	// Bool:
 	y = ndarray( 'bool', new BooleanArray( numel( sh ) ), sh, st, o, ord );
@@ -88,9 +93,33 @@ tape( 'the function assigns a scalar value to each indexed element of a 3-dimens
 	});
 	assignScalar( [ v, y ] );
 
-	for ( i = 0; i < numel( sh ); i++ ) {
-		t.strictEqual( y.data.get( i ), true, 'returns expected value' );
-	}
+	expected = new BooleanArray([
+		true,
+		true,
+		true,
+		true
+	]);
+	t.strictEqual( isEqualBooleanArray( getData( y ), expected ), true, 'returns expected value' );
+
+	// Complex:
+	y = ndarray( 'complex128', zeros( numel( sh ), 'complex128' ), sh, st, o, ord );
+
+	v = scalar2ndarray( new Complex128( 5.0, 6.0 ), {
+		'dtype': 'complex128'
+	});
+	assignScalar( [ v, y ] );
+
+	expected = new Complex128Array([
+		5.0,
+		6.0,
+		5.0,
+		6.0,
+		5.0,
+		6.0,
+		5.0,
+		6.0
+	]);
+	t.strictEqual( isSameComplex128Array( getData( y ), expected ), true, 'returns expected value' );
 
 	// Real-to-complex:
 	y = ndarray( 'complex128', zeros( numel( sh ), 'complex128' ), sh, st, o, ord );
@@ -100,20 +129,29 @@ tape( 'the function assigns a scalar value to each indexed element of a 3-dimens
 	});
 	assignScalar( [ v, y ] );
 
-	expected = new Complex128Array( [ 5.0, 0.0, 5.0, 0.0, 5.0, 0.0, 5.0, 0.0 ] );
-	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	expected = new Complex128Array([
+		5.0,
+		0.0,
+		5.0,
+		0.0,
+		5.0,
+		0.0,
+		5.0,
+		0.0
+	]);
+	t.strictEqual( isSameComplex128Array( getData( y ), expected ), true, 'returns expected value' );
 
 	t.end();
 });
 
 tape( 'the function assigns a scalar value to each indexed element of a 3-dimensional output ndarray (row-major, singleton dimensions, accessors)', function test( t ) {
+	var expected;
 	var ord;
 	var sh;
 	var st;
 	var o;
 	var v;
 	var y;
-	var i;
 
 	ord = 'row-major';
 	sh = [ 4, 1, 1 ];
@@ -127,9 +165,13 @@ tape( 'the function assigns a scalar value to each indexed element of a 3-dimens
 	});
 	assignScalar( [ v, y ] );
 
-	for ( i = 0; i < numel( sh ); i++ ) {
-		t.strictEqual( y.iget( i ), 10.0, 'returns expected value' );
-	}
+	expected = toAccessorArray([
+		10.0,
+		10.0,
+		10.0,
+		10.0
+	]);
+	t.strictEqual( isSameAccessorArray( getData( y ), expected ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -138,7 +180,6 @@ tape( 'the function assigns a scalar value to each indexed element of a 3-dimens
 	var expected;
 	var v;
 	var y;
-	var i;
 
 	y = ndarray( 'float64', zeros( 4, 'float64' ), [ 0, 0, 0 ], [ 1, 1, 1 ], 0, 'row-major' );
 
@@ -153,7 +194,7 @@ tape( 'the function assigns a scalar value to each indexed element of a 3-dimens
 		0.0,
 		0.0
 	]);
-	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.strictEqual( isSameFloat64Array( getData( y ), expected ), true, 'returns expected value' );
 
 	// Bool:
 	y = ndarray( 'bool', new BooleanArray( 4 ), [ 0, 0, 0 ], [ 1, 1, 1 ], 0, 'row-major' );
@@ -163,9 +204,33 @@ tape( 'the function assigns a scalar value to each indexed element of a 3-dimens
 	});
 	assignScalar( [ v, y ] );
 
-	for ( i = 0; i < 4; i++ ) {
-		t.strictEqual( y.data.get( i ), false, 'returns expected value' );
-	}
+	expected = new BooleanArray([
+		false,
+		false,
+		false,
+		false
+	]);
+	t.strictEqual( isEqualBooleanArray( getData( y ), expected ), true, 'returns expected value' );
+
+	// Complex:
+	y = ndarray( 'complex128', zeros( 4, 'complex128' ), [ 0, 0, 0 ], [ 1, 1, 1 ], 0, 'row-major' );
+
+	v = scalar2ndarray( new Complex128( 5.0, 6.0 ), {
+		'dtype': 'complex128'
+	});
+	assignScalar( [ v, y ] );
+
+	expected = new Complex128Array([
+		0.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0
+	]);
+	t.strictEqual( isSameComplex128Array( getData( y ), expected ), true, 'returns expected value' );
 
 	// Real-to-complex:
 	y = ndarray( 'complex128', zeros( 4, 'complex128' ), [ 0, 0, 0 ], [ 1, 1, 1 ], 0, 'row-major' );
@@ -175,8 +240,17 @@ tape( 'the function assigns a scalar value to each indexed element of a 3-dimens
 	});
 	assignScalar( [ v, y ] );
 
-	expected = new Complex128Array( [ 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 ] );
-	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	expected = new Complex128Array([
+		0.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0
+	]);
+	t.strictEqual( isSameComplex128Array( getData( y ), expected ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -190,7 +264,6 @@ tape( 'the function assigns a scalar value to each indexed element of a 3-dimens
 	var o;
 	var v;
 	var y;
-	var i;
 
 	dt = 'float64';
 	ord = 'row-major';
@@ -211,7 +284,7 @@ tape( 'the function assigns a scalar value to each indexed element of a 3-dimens
 		10.0,
 		10.0
 	]);
-	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.strictEqual( isSameFloat64Array( getData( y ), expected ), true, 'returns expected value' );
 
 	// Bool:
 	y = ndarray( 'bool', new BooleanArray( numel( sh ) ), sh, st, o, ord );
@@ -221,9 +294,33 @@ tape( 'the function assigns a scalar value to each indexed element of a 3-dimens
 	});
 	assignScalar( [ v, y ] );
 
-	for ( i = 0; i < numel( sh ); i++ ) {
-		t.strictEqual( y.data.get( i ), true, 'returns expected value' );
-	}
+	expected = new BooleanArray([
+		true,
+		true,
+		true,
+		true
+	]);
+	t.strictEqual( isEqualBooleanArray( getData( y ), expected ), true, 'returns expected value' );
+
+	// Complex:
+	y = ndarray( 'complex128', zeros( numel( sh ), 'complex128' ), sh, st, o, ord );
+
+	v = scalar2ndarray( new Complex128( 5.0, 6.0 ), {
+		'dtype': 'complex128'
+	});
+	assignScalar( [ v, y ] );
+
+	expected = new Complex128Array([
+		5.0,
+		6.0,
+		5.0,
+		6.0,
+		5.0,
+		6.0,
+		5.0,
+		6.0
+	]);
+	t.strictEqual( isSameComplex128Array( getData( y ), expected ), true, 'returns expected value' );
 
 	// Real-to-complex:
 	y = ndarray( 'complex128', zeros( numel( sh ), 'complex128' ), sh, st, o, ord );
@@ -233,8 +330,17 @@ tape( 'the function assigns a scalar value to each indexed element of a 3-dimens
 	});
 	assignScalar( [ v, y ] );
 
-	expected = new Complex128Array( [ 5.0, 0.0, 5.0, 0.0, 5.0, 0.0, 5.0, 0.0 ] );
-	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	expected = new Complex128Array([
+		5.0,
+		0.0,
+		5.0,
+		0.0,
+		5.0,
+		0.0,
+		5.0,
+		0.0
+	]);
+	t.strictEqual( isSameComplex128Array( getData( y ), expected ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -248,7 +354,6 @@ tape( 'the function assigns a scalar value to each indexed element of a 3-dimens
 	var o;
 	var v;
 	var y;
-	var i;
 
 	dt = 'float64';
 	ord = 'row-major';
@@ -273,7 +378,7 @@ tape( 'the function assigns a scalar value to each indexed element of a 3-dimens
 		10.0,
 		10.0
 	]);
-	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.strictEqual( isSameFloat64Array( getData( y ), expected ), true, 'returns expected value' );
 
 	// Bool:
 	y = ndarray( 'bool', new BooleanArray( numel( sh ) ), sh, st, o, ord );
@@ -283,9 +388,45 @@ tape( 'the function assigns a scalar value to each indexed element of a 3-dimens
 	});
 	assignScalar( [ v, y ] );
 
-	for ( i = 0; i < numel( sh ); i++ ) {
-		t.strictEqual( y.data.get( i ), true, 'returns expected value' );
-	}
+	expected = new BooleanArray([
+		true,
+		true,
+		true,
+		true,
+		true,
+		true,
+		true,
+		true
+	]);
+	t.strictEqual( isEqualBooleanArray( getData( y ), expected ), true, 'returns expected value' );
+
+	// Complex:
+	y = ndarray( 'complex128', zeros( numel( sh ), 'complex128' ), sh, st, o, ord );
+
+	v = scalar2ndarray( new Complex128( 5.0, 6.0 ), {
+		'dtype': 'complex128'
+	});
+	assignScalar( [ v, y ] );
+
+	expected = new Complex128Array([
+		5.0,
+		6.0,
+		5.0,
+		6.0,
+		5.0,
+		6.0,
+		5.0,
+		6.0,
+		5.0,
+		6.0,
+		5.0,
+		6.0,
+		5.0,
+		6.0,
+		5.0,
+		6.0
+	]);
+	t.strictEqual( isSameComplex128Array( getData( y ), expected ), true, 'returns expected value' );
 
 	// Real-to-complex:
 	y = ndarray( 'complex128', zeros( numel( sh ), 'complex128' ), sh, st, o, ord );
@@ -295,8 +436,25 @@ tape( 'the function assigns a scalar value to each indexed element of a 3-dimens
 	});
 	assignScalar( [ v, y ] );
 
-	expected = new Complex128Array( [ 5.0, 0.0, 5.0, 0.0, 5.0, 0.0, 5.0, 0.0, 5.0, 0.0, 5.0, 0.0, 5.0, 0.0, 5.0, 0.0 ] );
-	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	expected = new Complex128Array([
+		5.0,
+		0.0,
+		5.0,
+		0.0,
+		5.0,
+		0.0,
+		5.0,
+		0.0,
+		5.0,
+		0.0,
+		5.0,
+		0.0,
+		5.0,
+		0.0,
+		5.0,
+		0.0
+	]);
+	t.strictEqual( isSameComplex128Array( getData( y ), expected ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -310,7 +468,6 @@ tape( 'the function assigns a scalar value to each indexed element of a 3-dimens
 	var o;
 	var v;
 	var y;
-	var i;
 
 	dt = 'float64';
 	ord = 'row-major';
@@ -333,7 +490,7 @@ tape( 'the function assigns a scalar value to each indexed element of a 3-dimens
 		10.0,
 		0.0
 	]);
-	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.strictEqual( isSameFloat64Array( getData( y ), expected ), true, 'returns expected value' );
 
 	// Bool:
 	y = ndarray( 'bool', new BooleanArray( 6 ), sh, st, o, ord );
@@ -343,9 +500,39 @@ tape( 'the function assigns a scalar value to each indexed element of a 3-dimens
 	});
 	assignScalar( [ v, y ] );
 
-	for ( i = 0; i < y.length; i++ ) {
-		t.strictEqual( y.iget( i ), true, 'returns expected value' );
-	}
+	expected = new BooleanArray([
+		true,
+		true,
+		false,
+		true,
+		true,
+		false
+	]);
+	t.strictEqual( isEqualBooleanArray( getData( y ), expected ), true, 'returns expected value' );
+
+	// Complex:
+	y = ndarray( 'complex128', zeros( 6, 'complex128' ), sh, st, o, ord );
+
+	v = scalar2ndarray( new Complex128( 5.0, 6.0 ), {
+		'dtype': 'complex128'
+	});
+	assignScalar( [ v, y ] );
+
+	expected = new Complex128Array([
+		5.0,
+		6.0,
+		5.0,
+		6.0,
+		0.0,
+		0.0,
+		5.0,
+		6.0,
+		5.0,
+		6.0,
+		0.0,
+		0.0
+	]);
+	t.strictEqual( isSameComplex128Array( getData( y ), expected ), true, 'returns expected value' );
 
 	// Real-to-complex:
 	y = ndarray( 'complex128', zeros( 6, 'complex128' ), sh, st, o, ord );
@@ -355,9 +542,21 @@ tape( 'the function assigns a scalar value to each indexed element of a 3-dimens
 	});
 	assignScalar( [ v, y ] );
 
-	for ( i = 0; i < y.length; i++ ) {
-		t.strictEqual( y.iget( i ).toString(), '5 + 0i', 'returns expected value' );
-	}
+	expected = new Complex128Array([
+		5.0,
+		0.0,
+		5.0,
+		0.0,
+		0.0,
+		0.0,
+		5.0,
+		0.0,
+		5.0,
+		0.0,
+		0.0,
+		0.0
+	]);
+	t.strictEqual( isSameComplex128Array( getData( y ), expected ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -371,7 +570,6 @@ tape( 'the function assigns a scalar value to each indexed element of a 3-dimens
 	var o;
 	var v;
 	var y;
-	var i;
 
 	dt = 'float64';
 	ord = 'row-major';
@@ -394,7 +592,7 @@ tape( 'the function assigns a scalar value to each indexed element of a 3-dimens
 		10.0,
 		0.0
 	]);
-	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.strictEqual( isSameFloat64Array( getData( y ), expected ), true, 'returns expected value' );
 
 	// Bool:
 	y = ndarray( 'bool', new BooleanArray( 6 ), sh, st, o, ord );
@@ -404,9 +602,39 @@ tape( 'the function assigns a scalar value to each indexed element of a 3-dimens
 	});
 	assignScalar( [ v, y ] );
 
-	for ( i = 0; i < y.length; i++ ) {
-		t.strictEqual( y.iget( i ), true, 'returns expected value' );
-	}
+	expected = new BooleanArray([
+		true,
+		true,
+		false,
+		true,
+		true,
+		false
+	]);
+	t.strictEqual( isEqualBooleanArray( getData( y ), expected ), true, 'returns expected value' );
+
+	// Complex:
+	y = ndarray( 'complex128', zeros( 6, 'complex128' ), sh, st, o, ord );
+
+	v = scalar2ndarray( new Complex128( 5.0, 6.0 ), {
+		'dtype': 'complex128'
+	});
+	assignScalar( [ v, y ] );
+
+	expected = new Complex128Array([
+		5.0,
+		6.0,
+		5.0,
+		6.0,
+		0.0,
+		0.0,
+		5.0,
+		6.0,
+		5.0,
+		6.0,
+		0.0,
+		0.0
+	]);
+	t.strictEqual( isSameComplex128Array( getData( y ), expected ), true, 'returns expected value' );
 
 	// Real-to-complex:
 	y = ndarray( 'complex128', zeros( 6, 'complex128' ), sh, st, o, ord );
@@ -416,9 +644,21 @@ tape( 'the function assigns a scalar value to each indexed element of a 3-dimens
 	});
 	assignScalar( [ v, y ] );
 
-	for ( i = 0; i < y.length; i++ ) {
-		t.strictEqual( y.iget( i ).toString(), '5 + 0i', 'returns expected value' );
-	}
+	expected = new Complex128Array([
+		5.0,
+		0.0,
+		5.0,
+		0.0,
+		0.0,
+		0.0,
+		5.0,
+		0.0,
+		5.0,
+		0.0,
+		0.0,
+		0.0
+	]);
+	t.strictEqual( isSameComplex128Array( getData( y ), expected ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -433,7 +673,6 @@ tape( 'the function assigns a scalar value to each indexed element of a 3-dimens
 	var o;
 	var v;
 	var y;
-	var i;
 
 	dt = 'float64';
 	ord = 'row-major';
@@ -453,7 +692,7 @@ tape( 'the function assigns a scalar value to each indexed element of a 3-dimens
 	expected = new Float64Array( y.length*2 );
 	dfill( y.length, 10.0, expected, st[ 2 ] );
 
-	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.strictEqual( isSameFloat64Array( getData( y ), expected ), true, 'returns expected value' );
 
 	// Bool:
 	y = ndarray( 'bool', new BooleanArray( numel( sh )*2 ), sh, st, o, ord );
@@ -463,9 +702,23 @@ tape( 'the function assigns a scalar value to each indexed element of a 3-dimens
 	});
 	assignScalar( [ v, y ] );
 
-	for ( i = 0; i < y.length; i++ ) {
-		t.strictEqual( y.iget( i ), true, 'returns expected value' );
-	}
+	expected = new BooleanArray( numel( sh )*2 );
+	gfill( y.length, true, expected, st[ 2 ] );
+
+	t.strictEqual( isEqualBooleanArray( getData( y ), expected ), true, 'returns expected value' );
+
+	// Complex:
+	y = ndarray( 'complex128', zeros( numel( sh )*2, 'complex128' ), sh, st, o, ord );
+
+	v = scalar2ndarray( new Complex128( 5.0, 6.0 ), {
+		'dtype': 'complex128'
+	});
+	assignScalar( [ v, y ] );
+
+	expected = zeros( numel( sh )*2, 'complex128' );
+	zfill( y.length, new Complex128( 5.0, 6.0 ), expected, st[ 2 ] );
+
+	t.strictEqual( isSameComplex128Array( getData( y ), expected ), true, 'returns expected value' );
 
 	// Real-to-complex:
 	y = ndarray( 'complex128', zeros( numel( sh )*2, 'complex128' ), sh, st, o, ord );
@@ -475,9 +728,10 @@ tape( 'the function assigns a scalar value to each indexed element of a 3-dimens
 	});
 	assignScalar( [ v, y ] );
 
-	for ( i = 0; i < y.length; i++ ) {
-		t.strictEqual( y.iget( i ).toString(), '5 + 0i', 'returns expected value' );
-	}
+	expected = zeros( numel( sh )*2, 'complex128' );
+	zfill( y.length, new Complex128( 5.0, 0.0 ), expected, st[ 2 ] );
+
+	t.strictEqual( isSameComplex128Array( getData( y ), expected ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -492,7 +746,6 @@ tape( 'the function assigns a scalar value to each indexed element of a 3-dimens
 	var o;
 	var v;
 	var y;
-	var i;
 
 	dt = 'float64';
 	ord = 'row-major';
@@ -512,7 +765,7 @@ tape( 'the function assigns a scalar value to each indexed element of a 3-dimens
 	expected = new Float64Array( y.length*2 );
 	dfill( y.length, 10.0, expected, st[ 2 ] );
 
-	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.strictEqual( isSameFloat64Array( getData( y ), expected ), true, 'returns expected value' );
 
 	// Bool:
 	y = ndarray( 'bool', new BooleanArray( numel( sh )*2 ), sh, st, o, ord );
@@ -522,9 +775,23 @@ tape( 'the function assigns a scalar value to each indexed element of a 3-dimens
 	});
 	assignScalar( [ v, y ] );
 
-	for ( i = 0; i < y.length; i++ ) {
-		t.strictEqual( y.iget( i ), true, 'returns expected value' );
-	}
+	expected = new BooleanArray( numel( sh )*2 );
+	gfill( y.length, true, expected, st[ 2 ] );
+
+	t.strictEqual( isEqualBooleanArray( getData( y ), expected ), true, 'returns expected value' );
+
+	// Complex:
+	y = ndarray( 'complex128', zeros( numel( sh )*2, 'complex128' ), sh, st, o, ord );
+
+	v = scalar2ndarray( new Complex128( 5.0, 6.0 ), {
+		'dtype': 'complex128'
+	});
+	assignScalar( [ v, y ] );
+
+	expected = zeros( numel( sh )*2, 'complex128' );
+	zfill( y.length, new Complex128( 5.0, 6.0 ), expected, st[ 2 ] );
+
+	t.strictEqual( isSameComplex128Array( getData( y ), expected ), true, 'returns expected value' );
 
 	// Real-to-complex:
 	y = ndarray( 'complex128', zeros( numel( sh )*2, 'complex128' ), sh, st, o, ord );
@@ -534,9 +801,10 @@ tape( 'the function assigns a scalar value to each indexed element of a 3-dimens
 	});
 	assignScalar( [ v, y ] );
 
-	for ( i = 0; i < y.length; i++ ) {
-		t.strictEqual( y.iget( i ).toString(), '5 + 0i', 'returns expected value' );
-	}
+	expected = zeros( numel( sh )*2, 'complex128' );
+	zfill( y.length, new Complex128( 5.0, 0.0 ), expected, st[ 2 ] );
+
+	t.strictEqual( isSameComplex128Array( getData( y ), expected ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -551,7 +819,6 @@ tape( 'the function assigns a scalar value to each indexed element of a 3-dimens
 	var o;
 	var v;
 	var y;
-	var i;
 
 	dt = 'float64';
 	ord = 'row-major';
@@ -571,7 +838,7 @@ tape( 'the function assigns a scalar value to each indexed element of a 3-dimens
 	expected = new Float64Array( y.length*2 );
 	dfill( y.length, 10.0, expected, st[ 2 ] );
 
-	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.strictEqual( isSameFloat64Array( getData( y ), expected ), true, 'returns expected value' );
 
 	// Bool:
 	y = ndarray( 'bool', new BooleanArray( numel( sh )*2 ), sh, st, o, ord );
@@ -581,9 +848,23 @@ tape( 'the function assigns a scalar value to each indexed element of a 3-dimens
 	});
 	assignScalar( [ v, y ] );
 
-	for ( i = 0; i < y.length; i++ ) {
-		t.strictEqual( y.iget( i ), true, 'returns expected value' );
-	}
+	expected = new BooleanArray( numel( sh )*2 );
+	gfill( y.length, true, expected, st[ 2 ] );
+
+	t.strictEqual( isEqualBooleanArray( getData( y ), expected ), true, 'returns expected value' );
+
+	// Complex:
+	y = ndarray( 'complex128', zeros( numel( sh )*2, 'complex128' ), sh, st, o, ord );
+
+	v = scalar2ndarray( new Complex128( 5.0, 6.0 ), {
+		'dtype': 'complex128'
+	});
+	assignScalar( [ v, y ] );
+
+	expected = zeros( numel( sh )*2, 'complex128' );
+	zfill( y.length, new Complex128( 5.0, 6.0 ), expected, st[ 2 ] );
+
+	t.strictEqual( isSameComplex128Array( getData( y ), expected ), true, 'returns expected value' );
 
 	// Real-to-complex:
 	y = ndarray( 'complex128', zeros( numel( sh )*2, 'complex128' ), sh, st, o, ord );
@@ -593,21 +874,22 @@ tape( 'the function assigns a scalar value to each indexed element of a 3-dimens
 	});
 	assignScalar( [ v, y ] );
 
-	for ( i = 0; i < y.length; i++ ) {
-		t.strictEqual( y.iget( i ).toString(), '5 + 0i', 'returns expected value' );
-	}
+	expected = zeros( numel( sh )*2, 'complex128' );
+	zfill( y.length, new Complex128( 5.0, 0.0 ), expected, st[ 2 ] );
+
+	t.strictEqual( isSameComplex128Array( getData( y ), expected ), true, 'returns expected value' );
 
 	t.end();
 });
 
 tape( 'the function assigns a scalar value to each indexed element of a 3-dimensional output ndarray (row-major, contiguous, accessors)', function test( t ) {
+	var expected;
 	var ord;
 	var sh;
 	var st;
 	var o;
 	var v;
 	var y;
-	var i;
 
 	ord = 'row-major';
 	sh = [ 2, 1, 2 ];
@@ -621,21 +903,25 @@ tape( 'the function assigns a scalar value to each indexed element of a 3-dimens
 	});
 	assignScalar( [ v, y ] );
 
-	for ( i = 0; i < numel( sh ); i++ ) {
-		t.strictEqual( y.iget( i ), 10.0, 'returns expected value' );
-	}
+	expected = toAccessorArray([
+		10.0,
+		10.0,
+		10.0,
+		10.0
+	]);
+	t.strictEqual( isSameAccessorArray( getData( y ), expected ), true, 'returns expected value' );
 
 	t.end();
 });
 
 tape( 'the function assigns a scalar value to each indexed element of a 3-dimensional output ndarray (row-major, contiguous, negative strides, accessors)', function test( t ) {
+	var expected;
 	var ord;
 	var sh;
 	var st;
 	var o;
 	var v;
 	var y;
-	var i;
 
 	ord = 'row-major';
 	sh = [ 2, 2, 2 ];
@@ -649,21 +935,29 @@ tape( 'the function assigns a scalar value to each indexed element of a 3-dimens
 	});
 	assignScalar( [ v, y ] );
 
-	for ( i = 0; i < numel( sh ); i++ ) {
-		t.strictEqual( y.iget( i ), 10.0, 'returns expected value' );
-	}
+	expected = toAccessorArray([
+		10.0,
+		10.0,
+		10.0,
+		10.0,
+		10.0,
+		10.0,
+		10.0,
+		10.0
+	]);
+	t.strictEqual( isSameAccessorArray( getData( y ), expected ), true, 'returns expected value' );
 
 	t.end();
 });
 
 tape( 'the function assigns a scalar value to each indexed element of a 3-dimensional output ndarray (row-major, non-contiguous, same sign strides, accessors)', function test( t ) {
+	var expected;
 	var ord;
 	var sh;
 	var st;
 	var o;
 	var v;
 	var y;
-	var i;
 
 	ord = 'row-major';
 	sh = [ 2, 1, 2 ];
@@ -677,21 +971,27 @@ tape( 'the function assigns a scalar value to each indexed element of a 3-dimens
 	});
 	assignScalar( [ v, y ] );
 
-	for ( i = 0; i < y.length; i++ ) {
-		t.strictEqual( y.iget( i ), 10.0, 'returns expected value' );
-	}
+	expected = toAccessorArray([
+		10.0,
+		10.0,
+		0,
+		10.0,
+		10.0,
+		0
+	]);
+	t.strictEqual( isSameAccessorArray( getData( y ), expected ), true, 'returns expected value' );
 
 	t.end();
 });
 
 tape( 'the function assigns a scalar value to each indexed element of a 3-dimensional output ndarray (row-major, non-contiguous, mixed sign strides, accessors)', function test( t ) {
+	var expected;
 	var ord;
 	var sh;
 	var st;
 	var o;
 	var v;
 	var y;
-	var i;
 
 	ord = 'row-major';
 	sh = [ 2, 1, 2 ];
@@ -705,14 +1005,21 @@ tape( 'the function assigns a scalar value to each indexed element of a 3-dimens
 	});
 	assignScalar( [ v, y ] );
 
-	for ( i = 0; i < y.length; i++ ) {
-		t.strictEqual( y.iget( i ), 10.0, 'returns expected value' );
-	}
+	expected = toAccessorArray([
+		10.0,
+		10.0,
+		0,
+		10.0,
+		10.0,
+		0
+	]);
+	t.strictEqual( isSameAccessorArray( getData( y ), expected ), true, 'returns expected value' );
 
 	t.end();
 });
 
 tape( 'the function assigns a scalar value to each indexed element of a 3-dimensional output ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var expected;
 	var bsize;
 	var ord;
 	var sh;
@@ -720,7 +1027,6 @@ tape( 'the function assigns a scalar value to each indexed element of a 3-dimens
 	var o;
 	var v;
 	var y;
-	var i;
 
 	ord = 'row-major';
 
@@ -736,14 +1042,16 @@ tape( 'the function assigns a scalar value to each indexed element of a 3-dimens
 	});
 	assignScalar( [ v, y ] );
 
-	for ( i = 0; i < y.length; i++ ) {
-		t.strictEqual( y.iget( i ), 10.0, 'returns expected value' );
-	}
+	expected = toAccessorArray( zeros( numel( sh )*2, 'generic' ) );
+	gfill( y.length, 10.0, expected, st[ 2 ] );
+
+	t.strictEqual( isSameAccessorArray( getData( y ), expected ), true, 'returns expected value' );
 
 	t.end();
 });
 
 tape( 'the function assigns a scalar value to each indexed element of a 3-dimensional output ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var expected;
 	var bsize;
 	var ord;
 	var sh;
@@ -751,7 +1059,6 @@ tape( 'the function assigns a scalar value to each indexed element of a 3-dimens
 	var o;
 	var v;
 	var y;
-	var i;
 
 	ord = 'row-major';
 
@@ -767,14 +1074,16 @@ tape( 'the function assigns a scalar value to each indexed element of a 3-dimens
 	});
 	assignScalar( [ v, y ] );
 
-	for ( i = 0; i < y.length; i++ ) {
-		t.strictEqual( y.iget( i ), 10.0, 'returns expected value' );
-	}
+	expected = toAccessorArray( zeros( numel( sh )*2, 'generic' ) );
+	gfill( y.length, 10.0, expected, st[ 2 ] );
+
+	t.strictEqual( isSameAccessorArray( getData( y ), expected ), true, 'returns expected value' );
 
 	t.end();
 });
 
 tape( 'the function assigns a scalar value to each indexed element of a 3-dimensional output ndarray (row-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var expected;
 	var bsize;
 	var ord;
 	var sh;
@@ -782,7 +1091,6 @@ tape( 'the function assigns a scalar value to each indexed element of a 3-dimens
 	var o;
 	var v;
 	var y;
-	var i;
 
 	ord = 'row-major';
 
@@ -798,9 +1106,10 @@ tape( 'the function assigns a scalar value to each indexed element of a 3-dimens
 	});
 	assignScalar( [ v, y ] );
 
-	for ( i = 0; i < y.length; i++ ) {
-		t.strictEqual( y.iget( i ), 10.0, 'returns expected value' );
-	}
+	expected = toAccessorArray( zeros( numel( sh )*2, 'generic' ) );
+	gfill( y.length, 10.0, expected, st[ 2 ] );
+
+	t.strictEqual( isSameAccessorArray( getData( y ), expected ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -814,7 +1123,6 @@ tape( 'the function assigns a scalar value to each indexed element of a 3-dimens
 	var o;
 	var v;
 	var y;
-	var i;
 
 	dt = 'float64';
 	ord = 'column-major';
@@ -835,7 +1143,7 @@ tape( 'the function assigns a scalar value to each indexed element of a 3-dimens
 		10.0,
 		10.0
 	]);
-	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.strictEqual( isSameFloat64Array( getData( y ), expected ), true, 'returns expected value' );
 
 	// Bool:
 	y = ndarray( 'bool', new BooleanArray( numel( sh ) ), sh, st, o, ord );
@@ -845,9 +1153,33 @@ tape( 'the function assigns a scalar value to each indexed element of a 3-dimens
 	});
 	assignScalar( [ v, y ] );
 
-	for ( i = 0; i < numel( sh ); i++ ) {
-		t.strictEqual( y.data.get( i ), true, 'returns expected value' );
-	}
+	expected = new BooleanArray([
+		true,
+		true,
+		true,
+		true
+	]);
+	t.strictEqual( isEqualBooleanArray( getData( y ), expected ), true, 'returns expected value' );
+
+	// Complex:
+	y = ndarray( 'complex128', zeros( numel( sh ), 'complex128' ), sh, st, o, ord );
+
+	v = scalar2ndarray( new Complex128( 5.0, 6.0 ), {
+		'dtype': 'complex128'
+	});
+	assignScalar( [ v, y ] );
+
+	expected = new Complex128Array([
+		5.0,
+		6.0,
+		5.0,
+		6.0,
+		5.0,
+		6.0,
+		5.0,
+		6.0
+	]);
+	t.strictEqual( isSameComplex128Array( getData( y ), expected ), true, 'returns expected value' );
 
 	// Real-to-complex:
 	y = ndarray( 'complex128', zeros( numel( sh ), 'complex128' ), sh, st, o, ord );
@@ -857,20 +1189,29 @@ tape( 'the function assigns a scalar value to each indexed element of a 3-dimens
 	});
 	assignScalar( [ v, y ] );
 
-	expected = new Complex128Array( [ 5.0, 0.0, 5.0, 0.0, 5.0, 0.0, 5.0, 0.0 ] );
-	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	expected = new Complex128Array([
+		5.0,
+		0.0,
+		5.0,
+		0.0,
+		5.0,
+		0.0,
+		5.0,
+		0.0
+	]);
+	t.strictEqual( isSameComplex128Array( getData( y ), expected ), true, 'returns expected value' );
 
 	t.end();
 });
 
 tape( 'the function assigns a scalar value to each indexed element of a 3-dimensional output ndarray (column-major, singleton dimensions, accessors)', function test( t ) {
+	var expected;
 	var ord;
 	var sh;
 	var st;
 	var o;
 	var v;
 	var y;
-	var i;
 
 	ord = 'column-major';
 	sh = [ 1, 1, 4 ];
@@ -884,9 +1225,13 @@ tape( 'the function assigns a scalar value to each indexed element of a 3-dimens
 	});
 	assignScalar( [ v, y ] );
 
-	for ( i = 0; i < numel( sh ); i++ ) {
-		t.strictEqual( y.iget( i ), 10.0, 'returns expected value' );
-	}
+	expected = toAccessorArray([
+		10.0,
+		10.0,
+		10.0,
+		10.0
+	]);
+	t.strictEqual( isSameAccessorArray( getData( y ), expected ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -895,7 +1240,6 @@ tape( 'the function assigns a scalar value to each indexed element of a 3-dimens
 	var expected;
 	var v;
 	var y;
-	var i;
 
 	y = ndarray( 'float64', zeros( 4, 'float64' ), [ 0, 0, 0 ], [ 1, 1, 1 ], 0, 'column-major' );
 
@@ -910,7 +1254,7 @@ tape( 'the function assigns a scalar value to each indexed element of a 3-dimens
 		0.0,
 		0.0
 	]);
-	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.strictEqual( isSameFloat64Array( getData( y ), expected ), true, 'returns expected value' );
 
 	// Bool:
 	y = ndarray( 'bool', new BooleanArray( 4 ), [ 0, 0, 0 ], [ 1, 1, 1 ], 0, 'column-major' );
@@ -920,9 +1264,33 @@ tape( 'the function assigns a scalar value to each indexed element of a 3-dimens
 	});
 	assignScalar( [ v, y ] );
 
-	for ( i = 0; i < 4; i++ ) {
-		t.strictEqual( y.data.get( i ), false, 'returns expected value' );
-	}
+	expected = new BooleanArray([
+		false,
+		false,
+		false,
+		false
+	]);
+	t.strictEqual( isEqualBooleanArray( getData( y ), expected ), true, 'returns expected value' );
+
+	// Complex:
+	y = ndarray( 'complex128', zeros( 4, 'complex128' ), [ 0, 0, 0 ], [ 1, 1, 1 ], 0, 'column-major' );
+
+	v = scalar2ndarray( new Complex128( 5.0, 6.0 ), {
+		'dtype': 'complex128'
+	});
+	assignScalar( [ v, y ] );
+
+	expected = new Complex128Array([
+		0.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0
+	]);
+	t.strictEqual( isSameComplex128Array( getData( y ), expected ), true, 'returns expected value' );
 
 	// Real-to-complex:
 	y = ndarray( 'complex128', zeros( 4, 'complex128' ), [ 0, 0, 0 ], [ 1, 1, 1 ], 0, 'column-major' );
@@ -932,8 +1300,17 @@ tape( 'the function assigns a scalar value to each indexed element of a 3-dimens
 	});
 	assignScalar( [ v, y ] );
 
-	expected = new Complex128Array( [ 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0 ] );
-	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	expected = new Complex128Array([
+		0.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0,
+		0.0
+	]);
+	t.strictEqual( isSameComplex128Array( getData( y ), expected ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -947,7 +1324,6 @@ tape( 'the function assigns a scalar value to each indexed element of a 3-dimens
 	var o;
 	var v;
 	var y;
-	var i;
 
 	dt = 'float64';
 	ord = 'column-major';
@@ -968,7 +1344,7 @@ tape( 'the function assigns a scalar value to each indexed element of a 3-dimens
 		10.0,
 		10.0
 	]);
-	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.strictEqual( isSameFloat64Array( getData( y ), expected ), true, 'returns expected value' );
 
 	// Bool:
 	y = ndarray( 'bool', new BooleanArray( numel( sh ) ), sh, st, o, ord );
@@ -978,9 +1354,33 @@ tape( 'the function assigns a scalar value to each indexed element of a 3-dimens
 	});
 	assignScalar( [ v, y ] );
 
-	for ( i = 0; i < numel( sh ); i++ ) {
-		t.strictEqual( y.data.get( i ), true, 'returns expected value' );
-	}
+	expected = new BooleanArray([
+		true,
+		true,
+		true,
+		true
+	]);
+	t.strictEqual( isEqualBooleanArray( getData( y ), expected ), true, 'returns expected value' );
+
+	// Complex:
+	y = ndarray( 'complex128', zeros( numel( sh ), 'complex128' ), sh, st, o, ord );
+
+	v = scalar2ndarray( new Complex128( 5.0, 6.0 ), {
+		'dtype': 'complex128'
+	});
+	assignScalar( [ v, y ] );
+
+	expected = new Complex128Array([
+		5.0,
+		6.0,
+		5.0,
+		6.0,
+		5.0,
+		6.0,
+		5.0,
+		6.0
+	]);
+	t.strictEqual( isSameComplex128Array( getData( y ), expected ), true, 'returns expected value' );
 
 	// Real-to-complex:
 	y = ndarray( 'complex128', zeros( numel( sh ), 'complex128' ), sh, st, o, ord );
@@ -990,8 +1390,17 @@ tape( 'the function assigns a scalar value to each indexed element of a 3-dimens
 	});
 	assignScalar( [ v, y ] );
 
-	expected = new Complex128Array( [ 5.0, 0.0, 5.0, 0.0, 5.0, 0.0, 5.0, 0.0 ] );
-	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	expected = new Complex128Array([
+		5.0,
+		0.0,
+		5.0,
+		0.0,
+		5.0,
+		0.0,
+		5.0,
+		0.0
+	]);
+	t.strictEqual( isSameComplex128Array( getData( y ), expected ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -1005,7 +1414,6 @@ tape( 'the function assigns a scalar value to each indexed element of a 3-dimens
 	var o;
 	var v;
 	var y;
-	var i;
 
 	dt = 'float64';
 	ord = 'column-major';
@@ -1030,7 +1438,7 @@ tape( 'the function assigns a scalar value to each indexed element of a 3-dimens
 		10.0,
 		10.0
 	]);
-	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.strictEqual( isSameFloat64Array( getData( y ), expected ), true, 'returns expected value' );
 
 	// Bool:
 	y = ndarray( 'bool', new BooleanArray( numel( sh ) ), sh, st, o, ord );
@@ -1040,9 +1448,45 @@ tape( 'the function assigns a scalar value to each indexed element of a 3-dimens
 	});
 	assignScalar( [ v, y ] );
 
-	for ( i = 0; i < numel( sh ); i++ ) {
-		t.strictEqual( y.data.get( i ), true, 'returns expected value' );
-	}
+	expected = new BooleanArray([
+		true,
+		true,
+		true,
+		true,
+		true,
+		true,
+		true,
+		true
+	]);
+	t.strictEqual( isEqualBooleanArray( getData( y ), expected ), true, 'returns expected value' );
+
+	// Complex:
+	y = ndarray( 'complex128', zeros( numel( sh ), 'complex128' ), sh, st, o, ord );
+
+	v = scalar2ndarray( new Complex128( 5.0, 6.0 ), {
+		'dtype': 'complex128'
+	});
+	assignScalar( [ v, y ] );
+
+	expected = new Complex128Array([
+		5.0,
+		6.0,
+		5.0,
+		6.0,
+		5.0,
+		6.0,
+		5.0,
+		6.0,
+		5.0,
+		6.0,
+		5.0,
+		6.0,
+		5.0,
+		6.0,
+		5.0,
+		6.0
+	]);
+	t.strictEqual( isSameComplex128Array( getData( y ), expected ), true, 'returns expected value' );
 
 	// Real-to-complex:
 	y = ndarray( 'complex128', zeros( numel( sh ), 'complex128' ), sh, st, o, ord );
@@ -1052,8 +1496,25 @@ tape( 'the function assigns a scalar value to each indexed element of a 3-dimens
 	});
 	assignScalar( [ v, y ] );
 
-	expected = new Complex128Array( [ 5.0, 0.0, 5.0, 0.0, 5.0, 0.0, 5.0, 0.0, 5.0, 0.0, 5.0, 0.0, 5.0, 0.0, 5.0, 0.0 ] );
-	t.strictEqual( isSameComplex128Array( y.data, expected ), true, 'returns expected value' );
+	expected = new Complex128Array([
+		5.0,
+		0.0,
+		5.0,
+		0.0,
+		5.0,
+		0.0,
+		5.0,
+		0.0,
+		5.0,
+		0.0,
+		5.0,
+		0.0,
+		5.0,
+		0.0,
+		5.0,
+		0.0
+	]);
+	t.strictEqual( isSameComplex128Array( getData( y ), expected ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -1067,7 +1528,6 @@ tape( 'the function assigns a scalar value to each indexed element of a 3-dimens
 	var o;
 	var v;
 	var y;
-	var i;
 
 	dt = 'float64';
 	ord = 'column-major';
@@ -1090,7 +1550,7 @@ tape( 'the function assigns a scalar value to each indexed element of a 3-dimens
 		10.0,
 		0.0
 	]);
-	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.strictEqual( isSameFloat64Array( getData( y ), expected ), true, 'returns expected value' );
 
 	// Bool:
 	y = ndarray( 'bool', new BooleanArray( 6 ), sh, st, o, ord );
@@ -1100,9 +1560,39 @@ tape( 'the function assigns a scalar value to each indexed element of a 3-dimens
 	});
 	assignScalar( [ v, y ] );
 
-	for ( i = 0; i < y.length; i++ ) {
-		t.strictEqual( y.iget( i ), true, 'returns expected value' );
-	}
+	expected = new BooleanArray([
+		true,
+		true,
+		false,
+		true,
+		true,
+		false
+	]);
+	t.strictEqual( isEqualBooleanArray( getData( y ), expected ), true, 'returns expected value' );
+
+	// Complex:
+	y = ndarray( 'complex128', zeros( 6, 'complex128' ), sh, st, o, ord );
+
+	v = scalar2ndarray( new Complex128( 5.0, 6.0 ), {
+		'dtype': 'complex128'
+	});
+	assignScalar( [ v, y ] );
+
+	expected = new Complex128Array([
+		5.0,
+		6.0,
+		5.0,
+		6.0,
+		0.0,
+		0.0,
+		5.0,
+		6.0,
+		5.0,
+		6.0,
+		0.0,
+		0.0
+	]);
+	t.strictEqual( isSameComplex128Array( getData( y ), expected ), true, 'returns expected value' );
 
 	// Real-to-complex:
 	y = ndarray( 'complex128', zeros( 6, 'complex128' ), sh, st, o, ord );
@@ -1112,9 +1602,21 @@ tape( 'the function assigns a scalar value to each indexed element of a 3-dimens
 	});
 	assignScalar( [ v, y ] );
 
-	for ( i = 0; i < y.length; i++ ) {
-		t.strictEqual( y.iget( i ).toString(), '5 + 0i', 'returns expected value' );
-	}
+	expected = new Complex128Array([
+		5.0,
+		0.0,
+		5.0,
+		0.0,
+		0.0,
+		0.0,
+		5.0,
+		0.0,
+		5.0,
+		0.0,
+		0.0,
+		0.0
+	]);
+	t.strictEqual( isSameComplex128Array( getData( y ), expected ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -1128,7 +1630,6 @@ tape( 'the function assigns a scalar value to each indexed element of a 3-dimens
 	var o;
 	var v;
 	var y;
-	var i;
 
 	dt = 'float64';
 	ord = 'column-major';
@@ -1151,7 +1652,7 @@ tape( 'the function assigns a scalar value to each indexed element of a 3-dimens
 		10.0,
 		0.0
 	]);
-	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.strictEqual( isSameFloat64Array( getData( y ), expected ), true, 'returns expected value' );
 
 	// Bool:
 	y = ndarray( 'bool', new BooleanArray( 6 ), sh, st, o, ord );
@@ -1161,9 +1662,39 @@ tape( 'the function assigns a scalar value to each indexed element of a 3-dimens
 	});
 	assignScalar( [ v, y ] );
 
-	for ( i = 0; i < y.length; i++ ) {
-		t.strictEqual( y.iget( i ), true, 'returns expected value' );
-	}
+	expected = new BooleanArray([
+		true,
+		true,
+		false,
+		true,
+		true,
+		false
+	]);
+	t.strictEqual( isEqualBooleanArray( getData( y ), expected ), true, 'returns expected value' );
+
+	// Complex:
+	y = ndarray( 'complex128', zeros( 6, 'complex128' ), sh, st, o, ord );
+
+	v = scalar2ndarray( new Complex128( 5.0, 6.0 ), {
+		'dtype': 'complex128'
+	});
+	assignScalar( [ v, y ] );
+
+	expected = new Complex128Array([
+		5.0,
+		6.0,
+		5.0,
+		6.0,
+		0.0,
+		0.0,
+		5.0,
+		6.0,
+		5.0,
+		6.0,
+		0.0,
+		0.0
+	]);
+	t.strictEqual( isSameComplex128Array( getData( y ), expected ), true, 'returns expected value' );
 
 	// Real-to-complex:
 	y = ndarray( 'complex128', zeros( 6, 'complex128' ), sh, st, o, ord );
@@ -1173,9 +1704,21 @@ tape( 'the function assigns a scalar value to each indexed element of a 3-dimens
 	});
 	assignScalar( [ v, y ] );
 
-	for ( i = 0; i < y.length; i++ ) {
-		t.strictEqual( y.iget( i ).toString(), '5 + 0i', 'returns expected value' );
-	}
+	expected = new Complex128Array([
+		5.0,
+		0.0,
+		5.0,
+		0.0,
+		0.0,
+		0.0,
+		5.0,
+		0.0,
+		5.0,
+		0.0,
+		0.0,
+		0.0
+	]);
+	t.strictEqual( isSameComplex128Array( getData( y ), expected ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -1190,7 +1733,6 @@ tape( 'the function assigns a scalar value to each indexed element of a 3-dimens
 	var o;
 	var v;
 	var y;
-	var i;
 
 	dt = 'float64';
 	ord = 'column-major';
@@ -1210,7 +1752,7 @@ tape( 'the function assigns a scalar value to each indexed element of a 3-dimens
 	expected = new Float64Array( y.length*2 );
 	dfill( y.length, 10.0, expected, st[ 0 ] );
 
-	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.strictEqual( isSameFloat64Array( getData( y ), expected ), true, 'returns expected value' );
 
 	// Bool:
 	y = ndarray( 'bool', new BooleanArray( numel( sh )*2 ), sh, st, o, ord );
@@ -1220,9 +1762,23 @@ tape( 'the function assigns a scalar value to each indexed element of a 3-dimens
 	});
 	assignScalar( [ v, y ] );
 
-	for ( i = 0; i < y.length; i++ ) {
-		t.strictEqual( y.iget( i ), true, 'returns expected value' );
-	}
+	expected = new BooleanArray( numel( sh )*2 );
+	gfill( y.length, true, expected, st[ 0 ] );
+
+	t.strictEqual( isEqualBooleanArray( getData( y ), expected ), true, 'returns expected value' );
+
+	// Complex:
+	y = ndarray( 'complex128', zeros( numel( sh )*2, 'complex128' ), sh, st, o, ord );
+
+	v = scalar2ndarray( new Complex128( 5.0, 6.0 ), {
+		'dtype': 'complex128'
+	});
+	assignScalar( [ v, y ] );
+
+	expected = zeros( numel( sh )*2, 'complex128' );
+	zfill( y.length, new Complex128( 5.0, 6.0 ), expected, st[ 0 ] );
+
+	t.strictEqual( isSameComplex128Array( getData( y ), expected ), true, 'returns expected value' );
 
 	// Real-to-complex:
 	y = ndarray( 'complex128', zeros( numel( sh )*2, 'complex128' ), sh, st, o, ord );
@@ -1232,9 +1788,10 @@ tape( 'the function assigns a scalar value to each indexed element of a 3-dimens
 	});
 	assignScalar( [ v, y ] );
 
-	for ( i = 0; i < y.length; i++ ) {
-		t.strictEqual( y.iget( i ).toString(), '5 + 0i', 'returns expected value' );
-	}
+	expected = zeros( numel( sh )*2, 'complex128' );
+	zfill( y.length, new Complex128( 5.0, 0.0 ), expected, st[ 0 ] );
+
+	t.strictEqual( isSameComplex128Array( getData( y ), expected ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -1249,7 +1806,6 @@ tape( 'the function assigns a scalar value to each indexed element of a 3-dimens
 	var o;
 	var v;
 	var y;
-	var i;
 
 	dt = 'float64';
 	ord = 'column-major';
@@ -1269,7 +1825,7 @@ tape( 'the function assigns a scalar value to each indexed element of a 3-dimens
 	expected = new Float64Array( y.length*2 );
 	dfill( y.length, 10.0, expected, st[ 0 ] );
 
-	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.strictEqual( isSameFloat64Array( getData( y ), expected ), true, 'returns expected value' );
 
 	// Bool:
 	y = ndarray( 'bool', new BooleanArray( numel( sh )*2 ), sh, st, o, ord );
@@ -1279,9 +1835,23 @@ tape( 'the function assigns a scalar value to each indexed element of a 3-dimens
 	});
 	assignScalar( [ v, y ] );
 
-	for ( i = 0; i < y.length; i++ ) {
-		t.strictEqual( y.iget( i ), true, 'returns expected value' );
-	}
+	expected = new BooleanArray( numel( sh )*2 );
+	gfill( y.length, true, expected, st[ 0 ] );
+
+	t.strictEqual( isEqualBooleanArray( getData( y ), expected ), true, 'returns expected value' );
+
+	// Complex:
+	y = ndarray( 'complex128', zeros( numel( sh )*2, 'complex128' ), sh, st, o, ord );
+
+	v = scalar2ndarray( new Complex128( 5.0, 6.0 ), {
+		'dtype': 'complex128'
+	});
+	assignScalar( [ v, y ] );
+
+	expected = zeros( numel( sh )*2, 'complex128' );
+	zfill( y.length, new Complex128( 5.0, 6.0 ), expected, st[ 0 ] );
+
+	t.strictEqual( isSameComplex128Array( getData( y ), expected ), true, 'returns expected value' );
 
 	// Real-to-complex:
 	y = ndarray( 'complex128', zeros( numel( sh )*2, 'complex128' ), sh, st, o, ord );
@@ -1291,9 +1861,10 @@ tape( 'the function assigns a scalar value to each indexed element of a 3-dimens
 	});
 	assignScalar( [ v, y ] );
 
-	for ( i = 0; i < y.length; i++ ) {
-		t.strictEqual( y.iget( i ).toString(), '5 + 0i', 'returns expected value' );
-	}
+	expected = zeros( numel( sh )*2, 'complex128' );
+	zfill( y.length, new Complex128( 5.0, 0.0 ), expected, st[ 0 ] );
+
+	t.strictEqual( isSameComplex128Array( getData( y ), expected ), true, 'returns expected value' );
 
 	t.end();
 });
@@ -1308,7 +1879,6 @@ tape( 'the function assigns a scalar value to each indexed element of a 3-dimens
 	var o;
 	var v;
 	var y;
-	var i;
 
 	dt = 'float64';
 	ord = 'column-major';
@@ -1328,7 +1898,7 @@ tape( 'the function assigns a scalar value to each indexed element of a 3-dimens
 	expected = new Float64Array( y.length*2 );
 	dfill( y.length, 10.0, expected, st[ 0 ] );
 
-	t.strictEqual( isSameFloat64Array( y.data, expected ), true, 'returns expected value' );
+	t.strictEqual( isSameFloat64Array( getData( y ), expected ), true, 'returns expected value' );
 
 	// Bool:
 	y = ndarray( 'bool', new BooleanArray( numel( sh )*2 ), sh, st, o, ord );
@@ -1338,9 +1908,23 @@ tape( 'the function assigns a scalar value to each indexed element of a 3-dimens
 	});
 	assignScalar( [ v, y ] );
 
-	for ( i = 0; i < y.length; i++ ) {
-		t.strictEqual( y.iget( i ), true, 'returns expected value' );
-	}
+	expected = new BooleanArray( numel( sh )*2 );
+	gfill( y.length, true, expected, st[ 0 ] );
+
+	t.strictEqual( isEqualBooleanArray( getData( y ), expected ), true, 'returns expected value' );
+
+	// Complex:
+	y = ndarray( 'complex128', zeros( numel( sh )*2, 'complex128' ), sh, st, o, ord );
+
+	v = scalar2ndarray( new Complex128( 5.0, 6.0 ), {
+		'dtype': 'complex128'
+	});
+	assignScalar( [ v, y ] );
+
+	expected = zeros( numel( sh )*2, 'complex128' );
+	zfill( y.length, new Complex128( 5.0, 6.0 ), expected, st[ 0 ] );
+
+	t.strictEqual( isSameComplex128Array( getData( y ), expected ), true, 'returns expected value' );
 
 	// Real-to-complex:
 	y = ndarray( 'complex128', zeros( numel( sh )*2, 'complex128' ), sh, st, o, ord );
@@ -1350,21 +1934,22 @@ tape( 'the function assigns a scalar value to each indexed element of a 3-dimens
 	});
 	assignScalar( [ v, y ] );
 
-	for ( i = 0; i < y.length; i++ ) {
-		t.strictEqual( y.iget( i ).toString(), '5 + 0i', 'returns expected value' );
-	}
+	expected = zeros( numel( sh )*2, 'complex128' );
+	zfill( y.length, new Complex128( 5.0, 0.0 ), expected, st[ 0 ] );
+
+	t.strictEqual( isSameComplex128Array( getData( y ), expected ), true, 'returns expected value' );
 
 	t.end();
 });
 
 tape( 'the function assigns a scalar value to each indexed element of a 3-dimensional output ndarray (column-major, contiguous, accessors)', function test( t ) {
+	var expected;
 	var ord;
 	var sh;
 	var st;
 	var o;
 	var v;
 	var y;
-	var i;
 
 	ord = 'column-major';
 	sh = [ 2, 1, 2 ];
@@ -1378,21 +1963,25 @@ tape( 'the function assigns a scalar value to each indexed element of a 3-dimens
 	});
 	assignScalar( [ v, y ] );
 
-	for ( i = 0; i < numel( sh ); i++ ) {
-		t.strictEqual( y.iget( i ), 10.0, 'returns expected value' );
-	}
+	expected = toAccessorArray([
+		10.0,
+		10.0,
+		10.0,
+		10.0
+	]);
+	t.strictEqual( isSameAccessorArray( getData( y ), expected ), true, 'returns expected value' );
 
 	t.end();
 });
 
 tape( 'the function assigns a scalar value to each indexed element of a 3-dimensional output ndarray (column-major, contiguous, negative strides, accessors)', function test( t ) {
+	var expected;
 	var ord;
 	var sh;
 	var st;
 	var o;
 	var v;
 	var y;
-	var i;
 
 	ord = 'column-major';
 	sh = [ 2, 2, 2 ];
@@ -1406,21 +1995,29 @@ tape( 'the function assigns a scalar value to each indexed element of a 3-dimens
 	});
 	assignScalar( [ v, y ] );
 
-	for ( i = 0; i < numel( sh ); i++ ) {
-		t.strictEqual( y.iget( i ), 10.0, 'returns expected value' );
-	}
+	expected = toAccessorArray([
+		10.0,
+		10.0,
+		10.0,
+		10.0,
+		10.0,
+		10.0,
+		10.0,
+		10.0
+	]);
+	t.strictEqual( isSameAccessorArray( getData( y ), expected ), true, 'returns expected value' );
 
 	t.end();
 });
 
 tape( 'the function assigns a scalar value to each indexed element of a 3-dimensional output ndarray (column-major, non-contiguous, same sign strides, accessors)', function test( t ) {
+	var expected;
 	var ord;
 	var sh;
 	var st;
 	var o;
 	var v;
 	var y;
-	var i;
 
 	ord = 'column-major';
 	sh = [ 2, 1, 2 ];
@@ -1434,21 +2031,27 @@ tape( 'the function assigns a scalar value to each indexed element of a 3-dimens
 	});
 	assignScalar( [ v, y ] );
 
-	for ( i = 0; i < y.length; i++ ) {
-		t.strictEqual( y.iget( i ), 10.0, 'returns expected value' );
-	}
+	expected = toAccessorArray([
+		10.0,
+		10.0,
+		0,
+		10.0,
+		10.0,
+		0
+	]);
+	t.strictEqual( isSameAccessorArray( getData( y ), expected ), true, 'returns expected value' );
 
 	t.end();
 });
 
 tape( 'the function assigns a scalar value to each indexed element of a 3-dimensional output ndarray (column-major, non-contiguous, mixed sign strides, accessors)', function test( t ) {
+	var expected;
 	var ord;
 	var sh;
 	var st;
 	var o;
 	var v;
 	var y;
-	var i;
 
 	ord = 'column-major';
 	sh = [ 2, 1, 2 ];
@@ -1462,14 +2065,21 @@ tape( 'the function assigns a scalar value to each indexed element of a 3-dimens
 	});
 	assignScalar( [ v, y ] );
 
-	for ( i = 0; i < y.length; i++ ) {
-		t.strictEqual( y.iget( i ), 10.0, 'returns expected value' );
-	}
+	expected = toAccessorArray([
+		10.0,
+		10.0,
+		0,
+		10.0,
+		10.0,
+		0
+	]);
+	t.strictEqual( isSameAccessorArray( getData( y ), expected ), true, 'returns expected value' );
 
 	t.end();
 });
 
 tape( 'the function assigns a scalar value to each indexed element of a 3-dimensional output ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var expected;
 	var bsize;
 	var ord;
 	var sh;
@@ -1477,7 +2087,6 @@ tape( 'the function assigns a scalar value to each indexed element of a 3-dimens
 	var o;
 	var v;
 	var y;
-	var i;
 
 	ord = 'column-major';
 
@@ -1493,14 +2102,16 @@ tape( 'the function assigns a scalar value to each indexed element of a 3-dimens
 	});
 	assignScalar( [ v, y ] );
 
-	for ( i = 0; i < y.length; i++ ) {
-		t.strictEqual( y.iget( i ), 10.0, 'returns expected value' );
-	}
+	expected = toAccessorArray( zeros( numel( sh )*2, 'generic' ) );
+	gfill( y.length, 10.0, expected, st[ 0 ] );
+
+	t.strictEqual( isSameAccessorArray( getData( y ), expected ), true, 'returns expected value' );
 
 	t.end();
 });
 
 tape( 'the function assigns a scalar value to each indexed element of a 3-dimensional output ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var expected;
 	var bsize;
 	var ord;
 	var sh;
@@ -1508,7 +2119,6 @@ tape( 'the function assigns a scalar value to each indexed element of a 3-dimens
 	var o;
 	var v;
 	var y;
-	var i;
 
 	ord = 'column-major';
 
@@ -1524,14 +2134,16 @@ tape( 'the function assigns a scalar value to each indexed element of a 3-dimens
 	});
 	assignScalar( [ v, y ] );
 
-	for ( i = 0; i < y.length; i++ ) {
-		t.strictEqual( y.iget( i ), 10.0, 'returns expected value' );
-	}
+	expected = toAccessorArray( zeros( numel( sh )*2, 'generic' ) );
+	gfill( y.length, 10.0, expected, st[ 0 ] );
+
+	t.strictEqual( isSameAccessorArray( getData( y ), expected ), true, 'returns expected value' );
 
 	t.end();
 });
 
 tape( 'the function assigns a scalar value to each indexed element of a 3-dimensional output ndarray (column-major, non-contiguous, large arrays, accessors)', function test( t ) {
+	var expected;
 	var bsize;
 	var ord;
 	var sh;
@@ -1539,7 +2151,6 @@ tape( 'the function assigns a scalar value to each indexed element of a 3-dimens
 	var o;
 	var v;
 	var y;
-	var i;
 
 	ord = 'column-major';
 
@@ -1555,9 +2166,10 @@ tape( 'the function assigns a scalar value to each indexed element of a 3-dimens
 	});
 	assignScalar( [ v, y ] );
 
-	for ( i = 0; i < y.length; i++ ) {
-		t.strictEqual( y.iget( i ), 10.0, 'returns expected value' );
-	}
+	expected = toAccessorArray( zeros( numel( sh )*2, 'generic' ) );
+	gfill( y.length, 10.0, expected, st[ 0 ] );
+
+	t.strictEqual( isSameAccessorArray( getData( y ), expected ), true, 'returns expected value' );
 
 	t.end();
 });