@leofcoin/workers 1.5.27 → 1.5.28

package/exports/{worker-CPvGlmOu.js → worker-BrtyXRJ7.js}

@@ -325,53 +325,6 @@ var index$3 = (input, prefix) => {
     return typedArray;
 };
 
-var index$2 = (typedArray, prefix) => {
-    const set = [];
-    const varintAndSub = (typedArray) => {
-        const length = index$4.decode(typedArray);
-        // remove length
-        typedArray = typedArray.subarray(index$4.decode.bytes);
-        // push value
-        set.push(typedArray.subarray(0, length));
-        // remove value
-        typedArray = typedArray.subarray(length);
-        if (typedArray.length !== 0)
-            return varintAndSub(typedArray);
-        return set;
-    };
-    return varintAndSub(typedArray);
-};
-
-const ALPHABET$1 = '0123456789ABCDEF';
-base(ALPHABET$1);
-
-const ALPHABET = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_';
-base(ALPHABET);
-
-/**
- * Returns a Uint8Array as String
- * @param uint8Array Uint8Array to encode to String
- * @returns String
- */
-const toString$3 = (uint8Array) => new TextDecoder().decode(uint8Array);
-/**
- * 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'), '');
-const toBase58 = (uint8Array) => base58$1.encode(uint8Array);
-const fromBase58 = (string) => base58$1.decode(string);
-const toBase32 = (uint8Array) => index$5.encode(uint8Array);
-var index$1 = {
-    toString: toString$3};
-
 /*! pako 2.1.0 https://github.com/nodeca/pako @license (MIT AND Zlib) */
 // (C) 1995-2013 Jean-loup Gailly and Mark Adler
 // (C) 2014-2017 Vitaly Puzrin and Andrey Tupitsin
@@ -4101,7 +4054,7 @@ function ZStream() {
 
 var zstream = ZStream;
 
-const toString$1 = Object.prototype.toString;
+const toString$1$1 = Object.prototype.toString;
 
 /* Public constants ==========================================================*/
 /* ===========================================================================*/
@@ -4253,7 +4206,7 @@ function Deflate$1(options) {
     if (typeof opt.dictionary === 'string') {
       // If we need to compress text, change encoding to utf8.
       dict = strings.string2buf(opt.dictionary);
-    } else if (toString$1.call(opt.dictionary) === '[object ArrayBuffer]') {
+    } else if (toString$1$1.call(opt.dictionary) === '[object ArrayBuffer]') {
       dict = new Uint8Array(opt.dictionary);
     } else {
       dict = opt.dictionary;
@@ -4305,7 +4258,7 @@ Deflate$1.prototype.push = function (data, flush_mode) {
   if (typeof data === 'string') {
     // If we need to compress text, change encoding to utf8.
     strm.input = strings.string2buf(data);
-  } else if (toString$1.call(data) === '[object ArrayBuffer]') {
+  } else if (toString$1$1.call(data) === '[object ArrayBuffer]') {
     strm.input = new Uint8Array(data);
   } else {
     strm.input = data;
@@ -7242,88 +7195,141 @@ var pako = {
 };
 
 const jsonStringifyBigInt$1 = (key, value) => (typeof value === 'bigint' ? { $bigint: value.toString() } : value);
-const jsonParseBigInt$1 = (key, value) => typeof value === 'object' && value.$bigint ? BigInt(value.$bigint) : value;
+const jsonParseBigInt$1 = (key, value) => typeof value === 'object' && value?.$bigint ? BigInt(value.$bigint) : value;
 
-const { toString } = index$1;
-const isString = (type) => type === 'string';
-const isNumber = (type) => type === 'number';
-const isBoolean = (type) => type === 'boolean';
-const isUint8Array = (type) => type === 'uint8Array';
-const isBigInt = (type) => type === 'bigint';
+const tokenCache = new WeakMap();
 const tokenize = (key, value) => {
     const optional = key.endsWith('?');
     let type = value === undefined ? key : value;
     if (type instanceof Uint8Array)
         type = 'uint8Array';
-    else if (type instanceof BigInt)
+    else if (typeof type === 'bigint')
         type = 'bigint';
     else
         type = Array.isArray(type) ? 'array' : typeof type;
     const parts = key.split('?');
-    const minimumLength = parts[2]?.includes('min') ? parts[2].split['min:'][1] : 0;
-    return { type, optional, key: parts[0], minimumLength };
+    const minimumLength = parts[2]?.includes('min') ? Number(parts[2].split('min:')[1]) : 0;
+    return { type, optional, key: parts[0], minimumLength, defaultValue: value };
 };
+const getTokens = (proto) => {
+    if (tokenCache.has(proto))
+        return tokenCache.get(proto);
+    const keys = Object.keys(proto);
+    const values = Object.values(proto);
+    const tokens = keys.map((k, i) => tokenize(k, values[i]));
+    tokenCache.set(proto, tokens);
+    return tokens;
+};
+
+const encoder = new TextEncoder();
 const toType = (data) => {
-    // always return uint8Arrays as they are
     if (data instanceof Uint8Array)
         return data;
-    // returns the ArrayBuffer as UintArray
     if (data instanceof ArrayBuffer)
         return new Uint8Array(data);
-    // returns the BigTnt string as UintArray
     if (typeof data === 'bigint')
-        return new TextEncoder().encode(data.toString());
-    // returns the string as UintArray
+        return encoder.encode(data.toString());
     if (typeof data === 'string')
-        return new TextEncoder().encode(data);
-    // returns the object as UintArray
+        return encoder.encode(data);
     if (typeof data === 'object')
-        return new TextEncoder().encode(JSON.stringify(data, jsonStringifyBigInt$1));
-    // returns the number as UintArray
+        return encoder.encode(JSON.stringify(data, jsonStringifyBigInt$1));
     if (typeof data === 'number' || typeof data === 'boolean')
-        return new TextEncoder().encode(data.toString());
+        return encoder.encode(data.toString());
     throw new Error(`unsuported type ${typeof data || data}`);
 };
 const encode = (proto, input, compress) => {
-    const keys = Object.keys(proto);
-    const values = Object.values(proto);
+    const tokens = getTokens(proto);
     const set = [];
-    for (let i = 0; i < values.length; i++) {
-        const token = tokenize(keys[i], values[i]);
+    for (let i = 0; i < tokens.length; i++) {
+        const token = tokens[i];
         const data = input[token.key];
         if (!token.optional && data === undefined)
             throw new Error(`missing required property: ${token.key}`);
         if ((token.type === 'array' && token.minimumLength > data?.length) ||
             (token.type === 'object' && token.minimumLength > Object.keys(data).length))
             throw new Error(`minimumLength for ${token.key} is set to ${token.minimumLength} but got ${data.length}`);
-        // always push data to the set.
-        // when data is undefined push the default value of the proto
-        set.push(toType(data || values[i]));
+        set.push(toType(data !== undefined ? data : token.defaultValue));
     }
     return compress ? pako.deflate(index$3(set)) : index$3(set);
 };
+
+var index$2 = (typedArray, prefix) => {
+    const set = [];
+    const varintAndSub = (typedArray) => {
+        const length = index$4.decode(typedArray);
+        // remove length
+        typedArray = typedArray.subarray(index$4.decode.bytes);
+        // push value
+        set.push(typedArray.subarray(0, length));
+        // remove value
+        typedArray = typedArray.subarray(length);
+        if (typedArray.length !== 0)
+            return varintAndSub(typedArray);
+        return set;
+    };
+    return varintAndSub(typedArray);
+};
+
+const ALPHABET$1 = '0123456789ABCDEF';
+base(ALPHABET$1);
+
+const ALPHABET = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_';
+base(ALPHABET);
+
+/**
+ * Returns a Uint8Array as String
+ * @param uint8Array Uint8Array to encode to String
+ * @returns String
+ */
+const toString$1 = (uint8Array) => new TextDecoder().decode(uint8Array);
+/**
+ * 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);
+const toBase58 = (uint8Array) => base58$1.encode(uint8Array);
+const fromBase58 = (string) => base58$1.decode(string);
+const toBase32 = (uint8Array) => index$5.encode(uint8Array);
+var index$1 = {
+    toString: toString$1};
+
+const { toString } = index$1;
+const decoder = new TextDecoder();
 const decode = (proto, uint8Array, compressed) => {
     if (compressed)
         uint8Array = pako.inflate(uint8Array);
     let deconcated = index$2(uint8Array);
     const output = {};
-    const keys = Object.keys(proto);
-    const values = Object.values(proto);
-    if (keys.length !== deconcated.length)
-        console.warn(`length mismatch: expected  ${keys.length} got ${uint8Array.length}`);
-    for (let i = 0; i < values.length; i++) {
-        const token = tokenize(keys[i], values[i]);
-        if (isUint8Array(token.type))
+    const tokens = getTokens(proto);
+    if (tokens.length !== deconcated.length)
+        console.warn(`length mismatch: expected  ${tokens.length} got ${uint8Array.length}`);
+    for (let i = 0; i < tokens.length; i++) {
+        const token = tokens[i];
+        if (token.type === 'uint8Array')
             output[token.key] = deconcated[i];
-        else if (isString(token.type))
+        else if (token.type === 'string')
             output[token.key] = toString(deconcated[i]);
-        else if (isBoolean(token.type))
-            output[token.key] = new TextDecoder().decode(deconcated[i]) === 'true';
-        else if (isNumber(token.type))
-            output[token.key] = Number(new TextDecoder().decode(deconcated[i]));
-        else if (isBigInt(token.type))
-            output[token.key] = BigInt(new TextDecoder().decode(deconcated[i]));
-        else output[token.key] = JSON.parse(new TextDecoder().decode(deconcated[i]), jsonParseBigInt$1);
+        else if (token.type === 'boolean')
+            output[token.key] = decoder.decode(deconcated[i]) === 'true';
+        else if (token.type === 'number')
+            output[token.key] = Number(decoder.decode(deconcated[i]));
+        else if (token.type === 'bigint')
+            output[token.key] = BigInt(decoder.decode(deconcated[i]));
+        else if (token.type === 'object' || token.type === 'array')
+            output[token.key] = JSON.parse(decoder.decode(deconcated[i]), jsonParseBigInt$1);
         if (token.optional) {
             if (!output[token.key] || output[token.key].length === 0)
                 delete output[token.key];
@@ -7333,18 +7339,28 @@ const decode = (proto, uint8Array, compressed) => {
     }
     return output;
 };
-var index = {
-    encode,
-    decode
-};
 
-const jsonStringifyBigInt = (key, value) => typeof value === 'bigint' ? { $bigint: value.toString() } : value;
-const jsonParseBigInt = (key, value) => typeof value === 'object' && value.$bigint ? BigInt(value.$bigint) : value;
+var index = { encode, decode };
+
+const jsonStringifyBigInt = (key, value) => {
+    if (typeof value === 'bigint')
+        return { $bigint: value.toString() };
+    return value;
+};
+const jsonParseBigInt = (key, value) => {
+    if (typeof value === 'object' && value) {
+        if (value.$bigint)
+            return BigInt(value.$bigint);
+    }
+    return value;
+};
 class BasicInterface {
     #encoded;
     #decoded;
     name;
     #proto;
+    textEncoder = new TextEncoder();
+    textDecoder = new TextDecoder();
     get keys() {
         // handles proto keys
         // protokey -> key
@@ -7372,22 +7388,89 @@ class BasicInterface {
     get proto() {
         return this.#proto;
     }
+    from(value) {
+        if (value instanceof Uint8Array)
+            this.fromUint8Array(value);
+        else if (value instanceof ArrayBuffer)
+            this.fromArrayBuffer(value);
+        else if (typeof value === 'string' && isHex(value)) {
+            this.fromHex(value);
+        }
+        else if (typeof value === 'string') {
+            if (base58$1.isBase58(value)) {
+                try {
+                    this.fromBs58(value);
+                }
+                catch {
+                    if (index$5.isBase32(value))
+                        this.fromBs32(value);
+                    else
+                        throw new Error('Invalid base58/base32 input');
+                }
+            }
+            else if (index$5.isBase32(value))
+                this.fromBs32(value);
+            else
+                this.fromString(value);
+        }
+        else if (Array.isArray(value))
+            this.fromArray(value);
+        else if (typeof value === 'object')
+            this.create(value);
+        return this;
+    }
     decode(encoded) {
         encoded = encoded || this.encoded;
-        return new Object();
+        // Example: decode as JSON if possible (override in subclass)
+        try {
+            return JSON.parse(this.textDecoder.decode(encoded), jsonParseBigInt);
+        }
+        catch {
+            return new Object();
+        }
     }
     encode(decoded) {
         decoded = decoded || this.decoded;
-        return new Uint8Array();
+        // Example: encode as JSON (override in subclass)
+        return this.textEncoder.encode(JSON.stringify(decoded, jsonStringifyBigInt));
     }
     // get Codec(): Codec {}
+    create(options) {
+        for (const key of this.keys) {
+            if (options[key]) {
+                this[key] = options[key];
+            }
+        }
+    }
+    // Cache proto keys/values for reuse
+    static _protoCache = new WeakMap();
     protoEncode(data) {
-        // check schema
+        let cache = BasicInterface._protoCache.get(this.proto);
+        if (!cache) {
+            cache = {
+                keys: Object.keys(this.proto),
+                values: Object.values(this.proto)
+            };
+            BasicInterface._protoCache.set(this.proto, cache);
+        }
+        // Use proto.encode directly, but avoid new array allocations inside encode if possible
         return index.encode(this.proto, data, false);
     }
     protoDecode(data) {
-        // check schema
-        return index.decode(this.proto, data, false);
+        // Use a static output object if possible (not thread-safe, but safe for single-threaded use)
+        if (!this._decodeOutput)
+            this._decodeOutput = {};
+        const result = index.decode(this.proto, data, false);
+        // Copy properties to static object to avoid new allocations
+        Object.keys(result).forEach((k) => {
+            this._decodeOutput[k] = result[k];
+        });
+        // Remove any keys not in result
+        Object.keys(this._decodeOutput).forEach((k) => {
+            if (!(k in result))
+                delete this._decodeOutput[k];
+        });
+        return this._decodeOutput;
     }
     isHex(string) {
         return isHex(string);
@@ -7420,23 +7503,50 @@ class BasicInterface {
         return this.decode(fromHex(string));
     }
     fromArray(array) {
-        return this.decode(Uint8Array.from([...array]));
-    }
-    fromEncoded(encoded) {
-        return this.decode(encoded);
+        // Avoid unnecessary copy if already Uint8Array
+        if (array instanceof Uint8Array)
+            return this.decode(array);
+        return this.decode(Uint8Array.from(array));
+    }
+    fromArrayBuffer(uint8Array) {
+        return fromArrayLike(new Uint8Array(uint8Array));
+    }
+    fromUint8Array(uint8Array) {
+        return fromArrayLike(uint8Array);
+    }
+    toUint8Array(format) {
+        if (format === 'bs32')
+            return toBase32(this.encoded);
+        if (format === 'bs58')
+            return toBase58(this.encoded);
+        if (format === 'hex')
+            return toHex(this.encoded);
+        if (format === 'utf8')
+            return this.encoded.toString();
+        if (format === 'uint8Array')
+            return this.encoded;
+        if (format === 'uint8ArrayString')
+            return this.encoded.toString();
+        throw new Error(`Unknown format: ${format}`);
     }
     toString() {
         if (!this.encoded)
             this.encode();
-        return this.encoded.toString();
+        // Use cached string if available
+        if (!this._string)
+            this._string = Array.prototype.join.call(this.encoded, ',');
+        return this._string;
     }
     toHex() {
         if (!this.encoded)
             this.encode();
-        return toHex(this.encoded
-            .toString()
-            .split(',')
-            .map((number) => Number(number)));
+        // Use cached hex if available
+        if (!this._hex) {
+            if (!this._string)
+                this._string = Array.prototype.join.call(this.encoded, ',');
+            this._hex = toHex(this._string.split(',').map(Number));
+        }
+        return this._hex;
     }
     /**
      * @return {String} encoded
@@ -7444,7 +7554,10 @@ class BasicInterface {
     toBs32() {
         if (!this.encoded)
             this.encode();
-        return toBase32(this.encoded);
+        // Use cached bs32 if available
+        if (!this._bs32)
+            this._bs32 = toBase32(this.encoded);
+        return this._bs32;
     }
     /**
      * @return {String} encoded
@@ -7703,9 +7816,10 @@ class Codec extends BasicInterface {
                 else
                     this.fromString(buffer);
             }
-            if (!isNaN(buffer))
+            else if (typeof buffer === 'number') {
                 if (utils.getCodec(buffer))
                     this.fromCodec(buffer);
+            }
         }
     }
     fromEncoded(encoded) {
@@ -7762,11 +7876,603 @@ class Codec extends BasicInterface {
     }
 }
 
+/*!
+ * hash-wasm (https://www.npmjs.com/package/hash-wasm)
+ * (c) Dani Biro
+ * @license MIT
+ */
+
+
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+/* global Reflect, Promise, SuppressedError, Symbol, Iterator */
+
+
+function __awaiter(thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, [])).next());
+    });
+}
+
+typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+};
+
+class Mutex {
+    constructor() {
+        this.mutex = Promise.resolve();
+    }
+    lock() {
+        let begin = () => { };
+        this.mutex = this.mutex.then(() => new Promise(begin));
+        return new Promise((res) => {
+            begin = res;
+        });
+    }
+    dispatch(fn) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const unlock = yield this.lock();
+            try {
+                return yield Promise.resolve(fn());
+            }
+            finally {
+                unlock();
+            }
+        });
+    }
+}
+
+var _a;
+function getGlobal() {
+    if (typeof globalThis !== "undefined")
+        return globalThis;
+    if (typeof self !== "undefined")
+        return self;
+    if (typeof window !== "undefined")
+        return window;
+    return global;
+}
+const globalObject = getGlobal();
+const nodeBuffer = (_a = globalObject.Buffer) !== null && _a !== void 0 ? _a : null;
+const textEncoder = globalObject.TextEncoder
+    ? new globalObject.TextEncoder()
+    : null;
+function hexCharCodesToInt(a, b) {
+    return ((((a & 0xf) + ((a >> 6) | ((a >> 3) & 0x8))) << 4) |
+        ((b & 0xf) + ((b >> 6) | ((b >> 3) & 0x8))));
+}
+function writeHexToUInt8(buf, str) {
+    const size = str.length >> 1;
+    for (let i = 0; i < size; i++) {
+        const index = i << 1;
+        buf[i] = hexCharCodesToInt(str.charCodeAt(index), str.charCodeAt(index + 1));
+    }
+}
+function hexStringEqualsUInt8(str, buf) {
+    if (str.length !== buf.length * 2) {
+        return false;
+    }
+    for (let i = 0; i < buf.length; i++) {
+        const strIndex = i << 1;
+        if (buf[i] !==
+            hexCharCodesToInt(str.charCodeAt(strIndex), str.charCodeAt(strIndex + 1))) {
+            return false;
+        }
+    }
+    return true;
+}
+const alpha = "a".charCodeAt(0) - 10;
+const digit = "0".charCodeAt(0);
+function getDigestHex(tmpBuffer, input, hashLength) {
+    let p = 0;
+    for (let i = 0; i < hashLength; i++) {
+        let nibble = input[i] >>> 4;
+        tmpBuffer[p++] = nibble > 9 ? nibble + alpha : nibble + digit;
+        nibble = input[i] & 0xf;
+        tmpBuffer[p++] = nibble > 9 ? nibble + alpha : nibble + digit;
+    }
+    return String.fromCharCode.apply(null, tmpBuffer);
+}
+const getUInt8Buffer = nodeBuffer !== null
+    ? (data) => {
+        if (typeof data === "string") {
+            const buf = nodeBuffer.from(data, "utf8");
+            return new Uint8Array(buf.buffer, buf.byteOffset, buf.length);
+        }
+        if (nodeBuffer.isBuffer(data)) {
+            return new Uint8Array(data.buffer, data.byteOffset, data.length);
+        }
+        if (ArrayBuffer.isView(data)) {
+            return new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+        }
+        throw new Error("Invalid data type!");
+    }
+    : (data) => {
+        if (typeof data === "string") {
+            return textEncoder.encode(data);
+        }
+        if (ArrayBuffer.isView(data)) {
+            return new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+        }
+        throw new Error("Invalid data type!");
+    };
+const base64Chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+const base64Lookup = new Uint8Array(256);
+for (let i = 0; i < base64Chars.length; i++) {
+    base64Lookup[base64Chars.charCodeAt(i)] = i;
+}
+function getDecodeBase64Length(data) {
+    let bufferLength = Math.floor(data.length * 0.75);
+    const len = data.length;
+    if (data[len - 1] === "=") {
+        bufferLength -= 1;
+        if (data[len - 2] === "=") {
+            bufferLength -= 1;
+        }
+    }
+    return bufferLength;
+}
+function decodeBase64(data) {
+    const bufferLength = getDecodeBase64Length(data);
+    const len = data.length;
+    const bytes = new Uint8Array(bufferLength);
+    let p = 0;
+    for (let i = 0; i < len; i += 4) {
+        const encoded1 = base64Lookup[data.charCodeAt(i)];
+        const encoded2 = base64Lookup[data.charCodeAt(i + 1)];
+        const encoded3 = base64Lookup[data.charCodeAt(i + 2)];
+        const encoded4 = base64Lookup[data.charCodeAt(i + 3)];
+        bytes[p] = (encoded1 << 2) | (encoded2 >> 4);
+        p += 1;
+        bytes[p] = ((encoded2 & 15) << 4) | (encoded3 >> 2);
+        p += 1;
+        bytes[p] = ((encoded3 & 3) << 6) | (encoded4 & 63);
+        p += 1;
+    }
+    return bytes;
+}
+
+const MAX_HEAP = 16 * 1024;
+const WASM_FUNC_HASH_LENGTH = 4;
+const wasmMutex = new Mutex();
+const wasmModuleCache = new Map();
+function WASMInterface(binary, hashLength) {
+    return __awaiter(this, void 0, void 0, function* () {
+        let wasmInstance = null;
+        let memoryView = null;
+        let initialized = false;
+        if (typeof WebAssembly === "undefined") {
+            throw new Error("WebAssembly is not supported in this environment!");
+        }
+        const writeMemory = (data, offset = 0) => {
+            memoryView.set(data, offset);
+        };
+        const getMemory = () => memoryView;
+        const getExports = () => wasmInstance.exports;
+        const setMemorySize = (totalSize) => {
+            wasmInstance.exports.Hash_SetMemorySize(totalSize);
+            const arrayOffset = wasmInstance.exports.Hash_GetBuffer();
+            const memoryBuffer = wasmInstance.exports.memory.buffer;
+            memoryView = new Uint8Array(memoryBuffer, arrayOffset, totalSize);
+        };
+        const getStateSize = () => {
+            const view = new DataView(wasmInstance.exports.memory.buffer);
+            const stateSize = view.getUint32(wasmInstance.exports.STATE_SIZE, true);
+            return stateSize;
+        };
+        const loadWASMPromise = wasmMutex.dispatch(() => __awaiter(this, void 0, void 0, function* () {
+            if (!wasmModuleCache.has(binary.name)) {
+                const asm = decodeBase64(binary.data);
+                const promise = WebAssembly.compile(asm);
+                wasmModuleCache.set(binary.name, promise);
+            }
+            const module = yield wasmModuleCache.get(binary.name);
+            wasmInstance = yield WebAssembly.instantiate(module, {
+            // env: {
+            //   emscripten_memcpy_big: (dest, src, num) => {
+            //     const memoryBuffer = wasmInstance.exports.memory.buffer;
+            //     const memView = new Uint8Array(memoryBuffer, 0);
+            //     memView.set(memView.subarray(src, src + num), dest);
+            //   },
+            //   print_memory: (offset, len) => {
+            //     const memoryBuffer = wasmInstance.exports.memory.buffer;
+            //     const memView = new Uint8Array(memoryBuffer, 0);
+            //     console.log('print_int32', memView.subarray(offset, offset + len));
+            //   },
+            // },
+            });
+            // wasmInstance.exports._start();
+        }));
+        const setupInterface = () => __awaiter(this, void 0, void 0, function* () {
+            if (!wasmInstance) {
+                yield loadWASMPromise;
+            }
+            const arrayOffset = wasmInstance.exports.Hash_GetBuffer();
+            const memoryBuffer = wasmInstance.exports.memory.buffer;
+            memoryView = new Uint8Array(memoryBuffer, arrayOffset, MAX_HEAP);
+        });
+        const init = (bits = null) => {
+            initialized = true;
+            wasmInstance.exports.Hash_Init(bits);
+        };
+        const updateUInt8Array = (data) => {
+            let read = 0;
+            while (read < data.length) {
+                const chunk = data.subarray(read, read + MAX_HEAP);
+                read += chunk.length;
+                memoryView.set(chunk);
+                wasmInstance.exports.Hash_Update(chunk.length);
+            }
+        };
+        const update = (data) => {
+            if (!initialized) {
+                throw new Error("update() called before init()");
+            }
+            const Uint8Buffer = getUInt8Buffer(data);
+            updateUInt8Array(Uint8Buffer);
+        };
+        const digestChars = new Uint8Array(hashLength * 2);
+        const digest = (outputType, padding = null) => {
+            if (!initialized) {
+                throw new Error("digest() called before init()");
+            }
+            initialized = false;
+            wasmInstance.exports.Hash_Final(padding);
+            if (outputType === "binary") {
+                // the data is copied to allow GC of the original memory object
+                return memoryView.slice(0, hashLength);
+            }
+            return getDigestHex(digestChars, memoryView, hashLength);
+        };
+        const save = () => {
+            if (!initialized) {
+                throw new Error("save() can only be called after init() and before digest()");
+            }
+            const stateOffset = wasmInstance.exports.Hash_GetState();
+            const stateLength = getStateSize();
+            const memoryBuffer = wasmInstance.exports.memory.buffer;
+            const internalState = new Uint8Array(memoryBuffer, stateOffset, stateLength);
+            // prefix is 4 bytes from SHA1 hash of the WASM binary
+            // it is used to detect incompatible internal states between different versions of hash-wasm
+            const prefixedState = new Uint8Array(WASM_FUNC_HASH_LENGTH + stateLength);
+            writeHexToUInt8(prefixedState, binary.hash);
+            prefixedState.set(internalState, WASM_FUNC_HASH_LENGTH);
+            return prefixedState;
+        };
+        const load = (state) => {
+            if (!(state instanceof Uint8Array)) {
+                throw new Error("load() expects an Uint8Array generated by save()");
+            }
+            const stateOffset = wasmInstance.exports.Hash_GetState();
+            const stateLength = getStateSize();
+            const overallLength = WASM_FUNC_HASH_LENGTH + stateLength;
+            const memoryBuffer = wasmInstance.exports.memory.buffer;
+            if (state.length !== overallLength) {
+                throw new Error(`Bad state length (expected ${overallLength} bytes, got ${state.length})`);
+            }
+            if (!hexStringEqualsUInt8(binary.hash, state.subarray(0, WASM_FUNC_HASH_LENGTH))) {
+                throw new Error("This state was written by an incompatible hash implementation");
+            }
+            const internalState = state.subarray(WASM_FUNC_HASH_LENGTH);
+            new Uint8Array(memoryBuffer, stateOffset, stateLength).set(internalState);
+            initialized = true;
+        };
+        const isDataShort = (data) => {
+            if (typeof data === "string") {
+                // worst case is 4 bytes / char
+                return data.length < MAX_HEAP / 4;
+            }
+            return data.byteLength < MAX_HEAP;
+        };
+        let canSimplify = isDataShort;
+        switch (binary.name) {
+            case "argon2":
+            case "scrypt":
+                canSimplify = () => true;
+                break;
+            case "blake2b":
+            case "blake2s":
+                // if there is a key at blake2 then cannot simplify
+                canSimplify = (data, initParam) => initParam <= 512 && isDataShort(data);
+                break;
+            case "blake3":
+                // if there is a key at blake3 then cannot simplify
+                canSimplify = (data, initParam) => initParam === 0 && isDataShort(data);
+                break;
+            case "xxhash64": // cannot simplify
+            case "xxhash3":
+            case "xxhash128":
+            case "crc64":
+                canSimplify = () => false;
+                break;
+        }
+        // shorthand for (init + update + digest) for better performance
+        const calculate = (data, initParam = null, digestParam = null) => {
+            if (!canSimplify(data, initParam)) {
+                init(initParam);
+                update(data);
+                return digest("hex", digestParam);
+            }
+            const buffer = getUInt8Buffer(data);
+            memoryView.set(buffer);
+            wasmInstance.exports.Hash_Calculate(buffer.length, initParam, digestParam);
+            return getDigestHex(digestChars, memoryView, hashLength);
+        };
+        yield setupInterface();
+        return {
+            getMemory,
+            writeMemory,
+            getExports,
+            setMemorySize,
+            init,
+            update,
+            digest,
+            save,
+            load,
+            calculate,
+            hashLength,
+        };
+    });
+}
+
+new Mutex();
+
+new Mutex();
+
+new Mutex();
+
+new Mutex();
+
+new Mutex();
+
+new Mutex();
+
+new Mutex();
+
+new Mutex();
+
+var name$c = "sha1";
+var data$c = "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";
+var hash$c = "6b530c24";
+var wasmJson$c = {
+	name: name$c,
+	data: data$c,
+	hash: hash$c
+};
+
+new Mutex();
+/**
+ * Creates a new SHA-1 hash instance
+ */
+function createSHA1() {
+    return WASMInterface(wasmJson$c, 20).then((wasm) => {
+        wasm.init();
+        const obj = {
+            init: () => {
+                wasm.init();
+                return obj;
+            },
+            update: (data) => {
+                wasm.update(data);
+                return obj;
+            },
+            // biome-ignore lint/suspicious/noExplicitAny: Conflict with IHasher type
+            digest: (outputType) => wasm.digest(outputType),
+            save: () => wasm.save(),
+            load: (data) => {
+                wasm.load(data);
+                return obj;
+            },
+            blockSize: 64,
+            digestSize: 20,
+        };
+        return obj;
+    });
+}
+
+new Mutex();
+
+new Mutex();
+
+var name$a = "sha256";
+var data$a = "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";
+var hash$a = "8c18dd94";
+var wasmJson$a = {
+	name: name$a,
+	data: data$a,
+	hash: hash$a
+};
+
+new Mutex();
+/**
+ * Creates a new SHA-2 (SHA-224) hash instance
+ */
+function createSHA224() {
+    return WASMInterface(wasmJson$a, 28).then((wasm) => {
+        wasm.init(224);
+        const obj = {
+            init: () => {
+                wasm.init(224);
+                return obj;
+            },
+            update: (data) => {
+                wasm.update(data);
+                return obj;
+            },
+            // biome-ignore lint/suspicious/noExplicitAny: Conflict with IHasher type
+            digest: (outputType) => wasm.digest(outputType),
+            save: () => wasm.save(),
+            load: (data) => {
+                wasm.load(data);
+                return obj;
+            },
+            blockSize: 64,
+            digestSize: 28,
+        };
+        return obj;
+    });
+}
+
+new Mutex();
+/**
+ * Creates a new SHA-2 (SHA-256) hash instance
+ */
+function createSHA256() {
+    return WASMInterface(wasmJson$a, 32).then((wasm) => {
+        wasm.init(256);
+        const obj = {
+            init: () => {
+                wasm.init(256);
+                return obj;
+            },
+            update: (data) => {
+                wasm.update(data);
+                return obj;
+            },
+            // biome-ignore lint/suspicious/noExplicitAny: Conflict with IHasher type
+            digest: (outputType) => wasm.digest(outputType),
+            save: () => wasm.save(),
+            load: (data) => {
+                wasm.load(data);
+                return obj;
+            },
+            blockSize: 64,
+            digestSize: 32,
+        };
+        return obj;
+    });
+}
+
+var name$9 = "sha512";
+var data$9 = "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";
+var hash$9 = "f2e40eb1";
+var wasmJson$9 = {
+	name: name$9,
+	data: data$9,
+	hash: hash$9
+};
+
+new Mutex();
+/**
+ * Creates a new SHA-2 (SHA-384) hash instance
+ */
+function createSHA384() {
+    return WASMInterface(wasmJson$9, 48).then((wasm) => {
+        wasm.init(384);
+        const obj = {
+            init: () => {
+                wasm.init(384);
+                return obj;
+            },
+            update: (data) => {
+                wasm.update(data);
+                return obj;
+            },
+            // biome-ignore lint/suspicious/noExplicitAny: Conflict with IHasher type
+            digest: (outputType) => wasm.digest(outputType),
+            save: () => wasm.save(),
+            load: (data) => {
+                wasm.load(data);
+                return obj;
+            },
+            blockSize: 128,
+            digestSize: 48,
+        };
+        return obj;
+    });
+}
+
+new Mutex();
+/**
+ * Creates a new SHA-2 (SHA-512) hash instance
+ */
+function createSHA512() {
+    return WASMInterface(wasmJson$9, 64).then((wasm) => {
+        wasm.init(512);
+        const obj = {
+            init: () => {
+                wasm.init(512);
+                return obj;
+            },
+            update: (data) => {
+                wasm.update(data);
+                return obj;
+            },
+            // biome-ignore lint/suspicious/noExplicitAny: Conflict with IHasher type
+            digest: (outputType) => wasm.digest(outputType),
+            save: () => wasm.save(),
+            load: (data) => {
+                wasm.load(data);
+                return obj;
+            },
+            blockSize: 128,
+            digestSize: 64,
+        };
+        return obj;
+    });
+}
+
+new Mutex();
+
+new Mutex();
+
+new Mutex();
+
+new Mutex();
+
+new Mutex();
+
+new Mutex();
+
+new Mutex();
+
+const createHasher = (hashVariant) => {
+    switch (hashVariant) {
+        case 1:
+            return createSHA1();
+        case 224:
+            return createSHA224();
+        case 256:
+            return createSHA256();
+        case 384:
+            return createSHA384();
+        case 512:
+            return createSHA512();
+        default:
+            throw new Error(`unsupported hash variant: ${hashVariant}`);
+    }
+};
+const digestBuffer = async (hashVariant, buffer) => {
+    const view = buffer instanceof Uint8Array ? buffer : new Uint8Array(buffer);
+    const hasher = await createHasher(hashVariant);
+    hasher.init();
+    hasher.update(view);
+    const digest = hasher.digest('binary');
+    return digest instanceof Uint8Array ? digest : new Uint8Array(digest);
+};
 class CodecHash extends BasicInterface {
     codec;
     discoCodec;
     size;
-    constructor(buffer, options) {
+    codecs;
+    constructor(options = { name: 'disco-hash', codecs: {} }) {
         super();
         if (options?.name)
             this.name = options.name;
@@ -7774,33 +8480,24 @@ class CodecHash extends BasicInterface {
             this.name = 'disco-hash';
         if (options?.codecs)
             this.codecs = options.codecs;
-        return this.init(buffer);
     }
     async init(uint8Array) {
         if (uint8Array) {
-            if (uint8Array instanceof Uint8Array) {
-                this.discoCodec = new Codec(uint8Array);
-                const name = this.discoCodec.name;
-                if (name) {
-                    this.name = name;
-                    this.decode(uint8Array);
-                }
-                else {
-                    await this.encode(uint8Array);
-                }
+            if (!(uint8Array instanceof Uint8Array)) {
+                throw new Error('CodecHash only supports Uint8Array input');
             }
-            if (typeof uint8Array === 'string') {
-                if (this.isHex(uint8Array))
-                    await this.fromHex(uint8Array);
-                if (this.isBase32(uint8Array))
-                    await this.fromBs32(uint8Array);
-                else if (this.isBase58(uint8Array))
-                    await this.fromBs58(uint8Array);
-                else
-                    throw new Error(`unsupported string ${uint8Array}`);
+            // For large buffers, only check first bytes for codec prefix
+            // Codec prefixes are small (varint encoded), so 100 bytes is more than enough
+            const checkBuffer = uint8Array.length > 100 ? uint8Array.subarray(0, 100) : uint8Array;
+            this.discoCodec = new Codec(checkBuffer);
+            const name = this.discoCodec.name;
+            if (name) {
+                this.name = name;
+                this.decode(uint8Array);
+            }
+            else {
+                await this.encode(uint8Array);
             }
-            else if (typeof uint8Array === 'object')
-                await this.fromJSON(uint8Array);
         }
         return this;
     }
@@ -7820,34 +8517,19 @@ class CodecHash extends BasicInterface {
     get hash() {
         return this.encoded;
     }
-    fromJSON(json) {
-        return this.encode(new TextEncoder().encode(JSON.stringify(json, jsonStringifyBigInt)));
-    }
     async encode(buffer, name) {
         if (!this.name && name)
             this.name = name;
         if (!buffer)
-            buffer = this.buffer;
+            throw new Error('buffer is required for encoding');
         this.discoCodec = new Codec(this.name);
-        this.discoCodec.fromName(this.name);
         let hashAlg = this.discoCodec.hashAlg;
         const hashVariant = Number(hashAlg.split('-')[hashAlg.split('-').length - 1]);
         if (hashAlg.includes('dbl')) {
             hashAlg = hashAlg.replace('dbl-', '');
-            // const hasher = await createKeccak(hashVariant)
-            // await hasher.init()
-            // hasher.update(buffer)
-            // buffer = hasher.digest('binary')
-            buffer = await crypto.subtle.digest(`SHA-${hashVariant}`, buffer);
-        }
-        // const hasher = await createKeccak(hashVariant)
-        // await hasher.init()
-        // hasher.update(buffer)
-        // this.digest = hasher.digest('binary')
-        this.digest = await crypto.subtle.digest(`SHA-${hashVariant}`, buffer);
-        if (this.digest instanceof ArrayBuffer) {
-            this.digest = new Uint8Array(this.digest);
+            buffer = await digestBuffer(hashVariant, buffer);
         }
+        this.digest = await digestBuffer(hashVariant, buffer);
         this.size = this.digest.length;
         this.codec = this.discoCodec.encode();
         this.codec = this.discoCodec.codecBuffer;
@@ -7858,23 +8540,16 @@ class CodecHash extends BasicInterface {
         return this.encoded;
     }
     async validate(buffer) {
-        if (Buffer.isBuffer(buffer)) {
-            const codec = index$4.decode(buffer);
-            if (this.codecs[codec]) {
-                this.decode(buffer);
-            }
-            else {
-                await this.encode(buffer);
-            }
+        if (!(buffer instanceof Uint8Array)) {
+            throw new Error('CodecHash only supports Uint8Array input');
+        }
+        const codec = index$4.decode(buffer);
+        if (this.codecs[codec]) {
+            this.decode(buffer);
         }
-        if (typeof buffer === 'string') {
-            if (this.isHex(buffer))
-                this.fromHex(buffer);
-            if (this.isBase32(buffer))
-                this.fromBs32(buffer);
+        else {
+            await this.encode(buffer);
         }
-        if (typeof buffer === 'object')
-            this.fromJSON(buffer);
     }
     decode(buffer) {
         this.encoded = buffer;
@@ -7885,7 +8560,7 @@ class CodecHash extends BasicInterface {
         this.size = index$4.decode(buffer);
         this.digest = buffer.slice(index$4.decode.bytes);
         if (this.digest.length !== this.size) {
-            throw new Error(`hash length inconsistent: 0x${this.encoded.toString('hex')}`);
+            throw new Error(`hash length inconsistent: 0x${this.encoded.toString()}`);
         }
         // const discoCodec = new Codec(codec, this.codecs)
         this.name = this.discoCodec.name;
@@ -7910,27 +8585,11 @@ let FormatInterface$1 = class FormatInterface extends BasicInterface {
     set encoded(value) {
         this.#encoded = value;
     }
-    init(buffer) {
-        if (buffer instanceof FormatInterface && buffer?.name === this.name)
-            return buffer;
-        else if (buffer instanceof Uint8Array)
-            this.fromUint8Array(buffer);
-        else if (buffer instanceof ArrayBuffer)
-            this.fromArrayBuffer(buffer);
-        else if (typeof buffer === 'string') {
-            if (this.isHex(buffer))
-                this.fromHex(buffer);
-            else if (this.isBase58(buffer))
-                this.fromBs58(buffer);
-            else if (this.isBase32(buffer))
-                this.fromBs32(buffer);
-            else
-                this.fromString(buffer);
-        }
-        else {
-            this.create(buffer);
+    init(value) {
+        if (value instanceof FormatInterface && value?.name === this.name) {
+            return value;
         }
-        return this;
+        return this.from(value);
     }
     hasCodec() {
         if (!this.encoded)
@@ -7992,17 +8651,46 @@ let FormatInterface$1 = class FormatInterface extends BasicInterface {
         const upper = this.hashFormat.charAt(0).toUpperCase();
         return `${upper}${this.hashFormat.substring(1, this.hashFormat.length)}`;
     }
+    /**
+     * Extract content bytes without codec prefix
+     */
+    get contentBytes() {
+        if (!this.encoded)
+            return new Uint8Array(0);
+        const codec = new Codec(this.encoded);
+        if (codec.codecBuffer) {
+            return this.encoded.slice(codec.codecBuffer.length);
+        }
+        return this.encoded;
+    }
     beforeHashing(decoded) {
-        delete decoded.hash;
+        // Avoid copying if not needed
+        if (decoded && Object.prototype.hasOwnProperty.call(decoded, 'hash')) {
+            // Only copy if hash is present
+            const rest = { ...decoded };
+            delete rest.hash;
+            return rest;
+        }
         return decoded;
     }
     /**
      * @return {PeernetHash}
      */
     get peernetHash() {
+        // Optimize: if decoded has no hash property, contentBytes are already correct
+        // Since protoEncode is deterministic (varint-based), we can use them directly
+        if (this.encoded &&
+            this.decoded &&
+            !Object.prototype.hasOwnProperty.call(this.decoded, 'hash')) {
+            // @ts-ignore
+            const hash = new CodecHash({ name: this.name });
+            return hash.init(this.contentBytes);
+        }
+        // Fallback: must re-encode without hash property
         const decoded = this.beforeHashing({ ...this.decoded });
         // @ts-ignore
-        return new CodecHash(decoded, { name: this.name });
+        const hash = new CodecHash({ name: this.name });
+        return hash.init(decoded);
     }
     /**
      * @return {peernetHash}
@@ -8019,13 +8707,13 @@ let FormatInterface$1 = class FormatInterface extends BasicInterface {
         this.encoded = buffer;
         return this.hasCodec()
             ? this.decode()
-            : this.create(JSON.parse(new TextDecoder().decode(this.encoded), jsonParseBigInt));
+            : this.create(JSON.parse(this.textDecoder.decode(this.encoded), jsonParseBigInt));
     }
     fromArrayBuffer(buffer) {
         this.encoded = new Uint8Array(buffer, buffer.byteOffset, buffer.byteLength);
         return this.hasCodec()
             ? this.decode()
-            : this.create(JSON.parse(new TextDecoder().decode(this.encoded), jsonParseBigInt));
+            : this.create(JSON.parse(this.textDecoder.decode(this.encoded), jsonParseBigInt));
     }
     /**
      * @param {Object} data
@@ -8045,6 +8733,9 @@ let FormatInterface$1 = class FormatInterface extends BasicInterface {
     }
 };
 
+/**
+ * Interface for defining codec formats
+ */
 const FormatInterface = FormatInterface$1;
 
 var proto$3 = {
@@ -8071,7 +8762,10 @@ var proto$2 = {
     reward: BigInt(0),
     fees: BigInt(0),
     transactions: Array(),
-    validators: new Uint8Array()
+    validators: new Uint8Array(),
+    producer: String(),
+    producerProof: String(),
+    protocolVersion: String()
 };
 
 class BlockMessage extends FormatInterface {
@@ -8162,82 +8856,121 @@ class TransactionMessage extends FormatInterface {
 ({
     params: Array()});
 
-class EasyWorker {
-  #messageEvent = 'message'
-  #errorEvent = 'error'
-  #isBrowser = false
-  #isWorker = false
-
-  get isWorker() {
-    return this.#isWorker
-  }
-  constructor(url, options) {
-    return this.#init(url, options)
-  }
-
-  #init(url, options = {}) {
-    if (url) {
-      if (globalThis.Worker) {
-        this.#isBrowser = true;
-        this.worker = new Worker(url, {...options});
-      } else {
-        return new Promise(async (resolve, reject) => {
-          const {fork} = await import('child_process');  
-          this.worker = fork(url, ['easy-worker-child'], options);
-          resolve(this);
-        })
-      }
-    } else {
-      this.#isWorker = true;
-      if (globalThis.process?.argv[2] === 'easy-worker-child') {
-        this.worker = process;
-      } else {
-        this.#isBrowser = true;
-        this.worker = globalThis;
-      }
-    }
-    
-    return this
-  }
-
-  onmessage(fn) {
-    if (this.#isBrowser) this.worker.onmessage = ({data}) => fn(data);
-    else this.worker.on(this.#messageEvent, fn);
-  }
-
-  postMessage(message) {
-    if (this.#isBrowser) this.worker.postMessage(message);
-    else this.worker.send(message);
-  }
-
-  terminate() {
-    if (this.#isBrowser) this.worker.terminate();
-    else this.worker.kill();
-  }
-
-  onerror(fn) {
-    if (this.#isBrowser) this.worker.onerror = fn;
-    else this.worker.on(this.#errorEvent, fn);
-  }
-
-  /**
-   * 
-   * @param {*} data 
-   * @returns {Promise} resolves result onmessage & rejects on error
-   */
-  once(data) {
-    return new Promise((resolve, reject) => {
-      this.onmessage(message => {
-        resolve(message);
-        this.terminate();
-      });
-      this.onerror(error => {
-        reject(error);
-        this.terminate();
-      });
-      this.postMessage(data);
-    })    
-  }  
+class EasyWorker {
+    #messageEvent = 'message';
+    #errorEvent = 'error';
+    #isBrowser = false;
+    #isWorker = false;
+    #messageHandler = null;
+    #errorHandler = null;
+    worker;
+    get isWorker() {
+        return this.#isWorker;
+    }
+    constructor(url, options) {
+        return this.#init(url, options);
+    }
+    #init(url, options = {}) {
+        if (url) {
+            if (globalThis.Worker) {
+                this.#isBrowser = true;
+                this.worker = new Worker(url, { ...options });
+            }
+            else {
+                return new Promise((resolve, reject) => {
+                    import('child_process').then(({ fork }) => {
+                        const child = fork(url, ['easy-worker-child'], options);
+                        child.once('error', reject);
+                        this.worker = child;
+                        resolve(this);
+                    }).catch(reject);
+                });
+            }
+        }
+        else {
+            this.#isWorker = true;
+            if (globalThis.process?.argv[2] === 'easy-worker-child') {
+                this.worker = process;
+            }
+            else {
+                this.#isBrowser = true;
+                this.worker = globalThis;
+            }
+        }
+        return this;
+    }
+    onmessage(fn) {
+        if (this.#isBrowser) {
+            this.worker.onmessage = ({ data }) => fn(data);
+        }
+        else {
+            if (this.#messageHandler)
+                this.worker.off(this.#messageEvent, this.#messageHandler);
+            this.#messageHandler = fn;
+            this.worker.on(this.#messageEvent, fn);
+        }
+    }
+    postMessage(message) {
+        if (this.#isBrowser)
+            this.worker.postMessage(message);
+        else
+            this.worker.send(message);
+    }
+    terminate() {
+        if (this.#isBrowser)
+            this.worker.terminate();
+        else
+            this.worker.kill();
+    }
+    onerror(fn) {
+        if (this.#isBrowser) {
+            this.worker.onerror = fn;
+        }
+        else {
+            if (this.#errorHandler)
+                this.worker.off(this.#errorEvent, this.#errorHandler);
+            this.#errorHandler = fn;
+            this.worker.on(this.#errorEvent, fn);
+        }
+    }
+    /**
+     *
+     * @param {*} data
+     * @returns {Promise} resolves result onmessage & rejects on error
+     */
+    once(data) {
+        return new Promise((resolve, reject) => {
+            if (this.#isBrowser) {
+                const handleMessage = ({ data: result }) => {
+                    this.worker.onerror = null;
+                    resolve(result);
+                    this.terminate();
+                };
+                const handleError = (error) => {
+                    this.worker.onmessage = null;
+                    reject(error);
+                    this.terminate();
+                };
+                this.worker.onmessage = handleMessage;
+                this.worker.onerror = handleError;
+            }
+            else {
+                const handleMessage = (result) => {
+                    this.worker.off(this.#errorEvent, handleError);
+                    resolve(result);
+                    this.terminate();
+                };
+                const handleError = (error) => {
+                    this.worker.off(this.#messageEvent, handleMessage);
+                    reject(error);
+                    this.terminate();
+                };
+                this.worker.once(this.#messageEvent, handleMessage);
+                this.worker.once(this.#errorEvent, handleError);
+            }
+            this.postMessage(data);
+        });
+    }
 }
 
 export { BlockMessage as B, ContractMessage as C, EasyWorker as E, TransactionMessage as T };