web-dc-api 0.0.61 → 0.0.62

package/dist/cjs/node_modules/grpc-libp2p-client/dist/index.esm.js

@@ -0,0 +1,2392 @@
+'use strict';
+
+require('../../../_virtual/es.regexp.flags.js');
+var index$1 = require('../../it-pipe/dist/src/index.js');
+var index = require('../../it-pushable/dist/src/index.js');
+
+const FRAME_TYPES = {
+  DATA: 0x0,
+  // 传输 HTTP 消息的主体  
+  HEADERS: 0x1,
+  // 压缩的 HTTP 头部  
+  RST_STREAM: 0x3,
+  // 终止流  
+  SETTINGS: 0x4,
+  // 设置连接参数  
+  PING: 0x6,
+  // 测量RTT和活性检查  
+  WINDOW_UPDATE: 0x8
+};
+const 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(_ref) {
+  let {
+    name,
+    prefix,
+    encode,
+    decode
+  } = _ref;
+  return new Codec(name, prefix, encode, decode);
+}
+function baseX(_ref2) {
+  let {
+    name,
+    prefix,
+    alphabet
+  } = _ref2;
+  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(_ref3) {
+  let {
+    name,
+    prefix,
+    bitsPerChar,
+    alphabet
+  } = _ref3;
+  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() {
+  let size = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 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) {
+  let encoding = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'utf8';
+  const base = BASES[encoding];
+  if (base == null) {
+    throw new Error(`Unsupported encoding "${encoding}"`);
+  }
+  // strip multibase prefix
+  return base.encoder.encode(array).substring(1);
+}
+
+// HPACK Implementation
+class HPACK {
+  constructor() {
+    let maxDynamicTableSize = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 4096;
+    // 初始化动态表
+    this.dynamicTable = [];
+    this.dynamicTableSize = 0;
+    this.maxDynamicTableSize = maxDynamicTableSize;
+    // 初始化静态表
+    this.staticTable = [['', ''],
+    // Index 0 is not used
+    [':authority', ''], [':method', 'GET'], [':method', 'POST'], [':path', '/'], [':path', '/index.html'], [':scheme', 'http'], [':scheme', 'https'], [':status', '200'], [':status', '204'], [':status', '206'], [':status', '304'], [':status', '400'], [':status', '404'], [':status', '500'], ['accept-charset', ''], ['accept-encoding', 'gzip, deflate'], ['accept-language', ''], ['accept-ranges', ''], ['accept', ''], ['access-control-allow-origin', ''], ['age', ''], ['allow', ''], ['authorization', ''], ['cache-control', ''], ['content-disposition', ''], ['content-encoding', ''], ['content-language', ''], ['content-length', ''], ['content-location', ''], ['content-range', ''], ['content-type', ''], ['cookie', ''], ['date', ''], ['etag', ''], ['expect', ''], ['expires', ''], ['from', ''], ['host', ''], ['if-match', ''], ['if-modified-since', ''], ['if-none-match', ''], ['if-range', ''], ['if-unmodified-since', ''], ['last-modified', ''], ['link', ''], ['location', ''], ['max-forwards', ''], ['proxy-authenticate', ''], ['proxy-authorization', ''], ['range', ''], ['referer', ''], ['refresh', ''], ['retry-after', ''], ['server', ''], ['set-cookie', ''], ['strict-transport-security', ''], ['transfer-encoding', ''], ['user-agent', ''], ['vary', ''], ['via', ''], ['www-authenticate', '']];
+    // Huffman编码表
+    this.huffmanTable = this.buildHuffmanTable();
+  }
+  // 编码headers
+  encode(headers) {
+    const buffer = [];
+    for (const [name, value] of Object.entries(headers)) {
+      // 查找静态表索引
+      const staticIndex = this.findInStaticTable(name, value);
+      if (staticIndex !== -1) {
+        // 使用索引编码
+        buffer.push(...this.encodeInteger(staticIndex, 7, 0x80));
+        continue;
+      }
+      // 查找动态表索引
+      const dynamicIndex = this.findInDynamicTable(name, value);
+      if (dynamicIndex !== -1) {
+        buffer.push(...this.encodeInteger(dynamicIndex + this.staticTable.length, 7, 0x80));
+        continue;
+      }
+      // 字面量编码
+      this.encodeLiteral(buffer, name, value);
+    }
+    return new Uint8Array(buffer);
+  }
+  // // 解码二进制数据
+  // decode(buffer: Uint8Array): { [key: string]: string } {
+  //     const headers: { [key: string]: string } = {};
+  //     let pos = 0;
+  //     while (pos < buffer.length) {
+  //         const firstByte = buffer[pos];
+  //         // 检查是否是索引头部字段
+  //         if ((firstByte & 0x80) === 0x80) {
+  //             const { value: index, bytesRead } = this.decodeInteger(
+  //                 buffer.slice(pos),
+  //                 7
+  //             );
+  //             pos += bytesRead;
+  //             const [name, value] = this.getIndexedHeader(index);
+  //             if (name !== undefined && value !== undefined) {
+  //                 headers[name] = value;
+  //             }
+  //         }
+  //         // 字面量头部字段
+  //         else {
+  //             const { name, value, bytesRead } = this.decodeLiteral(
+  //                 buffer.slice(pos)
+  //             );
+  //             pos += bytesRead;
+  //             headers[name] = value;
+  //         }
+  //     }
+  //     return headers;
+  // }
+  // 编码整数
+  encodeInteger(value, prefixBits) {
+    let prefix = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 0;
+    const buffer = [];
+    const mask = (1 << prefixBits) - 1;
+    if (value < mask) {
+      buffer.push(prefix | value);
+      return buffer;
+    }
+    buffer.push(prefix | mask);
+    value -= mask;
+    while (value >= 128) {
+      buffer.push(value & 127 | 128);
+      value = value >> 7;
+    }
+    buffer.push(value);
+    return buffer;
+  }
+  // // 解码整数
+  // decodeInteger(buffer: Uint8Array, prefixBits: number) {
+  //     let value = buffer[0] & ((1 << prefixBits) - 1);
+  //     let bytesRead = 1;
+  //     if (value === (1 << prefixBits) - 1) {
+  //         let shift = 0;
+  //         do {
+  //             value += (buffer[bytesRead] & 127) << shift;
+  //             shift += 7;
+  //             bytesRead++;
+  //         } while (buffer[bytesRead - 1] & 128);
+  //     }
+  //     return { value, bytesRead };
+  // }
+  // 编码字符串
+  encodeString(str) {
+    const buffer = [];
+    const bytes = new TextEncoder().encode(str);
+    // 尝试Huffman编码
+    const huffmanEncoded = this.huffmanEncode(bytes);
+    if (huffmanEncoded.length < bytes.length) {
+      // 使用Huffman编码
+      buffer.push(...this.encodeInteger(huffmanEncoded.length, 7, 0x80));
+      buffer.push(...huffmanEncoded);
+    } else {
+      // 不使用Huffman编码
+      buffer.push(...this.encodeInteger(bytes.length, 7, 0x00));
+      buffer.push(...bytes);
+    }
+    return buffer;
+  }
+  // 在静态表中查找
+  findInStaticTable(name, value) {
+    for (let i = 1; i < this.staticTable.length; i++) {
+      if (this.staticTable[i][0] === name && this.staticTable[i][1] === value) {
+        return i;
+      }
+    }
+    return -1;
+  }
+  // 在动态表中查找
+  findInDynamicTable(name, value) {
+    for (let i = 0; i < this.dynamicTable.length; i++) {
+      if (this.dynamicTable[i][0] === name && this.dynamicTable[i][1] === value) {
+        return i;
+      }
+    }
+    return -1;
+  }
+  // 编码字面量头部字段
+  encodeLiteral(buffer, name, value) {
+    const nameIndex = this.findInStaticTable(name, '');
+    if (nameIndex !== -1) {
+      // 名称索引存在
+      buffer.push(...this.encodeInteger(nameIndex, 6, 0x40));
+    } else {
+      // 名称需要字面量编码
+      buffer.push(0x40);
+      buffer.push(...this.encodeString(name));
+    }
+    // 值总是需要字面量编码
+    buffer.push(...this.encodeString(value));
+    // 添加到动态表
+    this.addToDynamicTable(name, value);
+  }
+  // 添加到动态表
+  addToDynamicTable(name, value) {
+    const size = name.length + value.length + 32; // 32 bytes overhead
+    // 确保不超过最大大小
+    while (this.dynamicTableSize + size > this.maxDynamicTableSize && this.dynamicTable.length > 0) {
+      const entry = this.dynamicTable.pop();
+      if (entry) {
+        this.dynamicTableSize -= entry[0].length + entry[1].length + 32;
+      }
+    }
+    if (size <= this.maxDynamicTableSize) {
+      this.dynamicTable.unshift([name, value]);
+      this.dynamicTableSize += size;
+    }
+    this.dynamicTable.push([name, value]);
+  }
+  // 获取索引的头部
+  getIndexedHeader(index) {
+    if (index <= this.staticTable.length - 1) {
+      return this.staticTable[index];
+    }
+    return this.dynamicTable[index - this.staticTable.length];
+  }
+  buildHuffmanTable() {
+    // HTTP/2规范中定义的完整Huffman编码表  
+    return {
+      codes: new Uint32Array([0x1ff8, 0x7fffd8, 0xfffffe2, 0xfffffe3, 0xfffffe4, 0xfffffe5, 0xfffffe6, 0xfffffe7, 0xfffffe8, 0xffffea, 0x3ffffffc, 0xfffffe9, 0xfffffea, 0x3ffffffd, 0xfffffeb, 0xfffffec, 0xfffffed, 0xfffffee, 0xfffffef, 0xffffff0, 0xffffff1, 0xffffff2, 0x3ffffffe, 0xffffff3, 0xffffff4, 0xffffff5, 0xffffff6, 0xffffff7, 0xffffff8, 0xffffff9, 0xffffffa, 0xffffffb, 0x14, 0x3f8, 0x3f9, 0xffa, 0x1ff9, 0x15, 0xf8, 0x7fa, 0x3fa, 0x3fb, 0xf9, 0x7fb, 0xfa, 0x16, 0x17, 0x18, 0x0, 0x1, 0x2, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x5c, 0xfb, 0x7ffc, 0x20, 0xffb, 0x3fc, 0x1ffa, 0x21, 0x5d, 0x5e, 0x5f, 0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6a, 0x6b, 0x6c, 0x6d, 0x6e, 0x6f, 0x70, 0x71, 0x72, 0xfc, 0x73, 0xfd, 0x1ffb, 0x7fff0, 0x1ffc, 0x3ffc, 0x22, 0x7ffd, 0x3, 0x23, 0x4, 0x24, 0x5, 0x25, 0x26, 0x27, 0x6, 0x74, 0x75, 0x28, 0x29, 0x2a, 0x7, 0x2b, 0x76, 0x2c, 0x8, 0x9, 0x2d, 0x77, 0x78, 0x79, 0x7a, 0x7b, 0x7ffe, 0x7fc, 0x3ffd, 0x1ffd, 0xffffffc, 0xfffe6, 0x3fffd2, 0xfffe7, 0xfffe8, 0x3fffd3, 0x3fffd4, 0x3fffd5, 0x7fffd9, 0x3fffd6, 0x7fffda, 0x7fffdb, 0x7fffdc, 0x7fffdd, 0x7fffde, 0xffffeb, 0x7fffdf, 0xffffec, 0xffffed, 0x3fffd7, 0x7fffe0, 0xffffee, 0x7fffe1, 0x7fffe2, 0x7fffe3, 0x7fffe4, 0x1fffdc, 0x3fffd8, 0x7fffe5, 0x3fffd9, 0x7fffe6, 0x7fffe7, 0xffffef, 0x3fffda, 0x1fffdd, 0xfffe9, 0x3fffdb, 0x3fffdc, 0x7fffe8, 0x7fffe9, 0x1fffde, 0x7fffea, 0x3fffdd, 0x3fffde, 0xfffff0, 0x1fffdf, 0x3fffdf, 0x7fffeb, 0x7fffec, 0x1fffe0, 0x1fffe1, 0x3fffe0, 0x1fffe2, 0x7fffed, 0x3fffe1, 0x7fffee, 0x7fffef, 0xfffea, 0x3fffe2, 0x3fffe3, 0x3fffe4, 0x7ffff0, 0x3fffe5, 0x3fffe6, 0x7ffff1, 0x3ffffe0, 0x3ffffe1, 0xfffeb, 0x7fff1, 0x3fffe7, 0x7ffff2, 0x3fffe8, 0x1ffffec, 0x3ffffe2, 0x3ffffe3, 0x3ffffe4, 0x7ffffde, 0x7ffffdf, 0x3ffffe5, 0xfffff1, 0x1ffffed, 0x7fff2, 0x1fffe3, 0x3ffffe6, 0x7ffffe0, 0x7ffffe1, 0x3ffffe7, 0x7ffffe2, 0xfffff2, 0x1fffe4, 0x1fffe5, 0x3ffffe8, 0x3ffffe9, 0xffffffd, 0x7ffffe3, 0x7ffffe4, 0x7ffffe5, 0xfffec, 0xfffff3, 0xfffed, 0x1fffe6, 0x3fffe9, 0x1fffe7, 0x1fffe8, 0x7ffff3, 0x3fffea, 0x3fffeb, 0x1ffffee, 0x1ffffef, 0xfffff4, 0xfffff5, 0x3ffffea, 0x7ffff4, 0x3ffffeb, 0x7ffffe6, 0x3ffffec, 0x3ffffed, 0x7ffffe7, 0x7ffffe8, 0x7ffffe9, 0x7ffffea, 0x7ffffeb, 0xffffffe, 0x7ffffec, 0x7ffffed, 0x7ffffee, 0x7ffffef, 0x7fffff0, 0x3ffffee]),
+      lengths: new Uint8Array([13, 23, 28, 28, 28, 28, 28, 28, 28, 24, 30, 28, 28, 30, 28, 28, 28, 28, 28, 28, 28, 28, 30, 28, 28, 28, 28, 28, 28, 28, 28, 28, 6, 10, 10, 12, 13, 6, 8, 11, 10, 10, 8, 11, 8, 6, 6, 6, 5, 5, 5, 6, 6, 6, 6, 6, 6, 6, 7, 8, 15, 6, 12, 10, 13, 6, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 8, 7, 8, 13, 19, 13, 14, 6, 15, 5, 6, 5, 6, 5, 6, 6, 6, 5, 7, 7, 6, 6, 6, 5, 6, 7, 6, 5, 5, 6, 7, 7, 7, 7, 7, 15, 11, 14, 13, 28, 20, 22, 20, 20, 22, 22, 22, 23, 22, 23, 23, 23, 23, 23, 24, 23, 24, 24, 22, 23, 24, 23, 23, 23, 23, 21, 22, 23, 22, 23, 23, 24, 22, 21, 20, 22, 22, 23, 23, 21, 23, 22, 22, 24, 21, 22, 23, 23, 21, 21, 22, 21, 23, 22, 23, 23, 20, 22, 22, 22, 23, 22, 22, 23, 26, 26, 20, 19, 22, 23, 22, 25, 26, 26, 26, 27, 27, 26, 24, 25, 19, 21, 26, 27, 27, 26, 27, 24, 21, 21, 26, 26, 28, 27, 27, 27, 20, 24, 20, 21, 22, 21, 21, 23, 22, 22, 25, 25, 24, 24, 26, 23, 26, 27, 26, 26, 27, 27, 27, 27, 27, 28, 27, 27, 27, 27, 27, 26])
+    };
+  }
+  /**
+   * 解码Uint8Array为字符串
+   * @param input 编码后的Uint8Array
+   * @returns 解码后的字符串
+   */
+  decode(input) {
+    let result = '';
+    let accumulator = 0;
+    let bits = 0;
+    for (let i = 0; i < input.length; i++) {
+      const byte = input[i];
+      accumulator = accumulator << 8 | byte;
+      bits += 8;
+      while (bits >= 5) {
+        const decoded = this.findSymbol(accumulator, bits);
+        if (!decoded) {
+          break;
+        }
+        const [symbol, length] = decoded;
+        result += String.fromCharCode(symbol);
+        accumulator &= (1 << bits - length) - 1;
+        bits -= length;
+      }
+    }
+    // 验证填充  
+    if (bits > 0) {
+      const mask = (1 << bits) - 1;
+      if ((accumulator & mask) !== mask) {
+        throw new Error('Invalid Huffman padding');
+      }
+    }
+    return result;
+  }
+  /**
+   * 在Huffman树中查找符号
+   */
+  findSymbol(value, bits) {
+    for (let i = 0; i < this.huffmanTable.codes.length; i++) {
+      const length = this.huffmanTable.lengths[i];
+      if (bits < length) continue;
+      const code = value >> bits - length & (1 << length) - 1;
+      if (code === this.huffmanTable.codes[i]) {
+        return [i, length];
+      }
+    }
+    return null;
+  }
+  // Huffman编码实现  
+  huffmanEncode(bytes) {
+    let result = [];
+    let current = 0;
+    let bits = 0;
+    for (let i = 0; i < bytes.length; i++) {
+      const b = bytes[i];
+      const code = this.huffmanTable.codes[b];
+      const length = this.huffmanTable.lengths[b];
+      bits += length;
+      current = current << length | code;
+      while (bits >= 8) {
+        bits -= 8;
+        result.push(current >> bits & 0xFF);
+      }
+    }
+    // 处理剩余的位  
+    if (bits > 0) {
+      current = current << 8 - bits | (1 << 8 - bits) - 1;
+      result.push(current & 0xFF);
+    }
+    return new Uint8Array(result);
+  }
+  decodeHeaderFields(buffer) {
+    const headers = new Map();
+    let index = 0;
+    while (index < buffer.length) {
+      const firstByte = buffer[index];
+      // 检查首字节的类型  
+      if ((firstByte & 0x80) !== 0) {
+        // 1xxxxxxx - Indexed Header Field  
+        const [name, value, newIndex] = this.decodeIndexedHeader(buffer, index);
+        if (name && value) headers.set(name, value);
+        index = newIndex;
+      } else if ((firstByte & 0x40) !== 0) {
+        // 01xxxxxx - Literal Header Field with Incremental Indexing  
+        const [name, value, newIndex] = this.decodeLiteralHeaderWithIndexing(buffer, index);
+        if (name && value) headers.set(name, value);
+        index = newIndex;
+      } else if ((firstByte & 0x20) !== 0) {
+        // 001xxxxx - Dynamic Table Size Update  
+        index++; // 简单跳过，实际应该更新动态表大小  
+      } else if ((firstByte & 0x10) !== 0) {
+        // 0001xxxx - Literal Header Field Never Indexed  
+        const [name, value, newIndex] = this.decodeLiteralHeaderWithoutIndexing(buffer, index);
+        if (name && value) headers.set(name, value);
+        index = newIndex;
+      } else {
+        // 0000xxxx - Literal Header Field without Indexing  
+        const [name, value, newIndex] = this.decodeLiteralHeaderWithoutIndexing(buffer, index);
+        if (name && value) headers.set(name, value);
+        index = newIndex;
+      }
+    }
+    return headers;
+  }
+  decodeInteger(buffer, startIndex, prefixBits) {
+    const prefix = (1 << prefixBits) - 1;
+    const firstByte = buffer[startIndex];
+    let index = startIndex;
+    let value = firstByte & prefix;
+    if (value < prefix) {
+      return [value, index + 1];
+    }
+    index++;
+    let shift = 0;
+    while (index < buffer.length) {
+      const byte = buffer[index++];
+      value += (byte & 0x7F) << shift;
+      shift += 7;
+      if ((byte & 0x80) === 0) {
+        break;
+      }
+    }
+    return [value, index];
+  }
+  decodeLiteralString(buffer, startIndex) {
+    if (startIndex >= buffer.length) {
+      return ['', startIndex];
+    }
+    const firstByte = buffer[startIndex];
+    const isHuffman = (firstByte & 0x80) !== 0;
+    const [length, index] = this.decodeInteger(buffer, startIndex, 7);
+    if (index + length > buffer.length) {
+      return ['', index];
+    }
+    const bytes = buffer.slice(index, index + length);
+    let result;
+    if (isHuffman) {
+      try {
+        result = this.decode(bytes);
+      } catch (e) {
+        result = '';
+      }
+    } else {
+      try {
+        //    result = new TextDecoder().decode(bytes);  
+        result = toString(bytes);
+      } catch (e) {
+        result = '';
+      }
+    }
+    return [result, index + length];
+  }
+  decodeIndexedHeader(buffer, index) {
+    const [staticIndex, newIndex] = this.decodeInteger(buffer, index, 7);
+    if (staticIndex <= 0) {
+      return ['', '', newIndex];
+    }
+    const headerField = this.staticTable[staticIndex];
+    if (!headerField) {
+      return ['', '', newIndex];
+    }
+    return [headerField[0], headerField[1], newIndex];
+  }
+  decodeLiteralHeaderWithIndexing(buffer, index) {
+    const [staticIndex, nameIndex] = this.decodeInteger(buffer, index, 6);
+    index = nameIndex;
+    let name;
+    if (staticIndex > 0) {
+      const headerField = this.staticTable[staticIndex];
+      name = headerField ? headerField[0] : '';
+    } else {
+      const [decodedName, newIndex] = this.decodeLiteralString(buffer, index);
+      name = decodedName;
+      index = newIndex;
+    }
+    const [value, finalIndex] = this.decodeLiteralString(buffer, index);
+    return [name, value, finalIndex];
+  }
+  decodeLiteralHeaderWithoutIndexing(buffer, index) {
+    return this.decodeLiteralHeaderWithIndexing(buffer, index);
+  }
+  // 直接转换为字符串的方法  
+  huffmanDecodeToString(bytes) {
+    return this.decode(bytes);
+  }
+}
+class FrameEncoder {
+  // 编码SETTINGS帧  
+  static encodeSettingsFrame(frame) {
+    // 计算payload总长度：每个设置项占6字节  
+    const payloadLength = frame.payload.length * 6;
+    // 分配缓冲区：9字节头部 + payload长度  
+    const 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帧  
+  static encodeSettingsAckFrame() {
+    const buffer = new Uint8Array(9); // ACK帧只有头部  
+    _encodeFrameHeader(buffer, {
+      length: 0,
+      type: 0x4,
+      // SETTINGS  
+      flags: 0x1,
+      // ACK  
+      streamId: 0
+    });
+    return buffer;
+  }
+}
+// 编码帧头部（9字节）  
+function _encodeFrameHeader(buffer, header) {
+  // Length: 3 bytes  
+  const length = header.length ?? 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) {
+  let offset = 9; // 从第9个字节开始  
+  payload.forEach(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;
+}
+const 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
+};
+const defaultSettings = {
+  [SETTINGS_PARAMETERS.HEADER_TABLE_SIZE]: 4096,
+  [SETTINGS_PARAMETERS.ENABLE_PUSH]: 1,
+  [SETTINGS_PARAMETERS.MAX_CONCURRENT_STREAMS]: 100,
+  [SETTINGS_PARAMETERS.INITIAL_WINDOW_SIZE]: 16 << 10,
+  // 16k
+  [SETTINGS_PARAMETERS.MAX_FRAME_SIZE]: 16 << 10,
+  // 16k
+  [SETTINGS_PARAMETERS.MAX_HEADER_LIST_SIZE]: 8192
+};
+const HTTP2_PREFACE = 'PRI * HTTP/2.0\r\n\r\nSM\r\n\r\n';
+class Http2Frame {
+  // 创建并编码PREFACE帧
+  static createPreface() {
+    return new TextEncoder().encode(HTTP2_PREFACE);
+  }
+  static createPongFrame(payload) {
+    return Http2Frame.createFrame(0x6, 0x1, 0, payload);
+  }
+  // 创建并编码SETTINGS帧  
+  static createSettingsFrame() {
+    let settings = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    // 先创建帧对象  
+    const frame = Http2Frame.createOriginSettingsFrame(settings);
+    // 然后编码  
+    return FrameEncoder.encodeSettingsFrame(frame);
+  }
+  // 创建并编码SETTINGS ACK帧  
+  static createSettingsAckFrame() {
+    return FrameEncoder.encodeSettingsAckFrame();
+  }
+  /**
+  * 创建 WINDOW_UPDATE 帧
+  * @param streamId 流ID，0表示连接级别的窗口更新
+  * @param increment 窗口大小增量（必须为正数）
+  * @returns 编码好的 WINDOW_UPDATE 帧
+  */
+  static createWindowUpdateFrame(streamId, increment) {
+    // 验证窗口增量
+    if (increment <= 0 || increment > 2147483647) {
+      // 2^31 - 1
+      throw new Error('Window size increment must be between 1 and 2^31-1');
+    }
+    // 创建4字节的payload
+    const payload = new Uint8Array(4);
+    // 写入窗口大小增量 (31位无符号整数，最高位保留为0)
+    payload[0] = increment >> 24 & 0x7F; // 只用低7位，确保最高位为0
+    payload[1] = increment >> 16 & 0xFF;
+    payload[2] = increment >> 8 & 0xFF;
+    payload[3] = increment & 0xFF;
+    // 创建帧，类型0x8表示WINDOW_UPDATE
+    return Http2Frame.createFrame(0x8, 0x0, streamId, payload);
+  }
+  static createDataFrames(streamId, data) {
+    let shouldEnd = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+    let maxFrameSize = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 16384;
+    const frames = [];
+    // 首先构建完整的 gRPC 消息
+    // 格式: Compressed-Flag(1) + Message-Length(4) + Message-Data
+    const messageLength = data.length;
+    const grpcMessage = new Uint8Array(5 + messageLength);
+    // Compressed-Flag (0 = 不压缩)
+    grpcMessage[0] = 0;
+    // Message-Length (4 bytes) - 整个消息的长度
+    grpcMessage[1] = messageLength >> 24 & 0xFF;
+    grpcMessage[2] = messageLength >> 16 & 0xFF;
+    grpcMessage[3] = messageLength >> 8 & 0xFF;
+    grpcMessage[4] = messageLength & 0xFF;
+    // Message-Data
+    grpcMessage.set(data, 5);
+    // 然后将完整的 gRPC 消息分割成多个 HTTP/2 DATA 帧
+    // HTTP/2 帧头为 9 字节
+    const maxDataPerFrame = maxFrameSize - 9;
+    for (let offset = 0; offset < grpcMessage.length; offset += maxDataPerFrame) {
+      const remaining = grpcMessage.length - offset;
+      const chunkSize = Math.min(maxDataPerFrame, remaining);
+      const chunk = grpcMessage.slice(offset, offset + chunkSize);
+      // 判断是否是最后一个数据块
+      const isLastChunk = offset + chunkSize >= grpcMessage.length;
+      const endStream = isLastChunk && shouldEnd;
+      // 创建 HTTP/2 DATA 帧
+      const frame = Http2Frame.createFrame(0x0,
+      // DATA 帧类型
+      endStream ? 0x01 : 0x0,
+      // 只在最后一块且需要结束流时设置 END_STREAM
+      streamId, chunk);
+      frames.push(frame);
+    }
+    return frames;
+  }
+  static createDataFrame(streamId, data) {
+    let endStream = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
+    // gRPC 消息格式: 压缩标志(1字节) + 消息长度(4字节) + 消息内容  
+    const messageLen = data.length;
+    const 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);
+    const flags = endStream ? 0x01 : 0x0; // END_STREAM flag  
+    return Http2Frame.createFrame(0x0, flags, streamId, framedData);
+  }
+  static createHeadersFrame(streamId, path) {
+    let endHeaders = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
+    let token = arguments.length > 3 ? arguments[3] : undefined;
+    // gRPC-Web 需要的标准 headers  
+    const 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 ${token}`;
+    }
+    // 将 headers 编码为 HPACK 格式  
+    const hpack = new HPACK();
+    const encodedHeaders = hpack.encode(headersList);
+    // HEADERS frame flags: END_HEADERS | END_STREAM  
+    const flags = endHeaders ? 0x04 : 0x00;
+    return Http2Frame.createFrame(0x01, flags, streamId, encodedHeaders);
+  }
+  static createResponseHeadersFrame(streamId, headersList) {
+    let endHeaders = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
+    // 将 headers 编码为 HPACK 格式  
+    const hpack = new HPACK();
+    const encodedHeaders = hpack.encode(headersList);
+    // HEADERS frame flags: END_HEADERS | END_STREAM  
+    const flags = endHeaders ? 0x04 : 0x00;
+    return Http2Frame.createFrame(0x01, flags, streamId, encodedHeaders);
+  }
+  static createTrailersFrame(streamId, trailers) {
+    // 将 trailers 编码为 HPACK 格式
+    const hpack = new HPACK();
+    const encodedTrailers = hpack.encode(trailers);
+    // HEADERS frame flags: END_HEADERS | END_STREAM
+    const flags = 0x05; // 0x04 (END_HEADERS) | 0x01 (END_STREAM)
+    return Http2Frame.createFrame(0x01, flags, streamId, encodedTrailers);
+  }
+  // 创建 SETTINGS 帧  
+  static createOriginSettingsFrame() {
+    let settings = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    // 合并默认值和用户提供的设置  
+    const finalSettings = {
+      ...defaultSettings,
+      ...settings
+    };
+    // 验证设置值  
+    _validateSettings(finalSettings);
+    // 创建帧  
+    const frame = {
+      type: 0x4,
+      // SETTINGS frame type  
+      flags: 0x0,
+      // 无标志  
+      streamId: 0,
+      // SETTINGS 总是在 stream 0 上发送  
+      payload: _createPayload(finalSettings)
+    };
+    return frame;
+  }
+  // 创建确认帧（SETTINGS ACK）  
+  static createOriginSettingsAckFrame() {
+    return {
+      type: 0x4,
+      // SETTINGS frame type  
+      flags: 0x1,
+      // ACK flag  
+      streamId: 0,
+      payload: [] // ACK 帧没有payload  
+    };
+  }
+  static createFrame(type, flags, streamId, payload) {
+    const length = payload ? payload.length : 0;
+    const 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;
+  }
+}
+// 验证设置值  
+function _validateSettings(settings) {
+  for (const [id, value] of Object.entries(settings)) {
+    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 ${id} must be non-negative`);
+        }
+        break;
+      default:
+        console.warn(`Unknown settings parameter: ${id}`);
+    }
+  }
+}
+// 创建payload  
+function _createPayload(settings) {
+  const payload = [];
+  for (const [id, value] of Object.entries(settings)) {
+    payload.push({
+      identifier: Number(id),
+      value: value
+    });
+  }
+  return payload;
+}
+class HTTP2Parser {
+  constructor(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;
+  }
+  // 持续处理流数据
+  async processStream(stream) {
+    try {
+      for await (const chunk of stream.source) {
+        const newData = chunk.subarray();
+        // 累积数据到buffer
+        const newBuffer = new Uint8Array(this.buffer.length + newData.length);
+        newBuffer.set(this.buffer);
+        newBuffer.set(newData, this.buffer.length);
+        this.buffer = newBuffer;
+        // 持续处理所有完整的帧
+        while (this.buffer.length >= 9) {
+          // 判断是否有HTTP/2前导
+          if (this.buffer.length >= 24 && this.isHttp2Preface(this.buffer)) {
+            this.buffer = this.buffer.slice(24);
+            // 发送SETTINGS帧
+            const settingFrme = Http2Frame.createSettingsFrame();
+            this.writer.write(settingFrme);
+            break;
+          }
+          const frameHeader = this._parseFrameHeader(this.buffer);
+          const totalFrameLength = 9 + frameHeader.length;
+          // 检查是否有完整的帧
+          if (this.buffer.length < totalFrameLength) {
+            break;
+          }
+          // 获取完整帧数据
+          const frameData = this.buffer.slice(0, totalFrameLength);
+          // 处理不同类型的帧
+          await this._handleFrame(frameHeader, frameData);
+          // 移除已处理的帧
+          this.buffer = this.buffer.slice(totalFrameLength);
+        }
+      }
+    } catch (error) {
+      console.error("Error processing stream:", error);
+      throw error;
+    }
+  }
+  isHttp2Preface(buffer) {
+    const PREFACE = new TextEncoder().encode("PRI * HTTP/2.0\r\n\r\nSM\r\n\r\n");
+    if (buffer.length < PREFACE.length) return false;
+    for (let i = 0; i < PREFACE.length; i++) {
+      if (buffer[i] !== PREFACE[i]) return false;
+    }
+    return true;
+  }
+  // 等待SETTINGS ACK
+  waitForSettingsAck() {
+    return new Promise((resolve, reject) => {
+      if (this.settingsAckReceived) {
+        resolve();
+        return;
+      }
+      const interval = setInterval(() => {
+        if (this.settingsAckReceived) {
+          clearInterval(interval);
+          clearTimeout(timeout);
+          resolve();
+        }
+      }, 100);
+      const timeout = setTimeout(() => {
+        clearInterval(interval);
+        reject(new Error("Settings ACK timeout"));
+      }, 30000);
+    });
+  }
+  // 处理单个帧
+  async _handleFrame(frameHeader, frameData) {
+    switch (frameHeader.type) {
+      case FRAME_TYPES.SETTINGS:
+        if ((frameHeader.flags & FRAME_FLAGS.ACK) === FRAME_FLAGS.ACK) {
+          this.settingsAckReceived = true;
+        } else {
+          //接收到Setting请求,进行解析
+          const settingsPayload = frameData.slice(9);
+          for (let i = 0; i < settingsPayload.length; i += 6) {
+            settingsPayload[i];
+            settingsPayload[i + 1] << 16 | settingsPayload[i + 2] << 8 | settingsPayload[i + 3];
+          }
+          //发送ACK
+          if (this.onSettings) {
+            this.onSettings(frameHeader);
+          }
+        }
+        break;
+      case FRAME_TYPES.DATA:
+        // 处理数据帧
+        if (this.onData) {
+          this.onData(frameData.slice(9), frameHeader); // 跳过帧头
+        }
+        // 更新流窗口和连接窗口
+        try {
+          // 更新流级别的窗口
+          if (frameHeader.streamId !== 0) {
+            const streamWindowUpdate = Http2Frame.createWindowUpdateFrame(frameHeader.streamId, frameHeader.length);
+            this.writer.write(streamWindowUpdate);
+          }
+          // 更新连接级别的窗口
+          const connWindowUpdate = Http2Frame.createWindowUpdateFrame(0, frameHeader.length);
+          this.writer.write(connWindowUpdate);
+        } catch (err) {
+          console.error("[HTTP2] Error sending window update:", err);
+        }
+        //判断是否是最后一个帧
+        if ((frameHeader.flags & FRAME_FLAGS.END_STREAM) === FRAME_FLAGS.END_STREAM) {
+          this.endFlag = true;
+          if (this.onEnd) {
+            this.onEnd();
+          }
+          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;
+        }
+        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);
+    }
+  }
+  _parseFrameHeader(buffer) {
+    const length = buffer[0] << 16 | buffer[1] << 8 | buffer[2];
+    const type = buffer[3];
+    const flags = buffer[4];
+    const streamId = buffer[5] << 24 | buffer[6] << 16 | buffer[7] << 8 | buffer[8];
+    return {
+      length,
+      type,
+      flags,
+      streamId,
+      payload: buffer.slice(0, 9)
+    };
+  }
+  // 解析PING帧
+  _handlePingFrame(frameHeader, frameData) {
+    // PING帧的payload固定为8字节
+    if (frameHeader.length !== 8) {
+      throw new Error("PING frame must have a length of 8 bytes");
+    }
+    // 反馈PONG帧
+    const pongFrame = Http2Frame.createPongFrame(frameData.slice(9));
+    try {
+      this.writer.write(pongFrame);
+    } catch (error) {
+      console.error("Error sending PONG frame:", error);
+      throw error;
+    }
+  }
+  //等待流结束
+  waitForEndOfStream(waitTime) {
+    return new Promise((resolve, reject) => {
+      // If the stream has already ended, resolve immediately
+      if (this.endFlag) {
+        resolve();
+        return;
+      }
+      // 如果是0 ,则不设置超时
+      let timeout = null;
+      if (waitTime > 0) {
+        timeout = setTimeout(() => {
+          clearInterval(interval);
+          reject(new Error("End of stream timeout"));
+        }, waitTime);
+      }
+      // Check interval for real-time endFlag monitoring
+      const checkInterval = 100; // Check every 100 milliseconds
+      // Set an interval to check the endFlag regularly
+      const interval = setInterval(() => {
+        if (this.endFlag) {
+          if (timeout !== null) {
+            clearTimeout(timeout);
+          }
+          clearInterval(interval);
+          resolve();
+        }
+      }, checkInterval);
+      // If the onEnd is triggered externally, it should now be marked manually
+      const originalOnEnd = this.onEnd;
+      this.onEnd = () => {
+        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 帧
+  parseWindowUpdateFrame(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类型
+    //  const buffer = new Uint8Array(frameBuffer);
+    const buffer = new Uint8Array(frameBuffer.slice(9));
+    // 读取window size increment (4字节，大端序)
+    // 手动计算32位无符号整数，确保最高位为0
+    const 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 帧
+  handleWindowUpdateFrame(frameHeader, payload, streamId) {
+    try {
+      const windowUpdate = this.parseWindowUpdateFrame(payload, frameHeader);
+      this.connectionWindowSize += windowUpdate.windowSizeIncrement;
+      return windowUpdate;
+    } catch (error) {
+      // 处理错误情况
+      console.error("Error handling WINDOW_UPDATE frame:", error);
+      throw error;
+    }
+  }
+}
+const MaxChunkSize = 4 * 1024 - 5;
+class StreamWriter {
+  constructor(sink) {
+    let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    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: options.chunkSize ?? MaxChunkSize,
+        bufferSize: options.bufferSize ?? 5 * 1024 * 1024,
+        retries: options.retries ?? 3
+      };
+    } else {
+      this.options = {
+        chunkSize: MaxChunkSize,
+        bufferSize: 5 * 1024 * 1024,
+        retries: 3
+      };
+    }
+    if (this.options.chunkSize && this.options.chunkSize > MaxChunkSize) {
+      this.options.chunkSize = MaxChunkSize;
+    }
+    const basePushable = index.pushable({
+      objectMode: false
+    });
+    // 保留原始方法引用  
+    basePushable._originalPush = basePushable.push.bind(basePushable);
+    basePushable._originalNext = basePushable.next.bind(basePushable);
+    basePushable._queueSize = 0;
+    // 重写 next 方法  
+    Object.defineProperty(basePushable, 'next', {
+      value: async () => {
+        const result = await basePushable._originalNext();
+        if (!result.done && result.value) {
+          basePushable._queueSize -= result.value.byteLength;
+        }
+        return result;
+      },
+      writable: false,
+      configurable: false
+    });
+    // 安全重写 push 方法  
+    Object.defineProperty(basePushable, 'push', {
+      value: chunk => {
+        basePushable._queueSize += chunk.byteLength;
+        return basePushable._originalPush(chunk);
+      },
+      writable: false,
+      configurable: false
+    });
+    this.p = basePushable;
+    this.startPipeline();
+  }
+  get queueSize() {
+    return this.p._queueSize;
+  }
+  // 在 next() 操作时更新队列大小  
+  async safeNext() {
+    const result = await this.p.next();
+    if (!result.done) {
+      this.p._queueSize -= result.value.byteLength;
+    }
+    return result;
+  }
+  handleError(err) {
+    this.dispatchEvent(new CustomEvent('error', {
+      detail: err
+    }));
+    this.abort(err.message);
+  }
+  startPipeline() {
+    index$1.pipe(this.p, this.createTransform(), this.sink).catch(err => this.handleError(err)); // 正确绑定this  
+  }
+  createTransform() {
+    return async function* (source) {
+      for await (const chunk of source) {
+        yield chunk;
+      }
+    };
+  }
+  async write(data) {
+    if (this.abortController.signal.aborted) return;
+    return new Promise((resolve, reject) => {
+      const task = async () => {
+        try {
+          const buffer = await this.convertToBuffer(data);
+          await this.writeChunks(buffer);
+          resolve();
+        } catch (err) {
+          reject(err);
+        }
+      };
+      this.writeQueue.push(task);
+      this.processQueue();
+    });
+  }
+  async convertToBuffer(data) {
+    if (data instanceof Blob) return data.arrayBuffer();
+    if (typeof data === 'string') return new TextEncoder().encode(data).buffer;
+    return data;
+  }
+  async writeChunks(buffer) {
+    for (let offset = 0; offset < buffer.byteLength; offset += this.options.chunkSize) {
+      const end = Math.min(offset + this.options.chunkSize, buffer.byteLength);
+      const chunk = new Uint8Array(end - offset);
+      chunk.set(new Uint8Array(buffer.slice(offset, end)));
+      await this.retryableWrite(chunk);
+      this.updateProgress(chunk.byteLength);
+    }
+  }
+  async retryableWrite(chunk) {
+    let attempt = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
+    try {
+      await this.monitorBackpressure();
+      await new Promise((resolve, reject) => {
+        try {
+          this.p.push(chunk);
+        } catch (err) {
+          reject(err);
+        }
+        resolve();
+      });
+    } catch (err) {
+      if (attempt < this.options.retries) {
+        const delay = this.calculateRetryDelay(attempt);
+        await new Promise(r => setTimeout(r, delay));
+        return this.retryableWrite(chunk, attempt + 1);
+      }
+      throw err;
+    }
+  }
+  async monitorBackpressure() {
+    const checkInterval = 50;
+    const historySize = 10;
+    while (true) {
+      const currentSize = this.queueSize; // 空值合并运算符  
+      if (currentSize > 0) {
+        this.backpressureHistory.push(currentSize);
+      }
+      if (this.backpressureHistory.length > historySize) {
+        this.backpressureHistory.shift();
+      }
+      const avg = this.backpressureHistory.reduce((a, b) => a + b, 0) / historySize;
+      const dynamicThreshold = Math.min(this.options.bufferSize * 0.8, avg * 1.5);
+      if (currentSize < dynamicThreshold || currentSize === 0) {
+        if (this.isBackpressure) {
+          this.isBackpressure = false;
+          this.dispatchEvent(new CustomEvent('backpressure', {
+            detail: {
+              currentSize,
+              averageSize: avg,
+              threshold: dynamicThreshold,
+              waitingTime: 0
+            }
+          }));
+        }
+        return;
+      }
+      if (!this.isBackpressure) {
+        this.isBackpressure = true;
+        this.dispatchEvent(new CustomEvent('backpressure', {
+          detail: {
+            currentSize,
+            averageSize: avg,
+            threshold: dynamicThreshold,
+            waitingTime: 0
+          }
+        }));
+      }
+      const waitTime = Math.min(10, checkInterval * Math.pow(2, currentSize / dynamicThreshold));
+      await new Promise(r => setTimeout(r, waitTime));
+      if (this.abortController.signal.aborted) break;
+    }
+  }
+  calculateRetryDelay(attempt) {
+    const baseDelay = 10;
+    const maxDelay = 100;
+    return Math.min(baseDelay * Math.pow(2, attempt) + Math.random() * 100, maxDelay);
+  }
+  async processQueue() {
+    if (this.isProcessingQueue || this.abortController.signal.aborted) return;
+    this.isProcessingQueue = true;
+    while (this.writeQueue.length > 0) {
+      if (this.abortController.signal.aborted) break;
+      await this.monitorBackpressure();
+      const task = this.writeQueue.shift();
+      await task();
+    }
+    this.isProcessingQueue = false;
+  }
+  updateProgress(bytes) {
+    this.bytesWritten += bytes;
+    this.dispatchEvent(new CustomEvent('progress', {
+      detail: {
+        loaded: this.bytesWritten
+      }
+    }));
+  }
+  async end() {
+    this.p.end();
+    await this.sink.return?.();
+    this.cleanup();
+  }
+  abort() {
+    let reason = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'User aborted';
+    this.abortController.abort(reason);
+    this.cleanup();
+    this.dispatchEvent(new CustomEvent('abort', {
+      detail: reason
+    }));
+  }
+  cleanup() {
+    this.p.end();
+    this.abortController.abort();
+    this.writeQueue = [];
+  }
+  addEventListener(type, callback) {
+    const handlers = this.listeners.get(type) || [];
+    handlers.push(callback);
+    this.listeners.set(type, handlers);
+  }
+  // 修复后的代码片段  
+  dispatchEvent(event) {
+    const handlers = this.listeners.get(event.type) || [];
+    handlers.forEach(handler => handler(event));
+  }
+  // 明确指定事件类型  
+  dispatchBackpressureEvent(detail) {
+    this.dispatchEvent(new CustomEvent('backpressure', {
+      detail
+    }));
+  }
+}
+class StreamManager {
+  constructor() {
+    this.currentStreamId = 1; // 从 1 开始，以模拟奇数 ID  
+  }
+  getNextAppLevelStreamId() {
+    const id = this.currentStreamId;
+    this.currentStreamId += 2; // 确保奇数步进  
+    return id;
+  }
+}
+class Libp2pGrpcClient {
+  constructor(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;
+  }
+  setToken(token) {
+    this.token = token;
+  }
+  async unaryCall(method, requestData, timeout) {
+    let stream = null;
+    let responseData = null;
+    let responseBuffer = []; // 添加缓冲区来累积数据
+    let responseDataExpectedLength = -1; // 当前响应的期望长度
+    const hpack = new HPACK();
+    let exitFlag = false;
+    let errMsg = '';
+    let isResponseComplete = false; // 添加标志来标识响应是否完成
+    try {
+      // const stream = await this.node.dialProtocol(this.peerAddr, this.protocol)
+      const connection = await this.node.dial(this.peerAddr);
+      stream = await connection.newStream(this.protocol, {
+        maxOutboundStreams: 5
+      });
+      const streamId = this.steamManager.getNextAppLevelStreamId();
+      const writer = new StreamWriter(stream.sink);
+      const parser = new HTTP2Parser(writer);
+      responseDataExpectedLength = -1; // 重置期望长度
+      responseBuffer = []; // 重置缓冲区
+      parser.onData = (payload, frameHeader) => {
+        if (responseDataExpectedLength === -1) {
+          //grpc消息头部未读取
+          //提取gRPC消息头部
+          if (payload.length < 5) {
+            return;
+          }
+          const compressionFlag = payload[0]; // 压缩标志
+          const lengthBytes = payload.slice(1, 5); // 消息长度的4字节
+          responseDataExpectedLength = new DataView(lengthBytes.buffer, lengthBytes.byteOffset).getUint32(0, false); // big-endian
+          if (responseDataExpectedLength < 0) {
+            throw new Error('Invalid gRPC message length');
+          }
+          if (responseDataExpectedLength + 5 > payload.length) {
+            // 如果当前 payload 不足以包含完整的 gRPC 消息，缓存数据
+            const grpcData = payload.subarray(5);
+            responseBuffer.push(grpcData);
+            responseDataExpectedLength -= grpcData.length; // 更新期望长度
+            return;
+          } else {
+            // 如果当前 payload 足以包含完整的 gRPC 消息，重置缓冲区
+            const grpcData = payload.subarray(5); // 提取完整的 gRPC 消息
+            responseBuffer.push(grpcData);
+            responseData = grpcData;
+            isResponseComplete = true;
+            responseDataExpectedLength = -1; // 重置期望长度
+          }
+        } else if (responseDataExpectedLength > 0) {
+          //grpc消息头部已读取
+          responseBuffer.push(payload); // 将数据添加到缓冲区
+          responseDataExpectedLength -= payload.length; // 更新期望长度
+          if (responseDataExpectedLength <= 0) {
+            // 如果缓冲区中的数据已经完全处理，重置缓冲区
+            responseData = new Uint8Array(responseBuffer.reduce((sum, chunk) => sum + chunk.length, 0));
+            let offset = 0;
+            for (const chunk of responseBuffer) {
+              responseData.set(chunk, offset);
+              offset += chunk.length;
+            }
+            responseDataExpectedLength = -1;
+            isResponseComplete = true; // 设置响应完成标志
+          }
+        }
+        // 检查是否是流的最后一个帧（END_STREAM 标志）
+        if (frameHeader && frameHeader.flags & 0x1 && !isResponseComplete) {
+          // END_STREAM flag
+          // 合并所有缓冲的数据
+          const totalLength = responseBuffer.reduce((sum, chunk) => sum + chunk.length, 0);
+          responseData = new Uint8Array(totalLength);
+          let offset = 0;
+          for (const chunk of responseBuffer) {
+            responseData.set(chunk, offset);
+            offset += chunk.length;
+          }
+          isResponseComplete = true;
+        }
+      };
+      parser.onEnd = () => {
+        if (!isResponseComplete) {
+          isResponseComplete = true; // 设置响应完成标志
+          if (responseBuffer.length === 0) {
+            responseData = new Uint8Array(); // 如果没有数据，返回空数组
+          } else {
+            // 合并所有缓冲的数据
+            const totalLength = responseBuffer.reduce((sum, chunk) => sum + chunk.length, 0);
+            responseData = new Uint8Array(totalLength);
+            let offset = 0;
+            for (const chunk of responseBuffer) {
+              responseData.set(chunk, offset);
+              offset += chunk.length;
+            }
+            isResponseComplete = true;
+          }
+        }
+      };
+      parser.onSettings = () => {
+        const ackSettingFrame = Http2Frame.createSettingsAckFrame();
+        writer.write(ackSettingFrame);
+      };
+      parser.onHeaders = (headers, header) => {
+        const plainHeaders = hpack.decodeHeaderFields(headers);
+        if (plainHeaders.get('grpc-status') === '0') {} else if (plainHeaders.get('grpc-status') !== undefined) {
+          exitFlag = true;
+          errMsg = plainHeaders.get('grpc-message') || 'gRPC call failed';
+        }
+      };
+      parser.processStream(stream);
+      // 握手
+      const preface = Http2Frame.createPreface();
+      await writer.write(preface);
+      // 发送Settings请求
+      const settingFrme = Http2Frame.createSettingsFrame();
+      await writer.write(settingFrme);
+      await parser.waitForSettingsAck();
+      // 创建头部帧
+      const headerFrame = Http2Frame.createHeadersFrame(streamId, method, true, this.token);
+      await writer.write(headerFrame);
+      // 创建数据帧
+      const dataFrames = Http2Frame.createDataFrames(streamId, requestData, true);
+      // 发送请求
+      for (const dataFrame of dataFrames) {
+        await writer.write(dataFrame);
+      }
+      // 等待responseData 不为空,或超时
+      await new Promise((resolve, reject) => {
+        const t = setTimeout(() => {
+          reject(new Error('gRPC response timeout'));
+        }, timeout);
+        const checkResponse = () => {
+          if (isResponseComplete || exitFlag) {
+            // 使用新的完成标志
+            clearTimeout(t);
+            resolve(responseData);
+          } else {
+            setTimeout(checkResponse, 50);
+          }
+        };
+        checkResponse();
+      });
+      await writer.end();
+    } catch (err) {
+      console.error('unaryCall error:', err);
+      throw err;
+    } finally {
+      if (stream) {
+        await stream.close();
+      }
+    }
+    if (exitFlag) {
+      throw new Error(errMsg);
+    }
+    if (!responseData) {
+      responseData = new Uint8Array();
+    }
+    return responseData;
+  }
+  /**
+  * 执行GRPC调用，支持通过context和返回的取消函数控制终止
+  * @param method GRPC方法名
+  * @param requestData 请求数据
+  * @param timeout 超时时间(毫秒)
+  * @param mode 调用模式: 'unary'|'server-streaming'|'client-streaming'|'bidirectional'
+  * @param onDataCallback 数据回调函数
+  * @param dataSourceCallback 客户端流数据源回调
+  * @param onEndCallback 结束回调函数
+  * @param onErrorCallback 错误回调函数
+  * @param context 操作上下文，包含AbortSignal用于取消操作
+  * @returns 取消函数，可随时调用终止操作
+  */
+  async Call(method, requestData, timeout, mode, onDataCallback, dataSourceCallback, onEndCallback, onErrorCallback, context) {
+    // 创建内部AbortController用于控制操作
+    const internalController = new AbortController();
+    let timeoutHandle;
+    let stream = null;
+    // 取消函数 - 将在最后返回给调用者
+    const cancelOperation = () => {
+      internalController.abort();
+      if (timeoutHandle) {
+        clearTimeout(timeoutHandle);
+      }
+      if (stream) {
+        try {
+          stream.abort(new Error('Operation cancelled'));
+        } catch (err) {
+          console.error('Error closing stream on cancel:', err);
+        }
+      }
+    };
+    // 如果提供了外部信号，监听它
+    if (context?.signal) {
+      // 如果外部信号已经触发中止，立即返回
+      if (context.signal.aborted) {
+        if (onErrorCallback) {
+          onErrorCallback(new Error('Operation aborted by context'));
+        }
+        cancelOperation();
+      }
+      // 监听外部的abort事件
+      context.signal.addEventListener('abort', () => {
+        cancelOperation();
+      });
+    }
+    // 超时Promise
+    const timeoutPromise = new Promise((_, reject) => {
+      timeoutHandle = setTimeout(() => {
+        reject(new Error('Operation timed out'));
+        cancelOperation();
+      }, timeout);
+    });
+    // 主操作Promise
+    const operationPromise = (async () => {
+      let messageBuffer = new Uint8Array(0); // 用于累积跨帧的消息数据
+      let expectedMessageLength = -1; // 当前消息的期望长度
+      const hpack = new HPACK();
+      try {
+        // 检查是否已经中止
+        if (internalController.signal.aborted) {
+          throw new Error('Operation aborted');
+        }
+        const connection = await this.node.dial(this.peerAddr);
+        stream = await connection.newStream(this.protocol);
+        const streamId = this.steamManager.getNextAppLevelStreamId();
+        const writer = new StreamWriter(stream.sink);
+        const parser = new HTTP2Parser(writer);
+        clearTimeout(timeoutHandle);
+        // 在各个回调中检查是否已中止
+        parser.onData = async (payload, frameHeader) => {
+          // 检查是否已中止
+          if (internalController.signal.aborted) {
+            return;
+          }
+          try {
+            // 将新数据添加到消息缓冲区
+            const newBuffer = new Uint8Array(messageBuffer.length + payload.length);
+            newBuffer.set(messageBuffer);
+            newBuffer.set(payload, messageBuffer.length);
+            messageBuffer = newBuffer;
+            // 处理缓冲区中的完整消息
+            while (messageBuffer.length > 0) {
+              // 如果已经中止，停止处理
+              if (internalController.signal.aborted) {
+                return;
+              }
+              // 如果还没有读取消息长度，且缓冲区有足够数据
+              if (expectedMessageLength === -1 && messageBuffer.length >= 5) {
+                // 读取 gRPC 消息头：1字节压缩标志 + 4字节长度
+                const compressionFlag = messageBuffer[0];
+                const lengthBytes = messageBuffer.slice(1, 5);
+                expectedMessageLength = new DataView(lengthBytes.buffer, lengthBytes.byteOffset).getUint32(0, false); // big-endian
+              }
+              // 如果知道期望长度且有足够数据
+              if (expectedMessageLength !== -1 && messageBuffer.length >= expectedMessageLength + 5) {
+                // 提取完整消息（跳过5字节头部）
+                const completeMessage = messageBuffer.slice(5, expectedMessageLength + 5);
+                // 调用回调处理这个完整消息
+                onDataCallback(completeMessage);
+                // 移除已处理的消息，保留剩余数据
+                messageBuffer = messageBuffer.slice(expectedMessageLength + 5);
+                expectedMessageLength = -1;
+              } else {
+                // 没有足够数据构成完整消息，等待更多数据
+                break;
+              }
+            }
+          } catch (error) {
+            if (onErrorCallback) {
+              onErrorCallback(error);
+            } else {
+              throw error;
+            }
+          }
+        };
+        parser.onSettings = () => {
+          // 检查是否已中止
+          if (internalController.signal.aborted) return;
+          const ackSettingFrame = Http2Frame.createSettingsAckFrame();
+          writer.write(ackSettingFrame);
+        };
+        parser.onHeaders = (headers, header) => {
+          // 检查是否已中止
+          if (internalController.signal.aborted) return;
+          const plainHeaders = hpack.decodeHeaderFields(headers);
+          if (plainHeaders.get('grpc-status') === '0') {
+            // 成功状态
+          } else if (plainHeaders.get('grpc-status') !== undefined) {
+            const errMsg = plainHeaders.get('grpc-message') || 'gRPC call failed';
+            const err = new Error(errMsg);
+            if (onErrorCallback) {
+              onErrorCallback(err);
+            } else {
+              throw err;
+            }
+          }
+        };
+        parser.processStream(stream);
+        // 检查是否已中止
+        if (internalController.signal.aborted) {
+          throw new Error('Operation aborted');
+        }
+        // Handshake - send HTTP/2 preface  
+        const preface = Http2Frame.createPreface();
+        await writer.write(preface);
+        // 检查是否已中止
+        if (internalController.signal.aborted) {
+          throw new Error('Operation aborted');
+        }
+        // Send Settings request  
+        const settingFrame = Http2Frame.createSettingsFrame();
+        await writer.write(settingFrame);
+        // 检查是否已中止
+        if (internalController.signal.aborted) {
+          throw new Error('Operation aborted');
+        }
+        // Wait for the acknowledgement of SETTINGS  
+        await parser.waitForSettingsAck();
+        // 检查是否已中止
+        if (internalController.signal.aborted) {
+          throw new Error('Operation aborted');
+        }
+        // Send Settings ACK  
+        const ackSettingFrame = Http2Frame.createSettingsAckFrame();
+        await writer.write(ackSettingFrame);
+        // 检查是否已中止
+        if (internalController.signal.aborted) {
+          throw new Error('Operation aborted');
+        }
+        // Create header frame  
+        const headerFrame = Http2Frame.createHeadersFrame(streamId, method, true, this.token);
+        if (mode === 'unary' || mode === 'server-streaming') {
+          const dataFrames = Http2Frame.createDataFrames(streamId, requestData, true);
+          await writer.write(new Uint8Array([...headerFrame]));
+          // 检查是否已中止
+          if (internalController.signal.aborted) {
+            throw new Error('Operation aborted');
+          }
+          for (const dataFrame of dataFrames) {
+            // 检查是否已中止
+            if (internalController.signal.aborted) {
+              throw new Error('Operation aborted');
+            }
+            await writer.write(dataFrame);
+          }
+        } else if ((mode === 'client-streaming' || mode === 'bidirectional') && dataSourceCallback) {
+          await writer.write(headerFrame);
+          // 检查是否已中止
+          if (internalController.signal.aborted) {
+            throw new Error('Operation aborted');
+          }
+          if (requestData.length > 0) {
+            const dataFrames = Http2Frame.createDataFrames(streamId, requestData, false);
+            for (const dataFrame of dataFrames) {
+              // 检查是否已中止
+              if (internalController.signal.aborted) {
+                throw new Error('Operation aborted');
+              }
+              await writer.write(dataFrame);
+            }
+          }
+          for await (const chunk of dataSourceCallback()) {
+            // 检查是否已中止
+            if (internalController.signal.aborted) {
+              throw new Error('Operation aborted');
+            }
+            const dataFrames = Http2Frame.createDataFrames(streamId, chunk, false);
+            for (const dataFrame of dataFrames) {
+              // 检查是否已中止
+              if (internalController.signal.aborted) {
+                throw new Error('Operation aborted');
+              }
+              await writer.write(dataFrame);
+            }
+          }
+          // 检查是否已中止
+          if (internalController.signal.aborted) {
+            throw new Error('Operation aborted');
+          }
+          const finalFrame = Http2Frame.createDataFrame(streamId, new Uint8Array(), true);
+          await writer.write(finalFrame);
+          await writer.end();
+        }
+        // 检查是否已中止
+        if (internalController.signal.aborted) {
+          throw new Error('Operation aborted');
+        }
+        await parser.waitForEndOfStream(0);
+        if (onEndCallback) {
+          onEndCallback();
+        }
+      } catch (err) {
+        // 如果是由于取消导致的错误，使用特定的错误消息
+        if (internalController.signal.aborted && err instanceof Error && err.message === 'Operation aborted') {
+          if (onErrorCallback) {
+            onErrorCallback(new Error('Operation cancelled by user'));
+          }
+        } else if (onErrorCallback) {
+          onErrorCallback(err);
+        } else {
+          if (err instanceof Error) {
+            console.error('asyncCall error:', err.message);
+          } else {
+            console.error('asyncCall error:', err);
+          }
+        }
+      } finally {
+        if (stream) {
+          try {
+            await stream.close();
+          } catch (err) {
+            console.error('Error closing stream:', err);
+          }
+        }
+      }
+    })();
+    // 执行操作并返回取消函数
+    return Promise.race([operationPromise, timeoutPromise]);
+  }
+}
+
+exports.Libp2pGrpcClient = Libp2pGrpcClient;