@norionsoft/hd-derivations 1.0.0-beta.0

package/build/browser/bn-DgUofJEE.js

@@ -0,0 +1,208 @@
+import { g as getDefaultExportFromCjs } from './_commonjsHelpers-BFTU3MAI.js';
+import { a as requireBn } from './bn-C5dpaNMj.js';
+import { l as isFunction, R as REGEX_HEX_PREFIXED, m as REGEX_HEX_NOPREFIX, n as isHex } from './bundle-DjgjuASd.js';
+
+var bnExports = requireBn();
+const BN = /*@__PURE__*/getDefaultExportFromCjs(bnExports);
+
+/**
+ * @name isObject
+ * @summary Tests for an `object`.
+ * @description
+ * Checks to see if the input value is a JavaScript object.
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import { isObject } from '@polkadot/util';
+ *
+ * isObject({}); // => true
+ * isObject('something'); // => false
+ * ```
+ */
+function isObject(value) {
+    return !!value && typeof value === 'object';
+}
+
+function isOn(...fns) {
+    return (value) => (isObject(value) || isFunction(value)) &&
+        fns.every((f) => isFunction(value[f]));
+}
+
+const isToBigInt = /*#__PURE__*/ isOn('toBigInt');
+
+const isToBn = /*#__PURE__*/ isOn('toBn');
+
+/**
+ * @name hexStripPrefix
+ * @summary Strips any leading `0x` prefix.
+ * @description
+ * Tests for the existence of a `0x` prefix, and returns the value without the prefix. Un-prefixed values are returned as-is.
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import { hexStripPrefix } from '@polkadot/util';
+ *
+ * console.log('stripped', hexStripPrefix('0x1234')); // => 1234
+ * ```
+ */
+function hexStripPrefix(value) {
+    if (!value || value === '0x') {
+        return '';
+    }
+    else if (REGEX_HEX_PREFIXED.test(value)) {
+        return value.substring(2);
+    }
+    else if (REGEX_HEX_NOPREFIX.test(value)) {
+        return value;
+    }
+    throw new Error(`Expected hex value to convert, found '${value}'`);
+}
+
+/**
+ * @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 '@polkadot/util';
+ *
+ * hexToBn('0x123480001f'); // => BN(0x123480001f)
+ * ```
+ */
+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;
+}
+
+/**
+ * @name BN_ONE
+ * @summary BN constant for 1.
+ */
+const BN_ONE = /*#__PURE__*/ new BN(1);
+/**
+ * @name BN_TWO
+ * @summary BN constant for 2.
+ */
+const BN_TWO = /*#__PURE__*/ new BN(2);
+/**
+ * @name BN_EIGHT
+ * @summary BN constant for 8.
+ */
+const BN_EIGHT = /*#__PURE__*/ new BN(8);
+/**
+ * @name BN_BILLION
+ * @summary BN constant for 1,000,000,000.
+ */
+const BN_BILLION = /*#__PURE__*/ new BN(1_000_000_000);
+/**
+ * @name BN_QUINTILL
+ * @summary BN constant for 1,000,000,000,000,000,000.
+ */
+BN_BILLION.mul(BN_BILLION);
+
+/**
+ * @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 '@polkadot/util';
+ *
+ * console.log('isBigInt', isBigInt(123_456n)); // => true
+ * ```
+ */
+function isBigInt(value) {
+    return typeof value === 'bigint';
+}
+
+/**
+ * @name bnToBn
+ * @summary Creates a BN value from a BN, bigint, string (base 10 or hex) or number input.
+ * @description
+ * `null` inputs returns a `0x0` result, BN values returns the value, numbers returns a BN representation.
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import BN from 'bn.js';
+ * import { bnToBn } from '@polkadot/util';
+ *
+ * bnToBn(0x1234); // => BN(0x1234)
+ * bnToBn(new BN(0x1234)); // => BN(0x1234)
+ * ```
+ */
+function bnToBn(value) {
+    return value
+        ? BN.isBN(value)
+            ? value
+            : isHex(value)
+                ? hexToBn(value.toString())
+                : isBigInt(value)
+                    ? new BN(value.toString())
+                    : isToBn(value)
+                        ? value.toBn()
+                        : isToBigInt(value)
+                            ? new BN(value.toBigInt().toString())
+                            : new BN(value)
+        : new BN(0);
+}
+
+const DEFAULT_OPTS = { bitLength: -1, isLe: true, isNegative: false };
+/**
+ * @name bnToU8a
+ * @summary Creates a Uint8Array object from a BN.
+ * @description
+ * `null`/`undefined`/`NaN` inputs returns an empty `Uint8Array` result. `BN` input values return the actual bytes value converted to a `Uint8Array`. Optionally convert using little-endian format if `isLE` is set.
+ * @example
+ * <BR>
+ *
+ * ```javascript
+ * import { bnToU8a } from '@polkadot/util';
+ *
+ * bnToU8a(new BN(0x1234)); // => [0x12, 0x34]
+ * ```
+ */
+function bnToU8a(value, { bitLength = -1, isLe = true, isNegative = false } = DEFAULT_OPTS) {
+    const valueBn = bnToBn(value);
+    const byteLength = bitLength === -1
+        ? Math.ceil(valueBn.bitLength() / 8)
+        : Math.ceil((bitLength || 0) / 8);
+    if (!value) {
+        return bitLength === -1
+            ? new Uint8Array(1)
+            : new Uint8Array(byteLength);
+    }
+    const output = new Uint8Array(byteLength);
+    const bn = isNegative
+        ? valueBn.toTwos(byteLength * 8)
+        : valueBn;
+    output.set(bn.toArray(isLe ? 'le' : 'be', byteLength), 0);
+    return output;
+}
+
+const BN_LE_OPTS = { isLe: true };
+const BN_LE_32_OPTS = { bitLength: 32, isLe: true };
+const BN_LE_256_OPTS = { bitLength: 256, isLe: true };
+const BN_LE_512_OPTS = { bitLength: 512, isLe: true };
+
+export { BN as B, BN_EIGHT as a, bnToU8a as b, BN_LE_32_OPTS as c, BN_LE_512_OPTS as d, BN_LE_OPTS as e, bnToBn as f, BN_ONE as g, BN_TWO as h, isBigInt as i, BN_LE_256_OPTS as j };

package/build/browser/browser-D9H9snNo.js

@@ -0,0 +1,200 @@
+const HEX_STRINGS = "0123456789abcdefABCDEF";
+HEX_STRINGS.split("").map((c) => c.codePointAt(0));
+const HEX_CODEPOINTS = Array(256)
+    .fill(true)
+    .map((_, i) => {
+    const s = String.fromCodePoint(i);
+    const index = HEX_STRINGS.indexOf(s);
+    // ABCDEF will use 10 - 15
+    return index < 0 ? undefined : index < 16 ? index : index - 6;
+});
+const ENCODER = new TextEncoder();
+new TextDecoder();
+function fromUtf8(s) {
+    return ENCODER.encode(s);
+}
+function concat(arrays) {
+    const totalLength = arrays.reduce((a, b) => a + b.length, 0);
+    const result = new Uint8Array(totalLength);
+    let offset = 0;
+    for (const array of arrays) {
+        result.set(array, offset);
+        offset += array.length;
+    }
+    return result;
+}
+// Mimics Buffer.from(x, 'hex') logic
+// Stops on first non-hex string and returns
+// https://github.com/nodejs/node/blob/v14.18.1/src/string_bytes.cc#L246-L261
+function fromHex(hexString) {
+    const hexBytes = ENCODER.encode(hexString || "");
+    const resultBytes = new Uint8Array(Math.floor(hexBytes.length / 2));
+    let i;
+    for (i = 0; i < resultBytes.length; i++) {
+        const a = HEX_CODEPOINTS[hexBytes[i * 2]];
+        const b = HEX_CODEPOINTS[hexBytes[i * 2 + 1]];
+        if (a === undefined || b === undefined) {
+            break;
+        }
+        resultBytes[i] = (a << 4) | b;
+    }
+    return i === resultBytes.length ? resultBytes : resultBytes.slice(0, i);
+}
+// Same behavior as Buffer.compare()
+function compare(v1, v2) {
+    const minLength = Math.min(v1.length, v2.length);
+    for (let i = 0; i < minLength; ++i) {
+        if (v1[i] !== v2[i]) {
+            return v1[i] < v2[i] ? -1 : 1;
+        }
+    }
+    return v1.length === v2.length ? 0 : v1.length > v2.length ? 1 : -1;
+}
+function writeUInt8(buffer, offset, value) {
+    if (offset + 1 > buffer.length) {
+        throw new Error("Offset is outside the bounds of Uint8Array");
+    }
+    if (value > 0xff) {
+        throw new Error(`The value of "value" is out of range. It must be >= 0 and <= ${0xff}. Received ${value}`);
+    }
+    buffer[offset] = value;
+}
+function writeUInt16(buffer, offset, value, littleEndian) {
+    if (offset + 2 > buffer.length) {
+        throw new Error("Offset is outside the bounds of Uint8Array");
+    }
+    littleEndian = littleEndian.toUpperCase();
+    if (value > 0xffff) {
+        throw new Error(`The value of "value" is out of range. It must be >= 0 and <= ${0xffff}. Received ${value}`);
+    }
+    if (littleEndian === "LE") {
+        buffer[offset] = value & 0xff;
+        buffer[offset + 1] = (value >> 8) & 0xff;
+    }
+    else {
+        buffer[offset] = (value >> 8) & 0xff;
+        buffer[offset + 1] = value & 0xff;
+    }
+}
+function writeUInt32(buffer, offset, value, littleEndian) {
+    if (offset + 4 > buffer.length) {
+        throw new Error("Offset is outside the bounds of Uint8Array");
+    }
+    littleEndian = littleEndian.toUpperCase();
+    if (value > 0xffffffff) {
+        throw new Error(`The value of "value" is out of range. It must be >= 0 and <= ${0xffffffff}. Received ${value}`);
+    }
+    if (littleEndian === "LE") {
+        buffer[offset] = value & 0xff;
+        buffer[offset + 1] = (value >> 8) & 0xff;
+        buffer[offset + 2] = (value >> 16) & 0xff;
+        buffer[offset + 3] = (value >> 24) & 0xff;
+    }
+    else {
+        buffer[offset] = (value >> 24) & 0xff;
+        buffer[offset + 1] = (value >> 16) & 0xff;
+        buffer[offset + 2] = (value >> 8) & 0xff;
+        buffer[offset + 3] = value & 0xff;
+    }
+}
+function writeUInt64(buffer, offset, value, littleEndian) {
+    if (offset + 8 > buffer.length) {
+        throw new Error("Offset is outside the bounds of Uint8Array");
+    }
+    littleEndian = littleEndian.toUpperCase();
+    if (value > 0xffffffffffffffffn) {
+        throw new Error(`The value of "value" is out of range. It must be >= 0 and <= ${0xffffffffffffffffn}. Received ${value}`);
+    }
+    if (littleEndian === "LE") {
+        buffer[offset] = Number(value & 0xffn);
+        buffer[offset + 1] = Number((value >> 8n) & 0xffn);
+        buffer[offset + 2] = Number((value >> 16n) & 0xffn);
+        buffer[offset + 3] = Number((value >> 24n) & 0xffn);
+        buffer[offset + 4] = Number((value >> 32n) & 0xffn);
+        buffer[offset + 5] = Number((value >> 40n) & 0xffn);
+        buffer[offset + 6] = Number((value >> 48n) & 0xffn);
+        buffer[offset + 7] = Number((value >> 56n) & 0xffn);
+    }
+    else {
+        buffer[offset] = Number((value >> 56n) & 0xffn);
+        buffer[offset + 1] = Number((value >> 48n) & 0xffn);
+        buffer[offset + 2] = Number((value >> 40n) & 0xffn);
+        buffer[offset + 3] = Number((value >> 32n) & 0xffn);
+        buffer[offset + 4] = Number((value >> 24n) & 0xffn);
+        buffer[offset + 5] = Number((value >> 16n) & 0xffn);
+        buffer[offset + 6] = Number((value >> 8n) & 0xffn);
+        buffer[offset + 7] = Number(value & 0xffn);
+    }
+}
+function readUInt16(buffer, offset, littleEndian) {
+    if (offset + 2 > buffer.length) {
+        throw new Error("Offset is outside the bounds of Uint8Array");
+    }
+    littleEndian = littleEndian.toUpperCase();
+    if (littleEndian === "LE") {
+        let num = 0;
+        num = (num << 8) + buffer[offset + 1];
+        num = (num << 8) + buffer[offset];
+        return num;
+    }
+    else {
+        let num = 0;
+        num = (num << 8) + buffer[offset];
+        num = (num << 8) + buffer[offset + 1];
+        return num;
+    }
+}
+function readUInt32(buffer, offset, littleEndian) {
+    if (offset + 4 > buffer.length) {
+        throw new Error("Offset is outside the bounds of Uint8Array");
+    }
+    littleEndian = littleEndian.toUpperCase();
+    if (littleEndian === "LE") {
+        let num = 0;
+        num = ((num << 8) + buffer[offset + 3]) >>> 0;
+        num = ((num << 8) + buffer[offset + 2]) >>> 0;
+        num = ((num << 8) + buffer[offset + 1]) >>> 0;
+        num = ((num << 8) + buffer[offset]) >>> 0;
+        return num;
+    }
+    else {
+        let num = 0;
+        num = ((num << 8) + buffer[offset]) >>> 0;
+        num = ((num << 8) + buffer[offset + 1]) >>> 0;
+        num = ((num << 8) + buffer[offset + 2]) >>> 0;
+        num = ((num << 8) + buffer[offset + 3]) >>> 0;
+        return num;
+    }
+}
+function readUInt64(buffer, offset, littleEndian) {
+    if (offset + 8 > buffer.length) {
+        throw new Error("Offset is outside the bounds of Uint8Array");
+    }
+    littleEndian = littleEndian.toUpperCase();
+    if (littleEndian === "LE") {
+        let num = 0n;
+        num = (num << 8n) + BigInt(buffer[offset + 7]);
+        num = (num << 8n) + BigInt(buffer[offset + 6]);
+        num = (num << 8n) + BigInt(buffer[offset + 5]);
+        num = (num << 8n) + BigInt(buffer[offset + 4]);
+        num = (num << 8n) + BigInt(buffer[offset + 3]);
+        num = (num << 8n) + BigInt(buffer[offset + 2]);
+        num = (num << 8n) + BigInt(buffer[offset + 1]);
+        num = (num << 8n) + BigInt(buffer[offset]);
+        return num;
+    }
+    else {
+        let num = 0n;
+        num = (num << 8n) + BigInt(buffer[offset]);
+        num = (num << 8n) + BigInt(buffer[offset + 1]);
+        num = (num << 8n) + BigInt(buffer[offset + 2]);
+        num = (num << 8n) + BigInt(buffer[offset + 3]);
+        num = (num << 8n) + BigInt(buffer[offset + 4]);
+        num = (num << 8n) + BigInt(buffer[offset + 5]);
+        num = (num << 8n) + BigInt(buffer[offset + 6]);
+        num = (num << 8n) + BigInt(buffer[offset + 7]);
+        return num;
+    }
+}
+
+export { fromUtf8 as a, writeUInt8 as b, compare as c, concat as d, writeUInt16 as e, fromHex as f, writeUInt64 as g, readUInt16 as h, readUInt64 as i, readUInt32 as r, writeUInt32 as w };