@leofcoin/chain 1.4.82 → 1.4.84

package/exports/browser/node-browser.js

@@ -1,2 +1,2 @@
-export { N as default } from './node-browser-3cbee72b.js';
-import './index-c3f4012c.js';
+export { N as default } from './node-browser-504c804a.js';
+import './index-f4429da1.js';

package/exports/browser/workers/block-worker.js

@@ -4514,216 +4514,206 @@ var index$2 = {
     isBase64
 };
 
-const isTypedArrayCompatible = (possibleUint8Array) => {
-    if (typeof possibleUint8Array === 'string') {
-        possibleUint8Array = possibleUint8Array.split(',').map(number => Number(number));
-        for (const number of possibleUint8Array) {
-            if (isNaN(number))
-                return false;
-        }
-    }
-    for (const number of possibleUint8Array) {
-        if (isNaN(number))
-            return false;
-    }
-    return true;
-};
-/**
- * Returns a String as Uint8Array
- * @param string string to encode to Uint8Array
- * @returns Uint8Array
- */
-const fromString$1 = (string) => new TextEncoder().encode(string);
-/**
- * Returns a Uint8Array as String
- * @param uint8Array Uint8Array to encode to String
- * @returns String
- */
-const toString$1 = (uint8Array) => new TextDecoder().decode(uint8Array);
-/**
- * Returns a String as Uint8Array
- * @param string string to encode to Uint8Array
- * @returns Uint8Array
- */
-const fromUintArrayString = (string) => Uint8Array.from(string.split(',').map(string => Number(string)));
-/**
- * Returns a Uint8Array as String
- * @param uint8Array Uint8Array to encode to String
- * @returns String
- */
-const toUintArrayString = (uint8Array) => uint8Array.toString();
-/**
- * hexString -> uint8Array
- * @param string hex encoded string
- * @returns UintArray
- */
-const fromHex = (string) => Uint8Array.from(string.match(/.{1,2}/g).map((byte) => parseInt(byte, 16)));
-/**
- * uint8Array -> hexString
- * @param bytes number[]
- * @returns hexString
- */
-const toHex = (bytes) => bytes.reduce((string, byte) => string + byte.toString(16).padStart(2, '0'), '');
-/**
- * number[] -> Uint8Array
- * @param array number[]
- * @returns Uint8Array
- */
-const fromArrayLike = (array) => Uint8Array.from(array);
-/**
- * Uint8Array -> number[]
- * @param uint8Array Uint8Array
- * @returns Uint8Array
- */
-const toArrayLike = (uint8Array) => [...uint8Array.values()];
-const toBase64 = (uint8Array) => index$2.encode(uint8Array);
-const fromBase64 = (string) => index$2.decode(string);
-const toBase58 = (uint8Array) => base58$1.encode(uint8Array);
-const fromBase58 = (string) => base58$1.decode(string);
-const toBase32 = (uint8Array) => index$7.encode(uint8Array);
-const fromBase32 = (string) => index$7.decode(string);
-const toBase16 = (uint8Array) => index$3.encode(uint8Array);
-const fromBase16 = (string) => index$3.decode(string);
-let FormatInterface$2 = class FormatInterface {
-    encoded;
-    constructor(input) {
-        if (input) {
-            if (index$3.isBase16(input))
-                this.encoded = this.fromBase16(input);
-            else if (index$7.isBase32(input))
-                this.encoded = this.fromBase32(input);
-            else if (base58$1.isBase58(input))
-                this.encoded = this.fromBase58(input);
-            else if (index$2.isBase64(input))
-                this.encoded = this.fromBase64(input);
-            else if (typeof input === 'string') {
-                let isCompatible = isTypedArrayCompatible(input);
-                if (isCompatible)
-                    this.encoded = fromUintArrayString(input);
-                else
-                    this.encoded = this.fromString(input); // normal string
-            }
-            else if (typeof input === 'object')
-                this.encoded = this.fromObject(input);
-            else if (input instanceof Uint8Array)
-                this.encoded = input;
-            else if (Array.isArray(input) && isTypedArrayCompatible(input))
-                this.encoded = this.fromArrayLike(input);
-        }
-    }
-    /**
-   * Returns a String as Uint8Array
-   * @param string string to encode to Uint8Array
-   * @returns Uint8Array
-   */
-    fromString(string) {
-        return new TextEncoder().encode(string);
-    }
-    /**
-     * Returns a Uint8Array as String
-     * @param uint8Array Uint8Array to encode to String
-     * @returns String
-     */
-    toString(uint8Array) {
-        return new TextDecoder().decode(uint8Array);
-    }
-    /**
-     * Returns a String as Uint8Array
-     * @param string string to encode to Uint8Array
-     * @returns Uint8Array
-     */
-    fromUintArrayString(string) {
-        return Uint8Array.from(string.split(',').map(string => Number(string)));
-    }
-    /**
-     * Returns a Uint8Array as String
-     * @param uint8Array Uint8Array to encode to String
-     * @returns String
-     */
-    toUintArrayString(uint8Array) {
-        return uint8Array.toString();
-    }
-    /**
-     * hexString -> uint8Array
-     * @param string hex encoded string
-     * @returns UintArray
-     */
-    fromHex(string) {
-        return Uint8Array.from(string.match(/.{1,2}/g).map((byte) => parseInt(byte, 16)));
-    }
-    /**
-     * uint8Array -> hexString
-     * @param bytes number[]
-     * @returns hexString
-     */
-    toHex(bytes) {
-        return bytes.reduce((string, byte) => string + byte.toString(16).padStart(2, '0'), '');
-    }
-    /**
-     * number[] -> Uint8Array
-     * @param array number[]
-     * @returns Uint8Array
-     */
-    fromArrayLike(array) {
-        return Uint8Array.from(array);
-    }
-    /**
-     * Uint8Array -> number[]
-     * @param uint8Array Uint8Array
-     * @returns Uint8Array
-     */
-    toArrayLike(uint8Array) {
-        return [...uint8Array.values()];
-    }
-    fromObject(object) {
-        return new TextEncoder().encode(JSON.stringify(object));
-    }
-    toObject(uint8Array) {
-        return JSON.parse(new TextDecoder().decode(uint8Array));
-    }
-    toBase64(uint8Array) {
-        return index$2.encode(uint8Array);
-    }
-    fromBase64(string) {
-        return index$2.decode(string);
-    }
-    toBase58(uint8Array) {
-        return base58$1.encode(uint8Array);
-    }
-    fromBase58(string) {
-        return base58$1.decode(string);
-    }
-    toBase32(uint8Array) {
-        return index$7.encode(uint8Array);
-    }
-    fromBase32(string) {
-        return index$7.decode(string);
-    }
-    toBase16(uint8Array) {
-        return index$3.encode(uint8Array);
-    }
-    fromBase16(string) {
-        return index$3.decode(string);
-    }
-};
-var index$1 = {
-    fromString: fromString$1,
-    toString: toString$1,
-    fromHex,
-    toHex,
-    fromArrayLike,
-    toArrayLike,
-    fromUintArrayString,
-    toUintArrayString,
-    toBase64,
-    fromBase64,
-    toBase58,
-    fromBase58,
-    toBase32,
-    fromBase32,
-    toBase16,
-    fromBase16,
-    FormatInterface: FormatInterface$2
+/**
+ * Returns a hex string as Binary string
+ * @param string string to encode to binary
+ * @returns binaryString
+ */
+const hexToBinary = (hex) => (parseInt(hex, 16).toString(2)).padStart(8, '0');
+const isTypedArrayCompatible = (possibleUint8Array) => {
+    if (typeof possibleUint8Array === 'string') {
+        possibleUint8Array = possibleUint8Array.split(',').map(number => Number(number));
+        for (const number of possibleUint8Array) {
+            if (isNaN(number))
+                return false;
+        }
+    }
+    for (const number of possibleUint8Array) {
+        if (isNaN(number))
+            return false;
+    }
+    return true;
+};
+/**
+ * Returns a String as Uint8Array
+ * @param string string to encode to Uint8Array
+ * @returns Uint8Array
+ */
+const fromString$1 = (string) => new TextEncoder().encode(string);
+/**
+ * Returns a Uint8Array as String
+ * @param uint8Array Uint8Array to encode to String
+ * @returns String
+ */
+const toString$1 = (uint8Array) => new TextDecoder().decode(uint8Array);
+/**
+ * Returns a String as Uint8Array
+ * @param string string to encode to Uint8Array
+ * @returns Uint8Array
+ */
+const fromUintArrayString = (string) => Uint8Array.from(string.split(',').map(string => Number(string)));
+/**
+ * Returns a Uint8Array as String
+ * @param uint8Array Uint8Array to encode to String
+ * @returns String
+ */
+const toUintArrayString = (uint8Array) => uint8Array.toString();
+/**
+ * hexString -> uint8Array
+ * @param string hex encoded string
+ * @returns UintArray
+ */
+const fromHex = (string) => Uint8Array.from(string.match(/.{1,2}/g).map((byte) => parseInt(byte, 16)));
+/**
+ * uint8Array -> hexString
+ * @param bytes number[]
+ * @returns hexString
+ */
+const toHex = (bytes) => bytes.reduce((string, byte) => string + byte.toString(16).padStart(2, '0'), '');
+/**
+ * number[] -> Uint8Array
+ * @param array number[]
+ * @returns Uint8Array
+ */
+const fromArrayLike = (array) => Uint8Array.from(array);
+/**
+ * Uint8Array -> number[]
+ * @param uint8Array Uint8Array
+ * @returns Uint8Array
+ */
+const toArrayLike = (uint8Array) => [...uint8Array.values()];
+/**
+* object -> Uint8Array
+* @param object any
+* @returns Uint8Array
+*/
+const fromObject = (object) => new TextEncoder().encode(JSON.stringify(object));
+/**
+ * Uint8Array -> Object
+ * @param uint8Array Uint8Array
+ * @returns Object
+ */
+const toObject = (uint8Array) => JSON.parse(new TextDecoder().decode(uint8Array));
+const fromBinary = (string) => fromHex(parseInt(string, 2).toString(16).toUpperCase());
+const toBinary = (uint8Array) => hexToBinary(toHex(uint8Array));
+const toBase64 = (uint8Array) => index$2.encode(uint8Array);
+const fromBase64 = (string) => index$2.decode(string);
+const toBase58 = (uint8Array) => base58$1.encode(uint8Array);
+const fromBase58 = (string) => base58$1.decode(string);
+const toBase32 = (uint8Array) => index$7.encode(uint8Array);
+const fromBase32 = (string) => index$7.decode(string);
+const toBase16 = (uint8Array) => index$3.encode(uint8Array);
+const fromBase16 = (string) => index$3.decode(string);
+let FormatInterface$2 = class FormatInterface {
+    encoded;
+    decoded;
+    constructor(input) {
+        if (input) {
+            if (index$3.isBase16(input))
+                this.encoded = this.fromBase16(input);
+            else if (index$7.isBase32(input))
+                this.encoded = this.fromBase32(input);
+            else if (base58$1.isBase58(input))
+                this.encoded = this.fromBase58(input);
+            else if (index$2.isBase64(input))
+                this.encoded = this.fromBase64(input);
+            else if (typeof input === 'string') {
+                let isCompatible = isTypedArrayCompatible(input);
+                if (isCompatible)
+                    this.encoded = fromUintArrayString(input);
+                else
+                    this.encoded = this.fromString(input); // normal string
+            }
+            else if (typeof input === 'object')
+                this.encoded = this.fromObject(input);
+            else if (input instanceof Uint8Array)
+                this.encoded = input;
+            else if (Array.isArray(input) && isTypedArrayCompatible(input))
+                this.encoded = this.fromArrayLike(input);
+        }
+    }
+    /**
+   * Returns a String as Uint8Array
+   * @param string string to encode to Uint8Array
+   * @returns Uint8Array
+   */
+    fromString = (string) => this.encoded = fromString$1(string);
+    /**
+     * Returns a Uint8Array as String
+     * @param uint8Array Uint8Array to encode to String
+     * @returns String
+     */
+    toString = (uint8Array) => this.decoded = toString$1(uint8Array);
+    /**
+     * Returns a String as Uint8Array
+     * @param string string to encode to Uint8Array
+     * @returns Uint8Array
+     */
+    fromUintArrayString = (string) => this.encoded = fromUintArrayString(string);
+    /**
+     * Returns a Uint8Array as String
+     * @param uint8Array Uint8Array to encode to String
+     * @returns String
+     */
+    toUintArrayString = (uint8Array) => this.decoded = uint8Array.toString();
+    /**
+     * hexString -> uint8Array
+     * @param string hex encoded string
+     * @returns UintArray
+     */
+    fromHex = (string) => this.encoded = fromHex(string);
+    /**
+     * uint8Array -> hexString
+     * @param bytes ArrayLike
+     * @returns hexString
+     */
+    toHex = (arrayLike) => this.decoded = toHex(arrayLike);
+    /**
+     * number[] -> Uint8Array
+     * @param array number[]
+     * @returns Uint8Array
+     */
+    fromArrayLike = (array) => this.encoded = Uint8Array.from(array);
+    /**
+     * Uint8Array -> number[]
+     * @param uint8Array Uint8Array
+     * @returns Uint8Array
+     */
+    toArrayLike = (uint8Array) => this.decoded = [...uint8Array.values()];
+    fromObject = (object) => this.encoded = fromObject(object);
+    toBinary = (uint8Array) => this.decoded = hexToBinary(toHex(uint8Array));
+    fromBinary = (binary) => this.encoded = fromBinary(binary);
+    toObject = (uint8Array) => this.decoded = toObject(uint8Array);
+    toBase64 = (uint8Array) => this.decoded = index$2.encode(uint8Array);
+    fromBase64 = (string) => this.encoded = index$2.decode(string);
+    toBase58 = (uint8Array) => this.decoded = base58$1.encode(uint8Array);
+    fromBase58 = (string) => this.encoded = base58$1.decode(string);
+    toBase32 = (uint8Array) => this.decoded = index$7.encode(uint8Array);
+    fromBase32 = (string) => this.encoded = index$7.decode(string);
+    toBase16 = (uint8Array) => this.decoded = index$3.encode(uint8Array);
+    fromBase16 = (string) => this.decoded = index$3.decode(string);
+};
+var index$1 = {
+    fromString: fromString$1,
+    toString: toString$1,
+    fromHex,
+    toHex,
+    fromArrayLike,
+    toArrayLike,
+    fromUintArrayString,
+    toUintArrayString,
+    toObject,
+    toBinary,
+    fromBinary,
+    toBase64,
+    fromBase64,
+    toBase58,
+    fromBase58,
+    toBase32,
+    fromBase32,
+    toBase16,
+    fromBase16,
+    FormatInterface: FormatInterface$2
 };
 
 const { fromString, toString } = index$1;