grpc-libp2p-client 0.0.2 → 0.0.3

package/dist/grpc.js

@@ -0,0 +1,3377 @@
+(function (global, factory) {
+    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
+    typeof define === 'function' && define.amd ? define(['exports'], factory) :
+    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.GrpcLibp2pClient = {}));
+})(this, (function (exports) { 'use strict';
+
+    var global = typeof window !== 'undefined' ? window : this;
+
+    /******************************************************************************
+    Copyright (c) Microsoft Corporation.
+
+    Permission to use, copy, modify, and/or distribute this software for any
+    purpose with or without fee is hereby granted.
+
+    THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+    REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+    AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+    INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+    LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+    OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+    PERFORMANCE OF THIS SOFTWARE.
+    ***************************************************************************** */
+    /* global Reflect, Promise, SuppressedError, Symbol, Iterator */
+
+
+    var __assign = function() {
+        __assign = Object.assign || function __assign(t) {
+            for (var s, i = 1, n = arguments.length; i < n; i++) {
+                s = arguments[i];
+                for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
+            }
+            return t;
+        };
+        return __assign.apply(this, arguments);
+    };
+
+    function __awaiter(thisArg, _arguments, P, generator) {
+        function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+        return new (P || (P = Promise))(function (resolve, reject) {
+            function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+            function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+            function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+            step((generator = generator.apply(thisArg, _arguments || [])).next());
+        });
+    }
+
+    function __generator(thisArg, body) {
+        var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+        return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+        function verb(n) { return function (v) { return step([n, v]); }; }
+        function step(op) {
+            if (f) throw new TypeError("Generator is already executing.");
+            while (g && (g = 0, op[0] && (_ = 0)), _) try {
+                if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+                if (y = 0, t) op = [op[0] & 2, t.value];
+                switch (op[0]) {
+                    case 0: case 1: t = op; break;
+                    case 4: _.label++; return { value: op[1], done: false };
+                    case 5: _.label++; y = op[1]; op = [0]; continue;
+                    case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                    default:
+                        if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                        if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                        if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                        if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                        if (t[2]) _.ops.pop();
+                        _.trys.pop(); continue;
+                }
+                op = body.call(thisArg, _);
+            } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+            if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+        }
+    }
+
+    function __values(o) {
+        var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+        if (m) return m.call(o);
+        if (o && typeof o.length === "number") return {
+            next: function () {
+                if (o && i >= o.length) o = void 0;
+                return { value: o && o[i++], done: !o };
+            }
+        };
+        throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+    }
+
+    function __spreadArray(to, from, pack) {
+        if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+            if (ar || !(i in from)) {
+                if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+                ar[i] = from[i];
+            }
+        }
+        return to.concat(ar || Array.prototype.slice.call(from));
+    }
+
+    function __await(v) {
+        return this instanceof __await ? (this.v = v, this) : new __await(v);
+    }
+
+    function __asyncGenerator(thisArg, _arguments, generator) {
+        if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+        var g = generator.apply(thisArg, _arguments || []), i, q = [];
+        return i = Object.create((typeof AsyncIterator === "function" ? AsyncIterator : Object).prototype), verb("next"), verb("throw"), verb("return", awaitReturn), i[Symbol.asyncIterator] = function () { return this; }, i;
+        function awaitReturn(f) { return function (v) { return Promise.resolve(v).then(f, reject); }; }
+        function verb(n, f) { if (g[n]) { i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; if (f) i[n] = f(i[n]); } }
+        function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
+        function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
+        function fulfill(value) { resume("next", value); }
+        function reject(value) { resume("throw", value); }
+        function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
+    }
+
+    function __asyncValues(o) {
+        if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+        var m = o[Symbol.asyncIterator], i;
+        return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+        function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+        function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+    }
+
+    typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+        var e = new Error(message);
+        return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+    };
+
+    var FRAME_TYPES = {
+        DATA: 0x0, // 传输 HTTP 消息的主体  
+        HEADERS: 0x1, // 压缩的 HTTP 头部  
+        RST_STREAM: 0x3, // 终止流  
+        SETTINGS: 0x4, // 设置连接参数  
+        PING: 0x6, // 测量RTT和活性检查  
+        WINDOW_UPDATE: 0x8};
+    var FRAME_FLAGS = {
+        ACK: 0x1,
+        END_STREAM: 0x1};
+
+    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
+    var HPACK = /** @class */ (function () {
+        function HPACK(maxDynamicTableSize) {
+            if (maxDynamicTableSize === void 0) { 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
+        HPACK.prototype.encode = function (headers) {
+            var buffer = [];
+            for (var _i = 0, _a = Object.entries(headers); _i < _a.length; _i++) {
+                var _b = _a[_i], name_1 = _b[0], value = _b[1];
+                // 查找静态表索引
+                var staticIndex = this.findInStaticTable(name_1, value);
+                if (staticIndex !== -1) {
+                    // 使用索引编码
+                    buffer.push.apply(buffer, this.encodeInteger(staticIndex, 7, 0x80));
+                    continue;
+                }
+                // 查找动态表索引
+                var dynamicIndex = this.findInDynamicTable(name_1, value);
+                if (dynamicIndex !== -1) {
+                    buffer.push.apply(buffer, this.encodeInteger(dynamicIndex + this.staticTable.length, 7, 0x80));
+                    continue;
+                }
+                // 字面量编码
+                this.encodeLiteral(buffer, name_1, 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;
+        // }
+        // 编码整数
+        HPACK.prototype.encodeInteger = function (value, prefixBits, prefix) {
+            if (prefix === void 0) { prefix = 0; }
+            var buffer = [];
+            var 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 };
+        // }
+        // 编码字符串
+        HPACK.prototype.encodeString = function (str) {
+            var buffer = [];
+            var bytes = new TextEncoder().encode(str);
+            // 尝试Huffman编码
+            var huffmanEncoded = this.huffmanEncode(bytes);
+            if (huffmanEncoded.length < bytes.length) {
+                // 使用Huffman编码
+                buffer.push.apply(buffer, this.encodeInteger(huffmanEncoded.length, 7, 0x80));
+                buffer.push.apply(buffer, huffmanEncoded);
+            }
+            else {
+                // 不使用Huffman编码
+                buffer.push.apply(buffer, this.encodeInteger(bytes.length, 7, 0x00));
+                buffer.push.apply(buffer, bytes);
+            }
+            return buffer;
+        };
+        // 在静态表中查找
+        HPACK.prototype.findInStaticTable = function (name, value) {
+            for (var i = 1; i < this.staticTable.length; i++) {
+                if (this.staticTable[i][0] === name &&
+                    this.staticTable[i][1] === value) {
+                    return i;
+                }
+            }
+            return -1;
+        };
+        // 在动态表中查找
+        HPACK.prototype.findInDynamicTable = function (name, value) {
+            for (var i = 0; i < this.dynamicTable.length; i++) {
+                if (this.dynamicTable[i][0] === name &&
+                    this.dynamicTable[i][1] === value) {
+                    return i;
+                }
+            }
+            return -1;
+        };
+        // 编码字面量头部字段
+        HPACK.prototype.encodeLiteral = function (buffer, name, value) {
+            var nameIndex = this.findInStaticTable(name, '');
+            if (nameIndex !== -1) {
+                // 名称索引存在
+                buffer.push.apply(buffer, this.encodeInteger(nameIndex, 6, 0x40));
+            }
+            else {
+                // 名称需要字面量编码
+                buffer.push(0x40);
+                buffer.push.apply(buffer, this.encodeString(name));
+            }
+            // 值总是需要字面量编码
+            buffer.push.apply(buffer, this.encodeString(value));
+            // 添加到动态表
+            this.addToDynamicTable(name, value);
+        };
+        // 添加到动态表
+        HPACK.prototype.addToDynamicTable = function (name, value) {
+            var size = name.length + value.length + 32; // 32 bytes overhead
+            // 确保不超过最大大小
+            while (this.dynamicTableSize + size > this.maxDynamicTableSize &&
+                this.dynamicTable.length > 0) {
+                var 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]);
+        };
+        // 获取索引的头部
+        HPACK.prototype.getIndexedHeader = function (index) {
+            if (index <= this.staticTable.length - 1) {
+                return this.staticTable[index];
+            }
+            return this.dynamicTable[index - this.staticTable.length];
+        };
+        HPACK.prototype.buildHuffmanTable = function () {
+            // 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 解码后的字符串
+         */
+        HPACK.prototype.decode = function (input) {
+            var result = '';
+            var accumulator = 0;
+            var bits = 0;
+            for (var i = 0; i < input.length; i++) {
+                var byte = input[i];
+                accumulator = (accumulator << 8) | byte;
+                bits += 8;
+                while (bits >= 5) {
+                    var decoded = this.findSymbol(accumulator, bits);
+                    if (!decoded) {
+                        break;
+                    }
+                    var symbol = decoded[0], length_1 = decoded[1];
+                    result += String.fromCharCode(symbol);
+                    accumulator &= (1 << (bits - length_1)) - 1;
+                    bits -= length_1;
+                }
+            }
+            // 验证填充  
+            if (bits > 0) {
+                var mask = (1 << bits) - 1;
+                if ((accumulator & mask) !== mask) {
+                    throw new Error('Invalid Huffman padding');
+                }
+            }
+            return result;
+        };
+        /**
+         * 在Huffman树中查找符号
+         */
+        HPACK.prototype.findSymbol = function (value, bits) {
+            for (var i = 0; i < this.huffmanTable.codes.length; i++) {
+                var length_2 = this.huffmanTable.lengths[i];
+                if (bits < length_2)
+                    continue;
+                var code = (value >> (bits - length_2)) & ((1 << length_2) - 1);
+                if (code === this.huffmanTable.codes[i]) {
+                    return [i, length_2];
+                }
+            }
+            return null;
+        };
+        // Huffman编码实现  
+        HPACK.prototype.huffmanEncode = function (bytes) {
+            var result = [];
+            var current = 0;
+            var bits = 0;
+            for (var i = 0; i < bytes.length; i++) {
+                var b = bytes[i];
+                var code = this.huffmanTable.codes[b];
+                var length_3 = this.huffmanTable.lengths[b];
+                bits += length_3;
+                current = (current << length_3) | 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);
+        };
+        HPACK.prototype.decodeHeaderFields = function (buffer) {
+            var headers = new Map();
+            var index = 0;
+            while (index < buffer.length) {
+                var firstByte = buffer[index];
+                // 检查首字节的类型  
+                if ((firstByte & 0x80) !== 0) { // 1xxxxxxx - Indexed Header Field  
+                    var _a = this.decodeIndexedHeader(buffer, index), name_2 = _a[0], value = _a[1], newIndex = _a[2];
+                    if (name_2 && value)
+                        headers.set(name_2, value);
+                    index = newIndex;
+                }
+                else if ((firstByte & 0x40) !== 0) { // 01xxxxxx - Literal Header Field with Incremental Indexing  
+                    var _b = this.decodeLiteralHeaderWithIndexing(buffer, index), name_3 = _b[0], value = _b[1], newIndex = _b[2];
+                    if (name_3 && value)
+                        headers.set(name_3, 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  
+                    var _c = this.decodeLiteralHeaderWithoutIndexing(buffer, index), name_4 = _c[0], value = _c[1], newIndex = _c[2];
+                    if (name_4 && value)
+                        headers.set(name_4, value);
+                    index = newIndex;
+                }
+                else { // 0000xxxx - Literal Header Field without Indexing  
+                    var _d = this.decodeLiteralHeaderWithoutIndexing(buffer, index), name_5 = _d[0], value = _d[1], newIndex = _d[2];
+                    if (name_5 && value)
+                        headers.set(name_5, value);
+                    index = newIndex;
+                }
+            }
+            return headers;
+        };
+        HPACK.prototype.decodeInteger = function (buffer, startIndex, prefixBits) {
+            var prefix = (1 << prefixBits) - 1;
+            var firstByte = buffer[startIndex];
+            var index = startIndex;
+            var value = firstByte & prefix;
+            if (value < prefix) {
+                return [value, index + 1];
+            }
+            index++;
+            var shift = 0;
+            while (index < buffer.length) {
+                var byte = buffer[index++];
+                value += (byte & 0x7F) << shift;
+                shift += 7;
+                if ((byte & 0x80) === 0) {
+                    break;
+                }
+            }
+            return [value, index];
+        };
+        HPACK.prototype.decodeLiteralString = function (buffer, startIndex) {
+            if (startIndex >= buffer.length) {
+                return ['', startIndex];
+            }
+            var firstByte = buffer[startIndex];
+            var isHuffman = (firstByte & 0x80) !== 0;
+            var _a = this.decodeInteger(buffer, startIndex, 7), length = _a[0], index = _a[1];
+            if (index + length > buffer.length) {
+                return ['', index];
+            }
+            var bytes = buffer.slice(index, index + length);
+            var 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];
+        };
+        HPACK.prototype.decodeIndexedHeader = function (buffer, index) {
+            var _a = this.decodeInteger(buffer, index, 7), staticIndex = _a[0], newIndex = _a[1];
+            if (staticIndex <= 0) {
+                return ['', '', newIndex];
+            }
+            var headerField = this.staticTable[staticIndex];
+            if (!headerField) {
+                return ['', '', newIndex];
+            }
+            return [headerField[0], headerField[1], newIndex];
+        };
+        HPACK.prototype.decodeLiteralHeaderWithIndexing = function (buffer, index) {
+            var _a = this.decodeInteger(buffer, index, 6), staticIndex = _a[0], nameIndex = _a[1];
+            index = nameIndex;
+            var name;
+            if (staticIndex > 0) {
+                var headerField = this.staticTable[staticIndex];
+                name = headerField ? headerField[0] : '';
+            }
+            else {
+                var _b = this.decodeLiteralString(buffer, index), decodedName = _b[0], newIndex = _b[1];
+                name = decodedName;
+                index = newIndex;
+            }
+            var _c = this.decodeLiteralString(buffer, index), value = _c[0], finalIndex = _c[1];
+            return [name, value, finalIndex];
+        };
+        HPACK.prototype.decodeLiteralHeaderWithoutIndexing = function (buffer, index) {
+            return this.decodeLiteralHeaderWithIndexing(buffer, index);
+        };
+        // 直接转换为字符串的方法  
+        HPACK.prototype.huffmanDecodeToString = function (bytes) {
+            return this.decode(bytes);
+        };
+        return HPACK;
+    }());
+
+    var FrameEncoder = /** @class */ (function () {
+        function FrameEncoder() {
+        }
+        // 编码SETTINGS帧  
+        FrameEncoder.encodeSettingsFrame = function (frame) {
+            // 计算payload总长度：每个设置项占6字节  
+            var payloadLength = frame.payload.length * 6;
+            // 分配缓冲区：9字节头部 + payload长度  
+            var buffer = new Uint8Array(9 + payloadLength);
+            // 编码帧头部（前9个字节）  
+            _encodeFrameHeader(buffer, {
+                length: payloadLength,
+                type: frame.type,
+                flags: frame.flags,
+                streamId: frame.streamId
+            });
+            // 编码payload  
+            _encodeSettingsPayload(buffer, frame.payload);
+            return buffer;
+        };
+        // 编码SETTINGS ACK帧  
+        FrameEncoder.encodeSettingsAckFrame = function () {
+            var buffer = new Uint8Array(9); // ACK帧只有头部  
+            _encodeFrameHeader(buffer, {
+                length: 0,
+                type: 0x4, // SETTINGS  
+                flags: 0x1, // ACK  
+                streamId: 0
+            });
+            return buffer;
+        };
+        return FrameEncoder;
+    }());
+    // 编码帧头部（9字节）  
+    function _encodeFrameHeader(buffer, header) {
+        var _a;
+        // Length: 3 bytes  
+        var length = (_a = header.length) !== null && _a !== void 0 ? _a : 0;
+        buffer[0] = (length >> 16) & 0xFF;
+        buffer[1] = (length >> 8) & 0xFF;
+        buffer[2] = length & 0xFF;
+        // Type: 1 byte  
+        buffer[3] = header.type;
+        // Flags: 1 byte  
+        buffer[4] = header.flags;
+        // Stream Identifier: 4 bytes  
+        _writeUInt32BE(buffer, header.streamId & 0x7FFFFFFF, 5);
+    }
+    // 编码SETTINGS payload  
+    function _encodeSettingsPayload(buffer, payload) {
+        var offset = 9; // 从第9个字节开始  
+        payload.forEach(function (setting) {
+            // 写入2字节的标识符  
+            _writeUInt16BE(buffer, setting.identifier, offset);
+            offset += 2;
+            // 写入4字节的值  
+            _writeUInt32BE(buffer, setting.value, offset);
+            offset += 4;
+        });
+    }
+    // 写入16位无符号整数（大端序）  
+    function _writeUInt16BE(buffer, value, offset) {
+        buffer[offset] = (value >> 8) & 0xFF;
+        buffer[offset + 1] = value & 0xFF;
+    }
+    // 写入32位无符号整数（大端序）  
+    function _writeUInt32BE(buffer, value, offset) {
+        buffer[offset] = (value >> 24) & 0xFF;
+        buffer[offset + 1] = (value >> 16) & 0xFF;
+        buffer[offset + 2] = (value >> 8) & 0xFF;
+        buffer[offset + 3] = value & 0xFF;
+    }
+
+    var _a;
+    var SETTINGS_PARAMETERS = {
+        HEADER_TABLE_SIZE: 0x1,
+        ENABLE_PUSH: 0x2,
+        MAX_CONCURRENT_STREAMS: 0x3,
+        INITIAL_WINDOW_SIZE: 0x4,
+        MAX_FRAME_SIZE: 0x5,
+        MAX_HEADER_LIST_SIZE: 0x6
+    };
+    var defaultSettings = (_a = {},
+        _a[SETTINGS_PARAMETERS.HEADER_TABLE_SIZE] = 4096,
+        _a[SETTINGS_PARAMETERS.ENABLE_PUSH] = 1,
+        _a[SETTINGS_PARAMETERS.MAX_CONCURRENT_STREAMS] = 100,
+        _a[SETTINGS_PARAMETERS.INITIAL_WINDOW_SIZE] = 4 << 20,
+        _a[SETTINGS_PARAMETERS.MAX_FRAME_SIZE] = 4 << 20,
+        _a[SETTINGS_PARAMETERS.MAX_HEADER_LIST_SIZE] = 8192,
+        _a);
+    var HTTP2_PREFACE = 'PRI * HTTP/2.0\r\n\r\nSM\r\n\r\n';
+    var Http2Frame = /** @class */ (function () {
+        function Http2Frame() {
+        }
+        // 创建并编码PREFACE帧
+        Http2Frame.createPreface = function () {
+            return new TextEncoder().encode(HTTP2_PREFACE);
+        };
+        Http2Frame.createPongFrame = function (payload) {
+            return Http2Frame.createFrame(0x6, 0x1, 0, payload);
+        };
+        // 创建并编码SETTINGS帧  
+        Http2Frame.createSettingsFrame = function (settings) {
+            if (settings === void 0) { settings = {}; }
+            // 先创建帧对象  
+            var frame = Http2Frame.createOriginSettingsFrame(settings);
+            // 然后编码  
+            return FrameEncoder.encodeSettingsFrame(frame);
+        };
+        // 创建并编码SETTINGS ACK帧  
+        Http2Frame.createSettingsAckFrame = function () {
+            return FrameEncoder.encodeSettingsAckFrame();
+        };
+        Http2Frame.createDataFrames = function (streamId, data, shouldEnd, maxFrameSize) {
+            if (shouldEnd === void 0) { shouldEnd = false; }
+            if (maxFrameSize === void 0) { maxFrameSize = 1024; }
+            var frames = [];
+            var offset = 0;
+            while (offset < data.length) {
+                var chunkSize = Math.min(maxFrameSize, data.length - offset);
+                var chunk = data.slice(offset, offset + chunkSize);
+                var isEndStream = shouldEnd && (offset + chunkSize >= data.length); // 最后一帧设置 END_STREAM
+                var frame = Http2Frame.createDataFrame(streamId, chunk, isEndStream);
+                frames.push(frame);
+                offset += chunkSize;
+            }
+            return frames;
+        };
+        Http2Frame.createDataFrame = function (streamId, data, endStream) {
+            if (endStream === void 0) { endStream = true; }
+            // gRPC 消息格式: 压缩标志(1字节) + 消息长度(4字节) + 消息内容  
+            var messageLen = data.length;
+            var framedData = new Uint8Array(5 + messageLen);
+            // Compression flag (0 = 不压缩)  
+            framedData[0] = 0;
+            // Message length (4 bytes)  
+            framedData[1] = (messageLen >> 24) & 0xFF;
+            framedData[2] = (messageLen >> 16) & 0xFF;
+            framedData[3] = (messageLen >> 8) & 0xFF;
+            framedData[4] = messageLen & 0xFF;
+            // Message content  
+            framedData.set(data, 5);
+            var flags = endStream ? 0x01 : 0x0; // END_STREAM flag  
+            return Http2Frame.createFrame(0x0, flags, streamId, framedData);
+        };
+        Http2Frame.createHeadersFrame = function (streamId, path, endHeaders, token) {
+            if (endHeaders === void 0) { endHeaders = true; }
+            // gRPC-Web 需要的标准 headers  
+            var headersList = {
+                ':path': path,
+                ':method': 'POST',
+                ':scheme': 'http',
+                ':authority': 'localhost',
+                'content-type': 'application/grpc+proto',
+                'user-agent': 'grpc-web-client/0.1',
+                'accept': 'application/grpc+proto',
+                'grpc-timeout': '3600S'
+            };
+            if (token) {
+                headersList['authorization'] = "Bearer ".concat(token);
+            }
+            // 将 headers 编码为 HPACK 格式  
+            var hpack = new HPACK();
+            var encodedHeaders = hpack.encode(headersList);
+            console.log('Encoded:', encodedHeaders);
+            // HEADERS frame flags: END_HEADERS | END_STREAM  
+            var flags = endHeaders ? 0x04 : 0x00;
+            return Http2Frame.createFrame(0x01, flags, streamId, encodedHeaders);
+        };
+        Http2Frame.createResponseHeadersFrame = function (streamId, headersList, endHeaders) {
+            if (endHeaders === void 0) { endHeaders = true; }
+            // 将 headers 编码为 HPACK 格式  
+            var hpack = new HPACK();
+            var encodedHeaders = hpack.encode(headersList);
+            console.log('Encoded:', encodedHeaders);
+            // HEADERS frame flags: END_HEADERS | END_STREAM  
+            var flags = endHeaders ? 0x04 : 0x00;
+            return Http2Frame.createFrame(0x01, flags, streamId, encodedHeaders);
+        };
+        Http2Frame.createTrailersFrame = function (streamId, trailers) {
+            // 将 trailers 编码为 HPACK 格式
+            var hpack = new HPACK();
+            var encodedTrailers = hpack.encode(trailers);
+            // HEADERS frame flags: END_HEADERS | END_STREAM
+            var flags = 0x05; // 0x04 (END_HEADERS) | 0x01 (END_STREAM)
+            return Http2Frame.createFrame(0x01, flags, streamId, encodedTrailers);
+        };
+        // 创建 SETTINGS 帧  
+        Http2Frame.createOriginSettingsFrame = function (settings) {
+            if (settings === void 0) { settings = {}; }
+            // 合并默认值和用户提供的设置  
+            var finalSettings = __assign(__assign({}, defaultSettings), settings);
+            // 验证设置值  
+            _validateSettings(finalSettings);
+            // 创建帧  
+            var frame = {
+                type: 0x4, // SETTINGS frame type  
+                flags: 0x0, // 无标志  
+                streamId: 0, // SETTINGS 总是在 stream 0 上发送  
+                payload: _createPayload(finalSettings)
+            };
+            return frame;
+        };
+        // 创建确认帧（SETTINGS ACK）  
+        Http2Frame.createOriginSettingsAckFrame = function () {
+            return {
+                type: 0x4, // SETTINGS frame type  
+                flags: 0x1, // ACK flag  
+                streamId: 0,
+                payload: [] // ACK 帧没有payload  
+            };
+        };
+        Http2Frame.createFrame = function (type, flags, streamId, payload) {
+            var length = payload ? payload.length : 0;
+            var frame = new Uint8Array(9 + length); // 9 bytes for header + payload  
+            // Length (24 bits)  
+            frame[0] = (length >> 16) & 0xFF;
+            frame[1] = (length >> 8) & 0xFF;
+            frame[2] = length & 0xFF;
+            // Type (8 bits)  
+            frame[3] = type;
+            // Flags (8 bits)  
+            frame[4] = flags;
+            // Stream Identifier (32 bits)  
+            frame[5] = (streamId >> 24) & 0xFF;
+            frame[6] = (streamId >> 16) & 0xFF;
+            frame[7] = (streamId >> 8) & 0xFF;
+            frame[8] = streamId & 0xFF;
+            if (payload && length > 0) {
+                frame.set(payload, 9);
+            }
+            return frame;
+        };
+        return Http2Frame;
+    }());
+    // 验证设置值  
+    function _validateSettings(settings) {
+        for (var _i = 0, _a = Object.entries(settings); _i < _a.length; _i++) {
+            var _b = _a[_i], id = _b[0], value = _b[1];
+            switch (Number(id)) {
+                case SETTINGS_PARAMETERS.HEADER_TABLE_SIZE:
+                    if (value < 0) {
+                        throw new Error('HEADER_TABLE_SIZE must be non-negative');
+                    }
+                    break;
+                case SETTINGS_PARAMETERS.ENABLE_PUSH:
+                    if (value !== 0 && value !== 1) {
+                        throw new Error('ENABLE_PUSH must be 0 or 1');
+                    }
+                    break;
+                case SETTINGS_PARAMETERS.INITIAL_WINDOW_SIZE:
+                    if (value < 0 || value > 2147483647) { // 2^31 - 1  
+                        throw new Error('INITIAL_WINDOW_SIZE must be between 0 and 2^31-1');
+                    }
+                    break;
+                case SETTINGS_PARAMETERS.MAX_FRAME_SIZE:
+                    if (value < 16384 || value > 16777215) { // 2^14 to 2^24-1  
+                        throw new Error('MAX_FRAME_SIZE must be between 16,384 and 16,777,215');
+                    }
+                    break;
+                case SETTINGS_PARAMETERS.MAX_CONCURRENT_STREAMS:
+                case SETTINGS_PARAMETERS.MAX_HEADER_LIST_SIZE:
+                    if (value < 0) {
+                        throw new Error("Parameter ".concat(id, " must be non-negative"));
+                    }
+                    break;
+                default:
+                    console.warn("Unknown settings parameter: ".concat(id));
+            }
+        }
+    }
+    // 创建payload  
+    function _createPayload(settings) {
+        var payload = [];
+        for (var _i = 0, _a = Object.entries(settings); _i < _a.length; _i++) {
+            var _b = _a[_i], id = _b[0], value = _b[1];
+            payload.push({
+                identifier: Number(id),
+                value: value
+            });
+        }
+        return payload;
+    }
+
+    var HTTP2Parser = /** @class */ (function () {
+        function HTTP2Parser(writer) {
+            this.buffer = new Uint8Array(0);
+            this.settingsAckReceived = false;
+            // 初始化连接级别的流控制窗口大小（默认值：65,535）
+            this.connectionWindowSize = 4 << 20;
+            // 存储流的Map
+            this.streams = new Map();
+            // 默认的流级别初始窗口大小
+            this.defaultStreamWindowSize = 4 << 20;
+            // 结束标志
+            this.endFlag = false;
+            this.writer = writer;
+        }
+        // 持续处理流数据
+        HTTP2Parser.prototype.processStream = function (stream) {
+            return __awaiter(this, void 0, void 0, function () {
+                var _a, _b, _c, chunk, newData, newBuffer, settingFrme, frameHeader, totalFrameLength, frameData, e_1_1, error_1;
+                var _d, e_1, _e, _f;
+                return __generator(this, function (_g) {
+                    switch (_g.label) {
+                        case 0:
+                            _g.trys.push([0, 15, , 16]);
+                            _g.label = 1;
+                        case 1:
+                            _g.trys.push([1, 8, 9, 14]);
+                            _a = true, _b = __asyncValues(stream.source);
+                            _g.label = 2;
+                        case 2: return [4 /*yield*/, _b.next()];
+                        case 3:
+                            if (!(_c = _g.sent(), _d = _c.done, !_d)) return [3 /*break*/, 7];
+                            _f = _c.value;
+                            _a = false;
+                            chunk = _f;
+                            newData = chunk.subarray();
+                            newBuffer = new Uint8Array(this.buffer.length + newData.length);
+                            newBuffer.set(this.buffer);
+                            newBuffer.set(newData, this.buffer.length);
+                            this.buffer = newBuffer;
+                            _g.label = 4;
+                        case 4:
+                            if (!(this.buffer.length >= 9)) return [3 /*break*/, 6];
+                            // 判断是否有HTTP/2前导
+                            if (this.buffer.length >= 24 && this.isHttp2Preface(this.buffer)) {
+                                console.log("HTTP/2 preface detected");
+                                this.buffer = this.buffer.slice(24);
+                                settingFrme = Http2Frame.createSettingsFrame();
+                                this.writer.write(settingFrme);
+                                return [3 /*break*/, 6];
+                            }
+                            frameHeader = this._parseFrameHeader(this.buffer);
+                            totalFrameLength = 9 + frameHeader.length;
+                            // 检查是否有完整的帧
+                            if (this.buffer.length < totalFrameLength) {
+                                return [3 /*break*/, 6];
+                            }
+                            frameData = this.buffer.slice(0, totalFrameLength);
+                            // 处理不同类型的帧
+                            return [4 /*yield*/, this._handleFrame(frameHeader, frameData)];
+                        case 5:
+                            // 处理不同类型的帧
+                            _g.sent();
+                            // 移除已处理的帧
+                            this.buffer = this.buffer.slice(totalFrameLength);
+                            return [3 /*break*/, 4];
+                        case 6:
+                            _a = true;
+                            return [3 /*break*/, 2];
+                        case 7: return [3 /*break*/, 14];
+                        case 8:
+                            e_1_1 = _g.sent();
+                            e_1 = { error: e_1_1 };
+                            return [3 /*break*/, 14];
+                        case 9:
+                            _g.trys.push([9, , 12, 13]);
+                            if (!(!_a && !_d && (_e = _b.return))) return [3 /*break*/, 11];
+                            return [4 /*yield*/, _e.call(_b)];
+                        case 10:
+                            _g.sent();
+                            _g.label = 11;
+                        case 11: return [3 /*break*/, 13];
+                        case 12:
+                            if (e_1) throw e_1.error;
+                            return [7 /*endfinally*/];
+                        case 13: return [7 /*endfinally*/];
+                        case 14: return [3 /*break*/, 16];
+                        case 15:
+                            error_1 = _g.sent();
+                            console.error("Error processing stream:", error_1);
+                            throw error_1;
+                        case 16: return [2 /*return*/];
+                    }
+                });
+            });
+        };
+        HTTP2Parser.prototype.isHttp2Preface = function (buffer) {
+            var PREFACE = new TextEncoder().encode("PRI * HTTP/2.0\r\n\r\nSM\r\n\r\n");
+            if (buffer.length < PREFACE.length)
+                return false;
+            for (var i = 0; i < PREFACE.length; i++) {
+                if (buffer[i] !== PREFACE[i])
+                    return false;
+            }
+            return true;
+        };
+        // 等待SETTINGS ACK
+        HTTP2Parser.prototype.waitForSettingsAck = function () {
+            var _this = this;
+            return new Promise(function (resolve, reject) {
+                if (_this.settingsAckReceived) {
+                    resolve();
+                    return;
+                }
+                var interval = setInterval(function () {
+                    if (_this.settingsAckReceived) {
+                        clearInterval(interval);
+                        clearTimeout(timeout);
+                        resolve();
+                    }
+                }, 100);
+                var timeout = setTimeout(function () {
+                    clearInterval(interval);
+                    reject(new Error("Settings ACK timeout"));
+                }, 30000);
+            });
+        };
+        // 处理单个帧
+        HTTP2Parser.prototype._handleFrame = function (frameHeader, frameData) {
+            return __awaiter(this, void 0, void 0, function () {
+                var settingsPayload, settings, i, id, value;
+                return __generator(this, function (_a) {
+                    switch (frameHeader.type) {
+                        case FRAME_TYPES.SETTINGS:
+                            if ((frameHeader.flags & FRAME_FLAGS.ACK) === FRAME_FLAGS.ACK) {
+                                this.settingsAckReceived = true;
+                                console.log("Received SETTINGS ACK");
+                            }
+                            else {
+                                settingsPayload = frameData.slice(9);
+                                settings = {};
+                                for (i = 0; i < settingsPayload.length; i += 6) {
+                                    id = settingsPayload[i];
+                                    value = (settingsPayload[i + 1] << 16) |
+                                        (settingsPayload[i + 2] << 8) |
+                                        settingsPayload[i + 3];
+                                    settings[id] = value;
+                                }
+                                console.log("Received SETTINGS:", settings);
+                                //发送ACK
+                                if (this.onSettings) {
+                                    this.onSettings(frameHeader);
+                                }
+                            }
+                            break;
+                        case FRAME_TYPES.DATA:
+                            // 处理数据帧
+                            if (this.onData) {
+                                this.onData(frameData.slice(9), frameHeader); // 跳过帧头
+                            }
+                            //判断是否是最后一个帧
+                            if ((frameHeader.flags & FRAME_FLAGS.END_STREAM) ===
+                                FRAME_FLAGS.END_STREAM) {
+                                this.endFlag = true;
+                                if (this.onEnd) {
+                                    this.onEnd();
+                                }
+                                return [2 /*return*/];
+                            }
+                            break;
+                        case FRAME_TYPES.HEADERS:
+                            // 处理头部帧
+                            if (this.onHeaders) {
+                                this.onHeaders(frameData.slice(9), frameHeader);
+                            }
+                            //判断是否是最后一个帧
+                            if ((frameHeader.flags & FRAME_FLAGS.END_STREAM) ===
+                                FRAME_FLAGS.END_STREAM) {
+                                this.endFlag = true;
+                                if (this.onEnd) {
+                                    this.onEnd();
+                                }
+                                return [2 /*return*/];
+                            }
+                            break;
+                        case FRAME_TYPES.WINDOW_UPDATE:
+                            // 处理窗口更新帧
+                            this.handleWindowUpdateFrame(frameHeader, frameData, frameHeader.streamId);
+                            break;
+                        case FRAME_TYPES.PING:
+                            // 处理PING帧
+                            this._handlePingFrame(frameHeader, frameData);
+                            break;
+                        // case FRAME_TYPES.PUSH_PROMISE:
+                        //     // 处理服务器推送承诺帧
+                        //     this.handlePushPromiseFrame(frameHeader, frameData);
+                        //     break;
+                        case FRAME_TYPES.RST_STREAM:
+                            this.endFlag = true;
+                            if (this.onEnd) {
+                                this.onEnd();
+                            }
+                            break;
+                        default:
+                            console.debug("Unknown frame type:", frameHeader.type);
+                    }
+                    return [2 /*return*/];
+                });
+            });
+        };
+        HTTP2Parser.prototype._parseFrameHeader = function (buffer) {
+            var length = (buffer[0] << 16) | (buffer[1] << 8) | buffer[2];
+            var type = buffer[3];
+            var flags = buffer[4];
+            var streamId = (buffer[5] << 24) | (buffer[6] << 16) | (buffer[7] << 8) | buffer[8];
+            return {
+                length: length,
+                type: type,
+                flags: flags,
+                streamId: streamId,
+                payload: buffer.slice(0, 9),
+            };
+        };
+        // 解析PING帧
+        HTTP2Parser.prototype._handlePingFrame = function (frameHeader, frameData) {
+            // PING帧的payload固定为8字节
+            if (frameHeader.length !== 8) {
+                throw new Error("PING frame must have a length of 8 bytes");
+            }
+            // 反馈PONG帧
+            var pongFrame = Http2Frame.createPongFrame(frameData.slice(9));
+            try {
+                this.writer.write(pongFrame);
+            }
+            catch (error) {
+                console.error("Error sending PONG frame:", error);
+                throw error;
+            }
+        };
+        //等待流结束
+        HTTP2Parser.prototype.waitForEndOfStream = function (waitTime) {
+            var _this = this;
+            return new Promise(function (resolve, reject) {
+                // If the stream has already ended, resolve immediately
+                if (_this.endFlag) {
+                    resolve();
+                    return;
+                }
+                // 如果是0 ,则不设置超时
+                var timeout = null;
+                if (waitTime > 0) {
+                    timeout = setTimeout(function () {
+                        clearInterval(interval);
+                        reject(new Error("End of stream timeout"));
+                    }, waitTime);
+                }
+                // Check interval for real-time endFlag monitoring
+                var checkInterval = 100; // Check every 100 milliseconds
+                // Set an interval to check the endFlag regularly
+                var interval = setInterval(function () {
+                    if (_this.endFlag) {
+                        if (timeout !== null) {
+                            clearTimeout(timeout);
+                        }
+                        clearInterval(interval);
+                        resolve();
+                    }
+                }, checkInterval);
+                // If the onEnd is triggered externally, it should now be marked manually
+                var originalOnEnd = _this.onEnd;
+                _this.onEnd = function () {
+                    if (!_this.endFlag) {
+                        // The external trigger may set endFlag; if not, handle here
+                        _this.endFlag = true;
+                    }
+                    if (timeout !== null) {
+                        clearTimeout(timeout);
+                    }
+                    clearInterval(interval);
+                    resolve();
+                    if (originalOnEnd) {
+                        originalOnEnd(); // Call the original onEnd function if set
+                    }
+                };
+            });
+        };
+        // 解析 WINDOW_UPDATE 帧
+        HTTP2Parser.prototype.parseWindowUpdateFrame = function (frameBuffer, frameHeader) {
+            // WINDOW_UPDATE帧的payload固定为4字节
+            if (frameHeader.length !== 4) {
+                throw new Error("WINDOW_UPDATE frame must have a length of 4 bytes");
+            }
+            // 确保frameBuffer是Uint8Array类型
+            var buffer = new Uint8Array(frameBuffer);
+            // 读取window size increment (4字节，大端序)
+            // 手动计算32位无符号整数，确保最高位为0
+            var windowSizeIncrement = ((buffer[0] & 0x7f) << 24) |
+                (buffer[1] << 16) |
+                (buffer[2] << 8) |
+                buffer[3];
+            // 验证window size increment
+            if (windowSizeIncrement === 0) {
+                throw new Error("WINDOW_UPDATE increment must not be zero");
+            }
+            return {
+                windowSizeIncrement: windowSizeIncrement,
+            };
+        };
+        // 处理 WINDOW_UPDATE 帧
+        HTTP2Parser.prototype.handleWindowUpdateFrame = function (frameHeader, payload, streamId) {
+            try {
+                var windowUpdate = this.parseWindowUpdateFrame(payload, frameHeader);
+                this.connectionWindowSize += windowUpdate.windowSizeIncrement;
+                console.log("Connection window size increased by ".concat(windowUpdate.windowSizeIncrement));
+                return windowUpdate;
+            }
+            catch (error) {
+                // 处理错误情况
+                console.error("Error handling WINDOW_UPDATE frame:", error);
+                throw error;
+            }
+        };
+        return HTTP2Parser;
+    }());
+
+    function pDefer() {
+    	const deferred = {};
+
+    	deferred.promise = new Promise((resolve, reject) => {
+    		deferred.resolve = resolve;
+    		deferred.reject = reject;
+    	});
+
+    	return deferred;
+    }
+
+    // ported from https://www.npmjs.com/package/fast-fifo
+    class FixedFIFO {
+        buffer;
+        mask;
+        top;
+        btm;
+        next;
+        constructor(hwm) {
+            if (!(hwm > 0) || ((hwm - 1) & hwm) !== 0) {
+                throw new Error('Max size for a FixedFIFO should be a power of two');
+            }
+            this.buffer = new Array(hwm);
+            this.mask = hwm - 1;
+            this.top = 0;
+            this.btm = 0;
+            this.next = null;
+        }
+        push(data) {
+            if (this.buffer[this.top] !== undefined) {
+                return false;
+            }
+            this.buffer[this.top] = data;
+            this.top = (this.top + 1) & this.mask;
+            return true;
+        }
+        shift() {
+            const last = this.buffer[this.btm];
+            if (last === undefined) {
+                return undefined;
+            }
+            this.buffer[this.btm] = undefined;
+            this.btm = (this.btm + 1) & this.mask;
+            return last;
+        }
+        isEmpty() {
+            return this.buffer[this.btm] === undefined;
+        }
+    }
+    class FIFO {
+        size;
+        hwm;
+        head;
+        tail;
+        constructor(options = {}) {
+            this.hwm = options.splitLimit ?? 16;
+            this.head = new FixedFIFO(this.hwm);
+            this.tail = this.head;
+            this.size = 0;
+        }
+        calculateSize(obj) {
+            if (obj?.byteLength != null) {
+                return obj.byteLength;
+            }
+            return 1;
+        }
+        push(val) {
+            if (val?.value != null) {
+                this.size += this.calculateSize(val.value);
+            }
+            if (!this.head.push(val)) {
+                const prev = this.head;
+                this.head = prev.next = new FixedFIFO(2 * this.head.buffer.length);
+                this.head.push(val);
+            }
+        }
+        shift() {
+            let val = this.tail.shift();
+            if (val === undefined && (this.tail.next != null)) {
+                const next = this.tail.next;
+                this.tail.next = null;
+                this.tail = next;
+                val = this.tail.shift();
+            }
+            if (val?.value != null) {
+                this.size -= this.calculateSize(val.value);
+            }
+            return val;
+        }
+        isEmpty() {
+            return this.head.isEmpty();
+        }
+    }
+
+    /**
+     * @packageDocumentation
+     *
+     * An iterable that you can push values into.
+     *
+     * @example
+     *
+     * ```js
+     * import { pushable } from 'it-pushable'
+     *
+     * const source = pushable()
+     *
+     * setTimeout(() => source.push('hello'), 100)
+     * setTimeout(() => source.push('world'), 200)
+     * setTimeout(() => source.end(), 300)
+     *
+     * const start = Date.now()
+     *
+     * for await (const value of source) {
+     *   console.log(`got "${value}" after ${Date.now() - start}ms`)
+     * }
+     * console.log(`done after ${Date.now() - start}ms`)
+     *
+     * // Output:
+     * // got "hello" after 105ms
+     * // got "world" after 207ms
+     * // done after 309ms
+     * ```
+     *
+     * @example
+     *
+     * ```js
+     * import { pushableV } from 'it-pushable'
+     * import all from 'it-all'
+     *
+     * const source = pushableV()
+     *
+     * source.push(1)
+     * source.push(2)
+     * source.push(3)
+     * source.end()
+     *
+     * console.info(await all(source))
+     *
+     * // Output:
+     * // [ [1, 2, 3] ]
+     * ```
+     */
+    let AbortError$1 = class AbortError extends Error {
+        type;
+        code;
+        constructor(message, code) {
+            super(message ?? 'The operation was aborted');
+            this.type = 'aborted';
+            this.code = code ?? 'ABORT_ERR';
+        }
+    };
+    function pushable(options = {}) {
+        const getNext = (buffer) => {
+            const next = buffer.shift();
+            if (next == null) {
+                return { done: true };
+            }
+            if (next.error != null) {
+                throw next.error;
+            }
+            return {
+                done: next.done === true,
+                // @ts-expect-error if done is false, value will be present
+                value: next.value
+            };
+        };
+        return _pushable(getNext, options);
+    }
+    function _pushable(getNext, options) {
+        options = options ?? {};
+        let onEnd = options.onEnd;
+        let buffer = new FIFO();
+        let pushable;
+        let onNext;
+        let ended;
+        let drain = pDefer();
+        const waitNext = async () => {
+            try {
+                if (!buffer.isEmpty()) {
+                    return getNext(buffer);
+                }
+                if (ended) {
+                    return { done: true };
+                }
+                return await new Promise((resolve, reject) => {
+                    onNext = (next) => {
+                        onNext = null;
+                        buffer.push(next);
+                        try {
+                            resolve(getNext(buffer));
+                        }
+                        catch (err) {
+                            reject(err);
+                        }
+                        return pushable;
+                    };
+                });
+            }
+            finally {
+                if (buffer.isEmpty()) {
+                    // settle promise in the microtask queue to give consumers a chance to
+                    // await after calling .push
+                    queueMicrotask(() => {
+                        drain.resolve();
+                        drain = pDefer();
+                    });
+                }
+            }
+        };
+        const bufferNext = (next) => {
+            if (onNext != null) {
+                return onNext(next);
+            }
+            buffer.push(next);
+            return pushable;
+        };
+        const bufferError = (err) => {
+            buffer = new FIFO();
+            if (onNext != null) {
+                return onNext({ error: err });
+            }
+            buffer.push({ error: err });
+            return pushable;
+        };
+        const push = (value) => {
+            if (ended) {
+                return pushable;
+            }
+            // @ts-expect-error `byteLength` is not declared on PushType
+            if (options?.objectMode !== true && value?.byteLength == null) {
+                throw new Error('objectMode was not true but tried to push non-Uint8Array value');
+            }
+            return bufferNext({ done: false, value });
+        };
+        const end = (err) => {
+            if (ended)
+                return pushable;
+            ended = true;
+            return (err != null) ? bufferError(err) : bufferNext({ done: true });
+        };
+        const _return = () => {
+            buffer = new FIFO();
+            end();
+            return { done: true };
+        };
+        const _throw = (err) => {
+            end(err);
+            return { done: true };
+        };
+        pushable = {
+            [Symbol.asyncIterator]() { return this; },
+            next: waitNext,
+            return: _return,
+            throw: _throw,
+            push,
+            end,
+            get readableLength() {
+                return buffer.size;
+            },
+            onEmpty: async (options) => {
+                const signal = options?.signal;
+                signal?.throwIfAborted();
+                if (buffer.isEmpty()) {
+                    return;
+                }
+                let cancel;
+                let listener;
+                if (signal != null) {
+                    cancel = new Promise((resolve, reject) => {
+                        listener = () => {
+                            reject(new AbortError$1());
+                        };
+                        signal.addEventListener('abort', listener);
+                    });
+                }
+                try {
+                    await Promise.race([
+                        drain.promise,
+                        cancel
+                    ]);
+                }
+                finally {
+                    if (listener != null && signal != null) {
+                        signal?.removeEventListener('abort', listener);
+                    }
+                }
+            }
+        };
+        if (onEnd == null) {
+            return pushable;
+        }
+        const _pushable = pushable;
+        pushable = {
+            [Symbol.asyncIterator]() { return this; },
+            next() {
+                return _pushable.next();
+            },
+            throw(err) {
+                _pushable.throw(err);
+                if (onEnd != null) {
+                    onEnd(err);
+                    onEnd = undefined;
+                }
+                return { done: true };
+            },
+            return() {
+                _pushable.return();
+                if (onEnd != null) {
+                    onEnd();
+                    onEnd = undefined;
+                }
+                return { done: true };
+            },
+            push,
+            end(err) {
+                _pushable.end(err);
+                if (onEnd != null) {
+                    onEnd(err);
+                    onEnd = undefined;
+                }
+                return pushable;
+            },
+            get readableLength() {
+                return _pushable.readableLength;
+            },
+            onEmpty: (opts) => {
+                return _pushable.onEmpty(opts);
+            }
+        };
+        return pushable;
+    }
+
+    /**
+     * An abort error class that extends error
+     */
+    class AbortError extends Error {
+        type;
+        code;
+        constructor(message, code, name) {
+            super(message ?? 'The operation was aborted');
+            this.type = 'aborted';
+            this.name = name ?? 'AbortError';
+            this.code = code ?? 'ABORT_ERR';
+        }
+    }
+    /**
+     * Race a promise against an abort signal
+     */
+    async function raceSignal(promise, signal, opts) {
+        if (signal == null) {
+            return promise;
+        }
+        if (signal.aborted) {
+            // the passed promise may yet resolve or reject but the use has signalled
+            // they are no longer interested so smother the error
+            promise.catch(() => { });
+            return Promise.reject(new AbortError(opts?.errorMessage, opts?.errorCode, opts?.errorName));
+        }
+        let listener;
+        // create the error here so we have more context in the stack trace
+        const error = new AbortError(opts?.errorMessage, opts?.errorCode, opts?.errorName);
+        try {
+            return await Promise.race([
+                promise,
+                new Promise((resolve, reject) => {
+                    listener = () => {
+                        reject(error);
+                    };
+                    signal.addEventListener('abort', listener);
+                })
+            ]);
+        }
+        finally {
+            if (listener != null) {
+                signal.removeEventListener('abort', listener);
+            }
+        }
+    }
+
+    /**
+     * @packageDocumentation
+     *
+     * A pushable async generator that waits until the current value is consumed
+     * before allowing a new value to be pushed.
+     *
+     * Useful for when you don't want to keep memory usage under control and/or
+     * allow a downstream consumer to dictate how fast data flows through a pipe,
+     * but you want to be able to apply a transform to that data.
+     *
+     * @example
+     *
+     * ```typescript
+     * import { queuelessPushable } from 'it-queueless-pushable'
+     *
+     * const pushable = queuelessPushable<string>()
+     *
+     * // run asynchronously
+     * Promise.resolve().then(async () => {
+     *   // push a value - the returned promise will not resolve until the value is
+     *   // read from the pushable
+     *   await pushable.push('hello')
+     * })
+     *
+     * // read a value
+     * const result = await pushable.next()
+     * console.info(result) // { done: false, value: 'hello' }
+     * ```
+     */
+    class QueuelessPushable {
+        readNext;
+        haveNext;
+        ended;
+        nextResult;
+        error;
+        constructor() {
+            this.ended = false;
+            this.readNext = pDefer();
+            this.haveNext = pDefer();
+        }
+        [Symbol.asyncIterator]() {
+            return this;
+        }
+        async next() {
+            if (this.nextResult == null) {
+                // wait for the supplier to push a value
+                await this.haveNext.promise;
+            }
+            if (this.nextResult == null) {
+                throw new Error('HaveNext promise resolved but nextResult was undefined');
+            }
+            const nextResult = this.nextResult;
+            this.nextResult = undefined;
+            // signal to the supplier that we read the value
+            this.readNext.resolve();
+            this.readNext = pDefer();
+            return nextResult;
+        }
+        async throw(err) {
+            this.ended = true;
+            this.error = err;
+            if (err != null) {
+                // this can cause unhandled promise rejections if nothing is awaiting the
+                // next value so attach a dummy catch listener to the promise
+                this.haveNext.promise.catch(() => { });
+                this.haveNext.reject(err);
+            }
+            const result = {
+                done: true,
+                value: undefined
+            };
+            return result;
+        }
+        async return() {
+            const result = {
+                done: true,
+                value: undefined
+            };
+            this.ended = true;
+            this.nextResult = result;
+            // let the consumer know we have a new value
+            this.haveNext.resolve();
+            return result;
+        }
+        async push(value, options) {
+            await this._push(value, options);
+        }
+        async end(err, options) {
+            if (err != null) {
+                await this.throw(err);
+            }
+            else {
+                // abortable return
+                await this._push(undefined, options);
+            }
+        }
+        async _push(value, options) {
+            if (value != null && this.ended) {
+                throw this.error ?? new Error('Cannot push value onto an ended pushable');
+            }
+            // wait for all values to be read
+            while (this.nextResult != null) {
+                await this.readNext.promise;
+            }
+            if (value != null) {
+                this.nextResult = { done: false, value };
+            }
+            else {
+                this.ended = true;
+                this.nextResult = { done: true, value: undefined };
+            }
+            // let the consumer know we have a new value
+            this.haveNext.resolve();
+            this.haveNext = pDefer();
+            // wait for the consumer to have finished processing the value and requested
+            // the next one or for the passed signal to abort the waiting
+            await raceSignal(this.readNext.promise, options?.signal, options);
+        }
+    }
+    function queuelessPushable() {
+        return new QueuelessPushable();
+    }
+
+    /**
+     * @packageDocumentation
+     *
+     * Merge several (async)iterables into one, yield values as they arrive.
+     *
+     * Nb. sources are iterated over in parallel so the order of emitted items is not guaranteed.
+     *
+     * @example
+     *
+     * ```javascript
+     * import merge from 'it-merge'
+     * import all from 'it-all'
+     *
+     * // This can also be an iterator, generator, etc
+     * const values1 = [0, 1, 2, 3, 4]
+     * const values2 = [5, 6, 7, 8, 9]
+     *
+     * const arr = all(merge(values1, values2))
+     *
+     * console.info(arr) // 0, 1, 2, 3, 4, 5, 6, 7, 8, 9
+     * ```
+     *
+     * Async sources must be awaited:
+     *
+     * ```javascript
+     * import merge from 'it-merge'
+     * import all from 'it-all'
+     *
+     * // This can also be an iterator, async iterator, generator, etc
+     * const values1 = async function * () {
+     *   yield * [0, 1, 2, 3, 4]
+     * }
+     * const values2 = async function * () {
+     *   yield * [5, 6, 7, 8, 9]
+     * }
+     *
+     * const arr = await all(merge(values1(), values2()))
+     *
+     * console.info(arr) // 0, 1, 5, 6, 2, 3, 4, 7, 8, 9  <- nb. order is not guaranteed
+     * ```
+     */
+    function isAsyncIterable$1(thing) {
+        return thing[Symbol.asyncIterator] != null;
+    }
+    async function addAllToPushable(sources, output) {
+        try {
+            await Promise.all(sources.map(async (source) => {
+                for await (const item of source) {
+                    await output.push(item);
+                }
+            }));
+            await output.end();
+        }
+        catch (err) {
+            await output.end(err)
+                .catch(() => { });
+        }
+    }
+    async function* mergeSources(sources) {
+        const output = queuelessPushable();
+        addAllToPushable(sources, output)
+            .catch(() => { });
+        yield* output;
+    }
+    function* mergeSyncSources(syncSources) {
+        for (const source of syncSources) {
+            yield* source;
+        }
+    }
+    function merge(...sources) {
+        const syncSources = [];
+        for (const source of sources) {
+            if (!isAsyncIterable$1(source)) {
+                syncSources.push(source);
+            }
+        }
+        if (syncSources.length === sources.length) {
+            // all sources are synchronous
+            return mergeSyncSources(syncSources);
+        }
+        return mergeSources(sources);
+    }
+
+    function pipe(first, ...rest) {
+        if (first == null) {
+            throw new Error('Empty pipeline');
+        }
+        // Duplex at start: wrap in function and return duplex source
+        if (isDuplex(first)) {
+            const duplex = first;
+            first = () => duplex.source;
+            // Iterable at start: wrap in function
+        }
+        else if (isIterable(first) || isAsyncIterable(first)) {
+            const source = first;
+            first = () => source;
+        }
+        const fns = [first, ...rest];
+        if (fns.length > 1) {
+            // Duplex at end: use duplex sink
+            if (isDuplex(fns[fns.length - 1])) {
+                fns[fns.length - 1] = fns[fns.length - 1].sink;
+            }
+        }
+        if (fns.length > 2) {
+            // Duplex in the middle, consume source with duplex sink and return duplex source
+            for (let i = 1; i < fns.length - 1; i++) {
+                if (isDuplex(fns[i])) {
+                    fns[i] = duplexPipelineFn(fns[i]);
+                }
+            }
+        }
+        return rawPipe(...fns);
+    }
+    const rawPipe = (...fns) => {
+        let res;
+        while (fns.length > 0) {
+            res = fns.shift()(res);
+        }
+        return res;
+    };
+    const isAsyncIterable = (obj) => {
+        return obj?.[Symbol.asyncIterator] != null;
+    };
+    const isIterable = (obj) => {
+        return obj?.[Symbol.iterator] != null;
+    };
+    const isDuplex = (obj) => {
+        if (obj == null) {
+            return false;
+        }
+        return obj.sink != null && obj.source != null;
+    };
+    const duplexPipelineFn = (duplex) => {
+        return (source) => {
+            const p = duplex.sink(source);
+            if (p?.then != null) {
+                const stream = pushable({
+                    objectMode: true
+                });
+                p.then(() => {
+                    stream.end();
+                }, (err) => {
+                    stream.end(err);
+                });
+                let sourceWrap;
+                const source = duplex.source;
+                if (isAsyncIterable(source)) {
+                    sourceWrap = async function* () {
+                        yield* source;
+                        stream.end();
+                    };
+                }
+                else if (isIterable(source)) {
+                    sourceWrap = function* () {
+                        yield* source;
+                        stream.end();
+                    };
+                }
+                else {
+                    throw new Error('Unknown duplex source type - must be Iterable or AsyncIterable');
+                }
+                return merge(stream, sourceWrap());
+            }
+            return duplex.source;
+        };
+    };
+
+    var MaxChunkSize = 4 * 1024 - 5;
+    var StreamWriter = /** @class */ (function () {
+        function StreamWriter(sink, options) {
+            if (options === void 0) { options = {}; }
+            var _this = this;
+            var _a, _b, _c;
+            this.sink = sink;
+            this.options = options;
+            //private p = pushable({ objectMode: false }) 
+            this.bytesWritten = 0;
+            this.abortController = new AbortController();
+            // 背压控制相关属性  
+            this.backpressureHistory = [];
+            this.isBackpressure = false;
+            this.writeQueue = [];
+            this.isProcessingQueue = false;
+            // 事件系统  
+            this.listeners = new Map();
+            if (options) {
+                this.options = {
+                    chunkSize: (_a = options.chunkSize) !== null && _a !== void 0 ? _a : MaxChunkSize,
+                    bufferSize: (_b = options.bufferSize) !== null && _b !== void 0 ? _b : 5 * 1024 * 1024,
+                    retries: (_c = options.retries) !== null && _c !== void 0 ? _c : 3
+                };
+            }
+            else {
+                this.options = {
+                    chunkSize: MaxChunkSize,
+                    bufferSize: 5 * 1024 * 1024,
+                    retries: 3
+                };
+            }
+            if (this.options.chunkSize && this.options.chunkSize > MaxChunkSize) {
+                this.options.chunkSize = MaxChunkSize;
+            }
+            var basePushable = pushable({ objectMode: false });
+            // 保留原始方法引用  
+            basePushable._originalPush = basePushable.push.bind(basePushable);
+            basePushable._originalNext = basePushable.next.bind(basePushable);
+            basePushable._queueSize = 0;
+            // 重写 next 方法  
+            Object.defineProperty(basePushable, 'next', {
+                value: function () { return __awaiter(_this, void 0, void 0, function () {
+                    var result;
+                    return __generator(this, function (_a) {
+                        switch (_a.label) {
+                            case 0: return [4 /*yield*/, basePushable._originalNext()];
+                            case 1:
+                                result = _a.sent();
+                                if (!result.done && result.value) {
+                                    basePushable._queueSize -= result.value.byteLength;
+                                }
+                                return [2 /*return*/, result];
+                        }
+                    });
+                }); },
+                writable: false,
+                configurable: false
+            });
+            // 安全重写 push 方法  
+            Object.defineProperty(basePushable, 'push', {
+                value: function (chunk) {
+                    basePushable._queueSize += chunk.byteLength;
+                    return basePushable._originalPush(chunk);
+                },
+                writable: false,
+                configurable: false
+            });
+            this.p = basePushable;
+            this.startPipeline();
+        }
+        Object.defineProperty(StreamWriter.prototype, "queueSize", {
+            get: function () {
+                return this.p._queueSize;
+            },
+            enumerable: false,
+            configurable: true
+        });
+        // 在 next() 操作时更新队列大小  
+        StreamWriter.prototype.safeNext = function () {
+            return __awaiter(this, void 0, void 0, function () {
+                var result;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0: return [4 /*yield*/, this.p.next()];
+                        case 1:
+                            result = _a.sent();
+                            if (!result.done) {
+                                this.p._queueSize -= result.value.byteLength;
+                            }
+                            return [2 /*return*/, result];
+                    }
+                });
+            });
+        };
+        StreamWriter.prototype.handleError = function (err) {
+            this.dispatchEvent(new CustomEvent('error', { detail: err }));
+            this.abort(err.message);
+        };
+        StreamWriter.prototype.startPipeline = function () {
+            var _this = this;
+            pipe(this.p, this.createTransform(), this.sink).catch(function (err) { return _this.handleError(err); }); // 正确绑定this  
+        };
+        StreamWriter.prototype.createTransform = function () {
+            return function (source) {
+                return __asyncGenerator(this, arguments, function () {
+                    var _a, source_1, source_1_1, chunk, e_1_1;
+                    var _b, e_1, _c, _d;
+                    return __generator(this, function (_e) {
+                        switch (_e.label) {
+                            case 0:
+                                _e.trys.push([0, 7, 8, 13]);
+                                _a = true, source_1 = __asyncValues(source);
+                                _e.label = 1;
+                            case 1: return [4 /*yield*/, __await(source_1.next())];
+                            case 2:
+                                if (!(source_1_1 = _e.sent(), _b = source_1_1.done, !_b)) return [3 /*break*/, 6];
+                                _d = source_1_1.value;
+                                _a = false;
+                                chunk = _d;
+                                return [4 /*yield*/, __await(chunk)];
+                            case 3: return [4 /*yield*/, _e.sent()];
+                            case 4:
+                                _e.sent();
+                                _e.label = 5;
+                            case 5:
+                                _a = true;
+                                return [3 /*break*/, 1];
+                            case 6: return [3 /*break*/, 13];
+                            case 7:
+                                e_1_1 = _e.sent();
+                                e_1 = { error: e_1_1 };
+                                return [3 /*break*/, 13];
+                            case 8:
+                                _e.trys.push([8, , 11, 12]);
+                                if (!(!_a && !_b && (_c = source_1.return))) return [3 /*break*/, 10];
+                                return [4 /*yield*/, __await(_c.call(source_1))];
+                            case 9:
+                                _e.sent();
+                                _e.label = 10;
+                            case 10: return [3 /*break*/, 12];
+                            case 11:
+                                if (e_1) throw e_1.error;
+                                return [7 /*endfinally*/];
+                            case 12: return [7 /*endfinally*/];
+                            case 13: return [2 /*return*/];
+                        }
+                    });
+                });
+            };
+        };
+        StreamWriter.prototype.write = function (data) {
+            return __awaiter(this, void 0, void 0, function () {
+                var _this = this;
+                return __generator(this, function (_a) {
+                    if (this.abortController.signal.aborted)
+                        return [2 /*return*/];
+                    return [2 /*return*/, new Promise(function (resolve, reject) {
+                            var task = function () { return __awaiter(_this, void 0, void 0, function () {
+                                var buffer, err_1;
+                                return __generator(this, function (_a) {
+                                    switch (_a.label) {
+                                        case 0:
+                                            _a.trys.push([0, 3, , 4]);
+                                            return [4 /*yield*/, this.convertToBuffer(data)];
+                                        case 1:
+                                            buffer = _a.sent();
+                                            return [4 /*yield*/, this.writeChunks(buffer)];
+                                        case 2:
+                                            _a.sent();
+                                            resolve();
+                                            return [3 /*break*/, 4];
+                                        case 3:
+                                            err_1 = _a.sent();
+                                            reject(err_1);
+                                            return [3 /*break*/, 4];
+                                        case 4: return [2 /*return*/];
+                                    }
+                                });
+                            }); };
+                            _this.writeQueue.push(task);
+                            _this.processQueue();
+                        })];
+                });
+            });
+        };
+        StreamWriter.prototype.convertToBuffer = function (data) {
+            return __awaiter(this, void 0, void 0, function () {
+                return __generator(this, function (_a) {
+                    if (data instanceof Blob)
+                        return [2 /*return*/, data.arrayBuffer()];
+                    if (typeof data === 'string')
+                        return [2 /*return*/, new TextEncoder().encode(data).buffer];
+                    return [2 /*return*/, data];
+                });
+            });
+        };
+        StreamWriter.prototype.writeChunks = function (buffer) {
+            return __awaiter(this, void 0, void 0, function () {
+                var offset, end, chunk;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0:
+                            offset = 0;
+                            _a.label = 1;
+                        case 1:
+                            if (!(offset < buffer.byteLength)) return [3 /*break*/, 4];
+                            end = Math.min(offset + this.options.chunkSize, buffer.byteLength);
+                            chunk = new Uint8Array(end - offset);
+                            chunk.set(new Uint8Array(buffer.slice(offset, end)));
+                            return [4 /*yield*/, this.retryableWrite(chunk)];
+                        case 2:
+                            _a.sent();
+                            this.updateProgress(chunk.byteLength);
+                            _a.label = 3;
+                        case 3:
+                            offset += this.options.chunkSize;
+                            return [3 /*break*/, 1];
+                        case 4: return [2 /*return*/];
+                    }
+                });
+            });
+        };
+        StreamWriter.prototype.retryableWrite = function (chunk_1) {
+            return __awaiter(this, arguments, void 0, function (chunk, attempt) {
+                var err_2, delay_1;
+                var _this = this;
+                if (attempt === void 0) { attempt = 0; }
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0:
+                            _a.trys.push([0, 3, , 6]);
+                            return [4 /*yield*/, this.monitorBackpressure()];
+                        case 1:
+                            _a.sent();
+                            return [4 /*yield*/, new Promise(function (resolve, reject) {
+                                    try {
+                                        _this.p.push(chunk);
+                                    }
+                                    catch (err) {
+                                        reject(err);
+                                    }
+                                    resolve();
+                                })];
+                        case 2:
+                            _a.sent();
+                            return [3 /*break*/, 6];
+                        case 3:
+                            err_2 = _a.sent();
+                            if (!(attempt < this.options.retries)) return [3 /*break*/, 5];
+                            delay_1 = this.calculateRetryDelay(attempt);
+                            return [4 /*yield*/, new Promise(function (r) { return setTimeout(r, delay_1); })];
+                        case 4:
+                            _a.sent();
+                            return [2 /*return*/, this.retryableWrite(chunk, attempt + 1)];
+                        case 5: throw err_2;
+                        case 6: return [2 /*return*/];
+                    }
+                });
+            });
+        };
+        StreamWriter.prototype.monitorBackpressure = function () {
+            return __awaiter(this, void 0, void 0, function () {
+                var checkInterval, historySize, _loop_1, this_1, state_1;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0:
+                            checkInterval = 50;
+                            historySize = 10;
+                            _loop_1 = function () {
+                                var currentSize, avg, dynamicThreshold, waitTime;
+                                return __generator(this, function (_b) {
+                                    switch (_b.label) {
+                                        case 0:
+                                            currentSize = this_1.queueSize // 空值合并运算符  
+                                            ;
+                                            if (currentSize > 0) {
+                                                this_1.backpressureHistory.push(currentSize);
+                                            }
+                                            if (this_1.backpressureHistory.length > historySize) {
+                                                this_1.backpressureHistory.shift();
+                                            }
+                                            avg = this_1.backpressureHistory.reduce(function (a, b) { return a + b; }, 0) / historySize;
+                                            dynamicThreshold = Math.min(this_1.options.bufferSize * 0.8, avg * 1.5);
+                                            if (currentSize < dynamicThreshold || currentSize === 0) {
+                                                if (this_1.isBackpressure) {
+                                                    this_1.isBackpressure = false;
+                                                    this_1.dispatchEvent(new CustomEvent('backpressure', {
+                                                        detail: {
+                                                            currentSize: currentSize,
+                                                            averageSize: avg,
+                                                            threshold: dynamicThreshold,
+                                                            waitingTime: 0
+                                                        }
+                                                    }));
+                                                }
+                                                return [2 /*return*/, { value: void 0 }];
+                                            }
+                                            if (!this_1.isBackpressure) {
+                                                this_1.isBackpressure = true;
+                                                this_1.dispatchEvent(new CustomEvent('backpressure', {
+                                                    detail: {
+                                                        currentSize: currentSize,
+                                                        averageSize: avg,
+                                                        threshold: dynamicThreshold,
+                                                        waitingTime: 0
+                                                    }
+                                                }));
+                                            }
+                                            waitTime = Math.min(10, checkInterval * Math.pow(2, currentSize / dynamicThreshold));
+                                            return [4 /*yield*/, new Promise(function (r) { return setTimeout(r, waitTime); })];
+                                        case 1:
+                                            _b.sent();
+                                            if (this_1.abortController.signal.aborted)
+                                                return [2 /*return*/, "break"];
+                                            return [2 /*return*/];
+                                    }
+                                });
+                            };
+                            this_1 = this;
+                            _a.label = 1;
+                        case 1:
+                            return [5 /*yield**/, _loop_1()];
+                        case 2:
+                            state_1 = _a.sent();
+                            if (typeof state_1 === "object")
+                                return [2 /*return*/, state_1.value];
+                            if (state_1 === "break")
+                                return [3 /*break*/, 3];
+                            return [3 /*break*/, 1];
+                        case 3: return [2 /*return*/];
+                    }
+                });
+            });
+        };
+        StreamWriter.prototype.calculateRetryDelay = function (attempt) {
+            var baseDelay = 10;
+            var maxDelay = 100;
+            return Math.min(baseDelay * Math.pow(2, attempt) + Math.random() * 100, maxDelay);
+        };
+        StreamWriter.prototype.processQueue = function () {
+            return __awaiter(this, void 0, void 0, function () {
+                var task;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0:
+                            if (this.isProcessingQueue || this.abortController.signal.aborted)
+                                return [2 /*return*/];
+                            this.isProcessingQueue = true;
+                            _a.label = 1;
+                        case 1:
+                            if (!(this.writeQueue.length > 0)) return [3 /*break*/, 4];
+                            if (this.abortController.signal.aborted)
+                                return [3 /*break*/, 4];
+                            return [4 /*yield*/, this.monitorBackpressure()];
+                        case 2:
+                            _a.sent();
+                            task = this.writeQueue.shift();
+                            return [4 /*yield*/, task()];
+                        case 3:
+                            _a.sent();
+                            return [3 /*break*/, 1];
+                        case 4:
+                            this.isProcessingQueue = false;
+                            return [2 /*return*/];
+                    }
+                });
+            });
+        };
+        StreamWriter.prototype.updateProgress = function (bytes) {
+            this.bytesWritten += bytes;
+            this.dispatchEvent(new CustomEvent('progress', {
+                detail: { loaded: this.bytesWritten }
+            }));
+        };
+        StreamWriter.prototype.end = function () {
+            return __awaiter(this, void 0, void 0, function () {
+                var _a, _b;
+                return __generator(this, function (_c) {
+                    switch (_c.label) {
+                        case 0:
+                            this.p.end();
+                            return [4 /*yield*/, ((_b = (_a = this.sink).return) === null || _b === void 0 ? void 0 : _b.call(_a))];
+                        case 1:
+                            _c.sent();
+                            this.cleanup();
+                            return [2 /*return*/];
+                    }
+                });
+            });
+        };
+        StreamWriter.prototype.abort = function (reason) {
+            if (reason === void 0) { reason = 'User aborted'; }
+            this.abortController.abort(reason);
+            this.cleanup();
+            this.dispatchEvent(new CustomEvent('abort', { detail: reason }));
+        };
+        StreamWriter.prototype.cleanup = function () {
+            this.p.end();
+            this.abortController.abort();
+            this.writeQueue = [];
+        };
+        StreamWriter.prototype.addEventListener = function (type, callback) {
+            var handlers = this.listeners.get(type) || [];
+            handlers.push(callback);
+            this.listeners.set(type, handlers);
+        };
+        // 修复后的代码片段  
+        StreamWriter.prototype.dispatchEvent = function (event) {
+            var handlers = this.listeners.get(event.type) || [];
+            handlers.forEach(function (handler) { return handler(event); });
+        };
+        // 明确指定事件类型  
+        StreamWriter.prototype.dispatchBackpressureEvent = function (detail) {
+            this.dispatchEvent(new CustomEvent('backpressure', {
+                detail: detail
+            }));
+        };
+        return StreamWriter;
+    }());
+
+    console.log("ASDDSDS");
+    var StreamManager = /** @class */ (function () {
+        function StreamManager() {
+            this.currentStreamId = 1; // 从 1 开始，以模拟奇数 ID  
+        }
+        StreamManager.prototype.getNextAppLevelStreamId = function () {
+            var id = this.currentStreamId;
+            this.currentStreamId += 2; // 确保奇数步进  
+            return id;
+        };
+        return StreamManager;
+    }());
+    var Libp2pGrpcClient = /** @class */ (function () {
+        function Libp2pGrpcClient(node, peerAddr, token, protocol) {
+            this.node = node;
+            this.peerAddr = peerAddr;
+            if (protocol) {
+                this.protocol = protocol;
+            }
+            else {
+                this.protocol = '/dc/thread/0.0.1';
+            }
+            this.steamManager = new StreamManager();
+            this.token = token;
+        }
+        Libp2pGrpcClient.prototype.setToken = function (token) {
+            this.token = token;
+        };
+        Libp2pGrpcClient.prototype.unaryCall = function (method, requestData, timeout) {
+            return __awaiter(this, void 0, void 0, function () {
+                var stream, responseData, hpack, exitFlag, errMsg, connection, streamId, writer_1, parser, preface, settingFrme, headerFrame, dataFrame, err_1;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0:
+                            stream = null;
+                            responseData = null;
+                            hpack = new HPACK();
+                            exitFlag = false;
+                            errMsg = '';
+                            _a.label = 1;
+                        case 1:
+                            _a.trys.push([1, 11, 12, 15]);
+                            return [4 /*yield*/, this.node.dial(this.peerAddr)];
+                        case 2:
+                            connection = _a.sent();
+                            return [4 /*yield*/, connection.newStream(this.protocol, {
+                                    maxOutboundStreams: 5
+                                })];
+                        case 3:
+                            stream = _a.sent();
+                            streamId = this.steamManager.getNextAppLevelStreamId();
+                            writer_1 = new StreamWriter(stream.sink);
+                            parser = new HTTP2Parser(writer_1);
+                            parser.onData = function (payload, frameHeader) {
+                                responseData = payload.subarray(5);
+                            };
+                            parser.onSettings = function () {
+                                console.log('Settings received');
+                                var ackSettingFrame = Http2Frame.createSettingsAckFrame();
+                                writer_1.write(ackSettingFrame);
+                            };
+                            parser.onHeaders = function (headers, header) {
+                                var plainHeaders = hpack.decodeHeaderFields(headers);
+                                console.log('Received headers:', plainHeaders);
+                                if (plainHeaders.get('grpc-status') === '0') {
+                                    console.log('gRPC call success');
+                                }
+                                else if (plainHeaders.get('grpc-status') !== undefined) {
+                                    exitFlag = true;
+                                    errMsg = plainHeaders.get('grpc-message') || 'gRPC call failed';
+                                }
+                            };
+                            parser.processStream(stream);
+                            preface = Http2Frame.createPreface();
+                            return [4 /*yield*/, writer_1.write(preface)
+                                // 发送Settings请求
+                            ];
+                        case 4:
+                            _a.sent();
+                            settingFrme = Http2Frame.createSettingsFrame();
+                            return [4 /*yield*/, writer_1.write(settingFrme)];
+                        case 5:
+                            _a.sent();
+                            return [4 /*yield*/, parser.waitForSettingsAck()
+                                // 创建头部帧
+                            ];
+                        case 6:
+                            _a.sent();
+                            headerFrame = Http2Frame.createHeadersFrame(streamId, method, true, this.token);
+                            return [4 /*yield*/, writer_1.write(headerFrame)
+                                // 创建数据帧
+                            ];
+                        case 7:
+                            _a.sent();
+                            dataFrame = Http2Frame.createDataFrame(streamId, requestData, true);
+                            // 发送请求
+                            return [4 /*yield*/, writer_1.write(dataFrame)
+                                // 等待responseData 不为空,或超时
+                            ];
+                        case 8:
+                            // 发送请求
+                            _a.sent();
+                            // 等待responseData 不为空,或超时
+                            return [4 /*yield*/, new Promise(function (resolve, reject) {
+                                    var t = setTimeout(function () {
+                                        reject(new Error('gRPC response timeout'));
+                                    }, timeout);
+                                    var checkResponse = function () {
+                                        if (responseData || exitFlag) {
+                                            clearTimeout(t);
+                                            resolve(responseData);
+                                        }
+                                        else {
+                                            setTimeout(checkResponse, 50);
+                                        }
+                                    };
+                                    checkResponse();
+                                })];
+                        case 9:
+                            // 等待responseData 不为空,或超时
+                            _a.sent();
+                            return [4 /*yield*/, writer_1.end()];
+                        case 10:
+                            _a.sent();
+                            return [3 /*break*/, 15];
+                        case 11:
+                            err_1 = _a.sent();
+                            console.error('unaryCall error:', err_1);
+                            throw err_1;
+                        case 12:
+                            if (!stream) return [3 /*break*/, 14];
+                            return [4 /*yield*/, stream.close()];
+                        case 13:
+                            _a.sent();
+                            _a.label = 14;
+                        case 14: return [7 /*endfinally*/];
+                        case 15:
+                            if (exitFlag) {
+                                throw new Error(errMsg);
+                            }
+                            if (!responseData) {
+                                responseData = new Uint8Array();
+                            }
+                            return [2 /*return*/, responseData];
+                    }
+                });
+            });
+        };
+        Libp2pGrpcClient.prototype.Call = function (method, requestData, timeout, mode, onDataCallback, dataSourceCallback, onEndCallback, onErrorCallback) {
+            return __awaiter(this, void 0, void 0, function () {
+                var timeoutHandle, timeoutPromise, hpack, operationPromise;
+                var _this = this;
+                return __generator(this, function (_a) {
+                    timeoutPromise = new Promise(function (_, reject) {
+                        return timeoutHandle = setTimeout(function () { return reject(new Error('Operation timed out')); }, timeout);
+                    });
+                    hpack = new HPACK();
+                    operationPromise = (function () { return __awaiter(_this, void 0, void 0, function () {
+                        var stream, connection, streamId, writer_2, parser, preface, settingFrame, ackSettingFrame, headerFrame, dataFrame, dataFrame, _a, _b, _c, chunk, dataFrame, e_1_1, finalFrame, err_2;
+                        var _this = this;
+                        var _d, e_1, _e, _f;
+                        return __generator(this, function (_g) {
+                            switch (_g.label) {
+                                case 0:
+                                    stream = null;
+                                    _g.label = 1;
+                                case 1:
+                                    _g.trys.push([1, 29, 30, 33]);
+                                    return [4 /*yield*/, this.node.dial(this.peerAddr)];
+                                case 2:
+                                    connection = _g.sent();
+                                    return [4 /*yield*/, connection.newStream(this.protocol)];
+                                case 3:
+                                    stream = _g.sent();
+                                    streamId = this.steamManager.getNextAppLevelStreamId();
+                                    writer_2 = new StreamWriter(stream.sink);
+                                    parser = new HTTP2Parser(writer_2);
+                                    clearTimeout(timeoutHandle);
+                                    // Define the onData method to utilize the provided callback  
+                                    parser.onData = function (payload, frameHeader) { return __awaiter(_this, void 0, void 0, function () {
+                                        return __generator(this, function (_a) {
+                                            try {
+                                                onDataCallback(payload.subarray(5));
+                                            }
+                                            catch (error) {
+                                                if (onErrorCallback) {
+                                                    onErrorCallback(error);
+                                                }
+                                                else {
+                                                    throw error;
+                                                }
+                                            }
+                                            return [2 /*return*/];
+                                        });
+                                    }); };
+                                    parser.onSettings = function () {
+                                        console.log('Settings received');
+                                        var ackSettingFrame = Http2Frame.createSettingsAckFrame();
+                                        writer_2.write(ackSettingFrame);
+                                    };
+                                    parser.onHeaders = function (headers, header) {
+                                        var plainHeaders = hpack.decodeHeaderFields(headers);
+                                        console.log('Received headers:', plainHeaders);
+                                        if (plainHeaders.get('grpc-status') === '0') {
+                                            console.log('gRPC call success');
+                                        }
+                                        else if (plainHeaders.get('grpc-status') !== undefined) {
+                                            var errMsg = plainHeaders.get('grpc-message') || 'gRPC call failed';
+                                            var err = new Error(errMsg);
+                                            if (onErrorCallback) {
+                                                onErrorCallback(err);
+                                            }
+                                            else {
+                                                throw err;
+                                            }
+                                        }
+                                    };
+                                    parser.processStream(stream);
+                                    preface = Http2Frame.createPreface();
+                                    return [4 /*yield*/, writer_2.write(preface)];
+                                case 4:
+                                    _g.sent();
+                                    settingFrame = Http2Frame.createSettingsFrame();
+                                    return [4 /*yield*/, writer_2.write(settingFrame)];
+                                case 5:
+                                    _g.sent();
+                                    // Wait for the acknowledgement of SETTINGS  
+                                    return [4 /*yield*/, parser.waitForSettingsAck()];
+                                case 6:
+                                    // Wait for the acknowledgement of SETTINGS  
+                                    _g.sent();
+                                    ackSettingFrame = Http2Frame.createSettingsAckFrame();
+                                    return [4 /*yield*/, writer_2.write(ackSettingFrame)];
+                                case 7:
+                                    _g.sent();
+                                    headerFrame = Http2Frame.createHeadersFrame(streamId, method, true, this.token);
+                                    if (!(mode === 'unary' || mode === 'server-streaming')) return [3 /*break*/, 9];
+                                    dataFrame = Http2Frame.createDataFrame(streamId, requestData, true);
+                                    return [4 /*yield*/, writer_2.write(new Uint8Array(__spreadArray(__spreadArray([], headerFrame, true), dataFrame, true)))];
+                                case 8:
+                                    _g.sent();
+                                    return [3 /*break*/, 27];
+                                case 9:
+                                    if (!((mode === 'client-streaming' || mode === 'bidirectional') && dataSourceCallback)) return [3 /*break*/, 27];
+                                    return [4 /*yield*/, writer_2.write(headerFrame)];
+                                case 10:
+                                    _g.sent();
+                                    if (!(requestData.length > 0)) return [3 /*break*/, 12];
+                                    dataFrame = Http2Frame.createDataFrame(streamId, requestData, false);
+                                    return [4 /*yield*/, writer_2.write(dataFrame)];
+                                case 11:
+                                    _g.sent();
+                                    _g.label = 12;
+                                case 12:
+                                    _g.trys.push([12, 18, 19, 24]);
+                                    _a = true, _b = __asyncValues(dataSourceCallback());
+                                    _g.label = 13;
+                                case 13: return [4 /*yield*/, _b.next()];
+                                case 14:
+                                    if (!(_c = _g.sent(), _d = _c.done, !_d)) return [3 /*break*/, 17];
+                                    _f = _c.value;
+                                    _a = false;
+                                    chunk = _f;
+                                    dataFrame = Http2Frame.createDataFrame(streamId, chunk, false);
+                                    return [4 /*yield*/, writer_2.write(dataFrame)];
+                                case 15:
+                                    _g.sent();
+                                    _g.label = 16;
+                                case 16:
+                                    _a = true;
+                                    return [3 /*break*/, 13];
+                                case 17: return [3 /*break*/, 24];
+                                case 18:
+                                    e_1_1 = _g.sent();
+                                    e_1 = { error: e_1_1 };
+                                    return [3 /*break*/, 24];
+                                case 19:
+                                    _g.trys.push([19, , 22, 23]);
+                                    if (!(!_a && !_d && (_e = _b.return))) return [3 /*break*/, 21];
+                                    return [4 /*yield*/, _e.call(_b)];
+                                case 20:
+                                    _g.sent();
+                                    _g.label = 21;
+                                case 21: return [3 /*break*/, 23];
+                                case 22:
+                                    if (e_1) throw e_1.error;
+                                    return [7 /*endfinally*/];
+                                case 23: return [7 /*endfinally*/];
+                                case 24:
+                                    finalFrame = Http2Frame.createDataFrame(streamId, new Uint8Array(), true);
+                                    return [4 /*yield*/, writer_2.write(finalFrame)];
+                                case 25:
+                                    _g.sent();
+                                    return [4 /*yield*/, writer_2.end()];
+                                case 26:
+                                    _g.sent();
+                                    _g.label = 27;
+                                case 27: return [4 /*yield*/, parser.waitForEndOfStream(0)];
+                                case 28:
+                                    _g.sent();
+                                    if (onEndCallback) {
+                                        onEndCallback();
+                                    }
+                                    return [3 /*break*/, 33];
+                                case 29:
+                                    err_2 = _g.sent();
+                                    if (onErrorCallback) {
+                                        onErrorCallback(err_2);
+                                    }
+                                    else {
+                                        if (err_2 instanceof Error) {
+                                            console.error('asyncCall error:', err_2.message);
+                                        }
+                                        else {
+                                            console.error('asyncCall error:', err_2);
+                                        }
+                                    }
+                                    return [3 /*break*/, 33];
+                                case 30:
+                                    if (!stream) return [3 /*break*/, 32];
+                                    return [4 /*yield*/, stream.close()];
+                                case 31:
+                                    _g.sent();
+                                    _g.label = 32;
+                                case 32: return [7 /*endfinally*/];
+                                case 33: return [2 /*return*/];
+                            }
+                        });
+                    }); })();
+                    return [2 /*return*/, Promise.race([operationPromise, timeoutPromise])];
+                });
+            });
+        };
+        return Libp2pGrpcClient;
+    }());
+
+    exports.Libp2pGrpcClient = Libp2pGrpcClient;
+
+}));
+//# sourceMappingURL=grpc.js.map