{
  "version": 3,
  "sources": ["../src/constants.ts", "../node_modules/uint8arrays/src/alloc.ts", "../node_modules/multiformats/src/bases/base10.ts", "../node_modules/multiformats/src/bytes.ts", "../node_modules/multiformats/src/vendor/base-x.js", "../node_modules/multiformats/src/bases/base.ts", "../node_modules/multiformats/src/bases/base16.ts", "../node_modules/multiformats/src/bases/base2.ts", "../node_modules/multiformats/src/bases/base256emoji.ts", "../node_modules/multiformats/src/bases/base32.ts", "../node_modules/multiformats/src/bases/base36.ts", "../node_modules/multiformats/src/bases/base58.ts", "../node_modules/multiformats/src/bases/base64.ts", "../node_modules/multiformats/src/bases/base8.ts", "../node_modules/multiformats/src/bases/identity.ts", "../node_modules/multiformats/src/codecs/json.ts", "../node_modules/multiformats/src/hashes/identity.ts", "../node_modules/multiformats/src/vendor/varint.js", "../node_modules/multiformats/src/varint.ts", "../node_modules/multiformats/src/hashes/digest.ts", "../node_modules/multiformats/src/hashes/sha2-browser.ts", "../node_modules/multiformats/src/hashes/hasher.ts", "../node_modules/multiformats/src/cid.ts", "../node_modules/multiformats/src/basics.ts", "../node_modules/uint8arrays/src/util/bases.ts", "../node_modules/uint8arrays/src/from-string.ts", "../node_modules/uint8arrays/src/to-string.ts", "../src/errors.ts", "../src/index.ts", "../src/util.ts"],
  "sourcesContent": ["import { i2osp, concat } from './util.js'\n\n// RFC 9180 suite identifiers for the one suite this package implements:\n// DHKEM(X25519, HKDF-SHA256) = 0x0020, HKDF-SHA256 = 0x0001,\n// AES-256-GCM = 0x0002.\nexport const KEM_ID = 0x0020\nexport const KDF_ID = 0x0001\nexport const AEAD_ID = 0x0002\n\n// Lengths (bytes). Nsecret/Nk/Nh follow SHA-256; Nn/Nenc/tag are the\n// AES-256-GCM nonce, X25519 encapsulated-key, and GCM tag sizes.\nexport const NSECRET = 32\nexport const NK = 32\nexport const NN = 12\nexport const ENC_LENGTH = 32\nexport const AEAD_TAG_LENGTH = 16\n\n// HPKE base mode.\nexport const MODE_BASE = 0x00\n\nexport const HPKE_V1 = new TextEncoder().encode('HPKE-v1')\n\n// Length of the encrypt/decrypt length prefix, in bytes. The prefix is a\n// big-endian u16 giving the byte length of the `wrapped` segment, which\n// varies with the wrapped AES key size (64 bytes for 128-bit, 80 for 256).\nexport const WRAPPED_LEN_PREFIX = 2\n\n// suite_id for KEM labeled calls: \"KEM\" || I2OSP(kem_id, 2).\nexport const KEM_SUITE_ID = concat(\n    new TextEncoder().encode('KEM'),\n    i2osp(KEM_ID, 2)\n)\n\n// suite_id for key-schedule labeled calls:\n// \"HPKE\" || I2OSP(kem_id, 2) || I2OSP(kdf_id, 2) || I2OSP(aead_id, 2).\nexport const HPKE_SUITE_ID = concat(\n    new TextEncoder().encode('HPKE'),\n    i2osp(KEM_ID, 2),\n    i2osp(KDF_ID, 2),\n    i2osp(AEAD_ID, 2)\n)\n\n// ----- keyId derivation -----\n//\n// These constants are permanent. Changing any of them changes every\n// `keyId` a consumer has already stored, and there is no migration path,\n// so treat them exactly like the wire format.\n//\n// The label is both the fixed plaintext and the input the fixed nonce is\n// derived from: N = SHA-256(KEY_ID_LABEL)[0..KEY_ID_NONCE_LENGTH].\nexport const KEY_ID_LABEL = new TextEncoder()\n    .encode('simple-hpke/keyId/v1')\n\n// AES-GCM's standard nonce size, in bytes. The nonce comes from the label\n// hash rather than a counter or zeros: those are the values a caller\n// doing deterministic nonces would pick, and a collision there would let\n// an attacker solve GHASH for the nonce-independent hash subkey.\nexport const KEY_ID_NONCE_LENGTH = 12\n", "/**\n * Returns a `Uint8Array` of the requested size. Referenced memory will\n * be initialized to 0.\n */\nexport function alloc (size: number = 0): Uint8Array {\n  return new Uint8Array(size)\n}\n\n/**\n * Where possible returns a Uint8Array of the requested size that references\n * uninitialized memory. Only use if you are certain you will immediately\n * overwrite every value in the returned `Uint8Array`.\n */\nexport function allocUnsafe (size: number = 0): Uint8Array {\n  return new Uint8Array(size)\n}\n", "import { baseX } from './base.js'\n\nexport const base10 = baseX({\n  prefix: '9',\n  name: 'base10',\n  alphabet: '0123456789'\n})\n", "export const empty = new Uint8Array(0)\n\nexport function toHex (d: Uint8Array): string {\n  return d.reduce((hex, byte) => hex + byte.toString(16).padStart(2, '0'), '')\n}\n\nexport function fromHex (hex: string): Uint8Array {\n  const hexes = hex.match(/../g)\n  return hexes != null ? new Uint8Array(hexes.map(b => parseInt(b, 16))) : empty\n}\n\nexport function equals (aa: Uint8Array, bb: Uint8Array): boolean {\n  if (aa === bb) { return true }\n  if (aa.byteLength !== bb.byteLength) {\n    return false\n  }\n\n  for (let ii = 0; ii < aa.byteLength; ii++) {\n    if (aa[ii] !== bb[ii]) {\n      return false\n    }\n  }\n\n  return true\n}\n\nexport function coerce (o: ArrayBufferView | ArrayBuffer | Uint8Array): Uint8Array {\n  if (o instanceof Uint8Array && o.constructor.name === 'Uint8Array') { return o }\n  if (o instanceof ArrayBuffer) { return new Uint8Array(o) }\n  if (ArrayBuffer.isView(o)) {\n    return new Uint8Array(o.buffer, o.byteOffset, o.byteLength)\n  }\n  throw new Error('Unknown type, must be binary type')\n}\n\nexport function isBinary (o: unknown): o is ArrayBuffer | ArrayBufferView {\n  return o instanceof ArrayBuffer || ArrayBuffer.isView(o)\n}\n\nexport function fromString (str: string): Uint8Array {\n  return new TextEncoder().encode(str)\n}\n\nexport function toString (b: Uint8Array): string {\n  return new TextDecoder().decode(b)\n}\n", "/* eslint-disable */\n// base-x encoding / decoding\n// Copyright (c) 2018 base-x contributors\n// Copyright (c) 2014-2018 The Bitcoin Core developers (base58.cpp)\n// Distributed under the MIT software license, see the accompanying\n// file LICENSE or http://www.opensource.org/licenses/mit-license.php.\n/**\n * @param {string} ALPHABET\n * @param {any} name\n */\nfunction base (ALPHABET, name) {\n  if (ALPHABET.length >= 255) { throw new TypeError('Alphabet too long') }\n  var BASE_MAP = new Uint8Array(256);\n  for (var j = 0; j < BASE_MAP.length; j++) {\n    BASE_MAP[j] = 255;\n  }\n  for (var i = 0; i < ALPHABET.length; i++) {\n    var x = ALPHABET.charAt(i);\n    var xc = x.charCodeAt(0);\n    if (BASE_MAP[xc] !== 255) { throw new TypeError(x + ' is ambiguous') }\n    BASE_MAP[xc] = i;\n  }\n  var BASE = ALPHABET.length;\n  var LEADER = ALPHABET.charAt(0);\n  var FACTOR = Math.log(BASE) / Math.log(256); // log(BASE) / log(256), rounded up\n  var iFACTOR = Math.log(256) / Math.log(BASE); // log(256) / log(BASE), rounded up\n  /**\n   * @param {any[] | Iterable<number>} source\n   */\n  function encode (source) {\n    // @ts-ignore\n    if (source instanceof Uint8Array) ; else if (ArrayBuffer.isView(source)) {\n      source = new Uint8Array(source.buffer, source.byteOffset, source.byteLength);\n    } else if (Array.isArray(source)) {\n      source = Uint8Array.from(source);\n    }\n    if (!(source instanceof Uint8Array)) { throw new TypeError('Expected Uint8Array') }\n    if (source.length === 0) { return '' }\n        // Skip & count leading zeroes.\n    var zeroes = 0;\n    var length = 0;\n    var pbegin = 0;\n    var pend = source.length;\n    while (pbegin !== pend && source[pbegin] === 0) {\n      pbegin++;\n      zeroes++;\n    }\n        // Allocate enough space in big-endian base58 representation.\n    var size = ((pend - pbegin) * iFACTOR + 1) >>> 0;\n    var b58 = new Uint8Array(size);\n        // Process the bytes.\n    while (pbegin !== pend) {\n      var carry = source[pbegin];\n            // Apply \"b58 = b58 * 256 + ch\".\n      var i = 0;\n      for (var it1 = size - 1; (carry !== 0 || i < length) && (it1 !== -1); it1--, i++) {\n        carry += (256 * b58[it1]) >>> 0;\n        b58[it1] = (carry % BASE) >>> 0;\n        carry = (carry / BASE) >>> 0;\n      }\n      if (carry !== 0) { throw new Error('Non-zero carry') }\n      length = i;\n      pbegin++;\n    }\n        // Skip leading zeroes in base58 result.\n    var it2 = size - length;\n    while (it2 !== size && b58[it2] === 0) {\n      it2++;\n    }\n        // Translate the result into a string.\n    var str = LEADER.repeat(zeroes);\n    for (; it2 < size; ++it2) { str += ALPHABET.charAt(b58[it2]); }\n    return str\n  }\n  /**\n   * @param {string | string[]} source\n   */\n  function decodeUnsafe (source) {\n    if (typeof source !== 'string') { throw new TypeError('Expected String') }\n    if (source.length === 0) { return new Uint8Array() }\n    var psz = 0;\n        // Skip leading spaces.\n    if (source[psz] === ' ') { return }\n        // Skip and count leading '1's.\n    var zeroes = 0;\n    var length = 0;\n    while (source[psz] === LEADER) {\n      zeroes++;\n      psz++;\n    }\n        // Allocate enough space in big-endian base256 representation.\n    var size = (((source.length - psz) * FACTOR) + 1) >>> 0; // log(58) / log(256), rounded up.\n    var b256 = new Uint8Array(size);\n        // Process the characters.\n    while (source[psz]) {\n            // Decode character\n      var carry = BASE_MAP[source.charCodeAt(psz)];\n            // Invalid character\n      if (carry === 255) { return }\n      var i = 0;\n      for (var it3 = size - 1; (carry !== 0 || i < length) && (it3 !== -1); it3--, i++) {\n        carry += (BASE * b256[it3]) >>> 0;\n        b256[it3] = (carry % 256) >>> 0;\n        carry = (carry / 256) >>> 0;\n      }\n      if (carry !== 0) { throw new Error('Non-zero carry') }\n      length = i;\n      psz++;\n    }\n        // Skip trailing spaces.\n    if (source[psz] === ' ') { return }\n        // Skip leading zeroes in b256.\n    var it4 = size - length;\n    while (it4 !== size && b256[it4] === 0) {\n      it4++;\n    }\n    var vch = new Uint8Array(zeroes + (size - it4));\n    var j = zeroes;\n    while (it4 !== size) {\n      vch[j++] = b256[it4++];\n    }\n    return vch\n  }\n  /**\n   * @param {string | string[]} string\n   */\n  function decode (string) {\n    var buffer = decodeUnsafe(string);\n    if (buffer) { return buffer }\n    throw new Error(`Non-${name} character`)\n  }\n  return {\n    encode: encode,\n    decodeUnsafe: decodeUnsafe,\n    decode: decode\n  }\n}\nvar src = base;\n\nvar _brrp__multiformats_scope_baseX = src;\n\nexport default _brrp__multiformats_scope_baseX;\n", "import { coerce } from '../bytes.js'\nimport basex from '../vendor/base-x.js'\nimport type { BaseCodec, BaseDecoder, BaseEncoder, CombobaseDecoder, Multibase, MultibaseCodec, MultibaseDecoder, MultibaseEncoder, UnibaseDecoder } from './interface.js'\n\ninterface EncodeFn { (bytes: Uint8Array): string }\ninterface DecodeFn { (text: string): Uint8Array }\n\n/**\n * Class represents both BaseEncoder and MultibaseEncoder meaning it\n * can be used to encode to multibase or base encode without multibase\n * prefix.\n */\nclass Encoder<Base extends string, Prefix extends string> implements MultibaseEncoder<Prefix>, BaseEncoder {\n  readonly name: Base\n  readonly prefix: Prefix\n  readonly baseEncode: EncodeFn\n\n  constructor (name: Base, prefix: Prefix, baseEncode: EncodeFn) {\n    this.name = name\n    this.prefix = prefix\n    this.baseEncode = baseEncode\n  }\n\n  encode (bytes: Uint8Array): Multibase<Prefix> {\n    if (bytes instanceof Uint8Array) {\n      return `${this.prefix}${this.baseEncode(bytes)}`\n    } else {\n      throw Error('Unknown type, must be binary type')\n    }\n  }\n}\n\n/**\n * Class represents both BaseDecoder and MultibaseDecoder so it could be used\n * to decode multibases (with matching prefix) or just base decode strings\n * with corresponding base encoding.\n */\nclass Decoder<Base extends string, Prefix extends string> implements MultibaseDecoder<Prefix>, UnibaseDecoder<Prefix>, BaseDecoder {\n  readonly name: Base\n  readonly prefix: Prefix\n  readonly baseDecode: DecodeFn\n  private readonly prefixCodePoint: number\n\n  constructor (name: Base, prefix: Prefix, baseDecode: DecodeFn) {\n    this.name = name\n    this.prefix = prefix\n    const prefixCodePoint = prefix.codePointAt(0)\n    /* c8 ignore next 3 */\n    if (prefixCodePoint === undefined) {\n      throw new Error('Invalid prefix character')\n    }\n    this.prefixCodePoint = prefixCodePoint\n    this.baseDecode = baseDecode\n  }\n\n  decode (text: string): Uint8Array {\n    if (typeof text === 'string') {\n      if (text.codePointAt(0) !== this.prefixCodePoint) {\n        throw Error(`Unable to decode multibase string ${JSON.stringify(text)}, ${this.name} decoder only supports inputs prefixed with ${this.prefix}`)\n      }\n      return this.baseDecode(text.slice(this.prefix.length))\n    } else {\n      throw Error('Can only multibase decode strings')\n    }\n  }\n\n  or<OtherPrefix extends string> (decoder: UnibaseDecoder<OtherPrefix> | ComposedDecoder<OtherPrefix>): ComposedDecoder<Prefix | OtherPrefix> {\n    return or(this, decoder)\n  }\n}\n\ntype Decoders<Prefix extends string> = Record<Prefix, UnibaseDecoder<Prefix>>\n\nclass ComposedDecoder<Prefix extends string> implements MultibaseDecoder<Prefix>, CombobaseDecoder<Prefix> {\n  readonly decoders: Decoders<Prefix>\n\n  constructor (decoders: Decoders<Prefix>) {\n    this.decoders = decoders\n  }\n\n  or <OtherPrefix extends string> (decoder: UnibaseDecoder<OtherPrefix> | ComposedDecoder<OtherPrefix>): ComposedDecoder<Prefix | OtherPrefix> {\n    return or(this, decoder)\n  }\n\n  decode (input: string): Uint8Array {\n    const prefix = input[0] as Prefix\n    const decoder = this.decoders[prefix]\n    if (decoder != null) {\n      return decoder.decode(input)\n    } else {\n      throw RangeError(`Unable to decode multibase string ${JSON.stringify(input)}, only inputs prefixed with ${Object.keys(this.decoders)} are supported`)\n    }\n  }\n}\n\nexport function or <L extends string, R extends string> (left: UnibaseDecoder<L> | CombobaseDecoder<L>, right: UnibaseDecoder<R> | CombobaseDecoder<R>): ComposedDecoder<L | R> {\n  return new ComposedDecoder({\n    ...(left.decoders ?? { [(left as UnibaseDecoder<L>).prefix]: left }),\n    ...(right.decoders ?? { [(right as UnibaseDecoder<R>).prefix]: right })\n  } as Decoders<L | R>)\n}\n\nexport class Codec<Base extends string, Prefix extends string> implements MultibaseCodec<Prefix>, MultibaseEncoder<Prefix>, MultibaseDecoder<Prefix>, BaseCodec, BaseEncoder, BaseDecoder {\n  readonly name: Base\n  readonly prefix: Prefix\n  readonly baseEncode: EncodeFn\n  readonly baseDecode: DecodeFn\n  readonly encoder: Encoder<Base, Prefix>\n  readonly decoder: Decoder<Base, Prefix>\n\n  constructor (name: Base, prefix: Prefix, baseEncode: EncodeFn, baseDecode: DecodeFn) {\n    this.name = name\n    this.prefix = prefix\n    this.baseEncode = baseEncode\n    this.baseDecode = baseDecode\n    this.encoder = new Encoder(name, prefix, baseEncode)\n    this.decoder = new Decoder(name, prefix, baseDecode)\n  }\n\n  encode (input: Uint8Array): string {\n    return this.encoder.encode(input)\n  }\n\n  decode (input: string): Uint8Array {\n    return this.decoder.decode(input)\n  }\n}\n\nexport function from <Base extends string, Prefix extends string> ({ name, prefix, encode, decode }: { name: Base, prefix: Prefix, encode: EncodeFn, decode: DecodeFn }): Codec<Base, Prefix> {\n  return new Codec(name, prefix, encode, decode)\n}\n\nexport function baseX <Base extends string, Prefix extends string> ({ name, prefix, alphabet }: { name: Base, prefix: Prefix, alphabet: string }): Codec<Base, Prefix> {\n  const { encode, decode } = basex(alphabet, name)\n  return from({\n    prefix,\n    name,\n    encode,\n    decode: (text: string): Uint8Array => coerce(decode(text))\n  })\n}\n\nfunction decode (string: string, alphabetIdx: Record<string, number>, bitsPerChar: number, name: string): Uint8Array {\n  // Count the padding bytes:\n  let end = string.length\n  while (string[end - 1] === '=') {\n    --end\n  }\n\n  // Allocate the output:\n  const out = new Uint8Array((end * bitsPerChar / 8) | 0)\n\n  // Parse the data:\n  let bits = 0 // Number of bits currently in the buffer\n  let buffer = 0 // Bits waiting to be written out, MSB first\n  let written = 0 // Next byte to write\n  for (let i = 0; i < end; ++i) {\n    // Read one character from the string:\n    const value = alphabetIdx[string[i]]\n    if (value === undefined) {\n      throw new SyntaxError(`Non-${name} character`)\n    }\n\n    // Append the bits to the buffer:\n    buffer = (buffer << bitsPerChar) | value\n    bits += bitsPerChar\n\n    // Write out some bits if the buffer has a byte's worth:\n    if (bits >= 8) {\n      bits -= 8\n      out[written++] = 0xff & (buffer >> bits)\n    }\n  }\n\n  // Verify that we have received just enough bits:\n  if (bits >= bitsPerChar || (0xff & (buffer << (8 - bits))) !== 0) {\n    throw new SyntaxError('Unexpected end of data')\n  }\n\n  return out\n}\n\nfunction encode (data: Uint8Array, alphabet: string, bitsPerChar: number): string {\n  const pad = alphabet[alphabet.length - 1] === '='\n  const mask = (1 << bitsPerChar) - 1\n  let out = ''\n\n  let bits = 0 // Number of bits currently in the buffer\n  let buffer = 0 // Bits waiting to be written out, MSB first\n  for (let i = 0; i < data.length; ++i) {\n    // Slurp data into the buffer:\n    buffer = (buffer << 8) | data[i]\n    bits += 8\n\n    // Write out as much as we can:\n    while (bits > bitsPerChar) {\n      bits -= bitsPerChar\n      out += alphabet[mask & (buffer >> bits)]\n    }\n  }\n\n  // Partial character:\n  if (bits !== 0) {\n    out += alphabet[mask & (buffer << (bitsPerChar - bits))]\n  }\n\n  // Add padding characters until we hit a byte boundary:\n  if (pad) {\n    while (((out.length * bitsPerChar) & 7) !== 0) {\n      out += '='\n    }\n  }\n\n  return out\n}\n\nfunction createAlphabetIdx (alphabet: string): Record<string, number> {\n  // Build the character lookup table:\n  const alphabetIdx: Record<string, number> = {}\n  for (let i = 0; i < alphabet.length; ++i) {\n    alphabetIdx[alphabet[i]] = i\n  }\n  return alphabetIdx\n}\n\n/**\n * RFC4648 Factory\n */\nexport function rfc4648 <Base extends string, Prefix extends string> ({ name, prefix, bitsPerChar, alphabet }: { name: Base, prefix: Prefix, bitsPerChar: number, alphabet: string }): Codec<Base, Prefix> {\n  const alphabetIdx = createAlphabetIdx(alphabet)\n  return from({\n    prefix,\n    name,\n    encode (input: Uint8Array): string {\n      return encode(input, alphabet, bitsPerChar)\n    },\n    decode (input: string): Uint8Array {\n      return decode(input, alphabetIdx, bitsPerChar, name)\n    }\n  })\n}\n", "import { rfc4648 } from './base.js'\n\nexport const base16 = rfc4648({\n  prefix: 'f',\n  name: 'base16',\n  alphabet: '0123456789abcdef',\n  bitsPerChar: 4\n})\n\nexport const base16upper = rfc4648({\n  prefix: 'F',\n  name: 'base16upper',\n  alphabet: '0123456789ABCDEF',\n  bitsPerChar: 4\n})\n", "import { rfc4648 } from './base.js'\n\nexport const base2 = rfc4648({\n  prefix: '0',\n  name: 'base2',\n  alphabet: '01',\n  bitsPerChar: 1\n})\n", "import { from } from './base.js'\n\nconst alphabet = Array.from('\uD83D\uDE80\uD83E\uDE90\u2604\uD83D\uDEF0\uD83C\uDF0C\uD83C\uDF11\uD83C\uDF12\uD83C\uDF13\uD83C\uDF14\uD83C\uDF15\uD83C\uDF16\uD83C\uDF17\uD83C\uDF18\uD83C\uDF0D\uD83C\uDF0F\uD83C\uDF0E\uD83D\uDC09\u2600\uD83D\uDCBB\uD83D\uDDA5\uD83D\uDCBE\uD83D\uDCBF\uD83D\uDE02\u2764\uD83D\uDE0D\uD83E\uDD23\uD83D\uDE0A\uD83D\uDE4F\uD83D\uDC95\uD83D\uDE2D\uD83D\uDE18\uD83D\uDC4D\uD83D\uDE05\uD83D\uDC4F\uD83D\uDE01\uD83D\uDD25\uD83E\uDD70\uD83D\uDC94\uD83D\uDC96\uD83D\uDC99\uD83D\uDE22\uD83E\uDD14\uD83D\uDE06\uD83D\uDE44\uD83D\uDCAA\uD83D\uDE09\u263A\uD83D\uDC4C\uD83E\uDD17\uD83D\uDC9C\uD83D\uDE14\uD83D\uDE0E\uD83D\uDE07\uD83C\uDF39\uD83E\uDD26\uD83C\uDF89\uD83D\uDC9E\u270C\u2728\uD83E\uDD37\uD83D\uDE31\uD83D\uDE0C\uD83C\uDF38\uD83D\uDE4C\uD83D\uDE0B\uD83D\uDC97\uD83D\uDC9A\uD83D\uDE0F\uD83D\uDC9B\uD83D\uDE42\uD83D\uDC93\uD83E\uDD29\uD83D\uDE04\uD83D\uDE00\uD83D\uDDA4\uD83D\uDE03\uD83D\uDCAF\uD83D\uDE48\uD83D\uDC47\uD83C\uDFB6\uD83D\uDE12\uD83E\uDD2D\u2763\uD83D\uDE1C\uD83D\uDC8B\uD83D\uDC40\uD83D\uDE2A\uD83D\uDE11\uD83D\uDCA5\uD83D\uDE4B\uD83D\uDE1E\uD83D\uDE29\uD83D\uDE21\uD83E\uDD2A\uD83D\uDC4A\uD83E\uDD73\uD83D\uDE25\uD83E\uDD24\uD83D\uDC49\uD83D\uDC83\uD83D\uDE33\u270B\uD83D\uDE1A\uD83D\uDE1D\uD83D\uDE34\uD83C\uDF1F\uD83D\uDE2C\uD83D\uDE43\uD83C\uDF40\uD83C\uDF37\uD83D\uDE3B\uD83D\uDE13\u2B50\u2705\uD83E\uDD7A\uD83C\uDF08\uD83D\uDE08\uD83E\uDD18\uD83D\uDCA6\u2714\uD83D\uDE23\uD83C\uDFC3\uD83D\uDC90\u2639\uD83C\uDF8A\uD83D\uDC98\uD83D\uDE20\u261D\uD83D\uDE15\uD83C\uDF3A\uD83C\uDF82\uD83C\uDF3B\uD83D\uDE10\uD83D\uDD95\uD83D\uDC9D\uD83D\uDE4A\uD83D\uDE39\uD83D\uDDE3\uD83D\uDCAB\uD83D\uDC80\uD83D\uDC51\uD83C\uDFB5\uD83E\uDD1E\uD83D\uDE1B\uD83D\uDD34\uD83D\uDE24\uD83C\uDF3C\uD83D\uDE2B\u26BD\uD83E\uDD19\u2615\uD83C\uDFC6\uD83E\uDD2B\uD83D\uDC48\uD83D\uDE2E\uD83D\uDE46\uD83C\uDF7B\uD83C\uDF43\uD83D\uDC36\uD83D\uDC81\uD83D\uDE32\uD83C\uDF3F\uD83E\uDDE1\uD83C\uDF81\u26A1\uD83C\uDF1E\uD83C\uDF88\u274C\u270A\uD83D\uDC4B\uD83D\uDE30\uD83E\uDD28\uD83D\uDE36\uD83E\uDD1D\uD83D\uDEB6\uD83D\uDCB0\uD83C\uDF53\uD83D\uDCA2\uD83E\uDD1F\uD83D\uDE41\uD83D\uDEA8\uD83D\uDCA8\uD83E\uDD2C\u2708\uD83C\uDF80\uD83C\uDF7A\uD83E\uDD13\uD83D\uDE19\uD83D\uDC9F\uD83C\uDF31\uD83D\uDE16\uD83D\uDC76\uD83E\uDD74\u25B6\u27A1\u2753\uD83D\uDC8E\uD83D\uDCB8\u2B07\uD83D\uDE28\uD83C\uDF1A\uD83E\uDD8B\uD83D\uDE37\uD83D\uDD7A\u26A0\uD83D\uDE45\uD83D\uDE1F\uD83D\uDE35\uD83D\uDC4E\uD83E\uDD32\uD83E\uDD20\uD83E\uDD27\uD83D\uDCCC\uD83D\uDD35\uD83D\uDC85\uD83E\uDDD0\uD83D\uDC3E\uD83C\uDF52\uD83D\uDE17\uD83E\uDD11\uD83C\uDF0A\uD83E\uDD2F\uD83D\uDC37\u260E\uD83D\uDCA7\uD83D\uDE2F\uD83D\uDC86\uD83D\uDC46\uD83C\uDFA4\uD83D\uDE47\uD83C\uDF51\u2744\uD83C\uDF34\uD83D\uDCA3\uD83D\uDC38\uD83D\uDC8C\uD83D\uDCCD\uD83E\uDD40\uD83E\uDD22\uD83D\uDC45\uD83D\uDCA1\uD83D\uDCA9\uD83D\uDC50\uD83D\uDCF8\uD83D\uDC7B\uD83E\uDD10\uD83E\uDD2E\uD83C\uDFBC\uD83E\uDD75\uD83D\uDEA9\uD83C\uDF4E\uD83C\uDF4A\uD83D\uDC7C\uD83D\uDC8D\uD83D\uDCE3\uD83E\uDD42')\nconst alphabetBytesToChars: string[] = (alphabet.reduce<string[]>((p, c, i) => { p[i] = c; return p }, ([])))\nconst alphabetCharsToBytes: number[] = (alphabet.reduce<number[]>((p, c, i) => {\n  const codePoint = c.codePointAt(0)\n  if (codePoint == null) {\n    throw new Error(`Invalid character: ${c}`)\n  }\n  p[codePoint] = i\n  return p\n}, ([])))\n\nfunction encode (data: Uint8Array): string {\n  return data.reduce((p, c) => {\n    p += alphabetBytesToChars[c]\n    return p\n  }, '')\n}\n\nfunction decode (str: string): Uint8Array {\n  const byts = []\n  for (const char of str) {\n    const codePoint = char.codePointAt(0)\n    if (codePoint == null) {\n      throw new Error(`Invalid character: ${char}`)\n    }\n    const byt = alphabetCharsToBytes[codePoint]\n    if (byt == null) {\n      throw new Error(`Non-base256emoji character: ${char}`)\n    }\n    byts.push(byt)\n  }\n  return new Uint8Array(byts)\n}\n\nexport const base256emoji = from({\n  prefix: '\uD83D\uDE80',\n  name: 'base256emoji',\n  encode,\n  decode\n})\n", "import { rfc4648 } from './base.js'\n\nexport const base32 = rfc4648({\n  prefix: 'b',\n  name: 'base32',\n  alphabet: 'abcdefghijklmnopqrstuvwxyz234567',\n  bitsPerChar: 5\n})\n\nexport const base32upper = rfc4648({\n  prefix: 'B',\n  name: 'base32upper',\n  alphabet: 'ABCDEFGHIJKLMNOPQRSTUVWXYZ234567',\n  bitsPerChar: 5\n})\n\nexport const base32pad = rfc4648({\n  prefix: 'c',\n  name: 'base32pad',\n  alphabet: 'abcdefghijklmnopqrstuvwxyz234567=',\n  bitsPerChar: 5\n})\n\nexport const base32padupper = rfc4648({\n  prefix: 'C',\n  name: 'base32padupper',\n  alphabet: 'ABCDEFGHIJKLMNOPQRSTUVWXYZ234567=',\n  bitsPerChar: 5\n})\n\nexport const base32hex = rfc4648({\n  prefix: 'v',\n  name: 'base32hex',\n  alphabet: '0123456789abcdefghijklmnopqrstuv',\n  bitsPerChar: 5\n})\n\nexport const base32hexupper = rfc4648({\n  prefix: 'V',\n  name: 'base32hexupper',\n  alphabet: '0123456789ABCDEFGHIJKLMNOPQRSTUV',\n  bitsPerChar: 5\n})\n\nexport const base32hexpad = rfc4648({\n  prefix: 't',\n  name: 'base32hexpad',\n  alphabet: '0123456789abcdefghijklmnopqrstuv=',\n  bitsPerChar: 5\n})\n\nexport const base32hexpadupper = rfc4648({\n  prefix: 'T',\n  name: 'base32hexpadupper',\n  alphabet: '0123456789ABCDEFGHIJKLMNOPQRSTUV=',\n  bitsPerChar: 5\n})\n\nexport const base32z = rfc4648({\n  prefix: 'h',\n  name: 'base32z',\n  alphabet: 'ybndrfg8ejkmcpqxot1uwisza345h769',\n  bitsPerChar: 5\n})\n", "import { baseX } from './base.js'\n\nexport const base36 = baseX({\n  prefix: 'k',\n  name: 'base36',\n  alphabet: '0123456789abcdefghijklmnopqrstuvwxyz'\n})\n\nexport const base36upper = baseX({\n  prefix: 'K',\n  name: 'base36upper',\n  alphabet: '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ'\n})\n", "import { baseX } from './base.js'\n\nexport const base58btc = baseX({\n  name: 'base58btc',\n  prefix: 'z',\n  alphabet: '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz'\n})\n\nexport const base58flickr = baseX({\n  name: 'base58flickr',\n  prefix: 'Z',\n  alphabet: '123456789abcdefghijkmnopqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ'\n})\n", "import { rfc4648 } from './base.js'\n\nexport const base64 = rfc4648({\n  prefix: 'm',\n  name: 'base64',\n  alphabet: 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/',\n  bitsPerChar: 6\n})\n\nexport const base64pad = rfc4648({\n  prefix: 'M',\n  name: 'base64pad',\n  alphabet: 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=',\n  bitsPerChar: 6\n})\n\nexport const base64url = rfc4648({\n  prefix: 'u',\n  name: 'base64url',\n  alphabet: 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_',\n  bitsPerChar: 6\n})\n\nexport const base64urlpad = rfc4648({\n  prefix: 'U',\n  name: 'base64urlpad',\n  alphabet: 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_=',\n  bitsPerChar: 6\n})\n", "import { rfc4648 } from './base.js'\n\nexport const base8 = rfc4648({\n  prefix: '7',\n  name: 'base8',\n  alphabet: '01234567',\n  bitsPerChar: 3\n})\n", "import { fromString, toString } from '../bytes.js'\nimport { from } from './base.js'\n\nexport const identity = from({\n  prefix: '\\x00',\n  name: 'identity',\n  encode: (buf) => toString(buf),\n  decode: (str) => fromString(str)\n})\n", "import type { ArrayBufferView, ByteView } from './interface.js'\n\nconst textEncoder = new TextEncoder()\nconst textDecoder = new TextDecoder()\n\nexport const name = 'json'\nexport const code = 0x0200\n\nexport function encode <T> (node: T): ByteView<T> {\n  return textEncoder.encode(JSON.stringify(node))\n}\n\nexport function decode <T> (data: ByteView<T> | ArrayBufferView<T>): T {\n  return JSON.parse(textDecoder.decode(data))\n}\n", "import { coerce } from '../bytes.js'\nimport * as Digest from './digest.js'\nimport type { DigestOptions } from './hasher.js'\n\nconst code: 0x0 = 0x0\nconst name = 'identity'\n\nconst encode: (input: Uint8Array) => Uint8Array = coerce\n\nfunction digest (input: Uint8Array, options?: DigestOptions): Digest.Digest<typeof code, number> {\n  if (options?.truncate != null && options.truncate !== input.byteLength) {\n    if (options.truncate < 0 || options.truncate > input.byteLength) {\n      throw new Error(`Invalid truncate option, must be less than or equal to ${input.byteLength}`)\n    }\n\n    input = input.subarray(0, options.truncate)\n  }\n\n  return Digest.create(code, encode(input))\n}\n\nexport const identity = { code, name, encode, digest }\n", "/* eslint-disable */\nvar encode_1 = encode;\n\nvar MSB = 0x80\n  , REST = 0x7F\n  , MSBALL = ~REST\n  , INT = Math.pow(2, 31);\n\n/**\n * @param {number} num\n * @param {number[]} out\n * @param {number} offset\n */\nfunction encode(num, out, offset) {\n  out = out || [];\n  offset = offset || 0;\n  var oldOffset = offset;\n\n  while(num >= INT) {\n    out[offset++] = (num & 0xFF) | MSB;\n    num /= 128;\n  }\n  while(num & MSBALL) {\n    out[offset++] = (num & 0xFF) | MSB;\n    num >>>= 7;\n  }\n  out[offset] = num | 0;\n  \n  // @ts-ignore\n  encode.bytes = offset - oldOffset + 1;\n  \n  return out\n}\n\nvar decode = read;\n\nvar MSB$1 = 0x80\n  , REST$1 = 0x7F;\n\n/**\n * @param {string | any[]} buf\n * @param {number} offset\n */\nfunction read(buf, offset) {\n  var res    = 0\n    , offset = offset || 0\n    , shift  = 0\n    , counter = offset\n    , b\n    , l = buf.length;\n\n  do {\n    if (counter >= l) {\n      // @ts-ignore\n      read.bytes = 0;\n      throw new RangeError('Could not decode varint')\n    }\n    b = buf[counter++];\n    res += shift < 28\n      ? (b & REST$1) << shift\n      : (b & REST$1) * Math.pow(2, shift);\n    shift += 7;\n  } while (b >= MSB$1)\n\n  // @ts-ignore\n  read.bytes = counter - offset;\n\n  return res\n}\n\nvar N1 = Math.pow(2,  7);\nvar N2 = Math.pow(2, 14);\nvar N3 = Math.pow(2, 21);\nvar N4 = Math.pow(2, 28);\nvar N5 = Math.pow(2, 35);\nvar N6 = Math.pow(2, 42);\nvar N7 = Math.pow(2, 49);\nvar N8 = Math.pow(2, 56);\nvar N9 = Math.pow(2, 63);\n\nvar length = function (/** @type {number} */ value) {\n  return (\n    value < N1 ? 1\n  : value < N2 ? 2\n  : value < N3 ? 3\n  : value < N4 ? 4\n  : value < N5 ? 5\n  : value < N6 ? 6\n  : value < N7 ? 7\n  : value < N8 ? 8\n  : value < N9 ? 9\n  :              10\n  )\n};\n\nvar varint = {\n    encode: encode_1\n  , decode: decode\n  , encodingLength: length\n};\n\nvar _brrp_varint = varint;\n\nexport default _brrp_varint;\n", "import varint from './vendor/varint.js'\n\nexport function decode (data: Uint8Array, offset = 0): [number, number] {\n  const code = varint.decode(data, offset)\n  return [code, varint.decode.bytes]\n}\n\nexport function encodeTo (int: number, target: Uint8Array, offset = 0): Uint8Array {\n  varint.encode(int, target, offset)\n  return target\n}\n\nexport function encodingLength (int: number): number {\n  return varint.encodingLength(int)\n}\n", "import { coerce, equals as equalBytes } from '../bytes.js'\nimport * as varint from '../varint.js'\nimport type { MultihashDigest } from './interface.js'\n\n/**\n * Creates a multihash digest.\n */\nexport function create <Code extends number> (code: Code, digest: Uint8Array): Digest<Code, number> {\n  const size = digest.byteLength\n  const sizeOffset = varint.encodingLength(code)\n  const digestOffset = sizeOffset + varint.encodingLength(size)\n\n  const bytes = new Uint8Array(digestOffset + size)\n  varint.encodeTo(code, bytes, 0)\n  varint.encodeTo(size, bytes, sizeOffset)\n  bytes.set(digest, digestOffset)\n\n  return new Digest(code, size, digest, bytes)\n}\n\n/**\n * Turns bytes representation of multihash digest into an instance.\n */\nexport function decode (multihash: Uint8Array): MultihashDigest {\n  const bytes = coerce(multihash)\n  const [code, sizeOffset] = varint.decode(bytes)\n  const [size, digestOffset] = varint.decode(bytes.subarray(sizeOffset))\n  const digest = bytes.subarray(sizeOffset + digestOffset)\n\n  if (digest.byteLength !== size) {\n    throw new Error('Incorrect length')\n  }\n\n  return new Digest(code, size, digest, bytes)\n}\n\nexport function equals (a: MultihashDigest, b: unknown): b is MultihashDigest {\n  if (a === b) {\n    return true\n  } else {\n    const data = b as { code?: unknown, size?: unknown, bytes?: unknown }\n\n    return (\n      a.code === data.code &&\n      a.size === data.size &&\n      data.bytes instanceof Uint8Array &&\n      equalBytes(a.bytes, data.bytes)\n    )\n  }\n}\n\n/**\n * Represents a multihash digest which carries information about the\n * hashing algorithm and an actual hash digest.\n */\nexport class Digest<Code extends number, Size extends number> implements MultihashDigest {\n  readonly code: Code\n  readonly size: Size\n  readonly digest: Uint8Array\n  readonly bytes: Uint8Array\n\n  /**\n   * Creates a multihash digest.\n   */\n  constructor (code: Code, size: Size, digest: Uint8Array, bytes: Uint8Array) {\n    this.code = code\n    this.size = size\n    this.digest = digest\n    this.bytes = bytes\n  }\n}\n\n/**\n * Used to check that the passed multihash has the passed code\n */\nexport function hasCode <T extends number> (digest: MultihashDigest, code: T): digest is MultihashDigest<T> {\n  return digest.code === code\n}\n", "/* global crypto */\n\nimport { from } from './hasher.js'\n\nfunction sha (name: AlgorithmIdentifier): (data: Uint8Array) => Promise<Uint8Array> {\n  return async data => new Uint8Array(await crypto.subtle.digest(name, data))\n}\n\nexport const sha256 = from({\n  name: 'sha2-256',\n  code: 0x12,\n  encode: sha('SHA-256')\n})\n\nexport const sha512 = from({\n  name: 'sha2-512',\n  code: 0x13,\n  encode: sha('SHA-512')\n})\n", "import * as Digest from './digest.js'\nimport type { MultihashHasher } from './interface.js'\n\ntype Await<T> = Promise<T> | T\n\nconst DEFAULT_MIN_DIGEST_LENGTH = 20\n\nexport interface HasherInit <Name extends string, Code extends number> {\n  name: Name\n  code: Code\n  encode(input: Uint8Array): Await<Uint8Array>\n\n  /**\n   * The minimum length a hash is allowed to be truncated to in bytes\n   *\n   * @default 20\n   */\n  minDigestLength?: number\n\n  /**\n   * The maximum length a hash is allowed to be truncated to in bytes. If not\n   * specified it will be inferred from the length of the digest.\n   */\n  maxDigestLength?: number\n}\n\nexport function from <Name extends string, Code extends number> ({ name, code, encode, minDigestLength, maxDigestLength }: HasherInit<Name, Code>): Hasher<Name, Code> {\n  return new Hasher(name, code, encode, minDigestLength, maxDigestLength)\n}\n\nexport interface DigestOptions {\n  /**\n   * Truncate the returned digest to this number of bytes.\n   *\n   * This may cause the digest method to throw/reject if the passed value is\n   * greater than the digest length or below a threshold under which the risk of\n   * hash collisions is significant.\n   *\n   * The actual value of this threshold can depend on the hashing algorithm in\n   * use.\n   */\n  truncate?: number\n}\n\n/**\n * Hasher represents a hashing algorithm implementation that produces as\n * `MultihashDigest`.\n */\nexport class Hasher<Name extends string, Code extends number> implements MultihashHasher<Code> {\n  readonly name: Name\n  readonly code: Code\n  readonly encode: (input: Uint8Array) => Await<Uint8Array>\n  readonly minDigestLength: number\n  readonly maxDigestLength?: number\n\n  constructor (name: Name, code: Code, encode: (input: Uint8Array) => Await<Uint8Array>, minDigestLength?: number, maxDigestLength?: number) {\n    this.name = name\n    this.code = code\n    this.encode = encode\n    this.minDigestLength = minDigestLength ?? DEFAULT_MIN_DIGEST_LENGTH\n    this.maxDigestLength = maxDigestLength\n  }\n\n  digest (input: Uint8Array, options?: DigestOptions): Await<Digest.Digest<Code, number>> {\n    if (options?.truncate != null) {\n      if (options.truncate < this.minDigestLength) {\n        throw new Error(`Invalid truncate option, must be greater than or equal to ${this.minDigestLength}`)\n      }\n\n      if (this.maxDigestLength != null && options.truncate > this.maxDigestLength) {\n        throw new Error(`Invalid truncate option, must be less than or equal to ${this.maxDigestLength}`)\n      }\n    }\n\n    if (input instanceof Uint8Array) {\n      const result = this.encode(input)\n\n      if (result instanceof Uint8Array) {\n        return createDigest(result, this.code, options?.truncate)\n      }\n\n      return result.then(digest => createDigest(digest, this.code, options?.truncate))\n    } else {\n      throw Error('Unknown type, must be binary type')\n      /* c8 ignore next 1 */\n    }\n  }\n}\n\n/**\n * Create a Digest from the passed uint8array and code, optionally truncating it\n * first.\n */\nfunction createDigest <Code extends number> (digest: Uint8Array, code: Code, truncate?: number): Digest.Digest<Code, number> {\n  if (truncate != null && truncate !== digest.byteLength) {\n    if (truncate > digest.byteLength) {\n      throw new Error(`Invalid truncate option, must be less than or equal to ${digest.byteLength}`)\n    }\n\n    digest = digest.subarray(0, truncate)\n  }\n\n  return Digest.create(code, digest)\n}\n", "import { base32 } from './bases/base32.js'\nimport { base36 } from './bases/base36.js'\nimport { base58btc } from './bases/base58.js'\nimport { coerce } from './bytes.js'\nimport * as Digest from './hashes/digest.js'\nimport * as varint from './varint.js'\nimport type * as API from './link/interface.js'\n\n// This way TS will also expose all the types from module\nexport * from './link/interface.js'\n\nexport function format <T extends API.Link<unknown, number, number, API.Version>, Prefix extends string> (link: T, base?: API.MultibaseEncoder<Prefix>): API.ToString<T, Prefix> {\n  const { bytes, version } = link\n  switch (version) {\n    case 0:\n      return toStringV0(\n        bytes,\n        baseCache(link),\n        base as API.MultibaseEncoder<'z'> ?? base58btc.encoder\n      )\n    default:\n      return toStringV1(\n        bytes,\n        baseCache(link),\n        (base ?? base32.encoder) as API.MultibaseEncoder<Prefix>\n      )\n  }\n}\n\nexport function toJSON <Link extends API.UnknownLink> (link: Link): API.LinkJSON<Link> {\n  return {\n    '/': format(link)\n  }\n}\n\nexport function fromJSON <Link extends API.UnknownLink> (json: API.LinkJSON<Link>): CID<unknown, number, number, API.Version> {\n  return CID.parse(json['/'])\n}\n\nconst cache = new WeakMap<API.UnknownLink, Map<string, string>>()\n\nfunction baseCache (cid: API.UnknownLink): Map<string, string> {\n  const baseCache = cache.get(cid)\n  if (baseCache == null) {\n    const baseCache = new Map()\n    cache.set(cid, baseCache)\n    return baseCache\n  }\n  return baseCache\n}\n\nexport class CID<Data = unknown, Format extends number = number, Alg extends number = number, Version extends API.Version = API.Version> implements API.Link<Data, Format, Alg, Version> {\n  readonly code: Format\n  readonly version: Version\n  readonly multihash: API.MultihashDigest<Alg>\n  readonly bytes: Uint8Array\n  readonly '/': Uint8Array\n\n  /**\n   * @param version - Version of the CID\n   * @param code - Code of the codec content is encoded in, see https://github.com/multiformats/multicodec/blob/master/table.csv\n   * @param multihash - (Multi)hash of the of the content.\n   */\n  constructor (version: Version, code: Format, multihash: API.MultihashDigest<Alg>, bytes: Uint8Array) {\n    this.code = code\n    this.version = version\n    this.multihash = multihash\n    this.bytes = bytes\n\n    // flag to serializers that this is a CID and\n    // should be treated specially\n    this['/'] = bytes\n  }\n\n  /**\n   * Signalling `cid.asCID === cid` has been replaced with `cid['/'] === cid.bytes`\n   * please either use `CID.asCID(cid)` or switch to new signalling mechanism\n   *\n   * @deprecated\n   */\n  get asCID (): this {\n    return this\n  }\n\n  // ArrayBufferView\n  get byteOffset (): number {\n    return this.bytes.byteOffset\n  }\n\n  // ArrayBufferView\n  get byteLength (): number {\n    return this.bytes.byteLength\n  }\n\n  toV0 (): CID<Data, API.DAG_PB, API.SHA_256, 0> {\n    switch (this.version) {\n      case 0: {\n        return this as CID<Data, API.DAG_PB, API.SHA_256, 0>\n      }\n      case 1: {\n        const { code, multihash } = this\n\n        if (code !== DAG_PB_CODE) {\n          throw new Error('Cannot convert a non dag-pb CID to CIDv0')\n        }\n\n        // sha2-256\n        if (multihash.code !== SHA_256_CODE) {\n          throw new Error('Cannot convert non sha2-256 multihash CID to CIDv0')\n        }\n\n        return (\n          CID.createV0(\n            multihash as API.MultihashDigest<API.SHA_256>\n          )\n        )\n      }\n      default: {\n        throw Error(\n          `Can not convert CID version ${this.version} to version 0. This is a bug please report`\n        )\n      }\n    }\n  }\n\n  toV1 (): CID<Data, Format, Alg, 1> {\n    switch (this.version) {\n      case 0: {\n        const { code, digest } = this.multihash\n        const multihash = Digest.create(code, digest)\n        return (\n          CID.createV1(this.code, multihash)\n        )\n      }\n      case 1: {\n        return this as CID<Data, Format, Alg, 1>\n      }\n      default: {\n        throw Error(\n          `Can not convert CID version ${this.version} to version 1. This is a bug please report`\n        )\n      }\n    }\n  }\n\n  equals (other: unknown): other is CID<Data, Format, Alg, Version> {\n    return CID.equals(this, other)\n  }\n\n  static equals <Data, Format extends number, Alg extends number, Version extends API.Version>(self: API.Link<Data, Format, Alg, Version>, other: unknown): other is CID {\n    const unknown = other as { code?: unknown, version?: unknown, multihash?: unknown }\n    return (\n      unknown != null &&\n      self.code === unknown.code &&\n      self.version === unknown.version &&\n      Digest.equals(self.multihash, unknown.multihash)\n    )\n  }\n\n  toString (base?: API.MultibaseEncoder<string>): string {\n    return format(this, base)\n  }\n\n  toJSON (): API.LinkJSON<this> {\n    return { '/': format(this) }\n  }\n\n  link (): this {\n    return this\n  }\n\n  readonly [Symbol.toStringTag] = 'CID';\n\n  // Legacy\n\n  [Symbol.for('nodejs.util.inspect.custom')] (): string {\n    return `CID(${this.toString()})`\n  }\n\n  /**\n   * Takes any input `value` and returns a `CID` instance if it was\n   * a `CID` otherwise returns `null`. If `value` is instanceof `CID`\n   * it will return value back. If `value` is not instance of this CID\n   * class, but is compatible CID it will return new instance of this\n   * `CID` class. Otherwise returns null.\n   *\n   * This allows two different incompatible versions of CID library to\n   * co-exist and interop as long as binary interface is compatible.\n   */\n  static asCID <Data, Format extends number, Alg extends number, Version extends API.Version, U>(input: API.Link<Data, Format, Alg, Version> | U): CID<Data, Format, Alg, Version> | null {\n    if (input == null) {\n      return null\n    }\n\n    const value = input as any\n    if (value instanceof CID) {\n      // If value is instance of CID then we're all set.\n      return value\n    } else if ((value['/'] != null && value['/'] === value.bytes) || value.asCID === value) {\n      // If value isn't instance of this CID class but `this.asCID === this` or\n      // `value['/'] === value.bytes` is true it is CID instance coming from a\n      // different implementation (diff version or duplicate). In that case we\n      // rebase it to this `CID` implementation so caller is guaranteed to get\n      // instance with expected API.\n      const { version, code, multihash, bytes } = value\n      return new CID(\n        version,\n        code,\n        multihash as API.MultihashDigest<Alg>,\n        bytes ?? encodeCID(version, code, multihash.bytes)\n      )\n    } else if (value[cidSymbol] === true) {\n      // If value is a CID from older implementation that used to be tagged via\n      // symbol we still rebase it to the this `CID` implementation by\n      // delegating that to a constructor.\n      const { version, multihash, code } = value\n      const digest = Digest.decode(multihash) as API.MultihashDigest<Alg>\n      return CID.create(version, code, digest)\n    } else {\n      // Otherwise value is not a CID (or an incompatible version of it) in\n      // which case we return `null`.\n      return null\n    }\n  }\n\n  /**\n   * @param version - Version of the CID\n   * @param code - Code of the codec content is encoded in, see https://github.com/multiformats/multicodec/blob/master/table.csv\n   * @param digest - (Multi)hash of the of the content.\n   */\n  static create <Data, Format extends number, Alg extends number, Version extends API.Version>(version: Version, code: Format, digest: API.MultihashDigest<Alg>): CID<Data, Format, Alg, Version> {\n    if (typeof code !== 'number') {\n      throw new Error('String codecs are no longer supported')\n    }\n\n    if (!(digest.bytes instanceof Uint8Array)) {\n      throw new Error('Invalid digest')\n    }\n\n    switch (version) {\n      case 0: {\n        if (code !== DAG_PB_CODE) {\n          throw new Error(\n            `Version 0 CID must use dag-pb (code: ${DAG_PB_CODE}) block encoding`\n          )\n        } else {\n          return new CID(version, code, digest, digest.bytes)\n        }\n      }\n      case 1: {\n        const bytes = encodeCID(version, code, digest.bytes)\n        return new CID(version, code, digest, bytes)\n      }\n      default: {\n        throw new Error('Invalid version')\n      }\n    }\n  }\n\n  /**\n   * Simplified version of `create` for CIDv0.\n   */\n  static createV0 <T = unknown>(digest: API.MultihashDigest<typeof SHA_256_CODE>): CID<T, typeof DAG_PB_CODE, typeof SHA_256_CODE, 0> {\n    return CID.create(0, DAG_PB_CODE, digest)\n  }\n\n  /**\n   * Simplified version of `create` for CIDv1.\n   *\n   * @param code - Content encoding format code.\n   * @param digest - Multihash of the content.\n   */\n  static createV1 <Data, Code extends number, Alg extends number>(code: Code, digest: API.MultihashDigest<Alg>): CID<Data, Code, Alg, 1> {\n    return CID.create(1, code, digest)\n  }\n\n  /**\n   * Decoded a CID from its binary representation. The byte array must contain\n   * only the CID with no additional bytes.\n   *\n   * An error will be thrown if the bytes provided do not contain a valid\n   * binary representation of a CID.\n   */\n  static decode <Data, Code extends number, Alg extends number, Version extends API.Version>(bytes: API.ByteView<API.Link<Data, Code, Alg, Version>>): CID<Data, Code, Alg, Version> {\n    const [cid, remainder] = CID.decodeFirst(bytes)\n    if (remainder.length !== 0) {\n      throw new Error('Incorrect length')\n    }\n    return cid\n  }\n\n  /**\n   * Decoded a CID from its binary representation at the beginning of a byte\n   * array.\n   *\n   * Returns an array with the first element containing the CID and the second\n   * element containing the remainder of the original byte array. The remainder\n   * will be a zero-length byte array if the provided bytes only contained a\n   * binary CID representation.\n   */\n  static decodeFirst <T, C extends number, A extends number, V extends API.Version>(bytes: API.ByteView<API.Link<T, C, A, V>>): [CID<T, C, A, V>, Uint8Array] {\n    const specs = CID.inspectBytes(bytes)\n    const prefixSize = specs.size - specs.multihashSize\n    const multihashBytes = coerce(\n      bytes.subarray(prefixSize, prefixSize + specs.multihashSize)\n    )\n    if (multihashBytes.byteLength !== specs.multihashSize) {\n      throw new Error('Incorrect length')\n    }\n    const digestBytes = multihashBytes.subarray(\n      specs.multihashSize - specs.digestSize\n    )\n    const digest = new Digest.Digest(\n      specs.multihashCode,\n      specs.digestSize,\n      digestBytes,\n      multihashBytes\n    )\n    const cid =\n      specs.version === 0\n        ? CID.createV0(digest as API.MultihashDigest<API.SHA_256>)\n        : CID.createV1(specs.codec, digest)\n    return [cid as CID<T, C, A, V>, bytes.subarray(specs.size)]\n  }\n\n  /**\n   * Inspect the initial bytes of a CID to determine its properties.\n   *\n   * Involves decoding up to 4 varints. Typically this will require only 4 to 6\n   * bytes but for larger multicodec code values and larger multihash digest\n   * lengths these varints can be quite large. It is recommended that at least\n   * 10 bytes be made available in the `initialBytes` argument for a complete\n   * inspection.\n   */\n  static inspectBytes <T, C extends number, A extends number, V extends API.Version>(initialBytes: API.ByteView<API.Link<T, C, A, V>>): { version: V, codec: C, multihashCode: A, digestSize: number, multihashSize: number, size: number } {\n    let offset = 0\n    const next = (): number => {\n      const [i, length] = varint.decode(initialBytes.subarray(offset))\n      offset += length\n      return i\n    }\n\n    let version = next() as V\n    let codec = DAG_PB_CODE as C\n    if (version as number === 18) {\n      // CIDv0\n      version = 0 as V\n      offset = 0\n    } else {\n      codec = next() as C\n    }\n\n    if (version !== 0 && version !== 1) {\n      throw new RangeError(`Invalid CID version ${version}`)\n    }\n\n    const prefixSize = offset\n    const multihashCode = next() as A // multihash code\n    const digestSize = next() // multihash length\n    const size = offset + digestSize\n    const multihashSize = size - prefixSize\n\n    return { version, codec, multihashCode, digestSize, multihashSize, size }\n  }\n\n  /**\n   * Takes cid in a string representation and creates an instance. If `base`\n   * decoder is not provided will use a default from the configuration. It will\n   * throw an error if encoding of the CID is not compatible with supplied (or\n   * a default decoder).\n   */\n  static parse <Prefix extends string, Data, Code extends number, Alg extends number, Version extends API.Version>(source: API.ToString<API.Link<Data, Code, Alg, Version>, Prefix>, base?: API.MultibaseDecoder<Prefix>): CID<Data, Code, Alg, Version> {\n    const [prefix, bytes] = parseCIDtoBytes(source, base)\n\n    const cid = CID.decode(bytes)\n\n    if (cid.version === 0 && source[0] !== 'Q') {\n      throw Error('Version 0 CID string must not include multibase prefix')\n    }\n\n    // Cache string representation to avoid computing it on `this.toString()`\n    baseCache(cid).set(prefix, source)\n\n    return cid\n  }\n}\n\nfunction parseCIDtoBytes <Prefix extends string, Data, Code extends number, Alg extends number, Version extends API.Version> (source: API.ToString<API.Link<Data, Code, Alg, Version>, Prefix>, base?: API.MultibaseDecoder<Prefix>): [Prefix, API.ByteView<API.Link<Data, Code, Alg, Version>>] {\n  switch (source[0]) {\n    // CIDv0 is parsed differently\n    case 'Q': {\n      const decoder = base ?? base58btc\n      return [\n        base58btc.prefix as Prefix,\n        decoder.decode(`${base58btc.prefix}${source}`)\n      ]\n    }\n    case base58btc.prefix: {\n      const decoder = base ?? base58btc\n      return [base58btc.prefix as Prefix, decoder.decode(source)]\n    }\n    case base32.prefix: {\n      const decoder = base ?? base32\n      return [base32.prefix as Prefix, decoder.decode(source)]\n    }\n    case base36.prefix: {\n      const decoder = base ?? base36\n      return [base36.prefix as Prefix, decoder.decode(source)]\n    }\n    default: {\n      if (base == null) {\n        throw Error(\n          'To parse non base32, base36 or base58btc encoded CID multibase decoder must be provided'\n        )\n      }\n      return [source[0] as Prefix, base.decode(source)]\n    }\n  }\n}\n\nfunction toStringV0 (bytes: Uint8Array, cache: Map<string, string>, base: API.MultibaseEncoder<'z'>): string {\n  const { prefix } = base\n  if (prefix !== base58btc.prefix) {\n    throw Error(`Cannot string encode V0 in ${base.name} encoding`)\n  }\n\n  const cid = cache.get(prefix)\n  if (cid == null) {\n    const cid = base.encode(bytes).slice(1)\n    cache.set(prefix, cid)\n    return cid\n  } else {\n    return cid\n  }\n}\n\nfunction toStringV1 <Prefix extends string> (bytes: Uint8Array, cache: Map<string, string>, base: API.MultibaseEncoder<Prefix>): string {\n  const { prefix } = base\n  const cid = cache.get(prefix)\n  if (cid == null) {\n    const cid = base.encode(bytes)\n    cache.set(prefix, cid)\n    return cid\n  } else {\n    return cid\n  }\n}\n\nconst DAG_PB_CODE = 0x70\nconst SHA_256_CODE = 0x12\n\nfunction encodeCID (version: API.Version, code: number, multihash: Uint8Array): Uint8Array {\n  const codeOffset = varint.encodingLength(version)\n  const hashOffset = codeOffset + varint.encodingLength(code)\n  const bytes = new Uint8Array(hashOffset + multihash.byteLength)\n  varint.encodeTo(version, bytes, 0)\n  varint.encodeTo(code, bytes, codeOffset)\n  bytes.set(multihash, hashOffset)\n  return bytes\n}\n\nconst cidSymbol = Symbol.for('@ipld/js-cid/CID')\n", "import * as base10 from './bases/base10.js'\nimport * as base16 from './bases/base16.js'\nimport * as base2 from './bases/base2.js'\nimport * as base256emoji from './bases/base256emoji.js'\nimport * as base32 from './bases/base32.js'\nimport * as base36 from './bases/base36.js'\nimport * as base58 from './bases/base58.js'\nimport * as base64 from './bases/base64.js'\nimport * as base8 from './bases/base8.js'\nimport * as identityBase from './bases/identity.js'\nimport * as json from './codecs/json.js'\nimport * as raw from './codecs/raw.js'\nimport * as identity from './hashes/identity.js'\nimport * as sha2 from './hashes/sha2.js'\nimport { CID, hasher, digest, varint, bytes } from './index.js'\n\nexport const bases = { ...identityBase, ...base2, ...base8, ...base10, ...base16, ...base32, ...base36, ...base58, ...base64, ...base256emoji }\nexport const hashes = { ...sha2, ...identity }\nexport const codecs = { raw, json }\n\nexport { CID, hasher, digest, varint, bytes }\n", "import { bases } from 'multiformats/basics'\nimport type { MultibaseCodec } from 'multiformats'\nimport { allocUnsafe } from '#alloc'\n\nfunction createCodec (name: string, prefix: string, encode: (buf: Uint8Array) => string, decode: (str: string) => Uint8Array): MultibaseCodec<any> {\n  return {\n    name,\n    prefix,\n    encoder: {\n      name,\n      prefix,\n      encode\n    },\n    decoder: {\n      decode\n    }\n  }\n}\n\nconst string = createCodec('utf8', 'u', (buf) => {\n  const decoder = new TextDecoder('utf8')\n  return 'u' + decoder.decode(buf)\n}, (str) => {\n  const encoder = new TextEncoder()\n  return encoder.encode(str.substring(1))\n})\n\nconst ascii = createCodec('ascii', 'a', (buf) => {\n  let string = 'a'\n\n  for (let i = 0; i < buf.length; i++) {\n    string += String.fromCharCode(buf[i])\n  }\n  return string\n}, (str) => {\n  str = str.substring(1)\n  const buf = allocUnsafe(str.length)\n\n  for (let i = 0; i < str.length; i++) {\n    buf[i] = str.charCodeAt(i)\n  }\n\n  return buf\n})\n\nexport type SupportedEncodings = 'utf8' | 'utf-8' | 'hex' | 'latin1' | 'ascii' | 'binary' | keyof typeof bases\n\nconst BASES: Record<SupportedEncodings, MultibaseCodec<any>> = {\n  utf8: string,\n  'utf-8': string,\n  hex: bases.base16,\n  latin1: ascii,\n  ascii,\n  binary: ascii,\n\n  ...bases\n}\n\nexport default BASES\n", "import bases from './util/bases.ts'\nimport type { SupportedEncodings } from './util/bases.ts'\n\nexport type { SupportedEncodings }\n\n/**\n * Create a `Uint8Array` from the passed string\n *\n * Supports `utf8`, `utf-8`, `hex`, and any encoding supported by the multiformats module.\n *\n * Also `ascii` which is similar to node's 'binary' encoding.\n */\nexport function fromString (string: string, encoding: SupportedEncodings = 'utf8'): Uint8Array {\n  const base = bases[encoding]\n\n  if (base == null) {\n    throw new Error(`Unsupported encoding \"${encoding}\"`)\n  }\n\n  // add multibase prefix\n  return base.decoder.decode(`${base.prefix}${string}`)\n}\n", "import bases from './util/bases.ts'\nimport type { SupportedEncodings } from './util/bases.ts'\n\nexport type { SupportedEncodings }\n\n/**\n * Turns a `Uint8Array` into a string.\n *\n * Supports `utf8`, `utf-8` and any encoding supported by the multibase module.\n *\n * Also `ascii` which is similar to node's 'binary' encoding.\n */\nexport function toString (array: Uint8Array, encoding: SupportedEncodings = 'utf8'): string {\n  const base = bases[encoding]\n\n  if (base == null) {\n    throw new Error(`Unsupported encoding \"${encoding}\"`)\n  }\n\n  // strip multibase prefix\n  return base.encoder.encode(array).substring(1)\n}\n", "/**\n * The set of stable error codes this package raises.\n *\n * Branch on `err.code`, not on `err.message`: the codes are part of the\n * public API, the prose is not.\n */\nexport type HpkeErrorCode =\n    'ERR_INVALID_RECIPIENT_KEY'|\n    'ERR_INVALID_KEYPAIR'|\n    'ERR_SMALL_ORDER_KEY'|\n    'ERR_MALFORMED_ENVELOPE'|\n    'ERR_MALFORMED_MESSAGE'|\n    'ERR_INVALID_KEYSIZE'|\n    'ERR_INVALID_AES_KEY'|\n    'ERR_DECRYPT_FAILED'\n\n/**\n * An `Error` carrying a stable `code`. Every throw site in this package\n * raises one of these, so callers can branch on the failure instead of\n * pattern matching on a message.\n *\n * Where a WebCrypto failure is being wrapped, the original is kept on\n * `cause`.\n */\nexport class HpkeError extends Error {\n    readonly code:HpkeErrorCode\n\n    constructor (\n        code:HpkeErrorCode,\n        message:string,\n        opts?:{ cause?:unknown }\n    ) {\n        super(message, opts)\n        this.name = 'HpkeError'\n        this.code = code\n    }\n}\n", "import { fromString } from 'uint8arrays'\nimport {\n    type RecipientKey,\n    aeadSeal,\n    aeadOpen,\n    encryptToString,\n    encryptBytes,\n    resolveRecipientPublicKey,\n    concat,\n    encap,\n    decap,\n    labeledExtract,\n    labeledExpand,\n    keyId,\n} from './util'\nimport { HpkeError } from './errors'\nimport {\n    AEAD_TAG_LENGTH,\n    ENC_LENGTH,\n    NN,\n    NK,\n    MODE_BASE,\n    WRAPPED_LEN_PREFIX,\n    HPKE_SUITE_ID,\n} from './constants'\n\nexport { keyId }\nexport { HpkeError, type HpkeErrorCode } from './errors'\n\n// RFC 9180 HPKE cipher suite\n// (DHKEM(X25519, HKDF-SHA256) + HKDF-SHA256 + AES-256-GCM,\n// base mode, single-shot)\n// - Pure helpers build the labeled byte strings\n// - all crypto runs through WebCrypto's subtle API so the X25519 private\n//   key can stay non-extractable (HPKE needs only `deriveBits`).\n\nconst subtle = globalThis.crypto.subtle\n\n/**\n * Create a new AES key for the given public key.\n *\n * @param recipient Public key for decryptor\n * @param opts `size`, `info`, and `extractable`\n * @returns {{ wrapped, key }} The wrapped envelope bytes and the generated\n *   AES-GCM key.\n */\nexport async function create (\n    recipient:RecipientKey,\n    opts?:{\n        // Size of the GENERATED AES key. Ignored when an `aesKey` is supplied.\n        size?:128|256\n        // HPKE `info`: bound into the key schedule; must match on open.\n        info?:Uint8Array|string\n        // Whether the returned AES key can be exported. Default false.\n        extractable?:boolean\n    }\n):Promise<{ wrapped:Uint8Array<ArrayBufferLike>, key:CryptoKey }> {\n    const { wrapped, key } = await encryptKey(recipient, null, opts)\n    return { wrapped, key }\n}\n\n/**\n * Recover the AES key wrapped by `create` or `encryptKey`. Call `open(...)`\n * for a usable AES-GCM `CryptoKey`, or `open.raw(...)` for the raw key bytes.\n */\nexport const open = Object.assign(openBytes, {\n    raw: openRawBytes\n})\n\n/**\n * Wrap an AES key to `recipient` and AES-GCM encrypt a message under it.\n * Call `encrypt(...)` for the raw envelope bytes, or `encrypt.asString(...)`\n * for the same envelope as an encoded string.\n */\nexport const encrypt = Object.assign(encryptBytes, {\n    asString: encryptToString\n})\n\n/**\n * Recover the AES key from an `encrypt` envelope and AES-GCM decrypt the\n * message. Call `decrypt(...)` for the plaintext bytes,\n * `decrypt.asString(...)` to UTF-8 decode them to a string, or\n * `decrypt.fromString(...)` to decrypt a `base64url`-encoded envelope\n * string (from `encrypt.asString`).\n */\nexport const decrypt = Object.assign(decryptBytes, {\n    asString: decryptToString,\n    fromString: decryptFromString\n})\n\n/**\n * Recover the AES key from an envelope produced by `encrypt`, then AES-GCM\n * decrypt the message.\n *\n * @param keypair The same recipient `CryptoKeyPair` used to `encrypt`.\n * @param message The envelope returned by `encrypt`.\n * @param opts `info` -- must match the value passed to `encrypt`.\n * @returns The decrypted plaintext bytes. Use `decrypt.asString` for a string.\n */\nasync function decryptBytes (\n    keypair:CryptoKeyPair,\n    message:Uint8Array,\n    opts?:{ info?:Uint8Array|string }\n):Promise<Uint8Array> {\n    if (message.byteLength < WRAPPED_LEN_PREFIX) {\n        throw new HpkeError(\n            'ERR_MALFORMED_MESSAGE',\n            'malformed message: too short'\n        )\n    }\n\n    const wrappedLen = (message[0] << 8) | message[1]\n    const ivStart = WRAPPED_LEN_PREFIX + wrappedLen\n    const ctStart = ivStart + NN\n    if (message.byteLength < ctStart + AEAD_TAG_LENGTH) {\n        throw new HpkeError(\n            'ERR_MALFORMED_MESSAGE',\n            'malformed message: too short'\n        )\n    }\n\n    const wrapped = message.slice(WRAPPED_LEN_PREFIX, ivStart)\n    const iv = message.slice(ivStart, ctStart)\n    const ciphertext = message.slice(ctStart)\n\n    const keyBytes = await openRawBytes(\n        keypair,\n        wrapped,\n        opts?.info !== undefined ? { info: opts.info } : undefined\n    )\n    const key = await importAesKeyDecryptOnly(keyBytes)\n\n    let pt:ArrayBuffer\n    try {\n        pt = await subtle.decrypt(\n            { name: 'AES-GCM', iv: iv as BufferSource },\n            key,\n            ciphertext as BufferSource\n        )\n    } catch (err) {\n        // The wrapped key opened, so the keypair and `info` were right;\n        // the message body itself failed AES-GCM authentication.\n        throw new HpkeError(\n            'ERR_DECRYPT_FAILED',\n            'failed to decrypt the message: tampered ciphertext',\n            { cause: err }\n        )\n    }\n\n    return new Uint8Array(pt)\n}\n\n/**\n * Like `decrypt`, but UTF-8 decodes the plaintext to a string. Only use this\n * when the original message was text. Exposed as `decrypt.asString`.\n *\n * @param keypair The same recipient `CryptoKeyPair` used to `encrypt`.\n * @param message The envelope returned by `encrypt`.\n * @param opts `info` -- must match the value passed to `encrypt`.\n * @returns The decrypted plaintext as a string.\n */\nasync function decryptToString (\n    keypair:CryptoKeyPair,\n    message:Uint8Array,\n    opts?:{ info?:Uint8Array|string }\n):Promise<string> {\n    const bytes = await decryptBytes(keypair, message, opts)\n    return new TextDecoder().decode(bytes)\n}\n\n/**\n * Decode a `base64url` string envelope (from `encrypt.asString`),\n * recover the AES key, and AES-GCM decrypt the message. Exposed as\n * `decrypt.fromString`.\n *\n * @param keypair The same recipient `CryptoKeyPair` used to `encrypt`.\n * @param message The `base64url`-encoded envelope string, as returned\n *   by `encrypt.asString`.\n * @param opts `info` (must match `encrypt`), and `buffer` -- if true,\n *   return the raw plaintext `Uint8Array` instead of a UTF-8 decoded\n *   string.\n * @returns The decrypted plaintext, as a string (default) or\n *   `Uint8Array` (if `opts.buffer` is true).\n */\nasync function decryptFromString (\n    keypair:CryptoKeyPair,\n    message:string,\n    opts?:{ info?:Uint8Array|string, buffer?:false }\n):Promise<string>\n\nasync function decryptFromString (\n    keypair:CryptoKeyPair,\n    message:string,\n    opts:{ info?:Uint8Array|string, buffer:true }\n):Promise<Uint8Array>\n\nasync function decryptFromString (\n    keypair:CryptoKeyPair,\n    message:string,\n    opts?:{ info?:Uint8Array|string, buffer?:boolean }\n):Promise<string|Uint8Array> {\n    const bytes = fromString(message, 'base64url')\n    const plaintext = await decryptBytes(\n        keypair,\n        bytes,\n        opts?.info !== undefined ? { info: opts.info } : undefined\n    )\n\n    return opts?.buffer ? plaintext : new TextDecoder().decode(plaintext)\n}\n\nfunction validateKeysize (keysize:number):void {\n    if (keysize !== 128 && keysize !== 256) {\n        throw new HpkeError(\n            'ERR_INVALID_KEYSIZE',\n            `invalid keysize: ${keysize} (expected 128 or 256)`\n        )\n    }\n}\n\n// Raw AES key bytes must be a 128- or 256-bit key: this suite does not\n// support AES-192, so anything but 16 or 32 bytes is rejected (rather than\n// letting WebCrypto silently accept a 24-byte key later).\nfunction validateRawKeyBytes (raw:Uint8Array):void {\n    if (raw.length !== 16 && raw.length !== 32) {\n        throw new HpkeError(\n            'ERR_INVALID_AES_KEY',\n            `invalid aesKey length: ${raw.length} bytes ` +\n            '(expected 16 or 32)'\n        )\n    }\n}\n\nfunction normalizeInfo (info?:Uint8Array|string):Uint8Array {\n    if (info === undefined || info === null) return new Uint8Array(0)\n    if (typeof info === 'string') return new TextEncoder().encode(info)\n    return info\n}\n\nasync function exportAesKeyBytes (key:CryptoKey):Promise<Uint8Array> {\n    if (!key.extractable) {\n        throw new HpkeError(\n            'ERR_INVALID_AES_KEY',\n            'aesKey must be extractable: its raw bytes are what get sealed'\n        )\n    }\n    return new Uint8Array(await subtle.exportKey('raw', key))\n}\n\n// `extractable` defaults to false at every call site: a key that never\n// needs to leave the runtime should not be exportable, and `keyId` gives\n// callers a fingerprint without the bytes. Callers who really do need the\n// raw bytes opt in with `{ extractable: true }`.\nasync function importAesKey (\n    raw:Uint8Array,\n    extractable:boolean\n):Promise<CryptoKey> {\n    return subtle.importKey(\n        'raw',\n        raw as BufferSource,\n        { name: 'AES-GCM' },\n        extractable,\n        ['encrypt', 'decrypt']\n    )\n}\n\n// Used by `decryptBytes` instead of `importAesKey`: the message key never\n// leaves the library there, so it is imported decrypt-only rather than\n// with the both-usages key `open` returns for general use.\nasync function importAesKeyDecryptOnly (raw:Uint8Array):Promise<CryptoKey> {\n    return subtle.importKey(\n        'raw',\n        raw as BufferSource,\n        { name: 'AES-GCM' },\n        false,\n        ['decrypt']\n    )\n}\n\n// ----- Key schedule (base mode) -----\n\n// KeySchedule for base mode with empty psk / psk_id: derive the AEAD key and\n// base nonce from the KEM shared secret and `info`.\nasync function keySchedule (\n    sharedSecret:Uint8Array,\n    info:Uint8Array\n):Promise<{ key:Uint8Array; baseNonce:Uint8Array }> {\n    const empty = new Uint8Array(0)\n    const pskIdHash = await labeledExtract(\n        HPKE_SUITE_ID,\n        empty,\n        'psk_id_hash',\n        empty\n    )\n    const infoHash = await labeledExtract(\n        HPKE_SUITE_ID,\n        empty,\n        'info_hash',\n        info\n    )\n    const ksContext = concat(new Uint8Array([MODE_BASE]), pskIdHash, infoHash)\n\n    const secret = await labeledExtract(\n        HPKE_SUITE_ID,\n        sharedSecret,\n        'secret',\n        empty\n    )\n    const key = await labeledExpand(\n        HPKE_SUITE_ID,\n        secret,\n        'key',\n        ksContext,\n        NK\n    )\n    const baseNonce = await labeledExpand(\n        HPKE_SUITE_ID,\n        secret,\n        'base_nonce',\n        ksContext,\n        NN\n    )\n    return { key, baseNonce }\n}\n\n/**\n * Like `open`, but returns the recovered key as raw bytes instead of\n * importing it as an AES-GCM `CryptoKey`. Exposed as `open.raw`.\n *\n * @param keypair The same X25519 `CryptoKeyPair` used to create or encryptKey.\n * @param wrapped The `wrapped` bytes returned by `create` or `encryptKey`.\n * @param opts `info` -- must match the value passed to `create` or\n *   `encryptKey`.\n * @returns The recovered key bytes (16 or 32 bytes, matching whatever\n *   was wrapped).\n */\nasync function openRawBytes (\n    keypair:CryptoKeyPair,\n    wrapped:Uint8Array,\n    opts?:{ info?:Uint8Array|string }\n):Promise<Uint8Array> {\n    if (wrapped.byteLength < ENC_LENGTH + AEAD_TAG_LENGTH) {\n        throw new HpkeError(\n            'ERR_MALFORMED_ENVELOPE',\n            'malformed envelope: too short'\n        )\n    }\n\n    const info = normalizeInfo(opts?.info)\n    const enc = wrapped.slice(0, ENC_LENGTH)\n    const ciphertext = wrapped.slice(ENC_LENGTH)\n\n    const sharedSecret = await decap(enc, keypair)\n    const { key, baseNonce } = await keySchedule(sharedSecret, info)\n    return aeadOpen(key, baseNonce, ciphertext)\n}\n\n/**\n * Recover an AES key that was wrapped with `create` or `encryptKey`.\n *\n * @param keypair The same X25519 `CryptoKeyPair` used to create or encryptKey.\n * @param wrapped The `wrapped` bytes returned by `create` or `encryptKey`.\n * @param opts `info` -- must match the value passed to `create` or\n *   `encryptKey` -- and `extractable` (default false).\n * @returns The recovered AES-GCM `CryptoKey`, non-extractable unless\n *   `opts.extractable` is true.\n */\nasync function openBytes (\n    keypair:CryptoKeyPair,\n    wrapped:Uint8Array,\n    opts?:{ info?:Uint8Array|string; extractable?:boolean }\n):Promise<CryptoKey> {\n    const keyBytes = await openRawBytes(keypair, wrapped, opts)\n    return importAesKey(keyBytes, opts?.extractable ?? false)\n}\n\n/**\n * Wrap an AES key to a recipient's public key. `create(...)` calls this\n * helper with no `aesKey`, so it generates a fresh AES key first.\n *\n * @param recipient The recipient's X25519 public key, as a `CryptoKey`,\n *   `CryptoKeyPair` (its `.publicKey` is used), 32 raw bytes (`Uint8Array`),\n *   or `{ publicKey:string, encoding? }` (encoding defaults to `base64url`).\n * @param aesKey Optional key to wrap, as either an AES-GCM `CryptoKey` or its\n *   raw bytes (`Uint8Array`, 16 or 32 bytes). Omit to generate a fresh key\n *   of `opts.size` bits. A supplied `CryptoKey` MUST be extractable (its\n *   raw bytes are wrapped) -- that is an input constraint, unrelated to\n *   `opts.extractable`, which governs the key this returns.\n * @param opts `size` (128/256, default 256; ignored when `aesKey` is\n *   supplied), `info` (bound into the HPKE key schedule; default empty),\n *   and `extractable` (whether the RETURNED key can be exported; default\n *   false).\n * @returns { wrapped:Uint8Array, key:CryptoKey } The wrapped envelope\n *   bytes and a usable AES-GCM `CryptoKey`.\n */\nexport async function encryptKey (\n    recipient:RecipientKey,\n    aesKey?:CryptoKey|Uint8Array|null,\n    opts?:{\n        // Size of the GENERATED AES key. Ignored when an `aesKey` is supplied.\n        size?:128|256\n        // HPKE `info`: bound into the key schedule; must match on open.\n        info?:Uint8Array|string\n        // Whether the RETURNED AES key can be exported. Default false.\n        extractable?:boolean\n    }\n):Promise<{ wrapped:Uint8Array; key:CryptoKey }> {\n    const info = normalizeInfo(opts?.info)\n\n    let keyBytes:Uint8Array\n    if (aesKey instanceof Uint8Array) {\n        validateRawKeyBytes(aesKey)\n        keyBytes = aesKey\n    } else if (aesKey) {  // if given a CryptoKey\n        keyBytes = await exportAesKeyBytes(aesKey)\n        validateRawKeyBytes(keyBytes)\n    } else {  // generate a key\n        const keysize = opts?.size ?? 256\n        validateKeysize(keysize)\n        keyBytes = globalThis.crypto.getRandomValues(\n            new Uint8Array(keysize / 8)\n        )\n    }\n\n    const publicKey = await resolveRecipientPublicKey(recipient)\n    const { sharedSecret, enc } = await encap(publicKey)\n    const { key, baseNonce } = await keySchedule(sharedSecret, info)\n    const ciphertext = await aeadSeal(key, baseNonce, keyBytes)\n    const wrapped = concat(enc, ciphertext)\n    const aesGcmKey = await importAesKey(\n        keyBytes,\n        opts?.extractable ?? false\n    )\n\n    return { wrapped, key: aesGcmKey }\n}\n", "import {\n    toString,\n    fromString,\n    type SupportedEncodings\n} from 'uint8arrays'\nimport { encryptKey } from './index.js'\nimport { HpkeError, type HpkeErrorCode } from './errors.js'\nimport {\n    WRAPPED_LEN_PREFIX,\n    NN,\n    NSECRET,\n    HPKE_V1,\n    ENC_LENGTH,\n    KEM_SUITE_ID,\n    KEY_ID_LABEL,\n    KEY_ID_NONCE_LENGTH\n} from './constants.js'\nconst subtle = globalThis.crypto.subtle\n\n/**\n * A recipient's X25519 public key, in any of four forms:\n * - `CryptoKey`: an X25519 public key.\n * - `CryptoKeyPair`: its `.publicKey` is used (encryption never needs the\n *   private half).\n * - `Uint8Array`: 32 raw X25519 public-key bytes.\n * - `{ publicKey, encoding? }`: the public key as an encoded string;\n *   `encoding` defaults to `base64url`.\n */\nexport type RecipientKey =\n    | CryptoKey\n    | CryptoKeyPair\n    | Uint8Array\n    | { publicKey:string; encoding?:SupportedEncodings }\n\n/**\n * AEAD (AES-256-GCM), single-shot at sequence 0\n */\nexport async function aeadSeal (\n    key:Uint8Array,\n    nonce:Uint8Array,\n    plaintext:Uint8Array\n):Promise<Uint8Array> {\n    const k = await subtle.importKey(\n        'raw',\n        key as BufferSource,\n        { name: 'AES-GCM' },\n        false,\n        ['encrypt']\n    )\n    const ct = await subtle.encrypt(\n        { name: 'AES-GCM', iv: nonce as BufferSource },\n        k,\n        plaintext as BufferSource\n    )\n    return new Uint8Array(ct)\n}\n\nexport async function aeadOpen (\n    key:Uint8Array,\n    nonce:Uint8Array,\n    ciphertext:Uint8Array\n):Promise<Uint8Array> {\n    const k = await subtle.importKey(\n        'raw',\n        key as BufferSource,\n        { name: 'AES-GCM' },\n        false,\n        ['decrypt']\n    )\n    let pt:ArrayBuffer\n    try {\n        pt = await subtle.decrypt(\n            { name: 'AES-GCM', iv: nonce as BufferSource },\n            k,\n            ciphertext as BufferSource\n        )\n    } catch (err) {\n        // AES-GCM authentication failed. WebCrypto reports every cause\n        // as the same opaque `OperationError`, so this is deliberately\n        // the one error for all of them.\n        throw new HpkeError(\n            'ERR_DECRYPT_FAILED',\n            'failed to decrypt the wrapped key: wrong keypair, ' +\n            'wrong info, or a tampered envelope',\n            { cause: err }\n        )\n    }\n    return new Uint8Array(pt)\n}\n\n/**\n * Wrap a fresh (or supplied) AES key to `recipient`, then AES-GCM encrypt a\n * message under it. The wrapped key, IV, and ciphertext are concatenated\n * into a single self-describing envelope.\n *\n * Wire format: `wrappedLen(2, big-endian) \u2016 wrapped \u2016 iv(12) \u2016 ciphertext`.\n * The length prefix lets `decrypt` slice the segments apart for either\n * 128- or 256-bit wrapped keys.\n *\n * @param recipient The recipient's X25519 public key, as a `CryptoKey`,\n *   `CryptoKeyPair` (its `.publicKey` is used), 32 raw bytes (`Uint8Array`),\n *   or `{ publicKey:string, encoding? }` (encoding defaults to `base64url`).\n * @param message Plaintext to encrypt. A `string` is UTF-8 encoded.\n * @param aesKey Optional key, as either an AES-GCM `CryptoKey` or its raw\n *   bytes (`Uint8Array`, 16 or 32 bytes). Omit to generate a fresh key of\n *   `opts.size` bits. A supplied `CryptoKey` MUST be extractable. Each\n *   call picks a fresh random 96-bit IV for the message ciphertext, so\n *   reusing the same `aesKey` across many calls carries the standard\n *   birthday bound for random nonces (collision risk becomes\n *   non-negligible around 2^32 messages under one key, NIST SP 800-38D) --\n *   prefer a fresh key per call (the default) over reusing one at scale.\n * @param opts `size` (128/256, default 256; ignored when `aesKey` is\n *   supplied) and `info` (bound into the HPKE key schedule).\n * @returns The concatenated envelope bytes.\n *\n * `encrypt.asString(...)` returns the same envelope as an encoded string.\n */\nexport async function encryptBytes (\n    recipient:RecipientKey,\n    message:Uint8Array|string,\n    aesKey?:CryptoKey|Uint8Array|null,\n    opts?:{\n        size?:128|256\n        info?:Uint8Array|string\n    }\n):Promise<Uint8Array> {\n    const plaintext = typeof message === 'string' ?\n        new TextEncoder().encode(message) :\n        message\n\n    const { wrapped, key } = await encryptKey(recipient, aesKey, opts)\n\n    const iv = globalThis.crypto.getRandomValues(new Uint8Array(NN))\n    const ct = new Uint8Array(await subtle.encrypt(\n        { name: 'AES-GCM', iv: iv as BufferSource },\n        key,\n        plaintext as BufferSource\n    ))\n\n    return concat(\n        i2osp(wrapped.length, WRAPPED_LEN_PREFIX),\n        wrapped,\n        iv,\n        ct\n    )\n}\n\n/**\n * Like `encrypt`, but encodes the envelope bytes to a string -- handy for\n * transports that carry text (JSON, URLs, headers). Decode with\n * `fromString(...)` (or any matching decoder) and pass the bytes to\n * `decrypt` / `decrypt.asString`. Exposed as `encrypt.asString`.\n *\n * @param recipient The recipient's X25519 public key, as a `CryptoKey`,\n *   `CryptoKeyPair` (its `.publicKey` is used), 32 raw bytes (`Uint8Array`),\n *   or `{ publicKey:string, encoding? }` (encoding defaults to `base64url`).\n * @param message Plaintext to encrypt. A `string` is UTF-8 encoded.\n * @param aesKey Optional key, as either an AES-GCM `CryptoKey` or its raw\n *   bytes (`Uint8Array`, 16 or 32 bytes). Omit to generate a fresh key of\n *   `opts.size` bits. A supplied `CryptoKey` MUST be extractable. Each\n *   call picks a fresh random 96-bit IV for the message ciphertext, so\n *   reusing the same `aesKey` across many calls carries the standard\n *   birthday bound for random nonces (collision risk becomes\n *   non-negligible around 2^32 messages under one key, NIST SP 800-38D) --\n *   prefer a fresh key per call (the default) over reusing one at scale.\n * @param opts `size` (128/256, default 256; ignored when `aesKey` is\n *   supplied), `info` (bound into the HPKE key schedule), and `encoding`\n *   (the string encoding of the returned envelope; default `base64url`).\n * @returns The encoded envelope string.\n */\nexport async function encryptToString (\n    recipient:RecipientKey,\n    message:Uint8Array|string,\n    aesKey?:CryptoKey|Uint8Array|null,\n    opts?:{\n        size?:128|256\n        info?:Uint8Array|string\n        encoding?:SupportedEncodings\n    }\n):Promise<string> {\n    const envelope = await encryptBytes(recipient, message, aesKey, opts)\n    return toString(envelope, opts?.encoding ?? 'base64url')\n}\n\n// ----- HKDF via HMAC-SHA256 (imperative shell) -----\n//\n// WebCrypto's native HKDF fuses extract+expand and cannot take a supplied\n// PRK, so RFC 9180's LabeledExtract / LabeledExpand are built directly on\n// HMAC-SHA256.\n\nexport async function hmac (key:Uint8Array, data:Uint8Array):Promise<Uint8Array> {\n    const k = await subtle.importKey(\n        'raw',\n        key as BufferSource,\n        { name: 'HMAC', hash: 'SHA-256' },\n        false,\n        ['sign']\n    )\n    return new Uint8Array(await subtle.sign('HMAC', k, data as BufferSource))\n}\n\n// HKDF-Extract(salt, ikm) = HMAC(salt, ikm). Empty salt becomes 32 zero\n// bytes (RFC 5869: salt defaults to HashLen zeros).\nasync function extract (\n    salt:Uint8Array,\n    ikm:Uint8Array\n):Promise<Uint8Array> {\n    const key = salt.length === 0 ? new Uint8Array(NSECRET) : salt\n    return hmac(key, ikm)\n}\n\n// HKDF-Expand(prk, info, L).\nasync function expand (\n    prk:Uint8Array,\n    info:Uint8Array,\n    length:number\n):Promise<Uint8Array> {\n    const out = new Uint8Array(length)\n    let t:Uint8Array = new Uint8Array(0)\n    let offset = 0\n    let counter = 1\n    while (offset < length) {\n        t = await hmac(prk, concat(t, info, i2osp(counter, 1)))\n        const take = Math.min(t.length, length - offset)\n        out.set(t.subarray(0, take), offset)\n        offset += take\n        counter++\n    }\n    return out\n}\n\n// LabeledExtract(salt, label, ikm) with a given suite_id.\nexport async function labeledExtract (\n    suiteId:Uint8Array,\n    salt:Uint8Array,\n    label:string,\n    ikm:Uint8Array\n):Promise<Uint8Array> {\n    const labeledIkm = concat(\n        HPKE_V1,\n        suiteId,\n        new TextEncoder().encode(label),\n        ikm\n    )\n    return extract(salt, labeledIkm)\n}\n\n// LabeledExpand(prk, label, info, L) with a given suite_id.\nexport async function labeledExpand (\n    suiteId:Uint8Array,\n    prk:Uint8Array,\n    label:string,\n    info:Uint8Array,\n    length:number\n):Promise<Uint8Array> {\n    const labeledInfo = concat(\n        i2osp(length, 2),\n        HPKE_V1,\n        suiteId,\n        new TextEncoder().encode(label),\n        info\n    )\n    return expand(prk, labeledInfo, length)\n}\n\n// ----- DHKEM(X25519, HKDF-SHA256) -----\n\nasync function exportRawPublic (key:CryptoKey):Promise<Uint8Array> {\n    return new Uint8Array(await subtle.exportKey('raw', key))\n}\n\n// Import 32 raw bytes as an X25519 public key. Imported extractable: the KEM\n// re-exports the recipient public key for its context, and a public key holds\n// no secret.\nasync function importRawPublic (raw:Uint8Array):Promise<CryptoKey> {\n    if (raw.length !== ENC_LENGTH) {\n        throw new HpkeError(\n            'ERR_INVALID_RECIPIENT_KEY',\n            `invalid public key length: ${raw.length} bytes ` +\n            `(expected ${ENC_LENGTH})`\n        )\n    }\n    return subtle.importKey(\n        'raw',\n        raw as BufferSource,\n        { name: 'X25519' },\n        true,\n        []\n    )\n}\n\n// Resolve any accepted recipient form to an X25519 public `CryptoKey`.\n// Encryption only ever needs the recipient's public key, so a supplied\n// `CryptoKeyPair` contributes only its `.publicKey`.\nexport async function resolveRecipientPublicKey (\n    recipient:RecipientKey\n):Promise<CryptoKey> {\n    // Raw 32-byte X25519 public key.\n    if (recipient instanceof Uint8Array) {\n        return importRawPublic(recipient)\n    }\n\n    // A single public CryptoKey.\n    if (recipient instanceof CryptoKey) {\n        if (recipient.type !== 'public') {\n            throw new HpkeError(\n                'ERR_INVALID_RECIPIENT_KEY',\n                'recipient CryptoKey must be a public key'\n            )\n        }\n        assertX25519Algorithm(\n            recipient,\n            'recipient CryptoKey',\n            'ERR_INVALID_RECIPIENT_KEY'\n        )\n        return recipient\n    }\n\n    // String form: { publicKey, encoding? }, encoding defaults to base64url.\n    if (typeof (recipient as { publicKey?:unknown }).publicKey === 'string') {\n        const { publicKey, encoding } =\n            recipient as { publicKey:string; encoding?:SupportedEncodings }\n        return importRawPublic(fromString(publicKey, encoding ?? 'base64url'))\n    }\n\n    // CryptoKeyPair: use its public half.\n    const pair = recipient as CryptoKeyPair\n    if (pair.publicKey instanceof CryptoKey) {\n        if (pair.publicKey.type !== 'public') {\n            throw new HpkeError(\n                'ERR_INVALID_RECIPIENT_KEY',\n                'recipient keypair publicKey must be a public key'\n            )\n        }\n        assertX25519Algorithm(\n            pair.publicKey,\n            'recipient keypair publicKey',\n            'ERR_INVALID_RECIPIENT_KEY'\n        )\n        return pair.publicKey\n    }\n\n    throw new HpkeError(\n        'ERR_INVALID_RECIPIENT_KEY',\n        'unrecognized recipient key form'\n    )\n}\n\n// Guards against an easy mistake (e.g. passing an Ed25519 signing key from\n// a library that exposes both): fail with a clear message here rather than\n// an opaque WebCrypto error later inside deriveBits.\nfunction assertX25519Algorithm (\n    key:CryptoKey,\n    context:string,\n    code:HpkeErrorCode\n):void {\n    if (key.algorithm.name !== 'X25519') {\n        throw new HpkeError(\n            code,\n            `${context} must be an X25519 key (got ${key.algorithm.name})`\n        )\n    }\n}\n\n// X25519 Diffie-Hellman via WebCrypto deriveBits (works with a\n// non-extractable private key).\nasync function dh (\n    priv:CryptoKey,\n    pub:CryptoKey\n):Promise<Uint8Array> {\n    const bits = await subtle.deriveBits(\n        { name: 'X25519', public: pub },\n        priv,\n        256\n    )\n    const bytes = new Uint8Array(bits)\n\n    // The Secure Curves spec requires deriveBits to throw on an all-zero\n    // output (a small-order public key); conforming runtimes never reach\n    // here. Kept as defense-in-depth against a nonconforming runtime.\n    if (bytes.every(b => b === 0)) {\n        throw new HpkeError(\n            'ERR_SMALL_ORDER_KEY',\n            'X25519 shared secret is all-zero (small-order public key?)'\n        )\n    }\n\n    return bytes\n}\n\n// DHKEM ExtractAndExpand: derive the KEM shared secret from the DH output\n// and the KEM context (enc || pkRm).\nasync function extractAndExpand (\n    dhBytes:Uint8Array,\n    kemContext:Uint8Array\n):Promise<Uint8Array> {\n    const eaePrk = await labeledExtract(\n        KEM_SUITE_ID,\n        new Uint8Array(0),\n        'eae_prk',\n        dhBytes\n    )\n    return labeledExpand(\n        KEM_SUITE_ID,\n        eaePrk,\n        'shared_secret',\n        kemContext,\n        NSECRET\n    )\n}\n\n// Encap(pkR): generate an ephemeral keypair, run DH, and derive the shared\n// secret. Returns the shared secret and the encapsulated public key (enc).\nexport async function encap (\n    pkR:CryptoKey\n):Promise<{ sharedSecret:Uint8Array; enc:Uint8Array }> {\n    const eph = await subtle.generateKey(\n        { name: 'X25519' },\n        false,\n        ['deriveBits']\n    ) as CryptoKeyPair\n\n    const dhBytes = await dh(eph.privateKey, pkR)\n    const enc = await exportRawPublic(eph.publicKey)\n    const pkRm = await exportRawPublic(pkR)\n    const kemContext = concat(enc, pkRm)\n    const sharedSecret = await extractAndExpand(dhBytes, kemContext)\n    return { sharedSecret, enc }\n}\n\n// Decap(enc, skR): recover the shared secret from an encapsulated public\n// key and the recipient keypair.\nexport async function decap (\n    enc:Uint8Array,\n    keypair:CryptoKeyPair\n):Promise<Uint8Array> {\n    if (keypair.privateKey.type !== 'private') {\n        throw new HpkeError(\n            'ERR_INVALID_KEYPAIR',\n            'keypair.privateKey must be a private key'\n        )\n    }\n    assertX25519Algorithm(\n        keypair.privateKey,\n        'keypair.privateKey',\n        'ERR_INVALID_KEYPAIR'\n    )\n\n    const pkE = await subtle.importKey(\n        'raw',\n        enc as BufferSource,\n        { name: 'X25519' },\n        false,\n        []\n    )\n    const dhBytes = await dh(keypair.privateKey, pkE)\n    const pkRm = await exportRawPublic(keypair.publicKey)\n    const kemContext = concat(enc, pkRm)\n    return extractAndExpand(dhBytes, kemContext)\n}\n\n// ----- keyId -----\n\n/**\n * A stable fingerprint for an AES-GCM key: the same key bytes always give\n * the same string, and two different keys effectively never collide.\n *\n * Derived from the key's *behavior* rather than its bytes, so it works on\n * a non-extractable key -- including one rehydrated from IndexedDB, and\n * the keys `create` / `encryptKey` / `open` return by default. The obvious\n * implementation, `exportKey('raw')` then SHA-256, would force every such\n * key to be extractable. HKDF is not an option either: WebCrypto cannot\n * convert an AES-GCM key into an HKDF key, and `deriveBits` only accepts a\n * key imported under HKDF, which needs the raw bytes a non-extractable key\n * withholds. AES-GCM as a PRF is the only primitive such a key still\n * exposes.\n *\n * The derivation is fixed forever (see `src/constants.ts`):\n *\n * ```\n * LABEL = utf8(\"simple-hpke/keyId/v1\")\n * N     = SHA-256(LABEL)[0..12]        // fixed nonce\n * C     = AES-GCM(key, N, LABEL)       // ciphertext || 16-byte tag\n * keyId = base64url(SHA-256(LABEL || C))\n * ```\n *\n * @param key An AES-GCM `CryptoKey` with the `encrypt` usage. It does not\n *   need to be extractable.\n * @returns The fingerprint: the full 32-byte digest, base64url, unpadded\n *   (43 characters).\n * @throws {HpkeError} `ERR_INVALID_AES_KEY` if `key` is not an AES-GCM key\n *   or cannot encrypt.\n */\nexport async function keyId (key:CryptoKey):Promise<string> {\n    if (key.algorithm.name !== 'AES-GCM') {\n        throw new HpkeError(\n            'ERR_INVALID_AES_KEY',\n            'keyId needs an AES-GCM key ' +\n            `(got ${key.algorithm.name})`\n        )\n    }\n\n    if (!key.usages.includes('encrypt')) {\n        throw new HpkeError(\n            'ERR_INVALID_AES_KEY',\n            \"keyId needs a key with the 'encrypt' usage\"\n        )\n    }\n\n    const labelHash = new Uint8Array(\n        await subtle.digest('SHA-256', KEY_ID_LABEL as BufferSource)\n    )\n    const nonce = labelHash.slice(0, KEY_ID_NONCE_LENGTH)\n\n    // No AAD. AAD feeds GHASH only and leaves the counter stream\n    // untouched, so \"domain separation by AAD\" would produce a second\n    // (A, C) pair over an identical keystream under the same (K, N).\n    // That is nonce reuse with extra steps.\n    const ciphertext = new Uint8Array(await subtle.encrypt(\n        { name: 'AES-GCM', iv: nonce as BufferSource },\n        key,\n        KEY_ID_LABEL as BufferSource\n    ))\n\n    // Only the digest is returned. `ciphertext` is a known-plaintext\n    // block of keystream and must never escape.\n    const digest = await subtle.digest(\n        'SHA-256',\n        concat(KEY_ID_LABEL, ciphertext) as BufferSource\n    )\n\n    return toString(new Uint8Array(digest), 'base64url')\n}\n\n// ----- Pure byte helpers  -----\n\n// I2OSP(n, len): big-endian encode a non-negative integer into `len` bytes.\nexport function i2osp (n:number, len:number):Uint8Array {\n    const out = new Uint8Array(len)\n    let v = n\n    for (let i = len - 1; i >= 0; i--) {\n        out[i] = v & 0xff\n        v = Math.floor(v / 256)\n    }\n    return out\n}\n\nexport function concat (...arrays:Uint8Array[]):Uint8Array {\n    let total = 0\n    for (const a of arrays) total += a.length\n    const out = new Uint8Array(total)\n    let offset = 0\n    for (const a of arrays) {\n        out.set(a, offset)\n        offset += a.length\n    }\n    return out\n}\n"],
  "mappings": "qeAAA,IAAAA,GAAA,GAAAC,EAAAD,GAAA,aAAAE,GAAA,oBAAAC,GAAA,eAAAC,EAAA,kBAAAC,EAAA,YAAAC,GAAA,WAAAC,GAAA,WAAAC,GAAA,iBAAAC,GAAA,iBAAAC,GAAA,wBAAAC,GAAA,cAAAC,GAAA,OAAAC,GAAA,OAAAC,EAAA,YAAAC,GAAA,uBAAAC,IAAA,eAAAC,GAAAjB,ICaM,SAAUkB,GAAaC,EAAe,EAAC,CAC3C,OAAO,IAAI,WAAWA,CAAI,CAC5B,CAFgBC,EAAAF,GAAA,eCbhB,IAAAG,GAAA,GAAAC,EAAAD,GAAA,YAAAE,KCAO,IAAMC,GAAQ,IAAI,WAAW,CAAC,EAW/B,SAAUC,GAAQC,EAAgBC,EAAc,CACpD,GAAID,IAAOC,EAAM,MAAO,GACxB,GAAID,EAAG,aAAeC,EAAG,WACvB,MAAO,GAGT,QAASC,EAAK,EAAGA,EAAKF,EAAG,WAAYE,IACnC,GAAIF,EAAGE,CAAE,IAAMD,EAAGC,CAAE,EAClB,MAAO,GAIX,MAAO,EACT,CAbgBC,EAAAJ,GAAA,UAeV,SAAUK,EAAQC,EAA6C,CACnE,GAAIA,aAAa,YAAcA,EAAE,YAAY,OAAS,aAAgB,OAAOA,EAC7E,GAAIA,aAAa,YAAe,OAAO,IAAI,WAAWA,CAAC,EACvD,GAAI,YAAY,OAAOA,CAAC,EACtB,OAAO,IAAI,WAAWA,EAAE,OAAQA,EAAE,WAAYA,EAAE,UAAU,EAE5D,MAAM,IAAI,MAAM,mCAAmC,CACrD,CAPgBF,EAAAC,EAAA,UAaV,SAAUE,GAAYC,EAAW,CACrC,OAAO,IAAI,YAAW,EAAG,OAAOA,CAAG,CACrC,CAFgBC,EAAAF,GAAA,cAIV,SAAUG,GAAUC,EAAa,CACrC,OAAO,IAAI,YAAW,EAAG,OAAOA,CAAC,CACnC,CAFgBF,EAAAC,GAAA,YCjChB,SAASE,GAAMC,EAAUC,EAAI,CAC3B,GAAID,EAAS,QAAU,IAAO,MAAM,IAAI,UAAU,mBAAmB,EAErE,QADIE,EAAW,IAAI,WAAW,GAAG,EACxBC,EAAI,EAAGA,EAAID,EAAS,OAAQC,IACnCD,EAASC,CAAC,EAAI,IAEhB,QAASC,EAAI,EAAGA,EAAIJ,EAAS,OAAQI,IAAK,CACxC,IAAIC,EAAIL,EAAS,OAAOI,CAAC,EACrBE,EAAKD,EAAE,WAAW,CAAC,EACvB,GAAIH,EAASI,CAAE,IAAM,IAAO,MAAM,IAAI,UAAUD,EAAI,eAAe,EACnEH,EAASI,CAAE,EAAIF,CACjB,CACA,IAAIG,EAAOP,EAAS,OAChBQ,EAASR,EAAS,OAAO,CAAC,EAC1BS,EAAS,KAAK,IAAIF,CAAI,EAAI,KAAK,IAAI,GAAG,EACtCG,EAAU,KAAK,IAAI,GAAG,EAAI,KAAK,IAAIH,CAAI,EAI3C,SAASI,EAAQC,EAAM,CAOrB,GALIA,aAAkB,aAAuB,YAAY,OAAOA,CAAM,EACpEA,EAAS,IAAI,WAAWA,EAAO,OAAQA,EAAO,WAAYA,EAAO,UAAU,EAClE,MAAM,QAAQA,CAAM,IAC7BA,EAAS,WAAW,KAAKA,CAAM,IAE7B,EAAEA,aAAkB,YAAe,MAAM,IAAI,UAAU,qBAAqB,EAChF,GAAIA,EAAO,SAAW,EAAK,MAAO,GAMlC,QAJIC,EAAS,EACTC,EAAS,EACTC,EAAS,EACTC,EAAOJ,EAAO,OACXG,IAAWC,GAAQJ,EAAOG,CAAM,IAAM,GAC3CA,IACAF,IAMF,QAHII,GAASD,EAAOD,GAAUL,EAAU,IAAO,EAC3CQ,EAAM,IAAI,WAAWD,CAAI,EAEtBF,IAAWC,GAAM,CAItB,QAHIG,EAAQP,EAAOG,CAAM,EAErBX,EAAI,EACCgB,EAAMH,EAAO,GAAIE,IAAU,GAAKf,EAAIU,IAAYM,IAAQ,GAAKA,IAAOhB,IAC3Ee,GAAU,IAAMD,EAAIE,CAAG,IAAO,EAC9BF,EAAIE,CAAG,EAAKD,EAAQZ,IAAU,EAC9BY,EAASA,EAAQZ,IAAU,EAE7B,GAAIY,IAAU,EAAK,MAAM,IAAI,MAAM,gBAAgB,EACnDL,EAASV,EACTW,GACF,CAGA,QADIM,EAAMJ,EAAOH,EACVO,IAAQJ,GAAQC,EAAIG,CAAG,IAAM,GAClCA,IAIF,QADIC,EAAMd,EAAO,OAAOK,CAAM,EACvBQ,EAAMJ,EAAM,EAAEI,EAAOC,GAAOtB,EAAS,OAAOkB,EAAIG,CAAG,CAAC,EAC3D,OAAOC,CACT,CA5CSC,EAAAZ,EAAA,UAgDT,SAASa,EAAcZ,EAAM,CAC3B,GAAI,OAAOA,GAAW,SAAY,MAAM,IAAI,UAAU,iBAAiB,EACvE,GAAIA,EAAO,SAAW,EAAK,OAAO,IAAI,WACtC,IAAIa,EAAM,EAEV,GAAIb,EAAOa,CAAG,IAAM,IAIpB,SAFIZ,EAAS,EACTC,EAAS,EACNF,EAAOa,CAAG,IAAMjB,GACrBK,IACAY,IAMF,QAHIR,GAAUL,EAAO,OAASa,GAAOhB,EAAU,IAAO,EAClDiB,EAAO,IAAI,WAAWT,CAAI,EAEvBL,EAAOa,CAAG,GAAG,CAElB,IAAIN,EAAQjB,EAASU,EAAO,WAAWa,CAAG,CAAC,EAE3C,GAAIN,IAAU,IAAO,OAErB,QADIf,EAAI,EACCuB,EAAMV,EAAO,GAAIE,IAAU,GAAKf,EAAIU,IAAYa,IAAQ,GAAKA,IAAOvB,IAC3Ee,GAAUZ,EAAOmB,EAAKC,CAAG,IAAO,EAChCD,EAAKC,CAAG,EAAKR,EAAQ,MAAS,EAC9BA,EAASA,EAAQ,MAAS,EAE5B,GAAIA,IAAU,EAAK,MAAM,IAAI,MAAM,gBAAgB,EACnDL,EAASV,EACTqB,GACF,CAEA,GAAIb,EAAOa,CAAG,IAAM,IAGpB,SADIG,EAAMX,EAAOH,EACVc,IAAQX,GAAQS,EAAKE,CAAG,IAAM,GACnCA,IAIF,QAFIC,EAAM,IAAI,WAAWhB,GAAUI,EAAOW,EAAI,EAC1CzB,EAAIU,EACDe,IAAQX,GACbY,EAAI1B,GAAG,EAAIuB,EAAKE,GAAK,EAEvB,OAAOC,GACT,CA7CSN,EAAAC,EAAA,gBAiDT,SAASM,EAAQC,EAAM,CACrB,IAAIC,EAASR,EAAaO,CAAM,EAChC,GAAIC,EAAU,OAAOA,EACrB,MAAM,IAAI,MAAM,OAAO/B,CAAI,YAAY,CACzC,CAJS,OAAAsB,EAAAO,EAAA,UAKF,CACL,OAAQnB,EACR,aAAca,EACd,OAAQM,EAEZ,CA9HSP,EAAAxB,GAAA,QA+HT,IAAIkC,GAAMlC,GAENmC,GAAkCD,GAEtCE,GAAeD,GCjIf,IAAME,GAAN,KAAa,CAZb,MAYa,CAAAC,EAAA,gBACF,KACA,OACA,WAET,YAAaC,EAAYC,EAAgBC,EAAoB,CAC3D,KAAK,KAAOF,EACZ,KAAK,OAASC,EACd,KAAK,WAAaC,CACpB,CAEA,OAAQC,EAAiB,CACvB,GAAIA,aAAiB,WACnB,MAAO,GAAG,KAAK,MAAM,GAAG,KAAK,WAAWA,CAAK,CAAC,GAE9C,MAAM,MAAM,mCAAmC,CAEnD,GAQIC,GAAN,KAAa,CArCb,MAqCa,CAAAL,EAAA,gBACF,KACA,OACA,WACQ,gBAEjB,YAAaC,EAAYC,EAAgBI,EAAoB,CAC3D,KAAK,KAAOL,EACZ,KAAK,OAASC,EACd,IAAMK,EAAkBL,EAAO,YAAY,CAAC,EAE5C,GAAIK,IAAoB,OACtB,MAAM,IAAI,MAAM,0BAA0B,EAE5C,KAAK,gBAAkBA,EACvB,KAAK,WAAaD,CACpB,CAEA,OAAQE,EAAY,CAClB,GAAI,OAAOA,GAAS,SAAU,CAC5B,GAAIA,EAAK,YAAY,CAAC,IAAM,KAAK,gBAC/B,MAAM,MAAM,qCAAqC,KAAK,UAAUA,CAAI,CAAC,KAAK,KAAK,IAAI,+CAA+C,KAAK,MAAM,EAAE,EAEjJ,OAAO,KAAK,WAAWA,EAAK,MAAM,KAAK,OAAO,MAAM,CAAC,CACvD,KACE,OAAM,MAAM,mCAAmC,CAEnD,CAEA,GAAgCC,EAAmE,CACjG,OAAOC,GAAG,KAAMD,CAAO,CACzB,GAKIE,GAAN,KAAqB,CAzErB,MAyEqB,CAAAX,EAAA,wBACV,SAET,YAAaY,EAA0B,CACrC,KAAK,SAAWA,CAClB,CAEA,GAAiCH,EAAmE,CAClG,OAAOC,GAAG,KAAMD,CAAO,CACzB,CAEA,OAAQI,EAAa,CACnB,IAAMX,EAASW,EAAM,CAAC,EAChBJ,EAAU,KAAK,SAASP,CAAM,EACpC,GAAIO,GAAW,KACb,OAAOA,EAAQ,OAAOI,CAAK,EAE3B,MAAM,WAAW,qCAAqC,KAAK,UAAUA,CAAK,CAAC,+BAA+B,OAAO,KAAK,KAAK,QAAQ,CAAC,gBAAgB,CAExJ,GAGI,SAAUH,GAAyCI,EAA+CC,EAA8C,CACpJ,OAAO,IAAIJ,GAAgB,CACzB,GAAIG,EAAK,UAAY,CAAE,CAAEA,EAA2B,MAAM,EAAGA,CAAI,EACjE,GAAIC,EAAM,UAAY,CAAE,CAAEA,EAA4B,MAAM,EAAGA,CAAK,EAClD,CACtB,CALgBf,EAAAU,GAAA,MAOV,IAAOM,GAAP,KAAY,CAtGlB,MAsGkB,CAAAhB,EAAA,cACP,KACA,OACA,WACA,WACA,QACA,QAET,YAAaC,EAAYC,EAAgBC,EAAsBG,EAAoB,CACjF,KAAK,KAAOL,EACZ,KAAK,OAASC,EACd,KAAK,WAAaC,EAClB,KAAK,WAAaG,EAClB,KAAK,QAAU,IAAIP,GAAQE,EAAMC,EAAQC,CAAU,EACnD,KAAK,QAAU,IAAIE,GAAQJ,EAAMC,EAAQI,CAAU,CACrD,CAEA,OAAQO,EAAiB,CACvB,OAAO,KAAK,QAAQ,OAAOA,CAAK,CAClC,CAEA,OAAQA,EAAa,CACnB,OAAO,KAAK,QAAQ,OAAOA,CAAK,CAClC,GAGI,SAAUI,EAAmD,CAAE,KAAAhB,EAAM,OAAAC,EAAQ,OAAAgB,EAAQ,OAAAC,CAAM,EAAsE,CACrK,OAAO,IAAIH,GAAMf,EAAMC,EAAQgB,EAAQC,CAAM,CAC/C,CAFgBnB,EAAAiB,EAAA,QAIV,SAAUG,EAAoD,CAAE,KAAAnB,EAAM,OAAAC,EAAQ,SAAAmB,CAAQ,EAAoD,CAC9I,GAAM,CAAE,OAAAH,EAAQ,OAAAC,CAAM,EAAKG,GAAMD,EAAUpB,CAAI,EAC/C,OAAOgB,EAAK,CACV,OAAAf,EACA,KAAAD,EACA,OAAAiB,EACA,OAAQlB,EAACQ,GAA6Be,EAAOJ,EAAOX,CAAI,CAAC,EAAjD,UACT,CACH,CARgBR,EAAAoB,EAAA,SAUhB,SAASD,GAAQK,EAAgBC,EAAqCC,EAAqBzB,EAAY,CAErG,IAAI0B,EAAMH,EAAO,OACjB,KAAOA,EAAOG,EAAM,CAAC,IAAM,KACzB,EAAEA,EAIJ,IAAMC,EAAM,IAAI,WAAYD,EAAMD,EAAc,EAAK,CAAC,EAGlDG,EAAO,EACPC,EAAS,EACTC,EAAU,EACd,QAASC,EAAI,EAAGA,EAAIL,EAAK,EAAEK,EAAG,CAE5B,IAAMC,EAAQR,EAAYD,EAAOQ,CAAC,CAAC,EACnC,GAAIC,IAAU,OACZ,MAAM,IAAI,YAAY,OAAOhC,CAAI,YAAY,EAI/C6B,EAAUA,GAAUJ,EAAeO,EACnCJ,GAAQH,EAGJG,GAAQ,IACVA,GAAQ,EACRD,EAAIG,GAAS,EAAI,IAAQD,GAAUD,EAEvC,CAGA,GAAIA,GAAQH,IAAgB,IAAQI,GAAW,EAAID,KAAY,EAC7D,MAAM,IAAI,YAAY,wBAAwB,EAGhD,OAAOD,CACT,CAtCS5B,EAAAmB,GAAA,UAwCT,SAASD,GAAQgB,EAAkBb,EAAkBK,EAAmB,CACtE,IAAMS,EAAMd,EAASA,EAAS,OAAS,CAAC,IAAM,IACxCe,GAAQ,GAAKV,GAAe,EAC9BE,EAAM,GAENC,EAAO,EACPC,EAAS,EACb,QAASE,EAAI,EAAGA,EAAIE,EAAK,OAAQ,EAAEF,EAMjC,IAJAF,EAAUA,GAAU,EAAKI,EAAKF,CAAC,EAC/BH,GAAQ,EAGDA,EAAOH,GACZG,GAAQH,EACRE,GAAOP,EAASe,EAAQN,GAAUD,CAAK,EAU3C,GALIA,IAAS,IACXD,GAAOP,EAASe,EAAQN,GAAWJ,EAAcG,CAAM,GAIrDM,EACF,MAASP,EAAI,OAASF,EAAe,KAAO,GAC1CE,GAAO,IAIX,OAAOA,CACT,CAhCS5B,EAAAkB,GAAA,UAkCT,SAASmB,GAAmBhB,EAAgB,CAE1C,IAAMI,EAAsC,CAAA,EAC5C,QAASO,EAAI,EAAGA,EAAIX,EAAS,OAAQ,EAAEW,EACrCP,EAAYJ,EAASW,CAAC,CAAC,EAAIA,EAE7B,OAAOP,CACT,CAPSzB,EAAAqC,GAAA,qBAYH,SAAUC,EAAsD,CAAE,KAAArC,EAAM,OAAAC,EAAQ,YAAAwB,EAAa,SAAAL,CAAQ,EAAyE,CAClL,IAAMI,EAAcY,GAAkBhB,CAAQ,EAC9C,OAAOJ,EAAK,CACV,OAAAf,EACA,KAAAD,EACA,OAAQY,EAAiB,CACvB,OAAOK,GAAOL,EAAOQ,EAAUK,CAAW,CAC5C,EACA,OAAQb,EAAa,CACnB,OAAOM,GAAON,EAAOY,EAAaC,EAAazB,CAAI,CACrD,EACD,CACH,CAZgBD,EAAAsC,EAAA,WHlOT,IAAMC,GAASC,EAAM,CAC1B,OAAQ,IACR,KAAM,SACN,SAAU,aACX,EIND,IAAAC,GAAA,GAAAC,EAAAD,GAAA,YAAAE,GAAA,gBAAAC,KAEO,IAAMC,GAASC,EAAQ,CAC5B,OAAQ,IACR,KAAM,SACN,SAAU,mBACV,YAAa,EACd,EAEYC,GAAcD,EAAQ,CACjC,OAAQ,IACR,KAAM,cACN,SAAU,mBACV,YAAa,EACd,ECdD,IAAAE,GAAA,GAAAC,EAAAD,GAAA,WAAAE,KAEO,IAAMC,GAAQC,EAAQ,CAC3B,OAAQ,IACR,KAAM,QACN,SAAU,KACV,YAAa,EACd,ECPD,IAAAC,GAAA,GAAAC,EAAAD,GAAA,kBAAAE,KAEA,IAAMC,GAAW,MAAM,KAAK,orEAAwe,EAC9fC,GAAkCD,GAAS,OAAiB,CAACE,EAAGC,EAAGC,KAAQF,EAAEE,CAAC,EAAID,EAAUD,GAAM,CAAA,CAAG,EACrGG,GAAkCL,GAAS,OAAiB,CAACE,EAAGC,EAAGC,IAAK,CAC5E,IAAME,EAAYH,EAAE,YAAY,CAAC,EACjC,GAAIG,GAAa,KACf,MAAM,IAAI,MAAM,sBAAsBH,CAAC,EAAE,EAE3C,OAAAD,EAAEI,CAAS,EAAIF,EACRF,CACT,EAAI,CAAA,CAAG,EAEP,SAASK,GAAQC,EAAgB,CAC/B,OAAOA,EAAK,OAAO,CAACN,EAAGC,KACrBD,GAAKD,GAAqBE,CAAC,EACpBD,GACN,EAAE,CACP,CALSO,EAAAF,GAAA,UAOT,SAASG,GAAQC,EAAW,CAC1B,IAAMC,EAAO,CAAA,EACb,QAAWC,KAAQF,EAAK,CACtB,IAAML,EAAYO,EAAK,YAAY,CAAC,EACpC,GAAIP,GAAa,KACf,MAAM,IAAI,MAAM,sBAAsBO,CAAI,EAAE,EAE9C,IAAMC,EAAMT,GAAqBC,CAAS,EAC1C,GAAIQ,GAAO,KACT,MAAM,IAAI,MAAM,+BAA+BD,CAAI,EAAE,EAEvDD,EAAK,KAAKE,CAAG,CACf,CACA,OAAO,IAAI,WAAWF,CAAI,CAC5B,CAdSH,EAAAC,GAAA,UAgBF,IAAMK,GAAeC,EAAK,CAC/B,OAAQ,YACR,KAAM,eACN,OAAAT,GACA,OAAAG,GACD,ECzCD,IAAAO,GAAA,GAAAC,EAAAD,GAAA,YAAAE,EAAA,cAAAC,GAAA,iBAAAC,GAAA,sBAAAC,GAAA,mBAAAC,GAAA,cAAAC,GAAA,mBAAAC,GAAA,gBAAAC,GAAA,YAAAC,KAEO,IAAMC,EAASC,EAAQ,CAC5B,OAAQ,IACR,KAAM,SACN,SAAU,mCACV,YAAa,EACd,EAEYC,GAAcD,EAAQ,CACjC,OAAQ,IACR,KAAM,cACN,SAAU,mCACV,YAAa,EACd,EAEYE,GAAYF,EAAQ,CAC/B,OAAQ,IACR,KAAM,YACN,SAAU,oCACV,YAAa,EACd,EAEYG,GAAiBH,EAAQ,CACpC,OAAQ,IACR,KAAM,iBACN,SAAU,oCACV,YAAa,EACd,EAEYI,GAAYJ,EAAQ,CAC/B,OAAQ,IACR,KAAM,YACN,SAAU,mCACV,YAAa,EACd,EAEYK,GAAiBL,EAAQ,CACpC,OAAQ,IACR,KAAM,iBACN,SAAU,mCACV,YAAa,EACd,EAEYM,GAAeN,EAAQ,CAClC,OAAQ,IACR,KAAM,eACN,SAAU,oCACV,YAAa,EACd,EAEYO,GAAoBP,EAAQ,CACvC,OAAQ,IACR,KAAM,oBACN,SAAU,oCACV,YAAa,EACd,EAEYQ,GAAUR,EAAQ,CAC7B,OAAQ,IACR,KAAM,UACN,SAAU,mCACV,YAAa,EACd,EC/DD,IAAAS,GAAA,GAAAC,EAAAD,GAAA,YAAAE,EAAA,gBAAAC,KAEO,IAAMC,EAASC,EAAM,CAC1B,OAAQ,IACR,KAAM,SACN,SAAU,uCACX,EAEYC,GAAcD,EAAM,CAC/B,OAAQ,IACR,KAAM,cACN,SAAU,uCACX,ECZD,IAAAE,GAAA,GAAAC,EAAAD,GAAA,eAAAE,EAAA,iBAAAC,KAEO,IAAMC,EAAYC,EAAM,CAC7B,KAAM,YACN,OAAQ,IACR,SAAU,6DACX,EAEYC,GAAeD,EAAM,CAChC,KAAM,eACN,OAAQ,IACR,SAAU,6DACX,ECZD,IAAAE,GAAA,GAAAC,EAAAD,GAAA,YAAAE,GAAA,cAAAC,GAAA,cAAAC,GAAA,iBAAAC,KAEO,IAAMC,GAASC,EAAQ,CAC5B,OAAQ,IACR,KAAM,SACN,SAAU,mEACV,YAAa,EACd,EAEYC,GAAYD,EAAQ,CAC/B,OAAQ,IACR,KAAM,YACN,SAAU,oEACV,YAAa,EACd,EAEYE,GAAYF,EAAQ,CAC/B,OAAQ,IACR,KAAM,YACN,SAAU,mEACV,YAAa,EACd,EAEYG,GAAeH,EAAQ,CAClC,OAAQ,IACR,KAAM,eACN,SAAU,oEACV,YAAa,EACd,EC5BD,IAAAI,GAAA,GAAAC,EAAAD,GAAA,WAAAE,KAEO,IAAMC,GAAQC,EAAQ,CAC3B,OAAQ,IACR,KAAM,QACN,SAAU,WACV,YAAa,EACd,ECPD,IAAAC,GAAA,GAAAC,EAAAD,GAAA,cAAAE,KAGO,IAAMC,GAAWC,EAAK,CAC3B,OAAQ,KACR,KAAM,WACN,OAAQC,EAACC,GAAQC,GAASD,CAAG,EAArB,UACR,OAAQD,EAACG,GAAQC,GAAWD,CAAG,EAAvB,UACT,ECND,IAAME,GAAc,IAAI,YAClBC,GAAc,IAAI,YCHxB,IAAAC,GAAA,GAAAC,EAAAD,GAAA,cAAAE,KCCA,IAAIC,GAAWC,GAEXC,GAAM,IACNC,GAAO,IACPC,GAAS,CAACD,GACVE,GAAM,KAAK,IAAI,EAAG,EAAE,EAOxB,SAASJ,GAAOK,EAAKC,EAAKC,EAAM,CAC9BD,EAAMA,GAAO,CAAA,EACbC,EAASA,GAAU,EAGnB,QAFIC,EAAYD,EAEVF,GAAOD,IACXE,EAAIC,GAAQ,EAAKF,EAAM,IAAQJ,GAC/BI,GAAO,IAET,KAAMA,EAAMF,IACVG,EAAIC,GAAQ,EAAKF,EAAM,IAAQJ,GAC/BI,KAAS,EAEX,OAAAC,EAAIC,CAAM,EAAIF,EAAM,EAGpBL,GAAO,MAAQO,EAASC,EAAY,EAE7BF,CACT,CAnBSG,EAAAT,GAAA,UAqBT,IAAIU,GAASC,GAETC,GAAQ,IACRC,GAAS,IAMb,SAASF,GAAKG,EAAKP,EAAM,CACvB,IAAIQ,EAAS,EACTR,EAASA,GAAU,EACnBS,EAAS,EACTC,EAAUV,EACVW,EACAC,EAAIL,EAAI,OAEZ,EAAG,CACD,GAAIG,GAAWE,EAEb,MAAAR,GAAK,MAAQ,EACP,IAAI,WAAW,yBAAyB,EAEhDO,EAAIJ,EAAIG,GAAS,EACjBF,GAAOC,EAAQ,IACVE,EAAIL,KAAWG,GACfE,EAAIL,IAAU,KAAK,IAAI,EAAGG,CAAK,EACpCA,GAAS,CACX,OAASE,GAAKN,IAGd,OAAAD,GAAK,MAAQM,EAAUV,EAEhBQ,CACT,CAzBSN,EAAAE,GAAA,QA2BT,IAAIS,GAAK,KAAK,IAAI,EAAI,CAAC,EACnBC,GAAK,KAAK,IAAI,EAAG,EAAE,EACnBC,GAAK,KAAK,IAAI,EAAG,EAAE,EACnBC,GAAK,KAAK,IAAI,EAAG,EAAE,EACnBC,GAAK,KAAK,IAAI,EAAG,EAAE,EACnBC,GAAK,KAAK,IAAI,EAAG,EAAE,EACnBC,GAAK,KAAK,IAAI,EAAG,EAAE,EACnBC,GAAK,KAAK,IAAI,EAAG,EAAE,EACnBC,GAAK,KAAK,IAAI,EAAG,EAAE,EAEnBC,GAASpB,EAAA,SAAgCqB,EAAK,CAChD,OACEA,EAAQV,GAAK,EACbU,EAAQT,GAAK,EACbS,EAAQR,GAAK,EACbQ,EAAQP,GAAK,EACbO,EAAQN,GAAK,EACbM,EAAQL,GAAK,EACbK,EAAQJ,GAAK,EACbI,EAAQH,GAAK,EACbG,EAAQF,GAAK,EACA,EAEjB,EAba,UAeTG,GAAS,CACT,OAAQhC,GACR,OAAQW,GACR,eAAgBmB,IAGhBG,GAAeD,GAEnBE,EAAeD,GCrGT,SAAUE,EAAQC,EAAkBC,EAAS,EAAC,CAElD,MAAO,CADMC,EAAO,OAAOF,EAAMC,CAAM,EACzBC,EAAO,OAAO,KAAK,CACnC,CAHgBC,EAAAJ,EAAA,UAKV,SAAUK,EAAUC,EAAaC,EAAoBL,EAAS,EAAC,CACnE,OAAAC,EAAO,OAAOG,EAAKC,EAAQL,CAAM,EAC1BK,CACT,CAHgBH,EAAAC,EAAA,YAKV,SAAUG,EAAgBF,EAAW,CACzC,OAAOH,EAAO,eAAeG,CAAG,CAClC,CAFgBF,EAAAI,EAAA,kBCLV,SAAUC,EAA8BC,EAAYC,EAAkB,CAC1E,IAAMC,EAAOD,EAAO,WACdE,EAAoBC,EAAeJ,CAAI,EACvCK,EAAeF,EAAoBC,EAAeF,CAAI,EAEtDI,EAAQ,IAAI,WAAWD,EAAeH,CAAI,EAChD,OAAOK,EAASP,EAAMM,EAAO,CAAC,EACvBC,EAASL,EAAMI,EAAOH,CAAU,EACvCG,EAAM,IAAIL,EAAQI,CAAY,EAEvB,IAAIG,EAAOR,EAAME,EAAMD,EAAQK,CAAK,CAC7C,CAXgBG,EAAAV,EAAA,UAgBV,SAAUW,GAAQC,EAAqB,CAC3C,IAAML,EAAQM,EAAOD,CAAS,EACxB,CAACX,EAAMG,CAAU,EAAWO,EAAOJ,CAAK,EACxC,CAACJ,EAAMG,CAAY,EAAWK,EAAOJ,EAAM,SAASH,CAAU,CAAC,EAC/DF,EAASK,EAAM,SAASH,EAAaE,CAAY,EAEvD,GAAIJ,EAAO,aAAeC,EACxB,MAAM,IAAI,MAAM,kBAAkB,EAGpC,OAAO,IAAIM,EAAOR,EAAME,EAAMD,EAAQK,CAAK,CAC7C,CAXgBG,EAAAC,GAAA,UAaV,SAAUG,GAAQC,EAAoBC,EAAU,CACpD,GAAID,IAAMC,EACR,MAAO,GACF,CACL,IAAMC,EAAOD,EAEb,OACED,EAAE,OAASE,EAAK,MAChBF,EAAE,OAASE,EAAK,MAChBA,EAAK,iBAAiB,YACtBH,GAAWC,EAAE,MAAOE,EAAK,KAAK,CAElC,CACF,CAbgBP,EAAAI,GAAA,UAmBV,IAAOL,EAAP,KAAa,CAvDnB,MAuDmB,CAAAC,EAAA,eACR,KACA,KACA,OACA,MAKT,YAAaT,EAAYE,EAAYD,EAAoBK,EAAiB,CACxE,KAAK,KAAON,EACZ,KAAK,KAAOE,EACZ,KAAK,OAASD,EACd,KAAK,MAAQK,CACf,GHjEF,IAAMW,GAAY,EACZC,GAAO,WAEPC,GAA4CC,EAElD,SAASC,GAAQC,EAAmBC,EAAuB,CACzD,GAAIA,GAAS,UAAY,MAAQA,EAAQ,WAAaD,EAAM,WAAY,CACtE,GAAIC,EAAQ,SAAW,GAAKA,EAAQ,SAAWD,EAAM,WACnD,MAAM,IAAI,MAAM,0DAA0DA,EAAM,UAAU,EAAE,EAG9FA,EAAQA,EAAM,SAAS,EAAGC,EAAQ,QAAQ,CAC5C,CAEA,OAAcC,EAAOP,GAAME,GAAOG,CAAK,CAAC,CAC1C,CAVSG,EAAAJ,GAAA,UAYF,IAAMK,GAAW,CAAE,KAAAT,GAAM,KAAAC,GAAM,OAAAC,GAAQ,OAAAE,EAAM,EIrBpD,IAAAM,GAAA,GAAAC,EAAAD,GAAA,YAAAE,GAAA,WAAAC,KCKA,IAAMC,GAA4B,GAqB5B,SAAUC,GAAiD,CAAE,KAAAC,EAAM,KAAAC,EAAM,OAAAC,EAAQ,gBAAAC,EAAiB,gBAAAC,CAAe,EAA0B,CAC/I,OAAO,IAAIC,GAAOL,EAAMC,EAAMC,EAAQC,EAAiBC,CAAe,CACxE,CAFgBE,EAAAP,GAAA,QAsBV,IAAOM,GAAP,KAAa,CAhDnB,MAgDmB,CAAAC,EAAA,eACR,KACA,KACA,OACA,gBACA,gBAET,YAAaN,EAAYC,EAAYC,EAAkDC,EAA0BC,EAAwB,CACvI,KAAK,KAAOJ,EACZ,KAAK,KAAOC,EACZ,KAAK,OAASC,EACd,KAAK,gBAAkBC,GAAmBL,GAC1C,KAAK,gBAAkBM,CACzB,CAEA,OAAQG,EAAmBC,EAAuB,CAChD,GAAIA,GAAS,UAAY,KAAM,CAC7B,GAAIA,EAAQ,SAAW,KAAK,gBAC1B,MAAM,IAAI,MAAM,6DAA6D,KAAK,eAAe,EAAE,EAGrG,GAAI,KAAK,iBAAmB,MAAQA,EAAQ,SAAW,KAAK,gBAC1D,MAAM,IAAI,MAAM,0DAA0D,KAAK,eAAe,EAAE,CAEpG,CAEA,GAAID,aAAiB,WAAY,CAC/B,IAAME,EAAS,KAAK,OAAOF,CAAK,EAEhC,OAAIE,aAAkB,WACbC,GAAaD,EAAQ,KAAK,KAAMD,GAAS,QAAQ,EAGnDC,EAAO,KAAKE,GAAUD,GAAaC,EAAQ,KAAK,KAAMH,GAAS,QAAQ,CAAC,CACjF,KACE,OAAM,MAAM,mCAAmC,CAGnD,GAOF,SAASE,GAAoCC,EAAoBV,EAAYW,EAAiB,CAC5F,GAAIA,GAAY,MAAQA,IAAaD,EAAO,WAAY,CACtD,GAAIC,EAAWD,EAAO,WACpB,MAAM,IAAI,MAAM,0DAA0DA,EAAO,UAAU,EAAE,EAG/FA,EAASA,EAAO,SAAS,EAAGC,CAAQ,CACtC,CAEA,OAAcC,EAAOZ,EAAMU,CAAM,CACnC,CAVSL,EAAAI,GAAA,gBDzFT,SAASI,GAAKC,EAAyB,CACrC,MAAO,OAAMC,GAAQ,IAAI,WAAW,MAAM,OAAO,OAAO,OAAOD,EAAMC,CAAI,CAAC,CAC5E,CAFSC,EAAAH,GAAA,OAIF,IAAMI,GAASC,GAAK,CACzB,KAAM,WACN,KAAM,GACN,OAAQL,GAAI,SAAS,EACtB,EAEYM,GAASD,GAAK,CACzB,KAAM,WACN,KAAM,GACN,OAAQL,GAAI,SAAS,EACtB,EEPK,SAAUO,GAA0FC,EAASC,EAAmC,CACpJ,GAAM,CAAE,MAAAC,EAAO,QAAAC,CAAO,EAAKH,EAC3B,OAAQG,IACD,EACIC,GACLF,EACAG,GAAUL,CAAI,EACdC,GAAqCK,EAAU,OAAO,EAGjDC,GACLL,EACAG,GAAUL,CAAI,EACbC,GAAQO,EAAO,OAAwC,CAGhE,CAhBgBC,EAAAV,GAAA,UA4BhB,IAAMW,GAAQ,IAAI,QAElB,SAASC,GAAWC,EAAoB,CACtC,IAAMD,EAAYD,GAAM,IAAIE,CAAG,EAC/B,GAAID,GAAa,KAAM,CACrB,IAAMA,EAAY,IAAI,IACtB,OAAAD,GAAM,IAAIE,EAAKD,CAAS,EACjBA,CACT,CACA,OAAOA,CACT,CARSE,EAAAF,GAAA,aAUH,IAAOG,GAAP,MAAOC,CAAG,CAnDhB,MAmDgB,CAAAF,EAAA,YACL,KACA,QACA,UACA,MACA,IAOT,YAAaG,EAAkBC,EAAcC,EAAqCC,EAAiB,CACjG,KAAK,KAAOF,EACZ,KAAK,QAAUD,EACf,KAAK,UAAYE,EACjB,KAAK,MAAQC,EAIb,KAAK,GAAG,EAAIA,CACd,CAQA,IAAI,OAAK,CACP,OAAO,IACT,CAGA,IAAI,YAAU,CACZ,OAAO,KAAK,MAAM,UACpB,CAGA,IAAI,YAAU,CACZ,OAAO,KAAK,MAAM,UACpB,CAEA,MAAI,CACF,OAAQ,KAAK,QAAS,CACpB,IAAK,GACH,OAAO,KAET,IAAK,GAAG,CACN,GAAM,CAAE,KAAAF,EAAM,UAAAC,CAAS,EAAK,KAE5B,GAAID,IAASG,EACX,MAAM,IAAI,MAAM,0CAA0C,EAI5D,GAAIF,EAAU,OAASG,GACrB,MAAM,IAAI,MAAM,oDAAoD,EAGtE,OACEN,EAAI,SACFG,CAA6C,CAGnD,CACA,QACE,MAAM,MACJ,+BAA+B,KAAK,OAAO,4CAA4C,CAG7F,CACF,CAEA,MAAI,CACF,OAAQ,KAAK,QAAS,CACpB,IAAK,GAAG,CACN,GAAM,CAAE,KAAAD,EAAM,OAAAK,CAAM,EAAK,KAAK,UACxBJ,EAAmBK,EAAON,EAAMK,CAAM,EAC5C,OACEP,EAAI,SAAS,KAAK,KAAMG,CAAS,CAErC,CACA,IAAK,GACH,OAAO,KAET,QACE,MAAM,MACJ,+BAA+B,KAAK,OAAO,4CAA4C,CAG7F,CACF,CAEA,OAAQM,EAAc,CACpB,OAAOT,EAAI,OAAO,KAAMS,CAAK,CAC/B,CAEA,OAAO,OAAsFC,EAA4CD,EAAc,CACrJ,IAAME,EAAUF,EAChB,OACEE,GAAW,MACXD,EAAK,OAASC,EAAQ,MACtBD,EAAK,UAAYC,EAAQ,SAClBC,GAAOF,EAAK,UAAWC,EAAQ,SAAS,CAEnD,CAEA,SAAUE,EAAmC,CAC3C,OAAOC,GAAO,KAAMD,CAAI,CAC1B,CAEA,QAAM,CACJ,MAAO,CAAE,IAAKC,GAAO,IAAI,CAAC,CAC5B,CAEA,MAAI,CACF,OAAO,IACT,CAES,CAAC,OAAO,WAAW,EAAI,MAIhC,CAAC,OAAO,IAAI,4BAA4B,CAAC,GAAC,CACxC,MAAO,OAAO,KAAK,SAAQ,CAAE,GAC/B,CAYA,OAAO,MAAwFC,EAA+C,CAC5I,GAAIA,GAAS,KACX,OAAO,KAGT,IAAMC,EAAQD,EACd,GAAIC,aAAiBhB,EAEnB,OAAOgB,EACF,GAAKA,EAAM,GAAG,GAAK,MAAQA,EAAM,GAAG,IAAMA,EAAM,OAAUA,EAAM,QAAUA,EAAO,CAMtF,GAAM,CAAE,QAAAf,EAAS,KAAAC,EAAM,UAAAC,EAAW,MAAAC,CAAK,EAAKY,EAC5C,OAAO,IAAIhB,EACTC,EACAC,EACAC,EACAC,GAASa,GAAUhB,EAASC,EAAMC,EAAU,KAAK,CAAC,CAEtD,SAAWa,EAAME,EAAS,IAAM,GAAM,CAIpC,GAAM,CAAE,QAAAjB,EAAS,UAAAE,EAAW,KAAAD,CAAI,EAAKc,EAC/BT,EAAgBY,GAAOhB,CAAS,EACtC,OAAOH,EAAI,OAAOC,EAASC,EAAMK,CAAM,CACzC,KAGE,QAAO,IAEX,CAOA,OAAO,OAAsFN,EAAkBC,EAAcK,EAAgC,CAC3J,GAAI,OAAOL,GAAS,SAClB,MAAM,IAAI,MAAM,uCAAuC,EAGzD,GAAI,EAAEK,EAAO,iBAAiB,YAC5B,MAAM,IAAI,MAAM,gBAAgB,EAGlC,OAAQN,EAAS,CACf,IAAK,GAAG,CACN,GAAIC,IAASG,EACX,MAAM,IAAI,MACR,wCAAwCA,CAAW,kBAAkB,EAGvE,OAAO,IAAIL,EAAIC,EAASC,EAAMK,EAAQA,EAAO,KAAK,CAEtD,CACA,IAAK,GAAG,CACN,IAAMH,EAAQa,GAAUhB,EAASC,EAAMK,EAAO,KAAK,EACnD,OAAO,IAAIP,EAAIC,EAASC,EAAMK,EAAQH,CAAK,CAC7C,CACA,QACE,MAAM,IAAI,MAAM,iBAAiB,CAErC,CACF,CAKA,OAAO,SAAuBG,EAAgD,CAC5E,OAAOP,EAAI,OAAO,EAAGK,EAAaE,CAAM,CAC1C,CAQA,OAAO,SAAyDL,EAAYK,EAAgC,CAC1G,OAAOP,EAAI,OAAO,EAAGE,EAAMK,CAAM,CACnC,CASA,OAAO,OAAoFH,EAAuD,CAChJ,GAAM,CAACP,EAAKuB,CAAS,EAAIpB,EAAI,YAAYI,CAAK,EAC9C,GAAIgB,EAAU,SAAW,EACvB,MAAM,IAAI,MAAM,kBAAkB,EAEpC,OAAOvB,CACT,CAWA,OAAO,YAA2EO,EAAyC,CACzH,IAAMiB,EAAQrB,EAAI,aAAaI,CAAK,EAC9BkB,EAAaD,EAAM,KAAOA,EAAM,cAChCE,EAAiBC,EACrBpB,EAAM,SAASkB,EAAYA,EAAaD,EAAM,aAAa,CAAC,EAE9D,GAAIE,EAAe,aAAeF,EAAM,cACtC,MAAM,IAAI,MAAM,kBAAkB,EAEpC,IAAMI,EAAcF,EAAe,SACjCF,EAAM,cAAgBA,EAAM,UAAU,EAElCd,EAAS,IAAWmB,EACxBL,EAAM,cACNA,EAAM,WACNI,EACAF,CAAc,EAMhB,MAAO,CAHLF,EAAM,UAAY,EACdrB,EAAI,SAASO,CAA0C,EACvDP,EAAI,SAASqB,EAAM,MAAOd,CAAM,EACNH,EAAM,SAASiB,EAAM,IAAI,CAAC,CAC5D,CAWA,OAAO,aAA4EM,EAAgD,CACjI,IAAIC,EAAS,EACPC,EAAO/B,EAAA,IAAa,CACxB,GAAM,CAACgC,EAAGC,CAAM,EAAWZ,EAAOQ,EAAa,SAASC,CAAM,CAAC,EAC/D,OAAAA,GAAUG,EACHD,CACT,EAJa,QAMT7B,EAAU4B,EAAI,EACdG,EAAQ3B,EASZ,GARIJ,IAAsB,IAExBA,EAAU,EACV2B,EAAS,GAETI,EAAQH,EAAI,EAGV5B,IAAY,GAAKA,IAAY,EAC/B,MAAM,IAAI,WAAW,uBAAuBA,CAAO,EAAE,EAGvD,IAAMqB,EAAaM,EACbK,EAAgBJ,EAAI,EACpBK,EAAaL,EAAI,EACjBM,EAAOP,EAASM,EAChBE,EAAgBD,EAAOb,EAE7B,MAAO,CAAE,QAAArB,EAAS,MAAA+B,EAAO,cAAAC,EAAe,WAAAC,EAAY,cAAAE,EAAe,KAAAD,CAAI,CACzE,CAQA,OAAO,MAA0GE,EAAkExB,EAAmC,CACpN,GAAM,CAACyB,EAAQlC,CAAK,EAAImC,GAAgBF,EAAQxB,CAAI,EAE9ChB,EAAMG,EAAI,OAAOI,CAAK,EAE5B,GAAIP,EAAI,UAAY,GAAKwC,EAAO,CAAC,IAAM,IACrC,MAAM,MAAM,wDAAwD,EAItE,OAAAzC,GAAUC,CAAG,EAAE,IAAIyC,EAAQD,CAAM,EAE1BxC,CACT,GAGF,SAAS0C,GAAqHF,EAAkExB,EAAmC,CACjO,OAAQwB,EAAO,CAAC,EAAG,CAEjB,IAAK,IAAK,CACR,IAAMG,EAAU3B,GAAQ4B,EACxB,MAAO,CACLA,EAAU,OACVD,EAAQ,OAAO,GAAGC,EAAU,MAAM,GAAGJ,CAAM,EAAE,EAEjD,CACA,KAAKI,EAAU,OAAQ,CACrB,IAAMD,EAAU3B,GAAQ4B,EACxB,MAAO,CAACA,EAAU,OAAkBD,EAAQ,OAAOH,CAAM,CAAC,CAC5D,CACA,KAAKK,EAAO,OAAQ,CAClB,IAAMF,EAAU3B,GAAQ6B,EACxB,MAAO,CAACA,EAAO,OAAkBF,EAAQ,OAAOH,CAAM,CAAC,CACzD,CACA,KAAKM,EAAO,OAAQ,CAClB,IAAMH,EAAU3B,GAAQ8B,EACxB,MAAO,CAACA,EAAO,OAAkBH,EAAQ,OAAOH,CAAM,CAAC,CACzD,CACA,QAAS,CACP,GAAIxB,GAAQ,KACV,MAAM,MACJ,yFAAyF,EAG7F,MAAO,CAACwB,EAAO,CAAC,EAAaxB,EAAK,OAAOwB,CAAM,CAAC,CAClD,CACF,CACF,CA/BSvC,EAAAyC,GAAA,mBAiCT,SAASK,GAAYxC,EAAmBT,EAA4BkB,EAA+B,CACjG,GAAM,CAAE,OAAAyB,CAAM,EAAKzB,EACnB,GAAIyB,IAAWG,EAAU,OACvB,MAAM,MAAM,8BAA8B5B,EAAK,IAAI,WAAW,EAGhE,IAAMhB,EAAMF,EAAM,IAAI2C,CAAM,EAC5B,GAAIzC,GAAO,KAAM,CACf,IAAMA,EAAMgB,EAAK,OAAOT,CAAK,EAAE,MAAM,CAAC,EACtC,OAAAT,EAAM,IAAI2C,EAAQzC,CAAG,EACdA,CACT,KACE,QAAOA,CAEX,CAdSC,EAAA8C,GAAA,cAgBT,SAASC,GAAoCzC,EAAmBT,EAA4BkB,EAAkC,CAC5H,GAAM,CAAE,OAAAyB,CAAM,EAAKzB,EACbhB,EAAMF,EAAM,IAAI2C,CAAM,EAC5B,GAAIzC,GAAO,KAAM,CACf,IAAMA,EAAMgB,EAAK,OAAOT,CAAK,EAC7B,OAAAT,EAAM,IAAI2C,EAAQzC,CAAG,EACdA,CACT,KACE,QAAOA,CAEX,CAVSC,EAAA+C,GAAA,cAYT,IAAMxC,EAAc,IACdC,GAAe,GAErB,SAASW,GAAWhB,EAAsBC,EAAcC,EAAqB,CAC3E,IAAM2C,EAAoBC,EAAe9C,CAAO,EAC1C+C,EAAaF,EAAoBC,EAAe7C,CAAI,EACpDE,EAAQ,IAAI,WAAW4C,EAAa7C,EAAU,UAAU,EAC9D,OAAO8C,EAAShD,EAASG,EAAO,CAAC,EAC1B6C,EAAS/C,EAAME,EAAO0C,CAAU,EACvC1C,EAAM,IAAID,EAAW6C,CAAU,EACxB5C,CACT,CARSN,EAAAmB,GAAA,aAUT,IAAMC,GAAY,OAAO,IAAI,kBAAkB,EC7bxC,IAAMgC,GAAQ,CAAE,GAAGC,GAAc,GAAGC,GAAO,GAAGC,GAAO,GAAGC,GAAQ,GAAGC,GAAQ,GAAGC,GAAQ,GAAGC,GAAQ,GAAGC,GAAQ,GAAGC,GAAQ,GAAGC,EAAY,EAChIC,GAAS,CAAE,GAAGC,GAAM,GAAGX,EAAQ,ECb5C,SAASY,GAAaC,EAAcC,EAAgBC,EAAqCC,EAAmC,CAC1H,MAAO,CACL,KAAAH,EACA,OAAAC,EACA,QAAS,CACP,KAAAD,EACA,OAAAC,EACA,OAAAC,GAEF,QAAS,CACP,OAAAC,GAGN,CAbSC,EAAAL,GAAA,eAeT,IAAMM,GAASN,GAAY,OAAQ,IAAMO,GAEhC,IADS,IAAI,YAAY,MAAM,EACjB,OAAOA,CAAG,EAC7BC,GACc,IAAI,YAAW,EAChB,OAAOA,EAAI,UAAU,CAAC,CAAC,CACvC,EAEKC,GAAQT,GAAY,QAAS,IAAMO,GAAO,CAC9C,IAAID,EAAS,IAEb,QAASI,EAAI,EAAGA,EAAIH,EAAI,OAAQG,IAC9BJ,GAAU,OAAO,aAAaC,EAAIG,CAAC,CAAC,EAEtC,OAAOJ,CACT,EAAIE,GAAO,CACTA,EAAMA,EAAI,UAAU,CAAC,EACrB,IAAMD,EAAMI,GAAYH,EAAI,MAAM,EAElC,QAASE,EAAI,EAAGA,EAAIF,EAAI,OAAQE,IAC9BH,EAAIG,CAAC,EAAIF,EAAI,WAAWE,CAAC,EAG3B,OAAOH,CACT,CAAC,EAIKK,GAAyD,CAC7D,KAAMN,GACN,QAASA,GACT,IAAKO,GAAM,OACX,OAAQJ,GACR,MAAAA,GACA,OAAQA,GAER,GAAGI,IAGLC,GAAeF,GC9CT,SAAUG,EAAYC,EAAgBC,EAA+B,OAAM,CAC/E,IAAMC,EAAOC,GAAMF,CAAQ,EAE3B,GAAIC,GAAQ,KACV,MAAM,IAAI,MAAM,yBAAyBD,CAAQ,GAAG,EAItD,OAAOC,EAAK,QAAQ,OAAO,GAAGA,EAAK,MAAM,GAAGF,CAAM,EAAE,CACtD,CATgBI,EAAAL,EAAA,cCAV,SAAUM,GAAUC,EAAmBC,EAA+B,OAAM,CAChF,IAAMC,EAAOC,GAAMF,CAAQ,EAE3B,GAAIC,GAAQ,KACV,MAAM,IAAI,MAAM,yBAAyBD,CAAQ,GAAG,EAItD,OAAOC,EAAK,QAAQ,OAAOF,CAAK,EAAE,UAAU,CAAC,CAC/C,CATgBI,EAAAL,GAAA,YCYT,IAAMM,EAAN,cAAwB,KAAM,CAxBrC,MAwBqC,CAAAC,EAAA,kBACxB,KAET,YACIC,EACAC,EACAC,EACF,CACE,MAAMD,EAASC,CAAI,EACnB,KAAK,KAAO,YACZ,KAAK,KAAOF,CAChB,CACJ,ECAA,IAAMG,GAAS,WAAW,OAAO,OA6B1B,IAAMC,GAAO,OAAO,OAAOC,GAAW,CACzC,IAAKC,EACT,CAAC,EAOYC,GAAU,OAAO,OAAOC,GAAc,CAC/C,SAAUC,EACd,CAAC,EASYC,GAAU,OAAO,OAAOC,GAAc,CAC/C,SAAUC,GACV,WAAYC,EAChB,CAAC,EAWD,eAAeF,GACXG,EACAC,EACAC,EACkB,CAClB,GAAID,EAAQ,WAAaE,EACrB,MAAM,IAAIC,EACN,wBACA,8BACJ,EAGJ,IAAMC,EAAcJ,EAAQ,CAAC,GAAK,EAAKA,EAAQ,CAAC,EAC1CK,EAAUH,EAAqBE,EAC/BE,EAAUD,EAAUE,EAC1B,GAAIP,EAAQ,WAAaM,EAAUE,GAC/B,MAAM,IAAIL,EACN,wBACA,8BACJ,EAGJ,IAAMM,EAAUT,EAAQ,MAAME,EAAoBG,CAAO,EACnDK,EAAKV,EAAQ,MAAMK,EAASC,CAAO,EACnCK,EAAaX,EAAQ,MAAMM,CAAO,EAElCM,EAAW,MAAMrB,GACnBQ,EACAU,EACAR,GAAM,OAAS,OAAY,CAAE,KAAMA,EAAK,IAAK,EAAI,MACrD,EACMY,EAAM,MAAMC,GAAwBF,CAAQ,EAE9CG,EACJ,GAAI,CACAA,EAAK,MAAMC,GAAO,QACd,CAAE,KAAM,UAAW,GAAIN,CAAmB,EAC1CG,EACAF,CACJ,CACJ,OAASM,EAAK,CAGV,MAAM,IAAId,EACN,qBACA,qDACA,CAAE,MAAOc,CAAI,CACjB,CACJ,CAEA,OAAO,IAAI,WAAWF,CAAE,CAC5B,CAnDeG,EAAAtB,GAAA,gBA8Df,eAAeC,GACXE,EACAC,EACAC,EACc,CACd,IAAMkB,EAAQ,MAAMvB,GAAaG,EAASC,EAASC,CAAI,EACvD,OAAO,IAAI,YAAY,EAAE,OAAOkB,CAAK,CACzC,CAPeD,EAAArB,GAAA,mBAmCf,eAAeC,GACXC,EACAC,EACAC,EACyB,CACzB,IAAMkB,EAAQC,EAAWpB,EAAS,WAAW,EACvCqB,EAAY,MAAMzB,GACpBG,EACAoB,EACAlB,GAAM,OAAS,OAAY,CAAE,KAAMA,EAAK,IAAK,EAAI,MACrD,EAEA,OAAOA,GAAM,OAASoB,EAAY,IAAI,YAAY,EAAE,OAAOA,CAAS,CACxE,CAbeH,EAAApB,GAAA,qBAef,SAASwB,GAAiBC,EAAqB,CAC3C,GAAIA,IAAY,KAAOA,IAAY,IAC/B,MAAM,IAAIpB,EACN,sBACA,oBAAoBoB,CAAO,wBAC/B,CAER,CAPSL,EAAAI,GAAA,mBAYT,SAASE,GAAqBC,EAAqB,CAC/C,GAAIA,EAAI,SAAW,IAAMA,EAAI,SAAW,GACpC,MAAM,IAAItB,EACN,sBACA,0BAA0BsB,EAAI,MAAM,4BAExC,CAER,CARSP,EAAAM,GAAA,uBAUT,SAASE,GAAeC,EAAoC,CACxD,OAA0BA,GAAS,KAAa,IAAI,WAAW,CAAC,EAC5D,OAAOA,GAAS,SAAiB,IAAI,YAAY,EAAE,OAAOA,CAAI,EAC3DA,CACX,CAJST,EAAAQ,GAAA,iBAMT,eAAeE,GAAmBf,EAAmC,CACjE,GAAI,CAACA,EAAI,YACL,MAAM,IAAIV,EACN,sBACA,+DACJ,EAEJ,OAAO,IAAI,WAAW,MAAMa,GAAO,UAAU,MAAOH,CAAG,CAAC,CAC5D,CAReK,EAAAU,GAAA,qBAcf,eAAeC,GACXJ,EACAK,EACiB,CACjB,OAAOd,GAAO,UACV,MACAS,EACA,CAAE,KAAM,SAAU,EAClBK,EACA,CAAC,UAAW,SAAS,CACzB,CACJ,CAXeZ,EAAAW,GAAA,gBAgBf,eAAef,GAAyBW,EAAmC,CACvE,OAAOT,GAAO,UACV,MACAS,EACA,CAAE,KAAM,SAAU,EAClB,GACA,CAAC,SAAS,CACd,CACJ,CAReP,EAAAJ,GAAA,2BAcf,eAAeiB,GACXC,EACAL,EACgD,CAChD,IAAMM,EAAQ,IAAI,WAAW,CAAC,EACxBC,EAAY,MAAMC,EACpBC,EACAH,EACA,cACAA,CACJ,EACMI,EAAW,MAAMF,EACnBC,EACAH,EACA,YACAN,CACJ,EACMW,EAAYC,EAAO,IAAI,WAAW,CAACC,EAAS,CAAC,EAAGN,EAAWG,CAAQ,EAEnEI,EAAS,MAAMN,EACjBC,EACAJ,EACA,SACAC,CACJ,EACMpB,EAAM,MAAM6B,GACdN,EACAK,EACA,MACAH,EACAK,EACJ,EACMC,EAAY,MAAMF,GACpBN,EACAK,EACA,aACAH,EACA/B,CACJ,EACA,MAAO,CAAE,IAAAM,EAAK,UAAA+B,CAAU,CAC5B,CAxCe1B,EAAAa,GAAA,eAqDf,eAAexC,GACXQ,EACAU,EACAR,EACkB,CAClB,GAAIQ,EAAQ,WAAaoC,EAAarC,GAClC,MAAM,IAAIL,EACN,yBACA,+BACJ,EAGJ,IAAMwB,EAAOD,GAAczB,GAAM,IAAI,EAC/B6C,EAAMrC,EAAQ,MAAM,EAAGoC,CAAU,EACjClC,EAAaF,EAAQ,MAAMoC,CAAU,EAErCb,EAAe,MAAMe,GAAMD,EAAK/C,CAAO,EACvC,CAAE,IAAAc,EAAK,UAAA+B,CAAU,EAAI,MAAMb,GAAYC,EAAcL,CAAI,EAC/D,OAAOqB,GAASnC,EAAK+B,EAAWjC,CAAU,CAC9C,CAnBeO,EAAA3B,GAAA,gBA+Bf,eAAeD,GACXS,EACAU,EACAR,EACiB,CACjB,IAAMW,EAAW,MAAMrB,GAAaQ,EAASU,EAASR,CAAI,EAC1D,OAAO4B,GAAajB,EAAUX,GAAM,aAAe,EAAK,CAC5D,CAPeiB,EAAA5B,GAAA,aA4Bf,eAAsB2D,GAClBC,EACAC,EACAlD,EAQ6C,CAC7C,IAAM0B,EAAOD,GAAczB,GAAM,IAAI,EAEjCW,EACJ,GAAIuC,aAAkB,WAClB3B,GAAoB2B,CAAM,EAC1BvC,EAAWuC,UACJA,EACPvC,EAAW,MAAMgB,GAAkBuB,CAAM,EACzC3B,GAAoBZ,CAAQ,MACzB,CACH,IAAMW,EAAUtB,GAAM,MAAQ,IAC9BqB,GAAgBC,CAAO,EACvBX,EAAW,WAAW,OAAO,gBACzB,IAAI,WAAWW,EAAU,CAAC,CAC9B,CACJ,CAEA,IAAM6B,EAAY,MAAMC,GAA0BH,CAAS,EACrD,CAAE,aAAAlB,EAAc,IAAAc,CAAI,EAAI,MAAMQ,GAAMF,CAAS,EAC7C,CAAE,IAAAvC,EAAK,UAAA+B,CAAU,EAAI,MAAMb,GAAYC,EAAcL,CAAI,EACzDhB,EAAa,MAAM4C,GAAS1C,EAAK+B,EAAWhC,CAAQ,EACpDH,EAAU8B,EAAOO,EAAKnC,CAAU,EAChC6C,EAAY,MAAM3B,GACpBjB,EACAX,GAAM,aAAe,EACzB,EAEA,MAAO,CAAE,QAAAQ,EAAS,IAAK+C,CAAU,CACrC,CAxCsBtC,EAAA+B,GAAA,cC1XtB,IAAMQ,EAAS,WAAW,OAAO,OAoBjC,eAAsBC,GAClBC,EACAC,EACAC,EACkB,CAClB,IAAMC,EAAI,MAAML,EAAO,UACnB,MACAE,EACA,CAAE,KAAM,SAAU,EAClB,GACA,CAAC,SAAS,CACd,EACMI,EAAK,MAAMN,EAAO,QACpB,CAAE,KAAM,UAAW,GAAIG,CAAsB,EAC7CE,EACAD,CACJ,EACA,OAAO,IAAI,WAAWE,CAAE,CAC5B,CAlBsBC,EAAAN,GAAA,YAoBtB,eAAsBO,GAClBN,EACAC,EACAM,EACkB,CAClB,IAAMJ,EAAI,MAAML,EAAO,UACnB,MACAE,EACA,CAAE,KAAM,SAAU,EAClB,GACA,CAAC,SAAS,CACd,EACIQ,EACJ,GAAI,CACAA,EAAK,MAAMV,EAAO,QACd,CAAE,KAAM,UAAW,GAAIG,CAAsB,EAC7CE,EACAI,CACJ,CACJ,OAASE,EAAK,CAIV,MAAM,IAAIC,EACN,qBACA,uFAEA,CAAE,MAAOD,CAAI,CACjB,CACJ,CACA,OAAO,IAAI,WAAWD,CAAE,CAC5B,CA/BsBH,EAAAC,GAAA,YA4DtB,eAAsBK,GAClBC,EACAC,EACAC,EACAC,EAIkB,CAClB,IAAMb,EAAY,OAAOW,GAAY,SACjC,IAAI,YAAY,EAAE,OAAOA,CAAO,EAChCA,EAEE,CAAE,QAAAG,EAAS,IAAAhB,CAAI,EAAI,MAAMiB,GAAWL,EAAWE,EAAQC,CAAI,EAE3DG,EAAK,WAAW,OAAO,gBAAgB,IAAI,WAAWC,CAAE,CAAC,EACzDf,EAAK,IAAI,WAAW,MAAMN,EAAO,QACnC,CAAE,KAAM,UAAW,GAAIoB,CAAmB,EAC1ClB,EACAE,CACJ,CAAC,EAED,OAAOkB,EACHC,EAAML,EAAQ,OAAQM,CAAkB,EACxCN,EACAE,EACAd,CACJ,CACJ,CA5BsBC,EAAAM,GAAA,gBAqDtB,eAAsBY,GAClBX,EACAC,EACAC,EACAC,EAKc,CACd,IAAMS,EAAW,MAAMb,GAAaC,EAAWC,EAASC,EAAQC,CAAI,EACpE,OAAOU,GAASD,EAAUT,GAAM,UAAY,WAAW,CAC3D,CAZsBV,EAAAkB,GAAA,mBAoBtB,eAAsBG,GAAM1B,EAAgB2B,EAAqC,CAC7E,IAAMxB,EAAI,MAAML,EAAO,UACnB,MACAE,EACA,CAAE,KAAM,OAAQ,KAAM,SAAU,EAChC,GACA,CAAC,MAAM,CACX,EACA,OAAO,IAAI,WAAW,MAAMF,EAAO,KAAK,OAAQK,EAAGwB,CAAoB,CAAC,CAC5E,CATsBtB,EAAAqB,GAAA,QAatB,eAAeE,GACXC,EACAC,EACkB,CAClB,IAAM9B,EAAM6B,EAAK,SAAW,EAAI,IAAI,WAAWE,EAAO,EAAIF,EAC1D,OAAOH,GAAK1B,EAAK8B,CAAG,CACxB,CANezB,EAAAuB,GAAA,WASf,eAAeI,GACXC,EACAC,EACAC,EACkB,CAClB,IAAMC,EAAM,IAAI,WAAWD,CAAM,EAC7BE,EAAe,IAAI,WAAW,CAAC,EAC/BC,EAAS,EACTC,EAAU,EACd,KAAOD,EAASH,GAAQ,CACpBE,EAAI,MAAMX,GAAKO,EAAKb,EAAOiB,EAAGH,EAAMb,EAAMkB,EAAS,CAAC,CAAC,CAAC,EACtD,IAAMC,EAAO,KAAK,IAAIH,EAAE,OAAQF,EAASG,CAAM,EAC/CF,EAAI,IAAIC,EAAE,SAAS,EAAGG,CAAI,EAAGF,CAAM,EACnCA,GAAUE,EACVD,GACJ,CACA,OAAOH,CACX,CAjBe/B,EAAA2B,GAAA,UAoBf,eAAsBS,EAClBC,EACAb,EACAc,EACAb,EACkB,CAClB,IAAMc,EAAaxB,EACfyB,GACAH,EACA,IAAI,YAAY,EAAE,OAAOC,CAAK,EAC9Bb,CACJ,EACA,OAAOF,GAAQC,EAAMe,CAAU,CACnC,CAbsBvC,EAAAoC,EAAA,kBAgBtB,eAAsBK,GAClBJ,EACAT,EACAU,EACAT,EACAC,EACkB,CAClB,IAAMY,EAAc3B,EAChBC,EAAMc,EAAQ,CAAC,EACfU,GACAH,EACA,IAAI,YAAY,EAAE,OAAOC,CAAK,EAC9BT,CACJ,EACA,OAAOF,GAAOC,EAAKc,EAAaZ,CAAM,CAC1C,CAfsB9B,EAAAyC,GAAA,iBAmBtB,eAAeE,GAAiBhD,EAAmC,CAC/D,OAAO,IAAI,WAAW,MAAMF,EAAO,UAAU,MAAOE,CAAG,CAAC,CAC5D,CAFeK,EAAA2C,GAAA,mBAOf,eAAeC,GAAiBC,EAAmC,CAC/D,GAAIA,EAAI,SAAWC,EACf,MAAM,IAAIzC,EACN,4BACA,8BAA8BwC,EAAI,MAAM,oBAC3BC,CAAU,GAC3B,EAEJ,OAAOrD,EAAO,UACV,MACAoD,EACA,CAAE,KAAM,QAAS,EACjB,GACA,CAAC,CACL,CACJ,CAfe7C,EAAA4C,GAAA,mBAoBf,eAAsBG,GAClBxC,EACiB,CAEjB,GAAIA,aAAqB,WACrB,OAAOqC,GAAgBrC,CAAS,EAIpC,GAAIA,aAAqB,UAAW,CAChC,GAAIA,EAAU,OAAS,SACnB,MAAM,IAAIF,EACN,4BACA,0CACJ,EAEJ,OAAA2C,GACIzC,EACA,sBACA,2BACJ,EACOA,CACX,CAGA,GAAI,OAAQA,EAAqC,WAAc,SAAU,CACrE,GAAM,CAAE,UAAA0C,EAAW,SAAAC,CAAS,EACxB3C,EACJ,OAAOqC,GAAgBO,EAAWF,EAAWC,GAAY,WAAW,CAAC,CACzE,CAGA,IAAME,EAAO7C,EACb,GAAI6C,EAAK,qBAAqB,UAAW,CACrC,GAAIA,EAAK,UAAU,OAAS,SACxB,MAAM,IAAI/C,EACN,4BACA,kDACJ,EAEJ,OAAA2C,GACII,EAAK,UACL,8BACA,2BACJ,EACOA,EAAK,SAChB,CAEA,MAAM,IAAI/C,EACN,4BACA,iCACJ,CACJ,CApDsBL,EAAA+C,GAAA,6BAyDtB,SAASC,GACLrD,EACA0D,EACAC,EACG,CACH,GAAI3D,EAAI,UAAU,OAAS,SACvB,MAAM,IAAIU,EACNiD,EACA,GAAGD,CAAO,+BAA+B1D,EAAI,UAAU,IAAI,GAC/D,CAER,CAXSK,EAAAgD,GAAA,yBAeT,eAAeO,GACXC,EACAC,EACkB,CAClB,IAAMC,EAAO,MAAMjE,EAAO,WACtB,CAAE,KAAM,SAAU,OAAQgE,CAAI,EAC9BD,EACA,GACJ,EACMG,EAAQ,IAAI,WAAWD,CAAI,EAKjC,GAAIC,EAAM,MAAMC,GAAKA,IAAM,CAAC,EACxB,MAAM,IAAIvD,EACN,sBACA,4DACJ,EAGJ,OAAOsD,CACX,CAtBe3D,EAAAuD,GAAA,MA0Bf,eAAeM,GACXC,EACAC,EACkB,CAClB,IAAMC,EAAS,MAAM5B,EACjB6B,GACA,IAAI,WAAW,CAAC,EAChB,UACAH,CACJ,EACA,OAAOrB,GACHwB,GACAD,EACA,gBACAD,EACArC,EACJ,CACJ,CAjBe1B,EAAA6D,GAAA,oBAqBf,eAAsBK,GAClBC,EACmD,CACnD,IAAMC,EAAM,MAAM3E,EAAO,YACrB,CAAE,KAAM,QAAS,EACjB,GACA,CAAC,YAAY,CACjB,EAEMqE,EAAU,MAAMP,GAAGa,EAAI,WAAYD,CAAG,EACtCE,EAAM,MAAM1B,GAAgByB,EAAI,SAAS,EACzCE,EAAO,MAAM3B,GAAgBwB,CAAG,EAChCJ,EAAahD,EAAOsD,EAAKC,CAAI,EAEnC,MAAO,CAAE,aADY,MAAMT,GAAiBC,EAASC,CAAU,EACxC,IAAAM,CAAI,CAC/B,CAfsBrE,EAAAkE,GAAA,SAmBtB,eAAsBK,GAClBF,EACAG,EACkB,CAClB,GAAIA,EAAQ,WAAW,OAAS,UAC5B,MAAM,IAAInE,EACN,sBACA,0CACJ,EAEJ2C,GACIwB,EAAQ,WACR,qBACA,qBACJ,EAEA,IAAMC,EAAM,MAAMhF,EAAO,UACrB,MACA4E,EACA,CAAE,KAAM,QAAS,EACjB,GACA,CAAC,CACL,EACMP,EAAU,MAAMP,GAAGiB,EAAQ,WAAYC,CAAG,EAC1CH,EAAO,MAAM3B,GAAgB6B,EAAQ,SAAS,EAC9CT,EAAahD,EAAOsD,EAAKC,CAAI,EACnC,OAAOT,GAAiBC,EAASC,CAAU,CAC/C,CA3BsB/D,EAAAuE,GAAA,SAyGf,SAASG,EAAOC,EAAUC,EAAuB,CACpD,IAAMC,EAAM,IAAI,WAAWD,CAAG,EAC1BE,EAAIH,EACR,QAASI,EAAIH,EAAM,EAAGG,GAAK,EAAGA,IAC1BF,EAAIE,CAAC,EAAID,EAAI,IACbA,EAAI,KAAK,MAAMA,EAAI,GAAG,EAE1B,OAAOD,CACX,CARgBG,EAAAN,EAAA,SAUT,SAASO,KAAWC,EAAgC,CACvD,IAAIC,EAAQ,EACZ,QAAWC,KAAKF,EAAQC,GAASC,EAAE,OACnC,IAAMP,EAAM,IAAI,WAAWM,CAAK,EAC5BE,EAAS,EACb,QAAWD,KAAKF,EACZL,EAAI,IAAIO,EAAGC,CAAM,EACjBA,GAAUD,EAAE,OAEhB,OAAOP,CACX,CAVgBG,EAAAC,EAAA,U7B9hBT,IAAMK,GAAS,GACTC,GAAS,EACTC,GAAU,EAIVC,GAAU,GACVC,GAAK,GACLC,EAAK,GACLC,EAAa,GACbC,GAAkB,GAGlBC,GAAY,EAEZC,GAAU,IAAI,YAAY,EAAE,OAAO,SAAS,EAK5CC,EAAqB,EAGrBC,GAAeC,EACxB,IAAI,YAAY,EAAE,OAAO,KAAK,EAC9BC,EAAMb,GAAQ,CAAC,CACnB,EAIac,EAAgBF,EACzB,IAAI,YAAY,EAAE,OAAO,MAAM,EAC/BC,EAAMb,GAAQ,CAAC,EACfa,EAAMZ,GAAQ,CAAC,EACfY,EAAMX,GAAS,CAAC,CACpB,EAUaa,GAAe,IAAI,YAAY,EACvC,OAAO,sBAAsB,EAMrBC,GAAsB",
  "names": ["constants_exports", "__export", "AEAD_ID", "AEAD_TAG_LENGTH", "ENC_LENGTH", "HPKE_SUITE_ID", "HPKE_V1", "KDF_ID", "KEM_ID", "KEM_SUITE_ID", "KEY_ID_LABEL", "KEY_ID_NONCE_LENGTH", "MODE_BASE", "NK", "NN", "NSECRET", "WRAPPED_LEN_PREFIX", "__toCommonJS", "allocUnsafe", "size", "__name", "base10_exports", "__export", "base10", "empty", "equals", "aa", "bb", "ii", "__name", "coerce", "o", "fromString", "str", "__name", "toString", "b", "base", "ALPHABET", "name", "BASE_MAP", "j", "i", "x", "xc", "BASE", "LEADER", "FACTOR", "iFACTOR", "encode", "source", "zeroes", "length", "pbegin", "pend", "size", "b58", "carry", "it1", "it2", "str", "__name", "decodeUnsafe", "psz", "b256", "it3", "it4", "vch", "decode", "string", "buffer", "src", "_brrp__multiformats_scope_baseX", "base_x_default", "Encoder", "__name", "name", "prefix", "baseEncode", "bytes", "Decoder", "baseDecode", "prefixCodePoint", "text", "decoder", "or", "ComposedDecoder", "decoders", "input", "left", "right", "Codec", "from", "encode", "decode", "baseX", "alphabet", "base_x_default", "coerce", "string", "alphabetIdx", "bitsPerChar", "end", "out", "bits", "buffer", "written", "i", "value", "data", "pad", "mask", "createAlphabetIdx", "rfc4648", "base10", "baseX", "base16_exports", "__export", "base16", "base16upper", "base16", "rfc4648", "base16upper", "base2_exports", "__export", "base2", "base2", "rfc4648", "base256emoji_exports", "__export", "base256emoji", "alphabet", "alphabetBytesToChars", "p", "c", "i", "alphabetCharsToBytes", "codePoint", "encode", "data", "__name", "decode", "str", "byts", "char", "byt", "base256emoji", "from", "base32_exports", "__export", "base32", "base32hex", "base32hexpad", "base32hexpadupper", "base32hexupper", "base32pad", "base32padupper", "base32upper", "base32z", "base32", "rfc4648", "base32upper", "base32pad", "base32padupper", "base32hex", "base32hexupper", "base32hexpad", "base32hexpadupper", "base32z", "base36_exports", "__export", "base36", "base36upper", "base36", "baseX", "base36upper", "base58_exports", "__export", "base58btc", "base58flickr", "base58btc", "baseX", "base58flickr", "base64_exports", "__export", "base64", "base64pad", "base64url", "base64urlpad", "base64", "rfc4648", "base64pad", "base64url", "base64urlpad", "base8_exports", "__export", "base8", "base8", "rfc4648", "identity_exports", "__export", "identity", "identity", "from", "__name", "buf", "toString", "str", "fromString", "textEncoder", "textDecoder", "identity_exports", "__export", "identity", "encode_1", "encode", "MSB", "REST", "MSBALL", "INT", "num", "out", "offset", "oldOffset", "__name", "decode", "read", "MSB$1", "REST$1", "buf", "res", "shift", "counter", "b", "l", "N1", "N2", "N3", "N4", "N5", "N6", "N7", "N8", "N9", "length", "value", "varint", "_brrp_varint", "varint_default", "decode", "data", "offset", "varint_default", "__name", "encodeTo", "int", "target", "encodingLength", "create", "code", "digest", "size", "sizeOffset", "encodingLength", "digestOffset", "bytes", "encodeTo", "Digest", "__name", "decode", "multihash", "coerce", "equals", "a", "b", "data", "code", "name", "encode", "coerce", "digest", "input", "options", "create", "__name", "identity", "sha2_browser_exports", "__export", "sha256", "sha512", "DEFAULT_MIN_DIGEST_LENGTH", "from", "name", "code", "encode", "minDigestLength", "maxDigestLength", "Hasher", "__name", "input", "options", "result", "createDigest", "digest", "truncate", "create", "sha", "name", "data", "__name", "sha256", "from", "sha512", "format", "link", "base", "bytes", "version", "toStringV0", "baseCache", "base58btc", "toStringV1", "base32", "__name", "cache", "baseCache", "cid", "__name", "CID", "_CID", "version", "code", "multihash", "bytes", "DAG_PB_CODE", "SHA_256_CODE", "digest", "create", "other", "self", "unknown", "equals", "base", "format", "input", "value", "encodeCID", "cidSymbol", "decode", "remainder", "specs", "prefixSize", "multihashBytes", "coerce", "digestBytes", "Digest", "initialBytes", "offset", "next", "i", "length", "codec", "multihashCode", "digestSize", "size", "multihashSize", "source", "prefix", "parseCIDtoBytes", "decoder", "base58btc", "base32", "base36", "toStringV0", "toStringV1", "codeOffset", "encodingLength", "hashOffset", "encodeTo", "bases", "identity_exports", "base2_exports", "base8_exports", "base10_exports", "base16_exports", "base32_exports", "base36_exports", "base58_exports", "base64_exports", "base256emoji_exports", "hashes", "sha2_browser_exports", "createCodec", "name", "prefix", "encode", "decode", "__name", "string", "buf", "str", "ascii", "i", "allocUnsafe", "BASES", "bases", "bases_default", "fromString", "string", "encoding", "base", "bases_default", "__name", "toString", "array", "encoding", "base", "bases_default", "__name", "HpkeError", "__name", "code", "message", "opts", "subtle", "open", "openBytes", "openRawBytes", "encrypt", "encryptBytes", "encryptToString", "decrypt", "decryptBytes", "decryptToString", "decryptFromString", "keypair", "message", "opts", "WRAPPED_LEN_PREFIX", "HpkeError", "wrappedLen", "ivStart", "ctStart", "NN", "AEAD_TAG_LENGTH", "wrapped", "iv", "ciphertext", "keyBytes", "key", "importAesKeyDecryptOnly", "pt", "subtle", "err", "__name", "bytes", "fromString", "plaintext", "validateKeysize", "keysize", "validateRawKeyBytes", "raw", "normalizeInfo", "info", "exportAesKeyBytes", "importAesKey", "extractable", "keySchedule", "sharedSecret", "empty", "pskIdHash", "labeledExtract", "HPKE_SUITE_ID", "infoHash", "ksContext", "concat", "MODE_BASE", "secret", "labeledExpand", "NK", "baseNonce", "ENC_LENGTH", "enc", "decap", "aeadOpen", "encryptKey", "recipient", "aesKey", "publicKey", "resolveRecipientPublicKey", "encap", "aeadSeal", "aesGcmKey", "subtle", "aeadSeal", "key", "nonce", "plaintext", "k", "ct", "__name", "aeadOpen", "ciphertext", "pt", "err", "HpkeError", "encryptBytes", "recipient", "message", "aesKey", "opts", "wrapped", "encryptKey", "iv", "NN", "concat", "i2osp", "WRAPPED_LEN_PREFIX", "encryptToString", "envelope", "toString", "hmac", "data", "extract", "salt", "ikm", "NSECRET", "expand", "prk", "info", "length", "out", "t", "offset", "counter", "take", "labeledExtract", "suiteId", "label", "labeledIkm", "HPKE_V1", "labeledExpand", "labeledInfo", "exportRawPublic", "importRawPublic", "raw", "ENC_LENGTH", "resolveRecipientPublicKey", "assertX25519Algorithm", "publicKey", "encoding", "fromString", "pair", "context", "code", "dh", "priv", "pub", "bits", "bytes", "b", "extractAndExpand", "dhBytes", "kemContext", "eaePrk", "KEM_SUITE_ID", "encap", "pkR", "eph", "enc", "pkRm", "decap", "keypair", "pkE", "i2osp", "n", "len", "out", "v", "i", "__name", "concat", "arrays", "total", "a", "offset", "KEM_ID", "KDF_ID", "AEAD_ID", "NSECRET", "NK", "NN", "ENC_LENGTH", "AEAD_TAG_LENGTH", "MODE_BASE", "HPKE_V1", "WRAPPED_LEN_PREFIX", "KEM_SUITE_ID", "concat", "i2osp", "HPKE_SUITE_ID", "KEY_ID_LABEL", "KEY_ID_NONCE_LENGTH"]
}