feat!: add support for additional modes

kgryte · kgryte · commit 7c3729c19fdd · 2024-06-20T00:11:07.000-07:00
BREAKING CHANGE: rename 'throw' mode to 'strict'

To migrate, users should simply update 'throw' to 'strict'.
diff --git a/lib/node_modules/@stdlib/array/base/mskput/README.md b/lib/node_modules/@stdlib/array/base/mskput/README.md
@@ -37,7 +37,7 @@ Replaces elements of an array with provided values according to a provided mask
 ```javascript
 var x = [ 1, 2, 3, 4 ];
 
-var out = mskput( x, [ 1, 0, 1, 0 ], [ 20, 40 ], 'throw' );
+var out = mskput( x, [ 1, 0, 1, 0 ], [ 20, 40 ], 'strict' );
 // returns [ 1, 20, 3, 40 ]
 
 var bool = ( out === x );
@@ -49,27 +49,29 @@ The function supports the following parameters:
 -   **x**: input array.
 -   **mask**: mask array.
 -   **values**: values to set.
--   **mode**: string specifying whether to raise an exception when the number of `values` is less than the number of falsy `mask` values.
+-   **mode**: string specifying whether to raise an exception when the number of `values` does not equal the number of falsy `mask` values.
 
 The function supports the following modes:
 
--   `'throw'`: specifies that the function must raise an exception when the function is provided insufficient `values` to satisfy the `mask` array.
+-   `'strict'`: specifies that the function must raise an exception when the number of `values` does not **exactly** equal the number of falsy `mask` values.
+-   `'non_strict'`: specifies that the function must raise an exception when the function is provided insufficient `values` to satisfy the `mask` array.
+-   `'strict_broadcast'`: specifies that the function must broadcast a single-element `values` array and otherwise raise an exception when the number of `values` does not **exactly** equal the number of falsy `mask` values.
 -   `'broadcast'`: specifies that the function must broadcast a single-element `values` array and otherwise raise an exception when the function is provided insufficient `values` to satisfy the `mask` array.
 -   `'repeat'`: specifies that the function must reuse provided `values` when replacing elements in `x` in order to satisfy the `mask` array.
 
-When `mode` is equal to `'broadcast`', the function supports broadcasting a `values` array containing a single element against the number of falsy values in the `mask` array.
+In broadcasting modes, the function supports broadcasting a `values` array containing a single element against the number of falsy values in the `mask` array.
 
 ```javascript
 var x = [ 1, 2, 3, 4 ];
 
-var out = mskput( x, [ 1, 0, 1, 0 ], [ 20 ], 'broadcast' );
+var out = mskput( x, [ 1, 0, 1, 0 ], [ 20 ], 'strict_broadcast' );
 // returns [ 1, 20, 3, 20 ]
 
 var bool = ( out === x );
 // returns true
 ```
 
-When `mode` is equal to `repeat`, the function supports recycling elements in a `values` array to satisfy the number of falsy values in the `mask` array.
+In repeat mode, the function supports recycling elements in a `values` array to satisfy the number of falsy values in the `mask` array.
 
 ```javascript
 var x = [ 1, 2, 3, 4 ];
@@ -123,7 +125,7 @@ var values = filledBy( N, discreteUniform.factory( 1000, 2000 ) );
 console.log( values );
 
 // Update a random sample of elements in `x`:
-var out = mskput( x, mask, values, 'throw' );
+var out = mskput( x, mask, values, 'non_strict' );
 console.log( out );
 ```
 
diff --git a/lib/node_modules/@stdlib/array/base/mskput/benchmark/benchmark.js b/lib/node_modules/@stdlib/array/base/mskput/benchmark/benchmark.js
@@ -41,7 +41,7 @@ bench( pkg+'::no_broadcasting:len=100', function benchmark( b ) {
 
 	b.tic();
 	for ( i = 0; i < b.iterations; i++ ) {
-		v = mskput( x, mask, x, 'throw' );
+		v = mskput( x, mask, x, 'strict' );
 		if ( typeof v !== 'object' ) {
 			b.fail( 'should return an array' );
 		}
@@ -65,7 +65,7 @@ bench( pkg+'::broadcasting:len=100', function benchmark( b ) {
 
 	b.tic();
 	for ( i = 0; i < b.iterations; i++ ) {
-		v = mskput( x, mask, [ i ], 'broadcast' );
+		v = mskput( x, mask, [ i ], 'strict_broadcast' );
 		if ( typeof v !== 'object' ) {
 			b.fail( 'should return an array' );
 		}
diff --git a/lib/node_modules/@stdlib/array/base/mskput/benchmark/benchmark.length.js b/lib/node_modules/@stdlib/array/base/mskput/benchmark/benchmark.length.js
@@ -71,7 +71,7 @@ function createBenchmark( len ) {
 
 		b.tic();
 		for ( i = 0; i < b.iterations; i++ ) {
-			v = mskput( x, mask, values[ i%values.length ], 'throw' );
+			v = mskput( x, mask, values[ i%values.length ], 'strict' );
 			if ( typeof v !== 'object' ) {
 				b.fail( 'should return an array' );
 			}
diff --git a/lib/node_modules/@stdlib/array/base/mskput/docs/repl.txt b/lib/node_modules/@stdlib/array/base/mskput/docs/repl.txt
@@ -3,12 +3,12 @@
     Replaces elements of an array with provided values according to a provided
     mask array.
 
-    When the `mode` is `'broadcast'`, the function supports broadcasting a
-    `values` array containing a single element against the number of falsy
-    values in the `mask` array.
+    In broadcasting modes, the function supports broadcasting a values array
+    containing a single element against the number of falsy values in the mask
+    array.
 
-    When the `mode` is `'repeat'`, the function supports recycling elements in a
-    `values` array to satisfy the number of falsy values in the `mask` array.
+    In repeat mode, the function supports recycling elements in a values array
+    to satisfy the number of falsy values in the mask array.
 
     The function mutates the input array.
 
@@ -26,12 +26,19 @@
         Values to set.
 
     mode: string
-        String specifying behavior when the number of values to set is less than
-        the number of falsy mask values. The function supports the following
-        modes:
-
-        - 'throw': specifies that the function must raise an exception when the
-        function is provided insufficient values to satisfy the mask array.
+        String specifying behavior when the number of values to set does not
+        equal the number of falsy mask values. The function supports the
+        following modes:
+
+        - 'strict': specifies that the function must raise an exception when the
+        number of values does not *exactly* equal the number of falsy mask
+        values.
+        - 'non_strict': specifies that the function must raise an exception when
+        the function is provided insufficient values to satisfy the mask array.
+        - 'strict_broadcast': specifies that the function must broadcast a
+        single-element values array and otherwise raise an exception when the
+        number of values does not **exactly** equal the number of falsy mask
+        values.
         - 'broadcast': specifies that the function must broadcast a single-
         element values array and otherwise raise an exception when the function
         is provided insufficient values to satisfy the mask array.
@@ -46,7 +53,7 @@
     Examples
     --------
     > var x = [ 1, 2, 3, 4 ];
-    > var out = {{alias}}( x, [ 1, 0, 1, 0 ], [ 20, 40 ], 'throw' )
+    > var out = {{alias}}( x, [ 1, 0, 1, 0 ], [ 20, 40 ], 'strict' )
     [ 1, 20, 3, 40 ]
     > var bool = ( out === x )
     true
diff --git a/lib/node_modules/@stdlib/array/base/mskput/docs/types/index.d.ts b/lib/node_modules/@stdlib/array/base/mskput/docs/types/index.d.ts
@@ -34,25 +34,27 @@ type MaskArray = Collection | AccessorArrayLike<any>;
 type ValuesArray<T> = Collection<T> | AccessorArrayLike<T>;
 
 /**
-* Mode specifying behavior when the number of values to set is less than the number of falsy values in the mask array.
+* Mode specifying behavior when the number of values to set does not equal the number of falsy values in the mask array.
 *
 * ## Notes
 *
 * -   The function supports the following modes:
 *
-*     -   `'throw'`: specifies that the function must raise an exception when the function is provided insufficient `values` to satisfy the `mask` array.
-*     -   `'broadcast'`: specifies that the function must broadcast a single-element `values` array and otherwise raise an exception when the function is provided insufficient `values` to satisfy the `mask` array.
-*     -   `'repeat'`: specifies that the function must reuse provided `values` when replacing elements in `x` in order to satisfy the `mask` array.
+*     -   `'strict'`: specifies that the function must raise an exception when the number of `values` does not **exactly** equal the number of falsy `mask` values.
+*    -   `'non_strict'`: specifies that the function must raise an exception when the function is provided insufficient `values` to satisfy the `mask` array.
+*    -   `'strict_broadcast'`: specifies that the function must broadcast a single-element `values` array and otherwise raise an exception when the number of `values` does not **exactly** equal the number of falsy `mask` values.
+*    -   `'broadcast'`: specifies that the function must broadcast a single-element `values` array and otherwise raise an exception when the function is provided insufficient `values` to satisfy the `mask` array.
+*    -   `'repeat'`: specifies that the function must reuse provided `values` when replacing elements in `x` in order to satisfy the `mask` array.
 */
-type Mode = 'throw' | 'broadcast' | 'repeat';
+type Mode = 'strict' | 'non_strict' | 'strict_broadcast' | 'broadcast' | 'repeat';
 
 /**
 * Replaces elements of an array with provided values according to a provided mask array.
 *
 * @param x - input array
 * @param mask - mask array
 * @param values - values to set
-* @param mode - string specifying behavior when the number of values is less than the number of falsy values in the mask array
+* @param mode - string specifying behavior when the number of values does not equal the number of falsy values in the mask array
 * @returns input array
 *
 * @example
@@ -63,7 +65,7 @@ type Mode = 'throw' | 'broadcast' | 'repeat';
 * var mask = [ 1, 0, 0, 1 ];
 * var values = [ 20, 30 ];
 *
-* var out = mskput( x, mask, values, 'throw' );
+* var out = mskput( x, mask, values, 'strict' );
 * // returns <Int32Array>[ 1, 20, 30, 4 ]
 *
 * var bool = ( out === x );
@@ -74,7 +76,7 @@ type Mode = 'throw' | 'broadcast' | 'repeat';
 *
 * var x = new Int32Array( [ 1, 2, 3, 4 ] );
 *
-* var out = mskput( x, [ 1, 0, 0, 1 ], [ 30 ], 'broadcast' );
+* var out = mskput( x, [ 1, 0, 0, 1 ], [ 30 ], 'strict_broadcast' );
 * // returns <Int32Array>[ 1, 30, 30, 4 ]
 *
 * var bool = ( out === x );
@@ -88,7 +90,7 @@ declare function mskput<T extends TypedArray | BooleanTypedArray, U = unknown>(
 * @param x - input array
 * @param mask - mask array
 * @param values - values to set
-* @param mode - string specifying behavior when the number of values is less than the number of falsy values in the mask array
+* @param mode - string specifying behavior when the number of values does not equal the number of falsy values in the mask array
 * @returns input array
 *
 * @example
@@ -99,7 +101,7 @@ declare function mskput<T extends TypedArray | BooleanTypedArray, U = unknown>(
 * var mask = [ 1, 0, 0, 1 ];
 * var values = new Complex128Array( [ 20.0, 30.0, 40, 5.0 ] );
 *
-* var out = mskput( x, mask, values, 'throw' );
+* var out = mskput( x, mask, values, 'strict' );
 * // returns <Complex128Array>
 *
 * var bool = ( out === x );
@@ -113,7 +115,7 @@ declare function mskput<T extends TypedArray | BooleanTypedArray, U = unknown>(
 * var mask = [ 1, 0, 0, 1 ];
 * var values = new Complex128Array( [ 20.0, 30.0 ] );
 *
-* var out = mskput( x, mask, values, 'broadcast' );
+* var out = mskput( x, mask, values, 'strict_broadcast' );
 * // returns <Complex128Array>
 *
 * var bool = ( out === x );
@@ -127,7 +129,7 @@ declare function mskput<T extends ComplexTypedArray>( x: T, mask: MaskArray, val
 * @param x - input array
 * @param mask - mask array
 * @param values - values to set
-* @param mode - string specifying behavior when the number of values is less than the number of falsy values in the mask array
+* @param mode - string specifying behavior when the number of values does not equal the number of falsy values in the mask array
 * @returns input array
 *
 * @example
@@ -136,7 +138,7 @@ declare function mskput<T extends ComplexTypedArray>( x: T, mask: MaskArray, val
 * var mask = [ 1, 0, 0, 1 ];
 * var values = [ 20, 30 ];
 *
-* var out = mskput( x, mask, values, 'throw' );
+* var out = mskput( x, mask, values, 'strict' );
 * // returns [ 1, 20, 30, 4 ]
 *
 * var bool = ( out === x );
@@ -145,7 +147,7 @@ declare function mskput<T extends ComplexTypedArray>( x: T, mask: MaskArray, val
 * @example
 * var x = [ 1, 2, 3, 4 ];
 *
-* var out = mskput( x, [ 1, 0, 0, 1 ], [ 30 ], 'broadcast' );
+* var out = mskput( x, [ 1, 0, 0, 1 ], [ 30 ], 'strict_broadcast' );
 * // returns [ 1, 30, 30, 4 ]
 *
 * var bool = ( out === x );
@@ -159,7 +161,7 @@ declare function mskput<T = unknown, U = unknown>( x: Array<T>, mask: MaskArray,
 * @param x - input array
 * @param mask - mask array
 * @param values - values to set
-* @param mode - string specifying behavior when the number of values is less than the number of falsy values in the mask array
+* @param mode - string specifying behavior when the number of values does not equal the number of falsy values in the mask array
 * @returns input array
 *
 * @example
@@ -170,7 +172,7 @@ declare function mskput<T = unknown, U = unknown>( x: Array<T>, mask: MaskArray,
 * var mask = [ 1, 0, 0, 1 ];
 * var values = [ 20, 30 ];
 *
-* var out = mskput( x, mask, values, 'throw' );
+* var out = mskput( x, mask, values, 'strict' );
 *
 * var bool = ( out === x );
 * // returns true
@@ -180,7 +182,7 @@ declare function mskput<T = unknown, U = unknown>( x: Array<T>, mask: MaskArray,
 *
 * var x = toAccessorArray( [ 1, 2, 3, 4 ] );
 *
-* var out = mskput( x, [ 1, 0, 0, 1 ], [ 30 ], 'broadcast' );
+* var out = mskput( x, [ 1, 0, 0, 1 ], [ 30 ], 'strict_broadcast' );
 *
 * var bool = ( out === x );
 * // returns true
@@ -193,7 +195,7 @@ declare function mskput<T = unknown, U = unknown>( x: AccessorArrayLike<T>, mask
 * @param x - input array
 * @param mask - mask array
 * @param values - values to set
-* @param mode - string specifying behavior when the number of values is less than the number of falsy values in the mask array
+* @param mode - string specifying behavior when the number of values does not equal the number of falsy values in the mask array
 * @returns input array
 *
 * @example
@@ -202,7 +204,7 @@ declare function mskput<T = unknown, U = unknown>( x: AccessorArrayLike<T>, mask
 * var mask = [ 1, 0, 0, 1 ];
 * var values = [ 20, 30 ];
 *
-* var out = mskput( x, mask, values, 'throw' );
+* var out = mskput( x, mask, values, 'strict' );
 * // returns [ 1, 20, 30, 4 ]
 *
 * var bool = ( out === x );
@@ -211,7 +213,7 @@ declare function mskput<T = unknown, U = unknown>( x: AccessorArrayLike<T>, mask
 * @example
 * var x = [ 1, 2, 3, 4 ];
 *
-* var out = mskput( x, [ 1, 0, 0, 1 ], [ 30 ], 'throw' );
+* var out = mskput( x, [ 1, 0, 0, 1 ], [ 30 ], 'strict' );
 * // returns [ 1, 30, 30, 4 ]
 *
 * var bool = ( out === x );
diff --git a/lib/node_modules/@stdlib/array/base/mskput/docs/types/test.ts b/lib/node_modules/@stdlib/array/base/mskput/docs/types/test.ts
@@ -27,44 +27,46 @@ import mskput = require( './index' );
 
 // The function returns an array...
 {
-	mskput( [ 1, 2, 3, 4 ], [ 1, 0, 0, 1 ], [ 20, 30 ], 'throw' ); // $ExpectType number[]
+	mskput( [ 1, 2, 3, 4 ], [ 1, 0, 0, 1 ], [ 20, 30 ], 'strict' ); // $ExpectType number[]
+	mskput( [ 1, 2, 3, 4 ], [ 1, 0, 0, 1 ], [ 20, 30 ], 'non_strict' ); // $ExpectType number[]
+	mskput( [ 1, 2, 3, 4 ], [ 1, 0, 0, 1 ], [ 20, 30 ], 'strict_broadcast' ); // $ExpectType number[]
 	mskput( [ 1, 2, 3, 4 ], [ 1, 0, 0, 1 ], [ 20, 30 ], 'broadcast' ); // $ExpectType number[]
 	mskput( [ 1, 2, 3, 4 ], [ 1, 0, 0, 1 ], [ 20, 30 ], 'repeat' ); // $ExpectType number[]
 
-	mskput( new Int32Array( [ 1, 2, 3, 4 ] ), [ 1, 0, 0, 1 ], [ 20, 30 ], 'throw' ); // $ExpectType Int32Array
-	mskput( new Complex128Array( [ 1, 2, 3, 4 ] ), [ 1, 0, 0, 1 ], [ new Complex128( 20, 30 ), [ 40, 50 ] ], 'throw' ); // $ExpectType Complex128Array
-	mskput( new Complex64Array( [ 1, 2, 3, 4 ] ), [ 1, 0, 0, 1 ], [ new Complex128( 20, 30 ), [ 40, 50 ] ], 'throw' ); // $ExpectType Complex64Array
-	mskput( new AccessorArray<number>( [ 1, 2, 3, 4 ] ), [ 1, 0, 0, 1 ], new AccessorArray<number>( [ 20, 30 ] ), 'throw' ); // $ExpectType AccessorArrayLike<number>
+	mskput( new Int32Array( [ 1, 2, 3, 4 ] ), [ 1, 0, 0, 1 ], [ 20, 30 ], 'strict' ); // $ExpectType Int32Array
+	mskput( new Complex128Array( [ 1, 2, 3, 4 ] ), [ 1, 0, 0, 1 ], [ new Complex128( 20, 30 ), [ 40, 50 ] ], 'strict' ); // $ExpectType Complex128Array
+	mskput( new Complex64Array( [ 1, 2, 3, 4 ] ), [ 1, 0, 0, 1 ], [ new Complex128( 20, 30 ), [ 40, 50 ] ], 'strict' ); // $ExpectType Complex64Array
+	mskput( new AccessorArray<number>( [ 1, 2, 3, 4 ] ), [ 1, 0, 0, 1 ], new AccessorArray<number>( [ 20, 30 ] ), 'strict' ); // $ExpectType AccessorArrayLike<number>
 }
 
 // The compiler throws an error if the function is provided a first argument which is not an array-like object...
 {
-	mskput( 1, [ 1, 0, 0, 1 ], [ 20, 30 ], 'throw' ); // $ExpectError
-	mskput( true, [ 1, 0, 0, 1 ], [ 20, 30 ], 'throw' ); // $ExpectError
-	mskput( false, [ 1, 0, 0, 1 ], [ 20, 30 ], 'throw' ); // $ExpectError
-	mskput( null, [ 1, 0, 0, 1 ], [ 20, 30 ], 'throw' ); // $ExpectError
-	mskput( void 0, [ 1, 0, 0, 1 ], [ 20, 30 ], 'throw' ); // $ExpectError
-	mskput( {}, [ 1, 0, 0, 1 ], [ 20, 30 ], 'throw' ); // $ExpectError
+	mskput( 1, [ 1, 0, 0, 1 ], [ 20, 30 ], 'strict' ); // $ExpectError
+	mskput( true, [ 1, 0, 0, 1 ], [ 20, 30 ], 'strict' ); // $ExpectError
+	mskput( false, [ 1, 0, 0, 1 ], [ 20, 30 ], 'strict' ); // $ExpectError
+	mskput( null, [ 1, 0, 0, 1 ], [ 20, 30 ], 'strict' ); // $ExpectError
+	mskput( void 0, [ 1, 0, 0, 1 ], [ 20, 30 ], 'strict' ); // $ExpectError
+	mskput( {}, [ 1, 0, 0, 1 ], [ 20, 30 ], 'strict' ); // $ExpectError
 }
 
 // The compiler throws an error if the function is provided a second argument which is not an array-like object...
 {
-	mskput( [], 1, [ 20, 30 ], 'throw' ); // $ExpectError
-	mskput( [], true, [ 20, 30 ], 'throw' ); // $ExpectError
-	mskput( [], false, [ 20, 30 ], 'throw' ); // $ExpectError
-	mskput( [], null, [ 20, 30 ], 'throw' ); // $ExpectError
-	mskput( [], void 0, [ 20, 30 ], 'throw' ); // $ExpectError
-	mskput( [], {}, [ 20, 30 ], 'throw' ); // $ExpectError
+	mskput( [], 1, [ 20, 30 ], 'strict' ); // $ExpectError
+	mskput( [], true, [ 20, 30 ], 'strict' ); // $ExpectError
+	mskput( [], false, [ 20, 30 ], 'strict' ); // $ExpectError
+	mskput( [], null, [ 20, 30 ], 'strict' ); // $ExpectError
+	mskput( [], void 0, [ 20, 30 ], 'strict' ); // $ExpectError
+	mskput( [], {}, [ 20, 30 ], 'strict' ); // $ExpectError
 }
 
 // The compiler throws an error if the function is provided a third argument which is not an array-like object...
 {
-	mskput( [], [ 1, 0, 0, 1 ], 1, 'throw' ); // $ExpectError
-	mskput( [], [ 1, 0, 0, 1 ], true, 'throw' ); // $ExpectError
-	mskput( [], [ 1, 0, 0, 1 ], false, 'throw' ); // $ExpectError
-	mskput( [], [ 1, 0, 0, 1 ], null, 'throw' ); // $ExpectError
-	mskput( [], [ 1, 0, 0, 1 ], void 0, 'throw' ); // $ExpectError
-	mskput( [], [ 1, 0, 0, 1 ], {}, 'throw' ); // $ExpectError
+	mskput( [], [ 1, 0, 0, 1 ], 1, 'strict' ); // $ExpectError
+	mskput( [], [ 1, 0, 0, 1 ], true, 'strict' ); // $ExpectError
+	mskput( [], [ 1, 0, 0, 1 ], false, 'strict' ); // $ExpectError
+	mskput( [], [ 1, 0, 0, 1 ], null, 'strict' ); // $ExpectError
+	mskput( [], [ 1, 0, 0, 1 ], void 0, 'strict' ); // $ExpectError
+	mskput( [], [ 1, 0, 0, 1 ], {}, 'strict' ); // $ExpectError
 }
 
 // The compiler throws an error if the function is provided a fourth argument which is not a valid mode...
@@ -86,5 +88,5 @@ import mskput = require( './index' );
 	mskput( [] ); // $ExpectError
 	mskput( [], [] ); // $ExpectError
 	mskput( [], [], [], ); // $ExpectError
-	mskput( [], [], [], 'throw', {} ); // $ExpectError
+	mskput( [], [], [], 'strict', {} ); // $ExpectError
 }
diff --git a/lib/node_modules/@stdlib/array/base/mskput/examples/index.js b/lib/node_modules/@stdlib/array/base/mskput/examples/index.js
@@ -38,5 +38,5 @@ var values = filledBy( N, discreteUniform.factory( 1000, 2000 ) );
 console.log( values );
 
 // Update a random sample of elements in `x`:
-var out = mskput( x, mask, values, 'throw' );
+var out = mskput( x, mask, values, 'non_strict' );
 console.log( out );
diff --git a/lib/node_modules/@stdlib/array/base/mskput/lib/index.js b/lib/node_modules/@stdlib/array/base/mskput/lib/index.js
@@ -31,7 +31,7 @@
 * var mask = [ 1, 0, 0, 1 ];
 * var values = [ 20, 30 ];
 *
-* var out = mskput( x, mask, values, 'throw' );
+* var out = mskput( x, mask, values, 'strict' );
 * // returns [ 1, 20, 30, 4 ]
 *
 * var bool = ( out === x );
diff --git a/lib/node_modules/@stdlib/array/base/mskput/lib/main.js b/lib/node_modules/@stdlib/array/base/mskput/lib/main.js
diff --git a/lib/node_modules/@stdlib/array/base/mskput/test/test.js b/lib/node_modules/@stdlib/array/base/mskput/test/test.js

Original file line number	Diff line number	Diff line change
`@@ -71,7 +71,7 @@ function createBenchmark( len ) {`
`71`	`71`
`72`	`72`	`b.tic();`
`73`	`73`	`for ( i = 0; i < b.iterations; i++ ) {`
`74`		`- v = mskput( x, mask, values[ i%values.length ], 'throw' );`
	`74`	`+ v = mskput( x, mask, values[ i%values.length ], 'strict' );`
`75`	`75`	`if ( typeof v !== 'object' ) {`
`76`	`76`	`b.fail( 'should return an array' );`
`77`	`77`	`}`
Original file line number	Diff line number	Diff line change
`@@ -34,25 +34,27 @@ type MaskArray = Collection \| AccessorArrayLike<any>;`
`34`	`34`	`type ValuesArray<T> = Collection<T> \| AccessorArrayLike<T>;`
`35`	`35`
`36`	`36`	`/**`
`37`		`-* Mode specifying behavior when the number of values to set is less than the number of falsy values in the mask array.`
	`37`	`+* Mode specifying behavior when the number of values to set does not equal the number of falsy values in the mask array.`
`38`	`38`	`*`
`39`	`39`	`* ## Notes`
`40`	`40`	`*`
`41`	`41`	`* - The function supports the following modes:`
`42`	`42`	`*`
`43`		-* - `'throw'`: specifies that the function must raise an exception when the function is provided insufficient `values` to satisfy the `mask` array.
`44`		-* - `'broadcast'`: specifies that the function must broadcast a single-element `values` array and otherwise raise an exception when the function is provided insufficient `values` to satisfy the `mask` array.
`45`		-* - `'repeat'`: specifies that the function must reuse provided `values` when replacing elements in `x` in order to satisfy the `mask` array.
	`43`	+* - `'strict'`: specifies that the function must raise an exception when the number of `values` does not exactly equal the number of falsy `mask` values.
	`44`	+* - `'non_strict'`: specifies that the function must raise an exception when the function is provided insufficient `values` to satisfy the `mask` array.
	`45`	+* - `'strict_broadcast'`: specifies that the function must broadcast a single-element `values` array and otherwise raise an exception when the number of `values` does not exactly equal the number of falsy `mask` values.
	`46`	+* - `'broadcast'`: specifies that the function must broadcast a single-element `values` array and otherwise raise an exception when the function is provided insufficient `values` to satisfy the `mask` array.
	`47`	+* - `'repeat'`: specifies that the function must reuse provided `values` when replacing elements in `x` in order to satisfy the `mask` array.
`46`	`48`	`*/`
`47`		`-type Mode = 'throw' \| 'broadcast' \| 'repeat';`
	`49`	`+type Mode = 'strict' \| 'non_strict' \| 'strict_broadcast' \| 'broadcast' \| 'repeat';`
`48`	`50`
`49`	`51`	`/**`
`50`	`52`	`* Replaces elements of an array with provided values according to a provided mask array.`
`51`	`53`	`*`
`52`	`54`	`* @param x - input array`
`53`	`55`	`* @param mask - mask array`
`54`	`56`	`* @param values - values to set`
`55`		`-* @param mode - string specifying behavior when the number of values is less than the number of falsy values in the mask array`
	`57`	`+* @param mode - string specifying behavior when the number of values does not equal the number of falsy values in the mask array`
`56`	`58`	`* @returns input array`
`57`	`59`	`*`
`58`	`60`	`* @example`
`@@ -63,7 +65,7 @@ type Mode = 'throw' \| 'broadcast' \| 'repeat';`
`63`	`65`	`* var mask = [ 1, 0, 0, 1 ];`
`64`	`66`	`* var values = [ 20, 30 ];`
`65`	`67`	`*`
`66`		`-* var out = mskput( x, mask, values, 'throw' );`
	`68`	`+* var out = mskput( x, mask, values, 'strict' );`
`67`	`69`	`* // returns <Int32Array>[ 1, 20, 30, 4 ]`
`68`	`70`	`*`
`69`	`71`	`* var bool = ( out === x );`
`@@ -74,7 +76,7 @@ type Mode = 'throw' \| 'broadcast' \| 'repeat';`
`74`	`76`	`*`
`75`	`77`	`* var x = new Int32Array( [ 1, 2, 3, 4 ] );`
`76`	`78`	`*`
`77`		`-* var out = mskput( x, [ 1, 0, 0, 1 ], [ 30 ], 'broadcast' );`
	`79`	`+* var out = mskput( x, [ 1, 0, 0, 1 ], [ 30 ], 'strict_broadcast' );`
`78`	`80`	`* // returns <Int32Array>[ 1, 30, 30, 4 ]`
`79`	`81`	`*`
`80`	`82`	`* var bool = ( out === x );`
`@@ -88,7 +90,7 @@ declare function mskput<T extends TypedArray \| BooleanTypedArray, U = unknown>(`
`88`	`90`	`* @param x - input array`
`89`	`91`	`* @param mask - mask array`
`90`	`92`	`* @param values - values to set`
`91`		`-* @param mode - string specifying behavior when the number of values is less than the number of falsy values in the mask array`
	`93`	`+* @param mode - string specifying behavior when the number of values does not equal the number of falsy values in the mask array`
`92`	`94`	`* @returns input array`
`93`	`95`	`*`
`94`	`96`	`* @example`
`@@ -99,7 +101,7 @@ declare function mskput<T extends TypedArray \| BooleanTypedArray, U = unknown>(`
`99`	`101`	`* var mask = [ 1, 0, 0, 1 ];`
`100`	`102`	`* var values = new Complex128Array( [ 20.0, 30.0, 40, 5.0 ] );`
`101`	`103`	`*`
`102`		`-* var out = mskput( x, mask, values, 'throw' );`
	`104`	`+* var out = mskput( x, mask, values, 'strict' );`
`103`	`105`	`* // returns <Complex128Array>`
`104`	`106`	`*`
`105`	`107`	`* var bool = ( out === x );`
`@@ -113,7 +115,7 @@ declare function mskput<T extends TypedArray \| BooleanTypedArray, U = unknown>(`
`113`	`115`	`* var mask = [ 1, 0, 0, 1 ];`
`114`	`116`	`* var values = new Complex128Array( [ 20.0, 30.0 ] );`
`115`	`117`	`*`
`116`		`-* var out = mskput( x, mask, values, 'broadcast' );`
	`118`	`+* var out = mskput( x, mask, values, 'strict_broadcast' );`
`117`	`119`	`* // returns <Complex128Array>`
`118`	`120`	`*`
`119`	`121`	`* var bool = ( out === x );`
`@@ -127,7 +129,7 @@ declare function mskput<T extends ComplexTypedArray>( x: T, mask: MaskArray, val`
`127`	`129`	`* @param x - input array`
`128`	`130`	`* @param mask - mask array`
`129`	`131`	`* @param values - values to set`
`130`		`-* @param mode - string specifying behavior when the number of values is less than the number of falsy values in the mask array`
	`132`	`+* @param mode - string specifying behavior when the number of values does not equal the number of falsy values in the mask array`
`131`	`133`	`* @returns input array`
`132`	`134`	`*`
`133`	`135`	`* @example`
`@@ -136,7 +138,7 @@ declare function mskput<T extends ComplexTypedArray>( x: T, mask: MaskArray, val`
`136`	`138`	`* var mask = [ 1, 0, 0, 1 ];`
`137`	`139`	`* var values = [ 20, 30 ];`
`138`	`140`	`*`
`139`		`-* var out = mskput( x, mask, values, 'throw' );`
	`141`	`+* var out = mskput( x, mask, values, 'strict' );`
`140`	`142`	`* // returns [ 1, 20, 30, 4 ]`
`141`	`143`	`*`
`142`	`144`	`* var bool = ( out === x );`
`@@ -145,7 +147,7 @@ declare function mskput<T extends ComplexTypedArray>( x: T, mask: MaskArray, val`
`145`	`147`	`* @example`
`146`	`148`	`* var x = [ 1, 2, 3, 4 ];`
`147`	`149`	`*`
`148`		`-* var out = mskput( x, [ 1, 0, 0, 1 ], [ 30 ], 'broadcast' );`
	`150`	`+* var out = mskput( x, [ 1, 0, 0, 1 ], [ 30 ], 'strict_broadcast' );`
`149`	`151`	`* // returns [ 1, 30, 30, 4 ]`
`150`	`152`	`*`
`151`	`153`	`* var bool = ( out === x );`
`@@ -159,7 +161,7 @@ declare function mskput<T = unknown, U = unknown>( x: Array<T>, mask: MaskArray,`
`159`	`161`	`* @param x - input array`
`160`	`162`	`* @param mask - mask array`
`161`	`163`	`* @param values - values to set`
`162`		`-* @param mode - string specifying behavior when the number of values is less than the number of falsy values in the mask array`
	`164`	`+* @param mode - string specifying behavior when the number of values does not equal the number of falsy values in the mask array`
`163`	`165`	`* @returns input array`
`164`	`166`	`*`
`165`	`167`	`* @example`
`@@ -170,7 +172,7 @@ declare function mskput<T = unknown, U = unknown>( x: Array<T>, mask: MaskArray,`
`170`	`172`	`* var mask = [ 1, 0, 0, 1 ];`
`171`	`173`	`* var values = [ 20, 30 ];`
`172`	`174`	`*`
`173`		`-* var out = mskput( x, mask, values, 'throw' );`
	`175`	`+* var out = mskput( x, mask, values, 'strict' );`
`174`	`176`	`*`
`175`	`177`	`* var bool = ( out === x );`
`176`	`178`	`* // returns true`
`@@ -180,7 +182,7 @@ declare function mskput<T = unknown, U = unknown>( x: Array<T>, mask: MaskArray,`
`180`	`182`	`*`
`181`	`183`	`* var x = toAccessorArray( [ 1, 2, 3, 4 ] );`
`182`	`184`	`*`
`183`		`-* var out = mskput( x, [ 1, 0, 0, 1 ], [ 30 ], 'broadcast' );`
	`185`	`+* var out = mskput( x, [ 1, 0, 0, 1 ], [ 30 ], 'strict_broadcast' );`
`184`	`186`	`*`
`185`	`187`	`* var bool = ( out === x );`
`186`	`188`	`* // returns true`
`@@ -193,7 +195,7 @@ declare function mskput<T = unknown, U = unknown>( x: AccessorArrayLike<T>, mask`
`193`	`195`	`* @param x - input array`
`194`	`196`	`* @param mask - mask array`
`195`	`197`	`* @param values - values to set`
`196`		`-* @param mode - string specifying behavior when the number of values is less than the number of falsy values in the mask array`
	`198`	`+* @param mode - string specifying behavior when the number of values does not equal the number of falsy values in the mask array`
`197`	`199`	`* @returns input array`
`198`	`200`	`*`
`199`	`201`	`* @example`
`@@ -202,7 +204,7 @@ declare function mskput<T = unknown, U = unknown>( x: AccessorArrayLike<T>, mask`
`202`	`204`	`* var mask = [ 1, 0, 0, 1 ];`
`203`	`205`	`* var values = [ 20, 30 ];`
`204`	`206`	`*`
`205`		`-* var out = mskput( x, mask, values, 'throw' );`
	`207`	`+* var out = mskput( x, mask, values, 'strict' );`
`206`	`208`	`* // returns [ 1, 20, 30, 4 ]`
`207`	`209`	`*`
`208`	`210`	`* var bool = ( out === x );`
`@@ -211,7 +213,7 @@ declare function mskput<T = unknown, U = unknown>( x: AccessorArrayLike<T>, mask`
`211`	`213`	`* @example`
`212`	`214`	`* var x = [ 1, 2, 3, 4 ];`
`213`	`215`	`*`
`214`		`-* var out = mskput( x, [ 1, 0, 0, 1 ], [ 30 ], 'throw' );`
	`216`	`+* var out = mskput( x, [ 1, 0, 0, 1 ], [ 30 ], 'strict' );`
`215`	`217`	`* // returns [ 1, 30, 30, 4 ]`
`216`	`218`	`*`
`217`	`219`	`* var bool = ( out === x );`
Original file line number	Diff line number	Diff line change
`@@ -31,7 +31,7 @@`
`31`	`31`	`* var mask = [ 1, 0, 0, 1 ];`
`32`	`32`	`* var values = [ 20, 30 ];`
`33`	`33`	`*`
`34`		`-* var out = mskput( x, mask, values, 'throw' );`
	`34`	`+* var out = mskput( x, mask, values, 'strict' );`
`35`	`35`	`* // returns [ 1, 20, 30, 4 ]`
`36`	`36`	`*`
`37`	`37`	`* var bool = ( out === x );`