@pezkuwi/util 14.0.10 → 14.0.12

package/hex/toBn.js

@@ -0,0 +1,32 @@
+import { BN } from '../bn/bn.js';
+import { hexStripPrefix } from './stripPrefix.js';
+/**
+ * @name hexToBn
+ * @summary Creates a BN.js object from a hex string.
+ * @description
+ * `null` inputs returns a `BN(0)` result. Hex input values return the actual value converted to a BN. Anything that is not a hex string (including the `0x` prefix) throws an error.
+ * @param _value The value to convert
+ * @param _options Options to pass while converting
+ * @param _options.isLe Convert using Little Endian
+ * @param _options.isNegative Convert using two's complement
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import { hexToBn } from '@pezkuwi/util';
+ *
+ * hexToBn('0x123480001f'); // => BN(0x123480001f)
+ * ```
+ */
+export function hexToBn(value, { isLe = false, isNegative = false } = {}) {
+    if (!value || value === '0x') {
+        return new BN(0);
+    }
+    const stripped = hexStripPrefix(value);
+    const bn = new BN(stripped, 16, isLe ? 'le' : 'be');
+    // fromTwos takes as parameter the number of bits, which is the hex length
+    // multiplied by 4 (2 bytes being 8 bits)
+    return isNegative
+        ? bn.fromTwos(stripped.length * 4)
+        : bn;
+}

package/hex/toNumber.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @name hexToNumber
+ * @summary Creates a Number value from a Buffer object.
+ * @description
+ * `null` inputs returns an NaN result, `hex` values return the actual value as a `Number`.
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import { hexToNumber } from '@pezkuwi/util';
+ *
+ * hexToNumber('0x1234'); // => 0x1234
+ * ```
+ */
+export declare function hexToNumber(value?: string | null): number;

package/hex/toNumber.js

@@ -0,0 +1,20 @@
+import { hexToBn } from './toBn.js';
+/**
+ * @name hexToNumber
+ * @summary Creates a Number value from a Buffer object.
+ * @description
+ * `null` inputs returns an NaN result, `hex` values return the actual value as a `Number`.
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import { hexToNumber } from '@pezkuwi/util';
+ *
+ * hexToNumber('0x1234'); // => 0x1234
+ * ```
+ */
+export function hexToNumber(value) {
+    return value
+        ? hexToBn(value).toNumber()
+        : NaN;
+}

package/hex/toString.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @name hexToU8a
+ * @summary Creates a Uint8Array object from a hex string.
+ * @description
+ * Hex input values return the actual bytes value converted to a string. Anything that is not a hex string (including the `0x` prefix) throws an error.
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import { hexToString } from '@pezkuwi/util';
+ *
+ * hexToU8a('0x68656c6c6f'); // hello
+ * ```
+ */
+export declare function hexToString(_value?: string | null): string;

package/hex/toString.js

@@ -0,0 +1,19 @@
+import { u8aToString } from '../u8a/toString.js';
+import { hexToU8a } from './toU8a.js';
+/**
+ * @name hexToU8a
+ * @summary Creates a Uint8Array object from a hex string.
+ * @description
+ * Hex input values return the actual bytes value converted to a string. Anything that is not a hex string (including the `0x` prefix) throws an error.
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import { hexToString } from '@pezkuwi/util';
+ *
+ * hexToU8a('0x68656c6c6f'); // hello
+ * ```
+ */
+export function hexToString(_value) {
+    return u8aToString(hexToU8a(_value));
+}

package/hex/toU8a.d.ts

@@ -0,0 +1,16 @@
+/**
+ * @name hexToU8a
+ * @summary Creates a Uint8Array object from a hex string.
+ * @description
+ * `null` inputs returns an empty `Uint8Array` result. Hex input values return the actual bytes value converted to a Uint8Array. Anything that is not a hex string (including the `0x` prefix) throws an error.
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import { hexToU8a } from '@pezkuwi/util';
+ *
+ * hexToU8a('0x80001f'); // Uint8Array([0x80, 0x00, 0x1f])
+ * hexToU8a('0x80001f', 32); // Uint8Array([0x00, 0x80, 0x00, 0x1f])
+ * ```
+ */
+export declare function hexToU8a(value?: string | null, bitLength?: number): Uint8Array;

package/hex/toU8a.js

@@ -0,0 +1,54 @@
+const CHR = '0123456789abcdef';
+const U8 = new Uint8Array(256);
+const U16 = new Uint8Array(256 * 256);
+for (let i = 0, count = CHR.length; i < count; i++) {
+    U8[CHR[i].charCodeAt(0) | 0] = i | 0;
+    if (i > 9) {
+        U8[CHR[i].toUpperCase().charCodeAt(0) | 0] = i | 0;
+    }
+}
+for (let i = 0; i < 256; i++) {
+    const s = i << 8;
+    for (let j = 0; j < 256; j++) {
+        U16[s | j] = (U8[i] << 4) | U8[j];
+    }
+}
+/**
+ * @name hexToU8a
+ * @summary Creates a Uint8Array object from a hex string.
+ * @description
+ * `null` inputs returns an empty `Uint8Array` result. Hex input values return the actual bytes value converted to a Uint8Array. Anything that is not a hex string (including the `0x` prefix) throws an error.
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import { hexToU8a } from '@pezkuwi/util';
+ *
+ * hexToU8a('0x80001f'); // Uint8Array([0x80, 0x00, 0x1f])
+ * hexToU8a('0x80001f', 32); // Uint8Array([0x00, 0x80, 0x00, 0x1f])
+ * ```
+ */
+export function hexToU8a(value, bitLength = -1) {
+    if (!value) {
+        return new Uint8Array();
+    }
+    let s = value.startsWith('0x')
+        ? 2
+        : 0;
+    const decLength = Math.ceil((value.length - s) / 2);
+    const endLength = Math.ceil(bitLength === -1
+        ? decLength
+        : bitLength / 8);
+    const result = new Uint8Array(endLength);
+    const offset = endLength > decLength
+        ? endLength - decLength
+        : 0;
+    for (let i = offset; i < endLength; i++, s += 2) {
+        // The big factor here is actually the string lookups. If we do
+        // HEX_TO_U16[value.substring()] we get an 10x slowdown. In the
+        // same vein using charCodeAt (as opposed to value[s] or value.charAt(s)) is
+        // also the faster operation by at least 2x with the character map above
+        result[i] = U16[(value.charCodeAt(s) << 8) | value.charCodeAt(s + 1)];
+    }
+    return result;
+}

package/hex/toU8aBuffer.d.ts

@@ -0,0 +1,16 @@
+/**
+ * @name hexToU8a
+ * @summary Creates a Uint8Array object from a hex string.
+ * @description
+ * `null` inputs returns an empty `Uint8Array` result. Hex input values return the actual bytes value converted to a Uint8Array. Anything that is not a hex string (including the `0x` prefix) throws an error.
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import { hexToU8a } from '@pezkuwi/util';
+ *
+ * hexToU8a('0x80001f'); // Uint8Array([0x80, 0x00, 0x1f])
+ * hexToU8a('0x80001f', 32); // Uint8Array([0x00, 0x80, 0x00, 0x1f])
+ * ```
+ */
+export declare function hexToU8a(_value?: string | null, bitLength?: number): Uint8Array;

package/hex/toU8aBuffer.js

@@ -0,0 +1,40 @@
+/**
+ * @name hexToU8a
+ * @summary Creates a Uint8Array object from a hex string.
+ * @description
+ * `null` inputs returns an empty `Uint8Array` result. Hex input values return the actual bytes value converted to a Uint8Array. Anything that is not a hex string (including the `0x` prefix) throws an error.
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import { hexToU8a } from '@pezkuwi/util';
+ *
+ * hexToU8a('0x80001f'); // Uint8Array([0x80, 0x00, 0x1f])
+ * hexToU8a('0x80001f', 32); // Uint8Array([0x00, 0x80, 0x00, 0x1f])
+ * ```
+ */
+export function hexToU8a(_value, bitLength = -1) {
+    if (!_value) {
+        return new Uint8Array();
+    }
+    const value = _value.startsWith('0x')
+        ? _value.substring(2)
+        : _value;
+    const buf = Buffer.from(value, 'hex');
+    const valLength = value.length / 2;
+    const resultLength = Math.ceil(bitLength === -1
+        ? valLength
+        : bitLength / 8);
+    if (resultLength === valLength) {
+        return Uint8Array.from(buf);
+    }
+    const offset = resultLength > valLength
+        ? resultLength - valLength
+        : 0;
+    if (offset) {
+        const u8a = new Uint8Array(resultLength);
+        u8a.set(buf, offset);
+        return u8a;
+    }
+    return Uint8Array.from(buf.subarray(0, resultLength));
+}

package/index.d.ts

@@ -0,0 +1,2 @@
+import './packageDetect.js';
+export * from './bundle.js';

package/index.js

@@ -0,0 +1,2 @@
+import './packageDetect.js';
+export * from './bundle.js';

package/is/array.d.ts

@@ -0,0 +1,5 @@
+/**
+ * @name isArray
+ * @summary Tests for a Array instance.
+ */
+export declare function isArray<T>(value?: unknown): value is T[];

package/is/array.js

@@ -0,0 +1,7 @@
+/**
+ * @name isArray
+ * @summary Tests for a Array instance.
+ */
+export function isArray(value) {
+    return Array.isArray(value);
+}

package/is/ascii.d.ts

@@ -0,0 +1,8 @@
+import type { U8aLike } from '../types.js';
+/**
+ * @name isAscii
+ * @summary Tests if the input is printable ASCII
+ * @description
+ * Checks to see if the input string or Uint8Array is printable ASCII, 32-127 + formatters
+ */
+export declare function isAscii(value?: U8aLike | null): boolean;

package/is/ascii.js

@@ -0,0 +1,40 @@
+import { u8aToU8a } from '../u8a/toU8a.js';
+import { isHex } from './hex.js';
+import { isString } from './string.js';
+/** @internal */
+function isAsciiStr(str) {
+    for (let i = 0, count = str.length; i < count; i++) {
+        const b = str.charCodeAt(i);
+        // check is inlined here, it is faster than making a call
+        if (b < 32 || b > 126) {
+            return false;
+        }
+    }
+    return true;
+}
+/** @internal */
+function isAsciiBytes(u8a) {
+    for (let i = 0, count = u8a.length; i < count; i++) {
+        const b = u8a[i] | 0;
+        // check is inlined here, it is faster than making a call
+        if (b < 32 || b > 126) {
+            return false;
+        }
+    }
+    return true;
+}
+/**
+ * @name isAscii
+ * @summary Tests if the input is printable ASCII
+ * @description
+ * Checks to see if the input string or Uint8Array is printable ASCII, 32-127 + formatters
+ */
+export function isAscii(value) {
+    return isString(value)
+        ? isHex(value)
+            ? isAsciiBytes(u8aToU8a(value))
+            : isAsciiStr(value)
+        : value
+            ? isAsciiBytes(value)
+            : false;
+}

package/is/bigInt.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @name isBigInt
+ * @summary Tests for a `BigInt` object instance.
+ * @description
+ * Checks to see if the input object is an instance of `BigInt`
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import { isBigInt } from '@pezkuwi/util';
+ *
+ * console.log('isBigInt', isBigInt(123_456n)); // => true
+ * ```
+ */
+export declare function isBigInt(value: unknown): value is bigint;

package/is/bigInt.js

@@ -0,0 +1,17 @@
+/**
+ * @name isBigInt
+ * @summary Tests for a `BigInt` object instance.
+ * @description
+ * Checks to see if the input object is an instance of `BigInt`
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import { isBigInt } from '@pezkuwi/util';
+ *
+ * console.log('isBigInt', isBigInt(123_456n)); // => true
+ * ```
+ */
+export function isBigInt(value) {
+    return typeof value === 'bigint';
+}

package/is/bn.d.ts

@@ -0,0 +1,17 @@
+import { BN } from '../bn/bn.js';
+/**
+ * @name isBn
+ * @summary Tests for a `BN` object instance.
+ * @description
+ * Checks to see if the input object is an instance of `BN` (bn.js).
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import BN from 'bn.js';
+ * import { isBn } from '@pezkuwi/util';
+ *
+ * console.log('isBn', isBn(new BN(1))); // => true
+ * ```
+ */
+export declare function isBn(value: unknown): value is BN;

package/is/bn.js

@@ -0,0 +1,19 @@
+import { BN } from '../bn/bn.js';
+/**
+ * @name isBn
+ * @summary Tests for a `BN` object instance.
+ * @description
+ * Checks to see if the input object is an instance of `BN` (bn.js).
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import BN from 'bn.js';
+ * import { isBn } from '@pezkuwi/util';
+ *
+ * console.log('isBn', isBn(new BN(1))); // => true
+ * ```
+ */
+export function isBn(value) {
+    return BN.isBN(value);
+}

package/is/boolean.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @name isBoolean
+ * @summary Tests for a boolean value.
+ * @description
+ * Checks to see if the input value is a JavaScript boolean.
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import { isBoolean } from '@pezkuwi/util';
+ *
+ * isBoolean(false); // => true
+ * ```
+ */
+export declare function isBoolean(value: unknown): value is boolean;

package/is/boolean.js

@@ -0,0 +1,17 @@
+/**
+ * @name isBoolean
+ * @summary Tests for a boolean value.
+ * @description
+ * Checks to see if the input value is a JavaScript boolean.
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import { isBoolean } from '@pezkuwi/util';
+ *
+ * isBoolean(false); // => true
+ * ```
+ */
+export function isBoolean(value) {
+    return typeof value === 'boolean';
+}

package/is/buffer.d.ts

@@ -0,0 +1,16 @@
+import type { BufferObject } from '../types.js';
+/**
+ * @name isBuffer
+ * @summary Tests for a `Buffer` object instance.
+ * @description
+ * Checks to see if the input object is an instance of `Buffer`.
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import { isBuffer } from '@pezkuwi/util';
+ *
+ * console.log('isBuffer', isBuffer(Buffer.from([]))); // => true
+ * ```
+ */
+export declare function isBuffer<T = BufferObject>(value: unknown): value is T;

package/is/buffer.js

@@ -0,0 +1,21 @@
+import { xglobal } from '@pezkuwi/x-global';
+import { hasBuffer } from '../has.js';
+import { isFunction } from './function.js';
+/**
+ * @name isBuffer
+ * @summary Tests for a `Buffer` object instance.
+ * @description
+ * Checks to see if the input object is an instance of `Buffer`.
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import { isBuffer } from '@pezkuwi/util';
+ *
+ * console.log('isBuffer', isBuffer(Buffer.from([]))); // => true
+ * ```
+ */
+export function isBuffer(value) {
+    // we do check a function first, since it is slightly faster than isBuffer itself
+    return hasBuffer && !!value && isFunction(value.readDoubleLE) && xglobal.Buffer.isBuffer(value);
+}

package/is/childClass.d.ts

@@ -0,0 +1,17 @@
+import type { Class } from '../types.js';
+/**
+ * @name isChildClass
+ * @summary Tests if the child extends the parent Class
+ * @description
+ * Checks to see if the child Class extends the parent Class
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import { isChildClass } from '@pezkuwi/util';
+ *
+ * console.log('isChildClass', isChildClass(BN, BN); // => true
+ * console.log('isChildClass', isChildClass(BN, Uint8Array); // => false
+ * ```
+ */
+export declare function isChildClass<P extends Class>(Parent: P, Child?: unknown): Child is P;

package/is/childClass.js

@@ -0,0 +1,23 @@
+import { isClass } from './class.js';
+/**
+ * @name isChildClass
+ * @summary Tests if the child extends the parent Class
+ * @description
+ * Checks to see if the child Class extends the parent Class
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import { isChildClass } from '@pezkuwi/util';
+ *
+ * console.log('isChildClass', isChildClass(BN, BN); // => true
+ * console.log('isChildClass', isChildClass(BN, Uint8Array); // => false
+ * ```
+ */
+export function isChildClass(Parent, Child) {
+    // https://stackoverflow.com/questions/30993434/check-if-a-constructor-inherits-another-in-es6/30993664
+    return isClass(Child) && isClass(Parent)
+        // eslint-disable-next-line no-prototype-builtins
+        ? Parent === Child || Parent.isPrototypeOf(Child)
+        : false;
+}

package/is/class.d.ts

@@ -0,0 +1,6 @@
+import type { Class } from '../types.js';
+/**
+ * @name isClass
+ * Tests if the supplied argument is a Class
+ */
+export declare const isClass: <T extends Class>(value?: unknown) => value is T;

package/is/class.js

@@ -0,0 +1,6 @@
+import { isOnFunction } from './helpers.js';
+/**
+ * @name isClass
+ * Tests if the supplied argument is a Class
+ */
+export const isClass = /*#__PURE__*/ isOnFunction('isPrototypeOf', 'hasOwnProperty');

package/is/codec.d.ts

@@ -0,0 +1,12 @@
+import type { HexString } from '../types.js';
+interface Registry {
+    get: (...params: never[]) => any;
+}
+interface Codec {
+    readonly registry: Registry;
+    toHex(...params: never[]): HexString;
+    toHuman(...params: never[]): unknown;
+    toU8a: (...params: never[]) => Uint8Array;
+}
+export declare function isCodec<T extends Codec = Codec>(value?: unknown): value is T;
+export {};

package/is/codec.js

@@ -0,0 +1,6 @@
+import { isOnObject } from './helpers.js';
+const checkCodec = /*#__PURE__*/ isOnObject('toHex', 'toHuman', 'toU8a');
+const checkRegistry = /*#__PURE__*/ isOnObject('get');
+export function isCodec(value) {
+    return checkCodec(value) && checkRegistry(value.registry);
+}

package/is/compact.d.ts

@@ -0,0 +1,13 @@
+import type { BN } from '../bn/bn.js';
+interface Compact<T> {
+    toBigInt(): bigint;
+    toBn(): BN;
+    toNumber(): number;
+    unwrap(): T;
+}
+/**
+ * @name isCompact
+ * @summary Tests for SCALE-Compact-like object instance.
+ */
+export declare const isCompact: <T>(value?: unknown) => value is Compact<T>;
+export {};

package/is/compact.js

@@ -0,0 +1,6 @@
+import { isOnObject } from './helpers.js';
+/**
+ * @name isCompact
+ * @summary Tests for SCALE-Compact-like object instance.
+ */
+export const isCompact = /*#__PURE__*/ isOnObject('toBigInt', 'toBn', 'toNumber', 'unwrap');

package/is/error.d.ts

@@ -0,0 +1,15 @@
+/**
+ * @name isError
+ * @summary Tests for a `Error` object instance.
+ * @description
+ * Checks to see if the input object is an instance of `Error`.
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import { isError } from '@pezkuwi/util';
+ *
+ * console.log('isError', isError(new Error('message'))); // => true
+ * ```
+ */
+export declare function isError(value: unknown): value is Error;

package/is/error.js

@@ -0,0 +1,18 @@
+/**
+ * @name isError
+ * @summary Tests for a `Error` object instance.
+ * @description
+ * Checks to see if the input object is an instance of `Error`.
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import { isError } from '@pezkuwi/util';
+ *
+ * console.log('isError', isError(new Error('message'))); // => true
+ * ```
+ */
+export function isError(value) {
+    return (((value && value.constructor) === Error) ||
+        value instanceof Error);
+}

package/is/function.d.ts

@@ -0,0 +1,17 @@
+type FnType = Function;
+/**
+ * @name isFunction
+ * @summary Tests for a `function`.
+ * @description
+ * Checks to see if the input value is a JavaScript function.
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import { isFunction } from '@pezkuwi/util';
+ *
+ * isFunction(() => false); // => true
+ * ```
+ */
+export declare function isFunction(value: unknown): value is FnType;
+export {};

package/is/function.js

@@ -0,0 +1,17 @@
+/**
+ * @name isFunction
+ * @summary Tests for a `function`.
+ * @description
+ * Checks to see if the input value is a JavaScript function.
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import { isFunction } from '@pezkuwi/util';
+ *
+ * isFunction(() => false); // => true
+ * ```
+ */
+export function isFunction(value) {
+    return typeof value === 'function';
+}

package/is/helpers.d.ts

@@ -0,0 +1,3 @@
+export declare function isOn<T>(...fns: (keyof T)[]): (value?: unknown) => value is T;
+export declare function isOnFunction<T>(...fns: (keyof T)[]): (value?: unknown) => value is T;
+export declare function isOnObject<T>(...fns: (keyof T)[]): (value?: unknown) => value is T;

package/is/helpers.js

@@ -0,0 +1,14 @@
+import { isFunction } from './function.js';
+import { isObject } from './object.js';
+export function isOn(...fns) {
+    return (value) => (isObject(value) || isFunction(value)) &&
+        fns.every((f) => isFunction(value[f]));
+}
+export function isOnFunction(...fns) {
+    return (value) => isFunction(value) &&
+        fns.every((f) => isFunction(value[f]));
+}
+export function isOnObject(...fns) {
+    return (value) => isObject(value) &&
+        fns.every((f) => isFunction(value[f]));
+}