From d793d11f074cd0c2a068b6f5bad93742f00fd4d4 Mon Sep 17 00:00:00 2001 From: zeeshan3h3 Date: Sun, 4 Jan 2026 21:58:27 +0530 Subject: [PATCH 1/2] chore: fix JavaScript lint errors --- ksdn | 726 ++++++++++++++++++ .../deep-has-own-property/examples/index.js | 40 +- .../lapack/base/dlaswp/test/test.dlaswp.js | 321 ++++---- .../nonenumerable-property-names/lib/main.js | 17 +- stdlib | 1 + 5 files changed, 916 insertions(+), 189 deletions(-) create mode 100644 ksdn create mode 160000 stdlib diff --git a/ksdn b/ksdn new file mode 100644 index 000000000000..e1f75f6889e2 --- /dev/null +++ b/ksdn @@ -0,0 +1,726 @@ +diff --git a/lib/node_modules/@stdlib/assert/deep-has-own-property/examples/index.js b/lib/node_modules/@stdlib/assert/deep-has-own-property/examples/index.js +index 4a01f419f1f..040fdc56be1 100644 +--- a/lib/node_modules/@stdlib/assert/deep-has-own-property/examples/index.js ++++ b/lib/node_modules/@stdlib/assert/deep-has-own-property/examples/index.js +@@ -20,53 +20,53 @@ +  + 'use strict'; +  +-var deepHasOwnProp = require( './../lib' ); ++var deepHasOwnProp = require('./../lib'); +  + var obj = { 'a': { 'b': { 'c': 'd' } } }; +-var bool = deepHasOwnProp( obj, 'a.b.c' ); +-console.log( bool ); ++var bool = deepHasOwnProp(obj, 'a.b.c'); ++console.log(bool); + // => true +  + obj = { 'a': { 'b': { 'c': 'd' } } }; +-bool = deepHasOwnProp( obj, [ 'a', 'b', 'c' ] ); +-console.log( bool ); ++bool = deepHasOwnProp(obj, ['a', 'b', 'c']); ++console.log(bool); + // => true +  + obj = { 'a': { 'b': { 'c': 'd' } } }; +-bool = deepHasOwnProp( obj, 'a/b/c', { ++bool = deepHasOwnProp(obj, 'a/b/c', { + 'sep': '/' + }); +-console.log( bool ); ++console.log(bool); + // => true +  + obj = { 'a': { 'b': { 'c': 'd' } } }; +-bool = deepHasOwnProp( obj, 'a.b.c.d' ); +-console.log( bool ); ++bool = deepHasOwnProp(obj, 'a.b.c.d'); ++console.log(bool); + // => false +  +-obj = { 'a': [ { 'b': { 'c': 'd' } } ] }; +-bool = deepHasOwnProp( obj, [ 'a', '0', 'b', 'c', 'd' ] ); +-console.log( bool ); ++obj = { 'a': [{ 'b': { 'c': 'd' } }] }; ++bool = deepHasOwnProp(obj, ['a', '0', 'b', 'c', 'd']); ++console.log(bool); + // => false +  + obj = { 'a': { 'b': { 'c': 'd' } } }; +-bool = deepHasOwnProp( obj, 'a/b/c/d/e', { ++bool = deepHasOwnProp(obj, 'a/b/c/d/e', { + 'sep': '/' + }); +-console.log( bool ); ++console.log(bool); + // => false +  + // Create a customized function: +-var has = deepHasOwnProp.factory( 'a_b_c', { ++var has = deepHasOwnProp.factory('a_b_c', { + 'sep': '_' + }); +  + obj = { 'a': { 'b': { 'c': 'd' } } }; +-bool = has( obj ); +-console.log( bool ); ++bool = has(obj); ++console.log(bool); + // => true +  +-obj = { 'a': [ { 'b': { 'c': 'd' } } ] }; +-bool = has( obj ); +-console.log( bool ); ++obj = { 'a': [{ 'b': { 'c': 'd' } }] }; ++bool = has(obj); ++console.log(bool); + // => false +diff --git a/lib/node_modules/@stdlib/lapack/base/dlaswp/test/test.dlaswp.js b/lib/node_modules/@stdlib/lapack/base/dlaswp/test/test.dlaswp.js +index f2ce06b4c76..cd9960d1cc4 100644 +--- a/lib/node_modules/@stdlib/lapack/base/dlaswp/test/test.dlaswp.js ++++ b/lib/node_modules/@stdlib/lapack/base/dlaswp/test/test.dlaswp.js +@@ -22,49 +22,48 @@ +  + // MODULES // +  +-var tape = require( 'tape' ); +-var Int32Array = require( '@stdlib/array/int32' ); +-var Float64Array = require( '@stdlib/array/float64' ); +-var oneTo = require( '@stdlib/array/one-to' ); +-var flatten = require( '@stdlib/array/base/flatten' ); +-var reverse = require( '@stdlib/array/base/reverse' ); +-var ndarray2array = require( '@stdlib/ndarray/base/to-array' ); +-var numel = require( '@stdlib/ndarray/base/numel' ); +-var shape2strides = require( '@stdlib/ndarray/base/shape2strides' ); +-var dlaswp = require( './../lib/dlaswp.js' ); ++var tape = require('tape'); ++var Int32Array = require('@stdlib/array/int32'); ++var Float64Array = require('@stdlib/array/float64'); ++var oneTo = require('@stdlib/array/one-to'); ++var flatten = require('@stdlib/array/base/flatten'); ++var reverse = require('@stdlib/array/base/reverse'); ++var ndarray2array = require('@stdlib/ndarray/base/to-array'); ++var numel = require('@stdlib/ndarray/base/numel'); ++var shape2strides = require('@stdlib/ndarray/base/shape2strides'); ++var dlaswp = require('./../lib/dlaswp.js'); +  +  + // FIXTURES // +  +-var COL_MAJOR = require( './fixtures/column_major_no_offsets.json' ); +-var COL_MAJOR_IPIV_STRIDE_POS = require( './fixtures/column_major_ipiv_stride_positive.json' ); +-var COL_MAJOR_IPIV_STRIDE_NEG = require( './fixtures/column_major_ipiv_stride_negative.json' ); +-var COL_MAJOR_LDA = require( './fixtures/column_major_lda.json' ); +-var COL_MAJOR_REV_PIVOTS = require( './fixtures/column_major_reverse_pivots.json' ); +-var COL_MAJOR_K1 = require( './fixtures/column_major_k1.json' ); +- +-var ROW_MAJOR = require( './fixtures/row_major_no_offsets.json' ); +-var ROW_MAJOR_IPIV_STRIDE_POS = require( './fixtures/row_major_ipiv_stride_positive.json' ); +-var ROW_MAJOR_IPIV_STRIDE_NEG = require( './fixtures/row_major_ipiv_stride_negative.json' ); +-var ROW_MAJOR_LDA = require( './fixtures/row_major_lda.json' ); +-var ROW_MAJOR_REV_PIVOTS = require( './fixtures/row_major_reverse_pivots.json' ); +-var ROW_MAJOR_K1 = require( './fixtures/row_major_k1.json' ); ++var COL_MAJOR = require('./fixtures/column_major_no_offsets.json'); ++var COL_MAJOR_IPIV_STRIDE_POS = require('./fixtures/column_major_ipiv_stride_positive.json'); ++var COL_MAJOR_IPIV_STRIDE_NEG = require('./fixtures/column_major_ipiv_stride_negative.json'); ++var COL_MAJOR_LDA = require('./fixtures/column_major_lda.json'); ++var COL_MAJOR_REV_PIVOTS = require('./fixtures/column_major_reverse_pivots.json'); ++var COL_MAJOR_K1 = require('./fixtures/column_major_k1.json'); ++var ROW_MAJOR = require('./fixtures/row_major_no_offsets.json'); ++var ROW_MAJOR_IPIV_STRIDE_POS = require('./fixtures/row_major_ipiv_stride_positive.json'); ++var ROW_MAJOR_IPIV_STRIDE_NEG = require('./fixtures/row_major_ipiv_stride_negative.json'); ++var ROW_MAJOR_LDA = require('./fixtures/row_major_lda.json'); ++var ROW_MAJOR_REV_PIVOTS = require('./fixtures/row_major_reverse_pivots.json'); ++var ROW_MAJOR_K1 = require('./fixtures/row_major_k1.json'); +  +  + // TESTS // +  +-tape( 'main export is a function', function test( t ) { +- t.ok( true, __filename ); +- t.strictEqual( typeof dlaswp, 'function', 'main export is a function' ); ++tape('main export is a function', function test(t) { ++ t.ok(true, __filename); ++ t.strictEqual(typeof dlaswp, 'function', 'main export is a function'); + t.end(); + }); +  +-tape( 'the function has an arity of 8', function test( t ) { +- t.strictEqual( dlaswp.length, 8, 'returns expected value' ); ++tape('the function has an arity of 8', function test(t) { ++ t.strictEqual(dlaswp.length, 8, 'returns expected value'); + t.end(); + }); +  +-tape( 'the function throws an error if provided a first argument which is not a valid order', function test( t ) { ++tape('the function throws an error if provided a first argument which is not a valid order', function test(t) { + var values; + var data; + var i; +@@ -84,22 +83,22 @@ tape( 'the function throws an error if provided a first argument which is not a + void 0, + [], + {}, +- function noop() {} ++ function noop() { } + ]; +  +- for ( i = 0; i < values.length; i++ ) { +- t.throws( badValue( values[ i ] ), TypeError, 'throws an error when provided ' + values[ i ] ); ++ for (i = 0; i < values.length; i++) { ++ t.throws(badValue(values[i]), TypeError, 'throws an error when provided ' + values[i]); + } + t.end(); +  +- function badValue( value ) { ++ function badValue(value) { + return function badValue() { +- dlaswp( value, data.N, data.A, data.LDA, data.k1, data.k2, data.IPIV, data.strideIPIV ); ++ dlaswp(value, data.N, data.A, data.LDA, data.k1, data.k2, data.IPIV, data.strideIPIV); + }; + } + }); +  +-tape( 'the function throws an error if provided a fourth argument which is not a valid `LDA` value (row-major)', function test( t ) { ++tape('the function throws an error if provided a fourth argument which is not a valid `LDA` value (row-major)', function test(t) { + var values; + var data; + var i; +@@ -111,19 +110,19 @@ tape( 'the function throws an error if provided a fourth argument which is not a + 1 + ]; +  +- for ( i = 0; i < values.length; i++ ) { +- t.throws( badValue( values[ i ] ), RangeError, 'throws an error when provided ' + values[ i ] ); ++ for (i = 0; i < values.length; i++) { ++ t.throws(badValue(values[i]), RangeError, 'throws an error when provided ' + values[i]); + } + t.end(); +  +- function badValue( value ) { ++ function badValue(value) { + return function badValue() { +- dlaswp( data.order, data.N, data.A, value, data.k1, data.k2, data.IPIV, data.strideIPIV ); ++ dlaswp(data.order, data.N, data.A, value, data.k1, data.k2, data.IPIV, data.strideIPIV); + }; + } + }); +  +-tape( 'the function performs a series of row interchanges (column-major)', function test( t ) { ++tape('the function performs a series of row interchanges (column-major)', function test(t) { + var expected; + var IPIV; + var data; +@@ -132,19 +131,19 @@ tape( 'the function performs a series of row interchanges (column-major)', funct +  + data = COL_MAJOR; +  +- A = new Float64Array( data.A ); +- IPIV = new Int32Array( data.IPIV ); ++ A = new Float64Array(data.A); ++ IPIV = new Int32Array(data.IPIV); +  +- expected = new Float64Array( data.A_out ); ++ expected = new Float64Array(data.A_out); +  +- out = dlaswp( data.order, data.N, A, data.LDA, data.k1, data.k2, IPIV, data.strideIPIV ); +- t.strictEqual( out, A, 'returns expected value' ); +- t.deepEqual( out, expected, 'returns expected value' ); ++ out = dlaswp(data.order, data.N, A, data.LDA, data.k1, data.k2, IPIV, data.strideIPIV); ++ t.strictEqual(out, A, 'returns expected value'); ++ t.deepEqual(out, expected, 'returns expected value'); +  + t.end(); + }); +  +-tape( 'the function performs a series of row interchanges (column-major, k1 > 0)', function test( t ) { ++tape('the function performs a series of row interchanges (column-major, k1 > 0)', function test(t) { + var expected; + var IPIV; + var data; +@@ -153,19 +152,19 @@ tape( 'the function performs a series of row interchanges (column-major, k1 > 0) +  + data = COL_MAJOR_K1; +  +- A = new Float64Array( data.A ); +- IPIV = new Int32Array( data.IPIV ); ++ A = new Float64Array(data.A); ++ IPIV = new Int32Array(data.IPIV); +  +- expected = new Float64Array( data.A_out ); ++ expected = new Float64Array(data.A_out); +  +- out = dlaswp( data.order, data.N, A, data.LDA, data.k1, data.k2, IPIV, data.strideIPIV ); +- t.strictEqual( out, A, 'returns expected value' ); +- t.deepEqual( out, expected, 'returns expected value' ); ++ out = dlaswp(data.order, data.N, A, data.LDA, data.k1, data.k2, IPIV, data.strideIPIV); ++ t.strictEqual(out, A, 'returns expected value'); ++ t.deepEqual(out, expected, 'returns expected value'); +  + t.end(); + }); +  +-tape( 'the function supports applying pivots in reverse order (column-major)', function test( t ) { ++tape('the function supports applying pivots in reverse order (column-major)', function test(t) { + var expected; + var IPIV; + var data; +@@ -174,19 +173,19 @@ tape( 'the function supports applying pivots in reverse order (column-major)', f +  + data = COL_MAJOR_REV_PIVOTS; +  +- A = new Float64Array( data.A ); +- IPIV = new Int32Array( data.IPIV ); ++ A = new Float64Array(data.A); ++ IPIV = new Int32Array(data.IPIV); +  +- expected = new Float64Array( data.A_out ); ++ expected = new Float64Array(data.A_out); +  +- out = dlaswp( data.order, data.N, A, data.LDA, data.k1, data.k2, IPIV, data.strideIPIV ); +- t.strictEqual( out, A, 'returns expected value' ); +- t.deepEqual( out, expected, 'returns expected value' ); ++ out = dlaswp(data.order, data.N, A, data.LDA, data.k1, data.k2, IPIV, data.strideIPIV); ++ t.strictEqual(out, A, 'returns expected value'); ++ t.deepEqual(out, expected, 'returns expected value'); +  + t.end(); + }); +  +-tape( 'the function supports specifying an `LDA` parameter for operating on sub-matrices (column-major)', function test( t ) { ++tape('the function supports specifying an `LDA` parameter for operating on sub-matrices (column-major)', function test(t) { + var expected; + var IPIV; + var data; +@@ -195,19 +194,19 @@ tape( 'the function supports specifying an `LDA` parameter for operating on sub- +  + data = COL_MAJOR_LDA; +  +- A = new Float64Array( data.A ); +- IPIV = new Int32Array( data.IPIV ); ++ A = new Float64Array(data.A); ++ IPIV = new Int32Array(data.IPIV); +  +- expected = new Float64Array( data.A_out ); ++ expected = new Float64Array(data.A_out); +  +- out = dlaswp( data.order, data.N, A, data.LDA, data.k1, data.k2, IPIV, data.strideIPIV ); +- t.strictEqual( out, A, 'returns expected value' ); +- t.deepEqual( out, expected, 'returns expected value' ); ++ out = dlaswp(data.order, data.N, A, data.LDA, data.k1, data.k2, IPIV, data.strideIPIV); ++ t.strictEqual(out, A, 'returns expected value'); ++ t.deepEqual(out, expected, 'returns expected value'); +  + t.end(); + }); +  +-tape( 'the function supports specifying a positive increment between successive values of `IPIV` (column-major)', function test( t ) { ++tape('the function supports specifying a positive increment between successive values of `IPIV` (column-major)', function test(t) { + var expected; + var IPIV; + var data; +@@ -216,19 +215,19 @@ tape( 'the function supports specifying a positive increment between successive +  + data = COL_MAJOR_IPIV_STRIDE_POS; +  +- A = new Float64Array( data.A ); +- IPIV = new Int32Array( data.IPIV ); ++ A = new Float64Array(data.A); ++ IPIV = new Int32Array(data.IPIV); +  +- expected = new Float64Array( data.A_out ); ++ expected = new Float64Array(data.A_out); +  +- out = dlaswp( data.order, data.N, A, data.LDA, data.k1, data.k2, IPIV, data.strideIPIV ); +- t.strictEqual( out, A, 'returns expected value' ); +- t.deepEqual( out, expected, 'returns expected value' ); ++ out = dlaswp(data.order, data.N, A, data.LDA, data.k1, data.k2, IPIV, data.strideIPIV); ++ t.strictEqual(out, A, 'returns expected value'); ++ t.deepEqual(out, expected, 'returns expected value'); +  + t.end(); + }); +  +-tape( 'the function supports specifying a negative increment between successive values of `IPIV` (column-major)', function test( t ) { ++tape('the function supports specifying a negative increment between successive values of `IPIV` (column-major)', function test(t) { + var expected; + var IPIV; + var data; +@@ -237,19 +236,19 @@ tape( 'the function supports specifying a negative increment between successive +  + data = COL_MAJOR_IPIV_STRIDE_NEG; +  +- A = new Float64Array( data.A ); +- IPIV = new Int32Array( data.IPIV ); ++ A = new Float64Array(data.A); ++ IPIV = new Int32Array(data.IPIV); +  +- expected = new Float64Array( data.A_out ); ++ expected = new Float64Array(data.A_out); +  +- out = dlaswp( data.order, data.N, A, data.LDA, data.k1, data.k2, IPIV, data.strideIPIV ); +- t.strictEqual( out, A, 'returns expected value' ); +- t.deepEqual( out, expected, 'returns expected value' ); ++ out = dlaswp(data.order, data.N, A, data.LDA, data.k1, data.k2, IPIV, data.strideIPIV); ++ t.strictEqual(out, A, 'returns expected value'); ++ t.deepEqual(out, expected, 'returns expected value'); +  + t.end(); + }); +  +-tape( 'if provided an increment between successive values of `IPIV` equal to `0`, the function returns the input matrix unchanged (column-major)', function test( t ) { ++tape('if provided an increment between successive values of `IPIV` equal to `0`, the function returns the input matrix unchanged (column-major)', function test(t) { + var expected; + var IPIV; + var data; +@@ -258,19 +257,19 @@ tape( 'if provided an increment between successive values of `IPIV` equal to `0` +  + data = COL_MAJOR; +  +- A = new Float64Array( data.A ); +- IPIV = new Int32Array( data.IPIV ); ++ A = new Float64Array(data.A); ++ IPIV = new Int32Array(data.IPIV); +  +- expected = new Float64Array( data.A ); ++ expected = new Float64Array(data.A); +  +- out = dlaswp( data.order, data.N, A, data.LDA, data.k1, data.k2, IPIV, 0 ); +- t.strictEqual( out, A, 'returns expected value' ); +- t.deepEqual( out, expected, 'returns expected value' ); ++ out = dlaswp(data.order, data.N, A, data.LDA, data.k1, data.k2, IPIV, 0); ++ t.strictEqual(out, A, 'returns expected value'); ++ t.deepEqual(out, expected, 'returns expected value'); +  + t.end(); + }); +  +-tape( 'the function efficiently handles large datasets (column-major)', function test( t ) { ++tape('the function efficiently handles large datasets (column-major)', function test(t) { + var expected; + var IPIV; + var buf; +@@ -283,36 +282,36 @@ tape( 'the function efficiently handles large datasets (column-major)', function + var o; +  + ord = 'column-major'; +- sh = [ 5, 100 ]; +- st = shape2strides( sh, ord ); ++ sh = [5, 100]; ++ st = shape2strides(sh, ord); + o = 0; +  + // Define a linear buffer: +- buf = oneTo( numel( sh ), 'generic' ); ++ buf = oneTo(numel(sh), 'generic'); +  + // Convert to a nested array: +- mat = ndarray2array( buf, sh, st, o, ord ); ++ mat = ndarray2array(buf, sh, st, o, ord); +  + // Define an input matrix in linear storage: +- A = new Float64Array( buf ); ++ A = new Float64Array(buf); +  + // Create an array of pivot indices: +- IPIV = new Int32Array( [ 9999, 9999, 9999, 1, 0 ] ); ++ IPIV = new Int32Array([9999, 9999, 9999, 1, 0]); +  + // Define the expected output array: +- expected = reverse( mat.slice() ); +- expected = new Float64Array( flatten( expected, sh, true ) ); ++ expected = reverse(mat.slice()); ++ expected = new Float64Array(flatten(expected, sh, true)); +  + // Interchange rows: +- out = dlaswp( ord, sh[1], A, sh[0], 3, 4, IPIV, 1 ); ++ out = dlaswp(ord, sh[1], A, sh[0], 3, 4, IPIV, 1); +  +- t.strictEqual( out, A, 'returns expected value' ); +- t.deepEqual( out, expected, 'returns expected value' ); ++ t.strictEqual(out, A, 'returns expected value'); ++ t.deepEqual(out, expected, 'returns expected value'); +  + t.end(); + }); +  +-tape( 'the function performs a series of row interchanges (row-major)', function test( t ) { ++tape('the function performs a series of row interchanges (row-major)', function test(t) { + var expected; + var IPIV; + var data; +@@ -321,19 +320,19 @@ tape( 'the function performs a series of row interchanges (row-major)', function +  + data = ROW_MAJOR; +  +- A = new Float64Array( data.A ); +- IPIV = new Int32Array( data.IPIV ); ++ A = new Float64Array(data.A); ++ IPIV = new Int32Array(data.IPIV); +  +- expected = new Float64Array( data.A_out ); ++ expected = new Float64Array(data.A_out); +  +- out = dlaswp( data.order, data.N, A, data.LDA, data.k1, data.k2, IPIV, data.strideIPIV ); +- t.strictEqual( out, A, 'returns expected value' ); +- t.deepEqual( out, expected, 'returns expected value' ); ++ out = dlaswp(data.order, data.N, A, data.LDA, data.k1, data.k2, IPIV, data.strideIPIV); ++ t.strictEqual(out, A, 'returns expected value'); ++ t.deepEqual(out, expected, 'returns expected value'); +  + t.end(); + }); +  +-tape( 'the function performs a series of row interchanges (row-major, k1 > 0)', function test( t ) { ++tape('the function performs a series of row interchanges (row-major, k1 > 0)', function test(t) { + var expected; + var IPIV; + var data; +@@ -342,19 +341,19 @@ tape( 'the function performs a series of row interchanges (row-major, k1 > 0)', +  + data = ROW_MAJOR_K1; +  +- A = new Float64Array( data.A ); +- IPIV = new Int32Array( data.IPIV ); ++ A = new Float64Array(data.A); ++ IPIV = new Int32Array(data.IPIV); +  +- expected = new Float64Array( data.A_out ); ++ expected = new Float64Array(data.A_out); +  +- out = dlaswp( data.order, data.N, A, data.LDA, data.k1, data.k2, IPIV, data.strideIPIV ); +- t.strictEqual( out, A, 'returns expected value' ); +- t.deepEqual( out, expected, 'returns expected value' ); ++ out = dlaswp(data.order, data.N, A, data.LDA, data.k1, data.k2, IPIV, data.strideIPIV); ++ t.strictEqual(out, A, 'returns expected value'); ++ t.deepEqual(out, expected, 'returns expected value'); +  + t.end(); + }); +  +-tape( 'the function supports applying pivots in reverse order (row-major)', function test( t ) { ++tape('the function supports applying pivots in reverse order (row-major)', function test(t) { + var expected; + var IPIV; + var data; +@@ -363,19 +362,19 @@ tape( 'the function supports applying pivots in reverse order (row-major)', func +  + data = ROW_MAJOR_REV_PIVOTS; +  +- A = new Float64Array( data.A ); +- IPIV = new Int32Array( data.IPIV ); ++ A = new Float64Array(data.A); ++ IPIV = new Int32Array(data.IPIV); +  +- expected = new Float64Array( data.A_out ); ++ expected = new Float64Array(data.A_out); +  +- out = dlaswp( data.order, data.N, A, data.LDA, data.k1, data.k2, IPIV, data.strideIPIV ); +- t.strictEqual( out, A, 'returns expected value' ); +- t.deepEqual( out, expected, 'returns expected value' ); ++ out = dlaswp(data.order, data.N, A, data.LDA, data.k1, data.k2, IPIV, data.strideIPIV); ++ t.strictEqual(out, A, 'returns expected value'); ++ t.deepEqual(out, expected, 'returns expected value'); +  + t.end(); + }); +  +-tape( 'the function supports specifying an `LDA` parameter for operating on sub-matrices (row-major)', function test( t ) { ++tape('the function supports specifying an `LDA` parameter for operating on sub-matrices (row-major)', function test(t) { + var expected; + var IPIV; + var data; +@@ -384,19 +383,19 @@ tape( 'the function supports specifying an `LDA` parameter for operating on sub- +  + data = ROW_MAJOR_LDA; +  +- A = new Float64Array( data.A ); +- IPIV = new Int32Array( data.IPIV ); ++ A = new Float64Array(data.A); ++ IPIV = new Int32Array(data.IPIV); +  +- expected = new Float64Array( data.A_out ); ++ expected = new Float64Array(data.A_out); +  +- out = dlaswp( data.order, data.N, A, data.LDA, data.k1, data.k2, IPIV, data.strideIPIV ); +- t.strictEqual( out, A, 'returns expected value' ); +- t.deepEqual( out, expected, 'returns expected value' ); ++ out = dlaswp(data.order, data.N, A, data.LDA, data.k1, data.k2, IPIV, data.strideIPIV); ++ t.strictEqual(out, A, 'returns expected value'); ++ t.deepEqual(out, expected, 'returns expected value'); +  + t.end(); + }); +  +-tape( 'the function supports specifying a positive increment between successive values of `IPIV` (row-major)', function test( t ) { ++tape('the function supports specifying a positive increment between successive values of `IPIV` (row-major)', function test(t) { + var expected; + var IPIV; + var data; +@@ -405,19 +404,19 @@ tape( 'the function supports specifying a positive increment between successive +  + data = ROW_MAJOR_IPIV_STRIDE_POS; +  +- A = new Float64Array( data.A ); +- IPIV = new Int32Array( data.IPIV ); ++ A = new Float64Array(data.A); ++ IPIV = new Int32Array(data.IPIV); +  +- expected = new Float64Array( data.A_out ); ++ expected = new Float64Array(data.A_out); +  +- out = dlaswp( data.order, data.N, A, data.LDA, data.k1, data.k2, IPIV, data.strideIPIV ); +- t.strictEqual( out, A, 'returns expected value' ); +- t.deepEqual( out, expected, 'returns expected value' ); ++ out = dlaswp(data.order, data.N, A, data.LDA, data.k1, data.k2, IPIV, data.strideIPIV); ++ t.strictEqual(out, A, 'returns expected value'); ++ t.deepEqual(out, expected, 'returns expected value'); +  + t.end(); + }); +  +-tape( 'the function supports specifying a negative increment between successive values of `IPIV` (row-major)', function test( t ) { ++tape('the function supports specifying a negative increment between successive values of `IPIV` (row-major)', function test(t) { + var expected; + var IPIV; + var data; +@@ -426,19 +425,19 @@ tape( 'the function supports specifying a negative increment between successive +  + data = ROW_MAJOR_IPIV_STRIDE_NEG; +  +- A = new Float64Array( data.A ); +- IPIV = new Int32Array( data.IPIV ); ++ A = new Float64Array(data.A); ++ IPIV = new Int32Array(data.IPIV); +  +- expected = new Float64Array( data.A_out ); ++ expected = new Float64Array(data.A_out); +  +- out = dlaswp( data.order, data.N, A, data.LDA, data.k1, data.k2, IPIV, data.strideIPIV ); +- t.strictEqual( out, A, 'returns expected value' ); +- t.deepEqual( out, expected, 'returns expected value' ); ++ out = dlaswp(data.order, data.N, A, data.LDA, data.k1, data.k2, IPIV, data.strideIPIV); ++ t.strictEqual(out, A, 'returns expected value'); ++ t.deepEqual(out, expected, 'returns expected value'); +  + t.end(); + }); +  +-tape( 'if provided an increment between successive values of `IPIV` equal to `0`, the function returns the input matrix unchanged (row-major)', function test( t ) { ++tape('if provided an increment between successive values of `IPIV` equal to `0`, the function returns the input matrix unchanged (row-major)', function test(t) { + var expected; + var IPIV; + var data; +@@ -447,19 +446,19 @@ tape( 'if provided an increment between successive values of `IPIV` equal to `0` +  + data = ROW_MAJOR; +  +- A = new Float64Array( data.A ); +- IPIV = new Int32Array( data.IPIV ); ++ A = new Float64Array(data.A); ++ IPIV = new Int32Array(data.IPIV); +  +- expected = new Float64Array( data.A ); ++ expected = new Float64Array(data.A); +  +- out = dlaswp( data.order, data.N, A, data.LDA, data.k1, data.k2, IPIV, 0 ); +- t.strictEqual( out, A, 'returns expected value' ); +- t.deepEqual( out, expected, 'returns expected value' ); ++ out = dlaswp(data.order, data.N, A, data.LDA, data.k1, data.k2, IPIV, 0); ++ t.strictEqual(out, A, 'returns expected value'); ++ t.deepEqual(out, expected, 'returns expected value'); +  + t.end(); + }); +  +-tape( 'the function efficiently handles large datasets (row-major)', function test( t ) { ++tape('the function efficiently handles large datasets (row-major)', function test(t) { + var expected; + var IPIV; + var buf; +@@ -472,31 +471,31 @@ tape( 'the function efficiently handles large datasets (row-major)', function te + var o; +  + ord = 'row-major'; +- sh = [ 5, 100 ]; +- st = shape2strides( sh, ord ); ++ sh = [5, 100]; ++ st = shape2strides(sh, ord); + o = 0; +  + // Define a linear buffer: +- buf = oneTo( numel( sh ), 'generic' ); ++ buf = oneTo(numel(sh), 'generic'); +  + // Convert to a nested array: +- mat = ndarray2array( buf, sh, st, o, ord ); ++ mat = ndarray2array(buf, sh, st, o, ord); +  + // Define an input matrix in linear storage: +- A = new Float64Array( buf ); ++ A = new Float64Array(buf); +  + // Create an array of pivot indices: +- IPIV = new Int32Array( [ 9999, 9999, 9999, 1, 0 ] ); ++ IPIV = new Int32Array([9999, 9999, 9999, 1, 0]); +  + // Define the expected output array: +- expected = reverse( mat.slice() ); +- expected = new Float64Array( flatten( expected, sh, false ) ); ++ expected = reverse(mat.slice()); ++ expected = new Float64Array(flatten(expected, sh, false)); +  + // Interchange rows: +- out = dlaswp( ord, sh[1], A, sh[1], 3, 4, IPIV, 1 ); ++ out = dlaswp(ord, sh[1], A, sh[1], 3, 4, IPIV, 1); +  +- t.strictEqual( out, A, 'returns expected value' ); +- t.deepEqual( out, expected, 'returns expected value' ); ++ t.strictEqual(out, A, 'returns expected value'); ++ t.deepEqual(out, expected, 'returns expected value'); +  + t.end(); + }); +diff --git a/lib/node_modules/@stdlib/utils/nonenumerable-property-names/lib/main.js b/lib/node_modules/@stdlib/utils/nonenumerable-property-names/lib/main.js +index 5c4e90af21a..6765d283bcc 100644 +--- a/lib/node_modules/@stdlib/utils/nonenumerable-property-names/lib/main.js ++++ b/lib/node_modules/@stdlib/utils/nonenumerable-property-names/lib/main.js +@@ -20,8 +20,9 @@ +  + // MODULES // +  +-var getOwnPropertyNames = require( '@stdlib/utils/property-names' ); +-var isNonEnumerableProperty = require( '@stdlib/assert/is-nonenumerable-property' ); ++var getOwnPropertyNames = require('@stdlib/utils/property-names'); ++var isNonEnumerableProperty = require('@stdlib/assert/is-nonenumerable-property'); ++var Object = require('@stdlib/object/ctor'); +  +  + // MAIN // +@@ -47,19 +48,19 @@ var isNonEnumerableProperty = require( '@stdlib/assert/is-nonenumerable-property + * var keys = nonEnumerablePropertyNames( obj ); + * // returns [ 'beep' ] + */ +-function nonEnumerablePropertyNames( value ) { // eslint-disable-line id-length ++function nonEnumerablePropertyNames(value) { // eslint-disable-line id-length + var names; + var i; + var n; +  +- if ( value === null || value === void 0 ) { ++ if (value === null || value === void 0) { + return []; + } +- names = getOwnPropertyNames( Object( value ) ); ++ names = getOwnPropertyNames(Object(value)); + n = 0; +- for ( i = 0; i < names.length; i++ ) { +- if ( isNonEnumerableProperty( value, names[ i ] ) ) { +- names[ n ] = names[ i ]; ++ for (i = 0; i < names.length; i++) { ++ if (isNonEnumerableProperty(value, names[i])) { ++ names[n] = names[i]; + n += 1; + } + } diff --git a/lib/node_modules/@stdlib/assert/deep-has-own-property/examples/index.js b/lib/node_modules/@stdlib/assert/deep-has-own-property/examples/index.js index 4a01f419f1f5..040fdc56be12 100644 --- a/lib/node_modules/@stdlib/assert/deep-has-own-property/examples/index.js +++ b/lib/node_modules/@stdlib/assert/deep-has-own-property/examples/index.js @@ -20,53 +20,53 @@ 'use strict'; -var deepHasOwnProp = require( './../lib' ); +var deepHasOwnProp = require('./../lib'); var obj = { 'a': { 'b': { 'c': 'd' } } }; -var bool = deepHasOwnProp( obj, 'a.b.c' ); -console.log( bool ); +var bool = deepHasOwnProp(obj, 'a.b.c'); +console.log(bool); // => true obj = { 'a': { 'b': { 'c': 'd' } } }; -bool = deepHasOwnProp( obj, [ 'a', 'b', 'c' ] ); -console.log( bool ); +bool = deepHasOwnProp(obj, ['a', 'b', 'c']); +console.log(bool); // => true obj = { 'a': { 'b': { 'c': 'd' } } }; -bool = deepHasOwnProp( obj, 'a/b/c', { +bool = deepHasOwnProp(obj, 'a/b/c', { 'sep': '/' }); -console.log( bool ); +console.log(bool); // => true obj = { 'a': { 'b': { 'c': 'd' } } }; -bool = deepHasOwnProp( obj, 'a.b.c.d' ); -console.log( bool ); +bool = deepHasOwnProp(obj, 'a.b.c.d'); +console.log(bool); // => false -obj = { 'a': [ { 'b': { 'c': 'd' } } ] }; -bool = deepHasOwnProp( obj, [ 'a', '0', 'b', 'c', 'd' ] ); -console.log( bool ); +obj = { 'a': [{ 'b': { 'c': 'd' } }] }; +bool = deepHasOwnProp(obj, ['a', '0', 'b', 'c', 'd']); +console.log(bool); // => false obj = { 'a': { 'b': { 'c': 'd' } } }; -bool = deepHasOwnProp( obj, 'a/b/c/d/e', { +bool = deepHasOwnProp(obj, 'a/b/c/d/e', { 'sep': '/' }); -console.log( bool ); +console.log(bool); // => false // Create a customized function: -var has = deepHasOwnProp.factory( 'a_b_c', { +var has = deepHasOwnProp.factory('a_b_c', { 'sep': '_' }); obj = { 'a': { 'b': { 'c': 'd' } } }; -bool = has( obj ); -console.log( bool ); +bool = has(obj); +console.log(bool); // => true -obj = { 'a': [ { 'b': { 'c': 'd' } } ] }; -bool = has( obj ); -console.log( bool ); +obj = { 'a': [{ 'b': { 'c': 'd' } }] }; +bool = has(obj); +console.log(bool); // => false diff --git a/lib/node_modules/@stdlib/lapack/base/dlaswp/test/test.dlaswp.js b/lib/node_modules/@stdlib/lapack/base/dlaswp/test/test.dlaswp.js index f2ce06b4c767..cd9960d1cc43 100644 --- a/lib/node_modules/@stdlib/lapack/base/dlaswp/test/test.dlaswp.js +++ b/lib/node_modules/@stdlib/lapack/base/dlaswp/test/test.dlaswp.js @@ -22,49 +22,48 @@ // MODULES // -var tape = require( 'tape' ); -var Int32Array = require( '@stdlib/array/int32' ); -var Float64Array = require( '@stdlib/array/float64' ); -var oneTo = require( '@stdlib/array/one-to' ); -var flatten = require( '@stdlib/array/base/flatten' ); -var reverse = require( '@stdlib/array/base/reverse' ); -var ndarray2array = require( '@stdlib/ndarray/base/to-array' ); -var numel = require( '@stdlib/ndarray/base/numel' ); -var shape2strides = require( '@stdlib/ndarray/base/shape2strides' ); -var dlaswp = require( './../lib/dlaswp.js' ); +var tape = require('tape'); +var Int32Array = require('@stdlib/array/int32'); +var Float64Array = require('@stdlib/array/float64'); +var oneTo = require('@stdlib/array/one-to'); +var flatten = require('@stdlib/array/base/flatten'); +var reverse = require('@stdlib/array/base/reverse'); +var ndarray2array = require('@stdlib/ndarray/base/to-array'); +var numel = require('@stdlib/ndarray/base/numel'); +var shape2strides = require('@stdlib/ndarray/base/shape2strides'); +var dlaswp = require('./../lib/dlaswp.js'); // FIXTURES // -var COL_MAJOR = require( './fixtures/column_major_no_offsets.json' ); -var COL_MAJOR_IPIV_STRIDE_POS = require( './fixtures/column_major_ipiv_stride_positive.json' ); -var COL_MAJOR_IPIV_STRIDE_NEG = require( './fixtures/column_major_ipiv_stride_negative.json' ); -var COL_MAJOR_LDA = require( './fixtures/column_major_lda.json' ); -var COL_MAJOR_REV_PIVOTS = require( './fixtures/column_major_reverse_pivots.json' ); -var COL_MAJOR_K1 = require( './fixtures/column_major_k1.json' ); - -var ROW_MAJOR = require( './fixtures/row_major_no_offsets.json' ); -var ROW_MAJOR_IPIV_STRIDE_POS = require( './fixtures/row_major_ipiv_stride_positive.json' ); -var ROW_MAJOR_IPIV_STRIDE_NEG = require( './fixtures/row_major_ipiv_stride_negative.json' ); -var ROW_MAJOR_LDA = require( './fixtures/row_major_lda.json' ); -var ROW_MAJOR_REV_PIVOTS = require( './fixtures/row_major_reverse_pivots.json' ); -var ROW_MAJOR_K1 = require( './fixtures/row_major_k1.json' ); +var COL_MAJOR = require('./fixtures/column_major_no_offsets.json'); +var COL_MAJOR_IPIV_STRIDE_POS = require('./fixtures/column_major_ipiv_stride_positive.json'); +var COL_MAJOR_IPIV_STRIDE_NEG = require('./fixtures/column_major_ipiv_stride_negative.json'); +var COL_MAJOR_LDA = require('./fixtures/column_major_lda.json'); +var COL_MAJOR_REV_PIVOTS = require('./fixtures/column_major_reverse_pivots.json'); +var COL_MAJOR_K1 = require('./fixtures/column_major_k1.json'); +var ROW_MAJOR = require('./fixtures/row_major_no_offsets.json'); +var ROW_MAJOR_IPIV_STRIDE_POS = require('./fixtures/row_major_ipiv_stride_positive.json'); +var ROW_MAJOR_IPIV_STRIDE_NEG = require('./fixtures/row_major_ipiv_stride_negative.json'); +var ROW_MAJOR_LDA = require('./fixtures/row_major_lda.json'); +var ROW_MAJOR_REV_PIVOTS = require('./fixtures/row_major_reverse_pivots.json'); +var ROW_MAJOR_K1 = require('./fixtures/row_major_k1.json'); // TESTS // -tape( 'main export is a function', function test( t ) { - t.ok( true, __filename ); - t.strictEqual( typeof dlaswp, 'function', 'main export is a function' ); +tape('main export is a function', function test(t) { + t.ok(true, __filename); + t.strictEqual(typeof dlaswp, 'function', 'main export is a function'); t.end(); }); -tape( 'the function has an arity of 8', function test( t ) { - t.strictEqual( dlaswp.length, 8, 'returns expected value' ); +tape('the function has an arity of 8', function test(t) { + t.strictEqual(dlaswp.length, 8, 'returns expected value'); t.end(); }); -tape( 'the function throws an error if provided a first argument which is not a valid order', function test( t ) { +tape('the function throws an error if provided a first argument which is not a valid order', function test(t) { var values; var data; var i; @@ -84,22 +83,22 @@ tape( 'the function throws an error if provided a first argument which is not a void 0, [], {}, - function noop() {} + function noop() { } ]; - for ( i = 0; i < values.length; i++ ) { - t.throws( badValue( values[ i ] ), TypeError, 'throws an error when provided ' + values[ i ] ); + for (i = 0; i < values.length; i++) { + t.throws(badValue(values[i]), TypeError, 'throws an error when provided ' + values[i]); } t.end(); - function badValue( value ) { + function badValue(value) { return function badValue() { - dlaswp( value, data.N, data.A, data.LDA, data.k1, data.k2, data.IPIV, data.strideIPIV ); + dlaswp(value, data.N, data.A, data.LDA, data.k1, data.k2, data.IPIV, data.strideIPIV); }; } }); -tape( 'the function throws an error if provided a fourth argument which is not a valid `LDA` value (row-major)', function test( t ) { +tape('the function throws an error if provided a fourth argument which is not a valid `LDA` value (row-major)', function test(t) { var values; var data; var i; @@ -111,19 +110,19 @@ tape( 'the function throws an error if provided a fourth argument which is not a 1 ]; - for ( i = 0; i < values.length; i++ ) { - t.throws( badValue( values[ i ] ), RangeError, 'throws an error when provided ' + values[ i ] ); + for (i = 0; i < values.length; i++) { + t.throws(badValue(values[i]), RangeError, 'throws an error when provided ' + values[i]); } t.end(); - function badValue( value ) { + function badValue(value) { return function badValue() { - dlaswp( data.order, data.N, data.A, value, data.k1, data.k2, data.IPIV, data.strideIPIV ); + dlaswp(data.order, data.N, data.A, value, data.k1, data.k2, data.IPIV, data.strideIPIV); }; } }); -tape( 'the function performs a series of row interchanges (column-major)', function test( t ) { +tape('the function performs a series of row interchanges (column-major)', function test(t) { var expected; var IPIV; var data; @@ -132,19 +131,19 @@ tape( 'the function performs a series of row interchanges (column-major)', funct data = COL_MAJOR; - A = new Float64Array( data.A ); - IPIV = new Int32Array( data.IPIV ); + A = new Float64Array(data.A); + IPIV = new Int32Array(data.IPIV); - expected = new Float64Array( data.A_out ); + expected = new Float64Array(data.A_out); - out = dlaswp( data.order, data.N, A, data.LDA, data.k1, data.k2, IPIV, data.strideIPIV ); - t.strictEqual( out, A, 'returns expected value' ); - t.deepEqual( out, expected, 'returns expected value' ); + out = dlaswp(data.order, data.N, A, data.LDA, data.k1, data.k2, IPIV, data.strideIPIV); + t.strictEqual(out, A, 'returns expected value'); + t.deepEqual(out, expected, 'returns expected value'); t.end(); }); -tape( 'the function performs a series of row interchanges (column-major, k1 > 0)', function test( t ) { +tape('the function performs a series of row interchanges (column-major, k1 > 0)', function test(t) { var expected; var IPIV; var data; @@ -153,19 +152,19 @@ tape( 'the function performs a series of row interchanges (column-major, k1 > 0) data = COL_MAJOR_K1; - A = new Float64Array( data.A ); - IPIV = new Int32Array( data.IPIV ); + A = new Float64Array(data.A); + IPIV = new Int32Array(data.IPIV); - expected = new Float64Array( data.A_out ); + expected = new Float64Array(data.A_out); - out = dlaswp( data.order, data.N, A, data.LDA, data.k1, data.k2, IPIV, data.strideIPIV ); - t.strictEqual( out, A, 'returns expected value' ); - t.deepEqual( out, expected, 'returns expected value' ); + out = dlaswp(data.order, data.N, A, data.LDA, data.k1, data.k2, IPIV, data.strideIPIV); + t.strictEqual(out, A, 'returns expected value'); + t.deepEqual(out, expected, 'returns expected value'); t.end(); }); -tape( 'the function supports applying pivots in reverse order (column-major)', function test( t ) { +tape('the function supports applying pivots in reverse order (column-major)', function test(t) { var expected; var IPIV; var data; @@ -174,19 +173,19 @@ tape( 'the function supports applying pivots in reverse order (column-major)', f data = COL_MAJOR_REV_PIVOTS; - A = new Float64Array( data.A ); - IPIV = new Int32Array( data.IPIV ); + A = new Float64Array(data.A); + IPIV = new Int32Array(data.IPIV); - expected = new Float64Array( data.A_out ); + expected = new Float64Array(data.A_out); - out = dlaswp( data.order, data.N, A, data.LDA, data.k1, data.k2, IPIV, data.strideIPIV ); - t.strictEqual( out, A, 'returns expected value' ); - t.deepEqual( out, expected, 'returns expected value' ); + out = dlaswp(data.order, data.N, A, data.LDA, data.k1, data.k2, IPIV, data.strideIPIV); + t.strictEqual(out, A, 'returns expected value'); + t.deepEqual(out, expected, 'returns expected value'); t.end(); }); -tape( 'the function supports specifying an `LDA` parameter for operating on sub-matrices (column-major)', function test( t ) { +tape('the function supports specifying an `LDA` parameter for operating on sub-matrices (column-major)', function test(t) { var expected; var IPIV; var data; @@ -195,19 +194,19 @@ tape( 'the function supports specifying an `LDA` parameter for operating on sub- data = COL_MAJOR_LDA; - A = new Float64Array( data.A ); - IPIV = new Int32Array( data.IPIV ); + A = new Float64Array(data.A); + IPIV = new Int32Array(data.IPIV); - expected = new Float64Array( data.A_out ); + expected = new Float64Array(data.A_out); - out = dlaswp( data.order, data.N, A, data.LDA, data.k1, data.k2, IPIV, data.strideIPIV ); - t.strictEqual( out, A, 'returns expected value' ); - t.deepEqual( out, expected, 'returns expected value' ); + out = dlaswp(data.order, data.N, A, data.LDA, data.k1, data.k2, IPIV, data.strideIPIV); + t.strictEqual(out, A, 'returns expected value'); + t.deepEqual(out, expected, 'returns expected value'); t.end(); }); -tape( 'the function supports specifying a positive increment between successive values of `IPIV` (column-major)', function test( t ) { +tape('the function supports specifying a positive increment between successive values of `IPIV` (column-major)', function test(t) { var expected; var IPIV; var data; @@ -216,19 +215,19 @@ tape( 'the function supports specifying a positive increment between successive data = COL_MAJOR_IPIV_STRIDE_POS; - A = new Float64Array( data.A ); - IPIV = new Int32Array( data.IPIV ); + A = new Float64Array(data.A); + IPIV = new Int32Array(data.IPIV); - expected = new Float64Array( data.A_out ); + expected = new Float64Array(data.A_out); - out = dlaswp( data.order, data.N, A, data.LDA, data.k1, data.k2, IPIV, data.strideIPIV ); - t.strictEqual( out, A, 'returns expected value' ); - t.deepEqual( out, expected, 'returns expected value' ); + out = dlaswp(data.order, data.N, A, data.LDA, data.k1, data.k2, IPIV, data.strideIPIV); + t.strictEqual(out, A, 'returns expected value'); + t.deepEqual(out, expected, 'returns expected value'); t.end(); }); -tape( 'the function supports specifying a negative increment between successive values of `IPIV` (column-major)', function test( t ) { +tape('the function supports specifying a negative increment between successive values of `IPIV` (column-major)', function test(t) { var expected; var IPIV; var data; @@ -237,19 +236,19 @@ tape( 'the function supports specifying a negative increment between successive data = COL_MAJOR_IPIV_STRIDE_NEG; - A = new Float64Array( data.A ); - IPIV = new Int32Array( data.IPIV ); + A = new Float64Array(data.A); + IPIV = new Int32Array(data.IPIV); - expected = new Float64Array( data.A_out ); + expected = new Float64Array(data.A_out); - out = dlaswp( data.order, data.N, A, data.LDA, data.k1, data.k2, IPIV, data.strideIPIV ); - t.strictEqual( out, A, 'returns expected value' ); - t.deepEqual( out, expected, 'returns expected value' ); + out = dlaswp(data.order, data.N, A, data.LDA, data.k1, data.k2, IPIV, data.strideIPIV); + t.strictEqual(out, A, 'returns expected value'); + t.deepEqual(out, expected, 'returns expected value'); t.end(); }); -tape( 'if provided an increment between successive values of `IPIV` equal to `0`, the function returns the input matrix unchanged (column-major)', function test( t ) { +tape('if provided an increment between successive values of `IPIV` equal to `0`, the function returns the input matrix unchanged (column-major)', function test(t) { var expected; var IPIV; var data; @@ -258,19 +257,19 @@ tape( 'if provided an increment between successive values of `IPIV` equal to `0` data = COL_MAJOR; - A = new Float64Array( data.A ); - IPIV = new Int32Array( data.IPIV ); + A = new Float64Array(data.A); + IPIV = new Int32Array(data.IPIV); - expected = new Float64Array( data.A ); + expected = new Float64Array(data.A); - out = dlaswp( data.order, data.N, A, data.LDA, data.k1, data.k2, IPIV, 0 ); - t.strictEqual( out, A, 'returns expected value' ); - t.deepEqual( out, expected, 'returns expected value' ); + out = dlaswp(data.order, data.N, A, data.LDA, data.k1, data.k2, IPIV, 0); + t.strictEqual(out, A, 'returns expected value'); + t.deepEqual(out, expected, 'returns expected value'); t.end(); }); -tape( 'the function efficiently handles large datasets (column-major)', function test( t ) { +tape('the function efficiently handles large datasets (column-major)', function test(t) { var expected; var IPIV; var buf; @@ -283,36 +282,36 @@ tape( 'the function efficiently handles large datasets (column-major)', function var o; ord = 'column-major'; - sh = [ 5, 100 ]; - st = shape2strides( sh, ord ); + sh = [5, 100]; + st = shape2strides(sh, ord); o = 0; // Define a linear buffer: - buf = oneTo( numel( sh ), 'generic' ); + buf = oneTo(numel(sh), 'generic'); // Convert to a nested array: - mat = ndarray2array( buf, sh, st, o, ord ); + mat = ndarray2array(buf, sh, st, o, ord); // Define an input matrix in linear storage: - A = new Float64Array( buf ); + A = new Float64Array(buf); // Create an array of pivot indices: - IPIV = new Int32Array( [ 9999, 9999, 9999, 1, 0 ] ); + IPIV = new Int32Array([9999, 9999, 9999, 1, 0]); // Define the expected output array: - expected = reverse( mat.slice() ); - expected = new Float64Array( flatten( expected, sh, true ) ); + expected = reverse(mat.slice()); + expected = new Float64Array(flatten(expected, sh, true)); // Interchange rows: - out = dlaswp( ord, sh[1], A, sh[0], 3, 4, IPIV, 1 ); + out = dlaswp(ord, sh[1], A, sh[0], 3, 4, IPIV, 1); - t.strictEqual( out, A, 'returns expected value' ); - t.deepEqual( out, expected, 'returns expected value' ); + t.strictEqual(out, A, 'returns expected value'); + t.deepEqual(out, expected, 'returns expected value'); t.end(); }); -tape( 'the function performs a series of row interchanges (row-major)', function test( t ) { +tape('the function performs a series of row interchanges (row-major)', function test(t) { var expected; var IPIV; var data; @@ -321,19 +320,19 @@ tape( 'the function performs a series of row interchanges (row-major)', function data = ROW_MAJOR; - A = new Float64Array( data.A ); - IPIV = new Int32Array( data.IPIV ); + A = new Float64Array(data.A); + IPIV = new Int32Array(data.IPIV); - expected = new Float64Array( data.A_out ); + expected = new Float64Array(data.A_out); - out = dlaswp( data.order, data.N, A, data.LDA, data.k1, data.k2, IPIV, data.strideIPIV ); - t.strictEqual( out, A, 'returns expected value' ); - t.deepEqual( out, expected, 'returns expected value' ); + out = dlaswp(data.order, data.N, A, data.LDA, data.k1, data.k2, IPIV, data.strideIPIV); + t.strictEqual(out, A, 'returns expected value'); + t.deepEqual(out, expected, 'returns expected value'); t.end(); }); -tape( 'the function performs a series of row interchanges (row-major, k1 > 0)', function test( t ) { +tape('the function performs a series of row interchanges (row-major, k1 > 0)', function test(t) { var expected; var IPIV; var data; @@ -342,19 +341,19 @@ tape( 'the function performs a series of row interchanges (row-major, k1 > 0)', data = ROW_MAJOR_K1; - A = new Float64Array( data.A ); - IPIV = new Int32Array( data.IPIV ); + A = new Float64Array(data.A); + IPIV = new Int32Array(data.IPIV); - expected = new Float64Array( data.A_out ); + expected = new Float64Array(data.A_out); - out = dlaswp( data.order, data.N, A, data.LDA, data.k1, data.k2, IPIV, data.strideIPIV ); - t.strictEqual( out, A, 'returns expected value' ); - t.deepEqual( out, expected, 'returns expected value' ); + out = dlaswp(data.order, data.N, A, data.LDA, data.k1, data.k2, IPIV, data.strideIPIV); + t.strictEqual(out, A, 'returns expected value'); + t.deepEqual(out, expected, 'returns expected value'); t.end(); }); -tape( 'the function supports applying pivots in reverse order (row-major)', function test( t ) { +tape('the function supports applying pivots in reverse order (row-major)', function test(t) { var expected; var IPIV; var data; @@ -363,19 +362,19 @@ tape( 'the function supports applying pivots in reverse order (row-major)', func data = ROW_MAJOR_REV_PIVOTS; - A = new Float64Array( data.A ); - IPIV = new Int32Array( data.IPIV ); + A = new Float64Array(data.A); + IPIV = new Int32Array(data.IPIV); - expected = new Float64Array( data.A_out ); + expected = new Float64Array(data.A_out); - out = dlaswp( data.order, data.N, A, data.LDA, data.k1, data.k2, IPIV, data.strideIPIV ); - t.strictEqual( out, A, 'returns expected value' ); - t.deepEqual( out, expected, 'returns expected value' ); + out = dlaswp(data.order, data.N, A, data.LDA, data.k1, data.k2, IPIV, data.strideIPIV); + t.strictEqual(out, A, 'returns expected value'); + t.deepEqual(out, expected, 'returns expected value'); t.end(); }); -tape( 'the function supports specifying an `LDA` parameter for operating on sub-matrices (row-major)', function test( t ) { +tape('the function supports specifying an `LDA` parameter for operating on sub-matrices (row-major)', function test(t) { var expected; var IPIV; var data; @@ -384,19 +383,19 @@ tape( 'the function supports specifying an `LDA` parameter for operating on sub- data = ROW_MAJOR_LDA; - A = new Float64Array( data.A ); - IPIV = new Int32Array( data.IPIV ); + A = new Float64Array(data.A); + IPIV = new Int32Array(data.IPIV); - expected = new Float64Array( data.A_out ); + expected = new Float64Array(data.A_out); - out = dlaswp( data.order, data.N, A, data.LDA, data.k1, data.k2, IPIV, data.strideIPIV ); - t.strictEqual( out, A, 'returns expected value' ); - t.deepEqual( out, expected, 'returns expected value' ); + out = dlaswp(data.order, data.N, A, data.LDA, data.k1, data.k2, IPIV, data.strideIPIV); + t.strictEqual(out, A, 'returns expected value'); + t.deepEqual(out, expected, 'returns expected value'); t.end(); }); -tape( 'the function supports specifying a positive increment between successive values of `IPIV` (row-major)', function test( t ) { +tape('the function supports specifying a positive increment between successive values of `IPIV` (row-major)', function test(t) { var expected; var IPIV; var data; @@ -405,19 +404,19 @@ tape( 'the function supports specifying a positive increment between successive data = ROW_MAJOR_IPIV_STRIDE_POS; - A = new Float64Array( data.A ); - IPIV = new Int32Array( data.IPIV ); + A = new Float64Array(data.A); + IPIV = new Int32Array(data.IPIV); - expected = new Float64Array( data.A_out ); + expected = new Float64Array(data.A_out); - out = dlaswp( data.order, data.N, A, data.LDA, data.k1, data.k2, IPIV, data.strideIPIV ); - t.strictEqual( out, A, 'returns expected value' ); - t.deepEqual( out, expected, 'returns expected value' ); + out = dlaswp(data.order, data.N, A, data.LDA, data.k1, data.k2, IPIV, data.strideIPIV); + t.strictEqual(out, A, 'returns expected value'); + t.deepEqual(out, expected, 'returns expected value'); t.end(); }); -tape( 'the function supports specifying a negative increment between successive values of `IPIV` (row-major)', function test( t ) { +tape('the function supports specifying a negative increment between successive values of `IPIV` (row-major)', function test(t) { var expected; var IPIV; var data; @@ -426,19 +425,19 @@ tape( 'the function supports specifying a negative increment between successive data = ROW_MAJOR_IPIV_STRIDE_NEG; - A = new Float64Array( data.A ); - IPIV = new Int32Array( data.IPIV ); + A = new Float64Array(data.A); + IPIV = new Int32Array(data.IPIV); - expected = new Float64Array( data.A_out ); + expected = new Float64Array(data.A_out); - out = dlaswp( data.order, data.N, A, data.LDA, data.k1, data.k2, IPIV, data.strideIPIV ); - t.strictEqual( out, A, 'returns expected value' ); - t.deepEqual( out, expected, 'returns expected value' ); + out = dlaswp(data.order, data.N, A, data.LDA, data.k1, data.k2, IPIV, data.strideIPIV); + t.strictEqual(out, A, 'returns expected value'); + t.deepEqual(out, expected, 'returns expected value'); t.end(); }); -tape( 'if provided an increment between successive values of `IPIV` equal to `0`, the function returns the input matrix unchanged (row-major)', function test( t ) { +tape('if provided an increment between successive values of `IPIV` equal to `0`, the function returns the input matrix unchanged (row-major)', function test(t) { var expected; var IPIV; var data; @@ -447,19 +446,19 @@ tape( 'if provided an increment between successive values of `IPIV` equal to `0` data = ROW_MAJOR; - A = new Float64Array( data.A ); - IPIV = new Int32Array( data.IPIV ); + A = new Float64Array(data.A); + IPIV = new Int32Array(data.IPIV); - expected = new Float64Array( data.A ); + expected = new Float64Array(data.A); - out = dlaswp( data.order, data.N, A, data.LDA, data.k1, data.k2, IPIV, 0 ); - t.strictEqual( out, A, 'returns expected value' ); - t.deepEqual( out, expected, 'returns expected value' ); + out = dlaswp(data.order, data.N, A, data.LDA, data.k1, data.k2, IPIV, 0); + t.strictEqual(out, A, 'returns expected value'); + t.deepEqual(out, expected, 'returns expected value'); t.end(); }); -tape( 'the function efficiently handles large datasets (row-major)', function test( t ) { +tape('the function efficiently handles large datasets (row-major)', function test(t) { var expected; var IPIV; var buf; @@ -472,31 +471,31 @@ tape( 'the function efficiently handles large datasets (row-major)', function te var o; ord = 'row-major'; - sh = [ 5, 100 ]; - st = shape2strides( sh, ord ); + sh = [5, 100]; + st = shape2strides(sh, ord); o = 0; // Define a linear buffer: - buf = oneTo( numel( sh ), 'generic' ); + buf = oneTo(numel(sh), 'generic'); // Convert to a nested array: - mat = ndarray2array( buf, sh, st, o, ord ); + mat = ndarray2array(buf, sh, st, o, ord); // Define an input matrix in linear storage: - A = new Float64Array( buf ); + A = new Float64Array(buf); // Create an array of pivot indices: - IPIV = new Int32Array( [ 9999, 9999, 9999, 1, 0 ] ); + IPIV = new Int32Array([9999, 9999, 9999, 1, 0]); // Define the expected output array: - expected = reverse( mat.slice() ); - expected = new Float64Array( flatten( expected, sh, false ) ); + expected = reverse(mat.slice()); + expected = new Float64Array(flatten(expected, sh, false)); // Interchange rows: - out = dlaswp( ord, sh[1], A, sh[1], 3, 4, IPIV, 1 ); + out = dlaswp(ord, sh[1], A, sh[1], 3, 4, IPIV, 1); - t.strictEqual( out, A, 'returns expected value' ); - t.deepEqual( out, expected, 'returns expected value' ); + t.strictEqual(out, A, 'returns expected value'); + t.deepEqual(out, expected, 'returns expected value'); t.end(); }); diff --git a/lib/node_modules/@stdlib/utils/nonenumerable-property-names/lib/main.js b/lib/node_modules/@stdlib/utils/nonenumerable-property-names/lib/main.js index 5c4e90af21a2..6765d283bcc5 100644 --- a/lib/node_modules/@stdlib/utils/nonenumerable-property-names/lib/main.js +++ b/lib/node_modules/@stdlib/utils/nonenumerable-property-names/lib/main.js @@ -20,8 +20,9 @@ // MODULES // -var getOwnPropertyNames = require( '@stdlib/utils/property-names' ); -var isNonEnumerableProperty = require( '@stdlib/assert/is-nonenumerable-property' ); +var getOwnPropertyNames = require('@stdlib/utils/property-names'); +var isNonEnumerableProperty = require('@stdlib/assert/is-nonenumerable-property'); +var Object = require('@stdlib/object/ctor'); // MAIN // @@ -47,19 +48,19 @@ var isNonEnumerableProperty = require( '@stdlib/assert/is-nonenumerable-property * var keys = nonEnumerablePropertyNames( obj ); * // returns [ 'beep' ] */ -function nonEnumerablePropertyNames( value ) { // eslint-disable-line id-length +function nonEnumerablePropertyNames(value) { // eslint-disable-line id-length var names; var i; var n; - if ( value === null || value === void 0 ) { + if (value === null || value === void 0) { return []; } - names = getOwnPropertyNames( Object( value ) ); + names = getOwnPropertyNames(Object(value)); n = 0; - for ( i = 0; i < names.length; i++ ) { - if ( isNonEnumerableProperty( value, names[ i ] ) ) { - names[ n ] = names[ i ]; + for (i = 0; i < names.length; i++) { + if (isNonEnumerableProperty(value, names[i])) { + names[n] = names[i]; n += 1; } } diff --git a/stdlib b/stdlib new file mode 160000 index 000000000000..55030f9809f5 --- /dev/null +++ b/stdlib @@ -0,0 +1 @@ +Subproject commit 55030f9809f5dba8e7ab8015c1f7faf9ab337aac From 9a6670daac888b25a54efea79eab7a3954bb5e93 Mon Sep 17 00:00:00 2001 From: Athan Date: Sun, 4 Jan 2026 23:10:07 -0800 Subject: [PATCH 2/2] chore: remove file Signed-off-by: Athan --- ksdn | 726 ----------------------------------------------------------- 1 file changed, 726 deletions(-) delete mode 100644 ksdn diff --git a/ksdn b/ksdn deleted file mode 100644 index e1f75f6889e2..000000000000 --- a/ksdn +++ /dev/null @@ -1,726 +0,0 @@ -diff --git a/lib/node_modules/@stdlib/assert/deep-has-own-property/examples/index.js b/lib/node_modules/@stdlib/assert/deep-has-own-property/examples/index.js -index 4a01f419f1f..040fdc56be1 100644 ---- a/lib/node_modules/@stdlib/assert/deep-has-own-property/examples/index.js -+++ b/lib/node_modules/@stdlib/assert/deep-has-own-property/examples/index.js -@@ -20,53 +20,53 @@ -  - 'use strict'; -  --var deepHasOwnProp = require( './../lib' ); -+var deepHasOwnProp = require('./../lib'); -  - var obj = { 'a': { 'b': { 'c': 'd' } } }; --var bool = deepHasOwnProp( obj, 'a.b.c' ); --console.log( bool ); -+var bool = deepHasOwnProp(obj, 'a.b.c'); -+console.log(bool); - // => true -  - obj = { 'a': { 'b': { 'c': 'd' } } }; --bool = deepHasOwnProp( obj, [ 'a', 'b', 'c' ] ); --console.log( bool ); -+bool = deepHasOwnProp(obj, ['a', 'b', 'c']); -+console.log(bool); - // => true -  - obj = { 'a': { 'b': { 'c': 'd' } } }; --bool = deepHasOwnProp( obj, 'a/b/c', { -+bool = deepHasOwnProp(obj, 'a/b/c', { - 'sep': '/' - }); --console.log( bool ); -+console.log(bool); - // => true -  - obj = { 'a': { 'b': { 'c': 'd' } } }; --bool = deepHasOwnProp( obj, 'a.b.c.d' ); --console.log( bool ); -+bool = deepHasOwnProp(obj, 'a.b.c.d'); -+console.log(bool); - // => false -  --obj = { 'a': [ { 'b': { 'c': 'd' } } ] }; --bool = deepHasOwnProp( obj, [ 'a', '0', 'b', 'c', 'd' ] ); --console.log( bool ); -+obj = { 'a': [{ 'b': { 'c': 'd' } }] }; -+bool = deepHasOwnProp(obj, ['a', '0', 'b', 'c', 'd']); -+console.log(bool); - // => false -  - obj = { 'a': { 'b': { 'c': 'd' } } }; --bool = deepHasOwnProp( obj, 'a/b/c/d/e', { -+bool = deepHasOwnProp(obj, 'a/b/c/d/e', { - 'sep': '/' - }); --console.log( bool ); -+console.log(bool); - // => false -  - // Create a customized function: --var has = deepHasOwnProp.factory( 'a_b_c', { -+var has = deepHasOwnProp.factory('a_b_c', { - 'sep': '_' - }); -  - obj = { 'a': { 'b': { 'c': 'd' } } }; --bool = has( obj ); --console.log( bool ); -+bool = has(obj); -+console.log(bool); - // => true -  --obj = { 'a': [ { 'b': { 'c': 'd' } } ] }; --bool = has( obj ); --console.log( bool ); -+obj = { 'a': [{ 'b': { 'c': 'd' } }] }; -+bool = has(obj); -+console.log(bool); - // => false -diff --git a/lib/node_modules/@stdlib/lapack/base/dlaswp/test/test.dlaswp.js b/lib/node_modules/@stdlib/lapack/base/dlaswp/test/test.dlaswp.js -index f2ce06b4c76..cd9960d1cc4 100644 ---- a/lib/node_modules/@stdlib/lapack/base/dlaswp/test/test.dlaswp.js -+++ b/lib/node_modules/@stdlib/lapack/base/dlaswp/test/test.dlaswp.js -@@ -22,49 +22,48 @@ -  - // MODULES // -  --var tape = require( 'tape' ); --var Int32Array = require( '@stdlib/array/int32' ); --var Float64Array = require( '@stdlib/array/float64' ); --var oneTo = require( '@stdlib/array/one-to' ); --var flatten = require( '@stdlib/array/base/flatten' ); --var reverse = require( '@stdlib/array/base/reverse' ); --var ndarray2array = require( '@stdlib/ndarray/base/to-array' ); --var numel = require( '@stdlib/ndarray/base/numel' ); --var shape2strides = require( '@stdlib/ndarray/base/shape2strides' ); --var dlaswp = require( './../lib/dlaswp.js' ); -+var tape = require('tape'); -+var Int32Array = require('@stdlib/array/int32'); -+var Float64Array = require('@stdlib/array/float64'); -+var oneTo = require('@stdlib/array/one-to'); -+var flatten = require('@stdlib/array/base/flatten'); -+var reverse = require('@stdlib/array/base/reverse'); -+var ndarray2array = require('@stdlib/ndarray/base/to-array'); -+var numel = require('@stdlib/ndarray/base/numel'); -+var shape2strides = require('@stdlib/ndarray/base/shape2strides'); -+var dlaswp = require('./../lib/dlaswp.js'); -  -  - // FIXTURES // -  --var COL_MAJOR = require( './fixtures/column_major_no_offsets.json' ); --var COL_MAJOR_IPIV_STRIDE_POS = require( './fixtures/column_major_ipiv_stride_positive.json' ); --var COL_MAJOR_IPIV_STRIDE_NEG = require( './fixtures/column_major_ipiv_stride_negative.json' ); --var COL_MAJOR_LDA = require( './fixtures/column_major_lda.json' ); --var COL_MAJOR_REV_PIVOTS = require( './fixtures/column_major_reverse_pivots.json' ); --var COL_MAJOR_K1 = require( './fixtures/column_major_k1.json' ); -- --var ROW_MAJOR = require( './fixtures/row_major_no_offsets.json' ); --var ROW_MAJOR_IPIV_STRIDE_POS = require( './fixtures/row_major_ipiv_stride_positive.json' ); --var ROW_MAJOR_IPIV_STRIDE_NEG = require( './fixtures/row_major_ipiv_stride_negative.json' ); --var ROW_MAJOR_LDA = require( './fixtures/row_major_lda.json' ); --var ROW_MAJOR_REV_PIVOTS = require( './fixtures/row_major_reverse_pivots.json' ); --var ROW_MAJOR_K1 = require( './fixtures/row_major_k1.json' ); -+var COL_MAJOR = require('./fixtures/column_major_no_offsets.json'); -+var COL_MAJOR_IPIV_STRIDE_POS = require('./fixtures/column_major_ipiv_stride_positive.json'); -+var COL_MAJOR_IPIV_STRIDE_NEG = require('./fixtures/column_major_ipiv_stride_negative.json'); -+var COL_MAJOR_LDA = require('./fixtures/column_major_lda.json'); -+var COL_MAJOR_REV_PIVOTS = require('./fixtures/column_major_reverse_pivots.json'); -+var COL_MAJOR_K1 = require('./fixtures/column_major_k1.json'); -+var ROW_MAJOR = require('./fixtures/row_major_no_offsets.json'); -+var ROW_MAJOR_IPIV_STRIDE_POS = require('./fixtures/row_major_ipiv_stride_positive.json'); -+var ROW_MAJOR_IPIV_STRIDE_NEG = require('./fixtures/row_major_ipiv_stride_negative.json'); -+var ROW_MAJOR_LDA = require('./fixtures/row_major_lda.json'); -+var ROW_MAJOR_REV_PIVOTS = require('./fixtures/row_major_reverse_pivots.json'); -+var ROW_MAJOR_K1 = require('./fixtures/row_major_k1.json'); -  -  - // TESTS // -  --tape( 'main export is a function', function test( t ) { -- t.ok( true, __filename ); -- t.strictEqual( typeof dlaswp, 'function', 'main export is a function' ); -+tape('main export is a function', function test(t) { -+ t.ok(true, __filename); -+ t.strictEqual(typeof dlaswp, 'function', 'main export is a function'); - t.end(); - }); -  --tape( 'the function has an arity of 8', function test( t ) { -- t.strictEqual( dlaswp.length, 8, 'returns expected value' ); -+tape('the function has an arity of 8', function test(t) { -+ t.strictEqual(dlaswp.length, 8, 'returns expected value'); - t.end(); - }); -  --tape( 'the function throws an error if provided a first argument which is not a valid order', function test( t ) { -+tape('the function throws an error if provided a first argument which is not a valid order', function test(t) { - var values; - var data; - var i; -@@ -84,22 +83,22 @@ tape( 'the function throws an error if provided a first argument which is not a - void 0, - [], - {}, -- function noop() {} -+ function noop() { } - ]; -  -- for ( i = 0; i < values.length; i++ ) { -- t.throws( badValue( values[ i ] ), TypeError, 'throws an error when provided ' + values[ i ] ); -+ for (i = 0; i < values.length; i++) { -+ t.throws(badValue(values[i]), TypeError, 'throws an error when provided ' + values[i]); - } - t.end(); -  -- function badValue( value ) { -+ function badValue(value) { - return function badValue() { -- dlaswp( value, data.N, data.A, data.LDA, data.k1, data.k2, data.IPIV, data.strideIPIV ); -+ dlaswp(value, data.N, data.A, data.LDA, data.k1, data.k2, data.IPIV, data.strideIPIV); - }; - } - }); -  --tape( 'the function throws an error if provided a fourth argument which is not a valid `LDA` value (row-major)', function test( t ) { -+tape('the function throws an error if provided a fourth argument which is not a valid `LDA` value (row-major)', function test(t) { - var values; - var data; - var i; -@@ -111,19 +110,19 @@ tape( 'the function throws an error if provided a fourth argument which is not a - 1 - ]; -  -- for ( i = 0; i < values.length; i++ ) { -- t.throws( badValue( values[ i ] ), RangeError, 'throws an error when provided ' + values[ i ] ); -+ for (i = 0; i < values.length; i++) { -+ t.throws(badValue(values[i]), RangeError, 'throws an error when provided ' + values[i]); - } - t.end(); -  -- function badValue( value ) { -+ function badValue(value) { - return function badValue() { -- dlaswp( data.order, data.N, data.A, value, data.k1, data.k2, data.IPIV, data.strideIPIV ); -+ dlaswp(data.order, data.N, data.A, value, data.k1, data.k2, data.IPIV, data.strideIPIV); - }; - } - }); -  --tape( 'the function performs a series of row interchanges (column-major)', function test( t ) { -+tape('the function performs a series of row interchanges (column-major)', function test(t) { - var expected; - var IPIV; - var data; -@@ -132,19 +131,19 @@ tape( 'the function performs a series of row interchanges (column-major)', funct -  - data = COL_MAJOR; -  -- A = new Float64Array( data.A ); -- IPIV = new Int32Array( data.IPIV ); -+ A = new Float64Array(data.A); -+ IPIV = new Int32Array(data.IPIV); -  -- expected = new Float64Array( data.A_out ); -+ expected = new Float64Array(data.A_out); -  -- out = dlaswp( data.order, data.N, A, data.LDA, data.k1, data.k2, IPIV, data.strideIPIV ); -- t.strictEqual( out, A, 'returns expected value' ); -- t.deepEqual( out, expected, 'returns expected value' ); -+ out = dlaswp(data.order, data.N, A, data.LDA, data.k1, data.k2, IPIV, data.strideIPIV); -+ t.strictEqual(out, A, 'returns expected value'); -+ t.deepEqual(out, expected, 'returns expected value'); -  - t.end(); - }); -  --tape( 'the function performs a series of row interchanges (column-major, k1 > 0)', function test( t ) { -+tape('the function performs a series of row interchanges (column-major, k1 > 0)', function test(t) { - var expected; - var IPIV; - var data; -@@ -153,19 +152,19 @@ tape( 'the function performs a series of row interchanges (column-major, k1 > 0) -  - data = COL_MAJOR_K1; -  -- A = new Float64Array( data.A ); -- IPIV = new Int32Array( data.IPIV ); -+ A = new Float64Array(data.A); -+ IPIV = new Int32Array(data.IPIV); -  -- expected = new Float64Array( data.A_out ); -+ expected = new Float64Array(data.A_out); -  -- out = dlaswp( data.order, data.N, A, data.LDA, data.k1, data.k2, IPIV, data.strideIPIV ); -- t.strictEqual( out, A, 'returns expected value' ); -- t.deepEqual( out, expected, 'returns expected value' ); -+ out = dlaswp(data.order, data.N, A, data.LDA, data.k1, data.k2, IPIV, data.strideIPIV); -+ t.strictEqual(out, A, 'returns expected value'); -+ t.deepEqual(out, expected, 'returns expected value'); -  - t.end(); - }); -  --tape( 'the function supports applying pivots in reverse order (column-major)', function test( t ) { -+tape('the function supports applying pivots in reverse order (column-major)', function test(t) { - var expected; - var IPIV; - var data; -@@ -174,19 +173,19 @@ tape( 'the function supports applying pivots in reverse order (column-major)', f -  - data = COL_MAJOR_REV_PIVOTS; -  -- A = new Float64Array( data.A ); -- IPIV = new Int32Array( data.IPIV ); -+ A = new Float64Array(data.A); -+ IPIV = new Int32Array(data.IPIV); -  -- expected = new Float64Array( data.A_out ); -+ expected = new Float64Array(data.A_out); -  -- out = dlaswp( data.order, data.N, A, data.LDA, data.k1, data.k2, IPIV, data.strideIPIV ); -- t.strictEqual( out, A, 'returns expected value' ); -- t.deepEqual( out, expected, 'returns expected value' ); -+ out = dlaswp(data.order, data.N, A, data.LDA, data.k1, data.k2, IPIV, data.strideIPIV); -+ t.strictEqual(out, A, 'returns expected value'); -+ t.deepEqual(out, expected, 'returns expected value'); -  - t.end(); - }); -  --tape( 'the function supports specifying an `LDA` parameter for operating on sub-matrices (column-major)', function test( t ) { -+tape('the function supports specifying an `LDA` parameter for operating on sub-matrices (column-major)', function test(t) { - var expected; - var IPIV; - var data; -@@ -195,19 +194,19 @@ tape( 'the function supports specifying an `LDA` parameter for operating on sub- -  - data = COL_MAJOR_LDA; -  -- A = new Float64Array( data.A ); -- IPIV = new Int32Array( data.IPIV ); -+ A = new Float64Array(data.A); -+ IPIV = new Int32Array(data.IPIV); -  -- expected = new Float64Array( data.A_out ); -+ expected = new Float64Array(data.A_out); -  -- out = dlaswp( data.order, data.N, A, data.LDA, data.k1, data.k2, IPIV, data.strideIPIV ); -- t.strictEqual( out, A, 'returns expected value' ); -- t.deepEqual( out, expected, 'returns expected value' ); -+ out = dlaswp(data.order, data.N, A, data.LDA, data.k1, data.k2, IPIV, data.strideIPIV); -+ t.strictEqual(out, A, 'returns expected value'); -+ t.deepEqual(out, expected, 'returns expected value'); -  - t.end(); - }); -  --tape( 'the function supports specifying a positive increment between successive values of `IPIV` (column-major)', function test( t ) { -+tape('the function supports specifying a positive increment between successive values of `IPIV` (column-major)', function test(t) { - var expected; - var IPIV; - var data; -@@ -216,19 +215,19 @@ tape( 'the function supports specifying a positive increment between successive -  - data = COL_MAJOR_IPIV_STRIDE_POS; -  -- A = new Float64Array( data.A ); -- IPIV = new Int32Array( data.IPIV ); -+ A = new Float64Array(data.A); -+ IPIV = new Int32Array(data.IPIV); -  -- expected = new Float64Array( data.A_out ); -+ expected = new Float64Array(data.A_out); -  -- out = dlaswp( data.order, data.N, A, data.LDA, data.k1, data.k2, IPIV, data.strideIPIV ); -- t.strictEqual( out, A, 'returns expected value' ); -- t.deepEqual( out, expected, 'returns expected value' ); -+ out = dlaswp(data.order, data.N, A, data.LDA, data.k1, data.k2, IPIV, data.strideIPIV); -+ t.strictEqual(out, A, 'returns expected value'); -+ t.deepEqual(out, expected, 'returns expected value'); -  - t.end(); - }); -  --tape( 'the function supports specifying a negative increment between successive values of `IPIV` (column-major)', function test( t ) { -+tape('the function supports specifying a negative increment between successive values of `IPIV` (column-major)', function test(t) { - var expected; - var IPIV; - var data; -@@ -237,19 +236,19 @@ tape( 'the function supports specifying a negative increment between successive -  - data = COL_MAJOR_IPIV_STRIDE_NEG; -  -- A = new Float64Array( data.A ); -- IPIV = new Int32Array( data.IPIV ); -+ A = new Float64Array(data.A); -+ IPIV = new Int32Array(data.IPIV); -  -- expected = new Float64Array( data.A_out ); -+ expected = new Float64Array(data.A_out); -  -- out = dlaswp( data.order, data.N, A, data.LDA, data.k1, data.k2, IPIV, data.strideIPIV ); -- t.strictEqual( out, A, 'returns expected value' ); -- t.deepEqual( out, expected, 'returns expected value' ); -+ out = dlaswp(data.order, data.N, A, data.LDA, data.k1, data.k2, IPIV, data.strideIPIV); -+ t.strictEqual(out, A, 'returns expected value'); -+ t.deepEqual(out, expected, 'returns expected value'); -  - t.end(); - }); -  --tape( 'if provided an increment between successive values of `IPIV` equal to `0`, the function returns the input matrix unchanged (column-major)', function test( t ) { -+tape('if provided an increment between successive values of `IPIV` equal to `0`, the function returns the input matrix unchanged (column-major)', function test(t) { - var expected; - var IPIV; - var data; -@@ -258,19 +257,19 @@ tape( 'if provided an increment between successive values of `IPIV` equal to `0` -  - data = COL_MAJOR; -  -- A = new Float64Array( data.A ); -- IPIV = new Int32Array( data.IPIV ); -+ A = new Float64Array(data.A); -+ IPIV = new Int32Array(data.IPIV); -  -- expected = new Float64Array( data.A ); -+ expected = new Float64Array(data.A); -  -- out = dlaswp( data.order, data.N, A, data.LDA, data.k1, data.k2, IPIV, 0 ); -- t.strictEqual( out, A, 'returns expected value' ); -- t.deepEqual( out, expected, 'returns expected value' ); -+ out = dlaswp(data.order, data.N, A, data.LDA, data.k1, data.k2, IPIV, 0); -+ t.strictEqual(out, A, 'returns expected value'); -+ t.deepEqual(out, expected, 'returns expected value'); -  - t.end(); - }); -  --tape( 'the function efficiently handles large datasets (column-major)', function test( t ) { -+tape('the function efficiently handles large datasets (column-major)', function test(t) { - var expected; - var IPIV; - var buf; -@@ -283,36 +282,36 @@ tape( 'the function efficiently handles large datasets (column-major)', function - var o; -  - ord = 'column-major'; -- sh = [ 5, 100 ]; -- st = shape2strides( sh, ord ); -+ sh = [5, 100]; -+ st = shape2strides(sh, ord); - o = 0; -  - // Define a linear buffer: -- buf = oneTo( numel( sh ), 'generic' ); -+ buf = oneTo(numel(sh), 'generic'); -  - // Convert to a nested array: -- mat = ndarray2array( buf, sh, st, o, ord ); -+ mat = ndarray2array(buf, sh, st, o, ord); -  - // Define an input matrix in linear storage: -- A = new Float64Array( buf ); -+ A = new Float64Array(buf); -  - // Create an array of pivot indices: -- IPIV = new Int32Array( [ 9999, 9999, 9999, 1, 0 ] ); -+ IPIV = new Int32Array([9999, 9999, 9999, 1, 0]); -  - // Define the expected output array: -- expected = reverse( mat.slice() ); -- expected = new Float64Array( flatten( expected, sh, true ) ); -+ expected = reverse(mat.slice()); -+ expected = new Float64Array(flatten(expected, sh, true)); -  - // Interchange rows: -- out = dlaswp( ord, sh[1], A, sh[0], 3, 4, IPIV, 1 ); -+ out = dlaswp(ord, sh[1], A, sh[0], 3, 4, IPIV, 1); -  -- t.strictEqual( out, A, 'returns expected value' ); -- t.deepEqual( out, expected, 'returns expected value' ); -+ t.strictEqual(out, A, 'returns expected value'); -+ t.deepEqual(out, expected, 'returns expected value'); -  - t.end(); - }); -  --tape( 'the function performs a series of row interchanges (row-major)', function test( t ) { -+tape('the function performs a series of row interchanges (row-major)', function test(t) { - var expected; - var IPIV; - var data; -@@ -321,19 +320,19 @@ tape( 'the function performs a series of row interchanges (row-major)', function -  - data = ROW_MAJOR; -  -- A = new Float64Array( data.A ); -- IPIV = new Int32Array( data.IPIV ); -+ A = new Float64Array(data.A); -+ IPIV = new Int32Array(data.IPIV); -  -- expected = new Float64Array( data.A_out ); -+ expected = new Float64Array(data.A_out); -  -- out = dlaswp( data.order, data.N, A, data.LDA, data.k1, data.k2, IPIV, data.strideIPIV ); -- t.strictEqual( out, A, 'returns expected value' ); -- t.deepEqual( out, expected, 'returns expected value' ); -+ out = dlaswp(data.order, data.N, A, data.LDA, data.k1, data.k2, IPIV, data.strideIPIV); -+ t.strictEqual(out, A, 'returns expected value'); -+ t.deepEqual(out, expected, 'returns expected value'); -  - t.end(); - }); -  --tape( 'the function performs a series of row interchanges (row-major, k1 > 0)', function test( t ) { -+tape('the function performs a series of row interchanges (row-major, k1 > 0)', function test(t) { - var expected; - var IPIV; - var data; -@@ -342,19 +341,19 @@ tape( 'the function performs a series of row interchanges (row-major, k1 > 0)', -  - data = ROW_MAJOR_K1; -  -- A = new Float64Array( data.A ); -- IPIV = new Int32Array( data.IPIV ); -+ A = new Float64Array(data.A); -+ IPIV = new Int32Array(data.IPIV); -  -- expected = new Float64Array( data.A_out ); -+ expected = new Float64Array(data.A_out); -  -- out = dlaswp( data.order, data.N, A, data.LDA, data.k1, data.k2, IPIV, data.strideIPIV ); -- t.strictEqual( out, A, 'returns expected value' ); -- t.deepEqual( out, expected, 'returns expected value' ); -+ out = dlaswp(data.order, data.N, A, data.LDA, data.k1, data.k2, IPIV, data.strideIPIV); -+ t.strictEqual(out, A, 'returns expected value'); -+ t.deepEqual(out, expected, 'returns expected value'); -  - t.end(); - }); -  --tape( 'the function supports applying pivots in reverse order (row-major)', function test( t ) { -+tape('the function supports applying pivots in reverse order (row-major)', function test(t) { - var expected; - var IPIV; - var data; -@@ -363,19 +362,19 @@ tape( 'the function supports applying pivots in reverse order (row-major)', func -  - data = ROW_MAJOR_REV_PIVOTS; -  -- A = new Float64Array( data.A ); -- IPIV = new Int32Array( data.IPIV ); -+ A = new Float64Array(data.A); -+ IPIV = new Int32Array(data.IPIV); -  -- expected = new Float64Array( data.A_out ); -+ expected = new Float64Array(data.A_out); -  -- out = dlaswp( data.order, data.N, A, data.LDA, data.k1, data.k2, IPIV, data.strideIPIV ); -- t.strictEqual( out, A, 'returns expected value' ); -- t.deepEqual( out, expected, 'returns expected value' ); -+ out = dlaswp(data.order, data.N, A, data.LDA, data.k1, data.k2, IPIV, data.strideIPIV); -+ t.strictEqual(out, A, 'returns expected value'); -+ t.deepEqual(out, expected, 'returns expected value'); -  - t.end(); - }); -  --tape( 'the function supports specifying an `LDA` parameter for operating on sub-matrices (row-major)', function test( t ) { -+tape('the function supports specifying an `LDA` parameter for operating on sub-matrices (row-major)', function test(t) { - var expected; - var IPIV; - var data; -@@ -384,19 +383,19 @@ tape( 'the function supports specifying an `LDA` parameter for operating on sub- -  - data = ROW_MAJOR_LDA; -  -- A = new Float64Array( data.A ); -- IPIV = new Int32Array( data.IPIV ); -+ A = new Float64Array(data.A); -+ IPIV = new Int32Array(data.IPIV); -  -- expected = new Float64Array( data.A_out ); -+ expected = new Float64Array(data.A_out); -  -- out = dlaswp( data.order, data.N, A, data.LDA, data.k1, data.k2, IPIV, data.strideIPIV ); -- t.strictEqual( out, A, 'returns expected value' ); -- t.deepEqual( out, expected, 'returns expected value' ); -+ out = dlaswp(data.order, data.N, A, data.LDA, data.k1, data.k2, IPIV, data.strideIPIV); -+ t.strictEqual(out, A, 'returns expected value'); -+ t.deepEqual(out, expected, 'returns expected value'); -  - t.end(); - }); -  --tape( 'the function supports specifying a positive increment between successive values of `IPIV` (row-major)', function test( t ) { -+tape('the function supports specifying a positive increment between successive values of `IPIV` (row-major)', function test(t) { - var expected; - var IPIV; - var data; -@@ -405,19 +404,19 @@ tape( 'the function supports specifying a positive increment between successive -  - data = ROW_MAJOR_IPIV_STRIDE_POS; -  -- A = new Float64Array( data.A ); -- IPIV = new Int32Array( data.IPIV ); -+ A = new Float64Array(data.A); -+ IPIV = new Int32Array(data.IPIV); -  -- expected = new Float64Array( data.A_out ); -+ expected = new Float64Array(data.A_out); -  -- out = dlaswp( data.order, data.N, A, data.LDA, data.k1, data.k2, IPIV, data.strideIPIV ); -- t.strictEqual( out, A, 'returns expected value' ); -- t.deepEqual( out, expected, 'returns expected value' ); -+ out = dlaswp(data.order, data.N, A, data.LDA, data.k1, data.k2, IPIV, data.strideIPIV); -+ t.strictEqual(out, A, 'returns expected value'); -+ t.deepEqual(out, expected, 'returns expected value'); -  - t.end(); - }); -  --tape( 'the function supports specifying a negative increment between successive values of `IPIV` (row-major)', function test( t ) { -+tape('the function supports specifying a negative increment between successive values of `IPIV` (row-major)', function test(t) { - var expected; - var IPIV; - var data; -@@ -426,19 +425,19 @@ tape( 'the function supports specifying a negative increment between successive -  - data = ROW_MAJOR_IPIV_STRIDE_NEG; -  -- A = new Float64Array( data.A ); -- IPIV = new Int32Array( data.IPIV ); -+ A = new Float64Array(data.A); -+ IPIV = new Int32Array(data.IPIV); -  -- expected = new Float64Array( data.A_out ); -+ expected = new Float64Array(data.A_out); -  -- out = dlaswp( data.order, data.N, A, data.LDA, data.k1, data.k2, IPIV, data.strideIPIV ); -- t.strictEqual( out, A, 'returns expected value' ); -- t.deepEqual( out, expected, 'returns expected value' ); -+ out = dlaswp(data.order, data.N, A, data.LDA, data.k1, data.k2, IPIV, data.strideIPIV); -+ t.strictEqual(out, A, 'returns expected value'); -+ t.deepEqual(out, expected, 'returns expected value'); -  - t.end(); - }); -  --tape( 'if provided an increment between successive values of `IPIV` equal to `0`, the function returns the input matrix unchanged (row-major)', function test( t ) { -+tape('if provided an increment between successive values of `IPIV` equal to `0`, the function returns the input matrix unchanged (row-major)', function test(t) { - var expected; - var IPIV; - var data; -@@ -447,19 +446,19 @@ tape( 'if provided an increment between successive values of `IPIV` equal to `0` -  - data = ROW_MAJOR; -  -- A = new Float64Array( data.A ); -- IPIV = new Int32Array( data.IPIV ); -+ A = new Float64Array(data.A); -+ IPIV = new Int32Array(data.IPIV); -  -- expected = new Float64Array( data.A ); -+ expected = new Float64Array(data.A); -  -- out = dlaswp( data.order, data.N, A, data.LDA, data.k1, data.k2, IPIV, 0 ); -- t.strictEqual( out, A, 'returns expected value' ); -- t.deepEqual( out, expected, 'returns expected value' ); -+ out = dlaswp(data.order, data.N, A, data.LDA, data.k1, data.k2, IPIV, 0); -+ t.strictEqual(out, A, 'returns expected value'); -+ t.deepEqual(out, expected, 'returns expected value'); -  - t.end(); - }); -  --tape( 'the function efficiently handles large datasets (row-major)', function test( t ) { -+tape('the function efficiently handles large datasets (row-major)', function test(t) { - var expected; - var IPIV; - var buf; -@@ -472,31 +471,31 @@ tape( 'the function efficiently handles large datasets (row-major)', function te - var o; -  - ord = 'row-major'; -- sh = [ 5, 100 ]; -- st = shape2strides( sh, ord ); -+ sh = [5, 100]; -+ st = shape2strides(sh, ord); - o = 0; -  - // Define a linear buffer: -- buf = oneTo( numel( sh ), 'generic' ); -+ buf = oneTo(numel(sh), 'generic'); -  - // Convert to a nested array: -- mat = ndarray2array( buf, sh, st, o, ord ); -+ mat = ndarray2array(buf, sh, st, o, ord); -  - // Define an input matrix in linear storage: -- A = new Float64Array( buf ); -+ A = new Float64Array(buf); -  - // Create an array of pivot indices: -- IPIV = new Int32Array( [ 9999, 9999, 9999, 1, 0 ] ); -+ IPIV = new Int32Array([9999, 9999, 9999, 1, 0]); -  - // Define the expected output array: -- expected = reverse( mat.slice() ); -- expected = new Float64Array( flatten( expected, sh, false ) ); -+ expected = reverse(mat.slice()); -+ expected = new Float64Array(flatten(expected, sh, false)); -  - // Interchange rows: -- out = dlaswp( ord, sh[1], A, sh[1], 3, 4, IPIV, 1 ); -+ out = dlaswp(ord, sh[1], A, sh[1], 3, 4, IPIV, 1); -  -- t.strictEqual( out, A, 'returns expected value' ); -- t.deepEqual( out, expected, 'returns expected value' ); -+ t.strictEqual(out, A, 'returns expected value'); -+ t.deepEqual(out, expected, 'returns expected value'); -  - t.end(); - }); -diff --git a/lib/node_modules/@stdlib/utils/nonenumerable-property-names/lib/main.js b/lib/node_modules/@stdlib/utils/nonenumerable-property-names/lib/main.js -index 5c4e90af21a..6765d283bcc 100644 ---- a/lib/node_modules/@stdlib/utils/nonenumerable-property-names/lib/main.js -+++ b/lib/node_modules/@stdlib/utils/nonenumerable-property-names/lib/main.js -@@ -20,8 +20,9 @@ -  - // MODULES // -  --var getOwnPropertyNames = require( '@stdlib/utils/property-names' ); --var isNonEnumerableProperty = require( '@stdlib/assert/is-nonenumerable-property' ); -+var getOwnPropertyNames = require('@stdlib/utils/property-names'); -+var isNonEnumerableProperty = require('@stdlib/assert/is-nonenumerable-property'); -+var Object = require('@stdlib/object/ctor'); -  -  - // MAIN // -@@ -47,19 +48,19 @@ var isNonEnumerableProperty = require( '@stdlib/assert/is-nonenumerable-property - * var keys = nonEnumerablePropertyNames( obj ); - * // returns [ 'beep' ] - */ --function nonEnumerablePropertyNames( value ) { // eslint-disable-line id-length -+function nonEnumerablePropertyNames(value) { // eslint-disable-line id-length - var names; - var i; - var n; -  -- if ( value === null || value === void 0 ) { -+ if (value === null || value === void 0) { - return []; - } -- names = getOwnPropertyNames( Object( value ) ); -+ names = getOwnPropertyNames(Object(value)); - n = 0; -- for ( i = 0; i < names.length; i++ ) { -- if ( isNonEnumerableProperty( value, names[ i ] ) ) { -- names[ n ] = names[ i ]; -+ for (i = 0; i < names.length; i++) { -+ if (isNonEnumerableProperty(value, names[i])) { -+ names[n] = names[i]; - n += 1; - } - }