web-dc-api 0.0.58 → 0.0.60

package/dist/esm/node_modules/grpc-libp2p-client/dist/dc-http2/hpack.esm.js

@@ -0,0 +1,1085 @@
+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);
+  }
+}
+
+export { HPACK };