grpc-libp2p-client 0.0.1

package/dist/dc-http2/hpack.esm.js

@@ -0,0 +1,1199 @@
+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) {
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+    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, alphabet, bitsPerChar, name) {
+    // Build the character lookup table:
+    const codes = {};
+    for (let i = 0; i < alphabet.length; ++i) {
+        codes[alphabet[i]] = i;
+    }
+    // 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 = codes[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;
+}
+/**
+ * RFC4648 Factory
+ */
+function rfc4648({ name, prefix, bitsPerChar, alphabet }) {
+    return from({
+        prefix,
+        name,
+        encode(input) {
+            return encode$1(input, alphabet, bitsPerChar);
+        },
+        decode(input) {
+            return decode$1(input, alphabet, 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) {
+        // 初始化动态表
+        this.dynamicTable = [];
+        this.dynamicTableSize = 0;
+        this.maxDynamicTableSize = maxDynamicTableSize;
+        // 初始化静态表
+        this.staticTable = [
+            ['', ''], // Index 0 is not used
+            [':authority', ''],
+            [':method', 'GET'],
+            [':method', 'POST'],
+            [':path', '/'],
+            [':path', '/index.html'],
+            [':scheme', 'http'],
+            [':scheme', 'https'],
+            [':status', '200'],
+            [':status', '204'],
+            [':status', '206'],
+            [':status', '304'],
+            [':status', '400'],
+            [':status', '404'],
+            [':status', '500'],
+            ['accept-charset', ''],
+            ['accept-encoding', 'gzip, deflate'],
+            ['accept-language', ''],
+            ['accept-ranges', ''],
+            ['accept', ''],
+            ['access-control-allow-origin', ''],
+            ['age', ''],
+            ['allow', ''],
+            ['authorization', ''],
+            ['cache-control', ''],
+            ['content-disposition', ''],
+            ['content-encoding', ''],
+            ['content-language', ''],
+            ['content-length', ''],
+            ['content-location', ''],
+            ['content-range', ''],
+            ['content-type', ''],
+            ['cookie', ''],
+            ['date', ''],
+            ['etag', ''],
+            ['expect', ''],
+            ['expires', ''],
+            ['from', ''],
+            ['host', ''],
+            ['if-match', ''],
+            ['if-modified-since', ''],
+            ['if-none-match', ''],
+            ['if-range', ''],
+            ['if-unmodified-since', ''],
+            ['last-modified', ''],
+            ['link', ''],
+            ['location', ''],
+            ['max-forwards', ''],
+            ['proxy-authenticate', ''],
+            ['proxy-authorization', ''],
+            ['range', ''],
+            ['referer', ''],
+            ['refresh', ''],
+            ['retry-after', ''],
+            ['server', ''],
+            ['set-cookie', ''],
+            ['strict-transport-security', ''],
+            ['transfer-encoding', ''],
+            ['user-agent', ''],
+            ['vary', ''],
+            ['via', ''],
+            ['www-authenticate', '']
+        ];
+        // Huffman编码表
+        this.huffmanTable = this.buildHuffmanTable();
+    }
+    // 编码headers
+    encode(headers) {
+        const buffer = [];
+        for (const [name, value] of Object.entries(headers)) {
+            // 查找静态表索引
+            const staticIndex = this.findInStaticTable(name, value);
+            if (staticIndex !== -1) {
+                // 使用索引编码
+                buffer.push(...this.encodeInteger(staticIndex, 7, 0x80));
+                continue;
+            }
+            // 查找动态表索引
+            const dynamicIndex = this.findInDynamicTable(name, value);
+            if (dynamicIndex !== -1) {
+                buffer.push(...this.encodeInteger(dynamicIndex + this.staticTable.length, 7, 0x80));
+                continue;
+            }
+            // 字面量编码
+            this.encodeLiteral(buffer, name, value);
+        }
+        return new Uint8Array(buffer);
+    }
+    // // 解码二进制数据
+    // decode(buffer: Uint8Array): { [key: string]: string } {
+    //     const headers: { [key: string]: string } = {};
+    //     let pos = 0;
+    //     while (pos < buffer.length) {
+    //         const firstByte = buffer[pos];
+    //         // 检查是否是索引头部字段
+    //         if ((firstByte & 0x80) === 0x80) {
+    //             const { value: index, bytesRead } = this.decodeInteger(
+    //                 buffer.slice(pos),
+    //                 7
+    //             );
+    //             pos += bytesRead;
+    //             const [name, value] = this.getIndexedHeader(index);
+    //             if (name !== undefined && value !== undefined) {
+    //                 headers[name] = value;
+    //             }
+    //         }
+    //         // 字面量头部字段
+    //         else {
+    //             const { name, value, bytesRead } = this.decodeLiteral(
+    //                 buffer.slice(pos)
+    //             );
+    //             pos += bytesRead;
+    //             headers[name] = value;
+    //         }
+    //     }
+    //     return headers;
+    // }
+    // 编码整数
+    encodeInteger(value, prefixBits, prefix = 0) {
+        const buffer = [];
+        const mask = (1 << prefixBits) - 1;
+        if (value < mask) {
+            buffer.push(prefix | value);
+            return buffer;
+        }
+        buffer.push(prefix | mask);
+        value -= mask;
+        while (value >= 128) {
+            buffer.push((value & 127) | 128);
+            value = value >> 7;
+        }
+        buffer.push(value);
+        return buffer;
+    }
+    // // 解码整数
+    // decodeInteger(buffer: Uint8Array, prefixBits: number) {
+    //     let value = buffer[0] & ((1 << prefixBits) - 1);
+    //     let bytesRead = 1;
+    //     if (value === (1 << prefixBits) - 1) {
+    //         let shift = 0;
+    //         do {
+    //             value += (buffer[bytesRead] & 127) << shift;
+    //             shift += 7;
+    //             bytesRead++;
+    //         } while (buffer[bytesRead - 1] & 128);
+    //     }
+    //     return { value, bytesRead };
+    // }
+    // 编码字符串
+    encodeString(str) {
+        const buffer = [];
+        const bytes = new TextEncoder().encode(str);
+        // 尝试Huffman编码
+        const huffmanEncoded = this.huffmanEncode(bytes);
+        if (huffmanEncoded.length < bytes.length) {
+            // 使用Huffman编码
+            buffer.push(...this.encodeInteger(huffmanEncoded.length, 7, 0x80));
+            buffer.push(...huffmanEncoded);
+        }
+        else {
+            // 不使用Huffman编码
+            buffer.push(...this.encodeInteger(bytes.length, 7, 0x00));
+            buffer.push(...bytes);
+        }
+        return buffer;
+    }
+    // 在静态表中查找
+    findInStaticTable(name, value) {
+        for (let i = 1; i < this.staticTable.length; i++) {
+            if (this.staticTable[i][0] === name &&
+                this.staticTable[i][1] === value) {
+                return i;
+            }
+        }
+        return -1;
+    }
+    // 在动态表中查找
+    findInDynamicTable(name, value) {
+        for (let i = 0; i < this.dynamicTable.length; i++) {
+            if (this.dynamicTable[i][0] === name &&
+                this.dynamicTable[i][1] === value) {
+                return i;
+            }
+        }
+        return -1;
+    }
+    // 编码字面量头部字段
+    encodeLiteral(buffer, name, value) {
+        const nameIndex = this.findInStaticTable(name, '');
+        if (nameIndex !== -1) {
+            // 名称索引存在
+            buffer.push(...this.encodeInteger(nameIndex, 6, 0x40));
+        }
+        else {
+            // 名称需要字面量编码
+            buffer.push(0x40);
+            buffer.push(...this.encodeString(name));
+        }
+        // 值总是需要字面量编码
+        buffer.push(...this.encodeString(value));
+        // 添加到动态表
+        this.addToDynamicTable(name, value);
+    }
+    // 添加到动态表
+    addToDynamicTable(name, value) {
+        const size = name.length + value.length + 32; // 32 bytes overhead
+        // 确保不超过最大大小
+        while (this.dynamicTableSize + size > this.maxDynamicTableSize &&
+            this.dynamicTable.length > 0) {
+            const entry = this.dynamicTable.pop();
+            if (entry) {
+                this.dynamicTableSize -= entry[0].length + entry[1].length + 32;
+            }
+        }
+        if (size <= this.maxDynamicTableSize) {
+            this.dynamicTable.unshift([name, value]);
+            this.dynamicTableSize += size;
+        }
+        this.dynamicTable.push([name, value]);
+    }
+    // 获取索引的头部
+    getIndexedHeader(index) {
+        if (index <= this.staticTable.length - 1) {
+            return this.staticTable[index];
+        }
+        return this.dynamicTable[index - this.staticTable.length];
+    }
+    buildHuffmanTable() {
+        // HTTP/2规范中定义的完整Huffman编码表  
+        return {
+            codes: new Uint32Array([
+                0x1ff8, 0x7fffd8, 0xfffffe2, 0xfffffe3, 0xfffffe4, 0xfffffe5, 0xfffffe6, 0xfffffe7,
+                0xfffffe8, 0xffffea, 0x3ffffffc, 0xfffffe9, 0xfffffea, 0x3ffffffd, 0xfffffeb, 0xfffffec,
+                0xfffffed, 0xfffffee, 0xfffffef, 0xffffff0, 0xffffff1, 0xffffff2, 0x3ffffffe, 0xffffff3,
+                0xffffff4, 0xffffff5, 0xffffff6, 0xffffff7, 0xffffff8, 0xffffff9, 0xffffffa, 0xffffffb,
+                0x14, 0x3f8, 0x3f9, 0xffa, 0x1ff9, 0x15, 0xf8, 0x7fa,
+                0x3fa, 0x3fb, 0xf9, 0x7fb, 0xfa, 0x16, 0x17, 0x18,
+                0x0, 0x1, 0x2, 0x19, 0x1a, 0x1b, 0x1c, 0x1d,
+                0x1e, 0x1f, 0x5c, 0xfb, 0x7ffc, 0x20, 0xffb, 0x3fc,
+                0x1ffa, 0x21, 0x5d, 0x5e, 0x5f, 0x60, 0x61, 0x62,
+                0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a,
+                0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72,
+                0xfc, 0x73, 0xfd, 0x1ffb, 0x7fff0, 0x1ffc, 0x3ffc, 0x22,
+                0x7ffd, 0x3, 0x23, 0x4, 0x24, 0x5, 0x25, 0x26,
+                0x27, 0x6, 0x74, 0x75, 0x28, 0x29, 0x2a, 0x7,
+                0x2b, 0x76, 0x2c, 0x8, 0x9, 0x2d, 0x77, 0x78,
+                0x79, 0x7a, 0x7b, 0x7ffe, 0x7fc, 0x3ffd, 0x1ffd, 0xffffffc,
+                0xfffe6, 0x3fffd2, 0xfffe7, 0xfffe8, 0x3fffd3, 0x3fffd4, 0x3fffd5, 0x7fffd9,
+                0x3fffd6, 0x7fffda, 0x7fffdb, 0x7fffdc, 0x7fffdd, 0x7fffde, 0xffffeb, 0x7fffdf,
+                0xffffec, 0xffffed, 0x3fffd7, 0x7fffe0, 0xffffee, 0x7fffe1, 0x7fffe2, 0x7fffe3,
+                0x7fffe4, 0x1fffdc, 0x3fffd8, 0x7fffe5, 0x3fffd9, 0x7fffe6, 0x7fffe7, 0xffffef,
+                0x3fffda, 0x1fffdd, 0xfffe9, 0x3fffdb, 0x3fffdc, 0x7fffe8, 0x7fffe9, 0x1fffde,
+                0x7fffea, 0x3fffdd, 0x3fffde, 0xfffff0, 0x1fffdf, 0x3fffdf, 0x7fffeb, 0x7fffec,
+                0x1fffe0, 0x1fffe1, 0x3fffe0, 0x1fffe2, 0x7fffed, 0x3fffe1, 0x7fffee, 0x7fffef,
+                0xfffea, 0x3fffe2, 0x3fffe3, 0x3fffe4, 0x7ffff0, 0x3fffe5, 0x3fffe6, 0x7ffff1,
+                0x3ffffe0, 0x3ffffe1, 0xfffeb, 0x7fff1, 0x3fffe7, 0x7ffff2, 0x3fffe8, 0x1ffffec,
+                0x3ffffe2, 0x3ffffe3, 0x3ffffe4, 0x7ffffde, 0x7ffffdf, 0x3ffffe5, 0xfffff1, 0x1ffffed,
+                0x7fff2, 0x1fffe3, 0x3ffffe6, 0x7ffffe0, 0x7ffffe1, 0x3ffffe7, 0x7ffffe2, 0xfffff2,
+                0x1fffe4, 0x1fffe5, 0x3ffffe8, 0x3ffffe9, 0xffffffd, 0x7ffffe3, 0x7ffffe4, 0x7ffffe5,
+                0xfffec, 0xfffff3, 0xfffed, 0x1fffe6, 0x3fffe9, 0x1fffe7, 0x1fffe8, 0x7ffff3,
+                0x3fffea, 0x3fffeb, 0x1ffffee, 0x1ffffef, 0xfffff4, 0xfffff5, 0x3ffffea, 0x7ffff4,
+                0x3ffffeb, 0x7ffffe6, 0x3ffffec, 0x3ffffed, 0x7ffffe7, 0x7ffffe8, 0x7ffffe9, 0x7ffffea,
+                0x7ffffeb, 0xffffffe, 0x7ffffec, 0x7ffffed, 0x7ffffee, 0x7ffffef, 0x7fffff0, 0x3ffffee
+            ]),
+            lengths: new Uint8Array([
+                13, 23, 28, 28, 28, 28, 28, 28, 28, 24, 30, 28, 28, 30, 28, 28,
+                28, 28, 28, 28, 28, 28, 30, 28, 28, 28, 28, 28, 28, 28, 28, 28,
+                6, 10, 10, 12, 13, 6, 8, 11, 10, 10, 8, 11, 8, 6, 6, 6,
+                5, 5, 5, 6, 6, 6, 6, 6, 6, 6, 7, 8, 15, 6, 12, 10,
+                13, 6, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,
+                7, 7, 7, 7, 7, 7, 7, 7, 8, 7, 8, 13, 19, 13, 14, 6,
+                15, 5, 6, 5, 6, 5, 6, 6, 6, 5, 7, 7, 6, 6, 6, 5,
+                6, 7, 6, 5, 5, 6, 7, 7, 7, 7, 7, 15, 11, 14, 13, 28,
+                20, 22, 20, 20, 22, 22, 22, 23, 22, 23, 23, 23, 23, 23, 24, 23,
+                24, 24, 22, 23, 24, 23, 23, 23, 23, 21, 22, 23, 22, 23, 23, 24,
+                22, 21, 20, 22, 22, 23, 23, 21, 23, 22, 22, 24, 21, 22, 23, 23,
+                21, 21, 22, 21, 23, 22, 23, 23, 20, 22, 22, 22, 23, 22, 22, 23,
+                26, 26, 20, 19, 22, 23, 22, 25, 26, 26, 26, 27, 27, 26, 24, 25,
+                19, 21, 26, 27, 27, 26, 27, 24, 21, 21, 26, 26, 28, 27, 27, 27,
+                20, 24, 20, 21, 22, 21, 21, 23, 22, 22, 25, 25, 24, 24, 26, 23,
+                26, 27, 26, 26, 27, 27, 27, 27, 27, 28, 27, 27, 27, 27, 27, 26
+            ])
+        };
+    }
+    /**
+     * 解码Uint8Array为字符串
+     * @param input 编码后的Uint8Array
+     * @returns 解码后的字符串
+     */
+    decode(input) {
+        let result = '';
+        let accumulator = 0;
+        let bits = 0;
+        for (let i = 0; i < input.length; i++) {
+            const byte = input[i];
+            accumulator = (accumulator << 8) | byte;
+            bits += 8;
+            while (bits >= 5) {
+                const decoded = this.findSymbol(accumulator, bits);
+                if (!decoded) {
+                    break;
+                }
+                const [symbol, length] = decoded;
+                result += String.fromCharCode(symbol);
+                accumulator &= (1 << (bits - length)) - 1;
+                bits -= length;
+            }
+        }
+        // 验证填充  
+        if (bits > 0) {
+            const mask = (1 << bits) - 1;
+            if ((accumulator & mask) !== mask) {
+                throw new Error('Invalid Huffman padding');
+            }
+        }
+        return result;
+    }
+    /**
+     * 在Huffman树中查找符号
+     */
+    findSymbol(value, bits) {
+        for (let i = 0; i < this.huffmanTable.codes.length; i++) {
+            const length = this.huffmanTable.lengths[i];
+            if (bits < length)
+                continue;
+            const code = (value >> (bits - length)) & ((1 << length) - 1);
+            if (code === this.huffmanTable.codes[i]) {
+                return [i, length];
+            }
+        }
+        return null;
+    }
+    // Huffman编码实现  
+    huffmanEncode(bytes) {
+        let result = [];
+        let current = 0;
+        let bits = 0;
+        for (let i = 0; i < bytes.length; i++) {
+            const b = bytes[i];
+            const code = this.huffmanTable.codes[b];
+            const length = this.huffmanTable.lengths[b];
+            bits += length;
+            current = (current << length) | code;
+            while (bits >= 8) {
+                bits -= 8;
+                result.push((current >> bits) & 0xFF);
+            }
+        }
+        // 处理剩余的位  
+        if (bits > 0) {
+            current = (current << (8 - bits)) | ((1 << (8 - bits)) - 1);
+            result.push(current & 0xFF);
+        }
+        return new Uint8Array(result);
+    }
+    decodeHeaderFields(buffer) {
+        const headers = new Map();
+        let index = 0;
+        while (index < buffer.length) {
+            const firstByte = buffer[index];
+            // 检查首字节的类型  
+            if ((firstByte & 0x80) !== 0) { // 1xxxxxxx - Indexed Header Field  
+                const [name, value, newIndex] = this.decodeIndexedHeader(buffer, index);
+                if (name && value)
+                    headers.set(name, value);
+                index = newIndex;
+            }
+            else if ((firstByte & 0x40) !== 0) { // 01xxxxxx - Literal Header Field with Incremental Indexing  
+                const [name, value, newIndex] = this.decodeLiteralHeaderWithIndexing(buffer, index);
+                if (name && value)
+                    headers.set(name, value);
+                index = newIndex;
+            }
+            else if ((firstByte & 0x20) !== 0) { // 001xxxxx - Dynamic Table Size Update  
+                index++; // 简单跳过，实际应该更新动态表大小  
+            }
+            else if ((firstByte & 0x10) !== 0) { // 0001xxxx - Literal Header Field Never Indexed  
+                const [name, value, newIndex] = this.decodeLiteralHeaderWithoutIndexing(buffer, index);
+                if (name && value)
+                    headers.set(name, value);
+                index = newIndex;
+            }
+            else { // 0000xxxx - Literal Header Field without Indexing  
+                const [name, value, newIndex] = this.decodeLiteralHeaderWithoutIndexing(buffer, index);
+                if (name && value)
+                    headers.set(name, value);
+                index = newIndex;
+            }
+        }
+        return headers;
+    }
+    decodeInteger(buffer, startIndex, prefixBits) {
+        const prefix = (1 << prefixBits) - 1;
+        const firstByte = buffer[startIndex];
+        let index = startIndex;
+        let value = firstByte & prefix;
+        if (value < prefix) {
+            return [value, index + 1];
+        }
+        index++;
+        let shift = 0;
+        while (index < buffer.length) {
+            const byte = buffer[index++];
+            value += (byte & 0x7F) << shift;
+            shift += 7;
+            if ((byte & 0x80) === 0) {
+                break;
+            }
+        }
+        return [value, index];
+    }
+    decodeLiteralString(buffer, startIndex) {
+        if (startIndex >= buffer.length) {
+            return ['', startIndex];
+        }
+        const firstByte = buffer[startIndex];
+        const isHuffman = (firstByte & 0x80) !== 0;
+        const [length, index] = this.decodeInteger(buffer, startIndex, 7);
+        if (index + length > buffer.length) {
+            return ['', index];
+        }
+        const bytes = buffer.slice(index, index + length);
+        let result;
+        if (isHuffman) {
+            try {
+                result = this.decode(bytes);
+            }
+            catch (e) {
+                result = '';
+            }
+        }
+        else {
+            try {
+                //    result = new TextDecoder().decode(bytes);  
+                result = toString(bytes);
+            }
+            catch (e) {
+                result = '';
+            }
+        }
+        return [result, index + length];
+    }
+    decodeIndexedHeader(buffer, index) {
+        const [staticIndex, newIndex] = this.decodeInteger(buffer, index, 7);
+        if (staticIndex <= 0) {
+            return ['', '', newIndex];
+        }
+        const headerField = this.staticTable[staticIndex];
+        if (!headerField) {
+            return ['', '', newIndex];
+        }
+        return [headerField[0], headerField[1], newIndex];
+    }
+    decodeLiteralHeaderWithIndexing(buffer, index) {
+        const [staticIndex, nameIndex] = this.decodeInteger(buffer, index, 6);
+        index = nameIndex;
+        let name;
+        if (staticIndex > 0) {
+            const headerField = this.staticTable[staticIndex];
+            name = headerField ? headerField[0] : '';
+        }
+        else {
+            const [decodedName, newIndex] = this.decodeLiteralString(buffer, index);
+            name = decodedName;
+            index = newIndex;
+        }
+        const [value, finalIndex] = this.decodeLiteralString(buffer, index);
+        return [name, value, finalIndex];
+    }
+    decodeLiteralHeaderWithoutIndexing(buffer, index) {
+        return this.decodeLiteralHeaderWithIndexing(buffer, index);
+    }
+    // 直接转换为字符串的方法  
+    huffmanDecodeToString(bytes) {
+        return this.decode(bytes);
+    }
+}
+
+export { HPACK };
+//# sourceMappingURL=hpack.esm.js.map