@pezkuwi/util 14.0.13 → 14.0.14

package/build-tsc-cjs/u8a/toBigInt.js

@@ -1,73 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.u8aToBigInt = u8aToBigInt;
-const x_bigint_1 = require("@pezkuwi/x-bigint");
-const consts_js_1 = require("../bi/consts.js");
-const U8_MAX = (0, x_bigint_1.BigInt)(256);
-const U16_MAX = (0, x_bigint_1.BigInt)(256 * 256);
-const U64_MAX = (0, x_bigint_1.BigInt)('0x10000000000000000');
-/**
- * @name u8aToBigInt
- * @summary Creates a BigInt from a Uint8Array object.
- */
-function u8aToBigInt(value, { isLe = true, isNegative = false } = {}) {
-    // slice + reverse is expensive, however SCALE is LE by default so this is the path
-    // we are most interested in (the BE is added for the sake of being comprehensive)
-    if (!isLe) {
-        value = value.slice().reverse();
-    }
-    const count = value.length;
-    if (isNegative && count && (value[count - 1] & 0x80)) {
-        switch (count) {
-            case 0:
-                return (0, x_bigint_1.BigInt)(0);
-            case 1:
-                return (0, x_bigint_1.BigInt)(((value[0] ^ 0x0000_00ff) * -1) - 1);
-            case 2:
-                return (0, x_bigint_1.BigInt)((((value[0] + (value[1] << 8)) ^ 0x0000_ffff) * -1) - 1);
-            case 4:
-                return (0, x_bigint_1.BigInt)((((value[0] + (value[1] << 8) + (value[2] << 16) + (value[3] * 0x1_00_00_00)) ^ 0xffff_ffff) * -1) - 1);
-        }
-        const dvI = new DataView(value.buffer, value.byteOffset);
-        if (count === 8) {
-            return dvI.getBigInt64(0, true);
-        }
-        let result = (0, x_bigint_1.BigInt)(0);
-        const mod = count % 2;
-        for (let i = count - 2; i >= mod; i -= 2) {
-            result = (result * U16_MAX) + (0, x_bigint_1.BigInt)(dvI.getUint16(i, true) ^ 0xffff);
-        }
-        if (mod) {
-            result = (result * U8_MAX) + (0, x_bigint_1.BigInt)(value[0] ^ 0xff);
-        }
-        return (result * -consts_js_1._1n) - consts_js_1._1n;
-    }
-    switch (count) {
-        case 0:
-            return (0, x_bigint_1.BigInt)(0);
-        case 1:
-            return (0, x_bigint_1.BigInt)(value[0]);
-        case 2:
-            return (0, x_bigint_1.BigInt)(value[0] + (value[1] << 8));
-        case 4:
-            return (0, x_bigint_1.BigInt)(value[0] + (value[1] << 8) + (value[2] << 16) + (value[3] * 0x1_00_00_00));
-    }
-    const dvI = new DataView(value.buffer, value.byteOffset);
-    switch (count) {
-        case 8:
-            return dvI.getBigUint64(0, true);
-        case 16:
-            return (dvI.getBigUint64(8, true) * U64_MAX) + dvI.getBigUint64(0, true);
-        default: {
-            let result = (0, x_bigint_1.BigInt)(0);
-            const mod = count % 2;
-            for (let i = count - 2; i >= mod; i -= 2) {
-                result = (result * U16_MAX) + (0, x_bigint_1.BigInt)(dvI.getUint16(i, true));
-            }
-            if (mod) {
-                result = (result * U8_MAX) + (0, x_bigint_1.BigInt)(value[0]);
-            }
-            return result;
-        }
-    }
-}

package/build-tsc-cjs/u8a/toBn.js

@@ -1,81 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.u8aToBn = u8aToBn;
-const bn_js_1 = require("../bn/bn.js");
-/**
- * @name u8aToBn
- * @summary Creates a BN from a Uint8Array object.
- * @description
- * `UInt8Array` input values return the actual BN. `null` or `undefined` values returns an `0x0` value.
- * @param value The value to convert
- * @param options Options to pass while converting
- * @param options.isLe Convert using Little Endian (default)
- * @param options.isNegative Convert using two's complement
- * @example
- * <BR>
- *
- * ```javascript
- * import { u8aToBn } from '@pezkuwi/util';
- *
- * u8aToHex(new Uint8Array([0x68, 0x65, 0x6c, 0x6c, 0xf])); // 0x68656c0f
- * ```
- */
-function u8aToBn(value, { isLe = true, isNegative = false } = {}) {
-    // slice + reverse is expensive, however SCALE is LE by default so this is the path
-    // we are most interested in (the BE is added for the sake of being comprehensive)
-    if (!isLe) {
-        value = value.slice().reverse();
-    }
-    const count = value.length;
-    // shortcut for <= u48 values - in this case the manual conversion
-    // here seems to be more efficient than passing the full array
-    if (isNegative && count && (value[count - 1] & 0x80)) {
-        // Most common case i{8, 16, 32} default LE SCALE-encoded
-        // For <= 32, we also optimize the xor to a single op
-        switch (count) {
-            case 0:
-                return new bn_js_1.BN(0);
-            case 1:
-                return new bn_js_1.BN(((value[0] ^ 0x0000_00ff) * -1) - 1);
-            case 2:
-                return new bn_js_1.BN((((value[0] + (value[1] << 8)) ^ 0x0000_ffff) * -1) - 1);
-            case 3:
-                return new bn_js_1.BN((((value[0] + (value[1] << 8) + (value[2] << 16)) ^ 0x00ff_ffff) * -1) - 1);
-            case 4:
-                // for the 3rd byte, we don't << 24 - since JS converts all bitwise operators to
-                // 32-bit, in the case where the top-most bit is set this yields a negative value
-                return new bn_js_1.BN((((value[0] + (value[1] << 8) + (value[2] << 16) + (value[3] * 0x1_00_00_00)) ^ 0xffff_ffff) * -1) - 1);
-            case 5:
-                return new bn_js_1.BN(((((value[0] + (value[1] << 8) + (value[2] << 16) + (value[3] * 0x1_00_00_00)) ^ 0xffff_ffff) + ((value[4] ^ 0xff) * 0x1_00_00_00_00)) * -1) - 1);
-            case 6:
-                return new bn_js_1.BN(((((value[0] + (value[1] << 8) + (value[2] << 16) + (value[3] * 0x1_00_00_00)) ^ 0xffff_ffff) + (((value[4] + (value[5] << 8)) ^ 0x0000_ffff) * 0x1_00_00_00_00)) * -1) - 1);
-            default:
-                return new bn_js_1.BN(value, 'le').fromTwos(count * 8);
-        }
-    }
-    // Most common case - u{8, 16, 32} default LE SCALE-encoded
-    //
-    // There are some slight benefits in unrolling this specific loop,
-    // however it comes with diminishing returns since here the actual
-    // `new BN` does seem to take up the bulk of the time
-    switch (count) {
-        case 0:
-            return new bn_js_1.BN(0);
-        case 1:
-            return new bn_js_1.BN(value[0]);
-        case 2:
-            return new bn_js_1.BN(value[0] + (value[1] << 8));
-        case 3:
-            return new bn_js_1.BN(value[0] + (value[1] << 8) + (value[2] << 16));
-        case 4:
-            // for the 3rd byte, we don't << 24 - since JS converts all bitwise operators to
-            // 32-bit, in the case where the top-most bit is set this yields a negative value
-            return new bn_js_1.BN(value[0] + (value[1] << 8) + (value[2] << 16) + (value[3] * 0x1_00_00_00));
-        case 5:
-            return new bn_js_1.BN(value[0] + (value[1] << 8) + (value[2] << 16) + ((value[3] + (value[4] << 8)) * 0x1_00_00_00));
-        case 6:
-            return new bn_js_1.BN(value[0] + (value[1] << 8) + (value[2] << 16) + ((value[3] + (value[4] << 8) + (value[5] << 16)) * 0x1_00_00_00));
-        default:
-            return new bn_js_1.BN(value, 'le');
-    }
-}

package/build-tsc-cjs/u8a/toBuffer.js

@@ -1,24 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.u8aToBuffer = u8aToBuffer;
-const x_global_1 = require("@pezkuwi/x-global");
-const has_js_1 = require("../has.js");
-/**
- * @name u8aToBuffer
- * @summary Creates a Buffer object from a hex string.
- * @description
- * `null` inputs returns an empty `Buffer` result. `UInt8Array` input values return the actual bytes value converted to a `Buffer`. Anything that is not a `UInt8Array` throws an error.
- * @example
- * <BR>
- *
- * ```javascript
- * import { u8aToBuffer } from '@pezkuwi/util';
- *
- * console.log('Buffer', u8aToBuffer(new Uint8Array([1, 2, 3])));
- * ```
- */
-function u8aToBuffer(value) {
-    return has_js_1.hasBuffer
-        ? x_global_1.xglobal.Buffer.from(value || [])
-        : new Uint8Array(value || []);
-}

package/build-tsc-cjs/u8a/toFloat.js

@@ -1,20 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.u8aToFloat = u8aToFloat;
-/**
- * @name u8aToFloat
- * @description Converts a Uint8Array value into the float (either 32 or 64-bit)
- * representation.
- */
-function u8aToFloat(value, { bitLength = 32, isLe = true } = {}) {
-    if (bitLength !== 32 && bitLength !== 64) {
-        throw new Error('Invalid bitLength provided, expected 32 or 64');
-    }
-    else if (value.length < (bitLength / 8)) {
-        throw new Error(`Invalid input buffer provided, expected at least ${bitLength / 8} bytes, found ${value.length}`);
-    }
-    const dv = new DataView(value.buffer, value.byteOffset);
-    return bitLength === 32
-        ? dv.getFloat32(0, isLe)
-        : dv.getFloat64(0, isLe);
-}

package/build-tsc-cjs/u8a/toHex.js

@@ -1,56 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.u8aToHex = u8aToHex;
-const U8 = new Array(256);
-const U16 = new Array(256 * 256);
-for (let n = 0; n < 256; n++) {
-    U8[n] = n.toString(16).padStart(2, '0');
-}
-for (let i = 0; i < 256; i++) {
-    const s = i << 8;
-    for (let j = 0; j < 256; j++) {
-        U16[s | j] = U8[i] + U8[j];
-    }
-}
-/** @internal */
-function hex(value, result) {
-    const mod = (value.length % 2) | 0;
-    const length = (value.length - mod) | 0;
-    for (let i = 0; i < length; i += 2) {
-        result += U16[(value[i] << 8) | value[i + 1]];
-    }
-    if (mod) {
-        result += U8[value[length] | 0];
-    }
-    return result;
-}
-/**
- * @name u8aToHex
- * @summary Creates a hex string from a Uint8Array object.
- * @description
- * `UInt8Array` input values return the actual hex string. `null` or `undefined` values returns an `0x` string.
- * @example
- * <BR>
- *
- * ```javascript
- * import { u8aToHex } from '@pezkuwi/util';
- *
- * u8aToHex(new Uint8Array([0x68, 0x65, 0x6c, 0x6c, 0xf])); // 0x68656c0f
- * ```
- */
-function u8aToHex(value, bitLength = -1, isPrefixed = true) {
-    // this is not 100% correct sinmce we support isPrefixed = false....
-    const empty = isPrefixed
-        ? '0x'
-        : '';
-    if (!value?.length) {
-        return empty;
-    }
-    else if (bitLength > 0) {
-        const length = Math.ceil(bitLength / 8);
-        if (value.length > length) {
-            return `${hex(value.subarray(0, length / 2), empty)}…${hex(value.subarray(value.length - length / 2), '')}`;
-        }
-    }
-    return hex(value, empty);
-}

package/build-tsc-cjs/u8a/toHexBuffer.js

@@ -1,25 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.u8aToHex = u8aToHex;
-/**
- * @name u8aToHex
- * @summary Creates a hex string from a Uint8Array object.
- * @description
- * `UInt8Array` input values return the actual hex string. `null` or `undefined` values returns an `0x` string.
- * @example
- * <BR>
- *
- * ```javascript
- * import { u8aToHex } from '@pezkuwi/util';
- *
- * u8aToHex(new Uint8Array([0x68, 0x65, 0x6c, 0x6c, 0xf])); // 0x68656c0f
- * ```
- */
-function u8aToHex(value, bitLength = -1, isPrefixed = true) {
-    const length = Math.ceil(bitLength / 8);
-    return `${isPrefixed ? '0x' : ''}${!value?.length
-        ? ''
-        : (bitLength > 0 && value.length > length)
-            ? `${Buffer.from(value.subarray(0, length / 2)).toString('hex')}…${Buffer.from(value.subarray(value.length - length / 2)).toString('hex')}`
-            : Buffer.from(value).toString('hex')}`;
-}

package/build-tsc-cjs/u8a/toNumber.js

@@ -1,61 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.u8aToNumber = u8aToNumber;
-/**
- * @name u8aToNumber
- * @summary Creates a number from a Uint8Array object.
- */
-function u8aToNumber(value, { isLe = true, isNegative = false } = {}) {
-    // slice + reverse is expensive, however SCALE is LE by default so this is the path
-    // we are most interested in (the BE is added for the sake of being comprehensive)
-    if (!isLe) {
-        value = value.slice().reverse();
-    }
-    const count = value.length;
-    // When the value is a i{8, 16, 24, 32, 40, 40} values and the top-most bit
-    // indicates a signed value, we use a two's complement conversion. If one of these
-    // flags are not set, we just do a normal unsigned conversion (the same shortcut
-    // applies in both the u8aTo{BigInt, Bn} conversions as well)
-    if (isNegative && count && (value[count - 1] & 0x80)) {
-        switch (count) {
-            case 0:
-                return 0;
-            case 1:
-                return (((value[0] ^ 0x0000_00ff) * -1) - 1);
-            case 2:
-                return ((((value[0] + (value[1] << 8)) ^ 0x0000_ffff) * -1) - 1);
-            case 3:
-                return ((((value[0] + (value[1] << 8) + (value[2] << 16)) ^ 0x00ff_ffff) * -1) - 1);
-            case 4:
-                // for the 3rd byte, we don't << 24 - since JS converts all bitwise operators to
-                // 32-bit, in the case where the top-most bit is set this yields a negative value
-                return ((((value[0] + (value[1] << 8) + (value[2] << 16) + (value[3] * 0x1_00_00_00)) ^ 0xffff_ffff) * -1) - 1);
-            case 5:
-                return (((((value[0] + (value[1] << 8) + (value[2] << 16) + (value[3] * 0x1_00_00_00)) ^ 0xffff_ffff) + ((value[4] ^ 0xff) * 0x1_00_00_00_00)) * -1) - 1);
-            case 6:
-                return (((((value[0] + (value[1] << 8) + (value[2] << 16) + (value[3] * 0x1_00_00_00)) ^ 0xffff_ffff) + (((value[4] + (value[5] << 8)) ^ 0x0000_ffff) * 0x1_00_00_00_00)) * -1) - 1);
-            default:
-                throw new Error('Value more than 48-bits cannot be reliably converted');
-        }
-    }
-    switch (count) {
-        case 0:
-            return 0;
-        case 1:
-            return value[0];
-        case 2:
-            return value[0] + (value[1] << 8);
-        case 3:
-            return value[0] + (value[1] << 8) + (value[2] << 16);
-        case 4:
-            // for the 3rd byte, we don't << 24 - since JS converts all bitwise operators to
-            // 32-bit, in the case where the top-most bit is set this yields a negative value
-            return value[0] + (value[1] << 8) + (value[2] << 16) + (value[3] * 0x1_00_00_00);
-        case 5:
-            return value[0] + (value[1] << 8) + (value[2] << 16) + ((value[3] + (value[4] << 8)) * 0x1_00_00_00);
-        case 6:
-            return value[0] + (value[1] << 8) + (value[2] << 16) + ((value[3] + (value[4] << 8) + (value[5] << 16)) * 0x1_00_00_00);
-        default:
-            throw new Error('Value more than 48-bits cannot be reliably converted');
-    }
-}

package/build-tsc-cjs/u8a/toString.js

@@ -1,24 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.u8aToString = u8aToString;
-const x_textdecoder_1 = require("@pezkuwi/x-textdecoder");
-const decoder = new x_textdecoder_1.TextDecoder('utf-8');
-/**
- * @name u8aToString
- * @summary Creates a utf-8 string from a Uint8Array object.
- * @description
- * `UInt8Array` input values return the actual decoded utf-8 string. `null` or `undefined` values returns an empty string.
- * @example
- * <BR>
- *
- * ```javascript
- * import { u8aToString } from '@pezkuwi/util';
- *
- * u8aToString(new Uint8Array([0x68, 0x65, 0x6c, 0x6c, 0x6f])); // hello
- * ```
- */
-function u8aToString(value) {
-    return value
-        ? decoder.decode(value)
-        : '';
-}

package/build-tsc-cjs/u8a/toU8a.js

@@ -1,42 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.u8aToU8a = u8aToU8a;
-const toU8a_js_1 = require("../hex/toU8a.js");
-const buffer_js_1 = require("../is/buffer.js");
-const hex_js_1 = require("../is/hex.js");
-const u8a_js_1 = require("../is/u8a.js");
-const toU8a_js_2 = require("../string/toU8a.js");
-/**
- * @name u8aToU8a
- * @summary Creates a Uint8Array value from a Uint8Array, Buffer, string or hex input.
- * @description
- * `null` or `undefined` inputs returns a `[]` result, Uint8Array values returns the value, hex strings returns a Uint8Array representation.
- * If `strict` is true, `null` or `undefined` will throw an error instead of returning an empty array.
- * Supports input types: Uint8Array, Buffer, hex string, string, or number array.
- * @example
- * <BR>
- *
- * ```javascript
- * import { u8aToU8a } from '@pezkuwi/util';
- *
- * u8aToU8a(new Uint8Array([0x12, 0x34]); // => Uint8Array([0x12, 0x34])
- * u8aToU8a(0x1234); // => Uint8Array([0x12, 0x34])
- * ```
- */
-function u8aToU8a(value, strict = false) {
-    if (strict && (value === null || value === undefined)) {
-        throw new Error('u8aToU8a: Expected non-null, non-undefined value');
-    }
-    return (0, u8a_js_1.isU8a)(value)
-        // NOTE isBuffer needs to go here since it actually extends
-        // Uint8Array on Node.js environments, so all Buffer are Uint8Array,
-        // but Uint8Array is not Buffer
-        ? (0, buffer_js_1.isBuffer)(value)
-            ? new Uint8Array(value)
-            : value
-        : (0, hex_js_1.isHex)(value)
-            ? (0, toU8a_js_1.hexToU8a)(value)
-            : Array.isArray(value)
-                ? new Uint8Array(value)
-                : (0, toU8a_js_2.stringToU8a)(value);
-}

package/build-tsc-cjs/u8a/wrap.js

@@ -1,49 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.U8A_WRAP_POSTFIX = exports.U8A_WRAP_PREFIX = exports.U8A_WRAP_ETHEREUM = void 0;
-exports.u8aIsWrapped = u8aIsWrapped;
-exports.u8aUnwrapBytes = u8aUnwrapBytes;
-exports.u8aWrapBytes = u8aWrapBytes;
-const concat_js_1 = require("./concat.js");
-const eq_js_1 = require("./eq.js");
-const toU8a_js_1 = require("./toU8a.js");
-/** @internal */
-exports.U8A_WRAP_ETHEREUM = (0, toU8a_js_1.u8aToU8a)('\x19Ethereum Signed Message:\n');
-/** @internal */
-exports.U8A_WRAP_PREFIX = (0, toU8a_js_1.u8aToU8a)('<Bytes>');
-/** @internal */
-exports.U8A_WRAP_POSTFIX = (0, toU8a_js_1.u8aToU8a)('</Bytes>');
-const WRAP_LEN = exports.U8A_WRAP_PREFIX.length + exports.U8A_WRAP_POSTFIX.length;
-/** @internal */
-function u8aIsWrapped(u8a, withEthereum) {
-    return ((u8a.length >= WRAP_LEN &&
-        (0, eq_js_1.u8aEq)(u8a.subarray(0, exports.U8A_WRAP_PREFIX.length), exports.U8A_WRAP_PREFIX) &&
-        (0, eq_js_1.u8aEq)(u8a.slice(-exports.U8A_WRAP_POSTFIX.length), exports.U8A_WRAP_POSTFIX)) ||
-        (withEthereum &&
-            u8a.length >= exports.U8A_WRAP_ETHEREUM.length &&
-            (0, eq_js_1.u8aEq)(u8a.subarray(0, exports.U8A_WRAP_ETHEREUM.length), exports.U8A_WRAP_ETHEREUM)));
-}
-/**
- * @name u8aUnwrapBytes
- * @description Removes all <Bytes>...</Bytes> wrappers from the supplied value
- */
-function u8aUnwrapBytes(bytes) {
-    const u8a = (0, toU8a_js_1.u8aToU8a)(bytes);
-    // we don't want to unwrap Ethereum-style wraps
-    return u8aIsWrapped(u8a, false)
-        ? u8a.subarray(exports.U8A_WRAP_PREFIX.length, u8a.length - exports.U8A_WRAP_POSTFIX.length)
-        : u8a;
-}
-/**
- * @name u8aWrapBytes
- * @description
- * Adds a <Bytes>...</Bytes> wrapper to the supplied value, if
- * - We don't already have a Bytes wrapper
- * - The message is not an Ethereum-style message
- */
-function u8aWrapBytes(bytes) {
-    const u8a = (0, toU8a_js_1.u8aToU8a)(bytes);
-    return u8aIsWrapped(u8a, true)
-        ? u8a
-        : (0, concat_js_1.u8aConcatStrict)([exports.U8A_WRAP_PREFIX, u8a, exports.U8A_WRAP_POSTFIX]);
-}

package/build-tsc-esm/array/chunk.js

@@ -1,27 +0,0 @@
-/**
- * @name arrayChunk
- * @summary Split T[] into T[][] based on the defind size
- * @description
- * Returns a set ao arrays based on the chunksize
- * @example
- * <BR>
- *
- * ```javascript
- * import { arrayChunk } from '@pezkuwi/util';
- *
- * arrayChunk([1, 2, 3, 4, 5]); // [[1, 2], [3, 4], [5]]
- * ```
- */
-export function arrayChunk(array, chunkSize) {
-    const outputSize = Math.ceil(array.length / chunkSize);
-    // shortcut for the single-split case
-    if (outputSize === 1) {
-        return [array];
-    }
-    const output = Array(outputSize);
-    for (let i = 0; i < outputSize; i++) {
-        const offset = i * chunkSize;
-        output[i] = array.slice(offset, offset + chunkSize);
-    }
-    return output;
-}

package/build-tsc-esm/array/filter.js

@@ -1,19 +0,0 @@
-/**
- * @name arrayFilter
- * @summary Filters undefined and (optionally) null values from an array
- * @description
- * Returns a new array with all `undefined` values removed. Optionally, when `allowNulls = false`, it removes the `null` values as well
- * @example
- * <BR>
- *
- * ```javascript
- * import { arrayFilter } from '@pezkuwi/util';
- *
- * arrayFilter([0, void 0, true, null, false, '']); // [0, true, null, false, '']
- * arrayFilter([0, void 0, true, null, false, ''], false); // [0, true, false, '']
- * ```
- */
-export function arrayFilter(array, allowNulls = true) {
-    return array.filter((v) => v !== undefined &&
-        (allowNulls || v !== null));
-}

package/build-tsc-esm/array/flatten.js

@@ -1,39 +0,0 @@
-/**
- * @name arrayFlatten
- * @summary Merge T[][] into T[]
- * @description
- * Returns a new array with all arrays merged into one
- * @example
- * <BR>
- *
- * ```javascript
- * import { arrayFlatten } from '@pezkuwi/util';
- *
- * arrayFlatten([[1, 2], [3, 4], [5]]); // [1, 2, 3, 4, 5]
- * ```
- */
-export function arrayFlatten(arrays) {
-    const num = arrays.length;
-    // shortcuts for the empty & single-entry case
-    if (num === 0) {
-        return [];
-    }
-    else if (num === 1) {
-        return arrays[0];
-    }
-    // pre-allocate based on the combined size
-    let size = 0;
-    for (let i = 0; i < num; i++) {
-        size += arrays[i].length;
-    }
-    const output = new Array(size);
-    let i = -1;
-    for (let j = 0; j < num; j++) {
-        const a = arrays[j];
-        // instead of pushing, we just set the entries
-        for (let e = 0, count = a.length; e < count; e++) {
-            output[++i] = a[e];
-        }
-    }
-    return output;
-}

package/build-tsc-esm/array/index.js

@@ -1,10 +0,0 @@
-/**
- * @summary Utility methods that operates on arrays
- */
-export { arrayChunk } from './chunk.js';
-export { arrayFilter } from './filter.js';
-export { arrayFlatten } from './flatten.js';
-export { arrayRange } from './range.js';
-export { arrayShuffle } from './shuffle.js';
-export { arrayUnzip } from './unzip.js';
-export { arrayZip } from './zip.js';

package/build-tsc-esm/array/range.js

@@ -1,25 +0,0 @@
-/**
- * @name arrayRange
- * @summary Returns a range of numbers ith the size and the specified offset
- * @description
- * Returns a new array of numbers with the specific size. Optionally, when `startAt`, is provided, it generates the range to start at a specific value.
- * @example
- * <BR>
- *
- * ```javascript
- * import { arrayRange } from '@pezkuwi/util';
- *
- * arrayRange(5); // [0, 1, 2, 3, 4]
- * arrayRange(3, 5); // [5, 6, 7]
- * ```
- */
-export function arrayRange(size, startAt = 0) {
-    if (size <= 0) {
-        throw new Error('Expected non-zero, positive number as a range size');
-    }
-    const result = new Array(size);
-    for (let i = 0; i < size; i++) {
-        result[i] = i + startAt;
-    }
-    return result;
-}

package/build-tsc-esm/array/shuffle.js

@@ -1,19 +0,0 @@
-/**
- * @name arrayShuffle
- * @description Shuffles the input array (unlike sort, this is not done in-place)
- */
-export function arrayShuffle(input) {
-    const result = input.slice();
-    let curr = result.length;
-    // noop for the single entry
-    if (curr === 1) {
-        return result;
-    }
-    while (curr !== 0) {
-        // ~~ is more performant than Math.floor
-        const rand = ~~(Math.random() * curr);
-        curr--;
-        [result[curr], result[rand]] = [result[rand], result[curr]];
-    }
-    return result;
-}

package/build-tsc-esm/array/unzip.js

@@ -1,13 +0,0 @@
-/**
- * @name arrayUnzip
- * @description Splits a single [K, V][] into [K[], V[]]
- */
-export function arrayUnzip(entries) {
-    const count = entries.length;
-    const keys = new Array(count);
-    const values = new Array(count);
-    for (let i = 0; i < count; i++) {
-        [keys[i], values[i]] = entries[i];
-    }
-    return [keys, values];
-}

package/build-tsc-esm/array/zip.js

@@ -1,12 +0,0 @@
-/**
- * @name arrayZip
- * @description Combines 2 distinct key/value arrays into a single [K, V] array
- */
-export function arrayZip(keys, values) {
-    const count = keys.length;
-    const result = new Array(count);
-    for (let i = 0; i < count; i++) {
-        result[i] = [keys[i], values[i]];
-    }
-    return result;
-}