diff --git a/lib/node_modules/@stdlib/ndarray/base/kernels/generic/quaternary/blocked/README.md b/lib/node_modules/@stdlib/ndarray/base/kernels/generic/quaternary/blocked/README.md
new file mode 100644
index 000000000000..97b6d4401fa5
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/kernels/generic/quaternary/blocked/README.md
@@ -0,0 +1,1026 @@
+<!--
+
+@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.
+
+-->
+
+# kernel
+
+> Return a kernel for applying a quaternary callback to elements in four input ndarrays and assigning results to elements in an output ndarray using loop blocking.
+
+<section class="intro">
+
+</section>
+
+<!-- /.intro -->
+
+<section class="usage">
+
+## Usage
+
+```javascript
+var kernel = require( '@stdlib/ndarray/base/kernels/generic/quaternary/blocked' );
+```
+
+#### kernel( ndims )
+
+Returns a kernel for applying a quaternary callback to elements in four input ndarrays and assigning results to elements in an output ndarray using loop blocking.
+
+<!-- eslint-disable max-len -->
+
+```javascript
+var Float64Array = require( '@stdlib/array/float64' );
+var ndarray2array = require( '@stdlib/ndarray/base/to-array' );
+var add4 = require( '@stdlib/number/float64/base/add4' );
+
+// Create data buffers:
+var xbuf = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] );
+var ybuf = new Float64Array( [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ] );
+var zbuf = new Float64Array( [ 2.0, 2.0, 2.0, 2.0, 2.0, 2.0 ] );
+var wbuf = new Float64Array( [ 3.0, 3.0, 3.0, 3.0, 3.0, 3.0 ] );
+var ubuf = new Float64Array( 6 );
+
+// Define the shape of the input and output arrays:
+var shape = [ 3, 2 ];
+
+// Define the array strides:
+var sx = [ 2, 1 ];
+var sy = [ 2, 1 ];
+var sz = [ 2, 1 ];
+var sw = [ 2, 1 ];
+var su = [ 2, 1 ];
+
+// Create the input and output ndarray-like objects:
+var x = {
+    'dtype': 'float64',
+    'data': xbuf,
+    'shape': shape,
+    'strides': sx,
+    'offset': 0,
+    'order': 'row-major'
+};
+var y = {
+    'dtype': 'float64',
+    'data': ybuf,
+    'shape': shape,
+    'strides': sy,
+    'offset': 0,
+    'order': 'row-major'
+};
+var z = {
+    'dtype': 'float64',
+    'data': zbuf,
+    'shape': shape,
+    'strides': sz,
+    'offset': 0,
+    'order': 'row-major'
+};
+var w = {
+    'dtype': 'float64',
+    'data': wbuf,
+    'shape': shape,
+    'strides': sw,
+    'offset': 0,
+    'order': 'row-major'
+};
+var u = {
+    'dtype': 'float64',
+    'data': ubuf,
+    'shape': shape,
+    'strides': su,
+    'offset': 0,
+    'order': 'row-major'
+};
+
+// Resolve a kernel:
+var f = kernel( 2 );
+
+// Apply the quaternary function:
+f( x, y, z, w, u, add4 );
+
+var arr = ndarray2array( u.data, u.shape, u.strides, u.offset, u.order );
+// returns [ [ 7.0, 8.0 ], [ 9.0, 10.0 ], [ 11.0, 12.0 ] ]
+```
+
+The function accepts the following arguments:
+
+-   **ndims**: number of dimensions.
+
+If the function is provided an `ndims` value less than `2` or greater than the maximum number of supported dimensions, the function returns `null`.
+
+```javascript
+var f = kernel( 1 );
+// returns null
+```
+
+The returned function accepts the following arguments:
+
+-   **x**: first input ndarray descriptor (object with `dtype`, `data`, `shape`, `strides`, `offset`, `order`).
+-   **y**: second input ndarray descriptor.
+-   **z**: third input ndarray descriptor.
+-   **w**: fourth input ndarray descriptor.
+-   **u**: output ndarray descriptor.
+-   **fcn**: quaternary callback accepting four scalar values and returning one scalar value.
+
+#### kernel.kernel2d( x, y, z, w, u, fcn )
+
+Applies a quaternary callback to elements in two-dimensional input ndarrays and assigns results to elements in an equivalently shaped output ndarray via loop blocking.
+
+```javascript
+var Float64Array = require( '@stdlib/array/float64' );
+var ndarray2array = require( '@stdlib/ndarray/base/to-array' );
+var add4 = require( '@stdlib/number/float64/base/add4' );
+
+// Create data buffers:
+var xbuf = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] );
+var ybuf = new Float64Array( [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ] );
+var zbuf = new Float64Array( [ 2.0, 2.0, 2.0, 2.0, 2.0, 2.0 ] );
+var wbuf = new Float64Array( [ 3.0, 3.0, 3.0, 3.0, 3.0, 3.0 ] );
+var ubuf = new Float64Array( 6 );
+
+// Define the shape of the input and output arrays:
+var shape = [ 3, 2 ];
+
+// Define the array strides:
+var sx = [ 2, 1 ];
+var sy = [ 2, 1 ];
+var sz = [ 2, 1 ];
+var sw = [ 2, 1 ];
+var su = [ 2, 1 ];
+
+// Create the input and output ndarray-like objects:
+var x = {
+    'dtype': 'float64',
+    'data': xbuf,
+    'shape': shape,
+    'strides': sx,
+    'offset': 0,
+    'order': 'row-major'
+};
+var y = {
+    'dtype': 'float64',
+    'data': ybuf,
+    'shape': shape,
+    'strides': sy,
+    'offset': 0,
+    'order': 'row-major'
+};
+var z = {
+    'dtype': 'float64',
+    'data': zbuf,
+    'shape': shape,
+    'strides': sz,
+    'offset': 0,
+    'order': 'row-major'
+};
+var w = {
+    'dtype': 'float64',
+    'data': wbuf,
+    'shape': shape,
+    'strides': sw,
+    'offset': 0,
+    'order': 'row-major'
+};
+var u = {
+    'dtype': 'float64',
+    'data': ubuf,
+    'shape': shape,
+    'strides': su,
+    'offset': 0,
+    'order': 'row-major'
+};
+
+// Apply the quaternary function:
+kernel.kernel2d( x, y, z, w, u, add4 );
+
+var arr = ndarray2array( u.data, u.shape, u.strides, u.offset, u.order );
+// returns [ [ 7.0, 8.0 ], [ 9.0, 10.0 ], [ 11.0, 12.0 ] ]
+```
+
+The function accepts the following arguments:
+
+-   **x**: first input ndarray descriptor.
+-   **y**: second input ndarray descriptor.
+-   **z**: third input ndarray descriptor.
+-   **w**: fourth input ndarray descriptor.
+-   **u**: output ndarray descriptor.
+-   **fcn**: quaternary callback.
+
+#### kernel.kernel3d( x, y, z, w, u, fcn )
+
+Applies a quaternary callback to elements in three-dimensional input ndarrays and assigns results to elements in an equivalently shaped output ndarray via loop blocking.
+
+<!-- eslint-disable max-len -->
+
+```javascript
+var Float64Array = require( '@stdlib/array/float64' );
+var ndarray2array = require( '@stdlib/ndarray/base/to-array' );
+var add4 = require( '@stdlib/number/float64/base/add4' );
+
+// Create data buffers:
+var xbuf = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 ] );
+var ybuf = new Float64Array( [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ] );
+var zbuf = new Float64Array( [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ] );
+var wbuf = new Float64Array( [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ] );
+var ubuf = new Float64Array( 8 );
+
+// Define the shape of the input and output arrays:
+var shape = [ 2, 2, 2 ];
+
+// Define the array strides:
+var sx = [ 4, 2, 1 ];
+var sy = [ 4, 2, 1 ];
+var sz = [ 4, 2, 1 ];
+var sw = [ 4, 2, 1 ];
+var su = [ 4, 2, 1 ];
+
+// Create the input and output ndarray-like objects:
+var x = {
+    'dtype': 'float64',
+    'data': xbuf,
+    'shape': shape,
+    'strides': sx,
+    'offset': 0,
+    'order': 'row-major'
+};
+var y = {
+    'dtype': 'float64',
+    'data': ybuf,
+    'shape': shape,
+    'strides': sy,
+    'offset': 0,
+    'order': 'row-major'
+};
+var z = {
+    'dtype': 'float64',
+    'data': zbuf,
+    'shape': shape,
+    'strides': sz,
+    'offset': 0,
+    'order': 'row-major'
+};
+var w = {
+    'dtype': 'float64',
+    'data': wbuf,
+    'shape': shape,
+    'strides': sw,
+    'offset': 0,
+    'order': 'row-major'
+};
+var u = {
+    'dtype': 'float64',
+    'data': ubuf,
+    'shape': shape,
+    'strides': su,
+    'offset': 0,
+    'order': 'row-major'
+};
+
+// Apply the quaternary function:
+kernel.kernel3d( x, y, z, w, u, add4 );
+
+var arr = ndarray2array( u.data, u.shape, u.strides, u.offset, u.order );
+// returns [ [ [ 4.0, 5.0 ], [ 6.0, 7.0 ] ], [ [ 8.0, 9.0 ], [ 10.0, 11.0 ] ] ]
+```
+
+The function accepts the following arguments:
+
+-   **x**: first input ndarray descriptor.
+-   **y**: second input ndarray descriptor.
+-   **z**: third input ndarray descriptor.
+-   **w**: fourth input ndarray descriptor.
+-   **u**: output ndarray descriptor.
+-   **fcn**: quaternary callback.
+
+#### kernel.kernel4d( x, y, z, w, u, fcn )
+
+Applies a quaternary callback to elements in four-dimensional input ndarrays and assigns results to elements in an equivalently shaped output ndarray via loop blocking.
+
+<!-- eslint-disable max-len -->
+
+```javascript
+var Float64Array = require( '@stdlib/array/float64' );
+var ndarray2array = require( '@stdlib/ndarray/base/to-array' );
+var add4 = require( '@stdlib/number/float64/base/add4' );
+
+// Create data buffers:
+var xbuf = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 ] );
+var ybuf = new Float64Array( [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ] );
+var zbuf = new Float64Array( [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ] );
+var wbuf = new Float64Array( [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ] );
+var ubuf = new Float64Array( 8 );
+
+// Define the shape of the input and output arrays:
+var shape = [ 1, 2, 2, 2 ];
+
+// Define the array strides:
+var sx = [ 8, 4, 2, 1 ];
+var sy = [ 8, 4, 2, 1 ];
+var sz = [ 8, 4, 2, 1 ];
+var sw = [ 8, 4, 2, 1 ];
+var su = [ 8, 4, 2, 1 ];
+
+// Create the input and output ndarray-like objects:
+var x = {
+    'dtype': 'float64',
+    'data': xbuf,
+    'shape': shape,
+    'strides': sx,
+    'offset': 0,
+    'order': 'row-major'
+};
+var y = {
+    'dtype': 'float64',
+    'data': ybuf,
+    'shape': shape,
+    'strides': sy,
+    'offset': 0,
+    'order': 'row-major'
+};
+var z = {
+    'dtype': 'float64',
+    'data': zbuf,
+    'shape': shape,
+    'strides': sz,
+    'offset': 0,
+    'order': 'row-major'
+};
+var w = {
+    'dtype': 'float64',
+    'data': wbuf,
+    'shape': shape,
+    'strides': sw,
+    'offset': 0,
+    'order': 'row-major'
+};
+var u = {
+    'dtype': 'float64',
+    'data': ubuf,
+    'shape': shape,
+    'strides': su,
+    'offset': 0,
+    'order': 'row-major'
+};
+
+// Apply the quaternary function:
+kernel.kernel4d( x, y, z, w, u, add4 );
+
+var arr = ndarray2array( u.data, u.shape, u.strides, u.offset, u.order );
+// returns [ [ [ [ 4.0, 5.0 ], [ 6.0, 7.0 ] ], [ [ 8.0, 9.0 ], [ 10.0, 11.0 ] ] ] ]
+```
+
+The function accepts the following arguments:
+
+-   **x**: first input ndarray descriptor.
+-   **y**: second input ndarray descriptor.
+-   **z**: third input ndarray descriptor.
+-   **w**: fourth input ndarray descriptor.
+-   **u**: output ndarray descriptor.
+-   **fcn**: quaternary callback.
+
+#### kernel.kernel5d( x, y, z, w, u, fcn )
+
+Applies a quaternary callback to elements in five-dimensional input ndarrays and assigns results to elements in an equivalently shaped output ndarray via loop blocking.
+
+<!-- eslint-disable max-len -->
+
+```javascript
+var Float64Array = require( '@stdlib/array/float64' );
+var ndarray2array = require( '@stdlib/ndarray/base/to-array' );
+var add4 = require( '@stdlib/number/float64/base/add4' );
+
+// Create data buffers:
+var xbuf = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 ] );
+var ybuf = new Float64Array( [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ] );
+var zbuf = new Float64Array( [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ] );
+var wbuf = new Float64Array( [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ] );
+var ubuf = new Float64Array( 8 );
+
+// Define the shape of the input and output arrays:
+var shape = [ 1, 1, 2, 2, 2 ];
+
+// Define the array strides:
+var sx = [ 8, 8, 4, 2, 1 ];
+var sy = [ 8, 8, 4, 2, 1 ];
+var sz = [ 8, 8, 4, 2, 1 ];
+var sw = [ 8, 8, 4, 2, 1 ];
+var su = [ 8, 8, 4, 2, 1 ];
+
+// Create the input and output ndarray-like objects:
+var x = {
+    'dtype': 'float64',
+    'data': xbuf,
+    'shape': shape,
+    'strides': sx,
+    'offset': 0,
+    'order': 'row-major'
+};
+var y = {
+    'dtype': 'float64',
+    'data': ybuf,
+    'shape': shape,
+    'strides': sy,
+    'offset': 0,
+    'order': 'row-major'
+};
+var z = {
+    'dtype': 'float64',
+    'data': zbuf,
+    'shape': shape,
+    'strides': sz,
+    'offset': 0,
+    'order': 'row-major'
+};
+var w = {
+    'dtype': 'float64',
+    'data': wbuf,
+    'shape': shape,
+    'strides': sw,
+    'offset': 0,
+    'order': 'row-major'
+};
+var u = {
+    'dtype': 'float64',
+    'data': ubuf,
+    'shape': shape,
+    'strides': su,
+    'offset': 0,
+    'order': 'row-major'
+};
+
+// Apply the quaternary function:
+kernel.kernel5d( x, y, z, w, u, add4 );
+
+var arr = ndarray2array( u.data, u.shape, u.strides, u.offset, u.order );
+// returns [ [ [ [ [ 4.0, 5.0 ], [ 6.0, 7.0 ] ], [ [ 8.0, 9.0 ], [ 10.0, 11.0 ] ] ] ] ]
+```
+
+The function accepts the following arguments:
+
+-   **x**: first input ndarray descriptor.
+-   **y**: second input ndarray descriptor.
+-   **z**: third input ndarray descriptor.
+-   **w**: fourth input ndarray descriptor.
+-   **u**: output ndarray descriptor.
+-   **fcn**: quaternary callback.
+
+#### kernel.kernel6d( x, y, z, w, u, fcn )
+
+Applies a quaternary callback to elements in six-dimensional input ndarrays and assigns results to elements in an equivalently shaped output ndarray via loop blocking.
+
+<!-- eslint-disable max-len -->
+
+```javascript
+var Float64Array = require( '@stdlib/array/float64' );
+var ndarray2array = require( '@stdlib/ndarray/base/to-array' );
+var add4 = require( '@stdlib/number/float64/base/add4' );
+
+// Create data buffers:
+var xbuf = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 ] );
+var ybuf = new Float64Array( [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ] );
+var zbuf = new Float64Array( [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ] );
+var wbuf = new Float64Array( [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ] );
+var ubuf = new Float64Array( 8 );
+
+// Define the shape of the input and output arrays:
+var shape = [ 1, 1, 1, 2, 2, 2 ];
+
+// Define the array strides:
+var sx = [ 8, 8, 8, 4, 2, 1 ];
+var sy = [ 8, 8, 8, 4, 2, 1 ];
+var sz = [ 8, 8, 8, 4, 2, 1 ];
+var sw = [ 8, 8, 8, 4, 2, 1 ];
+var su = [ 8, 8, 8, 4, 2, 1 ];
+
+// Create the input and output ndarray-like objects:
+var x = {
+    'dtype': 'float64',
+    'data': xbuf,
+    'shape': shape,
+    'strides': sx,
+    'offset': 0,
+    'order': 'row-major'
+};
+var y = {
+    'dtype': 'float64',
+    'data': ybuf,
+    'shape': shape,
+    'strides': sy,
+    'offset': 0,
+    'order': 'row-major'
+};
+var z = {
+    'dtype': 'float64',
+    'data': zbuf,
+    'shape': shape,
+    'strides': sz,
+    'offset': 0,
+    'order': 'row-major'
+};
+var w = {
+    'dtype': 'float64',
+    'data': wbuf,
+    'shape': shape,
+    'strides': sw,
+    'offset': 0,
+    'order': 'row-major'
+};
+var u = {
+    'dtype': 'float64',
+    'data': ubuf,
+    'shape': shape,
+    'strides': su,
+    'offset': 0,
+    'order': 'row-major'
+};
+
+// Apply the quaternary function:
+kernel.kernel6d( x, y, z, w, u, add4 );
+
+var arr = ndarray2array( u.data, u.shape, u.strides, u.offset, u.order );
+// returns [ [ [ [ [ [ 4.0, 5.0 ], [ 6.0, 7.0 ] ], [ [ 8.0, 9.0 ], [ 10.0, 11.0 ] ] ] ] ] ]
+```
+
+The function accepts the following arguments:
+
+-   **x**: first input ndarray descriptor.
+-   **y**: second input ndarray descriptor.
+-   **z**: third input ndarray descriptor.
+-   **w**: fourth input ndarray descriptor.
+-   **u**: output ndarray descriptor.
+-   **fcn**: quaternary callback.
+
+#### kernel.kernel7d( x, y, z, w, u, fcn )
+
+Applies a quaternary callback to elements in seven-dimensional input ndarrays and assigns results to elements in an equivalently shaped output ndarray via loop blocking.
+
+<!-- eslint-disable max-len -->
+
+```javascript
+var Float64Array = require( '@stdlib/array/float64' );
+var ndarray2array = require( '@stdlib/ndarray/base/to-array' );
+var add4 = require( '@stdlib/number/float64/base/add4' );
+
+// Create data buffers:
+var xbuf = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 ] );
+var ybuf = new Float64Array( [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ] );
+var zbuf = new Float64Array( [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ] );
+var wbuf = new Float64Array( [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ] );
+var ubuf = new Float64Array( 8 );
+
+// Define the shape of the input and output arrays:
+var shape = [ 1, 1, 1, 1, 2, 2, 2 ];
+
+// Define the array strides:
+var sx = [ 8, 8, 8, 8, 4, 2, 1 ];
+var sy = [ 8, 8, 8, 8, 4, 2, 1 ];
+var sz = [ 8, 8, 8, 8, 4, 2, 1 ];
+var sw = [ 8, 8, 8, 8, 4, 2, 1 ];
+var su = [ 8, 8, 8, 8, 4, 2, 1 ];
+
+// Create the input and output ndarray-like objects:
+var x = {
+    'dtype': 'float64',
+    'data': xbuf,
+    'shape': shape,
+    'strides': sx,
+    'offset': 0,
+    'order': 'row-major'
+};
+var y = {
+    'dtype': 'float64',
+    'data': ybuf,
+    'shape': shape,
+    'strides': sy,
+    'offset': 0,
+    'order': 'row-major'
+};
+var z = {
+    'dtype': 'float64',
+    'data': zbuf,
+    'shape': shape,
+    'strides': sz,
+    'offset': 0,
+    'order': 'row-major'
+};
+var w = {
+    'dtype': 'float64',
+    'data': wbuf,
+    'shape': shape,
+    'strides': sw,
+    'offset': 0,
+    'order': 'row-major'
+};
+var u = {
+    'dtype': 'float64',
+    'data': ubuf,
+    'shape': shape,
+    'strides': su,
+    'offset': 0,
+    'order': 'row-major'
+};
+
+// Apply the quaternary function:
+kernel.kernel7d( x, y, z, w, u, add4 );
+
+var arr = ndarray2array( u.data, u.shape, u.strides, u.offset, u.order );
+// returns [ [ [ [ [ [ [ 4.0, 5.0 ], [ 6.0, 7.0 ] ], [ [ 8.0, 9.0 ], [ 10.0, 11.0 ] ] ] ] ] ] ]
+```
+
+The function accepts the following arguments:
+
+-   **x**: first input ndarray descriptor.
+-   **y**: second input ndarray descriptor.
+-   **z**: third input ndarray descriptor.
+-   **w**: fourth input ndarray descriptor.
+-   **u**: output ndarray descriptor.
+-   **fcn**: quaternary callback.
+
+#### kernel.kernel8d( x, y, z, w, u, fcn )
+
+Applies a quaternary callback to elements in eight-dimensional input ndarrays and assigns results to elements in an equivalently shaped output ndarray via loop blocking.
+
+<!-- eslint-disable max-len -->
+
+```javascript
+var Float64Array = require( '@stdlib/array/float64' );
+var ndarray2array = require( '@stdlib/ndarray/base/to-array' );
+var add4 = require( '@stdlib/number/float64/base/add4' );
+
+// Create data buffers:
+var xbuf = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 ] );
+var ybuf = new Float64Array( [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ] );
+var zbuf = new Float64Array( [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ] );
+var wbuf = new Float64Array( [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ] );
+var ubuf = new Float64Array( 8 );
+
+// Define the shape of the input and output arrays:
+var shape = [ 1, 1, 1, 1, 1, 2, 2, 2 ];
+
+// Define the array strides:
+var sx = [ 8, 8, 8, 8, 8, 4, 2, 1 ];
+var sy = [ 8, 8, 8, 8, 8, 4, 2, 1 ];
+var sz = [ 8, 8, 8, 8, 8, 4, 2, 1 ];
+var sw = [ 8, 8, 8, 8, 8, 4, 2, 1 ];
+var su = [ 8, 8, 8, 8, 8, 4, 2, 1 ];
+
+// Create the input and output ndarray-like objects:
+var x = {
+    'dtype': 'float64',
+    'data': xbuf,
+    'shape': shape,
+    'strides': sx,
+    'offset': 0,
+    'order': 'row-major'
+};
+var y = {
+    'dtype': 'float64',
+    'data': ybuf,
+    'shape': shape,
+    'strides': sy,
+    'offset': 0,
+    'order': 'row-major'
+};
+var z = {
+    'dtype': 'float64',
+    'data': zbuf,
+    'shape': shape,
+    'strides': sz,
+    'offset': 0,
+    'order': 'row-major'
+};
+var w = {
+    'dtype': 'float64',
+    'data': wbuf,
+    'shape': shape,
+    'strides': sw,
+    'offset': 0,
+    'order': 'row-major'
+};
+var u = {
+    'dtype': 'float64',
+    'data': ubuf,
+    'shape': shape,
+    'strides': su,
+    'offset': 0,
+    'order': 'row-major'
+};
+
+// Apply the quaternary function:
+kernel.kernel8d( x, y, z, w, u, add4 );
+
+var arr = ndarray2array( u.data, u.shape, u.strides, u.offset, u.order );
+// returns [ [ [ [ [ [ [ [ 4.0, 5.0 ], [ 6.0, 7.0 ] ], [ [ 8.0, 9.0 ], [ 10.0, 11.0 ] ] ] ] ] ] ] ]
+```
+
+The function accepts the following arguments:
+
+-   **x**: first input ndarray descriptor.
+-   **y**: second input ndarray descriptor.
+-   **z**: third input ndarray descriptor.
+-   **w**: fourth input ndarray descriptor.
+-   **u**: output ndarray descriptor.
+-   **fcn**: quaternary callback.
+
+#### kernel.kernel9d( x, y, z, w, u, fcn )
+
+Applies a quaternary callback to elements in nine-dimensional input ndarrays and assigns results to elements in an equivalently shaped output ndarray via loop blocking.
+
+<!-- eslint-disable max-len -->
+
+```javascript
+var Float64Array = require( '@stdlib/array/float64' );
+var ndarray2array = require( '@stdlib/ndarray/base/to-array' );
+var add4 = require( '@stdlib/number/float64/base/add4' );
+
+// Create data buffers:
+var xbuf = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 ] );
+var ybuf = new Float64Array( [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ] );
+var zbuf = new Float64Array( [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ] );
+var wbuf = new Float64Array( [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ] );
+var ubuf = new Float64Array( 8 );
+
+// Define the shape of the input and output arrays:
+var shape = [ 1, 1, 1, 1, 1, 1, 2, 2, 2 ];
+
+// Define the array strides:
+var sx = [ 8, 8, 8, 8, 8, 8, 4, 2, 1 ];
+var sy = [ 8, 8, 8, 8, 8, 8, 4, 2, 1 ];
+var sz = [ 8, 8, 8, 8, 8, 8, 4, 2, 1 ];
+var sw = [ 8, 8, 8, 8, 8, 8, 4, 2, 1 ];
+var su = [ 8, 8, 8, 8, 8, 8, 4, 2, 1 ];
+
+// Create the input and output ndarray-like objects:
+var x = {
+    'dtype': 'float64',
+    'data': xbuf,
+    'shape': shape,
+    'strides': sx,
+    'offset': 0,
+    'order': 'row-major'
+};
+var y = {
+    'dtype': 'float64',
+    'data': ybuf,
+    'shape': shape,
+    'strides': sy,
+    'offset': 0,
+    'order': 'row-major'
+};
+var z = {
+    'dtype': 'float64',
+    'data': zbuf,
+    'shape': shape,
+    'strides': sz,
+    'offset': 0,
+    'order': 'row-major'
+};
+var w = {
+    'dtype': 'float64',
+    'data': wbuf,
+    'shape': shape,
+    'strides': sw,
+    'offset': 0,
+    'order': 'row-major'
+};
+var u = {
+    'dtype': 'float64',
+    'data': ubuf,
+    'shape': shape,
+    'strides': su,
+    'offset': 0,
+    'order': 'row-major'
+};
+
+// Apply the quaternary function:
+kernel.kernel9d( x, y, z, w, u, add4 );
+
+var arr = ndarray2array( u.data, u.shape, u.strides, u.offset, u.order );
+// returns [ [ [ [ [ [ [ [ [ 4.0, 5.0 ], [ 6.0, 7.0 ] ], [ [ 8.0, 9.0 ], [ 10.0, 11.0 ] ] ] ] ] ] ] ] ]
+```
+
+The function accepts the following arguments:
+
+-   **x**: first input ndarray descriptor.
+-   **y**: second input ndarray descriptor.
+-   **z**: third input ndarray descriptor.
+-   **w**: fourth input ndarray descriptor.
+-   **u**: output ndarray descriptor.
+-   **fcn**: quaternary callback.
+
+#### kernel.kernel10d( x, y, z, w, u, fcn )
+
+Applies a quaternary callback to elements in ten-dimensional input ndarrays and assigns results to elements in an equivalently shaped output ndarray via loop blocking.
+
+<!-- eslint-disable max-len -->
+
+```javascript
+var Float64Array = require( '@stdlib/array/float64' );
+var ndarray2array = require( '@stdlib/ndarray/base/to-array' );
+var add4 = require( '@stdlib/number/float64/base/add4' );
+
+// Create data buffers:
+var xbuf = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 ] );
+var ybuf = new Float64Array( [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ] );
+var zbuf = new Float64Array( [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ] );
+var wbuf = new Float64Array( [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ] );
+var ubuf = new Float64Array( 8 );
+
+// Define the shape of the input and output arrays:
+var shape = [ 1, 1, 1, 1, 1, 1, 1, 2, 2, 2 ];
+
+// Define the array strides:
+var sx = [ 8, 8, 8, 8, 8, 8, 8, 4, 2, 1 ];
+var sy = [ 8, 8, 8, 8, 8, 8, 8, 4, 2, 1 ];
+var sz = [ 8, 8, 8, 8, 8, 8, 8, 4, 2, 1 ];
+var sw = [ 8, 8, 8, 8, 8, 8, 8, 4, 2, 1 ];
+var su = [ 8, 8, 8, 8, 8, 8, 8, 4, 2, 1 ];
+
+// Create the input and output ndarray-like objects:
+var x = {
+    'dtype': 'float64',
+    'data': xbuf,
+    'shape': shape,
+    'strides': sx,
+    'offset': 0,
+    'order': 'row-major'
+};
+var y = {
+    'dtype': 'float64',
+    'data': ybuf,
+    'shape': shape,
+    'strides': sy,
+    'offset': 0,
+    'order': 'row-major'
+};
+var z = {
+    'dtype': 'float64',
+    'data': zbuf,
+    'shape': shape,
+    'strides': sz,
+    'offset': 0,
+    'order': 'row-major'
+};
+var w = {
+    'dtype': 'float64',
+    'data': wbuf,
+    'shape': shape,
+    'strides': sw,
+    'offset': 0,
+    'order': 'row-major'
+};
+var u = {
+    'dtype': 'float64',
+    'data': ubuf,
+    'shape': shape,
+    'strides': su,
+    'offset': 0,
+    'order': 'row-major'
+};
+
+// Apply the quaternary function:
+kernel.kernel10d( x, y, z, w, u, add4 );
+
+var arr = ndarray2array( u.data, u.shape, u.strides, u.offset, u.order );
+// returns [ [ [ [ [ [ [ [ [ [ 4.0, 5.0 ], [ 6.0, 7.0 ] ], [ [ 8.0, 9.0 ], [ 10.0, 11.0 ] ] ] ] ] ] ] ] ] ]
+```
+
+The function accepts the following arguments:
+
+-   **x**: first input ndarray descriptor.
+-   **y**: second input ndarray descriptor.
+-   **z**: third input ndarray descriptor.
+-   **w**: fourth input ndarray descriptor.
+-   **u**: output ndarray descriptor.
+-   **fcn**: quaternary callback.
+
+</section>
+
+<!-- /.usage -->
+
+<section class="notes">
+
+## Notes
+
+-   The quaternary callback is expected to have the following signature:
+
+    ```text
+    fcn( v1, v2, v3, v4 )
+    ```
+
+    where
+
+    -   **v1**: element from the first input ndarray.
+    -   **v2**: element from the second input ndarray.
+    -   **v3**: element from the third input ndarray.
+    -   **v4**: element from the fourth input ndarray.
+
+</section>
+
+<!-- /.notes -->
+
+<section class="examples">
+
+## Examples
+
+<!-- eslint no-undef: "error" -->
+
+```javascript
+var Float64Array = require( '@stdlib/array/float64' );
+var ndarray2array = require( '@stdlib/ndarray/base/to-array' );
+var add4 = require( '@stdlib/number/float64/base/add4' );
+var kernel = require( '@stdlib/ndarray/base/kernels/generic/quaternary/blocked' );
+
+// Create data buffers:
+var xbuf = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] );
+var ybuf = new Float64Array( [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ] );
+var zbuf = new Float64Array( [ 2.0, 2.0, 2.0, 2.0, 2.0, 2.0 ] );
+var wbuf = new Float64Array( [ 3.0, 3.0, 3.0, 3.0, 3.0, 3.0 ] );
+var ubuf = new Float64Array( 6 );
+
+// Define the array shapes:
+var shape = [ 3, 2 ];
+
+// Create the input and output ndarray-like objects:
+var x = {
+    'dtype': 'float64',
+    'data': xbuf,
+    'shape': shape,
+    'strides': [ 2, 1 ],
+    'offset': 0,
+    'order': 'row-major'
+};
+var y = {
+    'dtype': 'float64',
+    'data': ybuf,
+    'shape': shape,
+    'strides': [ 2, 1 ],
+    'offset': 0,
+    'order': 'row-major'
+};
+var z = {
+    'dtype': 'float64',
+    'data': zbuf,
+    'shape': shape,
+    'strides': [ 2, 1 ],
+    'offset': 0,
+    'order': 'row-major'
+};
+var w = {
+    'dtype': 'float64',
+    'data': wbuf,
+    'shape': shape,
+    'strides': [ 2, 1 ],
+    'offset': 0,
+    'order': 'row-major'
+};
+var u = {
+    'dtype': 'float64',
+    'data': ubuf,
+    'shape': shape,
+    'strides': [ 2, 1 ],
+    'offset': 0,
+    'order': 'row-major'
+};
+
+// Resolve a kernel:
+var f = kernel( 2 );
+
+// Apply the quaternary function:
+f( x, y, z, w, u, add4 );
+
+console.log( ndarray2array( u.data, u.shape, u.strides, u.offset, u.order ) );
+// => [ [ 7.0, 8.0 ], [ 9.0, 10.0 ], [ 11.0, 12.0 ] ]
+```
+
+</section>
+
+<!-- /.examples -->
+
+<!-- Section for related `stdlib` packages. Do not manually edit this section, as it is automatically populated. -->
+
+<section class="related">
+
+</section>
+
+<!-- /.related -->
+
+<section class="links">
+
+</section>
+
+<!-- /.links -->
diff --git a/lib/node_modules/@stdlib/ndarray/base/kernels/generic/quaternary/blocked/benchmark/benchmark.2d.js b/lib/node_modules/@stdlib/ndarray/base/kernels/generic/quaternary/blocked/benchmark/benchmark.2d.js
new file mode 100644
index 000000000000..a8554a463f0a
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/kernels/generic/quaternary/blocked/benchmark/benchmark.2d.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.
+*/
+
+'use strict';
+
+// MODULES //
+
+var bench = require( '@stdlib/bench' );
+var isnan = require( '@stdlib/math/base/assert/is-nan' );
+var discreteUniform = require( '@stdlib/random/array/discrete-uniform' );
+var pow = require( '@stdlib/math/base/special/pow' );
+var sqrt = require( '@stdlib/math/base/special/sqrt' );
+var floor = require( '@stdlib/math/base/special/floor' );
+var filledarray = require( '@stdlib/array/filled' );
+var add4 = require( '@stdlib/number/float64/base/add4' );
+var shape2strides = require( '@stdlib/ndarray/base/shape2strides' );
+var strides2offset = require( '@stdlib/ndarray/base/strides2offset' );
+var descriptor = require( '@stdlib/ndarray/base/descriptor' );
+var orders = require( '@stdlib/ndarray/orders' );
+var format = require( '@stdlib/string/format' );
+var pkg = require( './../package.json' ).name;
+var kernel = require( './../lib' );
+
+
+// VARIABLES //
+
+var TYPES = [
+	'float64'
+];
+var ORDERS = orders();
+
+/**
+* Creates a benchmark function.
+*
+* @private
+* @param {PositiveInteger} len - ndarray length
+* @param {NonNegativeIntegerArray} shape - ndarray shape
+* @param {string} xtype - input ndarray data type
+* @param {string} utype - output ndarray data type
+* @param {string} order - memory layout
+* @returns {Function} benchmark function
+*/
+function createBenchmark( len, shape, xtype, utype, order ) {
+	var opts;
+	var st;
+	var x;
+	var y;
+	var z;
+	var w;
+	var u;
+	var f;
+
+	st = shape2strides( shape, order );
+	opts = {
+		'dtype': xtype
+	};
+	x = discreteUniform( len, -100, 100, opts );
+	y = discreteUniform( len, -100, 100, opts );
+	z = discreteUniform( len, -100, 100, opts );
+	w = discreteUniform( len, -100, 100, opts );
+	u = filledarray( 0.0, len, utype );
+
+	x = descriptor( xtype, x, shape, st, strides2offset( shape, st ), order );
+	y = descriptor( xtype, y, shape, st, strides2offset( shape, st ), order );
+	z = descriptor( xtype, z, shape, st, strides2offset( shape, st ), order );
+	w = descriptor( xtype, w, shape, st, strides2offset( shape, st ), order );
+	u = descriptor( utype, u, shape, st, strides2offset( shape, st ), order );
+
+	f = kernel( shape.length );
+	return benchmark;
+
+	/**
+	* Benchmark function.
+	*
+	* @private
+	* @param {Benchmark} b - benchmark instance
+	*/
+	function benchmark( b ) {
+		var i;
+
+		b.tic();
+		for ( i = 0; i < b.iterations; i++ ) {
+			f( x, y, z, w, u, add4 );
+			if ( isnan( u.data[ i%len ] ) ) {
+				b.fail( 'should not return NaN' );
+			}
+		}
+		b.toc();
+		if ( isnan( u.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 ord;
+	var sh;
+	var t1;
+	var t2;
+	var f;
+	var i;
+	var j;
+	var k;
+
+	min = 1; // 10^min
+	max = 6; // 10^max
+
+	for ( k = 0; k < ORDERS.length; k++ ) {
+		ord = ORDERS[ k ];
+		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, ord );
+				bench( format( '%s:ndims=%d,len=%d,shape=[%s],xorder=%s,uorder=%s,xtype=%s,utype=%s', pkg, sh.length, len, sh.join(','), ord, ord, t1, t2 ), f );
+
+				sh = [ 2, len/2 ];
+				f = createBenchmark( len, sh, t1, t2, ord );
+				bench( format( '%s:ndims=%d,len=%d,shape=[%s],xorder=%s,uorder=%s,xtype=%s,utype=%s', pkg, sh.length, len, sh.join(','), ord, ord, t1, t2 ), f );
+
+				len = floor( sqrt( len ) );
+				sh = [ len, len ];
+				len *= len;
+				f = createBenchmark( len, sh, t1, t2, ord );
+				bench( format( '%s:ndims=%d,len=%d,shape=[%s],xorder=%s,uorder=%s,xtype=%s,utype=%s', pkg, sh.length, len, sh.join(','), ord, ord, t1, t2 ), f );
+			}
+		}
+	}
+}
+
+main();
diff --git a/lib/node_modules/@stdlib/ndarray/base/kernels/generic/quaternary/blocked/benchmark/benchmark.3d.js b/lib/node_modules/@stdlib/ndarray/base/kernels/generic/quaternary/blocked/benchmark/benchmark.3d.js
new file mode 100644
index 000000000000..07656da3f2ca
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/kernels/generic/quaternary/blocked/benchmark/benchmark.3d.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.
+*/
+
+'use strict';
+
+// MODULES //
+
+var bench = require( '@stdlib/bench' );
+var isnan = require( '@stdlib/math/base/assert/is-nan' );
+var discreteUniform = require( '@stdlib/random/array/discrete-uniform' );
+var pow = require( '@stdlib/math/base/special/pow' );
+var cbrt = require( '@stdlib/math/base/special/cbrt' );
+var floor = require( '@stdlib/math/base/special/floor' );
+var filledarray = require( '@stdlib/array/filled' );
+var add4 = require( '@stdlib/number/float64/base/add4' );
+var shape2strides = require( '@stdlib/ndarray/base/shape2strides' );
+var strides2offset = require( '@stdlib/ndarray/base/strides2offset' );
+var descriptor = require( '@stdlib/ndarray/base/descriptor' );
+var orders = require( '@stdlib/ndarray/orders' );
+var format = require( '@stdlib/string/format' );
+var pkg = require( './../package.json' ).name;
+var kernel = require( './../lib' );
+
+
+// VARIABLES //
+
+var TYPES = [
+	'float64'
+];
+var ORDERS = orders();
+
+/**
+* Creates a benchmark function.
+*
+* @private
+* @param {PositiveInteger} len - ndarray length
+* @param {NonNegativeIntegerArray} shape - ndarray shape
+* @param {string} xtype - input ndarray data type
+* @param {string} utype - output ndarray data type
+* @param {string} order - memory layout
+* @returns {Function} benchmark function
+*/
+function createBenchmark( len, shape, xtype, utype, order ) {
+	var opts;
+	var st;
+	var x;
+	var y;
+	var z;
+	var w;
+	var u;
+	var f;
+
+	st = shape2strides( shape, order );
+	opts = {
+		'dtype': xtype
+	};
+	x = discreteUniform( len, -100, 100, opts );
+	y = discreteUniform( len, -100, 100, opts );
+	z = discreteUniform( len, -100, 100, opts );
+	w = discreteUniform( len, -100, 100, opts );
+	u = filledarray( 0.0, len, utype );
+
+	x = descriptor( xtype, x, shape, st, strides2offset( shape, st ), order );
+	y = descriptor( xtype, y, shape, st, strides2offset( shape, st ), order );
+	z = descriptor( xtype, z, shape, st, strides2offset( shape, st ), order );
+	w = descriptor( xtype, w, shape, st, strides2offset( shape, st ), order );
+	u = descriptor( utype, u, shape, st, strides2offset( shape, st ), order );
+
+	f = kernel( shape.length );
+	return benchmark;
+
+	/**
+	* Benchmark function.
+	*
+	* @private
+	* @param {Benchmark} b - benchmark instance
+	*/
+	function benchmark( b ) {
+		var i;
+
+		b.tic();
+		for ( i = 0; i < b.iterations; i++ ) {
+			f( x, y, z, w, u, add4 );
+			if ( isnan( u.data[ i%len ] ) ) {
+				b.fail( 'should not return NaN' );
+			}
+		}
+		b.toc();
+		if ( isnan( u.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 ord;
+	var sh;
+	var t1;
+	var t2;
+	var f;
+	var i;
+	var j;
+	var k;
+
+	min = 1; // 10^min
+	max = 6; // 10^max
+
+	for ( k = 0; k < ORDERS.length; k++ ) {
+		ord = ORDERS[ k ];
+		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, ord );
+				bench( format( '%s:ndims=%d,len=%d,shape=[%s],xorder=%s,uorder=%s,xtype=%s,utype=%s', pkg, sh.length, len, sh.join(','), ord, ord, t1, t2 ), f );
+
+				sh = [ 1, 2, len/2 ];
+				f = createBenchmark( len, sh, t1, t2, ord );
+				bench( format( '%s:ndims=%d,len=%d,shape=[%s],xorder=%s,uorder=%s,xtype=%s,utype=%s', pkg, sh.length, len, sh.join(','), ord, ord, t1, t2 ), f );
+
+				len = floor( cbrt( len ) );
+				sh = [ len, len, len ];
+				len *= len * len;
+				f = createBenchmark( len, sh, t1, t2, ord );
+				bench( format( '%s:ndims=%d,len=%d,shape=[%s],xorder=%s,uorder=%s,xtype=%s,utype=%s', pkg, sh.length, len, sh.join(','), ord, ord, t1, t2 ), f );
+			}
+		}
+	}
+}
+
+main();
diff --git a/lib/node_modules/@stdlib/ndarray/base/kernels/generic/quaternary/blocked/docs/repl.txt b/lib/node_modules/@stdlib/ndarray/base/kernels/generic/quaternary/blocked/docs/repl.txt
new file mode 100644
index 000000000000..c3e288d70c95
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/kernels/generic/quaternary/blocked/docs/repl.txt
@@ -0,0 +1,271 @@
+
+{{alias}}( ndims )
+    Returns a kernel for applying a quaternary callback to elements in four
+    input ndarrays and assigning results to elements in an output ndarray using
+    loop blocking.
+
+    The returned function has the following parameters:
+
+    - x: first input ndarray descriptor (object with `dtype`, `data`, `shape`,
+    `strides`, `offset`, `order`).
+    - y: second input ndarray descriptor.
+    - z: third input ndarray descriptor.
+    - w: fourth input ndarray descriptor.
+    - u: output ndarray descriptor.
+    - fcn: quaternary callback accepting four scalar values and returning one
+    scalar value.
+
+    If `ndims` is less than `2` or greater than the maximum number of supported
+    dimensions, the function returns `null`.
+
+    Parameters
+    ----------
+    ndims: integer
+        Number of dimensions.
+
+    Returns
+    -------
+    fcn: Function|null
+        Kernel function.
+
+    Examples
+    --------
+    > var f = {{alias}}( 2 )
+    <Function>
+
+
+{{alias}}.kernel2d( x, y, z, w, u, fcn )
+    Applies a quaternary callback to elements in two-dimensional input ndarrays
+    and assigns results to elements in an equivalently shaped output ndarray via
+    loop blocking.
+
+    Parameters
+    ----------
+    x: Object
+        First input ndarray descriptor.
+
+    y: Object
+        Second input ndarray descriptor.
+
+    z: Object
+        Third input ndarray descriptor.
+
+    w: Object
+        Fourth input ndarray descriptor.
+
+    u: Object
+        Output ndarray descriptor.
+
+    fcn: Function
+        Quaternary callback.
+
+
+{{alias}}.kernel3d( x, y, z, w, u, fcn )
+    Applies a quaternary callback to elements in three-dimensional input
+    ndarrays and assigns results to elements in an equivalently shaped output
+    ndarray via loop blocking.
+
+    Parameters
+    ----------
+    x: Object
+        First input ndarray descriptor.
+
+    y: Object
+        Second input ndarray descriptor.
+
+    z: Object
+        Third input ndarray descriptor.
+
+    w: Object
+        Fourth input ndarray descriptor.
+
+    u: Object
+        Output ndarray descriptor.
+
+    fcn: Function
+        Quaternary callback.
+
+
+{{alias}}.kernel4d( x, y, z, w, u, fcn )
+    Applies a quaternary callback to elements in four-dimensional input ndarrays
+    and assigns results to elements in an equivalently shaped output ndarray via
+    loop blocking.
+
+    Parameters
+    ----------
+    x: Object
+        First input ndarray descriptor.
+
+    y: Object
+        Second input ndarray descriptor.
+
+    z: Object
+        Third input ndarray descriptor.
+
+    w: Object
+        Fourth input ndarray descriptor.
+
+    u: Object
+        Output ndarray descriptor.
+
+    fcn: Function
+        Quaternary callback.
+
+
+{{alias}}.kernel5d( x, y, z, w, u, fcn )
+    Applies a quaternary callback to elements in five-dimensional input ndarrays
+    and assigns results to elements in an equivalently shaped output ndarray via
+    loop blocking.
+
+    Parameters
+    ----------
+    x: Object
+        First input ndarray descriptor.
+
+    y: Object
+        Second input ndarray descriptor.
+
+    z: Object
+        Third input ndarray descriptor.
+
+    w: Object
+        Fourth input ndarray descriptor.
+
+    u: Object
+        Output ndarray descriptor.
+
+    fcn: Function
+        Quaternary callback.
+
+
+{{alias}}.kernel6d( x, y, z, w, u, fcn )
+    Applies a quaternary callback to elements in six-dimensional input ndarrays
+    and assigns results to elements in an equivalently shaped output ndarray via
+    loop blocking.
+
+    Parameters
+    ----------
+    x: Object
+        First input ndarray descriptor.
+
+    y: Object
+        Second input ndarray descriptor.
+
+    z: Object
+        Third input ndarray descriptor.
+
+    w: Object
+        Fourth input ndarray descriptor.
+
+    u: Object
+        Output ndarray descriptor.
+
+    fcn: Function
+        Quaternary callback.
+
+
+{{alias}}.kernel7d( x, y, z, w, u, fcn )
+    Applies a quaternary callback to elements in seven-dimensional input
+    ndarrays and assigns results to elements in an equivalently shaped output
+    ndarray via loop blocking.
+
+    Parameters
+    ----------
+    x: Object
+        First input ndarray descriptor.
+
+    y: Object
+        Second input ndarray descriptor.
+
+    z: Object
+        Third input ndarray descriptor.
+
+    w: Object
+        Fourth input ndarray descriptor.
+
+    u: Object
+        Output ndarray descriptor.
+
+    fcn: Function
+        Quaternary callback.
+
+
+{{alias}}.kernel8d( x, y, z, w, u, fcn )
+    Applies a quaternary callback to elements in eight-dimensional input
+    ndarrays and assigns results to elements in an equivalently shaped output
+    ndarray via loop blocking.
+
+    Parameters
+    ----------
+    x: Object
+        First input ndarray descriptor.
+
+    y: Object
+        Second input ndarray descriptor.
+
+    z: Object
+        Third input ndarray descriptor.
+
+    w: Object
+        Fourth input ndarray descriptor.
+
+    u: Object
+        Output ndarray descriptor.
+
+    fcn: Function
+        Quaternary callback.
+
+
+{{alias}}.kernel9d( x, y, z, w, u, fcn )
+    Applies a quaternary callback to elements in nine-dimensional input ndarrays
+    and assigns results to elements in an equivalently shaped output ndarray via
+    loop blocking.
+
+    Parameters
+    ----------
+    x: Object
+        First input ndarray descriptor.
+
+    y: Object
+        Second input ndarray descriptor.
+
+    z: Object
+        Third input ndarray descriptor.
+
+    w: Object
+        Fourth input ndarray descriptor.
+
+    u: Object
+        Output ndarray descriptor.
+
+    fcn: Function
+        Quaternary callback.
+
+
+{{alias}}.kernel10d( x, y, z, w, u, fcn )
+    Applies a quaternary callback to elements in ten-dimensional input ndarrays
+    and assigns results to elements in an equivalently shaped output ndarray via
+    loop blocking.
+
+    Parameters
+    ----------
+    x: Object
+        First input ndarray descriptor.
+
+    y: Object
+        Second input ndarray descriptor.
+
+    z: Object
+        Third input ndarray descriptor.
+
+    w: Object
+        Fourth input ndarray descriptor.
+
+    u: Object
+        Output ndarray descriptor.
+
+    fcn: Function
+        Quaternary callback.
+
+    See Also
+    --------
diff --git a/lib/node_modules/@stdlib/ndarray/base/kernels/generic/quaternary/blocked/examples/index.js b/lib/node_modules/@stdlib/ndarray/base/kernels/generic/quaternary/blocked/examples/index.js
new file mode 100644
index 000000000000..de504ac57524
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/kernels/generic/quaternary/blocked/examples/index.js
@@ -0,0 +1,85 @@
+/**
+* @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 Float64Array = require( '@stdlib/array/float64' );
+var ndarray2array = require( '@stdlib/ndarray/base/to-array' );
+var add4 = require( '@stdlib/number/float64/base/add4' );
+var kernel = require( './../lib' );
+
+// Create data buffers:
+var xbuf = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] );
+var ybuf = new Float64Array( [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ] );
+var zbuf = new Float64Array( [ 2.0, 2.0, 2.0, 2.0, 2.0, 2.0 ] );
+var wbuf = new Float64Array( [ 3.0, 3.0, 3.0, 3.0, 3.0, 3.0 ] );
+var ubuf = new Float64Array( 6 );
+
+// Define the array shapes:
+var shape = [ 3, 2 ];
+
+// Create the input and output ndarray-like objects:
+var x = {
+	'dtype': 'float64',
+	'data': xbuf,
+	'shape': shape,
+	'strides': [ 2, 1 ],
+	'offset': 0,
+	'order': 'row-major'
+};
+var y = {
+	'dtype': 'float64',
+	'data': ybuf,
+	'shape': shape,
+	'strides': [ 2, 1 ],
+	'offset': 0,
+	'order': 'row-major'
+};
+var z = {
+	'dtype': 'float64',
+	'data': zbuf,
+	'shape': shape,
+	'strides': [ 2, 1 ],
+	'offset': 0,
+	'order': 'row-major'
+};
+var w = {
+	'dtype': 'float64',
+	'data': wbuf,
+	'shape': shape,
+	'strides': [ 2, 1 ],
+	'offset': 0,
+	'order': 'row-major'
+};
+var u = {
+	'dtype': 'float64',
+	'data': ubuf,
+	'shape': shape,
+	'strides': [ 2, 1 ],
+	'offset': 0,
+	'order': 'row-major'
+};
+
+// Resolve a kernel:
+var f = kernel( 2 );
+
+// Apply the quaternary function:
+f( x, y, z, w, u, add4 );
+
+console.log( ndarray2array( u.data, u.shape, u.strides, u.offset, u.order ) );
+// => [ [ 7.0, 8.0 ], [ 9.0, 10.0 ], [ 11.0, 12.0 ] ]
diff --git a/lib/node_modules/@stdlib/ndarray/base/kernels/generic/quaternary/blocked/lib/10d.js b/lib/node_modules/@stdlib/ndarray/base/kernels/generic/quaternary/blocked/lib/10d.js
new file mode 100644
index 000000000000..0ebf8a44ec67
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/kernels/generic/quaternary/blocked/lib/10d.js
@@ -0,0 +1,601 @@
+/**
+* @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, max-lines-per-function, max-len */
+
+'use strict';
+
+// MODULES //
+
+var loopOrder = require( '@stdlib/ndarray/base/quaternary-loop-interchange-order' );
+var blockSize = require( '@stdlib/ndarray/base/quaternary-tiling-block-size' );
+
+
+// MAIN //
+
+/**
+* Applies a quaternary callback to elements in ten-dimensional input ndarrays and assigns results 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 input 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 {Object} z - object containing input ndarray meta data
+* @param {*} z.dtype - data type
+* @param {Collection} z.data - data buffer
+* @param {NonNegativeIntegerArray} z.shape - dimensions
+* @param {IntegerArray} z.strides - stride lengths
+* @param {NonNegativeInteger} z.offset - index offset
+* @param {string} z.order - specifies whether `z` is row-major (C-style) or column-major (Fortran-style)
+* @param {Object} w - object containing input ndarray meta data
+* @param {*} w.dtype - data type
+* @param {Collection} w.data - data buffer
+* @param {NonNegativeIntegerArray} w.shape - dimensions
+* @param {IntegerArray} w.strides - stride lengths
+* @param {NonNegativeInteger} w.offset - index offset
+* @param {string} w.order - specifies whether `w` is row-major (C-style) or column-major (Fortran-style)
+* @param {Object} u - object containing output ndarray meta data
+* @param {*} u.dtype - data type
+* @param {Collection} u.data - data buffer
+* @param {NonNegativeIntegerArray} u.shape - dimensions
+* @param {IntegerArray} u.strides - stride lengths
+* @param {NonNegativeInteger} u.offset - index offset
+* @param {string} u.order - specifies whether `u` is row-major (C-style) or column-major (Fortran-style)
+* @param {Callback} fcn - quaternary callback
+*
+* @example
+* var Float64Array = require( '@stdlib/array/float64' );
+* var ndarray2array = require( '@stdlib/ndarray/base/to-array' );
+* var add4 = require( '@stdlib/number/float64/base/add4' );
+*
+* // Create data buffers:
+* var xbuf = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 ] );
+* var ybuf = new Float64Array( [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ] );
+* var zbuf = new Float64Array( [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ] );
+* var wbuf = new Float64Array( [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ] );
+* var ubuf = new Float64Array( 8 );
+*
+* // Define the shape of the input and output arrays:
+* var shape = [ 1, 1, 1, 1, 1, 1, 1, 2, 2, 2 ];
+*
+* // Define the array strides:
+* var sx = [ 8, 8, 8, 8, 8, 8, 8, 4, 2, 1 ];
+* var sy = [ 8, 8, 8, 8, 8, 8, 8, 4, 2, 1 ];
+* var sz = [ 8, 8, 8, 8, 8, 8, 8, 4, 2, 1 ];
+* var sw = [ 8, 8, 8, 8, 8, 8, 8, 4, 2, 1 ];
+* var su = [ 8, 8, 8, 8, 8, 8, 8, 4, 2, 1 ];
+*
+* // Define the index offsets:
+* var ox = 0;
+* var oy = 0;
+* var oz = 0;
+* var ow = 0;
+* var ou = 0;
+*
+* // Create the input and output ndarray-like objects:
+* var x = {
+*     'dtype': 'float64',
+*     'data': xbuf,
+*     'shape': shape,
+*     'strides': sx,
+*     'offset': ox,
+*     'order': 'row-major'
+* };
+* var y = {
+*     'dtype': 'float64',
+*     'data': ybuf,
+*     'shape': shape,
+*     'strides': sy,
+*     'offset': oy,
+*     'order': 'row-major'
+* };
+* var z = {
+*     'dtype': 'float64',
+*     'data': zbuf,
+*     'shape': shape,
+*     'strides': sz,
+*     'offset': oz,
+*     'order': 'row-major'
+* };
+* var w = {
+*     'dtype': 'float64',
+*     'data': wbuf,
+*     'shape': shape,
+*     'strides': sw,
+*     'offset': ow,
+*     'order': 'row-major'
+* };
+* var u = {
+*     'dtype': 'float64',
+*     'data': ubuf,
+*     'shape': shape,
+*     'strides': su,
+*     'offset': ou,
+*     'order': 'row-major'
+* };
+*
+* // Apply the quaternary function:
+* blockedquaternary10d( x, y, z, w, u, add4 );
+*
+* var arr = ndarray2array( u.data, u.shape, u.strides, u.offset, u.order );
+* // returns [ [ [ [ [ [ [ [ [ [ 4.0, 5.0 ], [ 6.0, 7.0 ] ], [ [ 8.0, 9.0 ], [ 10.0, 11.0 ] ] ] ] ] ] ] ] ] ]
+*/
+function blockedquaternary10d( x, y, z, w, u, fcn ) {
+	var bsize;
+	var xbuf;
+	var ybuf;
+	var zbuf;
+	var wbuf;
+	var ubuf;
+	var dx0;
+	var dx1;
+	var dx2;
+	var dx3;
+	var dx4;
+	var dx5;
+	var dx6;
+	var dx7;
+	var dx8;
+	var dx9;
+	var dy0;
+	var dy1;
+	var dy2;
+	var dy3;
+	var dy4;
+	var dy5;
+	var dy6;
+	var dy7;
+	var dy8;
+	var dy9;
+	var dz0;
+	var dz1;
+	var dz2;
+	var dz3;
+	var dz4;
+	var dz5;
+	var dz6;
+	var dz7;
+	var dz8;
+	var dz9;
+	var dw0;
+	var dw1;
+	var dw2;
+	var dw3;
+	var dw4;
+	var dw5;
+	var dw6;
+	var dw7;
+	var dw8;
+	var dw9;
+	var du0;
+	var du1;
+	var du2;
+	var du3;
+	var du4;
+	var du5;
+	var du6;
+	var du7;
+	var du8;
+	var du9;
+	var ox1;
+	var ox2;
+	var ox3;
+	var ox4;
+	var ox5;
+	var ox6;
+	var ox7;
+	var ox8;
+	var ox9;
+	var oy1;
+	var oy2;
+	var oy3;
+	var oy4;
+	var oy5;
+	var oy6;
+	var oy7;
+	var oy8;
+	var oy9;
+	var oz1;
+	var oz2;
+	var oz3;
+	var oz4;
+	var oz5;
+	var oz6;
+	var oz7;
+	var oz8;
+	var oz9;
+	var ow1;
+	var ow2;
+	var ow3;
+	var ow4;
+	var ow5;
+	var ow6;
+	var ow7;
+	var ow8;
+	var ow9;
+	var ou1;
+	var ou2;
+	var ou3;
+	var ou4;
+	var ou5;
+	var ou6;
+	var ou7;
+	var ou8;
+	var ou9;
+	var sh;
+	var s0;
+	var s1;
+	var s2;
+	var s3;
+	var s4;
+	var s5;
+	var s6;
+	var s7;
+	var s8;
+	var s9;
+	var sx;
+	var sy;
+	var sz;
+	var sw;
+	var su;
+	var ox;
+	var oy;
+	var oz;
+	var ow;
+	var ou;
+	var ix;
+	var iy;
+	var iz;
+	var iw;
+	var iu;
+	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#, dx#, dy#, dz#, dw#, du#, i#, j# where # corresponds to the loop number, with `0` being the innermost loop...
+
+	// Resolve the loop interchange order:
+	o = loopOrder( x.shape, x.strides, y.strides, z.strides, w.strides, u.strides );
+	sh = o.sh;
+	sx = o.sx;
+	sy = o.sy;
+	sz = o.sz;
+	sw = o.sw;
+	su = o.su;
+
+	// Determine the block size:
+	bsize = blockSize( x.dtype, y.dtype, z.dtype, w.dtype, u.dtype );
+
+	// Cache the indices of the first indexed elements in the respective ndarrays...
+	ox = x.offset;
+	oy = y.offset;
+	oz = z.offset;
+	ow = w.offset;
+	ou = u.offset;
+
+	// Cache references to the input and output ndarray buffers...
+	xbuf = x.data;
+	ybuf = y.data;
+	zbuf = z.data;
+	wbuf = w.data;
+	ubuf = u.data;
+
+	// Cache offset increments for the innermost loop...
+	dx0 = sx[0];
+	dy0 = sy[0];
+	dz0 = sz[0];
+	dw0 = sw[0];
+	du0 = su[0];
+
+	// Iterate over blocks...
+	for ( j9 = sh[9]; j9 > 0; ) {
+		if ( j9 < bsize ) {
+			s9 = j9;
+			j9 = 0;
+		} else {
+			s9 = bsize;
+			j9 -= bsize;
+		}
+		ox9 = ox + ( j9*sx[9] );
+		oy9 = oy + ( j9*sy[9] );
+		oz9 = oz + ( j9*sz[9] );
+		ow9 = ow + ( j9*sw[9] );
+		ou9 = ou + ( j9*su[9] );
+		for ( j8 = sh[8]; j8 > 0; ) {
+			if ( j8 < bsize ) {
+				s8 = j8;
+				j8 = 0;
+			} else {
+				s8 = bsize;
+				j8 -= bsize;
+			}
+			dx9 = sx[9] - ( s8*sx[8] );
+			dy9 = sy[9] - ( s8*sy[8] );
+			dz9 = sz[9] - ( s8*sz[8] );
+			dw9 = sw[9] - ( s8*sw[8] );
+			du9 = su[9] - ( s8*su[8] );
+			ox8 = ox9 + ( j8*sx[8] );
+			oy8 = oy9 + ( j8*sy[8] );
+			oz8 = oz9 + ( j8*sz[8] );
+			ow8 = ow9 + ( j8*sw[8] );
+			ou8 = ou9 + ( j8*su[8] );
+			for ( j7 = sh[7]; j7 > 0; ) {
+				if ( j7 < bsize ) {
+					s7 = j7;
+					j7 = 0;
+				} else {
+					s7 = bsize;
+					j7 -= bsize;
+				}
+				dx8 = sx[8] - ( s7*sx[7] );
+				dy8 = sy[8] - ( s7*sy[7] );
+				dz8 = sz[8] - ( s7*sz[7] );
+				dw8 = sw[8] - ( s7*sw[7] );
+				du8 = su[8] - ( s7*su[7] );
+				ox7 = ox8 + ( j7*sx[7] );
+				oy7 = oy8 + ( j7*sy[7] );
+				oz7 = oz8 + ( j7*sz[7] );
+				ow7 = ow8 + ( j7*sw[7] );
+				ou7 = ou8 + ( j7*su[7] );
+				for ( j6 = sh[6]; j6 > 0; ) {
+					if ( j6 < bsize ) {
+						s6 = j6;
+						j6 = 0;
+					} else {
+						s6 = bsize;
+						j6 -= bsize;
+					}
+					dx7 = sx[7] - ( s6*sx[6] );
+					dy7 = sy[7] - ( s6*sy[6] );
+					dz7 = sz[7] - ( s6*sz[6] );
+					dw7 = sw[7] - ( s6*sw[6] );
+					du7 = su[7] - ( s6*su[6] );
+					ox6 = ox7 + ( j6*sx[6] );
+					oy6 = oy7 + ( j6*sy[6] );
+					oz6 = oz7 + ( j6*sz[6] );
+					ow6 = ow7 + ( j6*sw[6] );
+					ou6 = ou7 + ( j6*su[6] );
+					for ( j5 = sh[5]; j5 > 0; ) {
+						if ( j5 < bsize ) {
+							s5 = j5;
+							j5 = 0;
+						} else {
+							s5 = bsize;
+							j5 -= bsize;
+						}
+						dx6 = sx[6] - ( s5*sx[5] );
+						dy6 = sy[6] - ( s5*sy[5] );
+						dz6 = sz[6] - ( s5*sz[5] );
+						dw6 = sw[6] - ( s5*sw[5] );
+						du6 = su[6] - ( s5*su[5] );
+						ox5 = ox6 + ( j5*sx[5] );
+						oy5 = oy6 + ( j5*sy[5] );
+						oz5 = oz6 + ( j5*sz[5] );
+						ow5 = ow6 + ( j5*sw[5] );
+						ou5 = ou6 + ( j5*su[5] );
+						for ( j4 = sh[4]; j4 > 0; ) {
+							if ( j4 < bsize ) {
+								s4 = j4;
+								j4 = 0;
+							} else {
+								s4 = bsize;
+								j4 -= bsize;
+							}
+							dx5 = sx[5] - ( s4*sx[4] );
+							dy5 = sy[5] - ( s4*sy[4] );
+							dz5 = sz[5] - ( s4*sz[4] );
+							dw5 = sw[5] - ( s4*sw[4] );
+							du5 = su[5] - ( s4*su[4] );
+							ox4 = ox5 + ( j4*sx[4] );
+							oy4 = oy5 + ( j4*sy[4] );
+							oz4 = oz5 + ( j4*sz[4] );
+							ow4 = ow5 + ( j4*sw[4] );
+							ou4 = ou5 + ( j4*su[4] );
+							for ( j3 = sh[3]; j3 > 0; ) {
+								if ( j3 < bsize ) {
+									s3 = j3;
+									j3 = 0;
+								} else {
+									s3 = bsize;
+									j3 -= bsize;
+								}
+								dx4 = sx[4] - ( s3*sx[3] );
+								dy4 = sy[4] - ( s3*sy[3] );
+								dz4 = sz[4] - ( s3*sz[3] );
+								dw4 = sw[4] - ( s3*sw[3] );
+								du4 = su[4] - ( s3*su[3] );
+								ox3 = ox4 + ( j3*sx[3] );
+								oy3 = oy4 + ( j3*sy[3] );
+								oz3 = oz4 + ( j3*sz[3] );
+								ow3 = ow4 + ( j3*sw[3] );
+								ou3 = ou4 + ( j3*su[3] );
+								for ( j2 = sh[2]; j2 > 0; ) {
+									if ( j2 < bsize ) {
+										s2 = j2;
+										j2 = 0;
+									} else {
+										s2 = bsize;
+										j2 -= bsize;
+									}
+									dx3 = sx[3] - ( s2*sx[2] );
+									dy3 = sy[3] - ( s2*sy[2] );
+									dz3 = sz[3] - ( s2*sz[2] );
+									dw3 = sw[3] - ( s2*sw[2] );
+									du3 = su[3] - ( s2*su[2] );
+									ox2 = ox3 + ( j2*sx[2] );
+									oy2 = oy3 + ( j2*sy[2] );
+									oz2 = oz3 + ( j2*sz[2] );
+									ow2 = ow3 + ( j2*sw[2] );
+									ou2 = ou3 + ( j2*su[2] );
+									for ( j1 = sh[1]; j1 > 0; ) {
+										if ( j1 < bsize ) {
+											s1 = j1;
+											j1 = 0;
+										} else {
+											s1 = bsize;
+											j1 -= bsize;
+										}
+										dx2 = sx[2] - ( s1*sx[1] );
+										dy2 = sy[2] - ( s1*sy[1] );
+										dz2 = sz[2] - ( s1*sz[1] );
+										dw2 = sw[2] - ( s1*sw[1] );
+										du2 = su[2] - ( s1*su[1] );
+										ox1 = ox2 + ( j1*sx[1] );
+										oy1 = oy2 + ( j1*sy[1] );
+										oz1 = oz2 + ( j1*sz[1] );
+										ow1 = ow2 + ( j1*sw[1] );
+										ou1 = ou2 + ( j1*su[1] );
+										for ( j0 = sh[0]; j0 > 0; ) {
+											if ( j0 < bsize ) {
+												s0 = j0;
+												j0 = 0;
+											} else {
+												s0 = bsize;
+												j0 -= bsize;
+											}
+											// Compute index offsets for the first input and output ndarray elements in the current block...
+											ix = ox1 + ( j0*sx[0] );
+											iy = oy1 + ( j0*sy[0] );
+											iz = oz1 + ( j0*sz[0] );
+											iw = ow1 + ( j0*sw[0] );
+											iu = ou1 + ( j0*su[0] );
+
+											// Compute loop offset increments...
+											dx1 = sx[1] - ( s0*sx[0] );
+											dy1 = sy[1] - ( s0*sy[0] );
+											dz1 = sz[1] - ( s0*sz[0] );
+											dw1 = sw[1] - ( s0*sw[0] );
+											du1 = su[1] - ( s0*su[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++ ) {
+																					ubuf[ iu ] = fcn( xbuf[ ix ], ybuf[ iy ], zbuf[ iz ], wbuf[ iw ] );
+																					ix += dx0;
+																					iy += dy0;
+																					iz += dz0;
+																					iw += dw0;
+																					iu += du0;
+																				}
+																				ix += dx1;
+																				iy += dy1;
+																				iz += dz1;
+																				iw += dw1;
+																				iu += du1;
+																			}
+																			ix += dx2;
+																			iy += dy2;
+																			iz += dz2;
+																			iw += dw2;
+																			iu += du2;
+																		}
+																		ix += dx3;
+																		iy += dy3;
+																		iz += dz3;
+																		iw += dw3;
+																		iu += du3;
+																	}
+																	ix += dx4;
+																	iy += dy4;
+																	iz += dz4;
+																	iw += dw4;
+																	iu += du4;
+																}
+																ix += dx5;
+																iy += dy5;
+																iz += dz5;
+																iw += dw5;
+																iu += du5;
+															}
+															ix += dx6;
+															iy += dy6;
+															iz += dz6;
+															iw += dw6;
+															iu += du6;
+														}
+														ix += dx7;
+														iy += dy7;
+														iz += dz7;
+														iw += dw7;
+														iu += du7;
+													}
+													ix += dx8;
+													iy += dy8;
+													iz += dz8;
+													iw += dw8;
+													iu += du8;
+												}
+												ix += dx9;
+												iy += dy9;
+												iz += dz9;
+												iw += dw9;
+												iu += du9;
+											}
+										}
+									}
+								}
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+}
+
+
+// EXPORTS //
+
+module.exports = blockedquaternary10d;
diff --git a/lib/node_modules/@stdlib/ndarray/base/kernels/generic/quaternary/blocked/lib/2d.js b/lib/node_modules/@stdlib/ndarray/base/kernels/generic/quaternary/blocked/lib/2d.js
new file mode 100644
index 000000000000..ef3c49cfae87
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/kernels/generic/quaternary/blocked/lib/2d.js
@@ -0,0 +1,289 @@
+/**
+* @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-statements */
+
+'use strict';
+
+// MODULES //
+
+var loopOrder = require( '@stdlib/ndarray/base/quaternary-loop-interchange-order' );
+var blockSize = require( '@stdlib/ndarray/base/quaternary-tiling-block-size' );
+
+
+// MAIN //
+
+/**
+* Applies a quaternary callback to elements in two-dimensional input ndarrays and assigns results 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 input 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 {Object} z - object containing input ndarray meta data
+* @param {*} z.dtype - data type
+* @param {Collection} z.data - data buffer
+* @param {NonNegativeIntegerArray} z.shape - dimensions
+* @param {IntegerArray} z.strides - stride lengths
+* @param {NonNegativeInteger} z.offset - index offset
+* @param {string} z.order - specifies whether `z` is row-major (C-style) or column-major (Fortran-style)
+* @param {Object} w - object containing input ndarray meta data
+* @param {*} w.dtype - data type
+* @param {Collection} w.data - data buffer
+* @param {NonNegativeIntegerArray} w.shape - dimensions
+* @param {IntegerArray} w.strides - stride lengths
+* @param {NonNegativeInteger} w.offset - index offset
+* @param {string} w.order - specifies whether `w` is row-major (C-style) or column-major (Fortran-style)
+* @param {Object} u - object containing output ndarray meta data
+* @param {*} u.dtype - data type
+* @param {Collection} u.data - data buffer
+* @param {NonNegativeIntegerArray} u.shape - dimensions
+* @param {IntegerArray} u.strides - stride lengths
+* @param {NonNegativeInteger} u.offset - index offset
+* @param {string} u.order - specifies whether `u` is row-major (C-style) or column-major (Fortran-style)
+* @param {Callback} fcn - quaternary callback
+*
+* @example
+* var Float64Array = require( '@stdlib/array/float64' );
+* var ndarray2array = require( '@stdlib/ndarray/base/to-array' );
+* var add4 = require( '@stdlib/number/float64/base/add4' );
+*
+* // Create data buffers:
+* var xbuf = new Float64Array( [ 1.0, 2.0, 3.0, 4.0 ] );
+* var ybuf = new Float64Array( [ 1.0, 1.0, 1.0, 1.0 ] );
+* var zbuf = new Float64Array( [ 1.0, 1.0, 1.0, 1.0 ] );
+* var wbuf = new Float64Array( [ 1.0, 1.0, 1.0, 1.0 ] );
+* var ubuf = new Float64Array( 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 ];
+* var sz = [ 2, 1 ];
+* var sw = [ 2, 1 ];
+* var su = [ 2, 1 ];
+*
+* // Define the index offsets:
+* var ox = 0;
+* var oy = 0;
+* var oz = 0;
+* var ow = 0;
+* var ou = 0;
+*
+* // Create the input and output ndarray-like objects:
+* var x = {
+*     'dtype': 'float64',
+*     'data': xbuf,
+*     'shape': shape,
+*     'strides': sx,
+*     'offset': ox,
+*     'order': 'row-major'
+* };
+* var y = {
+*     'dtype': 'float64',
+*     'data': ybuf,
+*     'shape': shape,
+*     'strides': sy,
+*     'offset': oy,
+*     'order': 'row-major'
+* };
+* var z = {
+*     'dtype': 'float64',
+*     'data': zbuf,
+*     'shape': shape,
+*     'strides': sz,
+*     'offset': oz,
+*     'order': 'row-major'
+* };
+* var w = {
+*     'dtype': 'float64',
+*     'data': wbuf,
+*     'shape': shape,
+*     'strides': sw,
+*     'offset': ow,
+*     'order': 'row-major'
+* };
+* var u = {
+*     'dtype': 'float64',
+*     'data': ubuf,
+*     'shape': shape,
+*     'strides': su,
+*     'offset': ou,
+*     'order': 'row-major'
+* };
+*
+* // Apply the quaternary function:
+* blockedquaternary2d( x, y, z, w, u, add4 );
+*
+* var arr = ndarray2array( u.data, u.shape, u.strides, u.offset, u.order );
+* // returns [ [ 4.0, 5.0 ], [ 6.0, 7.0 ] ]
+*/
+function blockedquaternary2d( x, y, z, w, u, fcn ) {
+	var bsize;
+	var xbuf;
+	var ybuf;
+	var zbuf;
+	var wbuf;
+	var ubuf;
+	var dx0;
+	var dx1;
+	var dy0;
+	var dy1;
+	var dz0;
+	var dz1;
+	var dw0;
+	var dw1;
+	var du0;
+	var du1;
+	var ox1;
+	var oy1;
+	var oz1;
+	var ow1;
+	var ou1;
+	var sh;
+	var s0;
+	var s1;
+	var sx;
+	var sy;
+	var sz;
+	var sw;
+	var su;
+	var ox;
+	var oy;
+	var oz;
+	var ow;
+	var ou;
+	var ix;
+	var iy;
+	var iz;
+	var iw;
+	var iu;
+	var i0;
+	var i1;
+	var j0;
+	var j1;
+	var o;
+
+	// Note on variable naming convention: s#, dx#, dy#, dz#, dw#, du#, i#, j# where # corresponds to the loop number, with `0` being the innermost loop...
+
+	// Resolve the loop interchange order:
+	o = loopOrder( x.shape, x.strides, y.strides, z.strides, w.strides, u.strides ); // eslint-disable-line max-len
+	sh = o.sh;
+	sx = o.sx;
+	sy = o.sy;
+	sz = o.sz;
+	sw = o.sw;
+	su = o.su;
+
+	// Determine the block size:
+	bsize = blockSize( x.dtype, y.dtype, z.dtype, w.dtype, u.dtype );
+
+	// Cache the indices of the first indexed elements in the respective ndarrays...
+	ox = x.offset;
+	oy = y.offset;
+	oz = z.offset;
+	ow = w.offset;
+	ou = u.offset;
+
+	// Cache references to the input and output ndarray buffers...
+	xbuf = x.data;
+	ybuf = y.data;
+	zbuf = z.data;
+	wbuf = w.data;
+	ubuf = u.data;
+
+	// Cache offset increments for the innermost loop...
+	dx0 = sx[0];
+	dy0 = sy[0];
+	dz0 = sz[0];
+	dw0 = sw[0];
+	du0 = su[0];
+
+	// Iterate over blocks...
+	for ( j1 = sh[1]; j1 > 0; ) {
+		if ( j1 < bsize ) {
+			s1 = j1;
+			j1 = 0;
+		} else {
+			s1 = bsize;
+			j1 -= bsize;
+		}
+		ox1 = ox + ( j1*sx[1] );
+		oy1 = oy + ( j1*sy[1] );
+		oz1 = oz + ( j1*sz[1] );
+		ow1 = ow + ( j1*sw[1] );
+		ou1 = ou + ( j1*su[1] );
+		for ( j0 = sh[0]; j0 > 0; ) {
+			if ( j0 < bsize ) {
+				s0 = j0;
+				j0 = 0;
+			} else {
+				s0 = bsize;
+				j0 -= bsize;
+			}
+			// Compute index offsets for the first input and output ndarray elements in the current block...
+			ix = ox1 + ( j0*sx[0] );
+			iy = oy1 + ( j0*sy[0] );
+			iz = oz1 + ( j0*sz[0] );
+			iw = ow1 + ( j0*sw[0] );
+			iu = ou1 + ( j0*su[0] );
+
+			// Compute loop offset increments...
+			dx1 = sx[1] - ( s0*sx[0] );
+			dy1 = sy[1] - ( s0*sy[0] );
+			dz1 = sz[1] - ( s0*sz[0] );
+			dw1 = sw[1] - ( s0*sw[0] );
+			du1 = su[1] - ( s0*su[0] );
+
+			// Iterate over the ndarray dimensions...
+			for ( i1 = 0; i1 < s1; i1++ ) {
+				for ( i0 = 0; i0 < s0; i0++ ) {
+					ubuf[ iu ] = fcn( xbuf[ ix ], ybuf[ iy ], zbuf[ iz ], wbuf[ iw ] ); // eslint-disable-line max-len
+					ix += dx0;
+					iy += dy0;
+					iz += dz0;
+					iw += dw0;
+					iu += du0;
+				}
+				ix += dx1;
+				iy += dy1;
+				iz += dz1;
+				iw += dw1;
+				iu += du1;
+			}
+		}
+	}
+}
+
+
+// EXPORTS //
+
+module.exports = blockedquaternary2d;
diff --git a/lib/node_modules/@stdlib/ndarray/base/kernels/generic/quaternary/blocked/lib/3d.js b/lib/node_modules/@stdlib/ndarray/base/kernels/generic/quaternary/blocked/lib/3d.js
new file mode 100644
index 000000000000..d16ee7622d0b
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/kernels/generic/quaternary/blocked/lib/3d.js
@@ -0,0 +1,328 @@
+/**
+* @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';
+
+// MODULES //
+
+var loopOrder = require( '@stdlib/ndarray/base/quaternary-loop-interchange-order' );
+var blockSize = require( '@stdlib/ndarray/base/quaternary-tiling-block-size' );
+
+
+// MAIN //
+
+/**
+* Applies a quaternary callback to elements in three-dimensional input ndarrays and assigns results 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 input 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 {Object} z - object containing input ndarray meta data
+* @param {*} z.dtype - data type
+* @param {Collection} z.data - data buffer
+* @param {NonNegativeIntegerArray} z.shape - dimensions
+* @param {IntegerArray} z.strides - stride lengths
+* @param {NonNegativeInteger} z.offset - index offset
+* @param {string} z.order - specifies whether `z` is row-major (C-style) or column-major (Fortran-style)
+* @param {Object} w - object containing input ndarray meta data
+* @param {*} w.dtype - data type
+* @param {Collection} w.data - data buffer
+* @param {NonNegativeIntegerArray} w.shape - dimensions
+* @param {IntegerArray} w.strides - stride lengths
+* @param {NonNegativeInteger} w.offset - index offset
+* @param {string} w.order - specifies whether `w` is row-major (C-style) or column-major (Fortran-style)
+* @param {Object} u - object containing output ndarray meta data
+* @param {*} u.dtype - data type
+* @param {Collection} u.data - data buffer
+* @param {NonNegativeIntegerArray} u.shape - dimensions
+* @param {IntegerArray} u.strides - stride lengths
+* @param {NonNegativeInteger} u.offset - index offset
+* @param {string} u.order - specifies whether `u` is row-major (C-style) or column-major (Fortran-style)
+* @param {Callback} fcn - quaternary callback
+*
+* @example
+* var Float64Array = require( '@stdlib/array/float64' );
+* var ndarray2array = require( '@stdlib/ndarray/base/to-array' );
+* var add4 = require( '@stdlib/number/float64/base/add4' );
+*
+* // Create data buffers:
+* var xbuf = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 ] );
+* var ybuf = new Float64Array( [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ] );
+* var zbuf = new Float64Array( [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ] );
+* var wbuf = new Float64Array( [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ] );
+* var ubuf = new Float64Array( 8 );
+*
+* // Define the shape of the input and output arrays:
+* var shape = [ 2, 2, 2 ];
+*
+* // Define the array strides:
+* var sx = [ 4, 2, 1 ];
+* var sy = [ 4, 2, 1 ];
+* var sz = [ 4, 2, 1 ];
+* var sw = [ 4, 2, 1 ];
+* var su = [ 4, 2, 1 ];
+*
+* // Define the index offsets:
+* var ox = 0;
+* var oy = 0;
+* var oz = 0;
+* var ow = 0;
+* var ou = 0;
+*
+* // Create the input and output ndarray-like objects:
+* var x = {
+*     'dtype': 'float64',
+*     'data': xbuf,
+*     'shape': shape,
+*     'strides': sx,
+*     'offset': ox,
+*     'order': 'row-major'
+* };
+* var y = {
+*     'dtype': 'float64',
+*     'data': ybuf,
+*     'shape': shape,
+*     'strides': sy,
+*     'offset': oy,
+*     'order': 'row-major'
+* };
+* var z = {
+*     'dtype': 'float64',
+*     'data': zbuf,
+*     'shape': shape,
+*     'strides': sz,
+*     'offset': oz,
+*     'order': 'row-major'
+* };
+* var w = {
+*     'dtype': 'float64',
+*     'data': wbuf,
+*     'shape': shape,
+*     'strides': sw,
+*     'offset': ow,
+*     'order': 'row-major'
+* };
+* var u = {
+*     'dtype': 'float64',
+*     'data': ubuf,
+*     'shape': shape,
+*     'strides': su,
+*     'offset': ou,
+*     'order': 'row-major'
+* };
+*
+* // Apply the quaternary function:
+* blockedquaternary3d( x, y, z, w, u, add4 );
+*
+* var arr = ndarray2array( u.data, u.shape, u.strides, u.offset, u.order );
+* // returns [ [ [ 4.0, 5.0 ], [ 6.0, 7.0 ] ], [ [ 8.0, 9.0 ], [ 10.0, 11.0 ] ] ]
+*/
+function blockedquaternary3d( x, y, z, w, u, fcn ) {
+	var bsize;
+	var xbuf;
+	var ybuf;
+	var zbuf;
+	var wbuf;
+	var ubuf;
+	var dx0;
+	var dx1;
+	var dx2;
+	var dy0;
+	var dy1;
+	var dy2;
+	var dz0;
+	var dz1;
+	var dz2;
+	var dw0;
+	var dw1;
+	var dw2;
+	var du0;
+	var du1;
+	var du2;
+	var ox1;
+	var ox2;
+	var oy1;
+	var oy2;
+	var oz1;
+	var oz2;
+	var ow1;
+	var ow2;
+	var ou1;
+	var ou2;
+	var sh;
+	var s0;
+	var s1;
+	var s2;
+	var sx;
+	var sy;
+	var sz;
+	var sw;
+	var su;
+	var ox;
+	var oy;
+	var oz;
+	var ow;
+	var ou;
+	var ix;
+	var iy;
+	var iz;
+	var iw;
+	var iu;
+	var i0;
+	var i1;
+	var i2;
+	var j0;
+	var j1;
+	var j2;
+	var o;
+
+	// Note on variable naming convention: s#, dx#, dy#, dz#, dw#, du#, i#, j# where # corresponds to the loop number, with `0` being the innermost loop...
+
+	// Resolve the loop interchange order:
+	o = loopOrder( x.shape, x.strides, y.strides, z.strides, w.strides, u.strides ); // eslint-disable-line max-len
+	sh = o.sh;
+	sx = o.sx;
+	sy = o.sy;
+	sz = o.sz;
+	sw = o.sw;
+	su = o.su;
+
+	// Determine the block size:
+	bsize = blockSize( x.dtype, y.dtype, z.dtype, w.dtype, u.dtype );
+
+	// Cache the indices of the first indexed elements in the respective ndarrays...
+	ox = x.offset;
+	oy = y.offset;
+	oz = z.offset;
+	ow = w.offset;
+	ou = u.offset;
+
+	// Cache references to the input and output ndarray buffers...
+	xbuf = x.data;
+	ybuf = y.data;
+	zbuf = z.data;
+	wbuf = w.data;
+	ubuf = u.data;
+
+	// Cache offset increments for the innermost loop...
+	dx0 = sx[0];
+	dy0 = sy[0];
+	dz0 = sz[0];
+	dw0 = sw[0];
+	du0 = su[0];
+
+	// Iterate over blocks...
+	for ( j2 = sh[2]; j2 > 0; ) {
+		if ( j2 < bsize ) {
+			s2 = j2;
+			j2 = 0;
+		} else {
+			s2 = bsize;
+			j2 -= bsize;
+		}
+		ox2 = ox + ( j2*sx[2] );
+		oy2 = oy + ( j2*sy[2] );
+		oz2 = oz + ( j2*sz[2] );
+		ow2 = ow + ( j2*sw[2] );
+		ou2 = ou + ( j2*su[2] );
+		for ( j1 = sh[1]; j1 > 0; ) {
+			if ( j1 < bsize ) {
+				s1 = j1;
+				j1 = 0;
+			} else {
+				s1 = bsize;
+				j1 -= bsize;
+			}
+			dx2 = sx[2] - ( s1*sx[1] );
+			dy2 = sy[2] - ( s1*sy[1] );
+			dz2 = sz[2] - ( s1*sz[1] );
+			dw2 = sw[2] - ( s1*sw[1] );
+			du2 = su[2] - ( s1*su[1] );
+			ox1 = ox2 + ( j1*sx[1] );
+			oy1 = oy2 + ( j1*sy[1] );
+			oz1 = oz2 + ( j1*sz[1] );
+			ow1 = ow2 + ( j1*sw[1] );
+			ou1 = ou2 + ( j1*su[1] );
+			for ( j0 = sh[0]; j0 > 0; ) {
+				if ( j0 < bsize ) {
+					s0 = j0;
+					j0 = 0;
+				} else {
+					s0 = bsize;
+					j0 -= bsize;
+				}
+				// Compute index offsets for the first input and output ndarray elements in the current block...
+				ix = ox1 + ( j0*sx[0] );
+				iy = oy1 + ( j0*sy[0] );
+				iz = oz1 + ( j0*sz[0] );
+				iw = ow1 + ( j0*sw[0] );
+				iu = ou1 + ( j0*su[0] );
+
+				// Compute loop offset increments...
+				dx1 = sx[1] - ( s0*sx[0] );
+				dy1 = sy[1] - ( s0*sy[0] );
+				dz1 = sz[1] - ( s0*sz[0] );
+				dw1 = sw[1] - ( s0*sw[0] );
+				du1 = su[1] - ( s0*su[0] );
+
+				// Iterate over the ndarray dimensions...
+				for ( i2 = 0; i2 < s2; i2++ ) {
+					for ( i1 = 0; i1 < s1; i1++ ) {
+						for ( i0 = 0; i0 < s0; i0++ ) {
+							ubuf[ iu ] = fcn( xbuf[ ix ], ybuf[ iy ], zbuf[ iz ], wbuf[ iw ] ); // eslint-disable-line max-len
+							ix += dx0;
+							iy += dy0;
+							iz += dz0;
+							iw += dw0;
+							iu += du0;
+						}
+						ix += dx1;
+						iy += dy1;
+						iz += dz1;
+						iw += dw1;
+						iu += du1;
+					}
+					ix += dx2;
+					iy += dy2;
+					iz += dz2;
+					iw += dw2;
+					iu += du2;
+				}
+			}
+		}
+	}
+}
+
+
+// EXPORTS //
+
+module.exports = blockedquaternary3d;
diff --git a/lib/node_modules/@stdlib/ndarray/base/kernels/generic/quaternary/blocked/lib/4d.js b/lib/node_modules/@stdlib/ndarray/base/kernels/generic/quaternary/blocked/lib/4d.js
new file mode 100644
index 000000000000..600e6260fe00
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/kernels/generic/quaternary/blocked/lib/4d.js
@@ -0,0 +1,367 @@
+/**
+* @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';
+
+// MODULES //
+
+var loopOrder = require( '@stdlib/ndarray/base/quaternary-loop-interchange-order' );
+var blockSize = require( '@stdlib/ndarray/base/quaternary-tiling-block-size' );
+
+
+// MAIN //
+
+/**
+* Applies a quaternary callback to elements in four-dimensional input ndarrays and assigns results 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 input 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 {Object} z - object containing input ndarray meta data
+* @param {*} z.dtype - data type
+* @param {Collection} z.data - data buffer
+* @param {NonNegativeIntegerArray} z.shape - dimensions
+* @param {IntegerArray} z.strides - stride lengths
+* @param {NonNegativeInteger} z.offset - index offset
+* @param {string} z.order - specifies whether `z` is row-major (C-style) or column-major (Fortran-style)
+* @param {Object} w - object containing input ndarray meta data
+* @param {*} w.dtype - data type
+* @param {Collection} w.data - data buffer
+* @param {NonNegativeIntegerArray} w.shape - dimensions
+* @param {IntegerArray} w.strides - stride lengths
+* @param {NonNegativeInteger} w.offset - index offset
+* @param {string} w.order - specifies whether `w` is row-major (C-style) or column-major (Fortran-style)
+* @param {Object} u - object containing output ndarray meta data
+* @param {*} u.dtype - data type
+* @param {Collection} u.data - data buffer
+* @param {NonNegativeIntegerArray} u.shape - dimensions
+* @param {IntegerArray} u.strides - stride lengths
+* @param {NonNegativeInteger} u.offset - index offset
+* @param {string} u.order - specifies whether `u` is row-major (C-style) or column-major (Fortran-style)
+* @param {Callback} fcn - quaternary callback
+*
+* @example
+* var Float64Array = require( '@stdlib/array/float64' );
+* var ndarray2array = require( '@stdlib/ndarray/base/to-array' );
+* var add4 = require( '@stdlib/number/float64/base/add4' );
+*
+* // Create data buffers:
+* var xbuf = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 ] );
+* var ybuf = new Float64Array( [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ] );
+* var zbuf = new Float64Array( [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ] );
+* var wbuf = new Float64Array( [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ] );
+* var ubuf = new Float64Array( 8 );
+*
+* // Define the shape of the input and output arrays:
+* var shape = [ 1, 2, 2, 2 ];
+*
+* // Define the array strides:
+* var sx = [ 8, 4, 2, 1 ];
+* var sy = [ 8, 4, 2, 1 ];
+* var sz = [ 8, 4, 2, 1 ];
+* var sw = [ 8, 4, 2, 1 ];
+* var su = [ 8, 4, 2, 1 ];
+*
+* // Define the index offsets:
+* var ox = 0;
+* var oy = 0;
+* var oz = 0;
+* var ow = 0;
+* var ou = 0;
+*
+* // Create the input and output ndarray-like objects:
+* var x = {
+*     'dtype': 'float64',
+*     'data': xbuf,
+*     'shape': shape,
+*     'strides': sx,
+*     'offset': ox,
+*     'order': 'row-major'
+* };
+* var y = {
+*     'dtype': 'float64',
+*     'data': ybuf,
+*     'shape': shape,
+*     'strides': sy,
+*     'offset': oy,
+*     'order': 'row-major'
+* };
+* var z = {
+*     'dtype': 'float64',
+*     'data': zbuf,
+*     'shape': shape,
+*     'strides': sz,
+*     'offset': oz,
+*     'order': 'row-major'
+* };
+* var w = {
+*     'dtype': 'float64',
+*     'data': wbuf,
+*     'shape': shape,
+*     'strides': sw,
+*     'offset': ow,
+*     'order': 'row-major'
+* };
+* var u = {
+*     'dtype': 'float64',
+*     'data': ubuf,
+*     'shape': shape,
+*     'strides': su,
+*     'offset': ou,
+*     'order': 'row-major'
+* };
+*
+* // Apply the quaternary function:
+* blockedquaternary4d( x, y, z, w, u, add4 );
+*
+* var arr = ndarray2array( u.data, u.shape, u.strides, u.offset, u.order );
+* // returns [ [ [ [ 4.0, 5.0 ], [ 6.0, 7.0 ] ], [ [ 8.0, 9.0 ], [ 10.0, 11.0 ] ] ] ]
+*/
+function blockedquaternary4d( x, y, z, w, u, fcn ) {
+	var bsize;
+	var xbuf;
+	var ybuf;
+	var zbuf;
+	var wbuf;
+	var ubuf;
+	var dx0;
+	var dx1;
+	var dx2;
+	var dx3;
+	var dy0;
+	var dy1;
+	var dy2;
+	var dy3;
+	var dz0;
+	var dz1;
+	var dz2;
+	var dz3;
+	var dw0;
+	var dw1;
+	var dw2;
+	var dw3;
+	var du0;
+	var du1;
+	var du2;
+	var du3;
+	var ox1;
+	var ox2;
+	var ox3;
+	var oy1;
+	var oy2;
+	var oy3;
+	var oz1;
+	var oz2;
+	var oz3;
+	var ow1;
+	var ow2;
+	var ow3;
+	var ou1;
+	var ou2;
+	var ou3;
+	var sh;
+	var s0;
+	var s1;
+	var s2;
+	var s3;
+	var sx;
+	var sy;
+	var sz;
+	var sw;
+	var su;
+	var ox;
+	var oy;
+	var oz;
+	var ow;
+	var ou;
+	var ix;
+	var iy;
+	var iz;
+	var iw;
+	var iu;
+	var i0;
+	var i1;
+	var i2;
+	var i3;
+	var j0;
+	var j1;
+	var j2;
+	var j3;
+	var o;
+
+	// Note on variable naming convention: s#, dx#, dy#, dz#, dw#, du#, i#, j# where # corresponds to the loop number, with `0` being the innermost loop...
+
+	// Resolve the loop interchange order:
+	o = loopOrder( x.shape, x.strides, y.strides, z.strides, w.strides, u.strides ); // eslint-disable-line max-len
+	sh = o.sh;
+	sx = o.sx;
+	sy = o.sy;
+	sz = o.sz;
+	sw = o.sw;
+	su = o.su;
+
+	// Determine the block size:
+	bsize = blockSize( x.dtype, y.dtype, z.dtype, w.dtype, u.dtype );
+
+	// Cache the indices of the first indexed elements in the respective ndarrays...
+	ox = x.offset;
+	oy = y.offset;
+	oz = z.offset;
+	ow = w.offset;
+	ou = u.offset;
+
+	// Cache references to the input and output ndarray buffers...
+	xbuf = x.data;
+	ybuf = y.data;
+	zbuf = z.data;
+	wbuf = w.data;
+	ubuf = u.data;
+
+	// Cache offset increments for the innermost loop...
+	dx0 = sx[0];
+	dy0 = sy[0];
+	dz0 = sz[0];
+	dw0 = sw[0];
+	du0 = su[0];
+
+	// Iterate over blocks...
+	for ( j3 = sh[3]; j3 > 0; ) {
+		if ( j3 < bsize ) {
+			s3 = j3;
+			j3 = 0;
+		} else {
+			s3 = bsize;
+			j3 -= bsize;
+		}
+		ox3 = ox + ( j3*sx[3] );
+		oy3 = oy + ( j3*sy[3] );
+		oz3 = oz + ( j3*sz[3] );
+		ow3 = ow + ( j3*sw[3] );
+		ou3 = ou + ( j3*su[3] );
+		for ( j2 = sh[2]; j2 > 0; ) {
+			if ( j2 < bsize ) {
+				s2 = j2;
+				j2 = 0;
+			} else {
+				s2 = bsize;
+				j2 -= bsize;
+			}
+			dx3 = sx[3] - ( s2*sx[2] );
+			dy3 = sy[3] - ( s2*sy[2] );
+			dz3 = sz[3] - ( s2*sz[2] );
+			dw3 = sw[3] - ( s2*sw[2] );
+			du3 = su[3] - ( s2*su[2] );
+			ox2 = ox3 + ( j2*sx[2] );
+			oy2 = oy3 + ( j2*sy[2] );
+			oz2 = oz3 + ( j2*sz[2] );
+			ow2 = ow3 + ( j2*sw[2] );
+			ou2 = ou3 + ( j2*su[2] );
+			for ( j1 = sh[1]; j1 > 0; ) {
+				if ( j1 < bsize ) {
+					s1 = j1;
+					j1 = 0;
+				} else {
+					s1 = bsize;
+					j1 -= bsize;
+				}
+				dx2 = sx[2] - ( s1*sx[1] );
+				dy2 = sy[2] - ( s1*sy[1] );
+				dz2 = sz[2] - ( s1*sz[1] );
+				dw2 = sw[2] - ( s1*sw[1] );
+				du2 = su[2] - ( s1*su[1] );
+				ox1 = ox2 + ( j1*sx[1] );
+				oy1 = oy2 + ( j1*sy[1] );
+				oz1 = oz2 + ( j1*sz[1] );
+				ow1 = ow2 + ( j1*sw[1] );
+				ou1 = ou2 + ( j1*su[1] );
+				for ( j0 = sh[0]; j0 > 0; ) {
+					if ( j0 < bsize ) {
+						s0 = j0;
+						j0 = 0;
+					} else {
+						s0 = bsize;
+						j0 -= bsize;
+					}
+					// Compute index offsets for the first input and output ndarray elements in the current block...
+					ix = ox1 + ( j0*sx[0] );
+					iy = oy1 + ( j0*sy[0] );
+					iz = oz1 + ( j0*sz[0] );
+					iw = ow1 + ( j0*sw[0] );
+					iu = ou1 + ( j0*su[0] );
+
+					// Compute loop offset increments...
+					dx1 = sx[1] - ( s0*sx[0] );
+					dy1 = sy[1] - ( s0*sy[0] );
+					dz1 = sz[1] - ( s0*sz[0] );
+					dw1 = sw[1] - ( s0*sw[0] );
+					du1 = su[1] - ( s0*su[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++ ) {
+									ubuf[ iu ] = fcn( xbuf[ ix ], ybuf[ iy ], zbuf[ iz ], wbuf[ iw ] ); // eslint-disable-line max-len
+									ix += dx0;
+									iy += dy0;
+									iz += dz0;
+									iw += dw0;
+									iu += du0;
+								}
+								ix += dx1;
+								iy += dy1;
+								iz += dz1;
+								iw += dw1;
+								iu += du1;
+							}
+							ix += dx2;
+							iy += dy2;
+							iz += dz2;
+							iw += dw2;
+							iu += du2;
+						}
+						ix += dx3;
+						iy += dy3;
+						iz += dz3;
+						iw += dw3;
+						iu += du3;
+					}
+				}
+			}
+		}
+	}
+}
+
+
+// EXPORTS //
+
+module.exports = blockedquaternary4d;
diff --git a/lib/node_modules/@stdlib/ndarray/base/kernels/generic/quaternary/blocked/lib/5d.js b/lib/node_modules/@stdlib/ndarray/base/kernels/generic/quaternary/blocked/lib/5d.js
new file mode 100644
index 000000000000..b73a4f529e5a
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/kernels/generic/quaternary/blocked/lib/5d.js
@@ -0,0 +1,406 @@
+/**
+* @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, max-lines-per-function */
+
+'use strict';
+
+// MODULES //
+
+var loopOrder = require( '@stdlib/ndarray/base/quaternary-loop-interchange-order' );
+var blockSize = require( '@stdlib/ndarray/base/quaternary-tiling-block-size' );
+
+
+// MAIN //
+
+/**
+* Applies a quaternary callback to elements in five-dimensional input ndarrays and assigns results 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 input 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 {Object} z - object containing input ndarray meta data
+* @param {*} z.dtype - data type
+* @param {Collection} z.data - data buffer
+* @param {NonNegativeIntegerArray} z.shape - dimensions
+* @param {IntegerArray} z.strides - stride lengths
+* @param {NonNegativeInteger} z.offset - index offset
+* @param {string} z.order - specifies whether `z` is row-major (C-style) or column-major (Fortran-style)
+* @param {Object} w - object containing input ndarray meta data
+* @param {*} w.dtype - data type
+* @param {Collection} w.data - data buffer
+* @param {NonNegativeIntegerArray} w.shape - dimensions
+* @param {IntegerArray} w.strides - stride lengths
+* @param {NonNegativeInteger} w.offset - index offset
+* @param {string} w.order - specifies whether `w` is row-major (C-style) or column-major (Fortran-style)
+* @param {Object} u - object containing output ndarray meta data
+* @param {*} u.dtype - data type
+* @param {Collection} u.data - data buffer
+* @param {NonNegativeIntegerArray} u.shape - dimensions
+* @param {IntegerArray} u.strides - stride lengths
+* @param {NonNegativeInteger} u.offset - index offset
+* @param {string} u.order - specifies whether `u` is row-major (C-style) or column-major (Fortran-style)
+* @param {Callback} fcn - quaternary callback
+*
+* @example
+* var Float64Array = require( '@stdlib/array/float64' );
+* var ndarray2array = require( '@stdlib/ndarray/base/to-array' );
+* var add4 = require( '@stdlib/number/float64/base/add4' );
+*
+* // Create data buffers:
+* var xbuf = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 ] );
+* var ybuf = new Float64Array( [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ] );
+* var zbuf = new Float64Array( [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ] );
+* var wbuf = new Float64Array( [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ] );
+* var ubuf = new Float64Array( 8 );
+*
+* // Define the shape of the input and output arrays:
+* var shape = [ 1, 1, 2, 2, 2 ];
+*
+* // Define the array strides:
+* var sx = [ 8, 8, 4, 2, 1 ];
+* var sy = [ 8, 8, 4, 2, 1 ];
+* var sz = [ 8, 8, 4, 2, 1 ];
+* var sw = [ 8, 8, 4, 2, 1 ];
+* var su = [ 8, 8, 4, 2, 1 ];
+*
+* // Define the index offsets:
+* var ox = 0;
+* var oy = 0;
+* var oz = 0;
+* var ow = 0;
+* var ou = 0;
+*
+* // Create the input and output ndarray-like objects:
+* var x = {
+*     'dtype': 'float64',
+*     'data': xbuf,
+*     'shape': shape,
+*     'strides': sx,
+*     'offset': ox,
+*     'order': 'row-major'
+* };
+* var y = {
+*     'dtype': 'float64',
+*     'data': ybuf,
+*     'shape': shape,
+*     'strides': sy,
+*     'offset': oy,
+*     'order': 'row-major'
+* };
+* var z = {
+*     'dtype': 'float64',
+*     'data': zbuf,
+*     'shape': shape,
+*     'strides': sz,
+*     'offset': oz,
+*     'order': 'row-major'
+* };
+* var w = {
+*     'dtype': 'float64',
+*     'data': wbuf,
+*     'shape': shape,
+*     'strides': sw,
+*     'offset': ow,
+*     'order': 'row-major'
+* };
+* var u = {
+*     'dtype': 'float64',
+*     'data': ubuf,
+*     'shape': shape,
+*     'strides': su,
+*     'offset': ou,
+*     'order': 'row-major'
+* };
+*
+* // Apply the quaternary function:
+* blockedquaternary5d( x, y, z, w, u, add4 );
+*
+* var arr = ndarray2array( u.data, u.shape, u.strides, u.offset, u.order );
+* // returns [ [ [ [ [ 4.0, 5.0 ], [ 6.0, 7.0 ] ], [ [ 8.0, 9.0 ], [ 10.0, 11.0 ] ] ] ] ]
+*/
+function blockedquaternary5d( x, y, z, w, u, fcn ) {
+	var bsize;
+	var xbuf;
+	var ybuf;
+	var zbuf;
+	var wbuf;
+	var ubuf;
+	var dx0;
+	var dx1;
+	var dx2;
+	var dx3;
+	var dx4;
+	var dy0;
+	var dy1;
+	var dy2;
+	var dy3;
+	var dy4;
+	var dz0;
+	var dz1;
+	var dz2;
+	var dz3;
+	var dz4;
+	var dw0;
+	var dw1;
+	var dw2;
+	var dw3;
+	var dw4;
+	var du0;
+	var du1;
+	var du2;
+	var du3;
+	var du4;
+	var ox1;
+	var ox2;
+	var ox3;
+	var ox4;
+	var oy1;
+	var oy2;
+	var oy3;
+	var oy4;
+	var oz1;
+	var oz2;
+	var oz3;
+	var oz4;
+	var ow1;
+	var ow2;
+	var ow3;
+	var ow4;
+	var ou1;
+	var ou2;
+	var ou3;
+	var ou4;
+	var sh;
+	var s0;
+	var s1;
+	var s2;
+	var s3;
+	var s4;
+	var sx;
+	var sy;
+	var sz;
+	var sw;
+	var su;
+	var ox;
+	var oy;
+	var oz;
+	var ow;
+	var ou;
+	var ix;
+	var iy;
+	var iz;
+	var iw;
+	var iu;
+	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#, dx#, dy#, dz#, dw#, du#, i#, j# where # corresponds to the loop number, with `0` being the innermost loop...
+
+	// Resolve the loop interchange order:
+	o = loopOrder( x.shape, x.strides, y.strides, z.strides, w.strides, u.strides ); // eslint-disable-line max-len
+	sh = o.sh;
+	sx = o.sx;
+	sy = o.sy;
+	sz = o.sz;
+	sw = o.sw;
+	su = o.su;
+
+	// Determine the block size:
+	bsize = blockSize( x.dtype, y.dtype, z.dtype, w.dtype, u.dtype );
+
+	// Cache the indices of the first indexed elements in the respective ndarrays...
+	ox = x.offset;
+	oy = y.offset;
+	oz = z.offset;
+	ow = w.offset;
+	ou = u.offset;
+
+	// Cache references to the input and output ndarray buffers...
+	xbuf = x.data;
+	ybuf = y.data;
+	zbuf = z.data;
+	wbuf = w.data;
+	ubuf = u.data;
+
+	// Cache offset increments for the innermost loop...
+	dx0 = sx[0];
+	dy0 = sy[0];
+	dz0 = sz[0];
+	dw0 = sw[0];
+	du0 = su[0];
+
+	// Iterate over blocks...
+	for ( j4 = sh[4]; j4 > 0; ) {
+		if ( j4 < bsize ) {
+			s4 = j4;
+			j4 = 0;
+		} else {
+			s4 = bsize;
+			j4 -= bsize;
+		}
+		ox4 = ox + ( j4*sx[4] );
+		oy4 = oy + ( j4*sy[4] );
+		oz4 = oz + ( j4*sz[4] );
+		ow4 = ow + ( j4*sw[4] );
+		ou4 = ou + ( j4*su[4] );
+		for ( j3 = sh[3]; j3 > 0; ) {
+			if ( j3 < bsize ) {
+				s3 = j3;
+				j3 = 0;
+			} else {
+				s3 = bsize;
+				j3 -= bsize;
+			}
+			dx4 = sx[4] - ( s3*sx[3] );
+			dy4 = sy[4] - ( s3*sy[3] );
+			dz4 = sz[4] - ( s3*sz[3] );
+			dw4 = sw[4] - ( s3*sw[3] );
+			du4 = su[4] - ( s3*su[3] );
+			ox3 = ox4 + ( j3*sx[3] );
+			oy3 = oy4 + ( j3*sy[3] );
+			oz3 = oz4 + ( j3*sz[3] );
+			ow3 = ow4 + ( j3*sw[3] );
+			ou3 = ou4 + ( j3*su[3] );
+			for ( j2 = sh[2]; j2 > 0; ) {
+				if ( j2 < bsize ) {
+					s2 = j2;
+					j2 = 0;
+				} else {
+					s2 = bsize;
+					j2 -= bsize;
+				}
+				dx3 = sx[3] - ( s2*sx[2] );
+				dy3 = sy[3] - ( s2*sy[2] );
+				dz3 = sz[3] - ( s2*sz[2] );
+				dw3 = sw[3] - ( s2*sw[2] );
+				du3 = su[3] - ( s2*su[2] );
+				ox2 = ox3 + ( j2*sx[2] );
+				oy2 = oy3 + ( j2*sy[2] );
+				oz2 = oz3 + ( j2*sz[2] );
+				ow2 = ow3 + ( j2*sw[2] );
+				ou2 = ou3 + ( j2*su[2] );
+				for ( j1 = sh[1]; j1 > 0; ) {
+					if ( j1 < bsize ) {
+						s1 = j1;
+						j1 = 0;
+					} else {
+						s1 = bsize;
+						j1 -= bsize;
+					}
+					dx2 = sx[2] - ( s1*sx[1] );
+					dy2 = sy[2] - ( s1*sy[1] );
+					dz2 = sz[2] - ( s1*sz[1] );
+					dw2 = sw[2] - ( s1*sw[1] );
+					du2 = su[2] - ( s1*su[1] );
+					ox1 = ox2 + ( j1*sx[1] );
+					oy1 = oy2 + ( j1*sy[1] );
+					oz1 = oz2 + ( j1*sz[1] );
+					ow1 = ow2 + ( j1*sw[1] );
+					ou1 = ou2 + ( j1*su[1] );
+					for ( j0 = sh[0]; j0 > 0; ) {
+						if ( j0 < bsize ) {
+							s0 = j0;
+							j0 = 0;
+						} else {
+							s0 = bsize;
+							j0 -= bsize;
+						}
+						// Compute index offsets for the first input and output ndarray elements in the current block...
+						ix = ox1 + ( j0*sx[0] );
+						iy = oy1 + ( j0*sy[0] );
+						iz = oz1 + ( j0*sz[0] );
+						iw = ow1 + ( j0*sw[0] );
+						iu = ou1 + ( j0*su[0] );
+
+						// Compute loop offset increments...
+						dx1 = sx[1] - ( s0*sx[0] );
+						dy1 = sy[1] - ( s0*sy[0] );
+						dz1 = sz[1] - ( s0*sz[0] );
+						dw1 = sw[1] - ( s0*sw[0] );
+						du1 = su[1] - ( s0*su[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++ ) {
+											ubuf[ iu ] = fcn( xbuf[ ix ], ybuf[ iy ], zbuf[ iz ], wbuf[ iw ] ); // eslint-disable-line max-len
+											ix += dx0;
+											iy += dy0;
+											iz += dz0;
+											iw += dw0;
+											iu += du0;
+										}
+										ix += dx1;
+										iy += dy1;
+										iz += dz1;
+										iw += dw1;
+										iu += du1;
+									}
+									ix += dx2;
+									iy += dy2;
+									iz += dz2;
+									iw += dw2;
+									iu += du2;
+								}
+								ix += dx3;
+								iy += dy3;
+								iz += dz3;
+								iw += dw3;
+								iu += du3;
+							}
+							ix += dx4;
+							iy += dy4;
+							iz += dz4;
+							iw += dw4;
+							iu += du4;
+						}
+					}
+				}
+			}
+		}
+	}
+}
+
+
+// EXPORTS //
+
+module.exports = blockedquaternary5d;
diff --git a/lib/node_modules/@stdlib/ndarray/base/kernels/generic/quaternary/blocked/lib/6d.js b/lib/node_modules/@stdlib/ndarray/base/kernels/generic/quaternary/blocked/lib/6d.js
new file mode 100644
index 000000000000..5a5f6f6d4553
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/kernels/generic/quaternary/blocked/lib/6d.js
@@ -0,0 +1,445 @@
+/**
+* @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, max-lines-per-function */
+
+'use strict';
+
+// MODULES //
+
+var loopOrder = require( '@stdlib/ndarray/base/quaternary-loop-interchange-order' );
+var blockSize = require( '@stdlib/ndarray/base/quaternary-tiling-block-size' );
+
+
+// MAIN //
+
+/**
+* Applies a quaternary callback to elements in six-dimensional input ndarrays and assigns results 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 input 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 {Object} z - object containing input ndarray meta data
+* @param {*} z.dtype - data type
+* @param {Collection} z.data - data buffer
+* @param {NonNegativeIntegerArray} z.shape - dimensions
+* @param {IntegerArray} z.strides - stride lengths
+* @param {NonNegativeInteger} z.offset - index offset
+* @param {string} z.order - specifies whether `z` is row-major (C-style) or column-major (Fortran-style)
+* @param {Object} w - object containing input ndarray meta data
+* @param {*} w.dtype - data type
+* @param {Collection} w.data - data buffer
+* @param {NonNegativeIntegerArray} w.shape - dimensions
+* @param {IntegerArray} w.strides - stride lengths
+* @param {NonNegativeInteger} w.offset - index offset
+* @param {string} w.order - specifies whether `w` is row-major (C-style) or column-major (Fortran-style)
+* @param {Object} u - object containing output ndarray meta data
+* @param {*} u.dtype - data type
+* @param {Collection} u.data - data buffer
+* @param {NonNegativeIntegerArray} u.shape - dimensions
+* @param {IntegerArray} u.strides - stride lengths
+* @param {NonNegativeInteger} u.offset - index offset
+* @param {string} u.order - specifies whether `u` is row-major (C-style) or column-major (Fortran-style)
+* @param {Callback} fcn - quaternary callback
+*
+* @example
+* var Float64Array = require( '@stdlib/array/float64' );
+* var ndarray2array = require( '@stdlib/ndarray/base/to-array' );
+* var add4 = require( '@stdlib/number/float64/base/add4' );
+*
+* // Create data buffers:
+* var xbuf = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 ] );
+* var ybuf = new Float64Array( [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ] );
+* var zbuf = new Float64Array( [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ] );
+* var wbuf = new Float64Array( [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ] );
+* var ubuf = new Float64Array( 8 );
+*
+* // Define the shape of the input and output arrays:
+* var shape = [ 1, 1, 1, 2, 2, 2 ];
+*
+* // Define the array strides:
+* var sx = [ 8, 8, 8, 4, 2, 1 ];
+* var sy = [ 8, 8, 8, 4, 2, 1 ];
+* var sz = [ 8, 8, 8, 4, 2, 1 ];
+* var sw = [ 8, 8, 8, 4, 2, 1 ];
+* var su = [ 8, 8, 8, 4, 2, 1 ];
+*
+* // Define the index offsets:
+* var ox = 0;
+* var oy = 0;
+* var oz = 0;
+* var ow = 0;
+* var ou = 0;
+*
+* // Create the input and output ndarray-like objects:
+* var x = {
+*     'dtype': 'float64',
+*     'data': xbuf,
+*     'shape': shape,
+*     'strides': sx,
+*     'offset': ox,
+*     'order': 'row-major'
+* };
+* var y = {
+*     'dtype': 'float64',
+*     'data': ybuf,
+*     'shape': shape,
+*     'strides': sy,
+*     'offset': oy,
+*     'order': 'row-major'
+* };
+* var z = {
+*     'dtype': 'float64',
+*     'data': zbuf,
+*     'shape': shape,
+*     'strides': sz,
+*     'offset': oz,
+*     'order': 'row-major'
+* };
+* var w = {
+*     'dtype': 'float64',
+*     'data': wbuf,
+*     'shape': shape,
+*     'strides': sw,
+*     'offset': ow,
+*     'order': 'row-major'
+* };
+* var u = {
+*     'dtype': 'float64',
+*     'data': ubuf,
+*     'shape': shape,
+*     'strides': su,
+*     'offset': ou,
+*     'order': 'row-major'
+* };
+*
+* // Apply the quaternary function:
+* blockedquaternary6d( x, y, z, w, u, add4 );
+*
+* var arr = ndarray2array( u.data, u.shape, u.strides, u.offset, u.order );
+* // returns [ [ [ [ [ [ 4.0, 5.0 ], [ 6.0, 7.0 ] ], [ [ 8.0, 9.0 ], [ 10.0, 11.0 ] ] ] ] ] ]
+*/
+function blockedquaternary6d( x, y, z, w, u, fcn ) {
+	var bsize;
+	var xbuf;
+	var ybuf;
+	var zbuf;
+	var wbuf;
+	var ubuf;
+	var dx0;
+	var dx1;
+	var dx2;
+	var dx3;
+	var dx4;
+	var dx5;
+	var dy0;
+	var dy1;
+	var dy2;
+	var dy3;
+	var dy4;
+	var dy5;
+	var dz0;
+	var dz1;
+	var dz2;
+	var dz3;
+	var dz4;
+	var dz5;
+	var dw0;
+	var dw1;
+	var dw2;
+	var dw3;
+	var dw4;
+	var dw5;
+	var du0;
+	var du1;
+	var du2;
+	var du3;
+	var du4;
+	var du5;
+	var ox1;
+	var ox2;
+	var ox3;
+	var ox4;
+	var ox5;
+	var oy1;
+	var oy2;
+	var oy3;
+	var oy4;
+	var oy5;
+	var oz1;
+	var oz2;
+	var oz3;
+	var oz4;
+	var oz5;
+	var ow1;
+	var ow2;
+	var ow3;
+	var ow4;
+	var ow5;
+	var ou1;
+	var ou2;
+	var ou3;
+	var ou4;
+	var ou5;
+	var sh;
+	var s0;
+	var s1;
+	var s2;
+	var s3;
+	var s4;
+	var s5;
+	var sx;
+	var sy;
+	var sz;
+	var sw;
+	var su;
+	var ox;
+	var oy;
+	var oz;
+	var ow;
+	var ou;
+	var ix;
+	var iy;
+	var iz;
+	var iw;
+	var iu;
+	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#, dx#, dy#, dz#, dw#, du#, i#, j# where # corresponds to the loop number, with `0` being the innermost loop...
+
+	// Resolve the loop interchange order:
+	o = loopOrder( x.shape, x.strides, y.strides, z.strides, w.strides, u.strides ); // eslint-disable-line max-len
+	sh = o.sh;
+	sx = o.sx;
+	sy = o.sy;
+	sz = o.sz;
+	sw = o.sw;
+	su = o.su;
+
+	// Determine the block size:
+	bsize = blockSize( x.dtype, y.dtype, z.dtype, w.dtype, u.dtype );
+
+	// Cache the indices of the first indexed elements in the respective ndarrays...
+	ox = x.offset;
+	oy = y.offset;
+	oz = z.offset;
+	ow = w.offset;
+	ou = u.offset;
+
+	// Cache references to the input and output ndarray buffers...
+	xbuf = x.data;
+	ybuf = y.data;
+	zbuf = z.data;
+	wbuf = w.data;
+	ubuf = u.data;
+
+	// Cache offset increments for the innermost loop...
+	dx0 = sx[0];
+	dy0 = sy[0];
+	dz0 = sz[0];
+	dw0 = sw[0];
+	du0 = su[0];
+
+	// Iterate over blocks...
+	for ( j5 = sh[5]; j5 > 0; ) {
+		if ( j5 < bsize ) {
+			s5 = j5;
+			j5 = 0;
+		} else {
+			s5 = bsize;
+			j5 -= bsize;
+		}
+		ox5 = ox + ( j5*sx[5] );
+		oy5 = oy + ( j5*sy[5] );
+		oz5 = oz + ( j5*sz[5] );
+		ow5 = ow + ( j5*sw[5] );
+		ou5 = ou + ( j5*su[5] );
+		for ( j4 = sh[4]; j4 > 0; ) {
+			if ( j4 < bsize ) {
+				s4 = j4;
+				j4 = 0;
+			} else {
+				s4 = bsize;
+				j4 -= bsize;
+			}
+			dx5 = sx[5] - ( s4*sx[4] );
+			dy5 = sy[5] - ( s4*sy[4] );
+			dz5 = sz[5] - ( s4*sz[4] );
+			dw5 = sw[5] - ( s4*sw[4] );
+			du5 = su[5] - ( s4*su[4] );
+			ox4 = ox5 + ( j4*sx[4] );
+			oy4 = oy5 + ( j4*sy[4] );
+			oz4 = oz5 + ( j4*sz[4] );
+			ow4 = ow5 + ( j4*sw[4] );
+			ou4 = ou5 + ( j4*su[4] );
+			for ( j3 = sh[3]; j3 > 0; ) {
+				if ( j3 < bsize ) {
+					s3 = j3;
+					j3 = 0;
+				} else {
+					s3 = bsize;
+					j3 -= bsize;
+				}
+				dx4 = sx[4] - ( s3*sx[3] );
+				dy4 = sy[4] - ( s3*sy[3] );
+				dz4 = sz[4] - ( s3*sz[3] );
+				dw4 = sw[4] - ( s3*sw[3] );
+				du4 = su[4] - ( s3*su[3] );
+				ox3 = ox4 + ( j3*sx[3] );
+				oy3 = oy4 + ( j3*sy[3] );
+				oz3 = oz4 + ( j3*sz[3] );
+				ow3 = ow4 + ( j3*sw[3] );
+				ou3 = ou4 + ( j3*su[3] );
+				for ( j2 = sh[2]; j2 > 0; ) {
+					if ( j2 < bsize ) {
+						s2 = j2;
+						j2 = 0;
+					} else {
+						s2 = bsize;
+						j2 -= bsize;
+					}
+					dx3 = sx[3] - ( s2*sx[2] );
+					dy3 = sy[3] - ( s2*sy[2] );
+					dz3 = sz[3] - ( s2*sz[2] );
+					dw3 = sw[3] - ( s2*sw[2] );
+					du3 = su[3] - ( s2*su[2] );
+					ox2 = ox3 + ( j2*sx[2] );
+					oy2 = oy3 + ( j2*sy[2] );
+					oz2 = oz3 + ( j2*sz[2] );
+					ow2 = ow3 + ( j2*sw[2] );
+					ou2 = ou3 + ( j2*su[2] );
+					for ( j1 = sh[1]; j1 > 0; ) {
+						if ( j1 < bsize ) {
+							s1 = j1;
+							j1 = 0;
+						} else {
+							s1 = bsize;
+							j1 -= bsize;
+						}
+						dx2 = sx[2] - ( s1*sx[1] );
+						dy2 = sy[2] - ( s1*sy[1] );
+						dz2 = sz[2] - ( s1*sz[1] );
+						dw2 = sw[2] - ( s1*sw[1] );
+						du2 = su[2] - ( s1*su[1] );
+						ox1 = ox2 + ( j1*sx[1] );
+						oy1 = oy2 + ( j1*sy[1] );
+						oz1 = oz2 + ( j1*sz[1] );
+						ow1 = ow2 + ( j1*sw[1] );
+						ou1 = ou2 + ( j1*su[1] );
+						for ( j0 = sh[0]; j0 > 0; ) {
+							if ( j0 < bsize ) {
+								s0 = j0;
+								j0 = 0;
+							} else {
+								s0 = bsize;
+								j0 -= bsize;
+							}
+							// Compute index offsets for the first input and output ndarray elements in the current block...
+							ix = ox1 + ( j0*sx[0] );
+							iy = oy1 + ( j0*sy[0] );
+							iz = oz1 + ( j0*sz[0] );
+							iw = ow1 + ( j0*sw[0] );
+							iu = ou1 + ( j0*su[0] );
+
+							// Compute loop offset increments...
+							dx1 = sx[1] - ( s0*sx[0] );
+							dy1 = sy[1] - ( s0*sy[0] );
+							dz1 = sz[1] - ( s0*sz[0] );
+							dw1 = sw[1] - ( s0*sw[0] );
+							du1 = su[1] - ( s0*su[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++ ) {
+													ubuf[ iu ] = fcn( xbuf[ ix ], ybuf[ iy ], zbuf[ iz ], wbuf[ iw ] ); // eslint-disable-line max-len
+													ix += dx0;
+													iy += dy0;
+													iz += dz0;
+													iw += dw0;
+													iu += du0;
+												}
+												ix += dx1;
+												iy += dy1;
+												iz += dz1;
+												iw += dw1;
+												iu += du1;
+											}
+											ix += dx2;
+											iy += dy2;
+											iz += dz2;
+											iw += dw2;
+											iu += du2;
+										}
+										ix += dx3;
+										iy += dy3;
+										iz += dz3;
+										iw += dw3;
+										iu += du3;
+									}
+									ix += dx4;
+									iy += dy4;
+									iz += dz4;
+									iw += dw4;
+									iu += du4;
+								}
+								ix += dx5;
+								iy += dy5;
+								iz += dz5;
+								iw += dw5;
+								iu += du5;
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+}
+
+
+// EXPORTS //
+
+module.exports = blockedquaternary6d;
diff --git a/lib/node_modules/@stdlib/ndarray/base/kernels/generic/quaternary/blocked/lib/7d.js b/lib/node_modules/@stdlib/ndarray/base/kernels/generic/quaternary/blocked/lib/7d.js
new file mode 100644
index 000000000000..173b1fbc77af
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/kernels/generic/quaternary/blocked/lib/7d.js
@@ -0,0 +1,484 @@
+/**
+* @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, max-lines-per-function, max-len */
+
+'use strict';
+
+// MODULES //
+
+var loopOrder = require( '@stdlib/ndarray/base/quaternary-loop-interchange-order' );
+var blockSize = require( '@stdlib/ndarray/base/quaternary-tiling-block-size' );
+
+
+// MAIN //
+
+/**
+* Applies a quaternary callback to elements in seven-dimensional input ndarrays and assigns results 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 input 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 {Object} z - object containing input ndarray meta data
+* @param {*} z.dtype - data type
+* @param {Collection} z.data - data buffer
+* @param {NonNegativeIntegerArray} z.shape - dimensions
+* @param {IntegerArray} z.strides - stride lengths
+* @param {NonNegativeInteger} z.offset - index offset
+* @param {string} z.order - specifies whether `z` is row-major (C-style) or column-major (Fortran-style)
+* @param {Object} w - object containing input ndarray meta data
+* @param {*} w.dtype - data type
+* @param {Collection} w.data - data buffer
+* @param {NonNegativeIntegerArray} w.shape - dimensions
+* @param {IntegerArray} w.strides - stride lengths
+* @param {NonNegativeInteger} w.offset - index offset
+* @param {string} w.order - specifies whether `w` is row-major (C-style) or column-major (Fortran-style)
+* @param {Object} u - object containing output ndarray meta data
+* @param {*} u.dtype - data type
+* @param {Collection} u.data - data buffer
+* @param {NonNegativeIntegerArray} u.shape - dimensions
+* @param {IntegerArray} u.strides - stride lengths
+* @param {NonNegativeInteger} u.offset - index offset
+* @param {string} u.order - specifies whether `u` is row-major (C-style) or column-major (Fortran-style)
+* @param {Callback} fcn - quaternary callback
+*
+* @example
+* var Float64Array = require( '@stdlib/array/float64' );
+* var ndarray2array = require( '@stdlib/ndarray/base/to-array' );
+* var add4 = require( '@stdlib/number/float64/base/add4' );
+*
+* // Create data buffers:
+* var xbuf = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 ] );
+* var ybuf = new Float64Array( [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ] );
+* var zbuf = new Float64Array( [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ] );
+* var wbuf = new Float64Array( [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ] );
+* var ubuf = new Float64Array( 8 );
+*
+* // Define the shape of the input and output arrays:
+* var shape = [ 1, 1, 1, 1, 2, 2, 2 ];
+*
+* // Define the array strides:
+* var sx = [ 8, 8, 8, 8, 4, 2, 1 ];
+* var sy = [ 8, 8, 8, 8, 4, 2, 1 ];
+* var sz = [ 8, 8, 8, 8, 4, 2, 1 ];
+* var sw = [ 8, 8, 8, 8, 4, 2, 1 ];
+* var su = [ 8, 8, 8, 8, 4, 2, 1 ];
+*
+* // Define the index offsets:
+* var ox = 0;
+* var oy = 0;
+* var oz = 0;
+* var ow = 0;
+* var ou = 0;
+*
+* // Create the input and output ndarray-like objects:
+* var x = {
+*     'dtype': 'float64',
+*     'data': xbuf,
+*     'shape': shape,
+*     'strides': sx,
+*     'offset': ox,
+*     'order': 'row-major'
+* };
+* var y = {
+*     'dtype': 'float64',
+*     'data': ybuf,
+*     'shape': shape,
+*     'strides': sy,
+*     'offset': oy,
+*     'order': 'row-major'
+* };
+* var z = {
+*     'dtype': 'float64',
+*     'data': zbuf,
+*     'shape': shape,
+*     'strides': sz,
+*     'offset': oz,
+*     'order': 'row-major'
+* };
+* var w = {
+*     'dtype': 'float64',
+*     'data': wbuf,
+*     'shape': shape,
+*     'strides': sw,
+*     'offset': ow,
+*     'order': 'row-major'
+* };
+* var u = {
+*     'dtype': 'float64',
+*     'data': ubuf,
+*     'shape': shape,
+*     'strides': su,
+*     'offset': ou,
+*     'order': 'row-major'
+* };
+*
+* // Apply the quaternary function:
+* blockedquaternary7d( x, y, z, w, u, add4 );
+*
+* var arr = ndarray2array( u.data, u.shape, u.strides, u.offset, u.order );
+* // returns [ [ [ [ [ [ [ 4.0, 5.0 ], [ 6.0, 7.0 ] ], [ [ 8.0, 9.0 ], [ 10.0, 11.0 ] ] ] ] ] ] ]
+*/
+function blockedquaternary7d( x, y, z, w, u, fcn ) {
+	var bsize;
+	var xbuf;
+	var ybuf;
+	var zbuf;
+	var wbuf;
+	var ubuf;
+	var dx0;
+	var dx1;
+	var dx2;
+	var dx3;
+	var dx4;
+	var dx5;
+	var dx6;
+	var dy0;
+	var dy1;
+	var dy2;
+	var dy3;
+	var dy4;
+	var dy5;
+	var dy6;
+	var dz0;
+	var dz1;
+	var dz2;
+	var dz3;
+	var dz4;
+	var dz5;
+	var dz6;
+	var dw0;
+	var dw1;
+	var dw2;
+	var dw3;
+	var dw4;
+	var dw5;
+	var dw6;
+	var du0;
+	var du1;
+	var du2;
+	var du3;
+	var du4;
+	var du5;
+	var du6;
+	var ox1;
+	var ox2;
+	var ox3;
+	var ox4;
+	var ox5;
+	var ox6;
+	var oy1;
+	var oy2;
+	var oy3;
+	var oy4;
+	var oy5;
+	var oy6;
+	var oz1;
+	var oz2;
+	var oz3;
+	var oz4;
+	var oz5;
+	var oz6;
+	var ow1;
+	var ow2;
+	var ow3;
+	var ow4;
+	var ow5;
+	var ow6;
+	var ou1;
+	var ou2;
+	var ou3;
+	var ou4;
+	var ou5;
+	var ou6;
+	var sh;
+	var s0;
+	var s1;
+	var s2;
+	var s3;
+	var s4;
+	var s5;
+	var s6;
+	var sx;
+	var sy;
+	var sz;
+	var sw;
+	var su;
+	var ox;
+	var oy;
+	var oz;
+	var ow;
+	var ou;
+	var ix;
+	var iy;
+	var iz;
+	var iw;
+	var iu;
+	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#, dx#, dy#, dz#, dw#, du#, i#, j# where # corresponds to the loop number, with `0` being the innermost loop...
+
+	// Resolve the loop interchange order:
+	o = loopOrder( x.shape, x.strides, y.strides, z.strides, w.strides, u.strides );
+	sh = o.sh;
+	sx = o.sx;
+	sy = o.sy;
+	sz = o.sz;
+	sw = o.sw;
+	su = o.su;
+
+	// Determine the block size:
+	bsize = blockSize( x.dtype, y.dtype, z.dtype, w.dtype, u.dtype );
+
+	// Cache the indices of the first indexed elements in the respective ndarrays...
+	ox = x.offset;
+	oy = y.offset;
+	oz = z.offset;
+	ow = w.offset;
+	ou = u.offset;
+
+	// Cache references to the input and output ndarray buffers...
+	xbuf = x.data;
+	ybuf = y.data;
+	zbuf = z.data;
+	wbuf = w.data;
+	ubuf = u.data;
+
+	// Cache offset increments for the innermost loop...
+	dx0 = sx[0];
+	dy0 = sy[0];
+	dz0 = sz[0];
+	dw0 = sw[0];
+	du0 = su[0];
+
+	// Iterate over blocks...
+	for ( j6 = sh[6]; j6 > 0; ) {
+		if ( j6 < bsize ) {
+			s6 = j6;
+			j6 = 0;
+		} else {
+			s6 = bsize;
+			j6 -= bsize;
+		}
+		ox6 = ox + ( j6*sx[6] );
+		oy6 = oy + ( j6*sy[6] );
+		oz6 = oz + ( j6*sz[6] );
+		ow6 = ow + ( j6*sw[6] );
+		ou6 = ou + ( j6*su[6] );
+		for ( j5 = sh[5]; j5 > 0; ) {
+			if ( j5 < bsize ) {
+				s5 = j5;
+				j5 = 0;
+			} else {
+				s5 = bsize;
+				j5 -= bsize;
+			}
+			dx6 = sx[6] - ( s5*sx[5] );
+			dy6 = sy[6] - ( s5*sy[5] );
+			dz6 = sz[6] - ( s5*sz[5] );
+			dw6 = sw[6] - ( s5*sw[5] );
+			du6 = su[6] - ( s5*su[5] );
+			ox5 = ox6 + ( j5*sx[5] );
+			oy5 = oy6 + ( j5*sy[5] );
+			oz5 = oz6 + ( j5*sz[5] );
+			ow5 = ow6 + ( j5*sw[5] );
+			ou5 = ou6 + ( j5*su[5] );
+			for ( j4 = sh[4]; j4 > 0; ) {
+				if ( j4 < bsize ) {
+					s4 = j4;
+					j4 = 0;
+				} else {
+					s4 = bsize;
+					j4 -= bsize;
+				}
+				dx5 = sx[5] - ( s4*sx[4] );
+				dy5 = sy[5] - ( s4*sy[4] );
+				dz5 = sz[5] - ( s4*sz[4] );
+				dw5 = sw[5] - ( s4*sw[4] );
+				du5 = su[5] - ( s4*su[4] );
+				ox4 = ox5 + ( j4*sx[4] );
+				oy4 = oy5 + ( j4*sy[4] );
+				oz4 = oz5 + ( j4*sz[4] );
+				ow4 = ow5 + ( j4*sw[4] );
+				ou4 = ou5 + ( j4*su[4] );
+				for ( j3 = sh[3]; j3 > 0; ) {
+					if ( j3 < bsize ) {
+						s3 = j3;
+						j3 = 0;
+					} else {
+						s3 = bsize;
+						j3 -= bsize;
+					}
+					dx4 = sx[4] - ( s3*sx[3] );
+					dy4 = sy[4] - ( s3*sy[3] );
+					dz4 = sz[4] - ( s3*sz[3] );
+					dw4 = sw[4] - ( s3*sw[3] );
+					du4 = su[4] - ( s3*su[3] );
+					ox3 = ox4 + ( j3*sx[3] );
+					oy3 = oy4 + ( j3*sy[3] );
+					oz3 = oz4 + ( j3*sz[3] );
+					ow3 = ow4 + ( j3*sw[3] );
+					ou3 = ou4 + ( j3*su[3] );
+					for ( j2 = sh[2]; j2 > 0; ) {
+						if ( j2 < bsize ) {
+							s2 = j2;
+							j2 = 0;
+						} else {
+							s2 = bsize;
+							j2 -= bsize;
+						}
+						dx3 = sx[3] - ( s2*sx[2] );
+						dy3 = sy[3] - ( s2*sy[2] );
+						dz3 = sz[3] - ( s2*sz[2] );
+						dw3 = sw[3] - ( s2*sw[2] );
+						du3 = su[3] - ( s2*su[2] );
+						ox2 = ox3 + ( j2*sx[2] );
+						oy2 = oy3 + ( j2*sy[2] );
+						oz2 = oz3 + ( j2*sz[2] );
+						ow2 = ow3 + ( j2*sw[2] );
+						ou2 = ou3 + ( j2*su[2] );
+						for ( j1 = sh[1]; j1 > 0; ) {
+							if ( j1 < bsize ) {
+								s1 = j1;
+								j1 = 0;
+							} else {
+								s1 = bsize;
+								j1 -= bsize;
+							}
+							dx2 = sx[2] - ( s1*sx[1] );
+							dy2 = sy[2] - ( s1*sy[1] );
+							dz2 = sz[2] - ( s1*sz[1] );
+							dw2 = sw[2] - ( s1*sw[1] );
+							du2 = su[2] - ( s1*su[1] );
+							ox1 = ox2 + ( j1*sx[1] );
+							oy1 = oy2 + ( j1*sy[1] );
+							oz1 = oz2 + ( j1*sz[1] );
+							ow1 = ow2 + ( j1*sw[1] );
+							ou1 = ou2 + ( j1*su[1] );
+							for ( j0 = sh[0]; j0 > 0; ) {
+								if ( j0 < bsize ) {
+									s0 = j0;
+									j0 = 0;
+								} else {
+									s0 = bsize;
+									j0 -= bsize;
+								}
+								// Compute index offsets for the first input and output ndarray elements in the current block...
+								ix = ox1 + ( j0*sx[0] );
+								iy = oy1 + ( j0*sy[0] );
+								iz = oz1 + ( j0*sz[0] );
+								iw = ow1 + ( j0*sw[0] );
+								iu = ou1 + ( j0*su[0] );
+
+								// Compute loop offset increments...
+								dx1 = sx[1] - ( s0*sx[0] );
+								dy1 = sy[1] - ( s0*sy[0] );
+								dz1 = sz[1] - ( s0*sz[0] );
+								dw1 = sw[1] - ( s0*sw[0] );
+								du1 = su[1] - ( s0*su[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++ ) {
+															ubuf[ iu ] = fcn( xbuf[ ix ], ybuf[ iy ], zbuf[ iz ], wbuf[ iw ] );
+															ix += dx0;
+															iy += dy0;
+															iz += dz0;
+															iw += dw0;
+															iu += du0;
+														}
+														ix += dx1;
+														iy += dy1;
+														iz += dz1;
+														iw += dw1;
+														iu += du1;
+													}
+													ix += dx2;
+													iy += dy2;
+													iz += dz2;
+													iw += dw2;
+													iu += du2;
+												}
+												ix += dx3;
+												iy += dy3;
+												iz += dz3;
+												iw += dw3;
+												iu += du3;
+											}
+											ix += dx4;
+											iy += dy4;
+											iz += dz4;
+											iw += dw4;
+											iu += du4;
+										}
+										ix += dx5;
+										iy += dy5;
+										iz += dz5;
+										iw += dw5;
+										iu += du5;
+									}
+									ix += dx6;
+									iy += dy6;
+									iz += dz6;
+									iw += dw6;
+									iu += du6;
+								}
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+}
+
+
+// EXPORTS //
+
+module.exports = blockedquaternary7d;
diff --git a/lib/node_modules/@stdlib/ndarray/base/kernels/generic/quaternary/blocked/lib/8d.js b/lib/node_modules/@stdlib/ndarray/base/kernels/generic/quaternary/blocked/lib/8d.js
new file mode 100644
index 000000000000..3c41ff7a5f5b
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/kernels/generic/quaternary/blocked/lib/8d.js
@@ -0,0 +1,523 @@
+/**
+* @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, max-lines-per-function, max-lines, max-len */
+
+'use strict';
+
+// MODULES //
+
+var loopOrder = require( '@stdlib/ndarray/base/quaternary-loop-interchange-order' );
+var blockSize = require( '@stdlib/ndarray/base/quaternary-tiling-block-size' );
+
+
+// MAIN //
+
+/**
+* Applies a quaternary callback to elements in eight-dimensional input ndarrays and assigns results 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 input 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 {Object} z - object containing input ndarray meta data
+* @param {*} z.dtype - data type
+* @param {Collection} z.data - data buffer
+* @param {NonNegativeIntegerArray} z.shape - dimensions
+* @param {IntegerArray} z.strides - stride lengths
+* @param {NonNegativeInteger} z.offset - index offset
+* @param {string} z.order - specifies whether `z` is row-major (C-style) or column-major (Fortran-style)
+* @param {Object} w - object containing input ndarray meta data
+* @param {*} w.dtype - data type
+* @param {Collection} w.data - data buffer
+* @param {NonNegativeIntegerArray} w.shape - dimensions
+* @param {IntegerArray} w.strides - stride lengths
+* @param {NonNegativeInteger} w.offset - index offset
+* @param {string} w.order - specifies whether `w` is row-major (C-style) or column-major (Fortran-style)
+* @param {Object} u - object containing output ndarray meta data
+* @param {*} u.dtype - data type
+* @param {Collection} u.data - data buffer
+* @param {NonNegativeIntegerArray} u.shape - dimensions
+* @param {IntegerArray} u.strides - stride lengths
+* @param {NonNegativeInteger} u.offset - index offset
+* @param {string} u.order - specifies whether `u` is row-major (C-style) or column-major (Fortran-style)
+* @param {Callback} fcn - quaternary callback
+*
+* @example
+* var Float64Array = require( '@stdlib/array/float64' );
+* var ndarray2array = require( '@stdlib/ndarray/base/to-array' );
+* var add4 = require( '@stdlib/number/float64/base/add4' );
+*
+* // Create data buffers:
+* var xbuf = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 ] );
+* var ybuf = new Float64Array( [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ] );
+* var zbuf = new Float64Array( [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ] );
+* var wbuf = new Float64Array( [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ] );
+* var ubuf = new Float64Array( 8 );
+*
+* // Define the shape of the input and output arrays:
+* var shape = [ 1, 1, 1, 1, 1, 2, 2, 2 ];
+*
+* // Define the array strides:
+* var sx = [ 8, 8, 8, 8, 8, 4, 2, 1 ];
+* var sy = [ 8, 8, 8, 8, 8, 4, 2, 1 ];
+* var sz = [ 8, 8, 8, 8, 8, 4, 2, 1 ];
+* var sw = [ 8, 8, 8, 8, 8, 4, 2, 1 ];
+* var su = [ 8, 8, 8, 8, 8, 4, 2, 1 ];
+*
+* // Define the index offsets:
+* var ox = 0;
+* var oy = 0;
+* var oz = 0;
+* var ow = 0;
+* var ou = 0;
+*
+* // Create the input and output ndarray-like objects:
+* var x = {
+*     'dtype': 'float64',
+*     'data': xbuf,
+*     'shape': shape,
+*     'strides': sx,
+*     'offset': ox,
+*     'order': 'row-major'
+* };
+* var y = {
+*     'dtype': 'float64',
+*     'data': ybuf,
+*     'shape': shape,
+*     'strides': sy,
+*     'offset': oy,
+*     'order': 'row-major'
+* };
+* var z = {
+*     'dtype': 'float64',
+*     'data': zbuf,
+*     'shape': shape,
+*     'strides': sz,
+*     'offset': oz,
+*     'order': 'row-major'
+* };
+* var w = {
+*     'dtype': 'float64',
+*     'data': wbuf,
+*     'shape': shape,
+*     'strides': sw,
+*     'offset': ow,
+*     'order': 'row-major'
+* };
+* var u = {
+*     'dtype': 'float64',
+*     'data': ubuf,
+*     'shape': shape,
+*     'strides': su,
+*     'offset': ou,
+*     'order': 'row-major'
+* };
+*
+* // Apply the quaternary function:
+* blockedquaternary8d( x, y, z, w, u, add4 );
+*
+* var arr = ndarray2array( u.data, u.shape, u.strides, u.offset, u.order );
+* // returns [ [ [ [ [ [ [ [ 4.0, 5.0 ], [ 6.0, 7.0 ] ], [ [ 8.0, 9.0 ], [ 10.0, 11.0 ] ] ] ] ] ] ] ]
+*/
+function blockedquaternary8d( x, y, z, w, u, fcn ) {
+	var bsize;
+	var xbuf;
+	var ybuf;
+	var zbuf;
+	var wbuf;
+	var ubuf;
+	var dx0;
+	var dx1;
+	var dx2;
+	var dx3;
+	var dx4;
+	var dx5;
+	var dx6;
+	var dx7;
+	var dy0;
+	var dy1;
+	var dy2;
+	var dy3;
+	var dy4;
+	var dy5;
+	var dy6;
+	var dy7;
+	var dz0;
+	var dz1;
+	var dz2;
+	var dz3;
+	var dz4;
+	var dz5;
+	var dz6;
+	var dz7;
+	var dw0;
+	var dw1;
+	var dw2;
+	var dw3;
+	var dw4;
+	var dw5;
+	var dw6;
+	var dw7;
+	var du0;
+	var du1;
+	var du2;
+	var du3;
+	var du4;
+	var du5;
+	var du6;
+	var du7;
+	var ox1;
+	var ox2;
+	var ox3;
+	var ox4;
+	var ox5;
+	var ox6;
+	var ox7;
+	var oy1;
+	var oy2;
+	var oy3;
+	var oy4;
+	var oy5;
+	var oy6;
+	var oy7;
+	var oz1;
+	var oz2;
+	var oz3;
+	var oz4;
+	var oz5;
+	var oz6;
+	var oz7;
+	var ow1;
+	var ow2;
+	var ow3;
+	var ow4;
+	var ow5;
+	var ow6;
+	var ow7;
+	var ou1;
+	var ou2;
+	var ou3;
+	var ou4;
+	var ou5;
+	var ou6;
+	var ou7;
+	var sh;
+	var s0;
+	var s1;
+	var s2;
+	var s3;
+	var s4;
+	var s5;
+	var s6;
+	var s7;
+	var sx;
+	var sy;
+	var sz;
+	var sw;
+	var su;
+	var ox;
+	var oy;
+	var oz;
+	var ow;
+	var ou;
+	var ix;
+	var iy;
+	var iz;
+	var iw;
+	var iu;
+	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#, dx#, dy#, dz#, dw#, du#, i#, j# where # corresponds to the loop number, with `0` being the innermost loop...
+
+	// Resolve the loop interchange order:
+	o = loopOrder( x.shape, x.strides, y.strides, z.strides, w.strides, u.strides );
+	sh = o.sh;
+	sx = o.sx;
+	sy = o.sy;
+	sz = o.sz;
+	sw = o.sw;
+	su = o.su;
+
+	// Determine the block size:
+	bsize = blockSize( x.dtype, y.dtype, z.dtype, w.dtype, u.dtype );
+
+	// Cache the indices of the first indexed elements in the respective ndarrays...
+	ox = x.offset;
+	oy = y.offset;
+	oz = z.offset;
+	ow = w.offset;
+	ou = u.offset;
+
+	// Cache references to the input and output ndarray buffers...
+	xbuf = x.data;
+	ybuf = y.data;
+	zbuf = z.data;
+	wbuf = w.data;
+	ubuf = u.data;
+
+	// Cache offset increments for the innermost loop...
+	dx0 = sx[0];
+	dy0 = sy[0];
+	dz0 = sz[0];
+	dw0 = sw[0];
+	du0 = su[0];
+
+	// Iterate over blocks...
+	for ( j7 = sh[7]; j7 > 0; ) {
+		if ( j7 < bsize ) {
+			s7 = j7;
+			j7 = 0;
+		} else {
+			s7 = bsize;
+			j7 -= bsize;
+		}
+		ox7 = ox + ( j7*sx[7] );
+		oy7 = oy + ( j7*sy[7] );
+		oz7 = oz + ( j7*sz[7] );
+		ow7 = ow + ( j7*sw[7] );
+		ou7 = ou + ( j7*su[7] );
+		for ( j6 = sh[6]; j6 > 0; ) {
+			if ( j6 < bsize ) {
+				s6 = j6;
+				j6 = 0;
+			} else {
+				s6 = bsize;
+				j6 -= bsize;
+			}
+			dx7 = sx[7] - ( s6*sx[6] );
+			dy7 = sy[7] - ( s6*sy[6] );
+			dz7 = sz[7] - ( s6*sz[6] );
+			dw7 = sw[7] - ( s6*sw[6] );
+			du7 = su[7] - ( s6*su[6] );
+			ox6 = ox7 + ( j6*sx[6] );
+			oy6 = oy7 + ( j6*sy[6] );
+			oz6 = oz7 + ( j6*sz[6] );
+			ow6 = ow7 + ( j6*sw[6] );
+			ou6 = ou7 + ( j6*su[6] );
+			for ( j5 = sh[5]; j5 > 0; ) {
+				if ( j5 < bsize ) {
+					s5 = j5;
+					j5 = 0;
+				} else {
+					s5 = bsize;
+					j5 -= bsize;
+				}
+				dx6 = sx[6] - ( s5*sx[5] );
+				dy6 = sy[6] - ( s5*sy[5] );
+				dz6 = sz[6] - ( s5*sz[5] );
+				dw6 = sw[6] - ( s5*sw[5] );
+				du6 = su[6] - ( s5*su[5] );
+				ox5 = ox6 + ( j5*sx[5] );
+				oy5 = oy6 + ( j5*sy[5] );
+				oz5 = oz6 + ( j5*sz[5] );
+				ow5 = ow6 + ( j5*sw[5] );
+				ou5 = ou6 + ( j5*su[5] );
+				for ( j4 = sh[4]; j4 > 0; ) {
+					if ( j4 < bsize ) {
+						s4 = j4;
+						j4 = 0;
+					} else {
+						s4 = bsize;
+						j4 -= bsize;
+					}
+					dx5 = sx[5] - ( s4*sx[4] );
+					dy5 = sy[5] - ( s4*sy[4] );
+					dz5 = sz[5] - ( s4*sz[4] );
+					dw5 = sw[5] - ( s4*sw[4] );
+					du5 = su[5] - ( s4*su[4] );
+					ox4 = ox5 + ( j4*sx[4] );
+					oy4 = oy5 + ( j4*sy[4] );
+					oz4 = oz5 + ( j4*sz[4] );
+					ow4 = ow5 + ( j4*sw[4] );
+					ou4 = ou5 + ( j4*su[4] );
+					for ( j3 = sh[3]; j3 > 0; ) {
+						if ( j3 < bsize ) {
+							s3 = j3;
+							j3 = 0;
+						} else {
+							s3 = bsize;
+							j3 -= bsize;
+						}
+						dx4 = sx[4] - ( s3*sx[3] );
+						dy4 = sy[4] - ( s3*sy[3] );
+						dz4 = sz[4] - ( s3*sz[3] );
+						dw4 = sw[4] - ( s3*sw[3] );
+						du4 = su[4] - ( s3*su[3] );
+						ox3 = ox4 + ( j3*sx[3] );
+						oy3 = oy4 + ( j3*sy[3] );
+						oz3 = oz4 + ( j3*sz[3] );
+						ow3 = ow4 + ( j3*sw[3] );
+						ou3 = ou4 + ( j3*su[3] );
+						for ( j2 = sh[2]; j2 > 0; ) {
+							if ( j2 < bsize ) {
+								s2 = j2;
+								j2 = 0;
+							} else {
+								s2 = bsize;
+								j2 -= bsize;
+							}
+							dx3 = sx[3] - ( s2*sx[2] );
+							dy3 = sy[3] - ( s2*sy[2] );
+							dz3 = sz[3] - ( s2*sz[2] );
+							dw3 = sw[3] - ( s2*sw[2] );
+							du3 = su[3] - ( s2*su[2] );
+							ox2 = ox3 + ( j2*sx[2] );
+							oy2 = oy3 + ( j2*sy[2] );
+							oz2 = oz3 + ( j2*sz[2] );
+							ow2 = ow3 + ( j2*sw[2] );
+							ou2 = ou3 + ( j2*su[2] );
+							for ( j1 = sh[1]; j1 > 0; ) {
+								if ( j1 < bsize ) {
+									s1 = j1;
+									j1 = 0;
+								} else {
+									s1 = bsize;
+									j1 -= bsize;
+								}
+								dx2 = sx[2] - ( s1*sx[1] );
+								dy2 = sy[2] - ( s1*sy[1] );
+								dz2 = sz[2] - ( s1*sz[1] );
+								dw2 = sw[2] - ( s1*sw[1] );
+								du2 = su[2] - ( s1*su[1] );
+								ox1 = ox2 + ( j1*sx[1] );
+								oy1 = oy2 + ( j1*sy[1] );
+								oz1 = oz2 + ( j1*sz[1] );
+								ow1 = ow2 + ( j1*sw[1] );
+								ou1 = ou2 + ( j1*su[1] );
+								for ( j0 = sh[0]; j0 > 0; ) {
+									if ( j0 < bsize ) {
+										s0 = j0;
+										j0 = 0;
+									} else {
+										s0 = bsize;
+										j0 -= bsize;
+									}
+									// Compute index offsets for the first input and output ndarray elements in the current block...
+									ix = ox1 + ( j0*sx[0] );
+									iy = oy1 + ( j0*sy[0] );
+									iz = oz1 + ( j0*sz[0] );
+									iw = ow1 + ( j0*sw[0] );
+									iu = ou1 + ( j0*su[0] );
+
+									// Compute loop offset increments...
+									dx1 = sx[1] - ( s0*sx[0] );
+									dy1 = sy[1] - ( s0*sy[0] );
+									dz1 = sz[1] - ( s0*sz[0] );
+									dw1 = sw[1] - ( s0*sw[0] );
+									du1 = su[1] - ( s0*su[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++ ) {
+																	ubuf[ iu ] = fcn( xbuf[ ix ], ybuf[ iy ], zbuf[ iz ], wbuf[ iw ] );
+																	ix += dx0;
+																	iy += dy0;
+																	iz += dz0;
+																	iw += dw0;
+																	iu += du0;
+																}
+																ix += dx1;
+																iy += dy1;
+																iz += dz1;
+																iw += dw1;
+																iu += du1;
+															}
+															ix += dx2;
+															iy += dy2;
+															iz += dz2;
+															iw += dw2;
+															iu += du2;
+														}
+														ix += dx3;
+														iy += dy3;
+														iz += dz3;
+														iw += dw3;
+														iu += du3;
+													}
+													ix += dx4;
+													iy += dy4;
+													iz += dz4;
+													iw += dw4;
+													iu += du4;
+												}
+												ix += dx5;
+												iy += dy5;
+												iz += dz5;
+												iw += dw5;
+												iu += du5;
+											}
+											ix += dx6;
+											iy += dy6;
+											iz += dz6;
+											iw += dw6;
+											iu += du6;
+										}
+										ix += dx7;
+										iy += dy7;
+										iz += dz7;
+										iw += dw7;
+										iu += du7;
+									}
+								}
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+}
+
+
+// EXPORTS //
+
+module.exports = blockedquaternary8d;
diff --git a/lib/node_modules/@stdlib/ndarray/base/kernels/generic/quaternary/blocked/lib/9d.js b/lib/node_modules/@stdlib/ndarray/base/kernels/generic/quaternary/blocked/lib/9d.js
new file mode 100644
index 000000000000..ef0c0131f465
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/kernels/generic/quaternary/blocked/lib/9d.js
@@ -0,0 +1,562 @@
+/**
+* @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, max-lines-per-function, max-len, max-lines */
+
+'use strict';
+
+// MODULES //
+
+var loopOrder = require( '@stdlib/ndarray/base/quaternary-loop-interchange-order' );
+var blockSize = require( '@stdlib/ndarray/base/quaternary-tiling-block-size' );
+
+
+// MAIN //
+
+/**
+* Applies a quaternary callback to elements in nine-dimensional input ndarrays and assigns results 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 input 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 {Object} z - object containing input ndarray meta data
+* @param {*} z.dtype - data type
+* @param {Collection} z.data - data buffer
+* @param {NonNegativeIntegerArray} z.shape - dimensions
+* @param {IntegerArray} z.strides - stride lengths
+* @param {NonNegativeInteger} z.offset - index offset
+* @param {string} z.order - specifies whether `z` is row-major (C-style) or column-major (Fortran-style)
+* @param {Object} w - object containing input ndarray meta data
+* @param {*} w.dtype - data type
+* @param {Collection} w.data - data buffer
+* @param {NonNegativeIntegerArray} w.shape - dimensions
+* @param {IntegerArray} w.strides - stride lengths
+* @param {NonNegativeInteger} w.offset - index offset
+* @param {string} w.order - specifies whether `w` is row-major (C-style) or column-major (Fortran-style)
+* @param {Object} u - object containing output ndarray meta data
+* @param {*} u.dtype - data type
+* @param {Collection} u.data - data buffer
+* @param {NonNegativeIntegerArray} u.shape - dimensions
+* @param {IntegerArray} u.strides - stride lengths
+* @param {NonNegativeInteger} u.offset - index offset
+* @param {string} u.order - specifies whether `u` is row-major (C-style) or column-major (Fortran-style)
+* @param {Callback} fcn - quaternary callback
+*
+* @example
+* var Float64Array = require( '@stdlib/array/float64' );
+* var ndarray2array = require( '@stdlib/ndarray/base/to-array' );
+* var add4 = require( '@stdlib/number/float64/base/add4' );
+*
+* // Create data buffers:
+* var xbuf = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0 ] );
+* var ybuf = new Float64Array( [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ] );
+* var zbuf = new Float64Array( [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ] );
+* var wbuf = new Float64Array( [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ] );
+* var ubuf = new Float64Array( 8 );
+*
+* // Define the shape of the input and output arrays:
+* var shape = [ 1, 1, 1, 1, 1, 1, 2, 2, 2 ];
+*
+* // Define the array strides:
+* var sx = [ 8, 8, 8, 8, 8, 8, 4, 2, 1 ];
+* var sy = [ 8, 8, 8, 8, 8, 8, 4, 2, 1 ];
+* var sz = [ 8, 8, 8, 8, 8, 8, 4, 2, 1 ];
+* var sw = [ 8, 8, 8, 8, 8, 8, 4, 2, 1 ];
+* var su = [ 8, 8, 8, 8, 8, 8, 4, 2, 1 ];
+*
+* // Define the index offsets:
+* var ox = 0;
+* var oy = 0;
+* var oz = 0;
+* var ow = 0;
+* var ou = 0;
+*
+* // Create the input and output ndarray-like objects:
+* var x = {
+*     'dtype': 'float64',
+*     'data': xbuf,
+*     'shape': shape,
+*     'strides': sx,
+*     'offset': ox,
+*     'order': 'row-major'
+* };
+* var y = {
+*     'dtype': 'float64',
+*     'data': ybuf,
+*     'shape': shape,
+*     'strides': sy,
+*     'offset': oy,
+*     'order': 'row-major'
+* };
+* var z = {
+*     'dtype': 'float64',
+*     'data': zbuf,
+*     'shape': shape,
+*     'strides': sz,
+*     'offset': oz,
+*     'order': 'row-major'
+* };
+* var w = {
+*     'dtype': 'float64',
+*     'data': wbuf,
+*     'shape': shape,
+*     'strides': sw,
+*     'offset': ow,
+*     'order': 'row-major'
+* };
+* var u = {
+*     'dtype': 'float64',
+*     'data': ubuf,
+*     'shape': shape,
+*     'strides': su,
+*     'offset': ou,
+*     'order': 'row-major'
+* };
+*
+* // Apply the quaternary function:
+* blockedquaternary9d( x, y, z, w, u, add4 );
+*
+* var arr = ndarray2array( u.data, u.shape, u.strides, u.offset, u.order );
+* // returns [ [ [ [ [ [ [ [ [ 4.0, 5.0 ], [ 6.0, 7.0 ] ], [ [ 8.0, 9.0 ], [ 10.0, 11.0 ] ] ] ] ] ] ] ] ]
+*/
+function blockedquaternary9d( x, y, z, w, u, fcn ) {
+	var bsize;
+	var xbuf;
+	var ybuf;
+	var zbuf;
+	var wbuf;
+	var ubuf;
+	var dx0;
+	var dx1;
+	var dx2;
+	var dx3;
+	var dx4;
+	var dx5;
+	var dx6;
+	var dx7;
+	var dx8;
+	var dy0;
+	var dy1;
+	var dy2;
+	var dy3;
+	var dy4;
+	var dy5;
+	var dy6;
+	var dy7;
+	var dy8;
+	var dz0;
+	var dz1;
+	var dz2;
+	var dz3;
+	var dz4;
+	var dz5;
+	var dz6;
+	var dz7;
+	var dz8;
+	var dw0;
+	var dw1;
+	var dw2;
+	var dw3;
+	var dw4;
+	var dw5;
+	var dw6;
+	var dw7;
+	var dw8;
+	var du0;
+	var du1;
+	var du2;
+	var du3;
+	var du4;
+	var du5;
+	var du6;
+	var du7;
+	var du8;
+	var ox1;
+	var ox2;
+	var ox3;
+	var ox4;
+	var ox5;
+	var ox6;
+	var ox7;
+	var ox8;
+	var oy1;
+	var oy2;
+	var oy3;
+	var oy4;
+	var oy5;
+	var oy6;
+	var oy7;
+	var oy8;
+	var oz1;
+	var oz2;
+	var oz3;
+	var oz4;
+	var oz5;
+	var oz6;
+	var oz7;
+	var oz8;
+	var ow1;
+	var ow2;
+	var ow3;
+	var ow4;
+	var ow5;
+	var ow6;
+	var ow7;
+	var ow8;
+	var ou1;
+	var ou2;
+	var ou3;
+	var ou4;
+	var ou5;
+	var ou6;
+	var ou7;
+	var ou8;
+	var sh;
+	var s0;
+	var s1;
+	var s2;
+	var s3;
+	var s4;
+	var s5;
+	var s6;
+	var s7;
+	var s8;
+	var sx;
+	var sy;
+	var sz;
+	var sw;
+	var su;
+	var ox;
+	var oy;
+	var oz;
+	var ow;
+	var ou;
+	var ix;
+	var iy;
+	var iz;
+	var iw;
+	var iu;
+	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#, dx#, dy#, dz#, dw#, du#, i#, j# where # corresponds to the loop number, with `0` being the innermost loop...
+
+	// Resolve the loop interchange order:
+	o = loopOrder( x.shape, x.strides, y.strides, z.strides, w.strides, u.strides );
+	sh = o.sh;
+	sx = o.sx;
+	sy = o.sy;
+	sz = o.sz;
+	sw = o.sw;
+	su = o.su;
+
+	// Determine the block size:
+	bsize = blockSize( x.dtype, y.dtype, z.dtype, w.dtype, u.dtype );
+
+	// Cache the indices of the first indexed elements in the respective ndarrays...
+	ox = x.offset;
+	oy = y.offset;
+	oz = z.offset;
+	ow = w.offset;
+	ou = u.offset;
+
+	// Cache references to the input and output ndarray buffers...
+	xbuf = x.data;
+	ybuf = y.data;
+	zbuf = z.data;
+	wbuf = w.data;
+	ubuf = u.data;
+
+	// Cache offset increments for the innermost loop...
+	dx0 = sx[0];
+	dy0 = sy[0];
+	dz0 = sz[0];
+	dw0 = sw[0];
+	du0 = su[0];
+
+	// Iterate over blocks...
+	for ( j8 = sh[8]; j8 > 0; ) {
+		if ( j8 < bsize ) {
+			s8 = j8;
+			j8 = 0;
+		} else {
+			s8 = bsize;
+			j8 -= bsize;
+		}
+		ox8 = ox + ( j8*sx[8] );
+		oy8 = oy + ( j8*sy[8] );
+		oz8 = oz + ( j8*sz[8] );
+		ow8 = ow + ( j8*sw[8] );
+		ou8 = ou + ( j8*su[8] );
+		for ( j7 = sh[7]; j7 > 0; ) {
+			if ( j7 < bsize ) {
+				s7 = j7;
+				j7 = 0;
+			} else {
+				s7 = bsize;
+				j7 -= bsize;
+			}
+			dx8 = sx[8] - ( s7*sx[7] );
+			dy8 = sy[8] - ( s7*sy[7] );
+			dz8 = sz[8] - ( s7*sz[7] );
+			dw8 = sw[8] - ( s7*sw[7] );
+			du8 = su[8] - ( s7*su[7] );
+			ox7 = ox8 + ( j7*sx[7] );
+			oy7 = oy8 + ( j7*sy[7] );
+			oz7 = oz8 + ( j7*sz[7] );
+			ow7 = ow8 + ( j7*sw[7] );
+			ou7 = ou8 + ( j7*su[7] );
+			for ( j6 = sh[6]; j6 > 0; ) {
+				if ( j6 < bsize ) {
+					s6 = j6;
+					j6 = 0;
+				} else {
+					s6 = bsize;
+					j6 -= bsize;
+				}
+				dx7 = sx[7] - ( s6*sx[6] );
+				dy7 = sy[7] - ( s6*sy[6] );
+				dz7 = sz[7] - ( s6*sz[6] );
+				dw7 = sw[7] - ( s6*sw[6] );
+				du7 = su[7] - ( s6*su[6] );
+				ox6 = ox7 + ( j6*sx[6] );
+				oy6 = oy7 + ( j6*sy[6] );
+				oz6 = oz7 + ( j6*sz[6] );
+				ow6 = ow7 + ( j6*sw[6] );
+				ou6 = ou7 + ( j6*su[6] );
+				for ( j5 = sh[5]; j5 > 0; ) {
+					if ( j5 < bsize ) {
+						s5 = j5;
+						j5 = 0;
+					} else {
+						s5 = bsize;
+						j5 -= bsize;
+					}
+					dx6 = sx[6] - ( s5*sx[5] );
+					dy6 = sy[6] - ( s5*sy[5] );
+					dz6 = sz[6] - ( s5*sz[5] );
+					dw6 = sw[6] - ( s5*sw[5] );
+					du6 = su[6] - ( s5*su[5] );
+					ox5 = ox6 + ( j5*sx[5] );
+					oy5 = oy6 + ( j5*sy[5] );
+					oz5 = oz6 + ( j5*sz[5] );
+					ow5 = ow6 + ( j5*sw[5] );
+					ou5 = ou6 + ( j5*su[5] );
+					for ( j4 = sh[4]; j4 > 0; ) {
+						if ( j4 < bsize ) {
+							s4 = j4;
+							j4 = 0;
+						} else {
+							s4 = bsize;
+							j4 -= bsize;
+						}
+						dx5 = sx[5] - ( s4*sx[4] );
+						dy5 = sy[5] - ( s4*sy[4] );
+						dz5 = sz[5] - ( s4*sz[4] );
+						dw5 = sw[5] - ( s4*sw[4] );
+						du5 = su[5] - ( s4*su[4] );
+						ox4 = ox5 + ( j4*sx[4] );
+						oy4 = oy5 + ( j4*sy[4] );
+						oz4 = oz5 + ( j4*sz[4] );
+						ow4 = ow5 + ( j4*sw[4] );
+						ou4 = ou5 + ( j4*su[4] );
+						for ( j3 = sh[3]; j3 > 0; ) {
+							if ( j3 < bsize ) {
+								s3 = j3;
+								j3 = 0;
+							} else {
+								s3 = bsize;
+								j3 -= bsize;
+							}
+							dx4 = sx[4] - ( s3*sx[3] );
+							dy4 = sy[4] - ( s3*sy[3] );
+							dz4 = sz[4] - ( s3*sz[3] );
+							dw4 = sw[4] - ( s3*sw[3] );
+							du4 = su[4] - ( s3*su[3] );
+							ox3 = ox4 + ( j3*sx[3] );
+							oy3 = oy4 + ( j3*sy[3] );
+							oz3 = oz4 + ( j3*sz[3] );
+							ow3 = ow4 + ( j3*sw[3] );
+							ou3 = ou4 + ( j3*su[3] );
+							for ( j2 = sh[2]; j2 > 0; ) {
+								if ( j2 < bsize ) {
+									s2 = j2;
+									j2 = 0;
+								} else {
+									s2 = bsize;
+									j2 -= bsize;
+								}
+								dx3 = sx[3] - ( s2*sx[2] );
+								dy3 = sy[3] - ( s2*sy[2] );
+								dz3 = sz[3] - ( s2*sz[2] );
+								dw3 = sw[3] - ( s2*sw[2] );
+								du3 = su[3] - ( s2*su[2] );
+								ox2 = ox3 + ( j2*sx[2] );
+								oy2 = oy3 + ( j2*sy[2] );
+								oz2 = oz3 + ( j2*sz[2] );
+								ow2 = ow3 + ( j2*sw[2] );
+								ou2 = ou3 + ( j2*su[2] );
+								for ( j1 = sh[1]; j1 > 0; ) {
+									if ( j1 < bsize ) {
+										s1 = j1;
+										j1 = 0;
+									} else {
+										s1 = bsize;
+										j1 -= bsize;
+									}
+									dx2 = sx[2] - ( s1*sx[1] );
+									dy2 = sy[2] - ( s1*sy[1] );
+									dz2 = sz[2] - ( s1*sz[1] );
+									dw2 = sw[2] - ( s1*sw[1] );
+									du2 = su[2] - ( s1*su[1] );
+									ox1 = ox2 + ( j1*sx[1] );
+									oy1 = oy2 + ( j1*sy[1] );
+									oz1 = oz2 + ( j1*sz[1] );
+									ow1 = ow2 + ( j1*sw[1] );
+									ou1 = ou2 + ( j1*su[1] );
+									for ( j0 = sh[0]; j0 > 0; ) {
+										if ( j0 < bsize ) {
+											s0 = j0;
+											j0 = 0;
+										} else {
+											s0 = bsize;
+											j0 -= bsize;
+										}
+										// Compute index offsets for the first input and output ndarray elements in the current block...
+										ix = ox1 + ( j0*sx[0] );
+										iy = oy1 + ( j0*sy[0] );
+										iz = oz1 + ( j0*sz[0] );
+										iw = ow1 + ( j0*sw[0] );
+										iu = ou1 + ( j0*su[0] );
+
+										// Compute loop offset increments...
+										dx1 = sx[1] - ( s0*sx[0] );
+										dy1 = sy[1] - ( s0*sy[0] );
+										dz1 = sz[1] - ( s0*sz[0] );
+										dw1 = sw[1] - ( s0*sw[0] );
+										du1 = su[1] - ( s0*su[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++ ) {
+																			ubuf[ iu ] = fcn( xbuf[ ix ], ybuf[ iy ], zbuf[ iz ], wbuf[ iw ] );
+																			ix += dx0;
+																			iy += dy0;
+																			iz += dz0;
+																			iw += dw0;
+																			iu += du0;
+																		}
+																		ix += dx1;
+																		iy += dy1;
+																		iz += dz1;
+																		iw += dw1;
+																		iu += du1;
+																	}
+																	ix += dx2;
+																	iy += dy2;
+																	iz += dz2;
+																	iw += dw2;
+																	iu += du2;
+																}
+																ix += dx3;
+																iy += dy3;
+																iz += dz3;
+																iw += dw3;
+																iu += du3;
+															}
+															ix += dx4;
+															iy += dy4;
+															iz += dz4;
+															iw += dw4;
+															iu += du4;
+														}
+														ix += dx5;
+														iy += dy5;
+														iz += dz5;
+														iw += dw5;
+														iu += du5;
+													}
+													ix += dx6;
+													iy += dy6;
+													iz += dz6;
+													iw += dw6;
+													iu += du6;
+												}
+												ix += dx7;
+												iy += dy7;
+												iz += dz7;
+												iw += dw7;
+												iu += du7;
+											}
+											ix += dx8;
+											iy += dy8;
+											iz += dz8;
+											iw += dw8;
+											iu += du8;
+										}
+									}
+								}
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+}
+
+
+// EXPORTS //
+
+module.exports = blockedquaternary9d;
diff --git a/lib/node_modules/@stdlib/ndarray/base/kernels/generic/quaternary/blocked/lib/index.js b/lib/node_modules/@stdlib/ndarray/base/kernels/generic/quaternary/blocked/lib/index.js
new file mode 100644
index 000000000000..a1f4ca2cad46
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/kernels/generic/quaternary/blocked/lib/index.js
@@ -0,0 +1,131 @@
+/**
+* @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';
+
+/**
+* Return a kernel for applying a quaternary callback to elements in four input ndarrays and assigning results to elements in an output ndarray using loop blocking.
+*
+* @module @stdlib/ndarray/base/kernels/generic/quaternary/blocked
+*
+* @example
+* var Float64Array = require( '@stdlib/array/float64' );
+* var ndarray2array = require( '@stdlib/ndarray/base/to-array' );
+* var add4 = require( '@stdlib/number/float64/base/add4' );
+* var kernel = require( '@stdlib/ndarray/base/kernels/generic/quaternary/blocked' );
+*
+* // Create data buffers:
+* var xbuf = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] );
+* var ybuf = new Float64Array( [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ] );
+* var zbuf = new Float64Array( [ 2.0, 2.0, 2.0, 2.0, 2.0, 2.0 ] );
+* var wbuf = new Float64Array( [ 3.0, 3.0, 3.0, 3.0, 3.0, 3.0 ] );
+* var ubuf = new Float64Array( 6 );
+*
+* // Define the shape of the input and output arrays:
+* var shape = [ 3, 2 ];
+*
+* // Define the array strides:
+* var sx = [ 2, 1 ];
+* var sy = [ 2, 1 ];
+* var sz = [ 2, 1 ];
+* var sw = [ 2, 1 ];
+* var su = [ 2, 1 ];
+*
+* // Create the input and output ndarray-like objects:
+* var x = {
+*     'dtype': 'float64',
+*     'data': xbuf,
+*     'shape': shape,
+*     'strides': sx,
+*     'offset': 0,
+*     'order': 'row-major'
+* };
+* var y = {
+*     'dtype': 'float64',
+*     'data': ybuf,
+*     'shape': shape,
+*     'strides': sy,
+*     'offset': 0,
+*     'order': 'row-major'
+* };
+* var z = {
+*     'dtype': 'float64',
+*     'data': zbuf,
+*     'shape': shape,
+*     'strides': sz,
+*     'offset': 0,
+*     'order': 'row-major'
+* };
+* var w = {
+*     'dtype': 'float64',
+*     'data': wbuf,
+*     'shape': shape,
+*     'strides': sw,
+*     'offset': 0,
+*     'order': 'row-major'
+* };
+* var u = {
+*     'dtype': 'float64',
+*     'data': ubuf,
+*     'shape': shape,
+*     'strides': su,
+*     'offset': 0,
+*     'order': 'row-major'
+* };
+*
+* // Resolve a kernel:
+* var f = kernel( 2 );
+*
+* // Apply the quaternary function:
+* f( x, y, z, w, u, add4 );
+*
+* var arr = ndarray2array( u.data, u.shape, u.strides, u.offset, u.order );
+* // returns [ [ 7.0, 8.0 ], [ 9.0, 10.0 ], [ 11.0, 12.0 ] ]
+*/
+
+// MODULES //
+
+var setReadOnly = require( '@stdlib/utils/define-nonenumerable-read-only-property' );
+var kernel2d = require( './2d.js' );
+var kernel3d = require( './3d.js' );
+var kernel4d = require( './4d.js' );
+var kernel5d = require( './5d.js' );
+var kernel6d = require( './6d.js' );
+var kernel7d = require( './7d.js' );
+var kernel8d = require( './8d.js' );
+var kernel9d = require( './9d.js' );
+var kernel10d = require( './10d.js' );
+var main = require( './main.js' );
+
+
+// MAIN //
+
+setReadOnly( main, 'kernel2d', kernel2d );
+setReadOnly( main, 'kernel3d', kernel3d );
+setReadOnly( main, 'kernel4d', kernel4d );
+setReadOnly( main, 'kernel5d', kernel5d );
+setReadOnly( main, 'kernel6d', kernel6d );
+setReadOnly( main, 'kernel7d', kernel7d );
+setReadOnly( main, 'kernel8d', kernel8d );
+setReadOnly( main, 'kernel9d', kernel9d );
+setReadOnly( main, 'kernel10d', kernel10d );
+
+
+// EXPORTS //
+
+module.exports = main;
diff --git a/lib/node_modules/@stdlib/ndarray/base/kernels/generic/quaternary/blocked/lib/main.js b/lib/node_modules/@stdlib/ndarray/base/kernels/generic/quaternary/blocked/lib/main.js
new file mode 100644
index 000000000000..349543ff37b1
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/kernels/generic/quaternary/blocked/lib/main.js
@@ -0,0 +1,141 @@
+/**
+* @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 kernel2d = require( './2d.js' );
+var kernel3d = require( './3d.js' );
+var kernel4d = require( './4d.js' );
+var kernel5d = require( './5d.js' );
+var kernel6d = require( './6d.js' );
+var kernel7d = require( './7d.js' );
+var kernel8d = require( './8d.js' );
+var kernel9d = require( './9d.js' );
+var kernel10d = require( './10d.js' );
+
+
+// VARIABLES //
+
+var KERNELS = [
+	kernel2d, // 0
+	kernel3d,
+	kernel4d,
+	kernel5d,
+	kernel6d,
+	kernel7d,
+	kernel8d,
+	kernel9d,
+	kernel10d // 8
+];
+var MAX_DIMS = KERNELS.length + 1;
+
+
+// MAIN //
+
+/**
+* Returns a kernel for applying a quaternary callback to elements in four input ndarrays and assigning results to elements in an output ndarray using loop blocking.
+*
+* @param {integer} ndims - number of dimensions
+* @returns {(Function|null)} kernel function or null
+*
+* @example
+* var Float64Array = require( '@stdlib/array/float64' );
+* var ndarray2array = require( '@stdlib/ndarray/base/to-array' );
+* var add4 = require( '@stdlib/number/float64/base/add4' );
+*
+* // Create data buffers:
+* var xbuf = new Float64Array( [ 1.0, 2.0, 3.0, 4.0, 5.0, 6.0 ] );
+* var ybuf = new Float64Array( [ 1.0, 1.0, 1.0, 1.0, 1.0, 1.0 ] );
+* var zbuf = new Float64Array( [ 2.0, 2.0, 2.0, 2.0, 2.0, 2.0 ] );
+* var wbuf = new Float64Array( [ 3.0, 3.0, 3.0, 3.0, 3.0, 3.0 ] );
+* var ubuf = new Float64Array( 6 );
+*
+* // Define the shape of the input and output arrays:
+* var shape = [ 3, 2 ];
+*
+* // Define the array strides:
+* var sx = [ 2, 1 ];
+* var sy = [ 2, 1 ];
+* var sz = [ 2, 1 ];
+* var sw = [ 2, 1 ];
+* var su = [ 2, 1 ];
+*
+* // Create the input and output ndarray-like objects:
+* var x = {
+*     'dtype': 'float64',
+*     'data': xbuf,
+*     'shape': shape,
+*     'strides': sx,
+*     'offset': 0,
+*     'order': 'row-major'
+* };
+* var y = {
+*     'dtype': 'float64',
+*     'data': ybuf,
+*     'shape': shape,
+*     'strides': sy,
+*     'offset': 0,
+*     'order': 'row-major'
+* };
+* var z = {
+*     'dtype': 'float64',
+*     'data': zbuf,
+*     'shape': shape,
+*     'strides': sz,
+*     'offset': 0,
+*     'order': 'row-major'
+* };
+* var w = {
+*     'dtype': 'float64',
+*     'data': wbuf,
+*     'shape': shape,
+*     'strides': sw,
+*     'offset': 0,
+*     'order': 'row-major'
+* };
+* var u = {
+*     'dtype': 'float64',
+*     'data': ubuf,
+*     'shape': shape,
+*     'strides': su,
+*     'offset': 0,
+*     'order': 'row-major'
+* };
+*
+* // Resolve a kernel:
+* var f = kernel( 2 );
+*
+* // Apply the quaternary function:
+* f( x, y, z, w, u, add4 );
+*
+* var arr = ndarray2array( u.data, u.shape, u.strides, u.offset, u.order );
+* // returns [ [ 7.0, 8.0 ], [ 9.0, 10.0 ], [ 11.0, 12.0 ] ]
+*/
+function kernel( ndims ) {
+	if ( ndims < 2 || ndims > MAX_DIMS ) {
+		return null;
+	}
+	return KERNELS[ ndims-2 ];
+}
+
+
+// EXPORTS //
+
+module.exports = kernel;
diff --git a/lib/node_modules/@stdlib/ndarray/base/kernels/generic/quaternary/blocked/package.json b/lib/node_modules/@stdlib/ndarray/base/kernels/generic/quaternary/blocked/package.json
new file mode 100644
index 000000000000..1c993bff3bea
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/kernels/generic/quaternary/blocked/package.json
@@ -0,0 +1,64 @@
+{
+  "name": "@stdlib/ndarray/base/kernels/generic/quaternary/blocked",
+  "version": "0.0.0",
+  "description": "Return a kernel for applying a quaternary callback to elements in four input ndarrays and assigning results to elements in an output ndarray using loop blocking.",
+  "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",
+    "ndarray",
+    "quaternary",
+    "apply",
+    "element-wise",
+    "elementwise",
+    "callback",
+    "kernel",
+    "blocked"
+  ],
+  "__stdlib__": {}
+}
diff --git a/lib/node_modules/@stdlib/ndarray/base/kernels/generic/quaternary/blocked/test/fixtures/large_10d.json b/lib/node_modules/@stdlib/ndarray/base/kernels/generic/quaternary/blocked/test/fixtures/large_10d.json
new file mode 100644
index 000000000000..8bb1cd190ba8
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/kernels/generic/quaternary/blocked/test/fixtures/large_10d.json
@@ -0,0 +1,50 @@
+{
+  "row_major_shapes": [
+    [16, 1, 1, 1, 1, 1, 1, 1, 1, 2],
+    [1, 16, 1, 1, 1, 1, 1, 1, 1, 2],
+    [1, 1, 16, 1, 1, 1, 1, 1, 1, 2],
+    [1, 1, 1, 16, 1, 1, 1, 1, 1, 2],
+    [1, 1, 1, 1, 16, 1, 1, 1, 1, 2],
+    [1, 1, 1, 1, 1, 16, 1, 1, 1, 2],
+    [1, 1, 1, 1, 1, 1, 16, 1, 1, 2],
+    [1, 1, 1, 1, 1, 1, 1, 16, 1, 2],
+    [1, 1, 1, 1, 1, 1, 1, 1, 16, 2],
+    [1, 1, 1, 1, 1, 1, 1, 1, 2, 16]
+  ],
+  "row_major_strides": [
+    [-4, -4, -4, -4, -4, -4, -4, -4, -4, 2],
+    [-64, -4, -4, -4, -4, -4, -4, -4, -4, 2],
+    [-64, -64, -4, -4, -4, -4, -4, -4, -4, 2],
+    [-64, -64, -64, -4, -4, -4, -4, -4, -4, 2],
+    [-64, -64, -64, -64, -4, -4, -4, -4, -4, 2],
+    [-64, -64, -64, -64, -64, -4, -4, -4, -4, 2],
+    [-64, -64, -64, -64, -64, -64, -4, -4, -4, 2],
+    [-64, -64, -64, -64, -64, -64, -64, -4, -4, 2],
+    [-64, -64, -64, -64, -64, -64, -64, -64, -4, 2],
+    [64, 64, 64, 64, 64, 64, 64, 64, 32, -2]
+  ],
+  "column_major_shapes": [
+    [2, 1, 1, 1, 1, 1, 1, 1, 1, 16],
+    [2, 1, 1, 1, 1, 1, 1, 1, 16, 1],
+    [2, 1, 1, 1, 1, 1, 1, 16, 1, 1],
+    [2, 1, 1, 1, 1, 1, 16, 1, 1, 1],
+    [2, 1, 1, 1, 1, 16, 1, 1, 1, 1],
+    [2, 1, 1, 1, 16, 1, 1, 1, 1, 1],
+    [2, 1, 1, 16, 1, 1, 1, 1, 1, 1],
+    [2, 1, 16, 1, 1, 1, 1, 1, 1, 1],
+    [2, 16, 1, 1, 1, 1, 1, 1, 1, 1],
+    [16, 2, 1, 1, 1, 1, 1, 1, 1, 1]
+  ],
+  "column_major_strides": [
+    [2, -4, -4, -4, -4, -4, -4, -4, -4, -4],
+    [2, -4, -4, -4, -4, -4, -4, -4, -4, -64],
+    [2, -4, -4, -4, -4, -4, -4, -4, -64, -64],
+    [2, -4, -4, -4, -4, -4, -4, -64, -64, -64],
+    [2, -4, -4, -4, -4, -4, -64, -64, -64, -64],
+    [2, -4, -4, -4, -4, -64, -64, -64, -64, -64],
+    [2, -4, -4, -4, -64, -64, -64, -64, -64, -64],
+    [2, -4, -4, -64, -64, -64, -64, -64, -64, -64],
+    [2, -4, -64, -64, -64, -64, -64, -64, -64, -64],
+    [-2, 32, 64, 64, 64, 64, 64, 64, 64, 64]
+  ]
+}
diff --git a/lib/node_modules/@stdlib/ndarray/base/kernels/generic/quaternary/blocked/test/fixtures/large_2d.json b/lib/node_modules/@stdlib/ndarray/base/kernels/generic/quaternary/blocked/test/fixtures/large_2d.json
new file mode 100644
index 000000000000..37edb1d0d2ec
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/kernels/generic/quaternary/blocked/test/fixtures/large_2d.json
@@ -0,0 +1,18 @@
+{
+  "row_major_shapes": [
+    [16, 2],
+    [2, 16]
+  ],
+  "row_major_strides": [
+    [-4, 2],
+    [32, -2]
+  ],
+  "column_major_shapes": [
+    [2, 16],
+    [16, 2]
+  ],
+  "column_major_strides": [
+    [2, -4],
+    [-2, 32]
+  ]
+}
diff --git a/lib/node_modules/@stdlib/ndarray/base/kernels/generic/quaternary/blocked/test/fixtures/large_3d.json b/lib/node_modules/@stdlib/ndarray/base/kernels/generic/quaternary/blocked/test/fixtures/large_3d.json
new file mode 100644
index 000000000000..07eaf71a41c5
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/kernels/generic/quaternary/blocked/test/fixtures/large_3d.json
@@ -0,0 +1,22 @@
+{
+  "row_major_shapes": [
+    [16, 1, 2],
+    [1, 16, 2],
+    [1, 2, 16]
+  ],
+  "row_major_strides": [
+    [-4, -4, 2],
+    [-64, -4, 2],
+    [64, 32, -2]
+  ],
+  "column_major_shapes": [
+    [2, 1, 16],
+    [2, 16, 1],
+    [16, 2, 1]
+  ],
+  "column_major_strides": [
+    [2, -4, -4],
+    [2, -4, -64],
+    [-2, 32, 64]
+  ]
+}
diff --git a/lib/node_modules/@stdlib/ndarray/base/kernels/generic/quaternary/blocked/test/fixtures/large_4d.json b/lib/node_modules/@stdlib/ndarray/base/kernels/generic/quaternary/blocked/test/fixtures/large_4d.json
new file mode 100644
index 000000000000..b7a256735153
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/kernels/generic/quaternary/blocked/test/fixtures/large_4d.json
@@ -0,0 +1,26 @@
+{
+  "row_major_shapes": [
+    [16, 1, 1, 2],
+    [1, 16, 1, 2],
+    [1, 1, 16, 2],
+    [1, 1, 2, 16]
+  ],
+  "row_major_strides": [
+    [-4, -4, -4, 2],
+    [-64, -4, -4, 2],
+    [-64, -64, -4, 2],
+    [64, 64, 32, -2]
+  ],
+  "column_major_shapes": [
+    [2, 1, 1, 16],
+    [2, 1, 16, 1],
+    [2, 16, 1, 1],
+    [16, 2, 1, 1]
+  ],
+  "column_major_strides": [
+    [2, -4, -4, -4],
+    [2, -4, -4, -64],
+    [2, -4, -64, -64],
+    [-2, 32, 64, 64]
+  ]
+}
diff --git a/lib/node_modules/@stdlib/ndarray/base/kernels/generic/quaternary/blocked/test/fixtures/large_5d.json b/lib/node_modules/@stdlib/ndarray/base/kernels/generic/quaternary/blocked/test/fixtures/large_5d.json
new file mode 100644
index 000000000000..27f3de836110
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/kernels/generic/quaternary/blocked/test/fixtures/large_5d.json
@@ -0,0 +1,30 @@
+{
+  "row_major_shapes": [
+    [16, 1, 1, 1, 2],
+    [1, 16, 1, 1, 2],
+    [1, 1, 16, 1, 2],
+    [1, 1, 1, 16, 2],
+    [1, 1, 1, 2, 16]
+  ],
+  "row_major_strides": [
+    [-4, -4, -4, -4, 2],
+    [-64, -4, -4, -4, 2],
+    [-64, -64, -4, -4, 2],
+    [-64, -64, -64, -4, 2],
+    [64, 64, 64, 32, -2]
+  ],
+  "column_major_shapes": [
+    [2, 1, 1, 1, 16],
+    [2, 1, 1, 16, 1],
+    [2, 1, 16, 1, 1],
+    [2, 16, 1, 1, 1],
+    [16, 2, 1, 1, 1]
+  ],
+  "column_major_strides": [
+    [2, -4, -4, -4, -4],
+    [2, -4, -4, -4, -64],
+    [2, -4, -4, -64, -64],
+    [2, -4, -64, -64, -64],
+    [-2, 32, 64, 64, 64]
+  ]
+}
diff --git a/lib/node_modules/@stdlib/ndarray/base/kernels/generic/quaternary/blocked/test/fixtures/large_6d.json b/lib/node_modules/@stdlib/ndarray/base/kernels/generic/quaternary/blocked/test/fixtures/large_6d.json
new file mode 100644
index 000000000000..9fc75c38dc5b
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/kernels/generic/quaternary/blocked/test/fixtures/large_6d.json
@@ -0,0 +1,34 @@
+{
+  "row_major_shapes": [
+    [16, 1, 1, 1, 1, 2],
+    [1, 16, 1, 1, 1, 2],
+    [1, 1, 16, 1, 1, 2],
+    [1, 1, 1, 16, 1, 2],
+    [1, 1, 1, 1, 16, 2],
+    [1, 1, 1, 1, 2, 16]
+  ],
+  "row_major_strides": [
+    [-4, -4, -4, -4, -4, 2],
+    [-64, -4, -4, -4, -4, 2],
+    [-64, -64, -4, -4, -4, 2],
+    [-64, -64, -64, -4, -4, 2],
+    [-64, -64, -64, -64, -4, 2],
+    [64, 64, 64, 64, 32, -2]
+  ],
+  "column_major_shapes": [
+    [2, 1, 1, 1, 1, 16],
+    [2, 1, 1, 1, 16, 1],
+    [2, 1, 1, 16, 1, 1],
+    [2, 1, 16, 1, 1, 1],
+    [2, 16, 1, 1, 1, 1],
+    [16, 2, 1, 1, 1, 1]
+  ],
+  "column_major_strides": [
+    [2, -4, -4, -4, -4, -4],
+    [2, -4, -4, -4, -4, -64],
+    [2, -4, -4, -4, -64, -64],
+    [2, -4, -4, -64, -64, -64],
+    [2, -4, -64, -64, -64, -64],
+    [-2, 32, 64, 64, 64, 64]
+  ]
+}
diff --git a/lib/node_modules/@stdlib/ndarray/base/kernels/generic/quaternary/blocked/test/fixtures/large_7d.json b/lib/node_modules/@stdlib/ndarray/base/kernels/generic/quaternary/blocked/test/fixtures/large_7d.json
new file mode 100644
index 000000000000..b970cac67aca
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/kernels/generic/quaternary/blocked/test/fixtures/large_7d.json
@@ -0,0 +1,38 @@
+{
+  "row_major_shapes": [
+    [16, 1, 1, 1, 1, 1, 2],
+    [1, 16, 1, 1, 1, 1, 2],
+    [1, 1, 16, 1, 1, 1, 2],
+    [1, 1, 1, 16, 1, 1, 2],
+    [1, 1, 1, 1, 16, 1, 2],
+    [1, 1, 1, 1, 1, 16, 2],
+    [1, 1, 1, 1, 1, 2, 16]
+  ],
+  "row_major_strides": [
+    [-4, -4, -4, -4, -4, -4, 2],
+    [-64, -4, -4, -4, -4, -4, 2],
+    [-64, -64, -4, -4, -4, -4, 2],
+    [-64, -64, -64, -4, -4, -4, 2],
+    [-64, -64, -64, -64, -4, -4, 2],
+    [-64, -64, -64, -64, -64, -4, 2],
+    [64, 64, 64, 64, 64, 32, -2]
+  ],
+  "column_major_shapes": [
+    [2, 1, 1, 1, 1, 1, 16],
+    [2, 1, 1, 1, 1, 16, 1],
+    [2, 1, 1, 1, 16, 1, 1],
+    [2, 1, 1, 16, 1, 1, 1],
+    [2, 1, 16, 1, 1, 1, 1],
+    [2, 16, 1, 1, 1, 1, 1],
+    [16, 2, 1, 1, 1, 1, 1]
+  ],
+  "column_major_strides": [
+    [2, -4, -4, -4, -4, -4, -4],
+    [2, -4, -4, -4, -4, -4, -64],
+    [2, -4, -4, -4, -4, -64, -64],
+    [2, -4, -4, -4, -64, -64, -64],
+    [2, -4, -4, -64, -64, -64, -64],
+    [2, -4, -64, -64, -64, -64, -64],
+    [-2, 32, 64, 64, 64, 64, 64]
+  ]
+}
diff --git a/lib/node_modules/@stdlib/ndarray/base/kernels/generic/quaternary/blocked/test/fixtures/large_8d.json b/lib/node_modules/@stdlib/ndarray/base/kernels/generic/quaternary/blocked/test/fixtures/large_8d.json
new file mode 100644
index 000000000000..ef984d23d869
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/kernels/generic/quaternary/blocked/test/fixtures/large_8d.json
@@ -0,0 +1,42 @@
+{
+  "row_major_shapes": [
+    [16, 1, 1, 1, 1, 1, 1, 2],
+    [1, 16, 1, 1, 1, 1, 1, 2],
+    [1, 1, 16, 1, 1, 1, 1, 2],
+    [1, 1, 1, 16, 1, 1, 1, 2],
+    [1, 1, 1, 1, 16, 1, 1, 2],
+    [1, 1, 1, 1, 1, 16, 1, 2],
+    [1, 1, 1, 1, 1, 1, 16, 2],
+    [1, 1, 1, 1, 1, 1, 2, 16]
+  ],
+  "row_major_strides": [
+    [-4, -4, -4, -4, -4, -4, -4, 2],
+    [-64, -4, -4, -4, -4, -4, -4, 2],
+    [-64, -64, -4, -4, -4, -4, -4, 2],
+    [-64, -64, -64, -4, -4, -4, -4, 2],
+    [-64, -64, -64, -64, -4, -4, -4, 2],
+    [-64, -64, -64, -64, -64, -4, -4, 2],
+    [-64, -64, -64, -64, -64, -64, -4, 2],
+    [64, 64, 64, 64, 64, 64, 32, -2]
+  ],
+  "column_major_shapes": [
+    [2, 1, 1, 1, 1, 1, 1, 16],
+    [2, 1, 1, 1, 1, 1, 16, 1],
+    [2, 1, 1, 1, 1, 16, 1, 1],
+    [2, 1, 1, 1, 16, 1, 1, 1],
+    [2, 1, 1, 16, 1, 1, 1, 1],
+    [2, 1, 16, 1, 1, 1, 1, 1],
+    [2, 16, 1, 1, 1, 1, 1, 1],
+    [16, 2, 1, 1, 1, 1, 1, 1]
+  ],
+  "column_major_strides": [
+    [2, -4, -4, -4, -4, -4, -4, -4],
+    [2, -4, -4, -4, -4, -4, -4, -64],
+    [2, -4, -4, -4, -4, -4, -64, -64],
+    [2, -4, -4, -4, -4, -64, -64, -64],
+    [2, -4, -4, -4, -64, -64, -64, -64],
+    [2, -4, -4, -64, -64, -64, -64, -64],
+    [2, -4, -64, -64, -64, -64, -64, -64],
+    [-2, 32, 64, 64, 64, 64, 64, 64]
+  ]
+}
diff --git a/lib/node_modules/@stdlib/ndarray/base/kernels/generic/quaternary/blocked/test/fixtures/large_9d.json b/lib/node_modules/@stdlib/ndarray/base/kernels/generic/quaternary/blocked/test/fixtures/large_9d.json
new file mode 100644
index 000000000000..ca65a36d9beb
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/kernels/generic/quaternary/blocked/test/fixtures/large_9d.json
@@ -0,0 +1,46 @@
+{
+  "row_major_shapes": [
+    [16, 1, 1, 1, 1, 1, 1, 1, 2],
+    [1, 16, 1, 1, 1, 1, 1, 1, 2],
+    [1, 1, 16, 1, 1, 1, 1, 1, 2],
+    [1, 1, 1, 16, 1, 1, 1, 1, 2],
+    [1, 1, 1, 1, 16, 1, 1, 1, 2],
+    [1, 1, 1, 1, 1, 16, 1, 1, 2],
+    [1, 1, 1, 1, 1, 1, 16, 1, 2],
+    [1, 1, 1, 1, 1, 1, 1, 16, 2],
+    [1, 1, 1, 1, 1, 1, 1, 2, 16]
+  ],
+  "row_major_strides": [
+    [-4, -4, -4, -4, -4, -4, -4, -4, 2],
+    [-64, -4, -4, -4, -4, -4, -4, -4, 2],
+    [-64, -64, -4, -4, -4, -4, -4, -4, 2],
+    [-64, -64, -64, -4, -4, -4, -4, -4, 2],
+    [-64, -64, -64, -64, -4, -4, -4, -4, 2],
+    [-64, -64, -64, -64, -64, -4, -4, -4, 2],
+    [-64, -64, -64, -64, -64, -64, -4, -4, 2],
+    [-64, -64, -64, -64, -64, -64, -64, -4, 2],
+    [64, 64, 64, 64, 64, 64, 64, 32, -2]
+  ],
+  "column_major_shapes": [
+    [2, 1, 1, 1, 1, 1, 1, 1, 16],
+    [2, 1, 1, 1, 1, 1, 1, 16, 1],
+    [2, 1, 1, 1, 1, 1, 16, 1, 1],
+    [2, 1, 1, 1, 1, 16, 1, 1, 1],
+    [2, 1, 1, 1, 16, 1, 1, 1, 1],
+    [2, 1, 1, 16, 1, 1, 1, 1, 1],
+    [2, 1, 16, 1, 1, 1, 1, 1, 1],
+    [2, 16, 1, 1, 1, 1, 1, 1, 1],
+    [16, 2, 1, 1, 1, 1, 1, 1, 1]
+  ],
+  "column_major_strides": [
+    [2, -4, -4, -4, -4, -4, -4, -4, -4],
+    [2, -4, -4, -4, -4, -4, -4, -4, -64],
+    [2, -4, -4, -4, -4, -4, -4, -64, -64],
+    [2, -4, -4, -4, -4, -4, -64, -64, -64],
+    [2, -4, -4, -4, -4, -64, -64, -64, -64],
+    [2, -4, -4, -4, -64, -64, -64, -64, -64],
+    [2, -4, -4, -64, -64, -64, -64, -64, -64],
+    [2, -4, -64, -64, -64, -64, -64, -64, -64],
+    [-2, 32, 64, 64, 64, 64, 64, 64, 64]
+  ]
+}
diff --git a/lib/node_modules/@stdlib/ndarray/base/kernels/generic/quaternary/blocked/test/test.js b/lib/node_modules/@stdlib/ndarray/base/kernels/generic/quaternary/blocked/test/test.js
new file mode 100644
index 000000000000..9b74dcebafb2
--- /dev/null
+++ b/lib/node_modules/@stdlib/ndarray/base/kernels/generic/quaternary/blocked/test/test.js
@@ -0,0 +1,234 @@
+/**
+* @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 isSameFloat64Array = require( '@stdlib/assert/is-same-float64array' );
+var Float64Array = require( '@stdlib/array/float64' );
+var oneTo = require( '@stdlib/array/one-to' );
+var zeros = require( '@stdlib/array/zeros' );
+var shape2strides = require( '@stdlib/ndarray/base/shape2strides' );
+var strides2offset = require( '@stdlib/ndarray/base/strides2offset' );
+var descriptor = require( '@stdlib/ndarray/base/descriptor' );
+var numel = require( '@stdlib/ndarray/base/numel' );
+var dfill = require( '@stdlib/blas/ext/base/dfill' );
+var ones = require( '@stdlib/array/ones' );
+var add4 = require( '@stdlib/number/float64/base/add4' );
+var kernel = require( './../lib' );
+var LARGE_2D = require( './fixtures/large_2d.json' );
+var LARGE_3D = require( './fixtures/large_3d.json' );
+var LARGE_4D = require( './fixtures/large_4d.json' );
+var LARGE_5D = require( './fixtures/large_5d.json' );
+var LARGE_6D = require( './fixtures/large_6d.json' );
+var LARGE_7D = require( './fixtures/large_7d.json' );
+var LARGE_8D = require( './fixtures/large_8d.json' );
+var LARGE_9D = require( './fixtures/large_9d.json' );
+var LARGE_10D = require( './fixtures/large_10d.json' );
+
+
+// TESTS //
+
+tape( 'main export is a function', function test( t ) {
+	t.ok( true, __filename );
+	t.strictEqual( typeof kernel, 'function', 'main export is a function' );
+	t.end();
+});
+
+tape( 'the function returns null if provided an unsupported number of dimensions', function test( t ) {
+	t.strictEqual( kernel( -1 ), null, 'returns expected value' );
+	t.strictEqual( kernel( 0 ), null, 'returns expected value' );
+	t.strictEqual( kernel( 1 ), null, 'returns expected value' );
+	t.strictEqual( kernel( 11 ), null, 'returns expected value' );
+	t.strictEqual( kernel( 100 ), null, 'returns expected value' );
+	t.end();
+});
+
+tape( 'the function returns a kernel for applying a quaternary callback (row-major)', function test( t ) {
+	var expected;
+	var shapes;
+	var sh;
+	var st;
+	var x;
+	var u;
+	var f;
+	var i;
+
+	shapes = [
+		[ 2, 3 ],
+		[ 2, 1, 3 ],
+		[ 1, 2, 1, 3 ],
+		[ 1, 1, 2, 1, 3 ],
+		[ 1, 1, 1, 2, 1, 3 ],
+		[ 1, 1, 1, 1, 2, 1, 3 ],
+		[ 1, 1, 1, 1, 1, 2, 1, 3 ],
+		[ 1, 1, 1, 1, 1, 1, 2, 1, 3 ],
+		[ 1, 1, 1, 1, 1, 1, 1, 2, 1, 3 ]
+	];
+	expected = new Float64Array( [ 4.0, 8.0, 12.0, 16.0, 20.0, 24.0 ] );
+
+	for ( i = 0; i < shapes.length; i++ ) {
+		sh = shapes[ i ];
+		st = shape2strides( sh, 'row-major' );
+
+		x = descriptor( 'float64', oneTo( numel( sh ), 'float64' ), sh, st, strides2offset( sh, st ), 'row-major' );
+		u = descriptor( 'float64', zeros( numel( sh ), 'float64' ), sh, st, strides2offset( sh, st ), 'row-major' );
+
+		f = kernel( sh.length );
+		f( x, x, x, x, u, add4 );
+		t.strictEqual( isSameFloat64Array( u.data, expected ), true, 'returns expected value' );
+	}
+	t.end();
+});
+
+tape( 'the function returns a kernel for applying a quaternary callback (column-major)', function test( t ) {
+	var expected;
+	var shapes;
+	var sh;
+	var st;
+	var x;
+	var u;
+	var f;
+	var i;
+
+	shapes = [
+		[ 2, 3 ],
+		[ 2, 1, 3 ],
+		[ 1, 2, 1, 3 ],
+		[ 1, 1, 2, 1, 3 ],
+		[ 1, 1, 1, 2, 1, 3 ],
+		[ 1, 1, 1, 1, 2, 1, 3 ],
+		[ 1, 1, 1, 1, 1, 2, 1, 3 ],
+		[ 1, 1, 1, 1, 1, 1, 2, 1, 3 ],
+		[ 1, 1, 1, 1, 1, 1, 1, 2, 1, 3 ]
+	];
+	expected = new Float64Array( [ 4.0, 8.0, 12.0, 16.0, 20.0, 24.0 ] );
+
+	for ( i = 0; i < shapes.length; i++ ) {
+		sh = shapes[ i ];
+		st = shape2strides( sh, 'column-major' );
+
+		x = descriptor( 'float64', oneTo( numel( sh ), 'float64' ), sh, st, strides2offset( sh, st ), 'column-major' );
+		u = descriptor( 'float64', zeros( numel( sh ), 'float64' ), sh, st, strides2offset( sh, st ), 'column-major' );
+
+		f = kernel( sh.length );
+		f( x, x, x, x, u, add4 );
+		t.strictEqual( isSameFloat64Array( u.data, expected ), true, 'returns expected value' );
+	}
+	t.end();
+});
+
+tape( 'the function returns a kernel for applying a quaternary callback (row-major, non-contiguous, large arrays)', function test( t ) {
+	var fixtures;
+	var expected;
+	var strides;
+	var shapes;
+	var len;
+	var sh;
+	var st;
+	var o;
+	var x;
+	var u;
+	var f;
+	var j;
+	var i;
+
+	fixtures = [
+		LARGE_2D,
+		LARGE_3D,
+		LARGE_4D,
+		LARGE_5D,
+		LARGE_6D,
+		LARGE_7D,
+		LARGE_8D,
+		LARGE_9D,
+		LARGE_10D
+	];
+	for ( j = 0; j < fixtures.length; j++ ) {
+		shapes = fixtures[ j ].row_major_shapes;
+		strides = fixtures[ j ].row_major_strides;
+		for ( i = 0; i < shapes.length; i++ ) {
+			sh = shapes[ i ];
+			st = strides[ i ];
+			o = strides2offset( sh, st );
+			len = numel( sh );
+
+			x = descriptor( 'float64', ones( len*2, 'float64' ), sh, st, o, 'row-major' );
+			u = descriptor( 'float64', zeros( len*2, 'float64' ), sh, st, o, 'row-major' );
+
+			f = kernel( sh.length );
+			f( x, x, x, x, u, add4 );
+
+			expected = new Float64Array( len*2 );
+			dfill( len, 4.0, expected, st[ sh.length-1 ] );
+			t.strictEqual( isSameFloat64Array( u.data, expected ), true, 'returns expected value' );
+		}
+	}
+	t.end();
+});
+
+tape( 'the function returns a kernel for applying a quaternary callback (column-major, non-contiguous, large arrays)', function test( t ) {
+	var fixtures;
+	var expected;
+	var strides;
+	var shapes;
+	var len;
+	var sh;
+	var st;
+	var o;
+	var x;
+	var u;
+	var f;
+	var j;
+	var i;
+
+	fixtures = [
+		LARGE_2D,
+		LARGE_3D,
+		LARGE_4D,
+		LARGE_5D,
+		LARGE_6D,
+		LARGE_7D,
+		LARGE_8D,
+		LARGE_9D,
+		LARGE_10D
+	];
+	for ( j = 0; j < fixtures.length; j++ ) {
+		shapes = fixtures[ j ].column_major_shapes;
+		strides = fixtures[ j ].column_major_strides;
+		for ( i = 0; i < shapes.length; i++ ) {
+			sh = shapes[ i ];
+			st = strides[ i ];
+			o = strides2offset( sh, st );
+			len = numel( sh );
+
+			x = descriptor( 'float64', ones( len*2, 'float64' ), sh, st, o, 'column-major' );
+			u = descriptor( 'float64', zeros( len*2, 'float64' ), sh, st, o, 'column-major' );
+
+			f = kernel( sh.length );
+			f( x, x, x, x, u, add4 );
+
+			expected = new Float64Array( len*2 );
+			dfill( len, 4.0, expected, st[ 0 ] );
+			t.strictEqual( isSameFloat64Array( u.data, expected ), true, 'returns expected value' );
+		}
+	}
+	t.end();
+});