grpc-libp2p-client 0.0.33 → 0.0.35

package/dist/dc-http2/frame.cjs.js

@@ -1,720 +1,5 @@
 'use strict';
 
-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');
-}
-function fromString(str) {
-    return new TextEncoder().encode(str);
-}
-function toString$1(b) {
-    return new TextDecoder().decode(b);
-}
-
-/* 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 })
-    });
-}
-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(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$1(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$1(input, alphabetIdx, bitsPerChar, name);
-        }
-    });
-}
-
-const base10 = baseX({
-    prefix: '9',
-    name: 'base10',
-    alphabet: '0123456789'
-});
-
-var base10$1 = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    base10: base10
-});
-
-const base16 = rfc4648({
-    prefix: 'f',
-    name: 'base16',
-    alphabet: '0123456789abcdef',
-    bitsPerChar: 4
-});
-const base16upper = rfc4648({
-    prefix: 'F',
-    name: 'base16upper',
-    alphabet: '0123456789ABCDEF',
-    bitsPerChar: 4
-});
-
-var base16$1 = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    base16: base16,
-    base16upper: base16upper
-});
-
-const base2 = rfc4648({
-    prefix: '0',
-    name: 'base2',
-    alphabet: '01',
-    bitsPerChar: 1
-});
-
-var base2$1 = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    base2: base2
-});
-
-const alphabet = Array.from('🚀🪐☄🛰🌌🌑🌒🌓🌔🌕🌖🌗🌘🌍🌏🌎🐉☀💻🖥💾💿😂❤😍🤣😊🙏💕😭😘👍😅👏😁🔥🥰💔💖💙😢🤔😆🙄💪😉☺👌🤗💜😔😎😇🌹🤦🎉💞✌✨🤷😱😌🌸🙌😋💗💚😏💛🙂💓🤩😄😀🖤😃💯🙈👇🎶😒🤭❣😜💋👀😪😑💥🙋😞😩😡🤪👊🥳😥🤤👉💃😳✋😚😝😴🌟😬🙃🍀🌷😻😓⭐✅🥺🌈😈🤘💦✔😣🏃💐☹🎊💘😠☝😕🌺🎂🌻😐🖕💝🙊😹🗣💫💀👑🎵🤞😛🔴😤🌼😫⚽🤙☕🏆🤫👈😮🙆🍻🍃🐶💁😲🌿🧡🎁⚡🌞🎈❌✊👋😰🤨😶🤝🚶💰🍓💢🤟🙁🚨💨🤬✈🎀🍺🤓😙💟🌱😖👶🥴▶➡❓💎💸⬇😨🌚🦋😷🕺⚠🙅😟😵👎🤲🤠🤧📌🔵💅🧐🐾🍒😗🤑🌊🤯🐷☎💧😯💆👆🎤🙇🍑❄🌴💣🐸💌📍🥀🤢👅💡💩👐📸👻🤐🤮🎼🥵🚩🍎🍊👼💍📣🥂');
-const alphabetBytesToChars = (alphabet.reduce((p, c, i) => { p[i] = c; return p; }, ([])));
-const alphabetCharsToBytes = (alphabet.reduce((p, c, i) => {
-    const codePoint = c.codePointAt(0);
-    if (codePoint == null) {
-        throw new Error(`Invalid character: ${c}`);
-    }
-    p[codePoint] = i;
-    return p;
-}, ([])));
-function encode(data) {
-    return data.reduce((p, c) => {
-        p += alphabetBytesToChars[c];
-        return p;
-    }, '');
-}
-function decode(str) {
-    const byts = [];
-    for (const char of str) {
-        const codePoint = char.codePointAt(0);
-        if (codePoint == null) {
-            throw new Error(`Invalid character: ${char}`);
-        }
-        const byt = alphabetCharsToBytes[codePoint];
-        if (byt == null) {
-            throw new Error(`Non-base256emoji character: ${char}`);
-        }
-        byts.push(byt);
-    }
-    return new Uint8Array(byts);
-}
-const base256emoji = from({
-    prefix: '🚀',
-    name: 'base256emoji',
-    encode,
-    decode
-});
-
-var base256emoji$1 = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    base256emoji: base256emoji
-});
-
-const base32 = rfc4648({
-    prefix: 'b',
-    name: 'base32',
-    alphabet: 'abcdefghijklmnopqrstuvwxyz234567',
-    bitsPerChar: 5
-});
-const base32upper = rfc4648({
-    prefix: 'B',
-    name: 'base32upper',
-    alphabet: 'ABCDEFGHIJKLMNOPQRSTUVWXYZ234567',
-    bitsPerChar: 5
-});
-const base32pad = rfc4648({
-    prefix: 'c',
-    name: 'base32pad',
-    alphabet: 'abcdefghijklmnopqrstuvwxyz234567=',
-    bitsPerChar: 5
-});
-const base32padupper = rfc4648({
-    prefix: 'C',
-    name: 'base32padupper',
-    alphabet: 'ABCDEFGHIJKLMNOPQRSTUVWXYZ234567=',
-    bitsPerChar: 5
-});
-const base32hex = rfc4648({
-    prefix: 'v',
-    name: 'base32hex',
-    alphabet: '0123456789abcdefghijklmnopqrstuv',
-    bitsPerChar: 5
-});
-const base32hexupper = rfc4648({
-    prefix: 'V',
-    name: 'base32hexupper',
-    alphabet: '0123456789ABCDEFGHIJKLMNOPQRSTUV',
-    bitsPerChar: 5
-});
-const base32hexpad = rfc4648({
-    prefix: 't',
-    name: 'base32hexpad',
-    alphabet: '0123456789abcdefghijklmnopqrstuv=',
-    bitsPerChar: 5
-});
-const base32hexpadupper = rfc4648({
-    prefix: 'T',
-    name: 'base32hexpadupper',
-    alphabet: '0123456789ABCDEFGHIJKLMNOPQRSTUV=',
-    bitsPerChar: 5
-});
-const base32z = rfc4648({
-    prefix: 'h',
-    name: 'base32z',
-    alphabet: 'ybndrfg8ejkmcpqxot1uwisza345h769',
-    bitsPerChar: 5
-});
-
-var base32$1 = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    base32: base32,
-    base32hex: base32hex,
-    base32hexpad: base32hexpad,
-    base32hexpadupper: base32hexpadupper,
-    base32hexupper: base32hexupper,
-    base32pad: base32pad,
-    base32padupper: base32padupper,
-    base32upper: base32upper,
-    base32z: base32z
-});
-
-const base36 = baseX({
-    prefix: 'k',
-    name: 'base36',
-    alphabet: '0123456789abcdefghijklmnopqrstuvwxyz'
-});
-const base36upper = baseX({
-    prefix: 'K',
-    name: 'base36upper',
-    alphabet: '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ'
-});
-
-var base36$1 = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    base36: base36,
-    base36upper: base36upper
-});
-
-const base58btc = baseX({
-    name: 'base58btc',
-    prefix: 'z',
-    alphabet: '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz'
-});
-const base58flickr = baseX({
-    name: 'base58flickr',
-    prefix: 'Z',
-    alphabet: '123456789abcdefghijkmnopqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ'
-});
-
-var base58 = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    base58btc: base58btc,
-    base58flickr: base58flickr
-});
-
-const base64 = rfc4648({
-    prefix: 'm',
-    name: 'base64',
-    alphabet: 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/',
-    bitsPerChar: 6
-});
-const base64pad = rfc4648({
-    prefix: 'M',
-    name: 'base64pad',
-    alphabet: 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=',
-    bitsPerChar: 6
-});
-const base64url = rfc4648({
-    prefix: 'u',
-    name: 'base64url',
-    alphabet: 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_',
-    bitsPerChar: 6
-});
-const base64urlpad = rfc4648({
-    prefix: 'U',
-    name: 'base64urlpad',
-    alphabet: 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_=',
-    bitsPerChar: 6
-});
-
-var base64$1 = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    base64: base64,
-    base64pad: base64pad,
-    base64url: base64url,
-    base64urlpad: base64urlpad
-});
-
-const base8 = rfc4648({
-    prefix: '7',
-    name: 'base8',
-    alphabet: '01234567',
-    bitsPerChar: 3
-});
-
-var base8$1 = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    base8: base8
-});
-
-const identity = from({
-    prefix: '\x00',
-    name: 'identity',
-    encode: (buf) => toString$1(buf),
-    decode: (str) => fromString(str)
-});
-
-var identityBase = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    identity: identity
-});
-
-new TextEncoder();
-new TextDecoder();
-
-const bases = { ...identityBase, ...base2$1, ...base8$1, ...base10$1, ...base16$1, ...base32$1, ...base36$1, ...base58, ...base64$1, ...base256emoji$1 };
-
-/**
- * Returns a `Uint8Array` of the requested size. Referenced memory will
- * be initialized to 0.
- */
-/**
- * Where possible returns a Uint8Array of the requested size that references
- * uninitialized memory. Only use if you are certain you will immediately
- * overwrite every value in the returned `Uint8Array`.
- */
-function allocUnsafe(size = 0) {
-    return new Uint8Array(size);
-}
-
-function createCodec(name, prefix, encode, decode) {
-    return {
-        name,
-        prefix,
-        encoder: {
-            name,
-            prefix,
-            encode
-        },
-        decoder: {
-            decode
-        }
-    };
-}
-const string = createCodec('utf8', 'u', (buf) => {
-    const decoder = new TextDecoder('utf8');
-    return 'u' + decoder.decode(buf);
-}, (str) => {
-    const encoder = new TextEncoder();
-    return encoder.encode(str.substring(1));
-});
-const ascii = createCodec('ascii', 'a', (buf) => {
-    let string = 'a';
-    for (let i = 0; i < buf.length; i++) {
-        string += String.fromCharCode(buf[i]);
-    }
-    return string;
-}, (str) => {
-    str = str.substring(1);
-    const buf = allocUnsafe(str.length);
-    for (let i = 0; i < str.length; i++) {
-        buf[i] = str.charCodeAt(i);
-    }
-    return buf;
-});
-const BASES = {
-    utf8: string,
-    'utf-8': string,
-    hex: bases.base16,
-    latin1: ascii,
-    ascii,
-    binary: ascii,
-    ...bases
-};
-
-/**
- * Turns a `Uint8Array` into a string.
- *
- * Supports `utf8`, `utf-8` and any encoding supported by the multibase module.
- *
- * Also `ascii` which is similar to node's 'binary' encoding.
- */
-function toString(array, encoding = 'utf8') {
-    const base = BASES[encoding];
-    if (base == null) {
-        throw new Error(`Unsupported encoding "${encoding}"`);
-    }
-    // strip multibase prefix
-    return base.encoder.encode(array).substring(1);
-}
-
 // HPACK Implementation
 class HPACK {
     constructor(maxDynamicTableSize = 4096) {
@@ -1157,8 +442,7 @@ class HPACK {
         }
         else {
             try {
-                //    result = new TextDecoder().decode(bytes);  
-                result = toString(bytes);
+                result = new TextDecoder().decode(bytes);
             }
             catch (e) {
                 result = '';