{
  "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": "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",
  "names": ["name", "encode", "length", "i", "j", "decode", "string", "name", "encode", "decode", "alphabet", "string", "encode", "decode", "identity_exports", "identity", "encode", "decode", "decode", "code", "code", "digest", "decode", "equals", "encode", "identity", "from", "name", "code", "encode", "digest", "name", "from", "base", "baseCache", "code", "digest", "equals", "base", "decode", "length", "cache", "cid", "identity_exports", "name", "encode", "decode", "string", "fromString", "string", "base", "toString", "base", "code", "fromString", "empty", "concat", "subtle", "concat", "toString", "length", "fromString", "code", "concat", "concat"]
}