@leofcoin/peernet 1.2.8 → 1.2.10

package/exports/browser/{peernet-BYkqPZ2L.js → peernet-CCZ65IdF.js}

@@ -1,4 +1,4 @@
-import { b as base$1, 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 { 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 KeyPath, a as KeyValue } from './value-C3vAp-wb.js';
 
 const getTargets = () => Array.from([]);
@@ -127,10 +127,10 @@ var isHex = string => /^[A-F0-9]+$/i.test(
 );
 
 const ALPHABET$1 = '0123456789ABCDEF';
-base$1(ALPHABET$1);
+base(ALPHABET$1);
 
 const ALPHABET = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_';
-base$1(ALPHABET);
+base(ALPHABET);
 
 /**
  * Returns a Uint8Array as String
@@ -7068,7 +7068,7 @@ const toType = (data) => {
         return new TextEncoder().encode(data.toString());
     throw new Error(`unsuported type ${typeof data || data}`);
 };
-const encode$2 = (proto, input, compress) => {
+const encode = (proto, input, compress) => {
     const keys = Object.keys(proto);
     const values = Object.values(proto);
     const set = [];
@@ -7086,7 +7086,7 @@ const encode$2 = (proto, input, compress) => {
     }
     return compress ? pako.deflate(index$3(set)) : index$3(set);
 };
-const decode$4 = (proto, uint8Array, compressed) => {
+const decode = (proto, uint8Array, compressed) => {
     if (compressed)
         uint8Array = pako.inflate(uint8Array);
     let deconcated = index$4(uint8Array);
@@ -7118,43 +7118,19 @@ const decode$4 = (proto, uint8Array, compressed) => {
     return output;
 };
 var index = {
-    encode: encode$2,
-    decode: decode$4
+    encode,
+    decode
 };
 
-const BASE64_CHUNK_SIZE = 0x8000;
-const uint8ArrayToBase64 = (value) => {
-    if (typeof Buffer !== 'undefined')
-        return Buffer.from(value).toString('base64');
-    let binary = '';
-    for (let offset = 0; offset < value.length; offset += BASE64_CHUNK_SIZE) {
-        const slice = value.subarray(offset, offset + BASE64_CHUNK_SIZE);
-        binary += String.fromCharCode(...slice);
-    }
-    return btoa(binary);
-};
-const base64ToUint8Array = (value) => {
-    if (typeof Buffer !== 'undefined')
-        return new Uint8Array(Buffer.from(value, 'base64'));
-    const binary = atob(value);
-    const output = new Uint8Array(binary.length);
-    for (let i = 0; i < binary.length; i++)
-        output[i] = binary.charCodeAt(i);
-    return output;
-};
 const jsonStringifyBigInt = (key, value) => {
     if (typeof value === 'bigint')
         return { $bigint: value.toString() };
-    if (value instanceof Uint8Array)
-        return { $uint8array: uint8ArrayToBase64(value) };
     return value;
 };
 const jsonParseBigInt = (key, value) => {
     if (typeof value === 'object' && value) {
         if (value.$bigint)
             return BigInt(value.$bigint);
-        if (value.$uint8array)
-            return base64ToUint8Array(value.$uint8array);
     }
     return value;
 };
@@ -7522,7 +7498,7 @@ var utils = {
     codecs: codecs
 };
 
-let Codec$2 = class Codec extends BasicInterface {
+let Codec$1 = class Codec extends BasicInterface {
     codecBuffer;
     codec;
     hashAlg;
@@ -7564,9 +7540,10 @@ let Codec$2 = 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) {
@@ -7623,997 +7600,7 @@ let Codec$2 = class Codec extends BasicInterface {
     }
 };
 
-function equals$1(aa, bb) {
-    if (aa === bb) {
-        return true;
-    }
-    if (aa.byteLength !== bb.byteLength) {
-        return false;
-    }
-    for (let ii = 0; ii < aa.byteLength; ii++) {
-        if (aa[ii] !== bb[ii]) {
-            return false;
-        }
-    }
-    return true;
-}
-function coerce(o) {
-    if (o instanceof Uint8Array && o.constructor.name === 'Uint8Array') {
-        return o;
-    }
-    if (o instanceof ArrayBuffer) {
-        return new Uint8Array(o);
-    }
-    if (ArrayBuffer.isView(o)) {
-        return new Uint8Array(o.buffer, o.byteOffset, o.byteLength);
-    }
-    throw new Error('Unknown type, must be binary type');
-}
-
-/* eslint-disable */
-// base-x encoding / decoding
-// Copyright (c) 2018 base-x contributors
-// Copyright (c) 2014-2018 The Bitcoin Core developers (base58.cpp)
-// Distributed under the MIT software license, see the accompanying
-// file LICENSE or http://www.opensource.org/licenses/mit-license.php.
-/**
- * @param {string} ALPHABET
- * @param {any} name
- */
-function base(ALPHABET, name) {
-    if (ALPHABET.length >= 255) {
-        throw new TypeError('Alphabet too long');
-    }
-    var BASE_MAP = new Uint8Array(256);
-    for (var j = 0; j < BASE_MAP.length; j++) {
-        BASE_MAP[j] = 255;
-    }
-    for (var i = 0; i < ALPHABET.length; i++) {
-        var x = ALPHABET.charAt(i);
-        var xc = x.charCodeAt(0);
-        if (BASE_MAP[xc] !== 255) {
-            throw new TypeError(x + ' is ambiguous');
-        }
-        BASE_MAP[xc] = i;
-    }
-    var BASE = ALPHABET.length;
-    var LEADER = ALPHABET.charAt(0);
-    var FACTOR = Math.log(BASE) / Math.log(256); // log(BASE) / log(256), rounded up
-    var iFACTOR = Math.log(256) / Math.log(BASE); // log(256) / log(BASE), rounded up
-    /**
-     * @param {any[] | Iterable<number>} source
-     */
-    function encode(source) {
-        // @ts-ignore
-        if (source instanceof Uint8Array)
-            ;
-        else if (ArrayBuffer.isView(source)) {
-            source = new Uint8Array(source.buffer, source.byteOffset, source.byteLength);
-        }
-        else if (Array.isArray(source)) {
-            source = Uint8Array.from(source);
-        }
-        if (!(source instanceof Uint8Array)) {
-            throw new TypeError('Expected Uint8Array');
-        }
-        if (source.length === 0) {
-            return '';
-        }
-        // Skip & count leading zeroes.
-        var zeroes = 0;
-        var length = 0;
-        var pbegin = 0;
-        var pend = source.length;
-        while (pbegin !== pend && source[pbegin] === 0) {
-            pbegin++;
-            zeroes++;
-        }
-        // Allocate enough space in big-endian base58 representation.
-        var size = ((pend - pbegin) * iFACTOR + 1) >>> 0;
-        var b58 = new Uint8Array(size);
-        // Process the bytes.
-        while (pbegin !== pend) {
-            var carry = source[pbegin];
-            // Apply "b58 = b58 * 256 + ch".
-            var i = 0;
-            for (var it1 = size - 1; (carry !== 0 || i < length) && (it1 !== -1); it1--, i++) {
-                carry += (256 * b58[it1]) >>> 0;
-                b58[it1] = (carry % BASE) >>> 0;
-                carry = (carry / BASE) >>> 0;
-            }
-            if (carry !== 0) {
-                throw new Error('Non-zero carry');
-            }
-            length = i;
-            pbegin++;
-        }
-        // Skip leading zeroes in base58 result.
-        var it2 = size - length;
-        while (it2 !== size && b58[it2] === 0) {
-            it2++;
-        }
-        // Translate the result into a string.
-        var str = LEADER.repeat(zeroes);
-        for (; it2 < size; ++it2) {
-            str += ALPHABET.charAt(b58[it2]);
-        }
-        return str;
-    }
-    /**
-     * @param {string | string[]} source
-     */
-    function decodeUnsafe(source) {
-        if (typeof source !== 'string') {
-            throw new TypeError('Expected String');
-        }
-        if (source.length === 0) {
-            return new Uint8Array();
-        }
-        var psz = 0;
-        // Skip leading spaces.
-        if (source[psz] === ' ') {
-            return;
-        }
-        // Skip and count leading '1's.
-        var zeroes = 0;
-        var length = 0;
-        while (source[psz] === LEADER) {
-            zeroes++;
-            psz++;
-        }
-        // Allocate enough space in big-endian base256 representation.
-        var size = (((source.length - psz) * FACTOR) + 1) >>> 0; // log(58) / log(256), rounded up.
-        var b256 = new Uint8Array(size);
-        // Process the characters.
-        while (source[psz]) {
-            // Decode character
-            var carry = BASE_MAP[source.charCodeAt(psz)];
-            // Invalid character
-            if (carry === 255) {
-                return;
-            }
-            var i = 0;
-            for (var it3 = size - 1; (carry !== 0 || i < length) && (it3 !== -1); it3--, i++) {
-                carry += (BASE * b256[it3]) >>> 0;
-                b256[it3] = (carry % 256) >>> 0;
-                carry = (carry / 256) >>> 0;
-            }
-            if (carry !== 0) {
-                throw new Error('Non-zero carry');
-            }
-            length = i;
-            psz++;
-        }
-        // Skip trailing spaces.
-        if (source[psz] === ' ') {
-            return;
-        }
-        // Skip leading zeroes in b256.
-        var it4 = size - length;
-        while (it4 !== size && b256[it4] === 0) {
-            it4++;
-        }
-        var vch = new Uint8Array(zeroes + (size - it4));
-        var j = zeroes;
-        while (it4 !== size) {
-            vch[j++] = b256[it4++];
-        }
-        return vch;
-    }
-    /**
-     * @param {string | string[]} string
-     */
-    function decode(string) {
-        var buffer = decodeUnsafe(string);
-        if (buffer) {
-            return buffer;
-        }
-        throw new Error(`Non-${name} character`);
-    }
-    return {
-        encode: encode,
-        decodeUnsafe: decodeUnsafe,
-        decode: decode
-    };
-}
-var src = base;
-var _brrp__multiformats_scope_baseX = src;
-
-/**
- * Class represents both BaseEncoder and MultibaseEncoder meaning it
- * can be used to encode to multibase or base encode without multibase
- * prefix.
- */
-class Encoder {
-    name;
-    prefix;
-    baseEncode;
-    constructor(name, prefix, baseEncode) {
-        this.name = name;
-        this.prefix = prefix;
-        this.baseEncode = baseEncode;
-    }
-    encode(bytes) {
-        if (bytes instanceof Uint8Array) {
-            return `${this.prefix}${this.baseEncode(bytes)}`;
-        }
-        else {
-            throw Error('Unknown type, must be binary type');
-        }
-    }
-}
-/**
- * Class represents both BaseDecoder and MultibaseDecoder so it could be used
- * to decode multibases (with matching prefix) or just base decode strings
- * with corresponding base encoding.
- */
-class Decoder {
-    name;
-    prefix;
-    baseDecode;
-    prefixCodePoint;
-    constructor(name, prefix, baseDecode) {
-        this.name = name;
-        this.prefix = prefix;
-        const prefixCodePoint = prefix.codePointAt(0);
-        /* c8 ignore next 3 */
-        if (prefixCodePoint === undefined) {
-            throw new Error('Invalid prefix character');
-        }
-        this.prefixCodePoint = prefixCodePoint;
-        this.baseDecode = baseDecode;
-    }
-    decode(text) {
-        if (typeof text === 'string') {
-            if (text.codePointAt(0) !== this.prefixCodePoint) {
-                throw Error(`Unable to decode multibase string ${JSON.stringify(text)}, ${this.name} decoder only supports inputs prefixed with ${this.prefix}`);
-            }
-            return this.baseDecode(text.slice(this.prefix.length));
-        }
-        else {
-            throw Error('Can only multibase decode strings');
-        }
-    }
-    or(decoder) {
-        return or(this, decoder);
-    }
-}
-class ComposedDecoder {
-    decoders;
-    constructor(decoders) {
-        this.decoders = decoders;
-    }
-    or(decoder) {
-        return or(this, decoder);
-    }
-    decode(input) {
-        const prefix = input[0];
-        const decoder = this.decoders[prefix];
-        if (decoder != null) {
-            return decoder.decode(input);
-        }
-        else {
-            throw RangeError(`Unable to decode multibase string ${JSON.stringify(input)}, only inputs prefixed with ${Object.keys(this.decoders)} are supported`);
-        }
-    }
-}
-function or(left, right) {
-    return new ComposedDecoder({
-        ...(left.decoders ?? { [left.prefix]: left }),
-        ...(right.decoders ?? { [right.prefix]: right })
-    });
-}
-let Codec$1 = class Codec {
-    name;
-    prefix;
-    baseEncode;
-    baseDecode;
-    encoder;
-    decoder;
-    constructor(name, prefix, baseEncode, baseDecode) {
-        this.name = name;
-        this.prefix = prefix;
-        this.baseEncode = baseEncode;
-        this.baseDecode = baseDecode;
-        this.encoder = new Encoder(name, prefix, baseEncode);
-        this.decoder = new Decoder(name, prefix, baseDecode);
-    }
-    encode(input) {
-        return this.encoder.encode(input);
-    }
-    decode(input) {
-        return this.decoder.decode(input);
-    }
-};
-function from({ name, prefix, encode, decode }) {
-    return new Codec$1(name, prefix, encode, decode);
-}
-function baseX({ name, prefix, alphabet }) {
-    const { encode, decode } = _brrp__multiformats_scope_baseX(alphabet, name);
-    return from({
-        prefix,
-        name,
-        encode,
-        decode: (text) => coerce(decode(text))
-    });
-}
-function decode$3(string, alphabetIdx, bitsPerChar, name) {
-    // Count the padding bytes:
-    let end = string.length;
-    while (string[end - 1] === '=') {
-        --end;
-    }
-    // Allocate the output:
-    const out = new Uint8Array((end * bitsPerChar / 8) | 0);
-    // Parse the data:
-    let bits = 0; // Number of bits currently in the buffer
-    let buffer = 0; // Bits waiting to be written out, MSB first
-    let written = 0; // Next byte to write
-    for (let i = 0; i < end; ++i) {
-        // Read one character from the string:
-        const value = alphabetIdx[string[i]];
-        if (value === undefined) {
-            throw new SyntaxError(`Non-${name} character`);
-        }
-        // Append the bits to the buffer:
-        buffer = (buffer << bitsPerChar) | value;
-        bits += bitsPerChar;
-        // Write out some bits if the buffer has a byte's worth:
-        if (bits >= 8) {
-            bits -= 8;
-            out[written++] = 0xff & (buffer >> bits);
-        }
-    }
-    // Verify that we have received just enough bits:
-    if (bits >= bitsPerChar || (0xff & (buffer << (8 - bits))) !== 0) {
-        throw new SyntaxError('Unexpected end of data');
-    }
-    return out;
-}
-function encode$1(data, alphabet, bitsPerChar) {
-    const pad = alphabet[alphabet.length - 1] === '=';
-    const mask = (1 << bitsPerChar) - 1;
-    let out = '';
-    let bits = 0; // Number of bits currently in the buffer
-    let buffer = 0; // Bits waiting to be written out, MSB first
-    for (let i = 0; i < data.length; ++i) {
-        // Slurp data into the buffer:
-        buffer = (buffer << 8) | data[i];
-        bits += 8;
-        // Write out as much as we can:
-        while (bits > bitsPerChar) {
-            bits -= bitsPerChar;
-            out += alphabet[mask & (buffer >> bits)];
-        }
-    }
-    // Partial character:
-    if (bits !== 0) {
-        out += alphabet[mask & (buffer << (bitsPerChar - bits))];
-    }
-    // Add padding characters until we hit a byte boundary:
-    if (pad) {
-        while (((out.length * bitsPerChar) & 7) !== 0) {
-            out += '=';
-        }
-    }
-    return out;
-}
-function createAlphabetIdx(alphabet) {
-    // Build the character lookup table:
-    const alphabetIdx = {};
-    for (let i = 0; i < alphabet.length; ++i) {
-        alphabetIdx[alphabet[i]] = i;
-    }
-    return alphabetIdx;
-}
-/**
- * RFC4648 Factory
- */
-function rfc4648({ name, prefix, bitsPerChar, alphabet }) {
-    const alphabetIdx = createAlphabetIdx(alphabet);
-    return from({
-        prefix,
-        name,
-        encode(input) {
-            return encode$1(input, alphabet, bitsPerChar);
-        },
-        decode(input) {
-            return decode$3(input, alphabetIdx, bitsPerChar, name);
-        }
-    });
-}
-
-const base32 = rfc4648({
-    prefix: 'b',
-    name: 'base32',
-    alphabet: 'abcdefghijklmnopqrstuvwxyz234567',
-    bitsPerChar: 5
-});
-rfc4648({
-    prefix: 'B',
-    name: 'base32upper',
-    alphabet: 'ABCDEFGHIJKLMNOPQRSTUVWXYZ234567',
-    bitsPerChar: 5
-});
-rfc4648({
-    prefix: 'c',
-    name: 'base32pad',
-    alphabet: 'abcdefghijklmnopqrstuvwxyz234567=',
-    bitsPerChar: 5
-});
-rfc4648({
-    prefix: 'C',
-    name: 'base32padupper',
-    alphabet: 'ABCDEFGHIJKLMNOPQRSTUVWXYZ234567=',
-    bitsPerChar: 5
-});
-rfc4648({
-    prefix: 'v',
-    name: 'base32hex',
-    alphabet: '0123456789abcdefghijklmnopqrstuv',
-    bitsPerChar: 5
-});
-rfc4648({
-    prefix: 'V',
-    name: 'base32hexupper',
-    alphabet: '0123456789ABCDEFGHIJKLMNOPQRSTUV',
-    bitsPerChar: 5
-});
-rfc4648({
-    prefix: 't',
-    name: 'base32hexpad',
-    alphabet: '0123456789abcdefghijklmnopqrstuv=',
-    bitsPerChar: 5
-});
-rfc4648({
-    prefix: 'T',
-    name: 'base32hexpadupper',
-    alphabet: '0123456789ABCDEFGHIJKLMNOPQRSTUV=',
-    bitsPerChar: 5
-});
-rfc4648({
-    prefix: 'h',
-    name: 'base32z',
-    alphabet: 'ybndrfg8ejkmcpqxot1uwisza345h769',
-    bitsPerChar: 5
-});
-
-const base36 = baseX({
-    prefix: 'k',
-    name: 'base36',
-    alphabet: '0123456789abcdefghijklmnopqrstuvwxyz'
-});
-baseX({
-    prefix: 'K',
-    name: 'base36upper',
-    alphabet: '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ'
-});
-
-const base58btc = baseX({
-    name: 'base58btc',
-    prefix: 'z',
-    alphabet: '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz'
-});
-baseX({
-    name: 'base58flickr',
-    prefix: 'Z',
-    alphabet: '123456789abcdefghijkmnopqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ'
-});
-
-/* eslint-disable */
-var encode_1 = encode;
-var MSB = 0x80, MSBALL = -128, INT = Math.pow(2, 31);
-/**
- * @param {number} num
- * @param {number[]} out
- * @param {number} offset
- */
-function encode(num, out, offset) {
-    out = out || [];
-    offset = offset || 0;
-    var oldOffset = offset;
-    while (num >= INT) {
-        out[offset++] = (num & 0xFF) | MSB;
-        num /= 128;
-    }
-    while (num & MSBALL) {
-        out[offset++] = (num & 0xFF) | MSB;
-        num >>>= 7;
-    }
-    out[offset] = num | 0;
-    // @ts-ignore
-    encode.bytes = offset - oldOffset + 1;
-    return out;
-}
-var decode$2 = read;
-var MSB$1 = 0x80, REST$1 = 0x7F;
-/**
- * @param {string | any[]} buf
- * @param {number} offset
- */
-function read(buf, offset) {
-    var res = 0, offset = offset || 0, shift = 0, counter = offset, b, l = buf.length;
-    do {
-        if (counter >= l) {
-            // @ts-ignore
-            read.bytes = 0;
-            throw new RangeError('Could not decode varint');
-        }
-        b = buf[counter++];
-        res += shift < 28
-            ? (b & REST$1) << shift
-            : (b & REST$1) * Math.pow(2, shift);
-        shift += 7;
-    } while (b >= MSB$1);
-    // @ts-ignore
-    read.bytes = counter - offset;
-    return res;
-}
-var N1 = Math.pow(2, 7);
-var N2 = Math.pow(2, 14);
-var N3 = Math.pow(2, 21);
-var N4 = Math.pow(2, 28);
-var N5 = Math.pow(2, 35);
-var N6 = Math.pow(2, 42);
-var N7 = Math.pow(2, 49);
-var N8 = Math.pow(2, 56);
-var N9 = Math.pow(2, 63);
-var length = function (/** @type {number} */ value) {
-    return (value < N1 ? 1
-        : value < N2 ? 2
-            : value < N3 ? 3
-                : value < N4 ? 4
-                    : value < N5 ? 5
-                        : value < N6 ? 6
-                            : value < N7 ? 7
-                                : value < N8 ? 8
-                                    : value < N9 ? 9
-                                        : 10);
-};
-var varint = {
-    encode: encode_1,
-    decode: decode$2,
-    encodingLength: length
-};
-var _brrp_varint = varint;
-
-function decode$1(data, offset = 0) {
-    const code = _brrp_varint.decode(data, offset);
-    return [code, _brrp_varint.decode.bytes];
-}
-function encodeTo(int, target, offset = 0) {
-    _brrp_varint.encode(int, target, offset);
-    return target;
-}
-function encodingLength(int) {
-    return _brrp_varint.encodingLength(int);
-}
-
-/**
- * Creates a multihash digest.
- */
-function create(code, digest) {
-    const size = digest.byteLength;
-    const sizeOffset = encodingLength(code);
-    const digestOffset = sizeOffset + encodingLength(size);
-    const bytes = new Uint8Array(digestOffset + size);
-    encodeTo(code, bytes, 0);
-    encodeTo(size, bytes, sizeOffset);
-    bytes.set(digest, digestOffset);
-    return new Digest(code, size, digest, bytes);
-}
-/**
- * Turns bytes representation of multihash digest into an instance.
- */
-function decode(multihash) {
-    const bytes = coerce(multihash);
-    const [code, sizeOffset] = decode$1(bytes);
-    const [size, digestOffset] = decode$1(bytes.subarray(sizeOffset));
-    const digest = bytes.subarray(sizeOffset + digestOffset);
-    if (digest.byteLength !== size) {
-        throw new Error('Incorrect length');
-    }
-    return new Digest(code, size, digest, bytes);
-}
-function equals(a, b) {
-    if (a === b) {
-        return true;
-    }
-    else {
-        const data = b;
-        return (a.code === data.code &&
-            a.size === data.size &&
-            data.bytes instanceof Uint8Array &&
-            equals$1(a.bytes, data.bytes));
-    }
-}
-/**
- * Represents a multihash digest which carries information about the
- * hashing algorithm and an actual hash digest.
- */
-class Digest {
-    code;
-    size;
-    digest;
-    bytes;
-    /**
-     * Creates a multihash digest.
-     */
-    constructor(code, size, digest, bytes) {
-        this.code = code;
-        this.size = size;
-        this.digest = digest;
-        this.bytes = bytes;
-    }
-}
-
-function format(link, base) {
-    const { bytes, version } = link;
-    switch (version) {
-        case 0:
-            return toStringV0(bytes, baseCache(link), base ?? base58btc.encoder);
-        default:
-            return toStringV1(bytes, baseCache(link), (base ?? base32.encoder));
-    }
-}
-const cache = new WeakMap();
-function baseCache(cid) {
-    const baseCache = cache.get(cid);
-    if (baseCache == null) {
-        const baseCache = new Map();
-        cache.set(cid, baseCache);
-        return baseCache;
-    }
-    return baseCache;
-}
-class CID {
-    code;
-    version;
-    multihash;
-    bytes;
-    '/';
-    /**
-     * @param version - Version of the CID
-     * @param code - Code of the codec content is encoded in, see https://github.com/multiformats/multicodec/blob/master/table.csv
-     * @param multihash - (Multi)hash of the of the content.
-     */
-    constructor(version, code, multihash, bytes) {
-        this.code = code;
-        this.version = version;
-        this.multihash = multihash;
-        this.bytes = bytes;
-        // flag to serializers that this is a CID and
-        // should be treated specially
-        this['/'] = bytes;
-    }
-    /**
-     * Signalling `cid.asCID === cid` has been replaced with `cid['/'] === cid.bytes`
-     * please either use `CID.asCID(cid)` or switch to new signalling mechanism
-     *
-     * @deprecated
-     */
-    get asCID() {
-        return this;
-    }
-    // ArrayBufferView
-    get byteOffset() {
-        return this.bytes.byteOffset;
-    }
-    // ArrayBufferView
-    get byteLength() {
-        return this.bytes.byteLength;
-    }
-    toV0() {
-        switch (this.version) {
-            case 0: {
-                return this;
-            }
-            case 1: {
-                const { code, multihash } = this;
-                if (code !== DAG_PB_CODE) {
-                    throw new Error('Cannot convert a non dag-pb CID to CIDv0');
-                }
-                // sha2-256
-                if (multihash.code !== SHA_256_CODE) {
-                    throw new Error('Cannot convert non sha2-256 multihash CID to CIDv0');
-                }
-                return (CID.createV0(multihash));
-            }
-            default: {
-                throw Error(`Can not convert CID version ${this.version} to version 0. This is a bug please report`);
-            }
-        }
-    }
-    toV1() {
-        switch (this.version) {
-            case 0: {
-                const { code, digest } = this.multihash;
-                const multihash = create(code, digest);
-                return (CID.createV1(this.code, multihash));
-            }
-            case 1: {
-                return this;
-            }
-            default: {
-                throw Error(`Can not convert CID version ${this.version} to version 1. This is a bug please report`);
-            }
-        }
-    }
-    equals(other) {
-        return CID.equals(this, other);
-    }
-    static equals(self, other) {
-        const unknown = other;
-        return (unknown != null &&
-            self.code === unknown.code &&
-            self.version === unknown.version &&
-            equals(self.multihash, unknown.multihash));
-    }
-    toString(base) {
-        return format(this, base);
-    }
-    toJSON() {
-        return { '/': format(this) };
-    }
-    link() {
-        return this;
-    }
-    [Symbol.toStringTag] = 'CID';
-    // Legacy
-    [Symbol.for('nodejs.util.inspect.custom')]() {
-        return `CID(${this.toString()})`;
-    }
-    /**
-     * Takes any input `value` and returns a `CID` instance if it was
-     * a `CID` otherwise returns `null`. If `value` is instanceof `CID`
-     * it will return value back. If `value` is not instance of this CID
-     * class, but is compatible CID it will return new instance of this
-     * `CID` class. Otherwise returns null.
-     *
-     * This allows two different incompatible versions of CID library to
-     * co-exist and interop as long as binary interface is compatible.
-     */
-    static asCID(input) {
-        if (input == null) {
-            return null;
-        }
-        const value = input;
-        if (value instanceof CID) {
-            // If value is instance of CID then we're all set.
-            return value;
-        }
-        else if ((value['/'] != null && value['/'] === value.bytes) || value.asCID === value) {
-            // If value isn't instance of this CID class but `this.asCID === this` or
-            // `value['/'] === value.bytes` is true it is CID instance coming from a
-            // different implementation (diff version or duplicate). In that case we
-            // rebase it to this `CID` implementation so caller is guaranteed to get
-            // instance with expected API.
-            const { version, code, multihash, bytes } = value;
-            return new CID(version, code, multihash, bytes ?? encodeCID(version, code, multihash.bytes));
-        }
-        else if (value[cidSymbol] === true) {
-            // If value is a CID from older implementation that used to be tagged via
-            // symbol we still rebase it to the this `CID` implementation by
-            // delegating that to a constructor.
-            const { version, multihash, code } = value;
-            const digest = decode(multihash);
-            return CID.create(version, code, digest);
-        }
-        else {
-            // Otherwise value is not a CID (or an incompatible version of it) in
-            // which case we return `null`.
-            return null;
-        }
-    }
-    /**
-     * @param version - Version of the CID
-     * @param code - Code of the codec content is encoded in, see https://github.com/multiformats/multicodec/blob/master/table.csv
-     * @param digest - (Multi)hash of the of the content.
-     */
-    static create(version, code, digest) {
-        if (typeof code !== 'number') {
-            throw new Error('String codecs are no longer supported');
-        }
-        if (!(digest.bytes instanceof Uint8Array)) {
-            throw new Error('Invalid digest');
-        }
-        switch (version) {
-            case 0: {
-                if (code !== DAG_PB_CODE) {
-                    throw new Error(`Version 0 CID must use dag-pb (code: ${DAG_PB_CODE}) block encoding`);
-                }
-                else {
-                    return new CID(version, code, digest, digest.bytes);
-                }
-            }
-            case 1: {
-                const bytes = encodeCID(version, code, digest.bytes);
-                return new CID(version, code, digest, bytes);
-            }
-            default: {
-                throw new Error('Invalid version');
-            }
-        }
-    }
-    /**
-     * Simplified version of `create` for CIDv0.
-     */
-    static createV0(digest) {
-        return CID.create(0, DAG_PB_CODE, digest);
-    }
-    /**
-     * Simplified version of `create` for CIDv1.
-     *
-     * @param code - Content encoding format code.
-     * @param digest - Multihash of the content.
-     */
-    static createV1(code, digest) {
-        return CID.create(1, code, digest);
-    }
-    /**
-     * Decoded a CID from its binary representation. The byte array must contain
-     * only the CID with no additional bytes.
-     *
-     * An error will be thrown if the bytes provided do not contain a valid
-     * binary representation of a CID.
-     */
-    static decode(bytes) {
-        const [cid, remainder] = CID.decodeFirst(bytes);
-        if (remainder.length !== 0) {
-            throw new Error('Incorrect length');
-        }
-        return cid;
-    }
-    /**
-     * Decoded a CID from its binary representation at the beginning of a byte
-     * array.
-     *
-     * Returns an array with the first element containing the CID and the second
-     * element containing the remainder of the original byte array. The remainder
-     * will be a zero-length byte array if the provided bytes only contained a
-     * binary CID representation.
-     */
-    static decodeFirst(bytes) {
-        const specs = CID.inspectBytes(bytes);
-        const prefixSize = specs.size - specs.multihashSize;
-        const multihashBytes = coerce(bytes.subarray(prefixSize, prefixSize + specs.multihashSize));
-        if (multihashBytes.byteLength !== specs.multihashSize) {
-            throw new Error('Incorrect length');
-        }
-        const digestBytes = multihashBytes.subarray(specs.multihashSize - specs.digestSize);
-        const digest = new Digest(specs.multihashCode, specs.digestSize, digestBytes, multihashBytes);
-        const cid = specs.version === 0
-            ? CID.createV0(digest)
-            : CID.createV1(specs.codec, digest);
-        return [cid, bytes.subarray(specs.size)];
-    }
-    /**
-     * Inspect the initial bytes of a CID to determine its properties.
-     *
-     * Involves decoding up to 4 varints. Typically this will require only 4 to 6
-     * bytes but for larger multicodec code values and larger multihash digest
-     * lengths these varints can be quite large. It is recommended that at least
-     * 10 bytes be made available in the `initialBytes` argument for a complete
-     * inspection.
-     */
-    static inspectBytes(initialBytes) {
-        let offset = 0;
-        const next = () => {
-            const [i, length] = decode$1(initialBytes.subarray(offset));
-            offset += length;
-            return i;
-        };
-        let version = next();
-        let codec = DAG_PB_CODE;
-        if (version === 18) {
-            // CIDv0
-            version = 0;
-            offset = 0;
-        }
-        else {
-            codec = next();
-        }
-        if (version !== 0 && version !== 1) {
-            throw new RangeError(`Invalid CID version ${version}`);
-        }
-        const prefixSize = offset;
-        const multihashCode = next(); // multihash code
-        const digestSize = next(); // multihash length
-        const size = offset + digestSize;
-        const multihashSize = size - prefixSize;
-        return { version, codec, multihashCode, digestSize, multihashSize, size };
-    }
-    /**
-     * Takes cid in a string representation and creates an instance. If `base`
-     * decoder is not provided will use a default from the configuration. It will
-     * throw an error if encoding of the CID is not compatible with supplied (or
-     * a default decoder).
-     */
-    static parse(source, base) {
-        const [prefix, bytes] = parseCIDtoBytes(source, base);
-        const cid = CID.decode(bytes);
-        if (cid.version === 0 && source[0] !== 'Q') {
-            throw Error('Version 0 CID string must not include multibase prefix');
-        }
-        // Cache string representation to avoid computing it on `this.toString()`
-        baseCache(cid).set(prefix, source);
-        return cid;
-    }
-}
-function parseCIDtoBytes(source, base) {
-    switch (source[0]) {
-        // CIDv0 is parsed differently
-        case 'Q': {
-            const decoder = base ?? base58btc;
-            return [
-                base58btc.prefix,
-                decoder.decode(`${base58btc.prefix}${source}`)
-            ];
-        }
-        case base58btc.prefix: {
-            const decoder = base ?? base58btc;
-            return [base58btc.prefix, decoder.decode(source)];
-        }
-        case base32.prefix: {
-            const decoder = base ?? base32;
-            return [base32.prefix, decoder.decode(source)];
-        }
-        case base36.prefix: {
-            const decoder = base ?? base36;
-            return [base36.prefix, decoder.decode(source)];
-        }
-        default: {
-            if (base == null) {
-                throw Error('To parse non base32, base36 or base58btc encoded CID multibase decoder must be provided');
-            }
-            return [source[0], base.decode(source)];
-        }
-    }
-}
-function toStringV0(bytes, cache, base) {
-    const { prefix } = base;
-    if (prefix !== base58btc.prefix) {
-        throw Error(`Cannot string encode V0 in ${base.name} encoding`);
-    }
-    const cid = cache.get(prefix);
-    if (cid == null) {
-        const cid = base.encode(bytes).slice(1);
-        cache.set(prefix, cid);
-        return cid;
-    }
-    else {
-        return cid;
-    }
-}
-function toStringV1(bytes, cache, base) {
-    const { prefix } = base;
-    const cid = cache.get(prefix);
-    if (cid == null) {
-        const cid = base.encode(bytes);
-        cache.set(prefix, cid);
-        return cid;
-    }
-    else {
-        return cid;
-    }
-}
-const DAG_PB_CODE = 0x70;
-const SHA_256_CODE = 0x12;
-function encodeCID(version, code, multihash) {
-    const codeOffset = encodingLength(version);
-    const hashOffset = codeOffset + encodingLength(code);
-    const bytes = new Uint8Array(hashOffset + multihash.byteLength);
-    encodeTo(version, bytes, 0);
-    encodeTo(code, bytes, codeOffset);
-    bytes.set(multihash, hashOffset);
-    return bytes;
-}
-const cidSymbol = Symbol.for('@ipld/js-cid/CID');
-
-const MAX_WEBCRYPTO_INPUT = 0x7fffffff;
-const STREAMING_CHUNK_SIZE = 64 * 1024 * 1024;
-const toUint8Array = (buffer) => buffer instanceof Uint8Array ? buffer : new Uint8Array(buffer);
-const getStreamingHasher = async (hashVariant) => {
+const createHasher = (hashVariant) => {
     switch (hashVariant) {
         case 1:
             return createSHA1();
@@ -8626,44 +7613,23 @@ const getStreamingHasher = async (hashVariant) => {
         case 512:
             return createSHA512();
         default:
-            return null;
+            throw new Error(`unsupported hash variant: ${hashVariant}`);
     }
 };
 const digestBuffer = async (hashVariant, buffer) => {
-    const view = toUint8Array(buffer);
-    if (view.byteLength >= MAX_WEBCRYPTO_INPUT) {
-        const hasher = await getStreamingHasher(hashVariant);
-        if (!hasher) {
-            throw new Error(`unsupported streaming hash variant: ${hashVariant}`);
-        }
-        hasher.init();
-        for (let offset = 0; offset < view.byteLength; offset += STREAMING_CHUNK_SIZE) {
-            const end = Math.min(offset + STREAMING_CHUNK_SIZE, view.byteLength);
-            hasher.update(view.subarray(offset, end));
-        }
-        const digest = hasher.digest('binary');
-        return digest instanceof Uint8Array ? digest : new Uint8Array(digest);
-    }
-    const sourceView = view.byteOffset === 0 && view.byteLength === view.buffer.byteLength ? view : view.slice();
-    const digest = await crypto.subtle.digest(`SHA-${hashVariant}`, sourceView.buffer);
-    return new Uint8Array(digest);
-};
-const parseCid = (input) => {
-    try {
-        if (typeof input === 'string')
-            return CID.parse(input);
-        const bytes = input instanceof Uint8Array ? input : new Uint8Array(input);
-        return CID.decode(bytes);
-    }
-    catch {
-        return null;
-    }
+    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;
@@ -8671,42 +7637,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) {
-            const cid = typeof uint8Array === 'string'
-                ? parseCid(uint8Array)
-                : uint8Array instanceof Uint8Array || uint8Array instanceof ArrayBuffer
-                    ? parseCid(uint8Array)
-                    : null;
-            if (cid) {
-                await this.fromCID(cid);
-                return this;
+            if (!(uint8Array instanceof Uint8Array)) {
+                throw new Error('CodecHash only supports Uint8Array input');
             }
-            if (uint8Array instanceof Uint8Array) {
-                this.discoCodec = new Codec$2(uint8Array);
-                const name = this.discoCodec.name;
-                if (name) {
-                    this.name = name;
-                    this.decode(uint8Array);
-                }
-                else {
-                    await this.encode(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$1(checkBuffer);
+            const name = this.discoCodec.name;
+            if (name) {
+                this.name = name;
+                this.decode(uint8Array);
             }
-            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}`);
+            else {
+                await this.encode(uint8Array);
             }
-            else if (typeof uint8Array === 'object')
-                await this.fromJSON(uint8Array);
         }
         return this;
     }
@@ -8726,16 +7674,12 @@ 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;
-        this.discoCodec = new Codec$2(this.name);
-        this.discoCodec.fromName(this.name);
+            throw new Error('buffer is required for encoding');
+        this.discoCodec = new Codec$1(this.name);
         let hashAlg = this.discoCodec.hashAlg;
         const hashVariant = Number(hashAlg.split('-')[hashAlg.split('-').length - 1]);
         if (hashAlg.includes('dbl')) {
@@ -8752,57 +7696,28 @@ class CodecHash extends BasicInterface {
         this.encoded = uint8Array;
         return this.encoded;
     }
-    async fromCID(cid) {
-        const parsed = cid instanceof CID
-            ? cid
-            : typeof cid === 'string' || cid instanceof Uint8Array
-                ? parseCid(cid)
-                : parseCid(cid);
-        if (!parsed)
-            throw new Error('invalid cid input');
-        if (!this.name)
-            this.name = 'disco-hash';
-        this.discoCodec = new Codec$2(this.name);
-        this.discoCodec.fromName(this.name);
-        this.digest = parsed.multihash.digest;
-        this.size = this.digest.length;
-        this.codec = this.discoCodec.encode();
-        this.codec = this.discoCodec.codecBuffer;
-        const uint8Array = new Uint8Array(this.digest.length + this.prefix.length);
-        uint8Array.set(this.prefix);
-        uint8Array.set(this.digest, this.prefix.length);
-        this.encoded = uint8Array;
-        return this.encoded;
-    }
     async validate(buffer) {
-        if (Buffer.isBuffer(buffer)) {
-            const codec = index$5.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');
         }
-        if (typeof buffer === 'string') {
-            if (this.isHex(buffer))
-                this.fromHex(buffer);
-            if (this.isBase32(buffer))
-                this.fromBs32(buffer);
+        const codec = index$5.decode(buffer);
+        if (this.codecs[codec]) {
+            this.decode(buffer);
+        }
+        else {
+            await this.encode(buffer);
         }
-        if (typeof buffer === 'object')
-            this.fromJSON(buffer);
     }
     decode(buffer) {
         this.encoded = buffer;
         const codec = index$5.decode(buffer);
-        this.discoCodec = new Codec$2(codec, this.codecs);
+        this.discoCodec = new Codec$1(codec, this.codecs);
         // TODO: validate codec
         buffer = buffer.slice(index$5.decode.bytes);
         this.size = index$5.decode(buffer);
         this.digest = buffer.slice(index$5.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;
@@ -8859,13 +7774,13 @@ let FormatInterface$1 = class FormatInterface extends BasicInterface {
     hasCodec() {
         if (!this.encoded)
             return false;
-        const codec = new Codec$2(this.encoded);
+        const codec = new Codec$1(this.encoded);
         if (codec.name)
             return true;
     }
     decode(encoded) {
         encoded = encoded || this.encoded;
-        const codec = new Codec$2(encoded);
+        const codec = new Codec$1(encoded);
         if (codec.codecBuffer) {
             encoded = encoded.slice(codec.codecBuffer.length);
             this.name = codec.name;
@@ -8883,7 +7798,7 @@ let FormatInterface$1 = class FormatInterface extends BasicInterface {
     encode(decoded) {
         let encoded;
         decoded = decoded || this.decoded;
-        const codec = new Codec$2(this.name);
+        const codec = new Codec$1(this.name);
         if (decoded instanceof Uint8Array)
             encoded = decoded;
         else
@@ -8916,6 +7831,18 @@ 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$1(this.encoded);
+        if (codec.codecBuffer) {
+            return this.encoded.slice(codec.codecBuffer.length);
+        }
+        return this.encoded;
+    }
     beforeHashing(decoded) {
         // Avoid copying if not needed
         if (decoded && Object.prototype.hasOwnProperty.call(decoded, 'hash')) {
@@ -8930,9 +7857,20 @@ let FormatInterface$1 = class FormatInterface extends BasicInterface {
      * @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}
@@ -8982,7 +7920,7 @@ const FormatInterface = FormatInterface$1;
 /**
  * Codec utility class
  */
-const Codec = Codec$2;
+const Codec = Codec$1;
 
 const BufferToUint8Array = (data) => {
     if (data.type === 'Buffer') {
@@ -9535,7 +8473,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-2i_0i581.js');
+        const { RequestMessage, ResponseMessage, PeerMessage, PeerMessageResponse, PeernetMessage, DHTMessage, DHTMessageResponse, DataMessage, DataMessageResponse, PsMessage, ChatMessage, PeernetFile } = await import(/* webpackChunkName: "messages" */ './messages-odneBhMk.js');
         /**
          * proto Object containing protos
          * @type {Object}
@@ -9582,7 +8520,7 @@ class Peernet {
         if (this.#starting || this.#started)
             return;
         this.#starting = true;
-        const importee = await import('./client-KrGUTq9O.js');
+        const importee = await import('./client-CwKuEJRO.js');
         /**
          * @access public
          * @type {PeernetClient}