@leofcoin/peernet 1.2.17 → 1.2.19

package/exports/browser/{peernet-DoO_MDV_.js → peernet-CkNrFC2s.js}

@@ -1,4 +1,4 @@
-import { b as base, a as base58$1, i as index$2, c as index$3, d as index$4, e as index$5, f as createSHA512, g as createSHA384, h as createSHA256, j as createSHA224, k as createSHA1, I as Identity } from './identity-CqSnKXWH.js';
+import { k as index$2, b as base, a as base58$1, l as index$3, m as index$4, n as index$5, h as createSHA512, g as createSHA384, f as createSHA256, e as createSHA224, d as createSHA1, I as Identity } from './identity-CVOmmghe.js';
 import { K as KeyPath, a as KeyValue } from './value-C3vAp-wb.js';
 
 const getTargets = () => Array.from([]);
@@ -126,36 +126,6 @@ var isHex = string => /^[A-F0-9]+$/i.test(
   string
 );
 
-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$2.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
@@ -3885,7 +3855,7 @@ function ZStream() {
 
 var zstream = ZStream;
 
-const toString$1 = Object.prototype.toString;
+const toString$1$1 = Object.prototype.toString;
 
 /* Public constants ==========================================================*/
 /* ===========================================================================*/
@@ -4037,7 +4007,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;
@@ -4089,7 +4059,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;
@@ -7026,88 +6996,128 @@ 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);
+    return compress ? pako.deflate(index$2(set)) : index$2(set);
 };
+
+const ALPHABET$1 = '0123456789ABCDEF';
+const base16 = base(ALPHABET$1);
+base16.decode;
+base16.encode;
+
+const ALPHABET = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_';
+const base64 = base(ALPHABET);
+base64.decode;
+base64.encode;
+
+/**
+ * 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$3.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$4(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];
@@ -7117,10 +7127,8 @@ const decode = (proto, uint8Array, compressed) => {
     }
     return output;
 };
-var index = {
-    encode,
-    decode
-};
+
+var index = { encode, decode };
 
 const jsonStringifyBigInt = (key, value) => {
     if (typeof value === 'bigint')
@@ -7134,13 +7142,13 @@ const jsonParseBigInt = (key, value) => {
     }
     return value;
 };
-const _textEncoder = new TextEncoder();
-const _textDecoder = new TextDecoder();
 class BasicInterface {
     #encoded;
     #decoded;
     name;
     #proto;
+    textEncoder = new TextEncoder();
+    textDecoder = new TextDecoder();
     get keys() {
         // handles proto keys
         // protokey -> key
@@ -7168,11 +7176,42 @@ 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$3.isBase32(value))
+                        this.fromBs32(value);
+                    else
+                        throw new Error('Invalid base58/base32 input');
+                }
+            }
+            else if (index$3.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;
         // Example: decode as JSON if possible (override in subclass)
         try {
-            return JSON.parse(_textDecoder.decode(encoded), jsonParseBigInt);
+            return JSON.parse(this.textDecoder.decode(encoded), jsonParseBigInt);
         }
         catch {
             return new Object();
@@ -7181,9 +7220,16 @@ class BasicInterface {
     encode(decoded) {
         decoded = decoded || this.decoded;
         // Example: encode as JSON (override in subclass)
-        return _textEncoder.encode(JSON.stringify(decoded, jsonStringifyBigInt));
+        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) {
@@ -7218,13 +7264,13 @@ class BasicInterface {
         return isHex(string);
     }
     isBase32(string) {
-        return index$2.isBase32(string);
+        return index$3.isBase32(string);
     }
     isBase58(string) {
         return base58$1.isBase58(string);
     }
     fromBs32(encoded) {
-        return this.decode(index$2.decode(encoded));
+        return this.decode(index$3.decode(encoded));
     }
     fromBs58(encoded) {
         return this.decode(fromBase58(encoded));
@@ -7250,8 +7296,26 @@ class BasicInterface {
             return this.decode(array);
         return this.decode(Uint8Array.from(array));
     }
-    fromEncoded(encoded) {
-        return this.decode(encoded);
+    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)
@@ -7293,209 +7357,237 @@ class BasicInterface {
     }
 }
 
-const blockchainCodecs = [
-    {
-        name: 'leofcoin-block',
-        codec: '0x6c62',
-        hashAlg: 'dbl-keccak-512',
-    },
-    {
-        name: 'leofcoin-tx',
-        codec: '0x6c74',
-        hashAlg: 'dbl-keccak-512',
-    },
-    {
-        name: 'leofcoin-itx',
-        codec: '0x6c69',
-        hashAlg: 'keccak-512',
-    },
-    {
-        name: 'leofcoin-pr',
-        codec: '0x6c70',
-        hashAlg: 'keccak-256',
-    },
-    {
-        name: 'contract-message',
-        codec: '0x63636d',
-        hashAlg: 'keccak-256'
-    },
-    {
-        name: 'transaction-message',
-        codec: '0x746d',
-        hashAlg: 'keccak-256'
-    },
-    {
-        name: 'raw-transaction-message',
-        codec: '0x772746d',
-        hashAlg: 'keccak-256'
-    },
-    {
-        name: 'block-message',
-        codec: '0x626d',
-        hashAlg: 'keccak-256'
-    },
-    {
-        name: 'bw-message',
-        codec: '0x62776d',
-        hashAlg: 'keccak-256'
-    },
-    {
-        name: 'bw-request-message',
-        codec: '0x6277726d',
-        hashAlg: 'keccak-256'
-    },
-    {
-        name: 'validator-message',
-        codec: '0x766d',
-        hashAlg: 'keccak-256'
-    }
+const blockchainCodecs = [
+    {
+        name: 'leofcoin-block',
+        codec: '0x6c62',
+        hashAlg: 'dbl-keccak-512'
+    },
+    {
+        name: 'leofcoin-tx',
+        codec: '0x6c74',
+        hashAlg: 'dbl-keccak-512'
+    },
+    {
+        name: 'leofcoin-itx',
+        codec: '0x6c69',
+        hashAlg: 'keccak-512'
+    },
+    {
+        name: 'leofcoin-pr',
+        codec: '0x6c70',
+        hashAlg: 'keccak-256'
+    },
+    {
+        name: 'contract-message',
+        codec: '0x63636d',
+        hashAlg: 'keccak-256'
+    },
+    {
+        name: 'transaction-message',
+        codec: '0x746d',
+        hashAlg: 'keccak-256'
+    },
+    {
+        name: 'raw-transaction-message',
+        codec: '0x772746d',
+        hashAlg: 'keccak-256'
+    },
+    {
+        name: 'block-message',
+        codec: '0x626d',
+        hashAlg: 'keccak-256'
+    },
+    {
+        name: 'bw-message',
+        codec: '0x62776d',
+        hashAlg: 'keccak-256'
+    },
+    {
+        name: 'bw-request-message',
+        codec: '0x6277726d',
+        hashAlg: 'keccak-256'
+    },
+    {
+        name: 'validator-message',
+        codec: '0x766d',
+        hashAlg: 'keccak-256'
+    },
+    {
+        name: 'last-block-message',
+        codec: '0x6c626d',
+        hashAlg: 'keccak-256'
+    },
+    {
+        name: 'last-block-request-message',
+        codec: '0x6c62726d',
+        hashAlg: 'keccak-256'
+    },
+    {
+        name: 'state-message',
+        codec: '0x73746d',
+        hashAlg: 'keccak-256'
+    },
+    {
+        name: 'publish-message',
+        codec: '0x70626d',
+        hashAlg: 'keccak-256'
+    }
 ];
-
-const internalCodecs = [
-    {
-        name: 'pubsub-request',
-        codec: '0x70737271',
-        hashAlg: 'keccak-256'
-    },
-    {
-        name: 'pubsub-response',
-        codec: '0x707372',
-        hashAlg: 'keccak-256'
-    }
+const consensusCodecs = [
+    {
+        name: 'proposal-message',
+        codec: '0x70726d',
+        hashAlg: 'keccak-256'
+    },
+    {
+        name: 'prevote-message',
+        codec: '0x70766d',
+        hashAlg: 'keccak-256'
+    },
+    {
+        name: 'precommit-message',
+        codec: '0x7063636d',
+        hashAlg: 'keccak-256'
+    }
 ];
-
-var social = [{
-        name: 'chat-message',
-        codec: '0x70636d',
-        hashAlg: 'dbl-keccak-256',
-    }];
-
-const peernetCodecs = [
-    {
-        name: 'disco-hash',
-        codec: '0x30',
-        hashAlg: 'dbl-keccak-256',
-    },
-    {
-        name: 'peernet-peer-response',
-        codec: '0x707072',
-        hashAlg: 'keccak-256',
-    },
-    {
-        name: 'peernet-peer',
-        codec: '0x7070',
-        hashAlg: 'keccak-256',
-    },
-    {
-        name: 'peernet-dht',
-        codec: '0x706468',
-        hashAlg: 'keccak-256',
-    },
-    {
-        name: 'peernet-dht-response',
-        codec: '0x706472',
-        hashAlg: 'keccak-256',
-    },
-    {
-        name: 'peernet-data',
-        codec: '0x706461',
-        hashAlg: 'keccak-256',
-    },
-    {
-        name: 'peernet-data-response',
-        codec: '0x70646172',
-        hashAlg: 'keccak-256',
-    },
-    {
-        name: 'peernet-message',
-        codec: '0x706d65',
-        hashAlg: 'keccak-256',
-    },
-    {
-        name: 'peernet-ps',
-        codec: '707073',
-        hashAlg: 'keccak-256',
-    },
-    {
-        name: 'peernet-response',
-        codec: '0x7072',
-        hashAlg: 'keccak-256',
-    },
-    {
-        name: 'peernet-request',
-        codec: '0x707271',
-        hashAlg: 'keccak-256',
-    },
-    {
-        name: 'peernet-file',
-        codec: '0x7066',
-        hashAlg: 'keccak-256',
-    },
-    {
-        name: 'peernet-file-response',
-        codec: '0x706672',
-        hashAlg: 'keccak-256',
-    }
+const internalCodecs = [
+    {
+        name: 'pubsub-request',
+        codec: '0x70737271',
+        hashAlg: 'keccak-256'
+    },
+    {
+        name: 'pubsub-response',
+        codec: '0x707372',
+        hashAlg: 'keccak-256'
+    }
 ];
-
-const codecs$1 = [
-    ...internalCodecs,
-    ...blockchainCodecs,
-    ...social,
-    ...peernetCodecs
+const socialCodecs = [
+    {
+        name: 'chat-message',
+        codec: '0x70636d',
+        hashAlg: 'dbl-keccak-256'
+    }
+];
+const peernetCodecs = [
+    {
+        name: 'disco-hash',
+        codec: '0x30',
+        hashAlg: 'dbl-keccak-256'
+    },
+    {
+        name: 'peernet-peer-response',
+        codec: '0x707072',
+        hashAlg: 'keccak-256'
+    },
+    {
+        name: 'peernet-peer',
+        codec: '0x7070',
+        hashAlg: 'keccak-256'
+    },
+    {
+        name: 'peernet-dht',
+        codec: '0x706468',
+        hashAlg: 'keccak-256'
+    },
+    {
+        name: 'peernet-dht-response',
+        codec: '0x706472',
+        hashAlg: 'keccak-256'
+    },
+    {
+        name: 'peernet-data',
+        codec: '0x706461',
+        hashAlg: 'keccak-256'
+    },
+    {
+        name: 'peernet-data-response',
+        codec: '0x70646172',
+        hashAlg: 'keccak-256'
+    },
+    {
+        name: 'peernet-message',
+        codec: '0x706d65',
+        hashAlg: 'keccak-256'
+    },
+    {
+        name: 'peernet-ps',
+        codec: '707073',
+        hashAlg: 'keccak-256'
+    },
+    {
+        name: 'peernet-response',
+        codec: '0x7072',
+        hashAlg: 'keccak-256'
+    },
+    {
+        name: 'peernet-request',
+        codec: '0x707271',
+        hashAlg: 'keccak-256'
+    },
+    {
+        name: 'peernet-file',
+        codec: '0x7066',
+        hashAlg: 'keccak-256'
+    },
+    {
+        name: 'peernet-file-response',
+        codec: '0x706672',
+        hashAlg: 'keccak-256'
+    }
+];
+const codecs = [
+    ...internalCodecs,
+    ...blockchainCodecs,
+    ...consensusCodecs,
+    ...socialCodecs,
+    ...peernetCodecs
 ];
 
-const codecs = {};
-const addCodec = (codecInput) => {
-    let { hashAlg, codec, name } = codecInput;
-    if (!codecs[name])
-        codecs[name] = {
-            hashAlg,
-            codec: typeof codec === 'string' ? parseInt(codec, 16) : codec
-        };
-};
-for (const codec of codecs$1) {
-    addCodec(codec);
-}
-const getCodec = (name) => {
-    if (typeof name === 'number')
-        return name;
-    return getCodecByName(name).codec;
-};
-const getCodecName = (codec) => {
-    return Object.keys(codecs).reduce((p, c) => {
-        const item = codecs[c];
-        if (item.codec === codec)
-            return c;
-        else
-            return p;
-    }, undefined);
-};
-const getCodecByName = (name) => codecs[name];
-const getHashAlg = (name) => {
-    if (typeof name === 'number')
-        return getCodecByName(getCodecName(name)).hashAlg;
-    return getCodecByName(name).hashAlg;
-};
-const isCodec = (codec) => {
-    if (codec.codec !== undefined && codec.hashAlg)
-        return true;
-    return false;
-};
-const validateCodec = (codec) => {
-    if (codec.codec === undefined ||
-        codec.hashAlg === undefined ||
-        codec.name === undefined)
-        throw new Error(`invalid codecInput: ${codec}`);
-};
-var utils = {
-    isCodec,
-    addCodec,
-    getCodec,
-    getHashAlg,
-    getCodecName,
-    validateCodec,
-    codecs: codecs
+const registry = {};
+const addCodec = (codecInput) => {
+    const { hashAlg, codec, name } = codecInput;
+    if (!registry[name])
+        registry[name] = {
+            hashAlg,
+            codec: typeof codec === 'string' ? parseInt(codec, 16) : codec
+        };
+};
+for (const codec of codecs) {
+    addCodec(codec);
+}
+const getCodecByName = (name) => registry[name];
+const getCodecName = (codec) => {
+    return Object.keys(registry).reduce((p, c) => {
+        return registry[c].codec === codec ? c : p;
+    }, undefined);
+};
+const getCodec = (name) => {
+    if (typeof name === 'number')
+        return name;
+    return getCodecByName(name).codec;
+};
+const getHashAlg = (name) => {
+    if (typeof name === 'number')
+        return getCodecByName(getCodecName(name)).hashAlg;
+    return getCodecByName(name).hashAlg;
+};
+const isCodec = (codec) => {
+    return codec.codec !== undefined && !!codec.hashAlg;
+};
+const validateCodec = (codec) => {
+    if (codec.codec === undefined || codec.hashAlg === undefined || codec.name === undefined)
+        throw new Error(`invalid codecInput: ${codec}`);
+};
+const utils = {
+    isCodec,
+    addCodec,
+    getCodec,
+    getHashAlg,
+    getCodecName,
+    validateCodec,
+    codecs: registry
 };
 
 let Codec$1 = class Codec extends BasicInterface {
@@ -7742,34 +7834,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;
+    init(value) {
+        if (value instanceof FormatInterface && value?.name === this.name) {
+            return value;
         }
-        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 if (typeof buffer === 'object' && buffer !== null) {
-            this.create(buffer);
-        }
-        else {
-            // Explicitly reject all other types (number, boolean, undefined, symbol, function, null)
-            throw new TypeError(`Invalid input type for FormatInterface: ${typeof buffer}`);
-        }
-        return this;
+        return this.from(value);
     }
     hasCodec() {
         if (!this.encoded)
@@ -7887,13 +7956,13 @@ let FormatInterface$1 = class FormatInterface extends BasicInterface {
         this.encoded = buffer;
         return this.hasCodec()
             ? this.decode()
-            : this.create(JSON.parse(BasicInterface._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(BasicInterface._textDecoder.decode(this.encoded), jsonParseBigInt));
+            : this.create(JSON.parse(this.textDecoder.decode(this.encoded), jsonParseBigInt));
     }
     /**
      * @param {Object} data
@@ -8475,7 +8544,7 @@ class Peernet {
         await getAddress();
         this.storePrefix = options.storePrefix;
         this.root = options.root;
-        const { RequestMessage, ResponseMessage, PeerMessage, PeerMessageResponse, PeernetMessage, DHTMessage, DHTMessageResponse, DataMessage, DataMessageResponse, PsMessage, ChatMessage, PeernetFile } = await import(/* webpackChunkName: "messages" */ './messages-B1x_wCLa.js');
+        const { RequestMessage, ResponseMessage, PeerMessage, PeerMessageResponse, PeernetMessage, DHTMessage, DHTMessageResponse, DataMessage, DataMessageResponse, PsMessage, ChatMessage, PeernetFile } = await import(/* webpackChunkName: "messages" */ './messages-CVgBNJyv.js');
         /**
          * proto Object containing protos
          * @type {Object}
@@ -8522,7 +8591,7 @@ class Peernet {
         if (this.#starting || this.#started)
             return;
         this.#starting = true;
-        const importee = await import('./client-otmI2TFk.js');
+        const importee = await import('./client-DoGApAbT.js');
         /**
          * @access public
          * @type {PeernetClient}