simple-hpke 0.0.8 → 0.0.11

package/dist/constants.js

@@ -0,0 +1,1751 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name2 in all)
+    __defProp(target, name2, { get: all[name2], enumerable: true });
+};
+
+// node_modules/uint8arrays/dist/src/alloc.js
+function allocUnsafe(size = 0) {
+  return new Uint8Array(size);
+}
+__name(allocUnsafe, "allocUnsafe");
+
+// node_modules/multiformats/dist/src/bases/base10.js
+var base10_exports = {};
+__export(base10_exports, {
+  base10: () => base10
+});
+
+// node_modules/multiformats/dist/src/bytes.js
+var empty = new Uint8Array(0);
+function equals(aa, bb) {
+  if (aa === bb) {
+    return true;
+  }
+  if (aa.byteLength !== bb.byteLength) {
+    return false;
+  }
+  for (let ii = 0; ii < aa.byteLength; ii++) {
+    if (aa[ii] !== bb[ii]) {
+      return false;
+    }
+  }
+  return true;
+}
+__name(equals, "equals");
+function coerce(o) {
+  if (o instanceof Uint8Array && o.constructor.name === "Uint8Array") {
+    return o;
+  }
+  if (o instanceof ArrayBuffer) {
+    return new Uint8Array(o);
+  }
+  if (ArrayBuffer.isView(o)) {
+    return new Uint8Array(o.buffer, o.byteOffset, o.byteLength);
+  }
+  throw new Error("Unknown type, must be binary type");
+}
+__name(coerce, "coerce");
+function fromString(str) {
+  return new TextEncoder().encode(str);
+}
+__name(fromString, "fromString");
+function toString(b) {
+  return new TextDecoder().decode(b);
+}
+__name(toString, "toString");
+
+// node_modules/multiformats/dist/src/vendor/base-x.js
+function base(ALPHABET, name2) {
+  if (ALPHABET.length >= 255) {
+    throw new TypeError("Alphabet too long");
+  }
+  var BASE_MAP = new Uint8Array(256);
+  for (var j = 0; j < BASE_MAP.length; j++) {
+    BASE_MAP[j] = 255;
+  }
+  for (var i = 0; i < ALPHABET.length; i++) {
+    var x = ALPHABET.charAt(i);
+    var xc = x.charCodeAt(0);
+    if (BASE_MAP[xc] !== 255) {
+      throw new TypeError(x + " is ambiguous");
+    }
+    BASE_MAP[xc] = i;
+  }
+  var BASE = ALPHABET.length;
+  var LEADER = ALPHABET.charAt(0);
+  var FACTOR = Math.log(BASE) / Math.log(256);
+  var iFACTOR = Math.log(256) / Math.log(BASE);
+  function encode5(source) {
+    if (source instanceof Uint8Array)
+      ;
+    else if (ArrayBuffer.isView(source)) {
+      source = new Uint8Array(source.buffer, source.byteOffset, source.byteLength);
+    } else if (Array.isArray(source)) {
+      source = Uint8Array.from(source);
+    }
+    if (!(source instanceof Uint8Array)) {
+      throw new TypeError("Expected Uint8Array");
+    }
+    if (source.length === 0) {
+      return "";
+    }
+    var zeroes = 0;
+    var length2 = 0;
+    var pbegin = 0;
+    var pend = source.length;
+    while (pbegin !== pend && source[pbegin] === 0) {
+      pbegin++;
+      zeroes++;
+    }
+    var size = (pend - pbegin) * iFACTOR + 1 >>> 0;
+    var b58 = new Uint8Array(size);
+    while (pbegin !== pend) {
+      var carry = source[pbegin];
+      var i2 = 0;
+      for (var it1 = size - 1; (carry !== 0 || i2 < length2) && it1 !== -1; it1--, i2++) {
+        carry += 256 * b58[it1] >>> 0;
+        b58[it1] = carry % BASE >>> 0;
+        carry = carry / BASE >>> 0;
+      }
+      if (carry !== 0) {
+        throw new Error("Non-zero carry");
+      }
+      length2 = i2;
+      pbegin++;
+    }
+    var it2 = size - length2;
+    while (it2 !== size && b58[it2] === 0) {
+      it2++;
+    }
+    var str = LEADER.repeat(zeroes);
+    for (; it2 < size; ++it2) {
+      str += ALPHABET.charAt(b58[it2]);
+    }
+    return str;
+  }
+  __name(encode5, "encode");
+  function decodeUnsafe(source) {
+    if (typeof source !== "string") {
+      throw new TypeError("Expected String");
+    }
+    if (source.length === 0) {
+      return new Uint8Array();
+    }
+    var psz = 0;
+    if (source[psz] === " ") {
+      return;
+    }
+    var zeroes = 0;
+    var length2 = 0;
+    while (source[psz] === LEADER) {
+      zeroes++;
+      psz++;
+    }
+    var size = (source.length - psz) * FACTOR + 1 >>> 0;
+    var b256 = new Uint8Array(size);
+    while (source[psz]) {
+      var carry = BASE_MAP[source.charCodeAt(psz)];
+      if (carry === 255) {
+        return;
+      }
+      var i2 = 0;
+      for (var it3 = size - 1; (carry !== 0 || i2 < length2) && it3 !== -1; it3--, i2++) {
+        carry += BASE * b256[it3] >>> 0;
+        b256[it3] = carry % 256 >>> 0;
+        carry = carry / 256 >>> 0;
+      }
+      if (carry !== 0) {
+        throw new Error("Non-zero carry");
+      }
+      length2 = i2;
+      psz++;
+    }
+    if (source[psz] === " ") {
+      return;
+    }
+    var it4 = size - length2;
+    while (it4 !== size && b256[it4] === 0) {
+      it4++;
+    }
+    var vch = new Uint8Array(zeroes + (size - it4));
+    var j2 = zeroes;
+    while (it4 !== size) {
+      vch[j2++] = b256[it4++];
+    }
+    return vch;
+  }
+  __name(decodeUnsafe, "decodeUnsafe");
+  function decode6(string2) {
+    var buffer = decodeUnsafe(string2);
+    if (buffer) {
+      return buffer;
+    }
+    throw new Error(`Non-${name2} character`);
+  }
+  __name(decode6, "decode");
+  return {
+    encode: encode5,
+    decodeUnsafe,
+    decode: decode6
+  };
+}
+__name(base, "base");
+var src = base;
+var _brrp__multiformats_scope_baseX = src;
+var base_x_default = _brrp__multiformats_scope_baseX;
+
+// node_modules/multiformats/dist/src/bases/base.js
+var Encoder = class {
+  static {
+    __name(this, "Encoder");
+  }
+  name;
+  prefix;
+  baseEncode;
+  constructor(name2, prefix, baseEncode) {
+    this.name = name2;
+    this.prefix = prefix;
+    this.baseEncode = baseEncode;
+  }
+  encode(bytes) {
+    if (bytes instanceof Uint8Array) {
+      return `${this.prefix}${this.baseEncode(bytes)}`;
+    } else {
+      throw Error("Unknown type, must be binary type");
+    }
+  }
+};
+var Decoder = class {
+  static {
+    __name(this, "Decoder");
+  }
+  name;
+  prefix;
+  baseDecode;
+  prefixCodePoint;
+  constructor(name2, prefix, baseDecode) {
+    this.name = name2;
+    this.prefix = prefix;
+    const prefixCodePoint = prefix.codePointAt(0);
+    if (prefixCodePoint === void 0) {
+      throw new Error("Invalid prefix character");
+    }
+    this.prefixCodePoint = prefixCodePoint;
+    this.baseDecode = baseDecode;
+  }
+  decode(text) {
+    if (typeof text === "string") {
+      if (text.codePointAt(0) !== this.prefixCodePoint) {
+        throw Error(`Unable to decode multibase string ${JSON.stringify(text)}, ${this.name} decoder only supports inputs prefixed with ${this.prefix}`);
+      }
+      return this.baseDecode(text.slice(this.prefix.length));
+    } else {
+      throw Error("Can only multibase decode strings");
+    }
+  }
+  or(decoder) {
+    return or(this, decoder);
+  }
+};
+var ComposedDecoder = class {
+  static {
+    __name(this, "ComposedDecoder");
+  }
+  decoders;
+  constructor(decoders) {
+    this.decoders = decoders;
+  }
+  or(decoder) {
+    return or(this, decoder);
+  }
+  decode(input) {
+    const prefix = input[0];
+    const decoder = this.decoders[prefix];
+    if (decoder != null) {
+      return decoder.decode(input);
+    } else {
+      throw RangeError(`Unable to decode multibase string ${JSON.stringify(input)}, only inputs prefixed with ${Object.keys(this.decoders)} are supported`);
+    }
+  }
+};
+function or(left, right) {
+  return new ComposedDecoder({
+    ...left.decoders ?? { [left.prefix]: left },
+    ...right.decoders ?? { [right.prefix]: right }
+  });
+}
+__name(or, "or");
+var Codec = class {
+  static {
+    __name(this, "Codec");
+  }
+  name;
+  prefix;
+  baseEncode;
+  baseDecode;
+  encoder;
+  decoder;
+  constructor(name2, prefix, baseEncode, baseDecode) {
+    this.name = name2;
+    this.prefix = prefix;
+    this.baseEncode = baseEncode;
+    this.baseDecode = baseDecode;
+    this.encoder = new Encoder(name2, prefix, baseEncode);
+    this.decoder = new Decoder(name2, prefix, baseDecode);
+  }
+  encode(input) {
+    return this.encoder.encode(input);
+  }
+  decode(input) {
+    return this.decoder.decode(input);
+  }
+};
+function from({ name: name2, prefix, encode: encode5, decode: decode6 }) {
+  return new Codec(name2, prefix, encode5, decode6);
+}
+__name(from, "from");
+function baseX({ name: name2, prefix, alphabet: alphabet2 }) {
+  const { encode: encode5, decode: decode6 } = base_x_default(alphabet2, name2);
+  return from({
+    prefix,
+    name: name2,
+    encode: encode5,
+    decode: /* @__PURE__ */ __name((text) => coerce(decode6(text)), "decode")
+  });
+}
+__name(baseX, "baseX");
+function decode(string2, alphabetIdx, bitsPerChar, name2) {
+  let end = string2.length;
+  while (string2[end - 1] === "=") {
+    --end;
+  }
+  const out = new Uint8Array(end * bitsPerChar / 8 | 0);
+  let bits = 0;
+  let buffer = 0;
+  let written = 0;
+  for (let i = 0; i < end; ++i) {
+    const value = alphabetIdx[string2[i]];
+    if (value === void 0) {
+      throw new SyntaxError(`Non-${name2} character`);
+    }
+    buffer = buffer << bitsPerChar | value;
+    bits += bitsPerChar;
+    if (bits >= 8) {
+      bits -= 8;
+      out[written++] = 255 & buffer >> bits;
+    }
+  }
+  if (bits >= bitsPerChar || (255 & buffer << 8 - bits) !== 0) {
+    throw new SyntaxError("Unexpected end of data");
+  }
+  return out;
+}
+__name(decode, "decode");
+function encode(data, alphabet2, bitsPerChar) {
+  const pad = alphabet2[alphabet2.length - 1] === "=";
+  const mask = (1 << bitsPerChar) - 1;
+  let out = "";
+  let bits = 0;
+  let buffer = 0;
+  for (let i = 0; i < data.length; ++i) {
+    buffer = buffer << 8 | data[i];
+    bits += 8;
+    while (bits > bitsPerChar) {
+      bits -= bitsPerChar;
+      out += alphabet2[mask & buffer >> bits];
+    }
+  }
+  if (bits !== 0) {
+    out += alphabet2[mask & buffer << bitsPerChar - bits];
+  }
+  if (pad) {
+    while ((out.length * bitsPerChar & 7) !== 0) {
+      out += "=";
+    }
+  }
+  return out;
+}
+__name(encode, "encode");
+function createAlphabetIdx(alphabet2) {
+  const alphabetIdx = {};
+  for (let i = 0; i < alphabet2.length; ++i) {
+    alphabetIdx[alphabet2[i]] = i;
+  }
+  return alphabetIdx;
+}
+__name(createAlphabetIdx, "createAlphabetIdx");
+function rfc4648({ name: name2, prefix, bitsPerChar, alphabet: alphabet2 }) {
+  const alphabetIdx = createAlphabetIdx(alphabet2);
+  return from({
+    prefix,
+    name: name2,
+    encode(input) {
+      return encode(input, alphabet2, bitsPerChar);
+    },
+    decode(input) {
+      return decode(input, alphabetIdx, bitsPerChar, name2);
+    }
+  });
+}
+__name(rfc4648, "rfc4648");
+
+// node_modules/multiformats/dist/src/bases/base10.js
+var base10 = baseX({
+  prefix: "9",
+  name: "base10",
+  alphabet: "0123456789"
+});
+
+// node_modules/multiformats/dist/src/bases/base16.js
+var base16_exports = {};
+__export(base16_exports, {
+  base16: () => base16,
+  base16upper: () => base16upper
+});
+var base16 = rfc4648({
+  prefix: "f",
+  name: "base16",
+  alphabet: "0123456789abcdef",
+  bitsPerChar: 4
+});
+var base16upper = rfc4648({
+  prefix: "F",
+  name: "base16upper",
+  alphabet: "0123456789ABCDEF",
+  bitsPerChar: 4
+});
+
+// node_modules/multiformats/dist/src/bases/base2.js
+var base2_exports = {};
+__export(base2_exports, {
+  base2: () => base2
+});
+var base2 = rfc4648({
+  prefix: "0",
+  name: "base2",
+  alphabet: "01",
+  bitsPerChar: 1
+});
+
+// node_modules/multiformats/dist/src/bases/base256emoji.js
+var base256emoji_exports = {};
+__export(base256emoji_exports, {
+  base256emoji: () => base256emoji
+});
+var alphabet = Array.from("\u{1F680}\u{1FA90}\u2604\u{1F6F0}\u{1F30C}\u{1F311}\u{1F312}\u{1F313}\u{1F314}\u{1F315}\u{1F316}\u{1F317}\u{1F318}\u{1F30D}\u{1F30F}\u{1F30E}\u{1F409}\u2600\u{1F4BB}\u{1F5A5}\u{1F4BE}\u{1F4BF}\u{1F602}\u2764\u{1F60D}\u{1F923}\u{1F60A}\u{1F64F}\u{1F495}\u{1F62D}\u{1F618}\u{1F44D}\u{1F605}\u{1F44F}\u{1F601}\u{1F525}\u{1F970}\u{1F494}\u{1F496}\u{1F499}\u{1F622}\u{1F914}\u{1F606}\u{1F644}\u{1F4AA}\u{1F609}\u263A\u{1F44C}\u{1F917}\u{1F49C}\u{1F614}\u{1F60E}\u{1F607}\u{1F339}\u{1F926}\u{1F389}\u{1F49E}\u270C\u2728\u{1F937}\u{1F631}\u{1F60C}\u{1F338}\u{1F64C}\u{1F60B}\u{1F497}\u{1F49A}\u{1F60F}\u{1F49B}\u{1F642}\u{1F493}\u{1F929}\u{1F604}\u{1F600}\u{1F5A4}\u{1F603}\u{1F4AF}\u{1F648}\u{1F447}\u{1F3B6}\u{1F612}\u{1F92D}\u2763\u{1F61C}\u{1F48B}\u{1F440}\u{1F62A}\u{1F611}\u{1F4A5}\u{1F64B}\u{1F61E}\u{1F629}\u{1F621}\u{1F92A}\u{1F44A}\u{1F973}\u{1F625}\u{1F924}\u{1F449}\u{1F483}\u{1F633}\u270B\u{1F61A}\u{1F61D}\u{1F634}\u{1F31F}\u{1F62C}\u{1F643}\u{1F340}\u{1F337}\u{1F63B}\u{1F613}\u2B50\u2705\u{1F97A}\u{1F308}\u{1F608}\u{1F918}\u{1F4A6}\u2714\u{1F623}\u{1F3C3}\u{1F490}\u2639\u{1F38A}\u{1F498}\u{1F620}\u261D\u{1F615}\u{1F33A}\u{1F382}\u{1F33B}\u{1F610}\u{1F595}\u{1F49D}\u{1F64A}\u{1F639}\u{1F5E3}\u{1F4AB}\u{1F480}\u{1F451}\u{1F3B5}\u{1F91E}\u{1F61B}\u{1F534}\u{1F624}\u{1F33C}\u{1F62B}\u26BD\u{1F919}\u2615\u{1F3C6}\u{1F92B}\u{1F448}\u{1F62E}\u{1F646}\u{1F37B}\u{1F343}\u{1F436}\u{1F481}\u{1F632}\u{1F33F}\u{1F9E1}\u{1F381}\u26A1\u{1F31E}\u{1F388}\u274C\u270A\u{1F44B}\u{1F630}\u{1F928}\u{1F636}\u{1F91D}\u{1F6B6}\u{1F4B0}\u{1F353}\u{1F4A2}\u{1F91F}\u{1F641}\u{1F6A8}\u{1F4A8}\u{1F92C}\u2708\u{1F380}\u{1F37A}\u{1F913}\u{1F619}\u{1F49F}\u{1F331}\u{1F616}\u{1F476}\u{1F974}\u25B6\u27A1\u2753\u{1F48E}\u{1F4B8}\u2B07\u{1F628}\u{1F31A}\u{1F98B}\u{1F637}\u{1F57A}\u26A0\u{1F645}\u{1F61F}\u{1F635}\u{1F44E}\u{1F932}\u{1F920}\u{1F927}\u{1F4CC}\u{1F535}\u{1F485}\u{1F9D0}\u{1F43E}\u{1F352}\u{1F617}\u{1F911}\u{1F30A}\u{1F92F}\u{1F437}\u260E\u{1F4A7}\u{1F62F}\u{1F486}\u{1F446}\u{1F3A4}\u{1F647}\u{1F351}\u2744\u{1F334}\u{1F4A3}\u{1F438}\u{1F48C}\u{1F4CD}\u{1F940}\u{1F922}\u{1F445}\u{1F4A1}\u{1F4A9}\u{1F450}\u{1F4F8}\u{1F47B}\u{1F910}\u{1F92E}\u{1F3BC}\u{1F975}\u{1F6A9}\u{1F34E}\u{1F34A}\u{1F47C}\u{1F48D}\u{1F4E3}\u{1F942}");
+var alphabetBytesToChars = alphabet.reduce((p, c, i) => {
+  p[i] = c;
+  return p;
+}, []);
+var alphabetCharsToBytes = alphabet.reduce((p, c, i) => {
+  const codePoint = c.codePointAt(0);
+  if (codePoint == null) {
+    throw new Error(`Invalid character: ${c}`);
+  }
+  p[codePoint] = i;
+  return p;
+}, []);
+function encode2(data) {
+  return data.reduce((p, c) => {
+    p += alphabetBytesToChars[c];
+    return p;
+  }, "");
+}
+__name(encode2, "encode");
+function decode2(str) {
+  const byts = [];
+  for (const char of str) {
+    const codePoint = char.codePointAt(0);
+    if (codePoint == null) {
+      throw new Error(`Invalid character: ${char}`);
+    }
+    const byt = alphabetCharsToBytes[codePoint];
+    if (byt == null) {
+      throw new Error(`Non-base256emoji character: ${char}`);
+    }
+    byts.push(byt);
+  }
+  return new Uint8Array(byts);
+}
+__name(decode2, "decode");
+var base256emoji = from({
+  prefix: "\u{1F680}",
+  name: "base256emoji",
+  encode: encode2,
+  decode: decode2
+});
+
+// node_modules/multiformats/dist/src/bases/base32.js
+var base32_exports = {};
+__export(base32_exports, {
+  base32: () => base32,
+  base32hex: () => base32hex,
+  base32hexpad: () => base32hexpad,
+  base32hexpadupper: () => base32hexpadupper,
+  base32hexupper: () => base32hexupper,
+  base32pad: () => base32pad,
+  base32padupper: () => base32padupper,
+  base32upper: () => base32upper,
+  base32z: () => base32z
+});
+var base32 = rfc4648({
+  prefix: "b",
+  name: "base32",
+  alphabet: "abcdefghijklmnopqrstuvwxyz234567",
+  bitsPerChar: 5
+});
+var base32upper = rfc4648({
+  prefix: "B",
+  name: "base32upper",
+  alphabet: "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567",
+  bitsPerChar: 5
+});
+var base32pad = rfc4648({
+  prefix: "c",
+  name: "base32pad",
+  alphabet: "abcdefghijklmnopqrstuvwxyz234567=",
+  bitsPerChar: 5
+});
+var base32padupper = rfc4648({
+  prefix: "C",
+  name: "base32padupper",
+  alphabet: "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567=",
+  bitsPerChar: 5
+});
+var base32hex = rfc4648({
+  prefix: "v",
+  name: "base32hex",
+  alphabet: "0123456789abcdefghijklmnopqrstuv",
+  bitsPerChar: 5
+});
+var base32hexupper = rfc4648({
+  prefix: "V",
+  name: "base32hexupper",
+  alphabet: "0123456789ABCDEFGHIJKLMNOPQRSTUV",
+  bitsPerChar: 5
+});
+var base32hexpad = rfc4648({
+  prefix: "t",
+  name: "base32hexpad",
+  alphabet: "0123456789abcdefghijklmnopqrstuv=",
+  bitsPerChar: 5
+});
+var base32hexpadupper = rfc4648({
+  prefix: "T",
+  name: "base32hexpadupper",
+  alphabet: "0123456789ABCDEFGHIJKLMNOPQRSTUV=",
+  bitsPerChar: 5
+});
+var base32z = rfc4648({
+  prefix: "h",
+  name: "base32z",
+  alphabet: "ybndrfg8ejkmcpqxot1uwisza345h769",
+  bitsPerChar: 5
+});
+
+// node_modules/multiformats/dist/src/bases/base36.js
+var base36_exports = {};
+__export(base36_exports, {
+  base36: () => base36,
+  base36upper: () => base36upper
+});
+var base36 = baseX({
+  prefix: "k",
+  name: "base36",
+  alphabet: "0123456789abcdefghijklmnopqrstuvwxyz"
+});
+var base36upper = baseX({
+  prefix: "K",
+  name: "base36upper",
+  alphabet: "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+});
+
+// node_modules/multiformats/dist/src/bases/base58.js
+var base58_exports = {};
+__export(base58_exports, {
+  base58btc: () => base58btc,
+  base58flickr: () => base58flickr
+});
+var base58btc = baseX({
+  name: "base58btc",
+  prefix: "z",
+  alphabet: "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"
+});
+var base58flickr = baseX({
+  name: "base58flickr",
+  prefix: "Z",
+  alphabet: "123456789abcdefghijkmnopqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ"
+});
+
+// node_modules/multiformats/dist/src/bases/base64.js
+var base64_exports = {};
+__export(base64_exports, {
+  base64: () => base64,
+  base64pad: () => base64pad,
+  base64url: () => base64url,
+  base64urlpad: () => base64urlpad
+});
+var base64 = rfc4648({
+  prefix: "m",
+  name: "base64",
+  alphabet: "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/",
+  bitsPerChar: 6
+});
+var base64pad = rfc4648({
+  prefix: "M",
+  name: "base64pad",
+  alphabet: "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=",
+  bitsPerChar: 6
+});
+var base64url = rfc4648({
+  prefix: "u",
+  name: "base64url",
+  alphabet: "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_",
+  bitsPerChar: 6
+});
+var base64urlpad = rfc4648({
+  prefix: "U",
+  name: "base64urlpad",
+  alphabet: "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_=",
+  bitsPerChar: 6
+});
+
+// node_modules/multiformats/dist/src/bases/base8.js
+var base8_exports = {};
+__export(base8_exports, {
+  base8: () => base8
+});
+var base8 = rfc4648({
+  prefix: "7",
+  name: "base8",
+  alphabet: "01234567",
+  bitsPerChar: 3
+});
+
+// node_modules/multiformats/dist/src/bases/identity.js
+var identity_exports = {};
+__export(identity_exports, {
+  identity: () => identity
+});
+var identity = from({
+  prefix: "\0",
+  name: "identity",
+  encode: /* @__PURE__ */ __name((buf) => toString(buf), "encode"),
+  decode: /* @__PURE__ */ __name((str) => fromString(str), "decode")
+});
+
+// node_modules/multiformats/dist/src/codecs/json.js
+var textEncoder = new TextEncoder();
+var textDecoder = new TextDecoder();
+
+// node_modules/multiformats/dist/src/hashes/identity.js
+var identity_exports2 = {};
+__export(identity_exports2, {
+  identity: () => identity2
+});
+
+// node_modules/multiformats/dist/src/vendor/varint.js
+var encode_1 = encode3;
+var MSB = 128;
+var REST = 127;
+var MSBALL = ~REST;
+var INT = Math.pow(2, 31);
+function encode3(num, out, offset) {
+  out = out || [];
+  offset = offset || 0;
+  var oldOffset = offset;
+  while (num >= INT) {
+    out[offset++] = num & 255 | MSB;
+    num /= 128;
+  }
+  while (num & MSBALL) {
+    out[offset++] = num & 255 | MSB;
+    num >>>= 7;
+  }
+  out[offset] = num | 0;
+  encode3.bytes = offset - oldOffset + 1;
+  return out;
+}
+__name(encode3, "encode");
+var decode3 = read;
+var MSB$1 = 128;
+var REST$1 = 127;
+function read(buf, offset) {
+  var res = 0, offset = offset || 0, shift = 0, counter = offset, b, l = buf.length;
+  do {
+    if (counter >= l) {
+      read.bytes = 0;
+      throw new RangeError("Could not decode varint");
+    }
+    b = buf[counter++];
+    res += shift < 28 ? (b & REST$1) << shift : (b & REST$1) * Math.pow(2, shift);
+    shift += 7;
+  } while (b >= MSB$1);
+  read.bytes = counter - offset;
+  return res;
+}
+__name(read, "read");
+var N1 = Math.pow(2, 7);
+var N2 = Math.pow(2, 14);
+var N3 = Math.pow(2, 21);
+var N4 = Math.pow(2, 28);
+var N5 = Math.pow(2, 35);
+var N6 = Math.pow(2, 42);
+var N7 = Math.pow(2, 49);
+var N8 = Math.pow(2, 56);
+var N9 = Math.pow(2, 63);
+var length = /* @__PURE__ */ __name(function(value) {
+  return value < N1 ? 1 : value < N2 ? 2 : value < N3 ? 3 : value < N4 ? 4 : value < N5 ? 5 : value < N6 ? 6 : value < N7 ? 7 : value < N8 ? 8 : value < N9 ? 9 : 10;
+}, "length");
+var varint = {
+  encode: encode_1,
+  decode: decode3,
+  encodingLength: length
+};
+var _brrp_varint = varint;
+var varint_default = _brrp_varint;
+
+// node_modules/multiformats/dist/src/varint.js
+function decode4(data, offset = 0) {
+  const code2 = varint_default.decode(data, offset);
+  return [code2, varint_default.decode.bytes];
+}
+__name(decode4, "decode");
+function encodeTo(int, target, offset = 0) {
+  varint_default.encode(int, target, offset);
+  return target;
+}
+__name(encodeTo, "encodeTo");
+function encodingLength(int) {
+  return varint_default.encodingLength(int);
+}
+__name(encodingLength, "encodingLength");
+
+// node_modules/multiformats/dist/src/hashes/digest.js
+function create(code2, digest2) {
+  const size = digest2.byteLength;
+  const sizeOffset = encodingLength(code2);
+  const digestOffset = sizeOffset + encodingLength(size);
+  const bytes = new Uint8Array(digestOffset + size);
+  encodeTo(code2, bytes, 0);
+  encodeTo(size, bytes, sizeOffset);
+  bytes.set(digest2, digestOffset);
+  return new Digest(code2, size, digest2, bytes);
+}
+__name(create, "create");
+function decode5(multihash) {
+  const bytes = coerce(multihash);
+  const [code2, sizeOffset] = decode4(bytes);
+  const [size, digestOffset] = decode4(bytes.subarray(sizeOffset));
+  const digest2 = bytes.subarray(sizeOffset + digestOffset);
+  if (digest2.byteLength !== size) {
+    throw new Error("Incorrect length");
+  }
+  return new Digest(code2, size, digest2, bytes);
+}
+__name(decode5, "decode");
+function equals2(a, b) {
+  if (a === b) {
+    return true;
+  } else {
+    const data = b;
+    return a.code === data.code && a.size === data.size && data.bytes instanceof Uint8Array && equals(a.bytes, data.bytes);
+  }
+}
+__name(equals2, "equals");
+var Digest = class {
+  static {
+    __name(this, "Digest");
+  }
+  code;
+  size;
+  digest;
+  bytes;
+  /**
+   * Creates a multihash digest.
+   */
+  constructor(code2, size, digest2, bytes) {
+    this.code = code2;
+    this.size = size;
+    this.digest = digest2;
+    this.bytes = bytes;
+  }
+};
+
+// node_modules/multiformats/dist/src/hashes/identity.js
+var code = 0;
+var name = "identity";
+var encode4 = coerce;
+function digest(input, options) {
+  if (options?.truncate != null && options.truncate !== input.byteLength) {
+    if (options.truncate < 0 || options.truncate > input.byteLength) {
+      throw new Error(`Invalid truncate option, must be less than or equal to ${input.byteLength}`);
+    }
+    input = input.subarray(0, options.truncate);
+  }
+  return create(code, encode4(input));
+}
+__name(digest, "digest");
+var identity2 = { code, name, encode: encode4, digest };
+
+// node_modules/multiformats/dist/src/hashes/sha2-browser.js
+var sha2_browser_exports = {};
+__export(sha2_browser_exports, {
+  sha256: () => sha256,
+  sha512: () => sha512
+});
+
+// node_modules/multiformats/dist/src/hashes/hasher.js
+var DEFAULT_MIN_DIGEST_LENGTH = 20;
+function from2({ name: name2, code: code2, encode: encode5, minDigestLength, maxDigestLength }) {
+  return new Hasher(name2, code2, encode5, minDigestLength, maxDigestLength);
+}
+__name(from2, "from");
+var Hasher = class {
+  static {
+    __name(this, "Hasher");
+  }
+  name;
+  code;
+  encode;
+  minDigestLength;
+  maxDigestLength;
+  constructor(name2, code2, encode5, minDigestLength, maxDigestLength) {
+    this.name = name2;
+    this.code = code2;
+    this.encode = encode5;
+    this.minDigestLength = minDigestLength ?? DEFAULT_MIN_DIGEST_LENGTH;
+    this.maxDigestLength = maxDigestLength;
+  }
+  digest(input, options) {
+    if (options?.truncate != null) {
+      if (options.truncate < this.minDigestLength) {
+        throw new Error(`Invalid truncate option, must be greater than or equal to ${this.minDigestLength}`);
+      }
+      if (this.maxDigestLength != null && options.truncate > this.maxDigestLength) {
+        throw new Error(`Invalid truncate option, must be less than or equal to ${this.maxDigestLength}`);
+      }
+    }
+    if (input instanceof Uint8Array) {
+      const result = this.encode(input);
+      if (result instanceof Uint8Array) {
+        return createDigest(result, this.code, options?.truncate);
+      }
+      return result.then((digest2) => createDigest(digest2, this.code, options?.truncate));
+    } else {
+      throw Error("Unknown type, must be binary type");
+    }
+  }
+};
+function createDigest(digest2, code2, truncate) {
+  if (truncate != null && truncate !== digest2.byteLength) {
+    if (truncate > digest2.byteLength) {
+      throw new Error(`Invalid truncate option, must be less than or equal to ${digest2.byteLength}`);
+    }
+    digest2 = digest2.subarray(0, truncate);
+  }
+  return create(code2, digest2);
+}
+__name(createDigest, "createDigest");
+
+// node_modules/multiformats/dist/src/hashes/sha2-browser.js
+function sha(name2) {
+  return async (data) => new Uint8Array(await crypto.subtle.digest(name2, data));
+}
+__name(sha, "sha");
+var sha256 = from2({
+  name: "sha2-256",
+  code: 18,
+  encode: sha("SHA-256")
+});
+var sha512 = from2({
+  name: "sha2-512",
+  code: 19,
+  encode: sha("SHA-512")
+});
+
+// node_modules/multiformats/dist/src/cid.js
+function format(link, base3) {
+  const { bytes, version } = link;
+  switch (version) {
+    case 0:
+      return toStringV0(bytes, baseCache(link), base3 ?? base58btc.encoder);
+    default:
+      return toStringV1(bytes, baseCache(link), base3 ?? base32.encoder);
+  }
+}
+__name(format, "format");
+var cache = /* @__PURE__ */ new WeakMap();
+function baseCache(cid) {
+  const baseCache2 = cache.get(cid);
+  if (baseCache2 == null) {
+    const baseCache3 = /* @__PURE__ */ new Map();
+    cache.set(cid, baseCache3);
+    return baseCache3;
+  }
+  return baseCache2;
+}
+__name(baseCache, "baseCache");
+var CID = class _CID {
+  static {
+    __name(this, "CID");
+  }
+  code;
+  version;
+  multihash;
+  bytes;
+  "/";
+  /**
+   * @param version - Version of the CID
+   * @param code - Code of the codec content is encoded in, see https://github.com/multiformats/multicodec/blob/master/table.csv
+   * @param multihash - (Multi)hash of the of the content.
+   */
+  constructor(version, code2, multihash, bytes) {
+    this.code = code2;
+    this.version = version;
+    this.multihash = multihash;
+    this.bytes = bytes;
+    this["/"] = bytes;
+  }
+  /**
+   * Signalling `cid.asCID === cid` has been replaced with `cid['/'] === cid.bytes`
+   * please either use `CID.asCID(cid)` or switch to new signalling mechanism
+   *
+   * @deprecated
+   */
+  get asCID() {
+    return this;
+  }
+  // ArrayBufferView
+  get byteOffset() {
+    return this.bytes.byteOffset;
+  }
+  // ArrayBufferView
+  get byteLength() {
+    return this.bytes.byteLength;
+  }
+  toV0() {
+    switch (this.version) {
+      case 0: {
+        return this;
+      }
+      case 1: {
+        const { code: code2, multihash } = this;
+        if (code2 !== DAG_PB_CODE) {
+          throw new Error("Cannot convert a non dag-pb CID to CIDv0");
+        }
+        if (multihash.code !== SHA_256_CODE) {
+          throw new Error("Cannot convert non sha2-256 multihash CID to CIDv0");
+        }
+        return _CID.createV0(multihash);
+      }
+      default: {
+        throw Error(`Can not convert CID version ${this.version} to version 0. This is a bug please report`);
+      }
+    }
+  }
+  toV1() {
+    switch (this.version) {
+      case 0: {
+        const { code: code2, digest: digest2 } = this.multihash;
+        const multihash = create(code2, digest2);
+        return _CID.createV1(this.code, multihash);
+      }
+      case 1: {
+        return this;
+      }
+      default: {
+        throw Error(`Can not convert CID version ${this.version} to version 1. This is a bug please report`);
+      }
+    }
+  }
+  equals(other) {
+    return _CID.equals(this, other);
+  }
+  static equals(self, other) {
+    const unknown = other;
+    return unknown != null && self.code === unknown.code && self.version === unknown.version && equals2(self.multihash, unknown.multihash);
+  }
+  toString(base3) {
+    return format(this, base3);
+  }
+  toJSON() {
+    return { "/": format(this) };
+  }
+  link() {
+    return this;
+  }
+  [Symbol.toStringTag] = "CID";
+  // Legacy
+  [/* @__PURE__ */ Symbol.for("nodejs.util.inspect.custom")]() {
+    return `CID(${this.toString()})`;
+  }
+  /**
+   * Takes any input `value` and returns a `CID` instance if it was
+   * a `CID` otherwise returns `null`. If `value` is instanceof `CID`
+   * it will return value back. If `value` is not instance of this CID
+   * class, but is compatible CID it will return new instance of this
+   * `CID` class. Otherwise returns null.
+   *
+   * This allows two different incompatible versions of CID library to
+   * co-exist and interop as long as binary interface is compatible.
+   */
+  static asCID(input) {
+    if (input == null) {
+      return null;
+    }
+    const value = input;
+    if (value instanceof _CID) {
+      return value;
+    } else if (value["/"] != null && value["/"] === value.bytes || value.asCID === value) {
+      const { version, code: code2, multihash, bytes } = value;
+      return new _CID(version, code2, multihash, bytes ?? encodeCID(version, code2, multihash.bytes));
+    } else if (value[cidSymbol] === true) {
+      const { version, multihash, code: code2 } = value;
+      const digest2 = decode5(multihash);
+      return _CID.create(version, code2, digest2);
+    } else {
+      return null;
+    }
+  }
+  /**
+   * @param version - Version of the CID
+   * @param code - Code of the codec content is encoded in, see https://github.com/multiformats/multicodec/blob/master/table.csv
+   * @param digest - (Multi)hash of the of the content.
+   */
+  static create(version, code2, digest2) {
+    if (typeof code2 !== "number") {
+      throw new Error("String codecs are no longer supported");
+    }
+    if (!(digest2.bytes instanceof Uint8Array)) {
+      throw new Error("Invalid digest");
+    }
+    switch (version) {
+      case 0: {
+        if (code2 !== DAG_PB_CODE) {
+          throw new Error(`Version 0 CID must use dag-pb (code: ${DAG_PB_CODE}) block encoding`);
+        } else {
+          return new _CID(version, code2, digest2, digest2.bytes);
+        }
+      }
+      case 1: {
+        const bytes = encodeCID(version, code2, digest2.bytes);
+        return new _CID(version, code2, digest2, bytes);
+      }
+      default: {
+        throw new Error("Invalid version");
+      }
+    }
+  }
+  /**
+   * Simplified version of `create` for CIDv0.
+   */
+  static createV0(digest2) {
+    return _CID.create(0, DAG_PB_CODE, digest2);
+  }
+  /**
+   * Simplified version of `create` for CIDv1.
+   *
+   * @param code - Content encoding format code.
+   * @param digest - Multihash of the content.
+   */
+  static createV1(code2, digest2) {
+    return _CID.create(1, code2, digest2);
+  }
+  /**
+   * Decoded a CID from its binary representation. The byte array must contain
+   * only the CID with no additional bytes.
+   *
+   * An error will be thrown if the bytes provided do not contain a valid
+   * binary representation of a CID.
+   */
+  static decode(bytes) {
+    const [cid, remainder] = _CID.decodeFirst(bytes);
+    if (remainder.length !== 0) {
+      throw new Error("Incorrect length");
+    }
+    return cid;
+  }
+  /**
+   * Decoded a CID from its binary representation at the beginning of a byte
+   * array.
+   *
+   * Returns an array with the first element containing the CID and the second
+   * element containing the remainder of the original byte array. The remainder
+   * will be a zero-length byte array if the provided bytes only contained a
+   * binary CID representation.
+   */
+  static decodeFirst(bytes) {
+    const specs = _CID.inspectBytes(bytes);
+    const prefixSize = specs.size - specs.multihashSize;
+    const multihashBytes = coerce(bytes.subarray(prefixSize, prefixSize + specs.multihashSize));
+    if (multihashBytes.byteLength !== specs.multihashSize) {
+      throw new Error("Incorrect length");
+    }
+    const digestBytes = multihashBytes.subarray(specs.multihashSize - specs.digestSize);
+    const digest2 = new Digest(specs.multihashCode, specs.digestSize, digestBytes, multihashBytes);
+    const cid = specs.version === 0 ? _CID.createV0(digest2) : _CID.createV1(specs.codec, digest2);
+    return [cid, bytes.subarray(specs.size)];
+  }
+  /**
+   * Inspect the initial bytes of a CID to determine its properties.
+   *
+   * Involves decoding up to 4 varints. Typically this will require only 4 to 6
+   * bytes but for larger multicodec code values and larger multihash digest
+   * lengths these varints can be quite large. It is recommended that at least
+   * 10 bytes be made available in the `initialBytes` argument for a complete
+   * inspection.
+   */
+  static inspectBytes(initialBytes) {
+    let offset = 0;
+    const next = /* @__PURE__ */ __name(() => {
+      const [i, length2] = decode4(initialBytes.subarray(offset));
+      offset += length2;
+      return i;
+    }, "next");
+    let version = next();
+    let codec = DAG_PB_CODE;
+    if (version === 18) {
+      version = 0;
+      offset = 0;
+    } else {
+      codec = next();
+    }
+    if (version !== 0 && version !== 1) {
+      throw new RangeError(`Invalid CID version ${version}`);
+    }
+    const prefixSize = offset;
+    const multihashCode = next();
+    const digestSize = next();
+    const size = offset + digestSize;
+    const multihashSize = size - prefixSize;
+    return { version, codec, multihashCode, digestSize, multihashSize, size };
+  }
+  /**
+   * Takes cid in a string representation and creates an instance. If `base`
+   * decoder is not provided will use a default from the configuration. It will
+   * throw an error if encoding of the CID is not compatible with supplied (or
+   * a default decoder).
+   */
+  static parse(source, base3) {
+    const [prefix, bytes] = parseCIDtoBytes(source, base3);
+    const cid = _CID.decode(bytes);
+    if (cid.version === 0 && source[0] !== "Q") {
+      throw Error("Version 0 CID string must not include multibase prefix");
+    }
+    baseCache(cid).set(prefix, source);
+    return cid;
+  }
+};
+function parseCIDtoBytes(source, base3) {
+  switch (source[0]) {
+    // CIDv0 is parsed differently
+    case "Q": {
+      const decoder = base3 ?? base58btc;
+      return [
+        base58btc.prefix,
+        decoder.decode(`${base58btc.prefix}${source}`)
+      ];
+    }
+    case base58btc.prefix: {
+      const decoder = base3 ?? base58btc;
+      return [base58btc.prefix, decoder.decode(source)];
+    }
+    case base32.prefix: {
+      const decoder = base3 ?? base32;
+      return [base32.prefix, decoder.decode(source)];
+    }
+    case base36.prefix: {
+      const decoder = base3 ?? base36;
+      return [base36.prefix, decoder.decode(source)];
+    }
+    default: {
+      if (base3 == null) {
+        throw Error("To parse non base32, base36 or base58btc encoded CID multibase decoder must be provided");
+      }
+      return [source[0], base3.decode(source)];
+    }
+  }
+}
+__name(parseCIDtoBytes, "parseCIDtoBytes");
+function toStringV0(bytes, cache2, base3) {
+  const { prefix } = base3;
+  if (prefix !== base58btc.prefix) {
+    throw Error(`Cannot string encode V0 in ${base3.name} encoding`);
+  }
+  const cid = cache2.get(prefix);
+  if (cid == null) {
+    const cid2 = base3.encode(bytes).slice(1);
+    cache2.set(prefix, cid2);
+    return cid2;
+  } else {
+    return cid;
+  }
+}
+__name(toStringV0, "toStringV0");
+function toStringV1(bytes, cache2, base3) {
+  const { prefix } = base3;
+  const cid = cache2.get(prefix);
+  if (cid == null) {
+    const cid2 = base3.encode(bytes);
+    cache2.set(prefix, cid2);
+    return cid2;
+  } else {
+    return cid;
+  }
+}
+__name(toStringV1, "toStringV1");
+var DAG_PB_CODE = 112;
+var SHA_256_CODE = 18;
+function encodeCID(version, code2, multihash) {
+  const codeOffset = encodingLength(version);
+  const hashOffset = codeOffset + encodingLength(code2);
+  const bytes = new Uint8Array(hashOffset + multihash.byteLength);
+  encodeTo(version, bytes, 0);
+  encodeTo(code2, bytes, codeOffset);
+  bytes.set(multihash, hashOffset);
+  return bytes;
+}
+__name(encodeCID, "encodeCID");
+var cidSymbol = /* @__PURE__ */ Symbol.for("@ipld/js-cid/CID");
+
+// node_modules/multiformats/dist/src/basics.js
+var bases = { ...identity_exports, ...base2_exports, ...base8_exports, ...base10_exports, ...base16_exports, ...base32_exports, ...base36_exports, ...base58_exports, ...base64_exports, ...base256emoji_exports };
+var hashes = { ...sha2_browser_exports, ...identity_exports2 };
+
+// node_modules/uint8arrays/dist/src/util/bases.js
+function createCodec(name2, prefix, encode5, decode6) {
+  return {
+    name: name2,
+    prefix,
+    encoder: {
+      name: name2,
+      prefix,
+      encode: encode5
+    },
+    decoder: {
+      decode: decode6
+    }
+  };
+}
+__name(createCodec, "createCodec");
+var string = createCodec("utf8", "u", (buf) => {
+  const decoder = new TextDecoder("utf8");
+  return "u" + decoder.decode(buf);
+}, (str) => {
+  const encoder = new TextEncoder();
+  return encoder.encode(str.substring(1));
+});
+var ascii = createCodec("ascii", "a", (buf) => {
+  let string2 = "a";
+  for (let i = 0; i < buf.length; i++) {
+    string2 += String.fromCharCode(buf[i]);
+  }
+  return string2;
+}, (str) => {
+  str = str.substring(1);
+  const buf = allocUnsafe(str.length);
+  for (let i = 0; i < str.length; i++) {
+    buf[i] = str.charCodeAt(i);
+  }
+  return buf;
+});
+var BASES = {
+  utf8: string,
+  "utf-8": string,
+  hex: bases.base16,
+  latin1: ascii,
+  ascii,
+  binary: ascii,
+  ...bases
+};
+var bases_default = BASES;
+
+// node_modules/uint8arrays/dist/src/from-string.js
+function fromString2(string2, encoding = "utf8") {
+  const base3 = bases_default[encoding];
+  if (base3 == null) {
+    throw new Error(`Unsupported encoding "${encoding}"`);
+  }
+  return base3.decoder.decode(`${base3.prefix}${string2}`);
+}
+__name(fromString2, "fromString");
+
+// node_modules/uint8arrays/dist/src/to-string.js
+function toString2(array, encoding = "utf8") {
+  const base3 = bases_default[encoding];
+  if (base3 == null) {
+    throw new Error(`Unsupported encoding "${encoding}"`);
+  }
+  return base3.encoder.encode(array).substring(1);
+}
+__name(toString2, "toString");
+
+// src/index.ts
+var subtle = globalThis.crypto.subtle;
+async function seal(recipient, aesKey, opts) {
+  const info = normalizeInfo(opts?.info);
+  let keyBytes;
+  if (aesKey instanceof Uint8Array) {
+    validateRawKeyBytes(aesKey);
+    keyBytes = aesKey;
+  } else if (aesKey) {
+    keyBytes = await exportAesKeyBytes(aesKey);
+    validateRawKeyBytes(keyBytes);
+  } else {
+    const keysize = opts?.keysize ?? 256;
+    validateKeysize(keysize);
+    keyBytes = globalThis.crypto.getRandomValues(
+      new Uint8Array(keysize / 8)
+    );
+  }
+  const publicKey = await resolveRecipientPublicKey(recipient);
+  const { sharedSecret, enc } = await encap(publicKey);
+  const { key, baseNonce } = await keySchedule(sharedSecret, info);
+  const ciphertext = await aeadSeal(key, baseNonce, keyBytes);
+  const wrapped = concat2(enc, ciphertext);
+  const aesGcmKey = await importAesKey(keyBytes);
+  return { wrapped, key: aesGcmKey };
+}
+__name(seal, "seal");
+var open = Object.assign(openBytes, {
+  raw: openRawBytes
+});
+async function openBytes(keypair, wrapped, opts) {
+  const keyBytes = await openRawBytes(keypair, wrapped, opts);
+  return importAesKey(keyBytes);
+}
+__name(openBytes, "openBytes");
+async function openRawBytes(keypair, wrapped, opts) {
+  if (wrapped.byteLength < ENC_LENGTH + AEAD_TAG_LENGTH) {
+    throw new Error("malformed envelope: too short");
+  }
+  const info = normalizeInfo(opts?.info);
+  const enc = wrapped.slice(0, ENC_LENGTH);
+  const ciphertext = wrapped.slice(ENC_LENGTH);
+  const sharedSecret = await decap(enc, keypair);
+  const { key, baseNonce } = await keySchedule(sharedSecret, info);
+  return aeadOpen(key, baseNonce, ciphertext);
+}
+__name(openRawBytes, "openRawBytes");
+var encrypt = Object.assign(encryptBytes, {
+  asString: encryptToString
+});
+var decrypt = Object.assign(decryptBytes, {
+  asString: decryptToString,
+  fromString: decryptFromString
+});
+async function decryptBytes(keypair, message, opts) {
+  if (message.byteLength < WRAPPED_LEN_PREFIX) {
+    throw new Error("malformed message: too short");
+  }
+  const wrappedLen = message[0] << 8 | message[1];
+  const ivStart = WRAPPED_LEN_PREFIX + wrappedLen;
+  const ctStart = ivStart + NN;
+  if (message.byteLength < ctStart + AEAD_TAG_LENGTH) {
+    throw new Error("malformed message: too short");
+  }
+  const wrapped = message.slice(WRAPPED_LEN_PREFIX, ivStart);
+  const iv = message.slice(ivStart, ctStart);
+  const ciphertext = message.slice(ctStart);
+  const keyBytes = await openRawBytes(
+    keypair,
+    wrapped,
+    opts?.info !== void 0 ? { info: opts.info } : void 0
+  );
+  const key = await importAesKeyDecryptOnly(keyBytes);
+  const pt = await subtle.decrypt(
+    { name: "AES-GCM", iv },
+    key,
+    ciphertext
+  );
+  return new Uint8Array(pt);
+}
+__name(decryptBytes, "decryptBytes");
+async function decryptToString(keypair, message, opts) {
+  const bytes = await decryptBytes(keypair, message, opts);
+  return new TextDecoder().decode(bytes);
+}
+__name(decryptToString, "decryptToString");
+async function decryptFromString(keypair, message, opts) {
+  const bytes = fromString2(message, "base64url");
+  const plaintext = await decryptBytes(
+    keypair,
+    bytes,
+    opts?.info !== void 0 ? { info: opts.info } : void 0
+  );
+  return opts?.buffer ? plaintext : new TextDecoder().decode(plaintext);
+}
+__name(decryptFromString, "decryptFromString");
+function validateKeysize(keysize) {
+  if (keysize !== 128 && keysize !== 256) {
+    throw new Error(
+      `invalid keysize: ${keysize} (expected 128 or 256)`
+    );
+  }
+}
+__name(validateKeysize, "validateKeysize");
+function validateRawKeyBytes(raw) {
+  if (raw.length !== 16 && raw.length !== 32) {
+    throw new Error(
+      `invalid aesKey length: ${raw.length} bytes (expected 16 or 32)`
+    );
+  }
+}
+__name(validateRawKeyBytes, "validateRawKeyBytes");
+function normalizeInfo(info) {
+  if (info === void 0 || info === null) return new Uint8Array(0);
+  if (typeof info === "string") return new TextEncoder().encode(info);
+  return info;
+}
+__name(normalizeInfo, "normalizeInfo");
+async function exportAesKeyBytes(key) {
+  if (!key.extractable) {
+    throw new Error(
+      "aesKey must be extractable: its raw bytes are what get sealed"
+    );
+  }
+  return new Uint8Array(await subtle.exportKey("raw", key));
+}
+__name(exportAesKeyBytes, "exportAesKeyBytes");
+async function importAesKey(raw) {
+  return subtle.importKey(
+    "raw",
+    raw,
+    { name: "AES-GCM" },
+    true,
+    ["encrypt", "decrypt"]
+  );
+}
+__name(importAesKey, "importAesKey");
+async function importAesKeyDecryptOnly(raw) {
+  return subtle.importKey(
+    "raw",
+    raw,
+    { name: "AES-GCM" },
+    false,
+    ["decrypt"]
+  );
+}
+__name(importAesKeyDecryptOnly, "importAesKeyDecryptOnly");
+async function keySchedule(sharedSecret, info) {
+  const empty2 = new Uint8Array(0);
+  const pskIdHash = await labeledExtract(
+    HPKE_SUITE_ID,
+    empty2,
+    "psk_id_hash",
+    empty2
+  );
+  const infoHash = await labeledExtract(
+    HPKE_SUITE_ID,
+    empty2,
+    "info_hash",
+    info
+  );
+  const ksContext = concat2(new Uint8Array([MODE_BASE]), pskIdHash, infoHash);
+  const secret = await labeledExtract(
+    HPKE_SUITE_ID,
+    sharedSecret,
+    "secret",
+    empty2
+  );
+  const key = await labeledExpand(
+    HPKE_SUITE_ID,
+    secret,
+    "key",
+    ksContext,
+    NK
+  );
+  const baseNonce = await labeledExpand(
+    HPKE_SUITE_ID,
+    secret,
+    "base_nonce",
+    ksContext,
+    NN
+  );
+  return { key, baseNonce };
+}
+__name(keySchedule, "keySchedule");
+
+// src/util.ts
+var subtle2 = globalThis.crypto.subtle;
+async function aeadSeal(key, nonce, plaintext) {
+  const k = await subtle2.importKey(
+    "raw",
+    key,
+    { name: "AES-GCM" },
+    false,
+    ["encrypt"]
+  );
+  const ct = await subtle2.encrypt(
+    { name: "AES-GCM", iv: nonce },
+    k,
+    plaintext
+  );
+  return new Uint8Array(ct);
+}
+__name(aeadSeal, "aeadSeal");
+async function aeadOpen(key, nonce, ciphertext) {
+  const k = await subtle2.importKey(
+    "raw",
+    key,
+    { name: "AES-GCM" },
+    false,
+    ["decrypt"]
+  );
+  const pt = await subtle2.decrypt(
+    { name: "AES-GCM", iv: nonce },
+    k,
+    ciphertext
+  );
+  return new Uint8Array(pt);
+}
+__name(aeadOpen, "aeadOpen");
+async function encryptBytes(recipient, message, aesKey, opts) {
+  const plaintext = typeof message === "string" ? new TextEncoder().encode(message) : message;
+  const { wrapped, key } = await seal(recipient, aesKey, opts);
+  const iv = globalThis.crypto.getRandomValues(new Uint8Array(NN));
+  const ct = new Uint8Array(await subtle2.encrypt(
+    { name: "AES-GCM", iv },
+    key,
+    plaintext
+  ));
+  return concat2(i2osp(wrapped.length, WRAPPED_LEN_PREFIX), wrapped, iv, ct);
+}
+__name(encryptBytes, "encryptBytes");
+async function encryptToString(recipient, message, aesKey, opts) {
+  const envelope = await encryptBytes(recipient, message, aesKey, opts);
+  return toString2(envelope, opts?.encoding ?? "base64url");
+}
+__name(encryptToString, "encryptToString");
+async function hmac(key, data) {
+  const k = await subtle2.importKey(
+    "raw",
+    key,
+    { name: "HMAC", hash: "SHA-256" },
+    false,
+    ["sign"]
+  );
+  return new Uint8Array(await subtle2.sign("HMAC", k, data));
+}
+__name(hmac, "hmac");
+async function extract(salt, ikm) {
+  const key = salt.length === 0 ? new Uint8Array(NSECRET) : salt;
+  return hmac(key, ikm);
+}
+__name(extract, "extract");
+async function expand(prk, info, length2) {
+  const out = new Uint8Array(length2);
+  let t = new Uint8Array(0);
+  let offset = 0;
+  let counter = 1;
+  while (offset < length2) {
+    t = await hmac(prk, concat2(t, info, i2osp(counter, 1)));
+    const take = Math.min(t.length, length2 - offset);
+    out.set(t.subarray(0, take), offset);
+    offset += take;
+    counter++;
+  }
+  return out;
+}
+__name(expand, "expand");
+async function labeledExtract(suiteId, salt, label, ikm) {
+  const labeledIkm = concat2(
+    HPKE_V1,
+    suiteId,
+    new TextEncoder().encode(label),
+    ikm
+  );
+  return extract(salt, labeledIkm);
+}
+__name(labeledExtract, "labeledExtract");
+async function labeledExpand(suiteId, prk, label, info, length2) {
+  const labeledInfo = concat2(
+    i2osp(length2, 2),
+    HPKE_V1,
+    suiteId,
+    new TextEncoder().encode(label),
+    info
+  );
+  return expand(prk, labeledInfo, length2);
+}
+__name(labeledExpand, "labeledExpand");
+async function exportRawPublic(key) {
+  return new Uint8Array(await subtle2.exportKey("raw", key));
+}
+__name(exportRawPublic, "exportRawPublic");
+async function importRawPublic(raw) {
+  if (raw.length !== ENC_LENGTH) {
+    throw new Error(
+      `invalid public key length: ${raw.length} bytes (expected ${ENC_LENGTH})`
+    );
+  }
+  return subtle2.importKey(
+    "raw",
+    raw,
+    { name: "X25519" },
+    true,
+    []
+  );
+}
+__name(importRawPublic, "importRawPublic");
+async function resolveRecipientPublicKey(recipient) {
+  if (recipient instanceof Uint8Array) {
+    return importRawPublic(recipient);
+  }
+  if (recipient instanceof CryptoKey) {
+    if (recipient.type !== "public") {
+      throw new Error("recipient CryptoKey must be a public key");
+    }
+    assertX25519Algorithm(recipient, "recipient CryptoKey");
+    return recipient;
+  }
+  if (typeof recipient.publicKey === "string") {
+    const { publicKey, encoding } = recipient;
+    return importRawPublic(fromString2(publicKey, encoding ?? "base64url"));
+  }
+  const pair = recipient;
+  if (pair.publicKey instanceof CryptoKey) {
+    if (pair.publicKey.type !== "public") {
+      throw new Error("recipient keypair publicKey must be a public key");
+    }
+    assertX25519Algorithm(pair.publicKey, "recipient keypair publicKey");
+    return pair.publicKey;
+  }
+  throw new Error("unrecognized recipient key form");
+}
+__name(resolveRecipientPublicKey, "resolveRecipientPublicKey");
+function assertX25519Algorithm(key, context) {
+  if (key.algorithm.name !== "X25519") {
+    throw new Error(
+      `${context} must be an X25519 key (got ${key.algorithm.name})`
+    );
+  }
+}
+__name(assertX25519Algorithm, "assertX25519Algorithm");
+async function dh(priv, pub) {
+  const bits = await subtle2.deriveBits(
+    { name: "X25519", public: pub },
+    priv,
+    256
+  );
+  const bytes = new Uint8Array(bits);
+  if (bytes.every((b) => b === 0)) {
+    throw new Error(
+      "X25519 shared secret is all-zero (small-order public key?)"
+    );
+  }
+  return bytes;
+}
+__name(dh, "dh");
+async function extractAndExpand(dhBytes, kemContext) {
+  const eaePrk = await labeledExtract(
+    KEM_SUITE_ID,
+    new Uint8Array(0),
+    "eae_prk",
+    dhBytes
+  );
+  return labeledExpand(
+    KEM_SUITE_ID,
+    eaePrk,
+    "shared_secret",
+    kemContext,
+    NSECRET
+  );
+}
+__name(extractAndExpand, "extractAndExpand");
+async function encap(pkR) {
+  const eph = await subtle2.generateKey(
+    { name: "X25519" },
+    false,
+    ["deriveBits"]
+  );
+  const dhBytes = await dh(eph.privateKey, pkR);
+  const enc = await exportRawPublic(eph.publicKey);
+  const pkRm = await exportRawPublic(pkR);
+  const kemContext = concat2(enc, pkRm);
+  const sharedSecret = await extractAndExpand(dhBytes, kemContext);
+  return { sharedSecret, enc };
+}
+__name(encap, "encap");
+async function decap(enc, keypair) {
+  if (keypair.privateKey.type !== "private") {
+    throw new Error("keypair.privateKey must be a private key");
+  }
+  assertX25519Algorithm(keypair.privateKey, "keypair.privateKey");
+  const pkE = await subtle2.importKey(
+    "raw",
+    enc,
+    { name: "X25519" },
+    false,
+    []
+  );
+  const dhBytes = await dh(keypair.privateKey, pkE);
+  const pkRm = await exportRawPublic(keypair.publicKey);
+  const kemContext = concat2(enc, pkRm);
+  return extractAndExpand(dhBytes, kemContext);
+}
+__name(decap, "decap");
+function i2osp(n, len) {
+  const out = new Uint8Array(len);
+  let v = n;
+  for (let i = len - 1; i >= 0; i--) {
+    out[i] = v & 255;
+    v = Math.floor(v / 256);
+  }
+  return out;
+}
+__name(i2osp, "i2osp");
+function concat2(...arrays) {
+  let total = 0;
+  for (const a of arrays) total += a.length;
+  const out = new Uint8Array(total);
+  let offset = 0;
+  for (const a of arrays) {
+    out.set(a, offset);
+    offset += a.length;
+  }
+  return out;
+}
+__name(concat2, "concat");
+
+// src/constants.ts
+var KEM_ID = 32;
+var KDF_ID = 1;
+var AEAD_ID = 2;
+var NSECRET = 32;
+var NK = 32;
+var NN = 12;
+var ENC_LENGTH = 32;
+var AEAD_TAG_LENGTH = 16;
+var MODE_BASE = 0;
+var HPKE_V1 = new TextEncoder().encode("HPKE-v1");
+var WRAPPED_LEN_PREFIX = 2;
+var KEM_SUITE_ID = concat2(
+  new TextEncoder().encode("KEM"),
+  i2osp(KEM_ID, 2)
+);
+var HPKE_SUITE_ID = concat2(
+  new TextEncoder().encode("HPKE"),
+  i2osp(KEM_ID, 2),
+  i2osp(KDF_ID, 2),
+  i2osp(AEAD_ID, 2)
+);
+export {
+  AEAD_ID,
+  AEAD_TAG_LENGTH,
+  ENC_LENGTH,
+  HPKE_SUITE_ID,
+  HPKE_V1,
+  KDF_ID,
+  KEM_ID,
+  KEM_SUITE_ID,
+  MODE_BASE,
+  NK,
+  NN,
+  NSECRET,
+  WRAPPED_LEN_PREFIX
+};
+//# sourceMappingURL=constants.js.map