diff --git a/lib/node_modules/@stdlib/number/uint64/base/string2words/README.md b/lib/node_modules/@stdlib/number/uint64/base/string2words/README.md
new file mode 100644
index 000000000000..aabf5312da17
--- /dev/null
+++ b/lib/node_modules/@stdlib/number/uint64/base/string2words/README.md
@@ -0,0 +1,136 @@
+
+
+# string2words
+
+> Parse a string representation of a 64-bit unsigned integer into high and low 32-bit words.
+
+
+
+
+
+
+
+
+
+
+
+## Usage
+
+```javascript
+var string2words = require( '@stdlib/number/uint64/base/string2words' );
+```
+
+#### string2words( str, radix )
+
+Parses a string representation of a 64-bit unsigned integer into high and low 32-bit words.
+
+```javascript
+var w = string2words( '1234', 10 );
+// returns [ 0, 1234 ]
+```
+
+The function returns an array containing two elements: a higher order word and a lower order word. The lower order word contains the less significant bits, while the higher order word contains the more significant bits.
+
+#### string2words.assign( str, radix, out, stride, offset )
+
+Parses a string representation of a 64-bit unsigned integer into high and low 32-bit words and assigns results to a provided output array.
+
+```javascript
+var Uint32Array = require( '@stdlib/array/uint32' );
+
+var out = new Uint32Array( 2 );
+// returns [ 0, 0 ]
+
+var w = string2words.assign( 'ffffffffffffffff', 16, out, 1, 0 );
+// returns [ 4294967295, 4294967295 ]
+
+var bool = ( w === out );
+// returns true
+```
+
+
+
+
+
+
+
+
+
+## Notes
+
+- The input string must be a valid representation of an unsigned 64-bit integer in the specified radix, containing no whitespace, sign symbols, or leading zeros.
+- If the provided string represents a value greater than `2^64-1` or the radix is invalid, then `0` is assigned to both high and low words.
+
+
+
+
+
+
+
+
+
+## Examples
+
+```javascript
+var string2words = require( '@stdlib/number/uint64/base/string2words' );
+
+var w = string2words( '1234', 10 );
+console.log( w );
+// => [ 0, 1234 ]
+
+w = string2words( 'abcd', 16 );
+console.log( w );
+// => [ 0, 43981 ]
+
+w = string2words( '18446744073709551615', 10 );
+console.log( w );
+// => [ 4294967295, 4294967295 ]
+
+w = string2words( '3w5e11264sgsf', 36 );
+console.log( w );
+// => [ 4294967295, 4294967295 ]
+```
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/lib/node_modules/@stdlib/number/uint64/base/string2words/benchmark/benchmark.js b/lib/node_modules/@stdlib/number/uint64/base/string2words/benchmark/benchmark.js
new file mode 100644
index 000000000000..97c82db9e5c7
--- /dev/null
+++ b/lib/node_modules/@stdlib/number/uint64/base/string2words/benchmark/benchmark.js
@@ -0,0 +1,118 @@
+/**
+* @license Apache-2.0
+*
+* Copyright (c) 2026 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+'use strict';
+
+// MODULES //
+
+var bench = require( '@stdlib/bench' );
+var Uint32Array = require( '@stdlib/array/uint32' );
+var isArray = require( '@stdlib/assert/is-array' );
+var UINT32_MAX = require( '@stdlib/constants/uint32/max' );
+var Uint64 = require( '@stdlib/number/uint64/ctor' );
+var discreteUniform = require( '@stdlib/random/array/discrete-uniform' );
+var format = require( '@stdlib/string/format' );
+var pkg = require( './../package.json' ).name;
+var string2words = require( './../lib' );
+
+
+// VARIABLES //
+
+var options = {
+ 'dtype': 'uint32'
+};
+
+
+// MAIN //
+
+bench( pkg, function benchmark( b ) {
+ var radices;
+ var values;
+ var rad;
+ var N;
+ var a;
+ var i;
+ var w;
+ var x;
+
+ N = 100;
+ x = discreteUniform( N, 0, UINT32_MAX, options );
+ values = [];
+ radices = [];
+ for ( i = 0; i < N; i++ ) {
+ a = Uint64.of( x[ i ], x[ (i+1)%N ] );
+ for ( rad = 2; rad <= 36; rad++ ) {
+ values.push( a.toString( rad ) );
+ radices.push( rad );
+ }
+ }
+
+ b.tic();
+ for ( i = 0; i < b.iterations; i++ ) {
+ w = string2words( values[ i % N ], radices[ i % N ] );
+ if ( typeof w !== 'object' ) {
+ b.fail( 'should return an array' );
+ }
+ }
+ b.toc();
+ if ( !isArray( w ) ) {
+ b.fail( 'should return an array' );
+ }
+ b.pass( 'benchmark finished' );
+ b.end();
+});
+
+bench( format( '%s:assign', pkg ), function benchmark( b ) {
+ var radices;
+ var values;
+ var out;
+ var rad;
+ var N;
+ var a;
+ var i;
+ var w;
+ var x;
+
+ N = 100;
+ x = discreteUniform( N, 0, UINT32_MAX, options );
+ values = [];
+ radices = [];
+ for ( i = 0; i < N; i++ ) {
+ a = Uint64.of( x[ i ], x[ (i+1)%N ] );
+ for ( rad = 2; rad <= 36; rad++ ) {
+ values.push( a.toString( rad ) );
+ radices.push( rad );
+ }
+ }
+
+ out = new Uint32Array( 2 );
+
+ b.tic();
+ for ( i = 0; i < b.iterations; i++ ) {
+ w = string2words.assign( values[ i % N ], radices[ i % N ], out, 1, 0 );
+ if ( typeof w !== 'object' ) {
+ b.fail( 'should return an array' );
+ }
+ }
+ b.toc();
+ if ( w !== out ) {
+ b.fail( 'should return the output array' );
+ }
+ b.pass( 'benchmark finished' );
+ b.end();
+});
diff --git a/lib/node_modules/@stdlib/number/uint64/base/string2words/docs/repl.txt b/lib/node_modules/@stdlib/number/uint64/base/string2words/docs/repl.txt
new file mode 100644
index 000000000000..4710cc02d131
--- /dev/null
+++ b/lib/node_modules/@stdlib/number/uint64/base/string2words/docs/repl.txt
@@ -0,0 +1,69 @@
+
+{{alias}}( str, radix )
+ Parses a string representation of a 64-bit unsigned integer into high and
+ low 32-bit words.
+
+ The function returns an array with two elements: a higher order word and a
+ lower order word, respectively. The lower order word contains the less
+ significant bits, while the higher order word contains the more significant
+ bits.
+
+ Parameters
+ ----------
+ str: string
+ String representation of a 64-bit unsigned integer.
+
+ radix: integer
+ Radix (base) to use for string conversion (2-36).
+
+ Returns
+ -------
+ out: Array
+ High and low words as 32-bit unsigned integers.
+
+ Examples
+ --------
+ > var w = {{alias}}( '1234', 10 )
+ [ 0, 1234 ]
+ > w = {{alias}}( 'abcd', 16 )
+ [ 0, 43981 ]
+ > w = {{alias}}( '3w5e11264sgsf', 36 )
+ [ 4294967295, 4294967295 ]
+
+
+{{alias}}.assign( str, radix, out, stride, offset )
+ Parses a string representation of a 64-bit unsigned integer into high and
+ low 32-bit words and assigns results to a provided output array.
+
+ Parameters
+ ----------
+ str: string
+ String representation of a 64-bit unsigned integer.
+
+ radix: integer
+ Radix (base) to use for string conversion (2-36).
+
+ out: Array|TypedArray|Object
+ Output array.
+
+ stride: integer
+ Output array stride.
+
+ offset: integer
+ Output array index offset.
+
+ Returns
+ -------
+ out: Array|TypedArray|Object
+ Output array.
+
+ Examples
+ --------
+ > var out = new {{alias:@stdlib/array/uint32}}( 2 );
+ > var w = {{alias}}.assign( 'ffffffffffffffff', 16, out, 1, 0 )
+ [ 4294967295, 4294967295 ]
+ > var bool = ( w === out )
+ true
+
+ See Also
+ --------
diff --git a/lib/node_modules/@stdlib/number/uint64/base/string2words/docs/types/index.d.ts b/lib/node_modules/@stdlib/number/uint64/base/string2words/docs/types/index.d.ts
new file mode 100644
index 000000000000..dcd5aeb55102
--- /dev/null
+++ b/lib/node_modules/@stdlib/number/uint64/base/string2words/docs/types/index.d.ts
@@ -0,0 +1,113 @@
+/*
+* @license Apache-2.0
+*
+* Copyright (c) 2026 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+// TypeScript Version: 4.1
+
+///
+
+import { Collection, NumericArray } from '@stdlib/types/array';
+
+/**
+* Interface describing `string2words`.
+*/
+interface StringToWords {
+ /**
+ * Parses a string representation of a 64-bit unsigned integer into high and low 32-bit words.
+ *
+ * @param str - string representation of a 64-bit unsigned integer
+ * @param radix - radix (base) to use for string conversion (2-36)
+ * @returns output array
+ *
+ * @example
+ * var out = string2words( '1234', 10 );
+ * // returns [ 0, 1234 ]
+ *
+ * out = string2words( '18446744073709551615', 10 );
+ * // returns [ 4294967295, 4294967295 ]
+ *
+ * out = string2words( 'ffffffffffffffff', 16 );
+ * // returns [ 4294967295, 4294967295 ]
+ *
+ * out = string2words( '3w5e11264sgsf', 36 );
+ * // returns [ 4294967295, 4294967295 ]
+ */
+ ( str: string, radix: number ): [ number, number ];
+
+ /**
+ * Parses a string representation of a 64-bit unsigned integer into high and low 32-bit words and assigns results to a provided output array.
+ *
+ * @param str - string representation of a 64-bit unsigned integer
+ * @param radix - radix (base) to use for string conversion (2-36)
+ * @param out - output array
+ * @param stride - stride length
+ * @param offset - starting index
+ * @returns output array
+ *
+ * @example
+ * var Uint32Array = require( '@stdlib/array/uint32' );
+ *
+ * var out = new Uint32Array( 2 );
+ * // returns [ 0, 0 ]
+ *
+ * var w = string2words.assign( 'ffffffffffffffff', 16, out, 1, 0 );
+ * // returns [ 4294967295, 4294967295 ]
+ *
+ * var bool = ( w === out );
+ * // returns true
+ */
+ assign>( str: string, radix: number, out: T, stride: number, offset: number ): T;
+}
+
+/**
+* Parses a string representation of a 64-bit unsigned integer into high and low 32-bit words.
+*
+* @param str - string representation of a 64-bit unsigned integer
+* @param radix - radix (base) to use for string conversion (2-36)
+* @returns output array
+*
+* @example
+* var out = string2words( '1234', 10 );
+* // returns [ 0, 1234 ]
+*
+* out = string2words( '18446744073709551615', 10 );
+* // returns [ 4294967295, 4294967295 ]
+*
+* out = string2words( 'ffffffffffffffff', 16 );
+* // returns [ 4294967295, 4294967295 ]
+*
+* out = string2words( '3w5e11264sgsf', 36 );
+* // returns [ 4294967295, 4294967295 ]
+*
+* @example
+* var Uint32Array = require( '@stdlib/array/uint32' );
+*
+* var out = new Uint32Array( 2 );
+* // returns [ 0, 0 ]
+*
+* var w = string2words.assign( 'ffffffffffffffff', 16, out, 1, 0 );
+* // returns [ 4294967295, 4294967295 ]
+*
+* var bool = ( w === out );
+* // returns true
+*/
+declare var string2words: StringToWords;
+
+
+// EXPORTS //
+
+export = string2words;
diff --git a/lib/node_modules/@stdlib/number/uint64/base/string2words/docs/types/test.ts b/lib/node_modules/@stdlib/number/uint64/base/string2words/docs/types/test.ts
new file mode 100644
index 000000000000..08a1420095c4
--- /dev/null
+++ b/lib/node_modules/@stdlib/number/uint64/base/string2words/docs/types/test.ts
@@ -0,0 +1,133 @@
+/*
+* @license Apache-2.0
+*
+* Copyright (c) 2026 The Stdlib Authors.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+
+import string2words = require( './index' );
+
+
+// TESTS //
+
+// The function returns an array...
+{
+ string2words( '1234', 10 ); // $ExpectType [number, number]
+}
+
+// The compiler throws an error if the function is provided a first argument that is not a string...
+{
+ string2words( 5, 10 ); // $ExpectError
+ string2words( true, 10 ); // $ExpectError
+ string2words( false, 10 ); // $ExpectError
+ string2words( null, 10 ); // $ExpectError
+ string2words( {}, 10 ); // $ExpectError
+ string2words( ( x: number ): number => x, 10 ); // $ExpectError
+}
+
+// The compiler throws an error if the function is provided a second argument that is not a number...
+{
+ string2words( '1234', '5' ); // $ExpectError
+ string2words( '1234', true ); // $ExpectError
+ string2words( '1234', false ); // $ExpectError
+ string2words( '1234', null ); // $ExpectError
+ string2words( '1234', {} ); // $ExpectError
+ string2words( '1234', ( x: number ): number => x ); // $ExpectError
+}
+
+// The compiler throws an error if the function is provided an unsupported number of arguments...
+{
+ string2words(); // $ExpectError
+ string2words( '1234', 10, 1 ); // $ExpectError
+}
+
+// Attached to the main export is an `assign` method which returns an array-like object containing numbers...
+{
+ string2words.assign( '1234', 10, [ 0, 0 ], 1, 0 ); // $ExpectType number[]
+ string2words.assign( '1234', 10, new Uint32Array( 2 ), 1, 0 ); // $ExpectType Uint32Array
+ string2words.assign( '1234', 10, new Float64Array( 2 ), 1, 0 ); // $ExpectType Float64Array
+}
+
+// The compiler throws an error if the `assign` method is provided a first argument which is not a string...
+{
+ const out = [ 0.0, 0.0 ];
+
+ string2words.assign( 5, 10, out, 1, 0 ); // $ExpectError
+ string2words.assign( true, 10, out, 1, 0 ); // $ExpectError
+ string2words.assign( false, 10, out, 1, 0 ); // $ExpectError
+ string2words.assign( null, 10, out, 1, 0 ); // $ExpectError
+ string2words.assign( [], 10, out, 1, 0 ); // $ExpectError
+ string2words.assign( {}, 10, out, 1, 0 ); // $ExpectError
+ string2words.assign( ( x: number ): number => x, 10, out, 1, 0 ); // $ExpectError
+}
+
+// The compiler throws an error if the `assign` method is provided a second argument which is not a number...
+{
+ const out = [ 0.0, 0.0 ];
+
+ string2words.assign( '1234', '5', out, 1, 0 ); // $ExpectError
+ string2words.assign( '1234', true, out, 1, 0 ); // $ExpectError
+ string2words.assign( '1234', false, out, 1, 0 ); // $ExpectError
+ string2words.assign( '1234', null, out, 1, 0 ); // $ExpectError
+ string2words.assign( '1234', [], out, 1, 0 ); // $ExpectError
+ string2words.assign( '1234', {}, out, 1, 0 ); // $ExpectError
+ string2words.assign( '1234', ( x: number ): number => x, out, 1, 0 ); // $ExpectError
+}
+
+// The compiler throws an error if the `assign` method is provided a third argument which is not an array-like object...
+{
+ string2words.assign( '1234', 10, 1, 1, 0 ); // $ExpectError
+ string2words.assign( '1234', 10, true, 1, 0 ); // $ExpectError
+ string2words.assign( '1234', 10, false, 1, 0 ); // $ExpectError
+ string2words.assign( '1234', 10, null, 1, 0 ); // $ExpectError
+ string2words.assign( '1234', 10, {}, 1, 0 ); // $ExpectError
+}
+
+// The compiler throws an error if the `assign` method is provided a fourth argument which is not a number...
+{
+ const out = [ 0.0, 0.0 ];
+
+ string2words.assign( '1234', 10, out, '5', 0 ); // $ExpectError
+ string2words.assign( '1234', 10, out, true, 0 ); // $ExpectError
+ string2words.assign( '1234', 10, out, false, 0 ); // $ExpectError
+ string2words.assign( '1234', 10, out, null, 0 ); // $ExpectError
+ string2words.assign( '1234', 10, out, [], 0 ); // $ExpectError
+ string2words.assign( '1234', 10, out, {}, 0 ); // $ExpectError
+ string2words.assign( '1234', 10, out, ( x: number ): number => x, 0 ); // $ExpectError
+}
+
+// The compiler throws an error if the `assign` method is provided a fifth argument which is not a number...
+{
+ const out = [ 0.0, 0.0 ];
+
+ string2words.assign( '1234', 10, out, 1, '5' ); // $ExpectError
+ string2words.assign( '1234', 10, out, 1, true ); // $ExpectError
+ string2words.assign( '1234', 10, out, 1, false ); // $ExpectError
+ string2words.assign( '1234', 10, out, 1, null ); // $ExpectError
+ string2words.assign( '1234', 10, out, 1, [] ); // $ExpectError
+ string2words.assign( '1234', 10, out, 1, {} ); // $ExpectError
+ string2words.assign( '1234', 10, out, 1, ( x: number ): number => x ); // $ExpectError
+}
+
+// The compiler throws an error if the `assign` method is provided an unsupported number of arguments...
+{
+ const out = [ 0.0, 0.0 ];
+
+ string2words.assign(); // $ExpectError
+ string2words.assign( '1234' ); // $ExpectError
+ string2words.assign( '1234', 10 ); // $ExpectError
+ string2words.assign( '1234', 10, out ); // $ExpectError
+ string2words.assign( '1234', 10, out, 1 ); // $ExpectError
+ string2words.assign( '1234', 10, out, 1, 0, 1 ); // $ExpectError
+}
diff --git a/lib/node_modules/@stdlib/number/uint64/base/string2words/examples/index.js b/lib/node_modules/@stdlib/number/uint64/base/string2words/examples/index.js
new file mode 100644
index 000000000000..d9eda984a20e
--- /dev/null
+++ b/lib/node_modules/@stdlib/number/uint64/base/string2words/examples/index.js
@@ -0,0 +1,37 @@
+/**
+* @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 string2words = require( './../lib' );
+
+var w = string2words( '1234', 10 );
+console.log( w );
+// => [ 0, 1234 ]
+
+w = string2words( 'abcd', 16 );
+console.log( w );
+// => [ 0, 43981 ]
+
+w = string2words( '18446744073709551615', 10 );
+console.log( w );
+// => [ 4294967295, 4294967295 ]
+
+w = string2words( '3w5e11264sgsf', 36 );
+console.log( w );
+// => [ 4294967295, 4294967295 ]
diff --git a/lib/node_modules/@stdlib/number/uint64/base/string2words/lib/assign.js b/lib/node_modules/@stdlib/number/uint64/base/string2words/lib/assign.js
new file mode 100644
index 000000000000..1f0ac8f5cdb9
--- /dev/null
+++ b/lib/node_modules/@stdlib/number/uint64/base/string2words/lib/assign.js
@@ -0,0 +1,207 @@
+/**
+* @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';
+
+// VARIABLES //
+
+var TWO_32 = 0x100000000; // 2^32
+
+/* eslint-disable array-element-newline */
+
+/**
+* A flat, strided array containing metadata for parsing large numeric strings into 64-bit values within JavaScript's 53-bit safe integer precision limits.
+*
+* Each radix from 2 to 36 is represented by a 3-element tuple: `[chunk1_len, chunk2_len, multiplier]`.
+*
+* ## Tuple Properties
+*
+* - **chunk1_len**: the maximum number of digits that can be safely parsed in a single pass without exceeding `Number.MAX_SAFE_INTEGER`.
+* - **chunk2_len**: the remaining number of digits required to fulfill the maximum width of a 64-bit unsigned integer for that radix.
+* - **multiplier**: the positional weight scalar (`radix^chunk2_len`) used to shift the place value of the first chunk when aggregating the final 64-bit split.
+*
+* @private
+* @name CHUNKMAP
+* @type {Array}
+*/
+var CHUNKMAP = [
+ // , , // radix
+ 53, 11, 2048, // 2
+ 33, 8, 6561, // 3
+ 26, 6, 4096, // 4
+ 22, 6, 15625, // 5
+ 20, 5, 7776, // 6
+ 18, 5, 16807, // 7
+ 17, 5, 32768, // 8
+ 16, 5, 59049, // 9
+ 15, 5, 100000, // 10
+ 15, 4, 14641, // 11
+ 14, 4, 20736, // 12
+ 14, 4, 28561, // 13
+ 13, 4, 38416, // 14
+ 13, 4, 50625, // 15
+ 13, 3, 4096, // 16
+ 12, 4, 83521, // 17
+ 12, 4, 104976, // 18
+ 12, 4, 130321, // 19
+ 12, 3, 8000, // 20
+ 12, 3, 9261, // 21
+ 11, 4, 234256, // 22
+ 11, 4, 279841, // 23
+ 11, 3, 13824, // 24
+ 11, 3, 15625, // 25
+ 11, 3, 17576, // 26
+ 11, 3, 19683, // 27
+ 11, 3, 21952, // 28
+ 10, 4, 707281, // 29
+ 10, 4, 810000, // 30
+ 10, 3, 29791, // 31
+ 10, 3, 32768, // 32
+ 10, 3, 35937, // 33
+ 10, 3, 39304, // 34
+ 10, 3, 42875, // 35
+ 10, 3, 46656 // 36
+];
+
+/* eslint-enable array-element-newline */
+
+/**
+* Parses a string representation of a 64-bit unsigned integer into high and low 32-bit words using two-step chunking.
+*
+* @private
+* @param {string} str - string representation of a 64-bit unsigned integer
+* @param {PositiveInteger} radix - radix (base) to use for string conversion (2-36)
+* @param {PositiveInteger} len1 - length of the first chunk
+* @param {PositiveInteger} len2 - length of the second chunk
+* @param {PositiveInteger} mult - multiplier for the place value calculation (radix raised to the power of len2)
+* @param {Collection} out - output array
+* @param {integer} stride - stride length
+* @param {NonNegativeInteger} offset - starting index
+* @returns {Collection} output array
+*
+* @example
+* var out = chunkedParse( '1111111111111111111111111111111111111111111111111111111111111111', 2, CHUNKMAP[0], CHUNKMAP[1], CHUNKMAP[2], [ 0, 0 ], 1, 0 );
+* // returns [ 4294967295, 4294967295 ]
+*
+* out = chunkedParse( '18446744073709551615', 10, CHUNKMAP[24], CHUNKMAP[25], CHUNKMAP[26], [ 0, 0 ], 1, 0 );
+* // returns [ 4294967295, 4294967295 ]
+*
+* out = chunkedParse( '3w5e11264sgsf', 36, CHUNKMAP[102], CHUNKMAP[103], CHUNKMAP[104], [ 0, 0 ], 1, 0 );
+* // returns [ 4294967295, 4294967295 ]
+*/
+function chunkedParse( str, radix, len1, len2, mult, out, stride, offset ) {
+ var chunk1;
+ var chunk2;
+ var hi;
+ var lo;
+
+ if ( str.length <= len1 ) {
+ // Parse in a single pass when input length is within chunk1 length:
+ chunk1 = parseInt( str, radix );
+ } else {
+ // Otherwise use a big chunk1 (start-aligned) and a small chunk2 (end-aligned):
+ chunk1 = parseInt( str.slice( 0, -len2 ), radix ); // everything until last `len2` digits
+ chunk2 = parseInt( str.slice( -len2 ), radix ); // `len2` digits from the end
+ }
+
+ hi = ( chunk1 / TWO_32 ) >>> 0; // integer division by 2^32
+ lo = chunk1 >>> 0; // 32-bit truncation
+
+ // Process chunk2 if applicable...
+ if ( str.length > len1 ) {
+ lo = ( lo * mult ) + chunk2;
+ hi = ( hi * mult ) + ( ( lo / TWO_32 ) >>> 0 );
+ lo >>>= 0; // 32-bit truncation
+
+ // Check if too big for uint64...
+ if ( hi >= TWO_32 ) {
+ hi = 0;
+ lo = 0;
+ }
+ }
+ out[ offset ] = hi;
+ out[ offset + stride ] = lo;
+ return out;
+}
+
+
+// MAIN //
+
+/**
+* Parses a string representation of a 64-bit unsigned integer into high and low 32-bit words and assigns results to a provided output array.
+*
+* @param {string} str - string representation of a 64-bit unsigned integer
+* @param {PositiveInteger} radix - radix (base) to use for string conversion (2-36)
+* @param {Collection} out - output array
+* @param {integer} stride - stride length
+* @param {NonNegativeInteger} offset - starting index
+* @returns {Collection} output array
+*
+* @example
+* var Uint32Array = require( '@stdlib/array/uint32' );
+*
+* var out = new Uint32Array( 2 );
+* // returns [ 0, 0 ]
+*
+* var w = assign( 'ffffffffffffffff', 16, out, 1, 0 );
+* // returns [ 4294967295, 4294967295 ]
+*
+* var bool = ( w === out );
+* // returns true
+*/
+function assign( str, radix, out, stride, offset ) {
+ var len1;
+ var len2;
+ var mult;
+ var idx;
+
+ // Check for an invalid radix...
+ if ( radix < 2 || radix > 36 ) {
+ out[ offset ] = 0;
+ out[ offset + stride ] = 0;
+ return out;
+ }
+ // Compute the index into a pre-computed strided table:
+ idx = 3 * ( radix-2 );
+
+ // Use a pre-computed table to select chunk lengths and the multiplier:
+ len1 = CHUNKMAP[ idx ];
+ len2 = CHUNKMAP[ idx+1 ];
+ mult = CHUNKMAP[ idx+2 ];
+
+ // Check if too big for uint64...
+ if ( str.length > len1+len2 ) {
+ out[ offset ] = 0;
+ out[ offset + stride ] = 0;
+ return out;
+ }
+ // Fast path for bases 2, 4, and 16, thanks to evenly splittable 32-bit halves...
+ if ( radix === 2 || radix === 4 || radix === 16 ) {
+ len1 = ( len1 + len2 ) / 2;
+ out[ offset ] = parseInt( '0' + str.slice( 0, -len1 ), radix ); // add leading zero in case the higher slice is empty
+ out[ offset + stride ] = parseInt( str.slice( -len1 ), radix );
+ return out;
+ }
+ // General path for other bases:
+ return chunkedParse( str, radix, len1, len2, mult, out, stride, offset );
+}
+
+
+// EXPORTS //
+
+module.exports = assign;
diff --git a/lib/node_modules/@stdlib/number/uint64/base/string2words/lib/index.js b/lib/node_modules/@stdlib/number/uint64/base/string2words/lib/index.js
new file mode 100644
index 000000000000..73cf1087db5c
--- /dev/null
+++ b/lib/node_modules/@stdlib/number/uint64/base/string2words/lib/index.js
@@ -0,0 +1,57 @@
+/**
+* @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';
+
+/**
+* Parse a string representation of a 64-bit unsigned integer into high and low 32-bit words.
+*
+* @module @stdlib/number/uint64/base/string2words
+*
+* @example
+* var string2words = require( '@stdlib/number/uint64/base/string2words' );
+*
+* var out = string2words( '1234', 10 );
+* // returns [ 0, 1234 ]
+*
+* out = string2words( '18446744073709551615', 10 );
+* // returns [ 4294967295, 4294967295 ]
+*
+* out = string2words( 'ffffffffffffffff', 16 );
+* // returns [ 4294967295, 4294967295 ]
+*
+* out = string2words( '3w5e11264sgsf', 36 );
+* // returns [ 4294967295, 4294967295 ]
+*/
+
+
+// MODULES //
+
+var setReadOnly = require( '@stdlib/utils/define-nonenumerable-read-only-property' );
+var assign = require( './assign.js' );
+var main = require( './main.js' );
+
+
+// MAIN //
+
+setReadOnly( main, 'assign', assign );
+
+
+// EXPORTS //
+
+module.exports = main;
diff --git a/lib/node_modules/@stdlib/number/uint64/base/string2words/lib/main.js b/lib/node_modules/@stdlib/number/uint64/base/string2words/lib/main.js
new file mode 100644
index 000000000000..27a9fb078b76
--- /dev/null
+++ b/lib/node_modules/@stdlib/number/uint64/base/string2words/lib/main.js
@@ -0,0 +1,55 @@
+/**
+* @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 assign = require( './assign.js' );
+
+
+// MAIN //
+
+/**
+* Parses a string representation of a 64-bit unsigned integer into high and low 32-bit words.
+*
+* @param {string} str - string representation of a 64-bit unsigned integer
+* @param {PositiveInteger} radix - radix (base) to use for string conversion (2-36)
+* @returns {Collection} output array
+*
+* @example
+* var out = string2words( '1234', 10 );
+* // returns [ 0, 1234 ]
+*
+* out = string2words( '18446744073709551615', 10 );
+* // returns [ 4294967295, 4294967295 ]
+*
+* out = string2words( 'ffffffffffffffff', 16 );
+* // returns [ 4294967295, 4294967295 ]
+*
+* out = string2words( '3w5e11264sgsf', 36 );
+* // returns [ 4294967295, 4294967295 ]
+*/
+function string2words( str, radix ) {
+ return assign( str, radix, [ 0, 0 ], 1, 0 );
+}
+
+
+// EXPORTS //
+
+module.exports = string2words;
diff --git a/lib/node_modules/@stdlib/number/uint64/base/string2words/package.json b/lib/node_modules/@stdlib/number/uint64/base/string2words/package.json
new file mode 100644
index 000000000000..67879c33dfe6
--- /dev/null
+++ b/lib/node_modules/@stdlib/number/uint64/base/string2words/package.json
@@ -0,0 +1,73 @@
+{
+ "name": "@stdlib/number/uint64/base/string2words",
+ "version": "0.0.0",
+ "description": "Parse a string representation of a 64-bit unsigned integer into high and low 32-bit words.",
+ "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",
+ "stdtypes",
+ "base",
+ "utilities",
+ "utility",
+ "utils",
+ "util",
+ "types",
+ "type",
+ "uint64",
+ "unsigned",
+ "64-bit",
+ "integer",
+ "int",
+ "string",
+ "parse",
+ "words",
+ "split",
+ "high",
+ "low"
+ ]
+}
diff --git a/lib/node_modules/@stdlib/number/uint64/base/string2words/test/test.assign.js b/lib/node_modules/@stdlib/number/uint64/base/string2words/test/test.assign.js
new file mode 100644
index 000000000000..e088fbffd426
--- /dev/null
+++ b/lib/node_modules/@stdlib/number/uint64/base/string2words/test/test.assign.js
@@ -0,0 +1,298 @@
+/**
+* @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 Uint32Array = require( '@stdlib/array/uint32' );
+var hasBigIntSupport = require( '@stdlib/assert/has-bigint-support' );
+var isEqualArray = require( '@stdlib/assert/is-equal-array' );
+var isInteger = require( '@stdlib/assert/is-integer' ).isPrimitive;
+var BigInt = require( '@stdlib/bigint/ctor' );
+var toWords = require( '@stdlib/number/uint64/base/to-words' );
+var MAX_SAFE_INTEGER = require( '@stdlib/constants/float64/max-safe-integer' );
+var UINT32_MAX = require( '@stdlib/constants/uint32/max' );
+var Uint64 = require( '@stdlib/number/uint64/ctor' );
+var string2words = require( './../lib/assign.js' );
+
+
+// VARIABLES //
+
+var HAS_BIGINT = hasBigIntSupport();
+
+
+// TESTS //
+
+tape( 'main export is a function', function test( t ) {
+ t.ok( true, __filename );
+ t.strictEqual( typeof string2words, 'function', 'main export is a function' );
+ t.end();
+});
+
+tape( 'the function returns a two-element numeric array containing integers', function test( t ) {
+ var out;
+ var w;
+
+ out = [ 0, 0 ];
+ w = string2words( '1234', 10, out, 1, 0 );
+
+ t.strictEqual( w, out, 'returns expected value' );
+ t.strictEqual( isInteger( w[0] ), true, 'returns expected value' );
+ t.strictEqual( isInteger( w[1] ), true, 'returns expected value' );
+
+ t.end();
+});
+
+tape( 'the function parses a string representation of a 64-bit unsigned integer into high and low 32-bit words', function test( t ) {
+ var out;
+ var w;
+
+ out = [ 0, 0 ];
+ w = string2words( '18446744073709551615', 10, out, 1, 0 );
+
+ t.strictEqual( w, out, 'returns expected value' );
+ t.strictEqual( w[0], 4294967295, 'returns expected value' );
+ t.strictEqual( w[1], 4294967295, 'returns expected value' );
+
+ t.end();
+});
+
+tape( 'the function parses a string representation of a 64-bit unsigned integer into high and low 32-bit words in bases 2 through 36', function test( t ) {
+ var expected;
+ var values;
+ var out;
+ var rad;
+ var i;
+ var s;
+ var w;
+
+ values = [
+ 0,
+ 1,
+ 2,
+ 3,
+ 4,
+ 5,
+ 10,
+ 99,
+ 100,
+ 999,
+ 1000,
+ 999999,
+ 1000000,
+ 999999999,
+ 1000000000,
+ UINT32_MAX,
+ UINT32_MAX + 1,
+ 9007199254740881, // Largest prime under 2^53
+ MAX_SAFE_INTEGER - 1,
+ MAX_SAFE_INTEGER
+ ];
+
+ out = [ 0, 0 ];
+
+ for ( i = 0; i < values.length; i++ ) {
+ values[ i ] = new Uint64( values[ i ] ); // Convert to Uint64
+ expected = toWords( values[ i ] ); // Extract words from Uint64 for verification
+
+ for ( rad = 2; rad <= 36; rad++ ) {
+ s = values[ i ].toString( rad ); // Convert the Uint64 to string with a radix
+ w = string2words( s, rad, out, 1, 0 ); // Extract words from the string reperesentation
+
+ t.ok( isEqualArray( w, expected ), 'returns expected value' );
+ t.strictEqual( w, out, 'returns expected value' );
+ }
+ }
+
+ t.end();
+});
+
+tape( 'the function parses a string representation of a 64-bit unsigned integer into high and low 32-bit words in bases 2 through 36 (larger than max safe integer)', function test( t ) {
+ var expected;
+ var values;
+ var out;
+ var rad;
+ var i;
+ var s;
+ var w;
+
+ if ( !HAS_BIGINT ) {
+ t.end();
+ return;
+ }
+
+ values = [
+ '9007199254740992', // MAX_SAFE_INTEGER + 1
+ '9999999999999999',
+ '10000000000000000',
+ '99999999999999999',
+ '100000000000000000',
+ '999999999999999999',
+ '1000000000000000000',
+ '9223372036854775783', // Largest prime under 2^63
+ '9999999999999999999',
+ '10000000000000000000',
+ '18446744073709551557', // Largest prime under 2^64
+ '18446744073709551615' // 2^64 - 1
+ ];
+
+ out = [ 0, 0 ];
+
+ for ( i = 0; i < values.length; i++ ) {
+ values[ i ] = new Uint64( BigInt( values[ i ] ) ); // Convert to Uint64
+ expected = toWords( values[ i ] ); // Extract words from Uint64 for verification
+
+ for ( rad = 2; rad <= 36; rad++ ) {
+ s = values[ i ].toString( rad ); // Convert Uint64 to string with a radix
+ w = string2words( s, rad, out, 1, 0 ); // Extract words from the string reperesentation
+
+ t.ok( isEqualArray( w, expected ), 'returns expected value' );
+ t.strictEqual( w, out, 'returns expected value' );
+ }
+ }
+
+ t.end();
+});
+
+tape( 'the function assigns 0 to both high and low words if the provided string represents a value greater than 2^64-1', function test( t ) {
+ var expected;
+ var values;
+ var out;
+ var rad;
+ var i;
+ var s;
+ var w;
+
+ values = [
+ '0x10000000000000000',
+ '0x10000000000000001',
+ '0x123456789abcdef01',
+ '0xdeadbeef15badf00d',
+ '0x1337c0de4ce5b16b055',
+ '0x123456789abcdef0123456789abcdef0'
+ ];
+
+ expected = [ 0, 0 ];
+
+ for ( i = 0; i < values.length; i++ ) {
+ values[ i ] = BigInt( values[ i ] ); // Convert to BigInt
+
+ for ( rad = 2; rad <= 36; rad++ ) {
+ s = values[ i ].toString( rad ); // Convert BigInt to string with a radix
+ out = [ 1, 1 ]; // To observe that it gets changed
+ w = string2words( s, rad, out, 1, 0 ); // Extract words from the string reperesentation
+
+ t.ok( isEqualArray( w, expected ), 'returns expected value' );
+ t.strictEqual( w, out, 'returns expected value' );
+ }
+ }
+
+ t.end();
+});
+
+tape( 'the function assigns 0 to both high and low words if provided an invalid radix', function test( t ) {
+ var expected;
+ var values;
+ var out;
+ var rad;
+ var i;
+ var w;
+
+ values = [
+ 0,
+ 1,
+ 37,
+ 38,
+ 100
+ ];
+
+ expected = [ 0, 0 ];
+
+ for ( i = 0; i < values.length; i++ ) {
+ rad = values[ i ];
+ out = [ 1, 1 ]; // To observe that it gets changed
+ w = string2words( '10', rad, out, 1, 0 );
+
+ t.ok( isEqualArray( w, expected ), 'returns expected value' );
+ t.strictEqual( w, out, 'returns expected value' );
+ }
+
+ t.end();
+});
+
+tape( 'the function supports providing an output object (array)', function test( t ) {
+ var out;
+ var w;
+
+ out = [ 0, 0 ];
+ w = string2words( '4294967296', 10, out, 1, 0 );
+
+ t.strictEqual( w, out, 'returns expected value' );
+ t.strictEqual( w[ 0 ], 1, 'returns expected value' );
+ t.strictEqual( w[ 1 ], 0, 'returns expected value' );
+
+ t.end();
+});
+
+tape( 'the function supports providing an output object (typed array)', function test( t ) {
+ var out;
+ var w;
+
+ out = new Uint32Array( 2 );
+ w = string2words( '4294967296', 10, out, 1, 0 );
+
+ t.strictEqual( w, out, 'returns expected value' );
+ t.strictEqual( w[ 0 ], 1, 'returns expected value' );
+ t.strictEqual( w[ 1 ], 0, 'returns expected value' );
+
+ t.end();
+});
+
+tape( 'the function supports specifying a stride', function test( t ) {
+ var out;
+ var val;
+
+ out = new Uint32Array( 4 );
+ val = string2words( '4294967298', 10, out, 2, 0 );
+
+ t.strictEqual( val, out, 'returns expected value' );
+ t.strictEqual( val[ 0 ], 1, 'returns expected value' );
+ t.strictEqual( val[ 1 ], 0, 'returns expected value' );
+ t.strictEqual( val[ 2 ], 2, 'returns expected value' );
+ t.strictEqual( val[ 3 ], 0, 'returns expected value' );
+
+ t.end();
+});
+
+tape( 'the function supports specifying an offset', function test( t ) {
+ var out;
+ var val;
+
+ out = new Uint32Array( 4 );
+ val = string2words( '4294967298', 10, out, 2, 1 );
+
+ t.strictEqual( val, out, 'returns expected value' );
+ t.strictEqual( val[ 0 ], 0, 'returns expected value' );
+ t.strictEqual( val[ 1 ], 1, 'returns expected value' );
+ t.strictEqual( val[ 2 ], 0, 'returns expected value' );
+ t.strictEqual( val[ 3 ], 2, 'returns expected value' );
+
+ t.end();
+});
diff --git a/lib/node_modules/@stdlib/number/uint64/base/string2words/test/test.js b/lib/node_modules/@stdlib/number/uint64/base/string2words/test/test.js
new file mode 100644
index 000000000000..4eb42e279f95
--- /dev/null
+++ b/lib/node_modules/@stdlib/number/uint64/base/string2words/test/test.js
@@ -0,0 +1,40 @@
+/**
+* @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 hasOwnProp = require( '@stdlib/assert/has-own-property' );
+var string2words = require( './../lib' );
+
+
+// TESTS //
+
+tape( 'main export is a function', function test( t ) {
+ t.ok( true, __filename );
+ t.strictEqual( typeof string2words, 'function', 'main export is a function' );
+ t.end();
+});
+
+tape( 'attached to the main export is an `assign` method', function test( t ) {
+ t.strictEqual( hasOwnProp( string2words, 'assign' ), true, 'has property' );
+ t.strictEqual( typeof string2words.assign, 'function', 'has method' );
+ t.end();
+});
diff --git a/lib/node_modules/@stdlib/number/uint64/base/string2words/test/test.main.js b/lib/node_modules/@stdlib/number/uint64/base/string2words/test/test.main.js
new file mode 100644
index 000000000000..5b128016ec7a
--- /dev/null
+++ b/lib/node_modules/@stdlib/number/uint64/base/string2words/test/test.main.js
@@ -0,0 +1,52 @@
+/**
+* @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 isInteger = require( '@stdlib/assert/is-integer' ).isPrimitive;
+var string2words = require( './../lib/main.js' );
+
+
+// TESTS //
+
+tape( 'main export is a function', function test( t ) {
+ t.ok( true, __filename );
+ t.strictEqual( typeof string2words, 'function', 'main export is a function' );
+ t.end();
+});
+
+tape( 'the function returns a two-element numeric array containing integers', function test( t ) {
+ var w = string2words( '1234', 10 );
+
+ t.strictEqual( isInteger( w[0] ), true, 'returns expected value' );
+ t.strictEqual( isInteger( w[1] ), true, 'returns expected value' );
+
+ t.end();
+});
+
+tape( 'the function parses a string representation of a 64-bit unsigned integer into high and low 32-bit words', function test( t ) {
+ var w = string2words( '18446744073709551615', 10 );
+
+ t.strictEqual( w[0], 4294967295, 'returns expected value' );
+ t.strictEqual( w[1], 4294967295, 'returns expected value' );
+
+ t.end();
+});