@atproto/crypto 0.3.0 → 0.3.1-next.0

package/dist/index.js

@@ -1,3352 +1,28 @@
 "use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name2 in all)
-    __defProp(target, name2, { get: all[name2], enumerable: true });
-};
-var __copyProps = (to, from3, except, desc) => {
-  if (from3 && typeof from3 === "object" || typeof from3 === "function") {
-    for (let key of __getOwnPropNames(from3))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from3[key], enumerable: !(desc = __getOwnPropDesc(from3, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod2, isNodeMode, target) => (target = mod2 != null ? __create(__getProtoOf(mod2)) : {}, __copyProps(isNodeMode || !mod2 || !mod2.__esModule ? __defProp(target, "default", { value: mod2, enumerable: true }) : target, mod2));
-var __toCommonJS = (mod2) => __copyProps(__defProp({}, "__esModule", { value: true }), mod2);
-
-// src/index.ts
-var src_exports2 = {};
-__export(src_exports2, {
-  BASE58_MULTIBASE_PREFIX: () => BASE58_MULTIBASE_PREFIX,
-  DID_KEY_PREFIX: () => DID_KEY_PREFIX,
-  P256Keypair: () => P256Keypair,
-  P256_DID_PREFIX: () => P256_DID_PREFIX,
-  P256_JWT_ALG: () => P256_JWT_ALG,
-  SECP256K1_DID_PREFIX: () => SECP256K1_DID_PREFIX,
-  SECP256K1_JWT_ALG: () => SECP256K1_JWT_ALG,
-  Secp256k1Keypair: () => Secp256k1Keypair,
-  bytesToMultibase: () => bytesToMultibase,
-  formatDidKey: () => formatDidKey,
-  formatMultikey: () => formatMultikey,
-  multibaseToBytes: () => multibaseToBytes,
-  p256Plugin: () => p256Plugin,
-  parseDidKey: () => parseDidKey,
-  parseMultikey: () => parseMultikey,
-  randomBytes: () => randomBytes2,
-  randomIntFromSeed: () => randomIntFromSeed,
-  randomStr: () => randomStr,
-  secp256k1Plugin: () => secp256k1Plugin,
-  sha256: () => sha2563,
-  verifySignature: () => verifySignature,
-  verifySignatureUtf8: () => verifySignatureUtf8
-});
-module.exports = __toCommonJS(src_exports2);
-
-// src/const.ts
-var P256_DID_PREFIX = new Uint8Array([128, 36]);
-var SECP256K1_DID_PREFIX = new Uint8Array([231, 1]);
-var BASE58_MULTIBASE_PREFIX = "z";
-var DID_KEY_PREFIX = "did:key:";
-var P256_JWT_ALG = "ES256";
-var SECP256K1_JWT_ALG = "ES256K";
-
-// ../../node_modules/.pnpm/uint8arrays@3.0.0/node_modules/uint8arrays/esm/src/concat.js
-function concat(arrays, length2) {
-  if (!length2) {
-    length2 = arrays.reduce((acc, curr) => acc + curr.length, 0);
-  }
-  const output2 = new Uint8Array(length2);
-  let offset = 0;
-  for (const arr of arrays) {
-    output2.set(arr, offset);
-    offset += arr.length;
-  }
-  return output2;
-}
-
-// ../../node_modules/.pnpm/uint8arrays@3.0.0/node_modules/uint8arrays/esm/src/equals.js
-function equals(a, b) {
-  if (a === b) {
-    return true;
-  }
-  if (a.byteLength !== b.byteLength) {
-    return false;
-  }
-  for (let i = 0; i < a.byteLength; i++) {
-    if (a[i] !== b[i]) {
-      return false;
-    }
-  }
-  return true;
-}
-
-// ../../node_modules/.pnpm/multiformats@9.9.0/node_modules/multiformats/esm/src/bases/identity.js
-var identity_exports = {};
-__export(identity_exports, {
-  identity: () => identity
-});
-
-// ../../node_modules/.pnpm/multiformats@9.9.0/node_modules/multiformats/esm/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;
-  }
-  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;
-  }
-  function decode6(string2) {
-    var buffer = decodeUnsafe(string2);
-    if (buffer) {
-      return buffer;
-    }
-    throw new Error(`Non-${name2} character`);
-  }
-  return {
-    encode: encode5,
-    decodeUnsafe,
-    decode: decode6
-  };
-}
-var src = base;
-var _brrp__multiformats_scope_baseX = src;
-var base_x_default = _brrp__multiformats_scope_baseX;
-
-// ../../node_modules/.pnpm/multiformats@9.9.0/node_modules/multiformats/esm/src/bytes.js
-var empty = new Uint8Array(0);
-var equals2 = (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;
-};
-var 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");
-};
-var fromString = (str) => new TextEncoder().encode(str);
-var toString = (b) => new TextDecoder().decode(b);
-
-// ../../node_modules/.pnpm/multiformats@9.9.0/node_modules/multiformats/esm/src/bases/base.js
-var Encoder = class {
-  constructor(name2, prefix, baseEncode) {
-    this.name = name2;
-    this.prefix = prefix;
-    this.baseEncode = baseEncode;
-  }
-  encode(bytes2) {
-    if (bytes2 instanceof Uint8Array) {
-      return `${this.prefix}${this.baseEncode(bytes2)}`;
-    } else {
-      throw Error("Unknown type, must be binary type");
-    }
-  }
-};
-var Decoder = class {
-  constructor(name2, prefix, baseDecode) {
-    this.name = name2;
-    this.prefix = prefix;
-    if (prefix.codePointAt(0) === void 0) {
-      throw new Error("Invalid prefix character");
-    }
-    this.prefixCodePoint = prefix.codePointAt(0);
-    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 {
-  constructor(decoders) {
-    this.decoders = decoders;
-  }
-  or(decoder) {
-    return or(this, decoder);
-  }
-  decode(input) {
-    const prefix = input[0];
-    const decoder = this.decoders[prefix];
-    if (decoder) {
-      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`);
-    }
-  }
-};
-var or = (left, right) => new ComposedDecoder({
-  ...left.decoders || { [left.prefix]: left },
-  ...right.decoders || { [right.prefix]: right }
-});
-var Codec = class {
-  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);
-  }
-};
-var from = ({ name: name2, prefix, encode: encode5, decode: decode6 }) => new Codec(name2, prefix, encode5, decode6);
-var baseX = ({ prefix, name: name2, alphabet: alphabet2 }) => {
-  const { encode: encode5, decode: decode6 } = base_x_default(alphabet2, name2);
-  return from({
-    prefix,
-    name: name2,
-    encode: encode5,
-    decode: (text) => coerce(decode6(text))
-  });
-};
-var decode = (string2, alphabet2, bitsPerChar, name2) => {
-  const codes = {};
-  for (let i = 0; i < alphabet2.length; ++i) {
-    codes[alphabet2[i]] = i;
-  }
-  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 = codes[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) {
-    throw new SyntaxError("Unexpected end of data");
-  }
-  return out;
-};
-var 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) {
-    out += alphabet2[mask & buffer << bitsPerChar - bits];
-  }
-  if (pad) {
-    while (out.length * bitsPerChar & 7) {
-      out += "=";
-    }
-  }
-  return out;
-};
-var rfc4648 = ({ name: name2, prefix, bitsPerChar, alphabet: alphabet2 }) => {
-  return from({
-    prefix,
-    name: name2,
-    encode(input) {
-      return encode(input, alphabet2, bitsPerChar);
-    },
-    decode(input) {
-      return decode(input, alphabet2, bitsPerChar, name2);
-    }
-  });
-};
-
-// ../../node_modules/.pnpm/multiformats@9.9.0/node_modules/multiformats/esm/src/bases/identity.js
-var identity = from({
-  prefix: "\0",
-  name: "identity",
-  encode: (buf) => toString(buf),
-  decode: (str) => fromString(str)
-});
-
-// ../../node_modules/.pnpm/multiformats@9.9.0/node_modules/multiformats/esm/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/.pnpm/multiformats@9.9.0/node_modules/multiformats/esm/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/.pnpm/multiformats@9.9.0/node_modules/multiformats/esm/src/bases/base10.js
-var base10_exports = {};
-__export(base10_exports, {
-  base10: () => base10
-});
-var base10 = baseX({
-  prefix: "9",
-  name: "base10",
-  alphabet: "0123456789"
-});
-
-// ../../node_modules/.pnpm/multiformats@9.9.0/node_modules/multiformats/esm/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/.pnpm/multiformats@9.9.0/node_modules/multiformats/esm/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/.pnpm/multiformats@9.9.0/node_modules/multiformats/esm/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/.pnpm/multiformats@9.9.0/node_modules/multiformats/esm/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/.pnpm/multiformats@9.9.0/node_modules/multiformats/esm/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/.pnpm/multiformats@9.9.0/node_modules/multiformats/esm/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) => {
-  p[c.codePointAt(0)] = i;
-  return p;
-}, []);
-function encode2(data) {
-  return data.reduce((p, c) => {
-    p += alphabetBytesToChars[c];
-    return p;
-  }, "");
-}
-function decode2(str) {
-  const byts = [];
-  for (const char of str) {
-    const byt = alphabetCharsToBytes[char.codePointAt(0)];
-    if (byt === void 0) {
-      throw new Error(`Non-base256emoji character: ${char}`);
-    }
-    byts.push(byt);
-  }
-  return new Uint8Array(byts);
-}
-var base256emoji = from({
-  prefix: "\u{1F680}",
-  name: "base256emoji",
-  encode: encode2,
-  decode: decode2
-});
-
-// ../../node_modules/.pnpm/multiformats@9.9.0/node_modules/multiformats/esm/src/hashes/sha2.js
-var sha2_exports = {};
-__export(sha2_exports, {
-  sha256: () => sha256,
-  sha512: () => sha512
-});
-var import_crypto = __toESM(require("crypto"), 1);
-
-// ../../node_modules/.pnpm/multiformats@9.9.0/node_modules/multiformats/esm/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;
-}
-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;
-}
-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 = 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;
-};
-var varint = {
-  encode: encode_1,
-  decode: decode3,
-  encodingLength: length
-};
-var _brrp_varint = varint;
-var varint_default = _brrp_varint;
-
-// ../../node_modules/.pnpm/multiformats@9.9.0/node_modules/multiformats/esm/src/varint.js
-var decode4 = (data, offset = 0) => {
-  const code2 = varint_default.decode(data, offset);
-  return [
-    code2,
-    varint_default.decode.bytes
-  ];
-};
-var encodeTo = (int, target, offset = 0) => {
-  varint_default.encode(int, target, offset);
-  return target;
-};
-var encodingLength = (int) => {
-  return varint_default.encodingLength(int);
-};
-
-// ../../node_modules/.pnpm/multiformats@9.9.0/node_modules/multiformats/esm/src/hashes/digest.js
-var create = (code2, digest2) => {
-  const size = digest2.byteLength;
-  const sizeOffset = encodingLength(code2);
-  const digestOffset = sizeOffset + encodingLength(size);
-  const bytes2 = new Uint8Array(digestOffset + size);
-  encodeTo(code2, bytes2, 0);
-  encodeTo(size, bytes2, sizeOffset);
-  bytes2.set(digest2, digestOffset);
-  return new Digest(code2, size, digest2, bytes2);
-};
-var decode5 = (multihash) => {
-  const bytes2 = coerce(multihash);
-  const [code2, sizeOffset] = decode4(bytes2);
-  const [size, digestOffset] = decode4(bytes2.subarray(sizeOffset));
-  const digest2 = bytes2.subarray(sizeOffset + digestOffset);
-  if (digest2.byteLength !== size) {
-    throw new Error("Incorrect length");
-  }
-  return new Digest(code2, size, digest2, bytes2);
-};
-var equals3 = (a, b) => {
-  if (a === b) {
-    return true;
-  } else {
-    return a.code === b.code && a.size === b.size && equals2(a.bytes, b.bytes);
-  }
-};
-var Digest = class {
-  constructor(code2, size, digest2, bytes2) {
-    this.code = code2;
-    this.size = size;
-    this.digest = digest2;
-    this.bytes = bytes2;
-  }
-};
-
-// ../../node_modules/.pnpm/multiformats@9.9.0/node_modules/multiformats/esm/src/hashes/hasher.js
-var from2 = ({ name: name2, code: code2, encode: encode5 }) => new Hasher(name2, code2, encode5);
-var Hasher = class {
-  constructor(name2, code2, encode5) {
-    this.name = name2;
-    this.code = code2;
-    this.encode = encode5;
-  }
-  digest(input) {
-    if (input instanceof Uint8Array) {
-      const result = this.encode(input);
-      return result instanceof Uint8Array ? create(this.code, result) : result.then((digest2) => create(this.code, digest2));
-    } else {
-      throw Error("Unknown type, must be binary type");
-    }
-  }
-};
-
-// ../../node_modules/.pnpm/multiformats@9.9.0/node_modules/multiformats/esm/src/hashes/sha2.js
-var sha256 = from2({
-  name: "sha2-256",
-  code: 18,
-  encode: (input) => coerce(import_crypto.default.createHash("sha256").update(input).digest())
-});
-var sha512 = from2({
-  name: "sha2-512",
-  code: 19,
-  encode: (input) => coerce(import_crypto.default.createHash("sha512").update(input).digest())
-});
-
-// ../../node_modules/.pnpm/multiformats@9.9.0/node_modules/multiformats/esm/src/hashes/identity.js
-var identity_exports2 = {};
-__export(identity_exports2, {
-  identity: () => identity2
-});
-var code = 0;
-var name = "identity";
-var encode4 = coerce;
-var digest = (input) => create(code, encode4(input));
-var identity2 = {
-  code,
-  name,
-  encode: encode4,
-  digest
-};
-
-// ../../node_modules/.pnpm/multiformats@9.9.0/node_modules/multiformats/esm/src/codecs/json.js
-var textEncoder = new TextEncoder();
-var textDecoder = new TextDecoder();
-
-// ../../node_modules/.pnpm/multiformats@9.9.0/node_modules/multiformats/esm/src/cid.js
-var CID = class {
-  constructor(version2, code2, multihash, bytes2) {
-    this.code = code2;
-    this.version = version2;
-    this.multihash = multihash;
-    this.bytes = bytes2;
-    this.byteOffset = bytes2.byteOffset;
-    this.byteLength = bytes2.byteLength;
-    this.asCID = this;
-    this._baseCache = /* @__PURE__ */ new Map();
-    Object.defineProperties(this, {
-      byteOffset: hidden,
-      byteLength: hidden,
-      code: readonly,
-      version: readonly,
-      multihash: readonly,
-      bytes: readonly,
-      _baseCache: hidden,
-      asCID: hidden
-    });
-  }
-  toV0() {
-    switch (this.version) {
-      case 0: {
-        return this;
-      }
-      default: {
-        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);
-      }
-    }
-  }
-  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 0. This is a bug please report`);
-      }
-    }
-  }
-  equals(other) {
-    return other && this.code === other.code && this.version === other.version && equals3(this.multihash, other.multihash);
-  }
-  toString(base3) {
-    const { bytes: bytes2, version: version2, _baseCache } = this;
-    switch (version2) {
-      case 0:
-        return toStringV0(bytes2, _baseCache, base3 || base58btc.encoder);
-      default:
-        return toStringV1(bytes2, _baseCache, base3 || base32.encoder);
-    }
-  }
-  toJSON() {
-    return {
-      code: this.code,
-      version: this.version,
-      hash: this.multihash.bytes
-    };
-  }
-  get [Symbol.toStringTag]() {
-    return "CID";
-  }
-  [Symbol.for("nodejs.util.inspect.custom")]() {
-    return "CID(" + this.toString() + ")";
-  }
-  static isCID(value) {
-    deprecate(/^0\.0/, IS_CID_DEPRECATION);
-    return !!(value && (value[cidSymbol] || value.asCID === value));
-  }
-  get toBaseEncodedString() {
-    throw new Error("Deprecated, use .toString()");
-  }
-  get codec() {
-    throw new Error('"codec" property is deprecated, use integer "code" property instead');
-  }
-  get buffer() {
-    throw new Error("Deprecated .buffer property, use .bytes to get Uint8Array instead");
-  }
-  get multibaseName() {
-    throw new Error('"multibaseName" property is deprecated');
-  }
-  get prefix() {
-    throw new Error('"prefix" property is deprecated');
-  }
-  static asCID(value) {
-    if (value instanceof CID) {
-      return value;
-    } else if (value != null && value.asCID === value) {
-      const { version: version2, code: code2, multihash, bytes: bytes2 } = value;
-      return new CID(version2, code2, multihash, bytes2 || encodeCID(version2, code2, multihash.bytes));
-    } else if (value != null && value[cidSymbol] === true) {
-      const { version: version2, multihash, code: code2 } = value;
-      const digest2 = decode5(multihash);
-      return CID.create(version2, code2, digest2);
-    } else {
-      return null;
-    }
-  }
-  static create(version2, code2, digest2) {
-    if (typeof code2 !== "number") {
-      throw new Error("String codecs are no longer supported");
-    }
-    switch (version2) {
-      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(version2, code2, digest2, digest2.bytes);
-        }
-      }
-      case 1: {
-        const bytes2 = encodeCID(version2, code2, digest2.bytes);
-        return new CID(version2, code2, digest2, bytes2);
-      }
-      default: {
-        throw new Error("Invalid version");
-      }
-    }
-  }
-  static createV0(digest2) {
-    return CID.create(0, DAG_PB_CODE, digest2);
-  }
-  static createV1(code2, digest2) {
-    return CID.create(1, code2, digest2);
-  }
-  static decode(bytes2) {
-    const [cid, remainder] = CID.decodeFirst(bytes2);
-    if (remainder.length) {
-      throw new Error("Incorrect length");
-    }
-    return cid;
-  }
-  static decodeFirst(bytes2) {
-    const specs = CID.inspectBytes(bytes2);
-    const prefixSize = specs.size - specs.multihashSize;
-    const multihashBytes = coerce(bytes2.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,
-      bytes2.subarray(specs.size)
-    ];
-  }
-  static inspectBytes(initialBytes) {
-    let offset = 0;
-    const next = () => {
-      const [i, length2] = decode4(initialBytes.subarray(offset));
-      offset += length2;
-      return i;
-    };
-    let version2 = next();
-    let codec = DAG_PB_CODE;
-    if (version2 === 18) {
-      version2 = 0;
-      offset = 0;
-    } else if (version2 === 1) {
-      codec = next();
-    }
-    if (version2 !== 0 && version2 !== 1) {
-      throw new RangeError(`Invalid CID version ${version2}`);
-    }
-    const prefixSize = offset;
-    const multihashCode = next();
-    const digestSize = next();
-    const size = offset + digestSize;
-    const multihashSize = size - prefixSize;
-    return {
-      version: version2,
-      codec,
-      multihashCode,
-      digestSize,
-      multihashSize,
-      size
-    };
-  }
-  static parse(source, base3) {
-    const [prefix, bytes2] = parseCIDtoBytes(source, base3);
-    const cid = CID.decode(bytes2);
-    cid._baseCache.set(prefix, source);
-    return cid;
-  }
-};
-var parseCIDtoBytes = (source, base3) => {
-  switch (source[0]) {
-    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)
-      ];
-    }
-    default: {
-      if (base3 == null) {
-        throw Error("To parse non base32 or base58btc encoded CID multibase decoder must be provided");
-      }
-      return [
-        source[0],
-        base3.decode(source)
-      ];
-    }
-  }
-};
-var toStringV0 = (bytes2, cache, base3) => {
-  const { prefix } = base3;
-  if (prefix !== base58btc.prefix) {
-    throw Error(`Cannot string encode V0 in ${base3.name} encoding`);
-  }
-  const cid = cache.get(prefix);
-  if (cid == null) {
-    const cid2 = base3.encode(bytes2).slice(1);
-    cache.set(prefix, cid2);
-    return cid2;
-  } else {
-    return cid;
-  }
-};
-var toStringV1 = (bytes2, cache, base3) => {
-  const { prefix } = base3;
-  const cid = cache.get(prefix);
-  if (cid == null) {
-    const cid2 = base3.encode(bytes2);
-    cache.set(prefix, cid2);
-    return cid2;
-  } else {
-    return cid;
-  }
-};
-var DAG_PB_CODE = 112;
-var SHA_256_CODE = 18;
-var encodeCID = (version2, code2, multihash) => {
-  const codeOffset = encodingLength(version2);
-  const hashOffset = codeOffset + encodingLength(code2);
-  const bytes2 = new Uint8Array(hashOffset + multihash.byteLength);
-  encodeTo(version2, bytes2, 0);
-  encodeTo(code2, bytes2, codeOffset);
-  bytes2.set(multihash, hashOffset);
-  return bytes2;
-};
-var cidSymbol = Symbol.for("@ipld/js-cid/CID");
-var readonly = {
-  writable: false,
-  configurable: false,
-  enumerable: true
-};
-var hidden = {
-  writable: false,
-  enumerable: false,
-  configurable: false
-};
-var version = "0.0.0-dev";
-var deprecate = (range, message) => {
-  if (range.test(version)) {
-    console.warn(message);
-  } else {
-    throw new Error(message);
-  }
-};
-var IS_CID_DEPRECATION = `CID.isCID(v) is deprecated and will be removed in the next major release.
-Following code pattern:
-
-if (CID.isCID(value)) {
-  doSomethingWithCID(value)
-}
-
-Is replaced with:
-
-const cid = CID.asCID(value)
-if (cid) {
-  // Make sure to use cid instead of value
-  doSomethingWithCID(cid)
-}
-`;
-
-// ../../node_modules/.pnpm/multiformats@9.9.0/node_modules/multiformats/esm/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_exports,
-  ...identity_exports2
-};
-
-// ../../node_modules/.pnpm/uint8arrays@3.0.0/node_modules/uint8arrays/esm/src/util/bases.js
-function createCodec(name2, prefix, encode5, decode6) {
-  return {
-    name: name2,
-    prefix,
-    encoder: {
-      name: name2,
-      prefix,
-      encode: encode5
-    },
-    decoder: { decode: decode6 }
-  };
-}
-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 = new Uint8Array(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/.pnpm/uint8arrays@3.0.0/node_modules/uint8arrays/esm/src/from-string.js
-function fromString2(string2, encoding = "utf8") {
-  const base3 = bases_default[encoding];
-  if (!base3) {
-    throw new Error(`Unsupported encoding "${encoding}"`);
-  }
-  return base3.decoder.decode(`${base3.prefix}${string2}`);
-}
-
-// ../../node_modules/.pnpm/uint8arrays@3.0.0/node_modules/uint8arrays/esm/src/to-string.js
-function toString2(array, encoding = "utf8") {
-  const base3 = bases_default[encoding];
-  if (!base3) {
-    throw new Error(`Unsupported encoding "${encoding}"`);
-  }
-  return base3.encoder.encode(array).substring(1);
-}
-
-// ../../node_modules/.pnpm/@noble+hashes@1.3.1/node_modules/@noble/hashes/esm/_assert.js
-function number(n) {
-  if (!Number.isSafeInteger(n) || n < 0)
-    throw new Error(`Wrong positive integer: ${n}`);
-}
-function bool(b) {
-  if (typeof b !== "boolean")
-    throw new Error(`Expected boolean, not ${b}`);
-}
-function bytes(b, ...lengths) {
-  if (!(b instanceof Uint8Array))
-    throw new Error("Expected Uint8Array");
-  if (lengths.length > 0 && !lengths.includes(b.length))
-    throw new Error(`Expected Uint8Array of length ${lengths}, not of length=${b.length}`);
-}
-function hash(hash2) {
-  if (typeof hash2 !== "function" || typeof hash2.create !== "function")
-    throw new Error("Hash should be wrapped by utils.wrapConstructor");
-  number(hash2.outputLen);
-  number(hash2.blockLen);
-}
-function exists(instance, checkFinished = true) {
-  if (instance.destroyed)
-    throw new Error("Hash instance has been destroyed");
-  if (checkFinished && instance.finished)
-    throw new Error("Hash#digest() has already been called");
-}
-function output(out, instance) {
-  bytes(out);
-  const min = instance.outputLen;
-  if (out.length < min) {
-    throw new Error(`digestInto() expects output buffer of length at least ${min}`);
-  }
-}
-var assert = {
-  number,
-  bool,
-  bytes,
-  hash,
-  exists,
-  output
-};
-var assert_default = assert;
-
-// ../../node_modules/.pnpm/@noble+hashes@1.3.1/node_modules/@noble/hashes/esm/cryptoNode.js
-var nc = __toESM(require("node:crypto"), 1);
-var crypto2 = nc && typeof nc === "object" && "webcrypto" in nc ? nc.webcrypto : void 0;
-
-// ../../node_modules/.pnpm/@noble+hashes@1.3.1/node_modules/@noble/hashes/esm/utils.js
-var u8a = (a) => a instanceof Uint8Array;
-var createView = (arr) => new DataView(arr.buffer, arr.byteOffset, arr.byteLength);
-var rotr = (word, shift) => word << 32 - shift | word >>> shift;
-var isLE = new Uint8Array(new Uint32Array([287454020]).buffer)[0] === 68;
-if (!isLE)
-  throw new Error("Non little-endian hardware is not supported");
-var hexes = Array.from({ length: 256 }, (v, i) => i.toString(16).padStart(2, "0"));
-function utf8ToBytes(str) {
-  if (typeof str !== "string")
-    throw new Error(`utf8ToBytes expected string, got ${typeof str}`);
-  return new Uint8Array(new TextEncoder().encode(str));
-}
-function toBytes(data) {
-  if (typeof data === "string")
-    data = utf8ToBytes(data);
-  if (!u8a(data))
-    throw new Error(`expected Uint8Array, got ${typeof data}`);
-  return data;
-}
-function concatBytes(...arrays) {
-  const r = new Uint8Array(arrays.reduce((sum, a) => sum + a.length, 0));
-  let pad = 0;
-  arrays.forEach((a) => {
-    if (!u8a(a))
-      throw new Error("Uint8Array expected");
-    r.set(a, pad);
-    pad += a.length;
-  });
-  return r;
-}
-var Hash = class {
-  clone() {
-    return this._cloneInto();
-  }
-};
-function wrapConstructor(hashCons) {
-  const hashC = (msg) => hashCons().update(toBytes(msg)).digest();
-  const tmp = hashCons();
-  hashC.outputLen = tmp.outputLen;
-  hashC.blockLen = tmp.blockLen;
-  hashC.create = () => hashCons();
-  return hashC;
-}
-function randomBytes(bytesLength = 32) {
-  if (crypto2 && typeof crypto2.getRandomValues === "function") {
-    return crypto2.getRandomValues(new Uint8Array(bytesLength));
-  }
-  throw new Error("crypto.getRandomValues must be defined");
-}
-
-// ../../node_modules/.pnpm/@noble+hashes@1.3.1/node_modules/@noble/hashes/esm/hmac.js
-var HMAC = class extends Hash {
-  constructor(hash2, _key) {
-    super();
-    this.finished = false;
-    this.destroyed = false;
-    assert_default.hash(hash2);
-    const key = toBytes(_key);
-    this.iHash = hash2.create();
-    if (typeof this.iHash.update !== "function")
-      throw new Error("Expected instance of class which extends utils.Hash");
-    this.blockLen = this.iHash.blockLen;
-    this.outputLen = this.iHash.outputLen;
-    const blockLen = this.blockLen;
-    const pad = new Uint8Array(blockLen);
-    pad.set(key.length > blockLen ? hash2.create().update(key).digest() : key);
-    for (let i = 0; i < pad.length; i++)
-      pad[i] ^= 54;
-    this.iHash.update(pad);
-    this.oHash = hash2.create();
-    for (let i = 0; i < pad.length; i++)
-      pad[i] ^= 54 ^ 92;
-    this.oHash.update(pad);
-    pad.fill(0);
-  }
-  update(buf) {
-    assert_default.exists(this);
-    this.iHash.update(buf);
-    return this;
-  }
-  digestInto(out) {
-    assert_default.exists(this);
-    assert_default.bytes(out, this.outputLen);
-    this.finished = true;
-    this.iHash.digestInto(out);
-    this.oHash.update(out);
-    this.oHash.digestInto(out);
-    this.destroy();
-  }
-  digest() {
-    const out = new Uint8Array(this.oHash.outputLen);
-    this.digestInto(out);
-    return out;
-  }
-  _cloneInto(to) {
-    to || (to = Object.create(Object.getPrototypeOf(this), {}));
-    const { oHash, iHash, finished, destroyed, blockLen, outputLen } = this;
-    to = to;
-    to.finished = finished;
-    to.destroyed = destroyed;
-    to.blockLen = blockLen;
-    to.outputLen = outputLen;
-    to.oHash = oHash._cloneInto(to.oHash);
-    to.iHash = iHash._cloneInto(to.iHash);
-    return to;
-  }
-  destroy() {
-    this.destroyed = true;
-    this.oHash.destroy();
-    this.iHash.destroy();
-  }
-};
-var hmac = (hash2, key, message) => new HMAC(hash2, key).update(message).digest();
-hmac.create = (hash2, key) => new HMAC(hash2, key);
-
-// ../../node_modules/.pnpm/@noble+curves@1.1.0/node_modules/@noble/curves/esm/abstract/utils.js
-var utils_exports = {};
-__export(utils_exports, {
-  bitGet: () => bitGet,
-  bitLen: () => bitLen,
-  bitMask: () => bitMask,
-  bitSet: () => bitSet,
-  bytesToHex: () => bytesToHex,
-  bytesToNumberBE: () => bytesToNumberBE,
-  bytesToNumberLE: () => bytesToNumberLE,
-  concatBytes: () => concatBytes2,
-  createHmacDrbg: () => createHmacDrbg,
-  ensureBytes: () => ensureBytes,
-  equalBytes: () => equalBytes,
-  hexToBytes: () => hexToBytes,
-  hexToNumber: () => hexToNumber,
-  numberToBytesBE: () => numberToBytesBE,
-  numberToBytesLE: () => numberToBytesLE,
-  numberToHexUnpadded: () => numberToHexUnpadded,
-  numberToVarBytesBE: () => numberToVarBytesBE,
-  utf8ToBytes: () => utf8ToBytes2,
-  validateObject: () => validateObject
-});
-var _0n = BigInt(0);
-var _1n = BigInt(1);
-var _2n = BigInt(2);
-var u8a2 = (a) => a instanceof Uint8Array;
-var hexes2 = Array.from({ length: 256 }, (v, i) => i.toString(16).padStart(2, "0"));
-function bytesToHex(bytes2) {
-  if (!u8a2(bytes2))
-    throw new Error("Uint8Array expected");
-  let hex = "";
-  for (let i = 0; i < bytes2.length; i++) {
-    hex += hexes2[bytes2[i]];
-  }
-  return hex;
-}
-function numberToHexUnpadded(num) {
-  const hex = num.toString(16);
-  return hex.length & 1 ? `0${hex}` : hex;
-}
-function hexToNumber(hex) {
-  if (typeof hex !== "string")
-    throw new Error("hex string expected, got " + typeof hex);
-  return BigInt(hex === "" ? "0" : `0x${hex}`);
-}
-function hexToBytes(hex) {
-  if (typeof hex !== "string")
-    throw new Error("hex string expected, got " + typeof hex);
-  const len = hex.length;
-  if (len % 2)
-    throw new Error("padded hex string expected, got unpadded hex of length " + len);
-  const array = new Uint8Array(len / 2);
-  for (let i = 0; i < array.length; i++) {
-    const j = i * 2;
-    const hexByte = hex.slice(j, j + 2);
-    const byte = Number.parseInt(hexByte, 16);
-    if (Number.isNaN(byte) || byte < 0)
-      throw new Error("Invalid byte sequence");
-    array[i] = byte;
-  }
-  return array;
-}
-function bytesToNumberBE(bytes2) {
-  return hexToNumber(bytesToHex(bytes2));
-}
-function bytesToNumberLE(bytes2) {
-  if (!u8a2(bytes2))
-    throw new Error("Uint8Array expected");
-  return hexToNumber(bytesToHex(Uint8Array.from(bytes2).reverse()));
-}
-function numberToBytesBE(n, len) {
-  return hexToBytes(n.toString(16).padStart(len * 2, "0"));
-}
-function numberToBytesLE(n, len) {
-  return numberToBytesBE(n, len).reverse();
-}
-function numberToVarBytesBE(n) {
-  return hexToBytes(numberToHexUnpadded(n));
-}
-function ensureBytes(title, hex, expectedLength) {
-  let res;
-  if (typeof hex === "string") {
-    try {
-      res = hexToBytes(hex);
-    } catch (e) {
-      throw new Error(`${title} must be valid hex string, got "${hex}". Cause: ${e}`);
-    }
-  } else if (u8a2(hex)) {
-    res = Uint8Array.from(hex);
-  } else {
-    throw new Error(`${title} must be hex string or Uint8Array`);
-  }
-  const len = res.length;
-  if (typeof expectedLength === "number" && len !== expectedLength)
-    throw new Error(`${title} expected ${expectedLength} bytes, got ${len}`);
-  return res;
-}
-function concatBytes2(...arrays) {
-  const r = new Uint8Array(arrays.reduce((sum, a) => sum + a.length, 0));
-  let pad = 0;
-  arrays.forEach((a) => {
-    if (!u8a2(a))
-      throw new Error("Uint8Array expected");
-    r.set(a, pad);
-    pad += a.length;
-  });
-  return r;
-}
-function equalBytes(b1, b2) {
-  if (b1.length !== b2.length)
-    return false;
-  for (let i = 0; i < b1.length; i++)
-    if (b1[i] !== b2[i])
-      return false;
-  return true;
-}
-function utf8ToBytes2(str) {
-  if (typeof str !== "string")
-    throw new Error(`utf8ToBytes expected string, got ${typeof str}`);
-  return new Uint8Array(new TextEncoder().encode(str));
-}
-function bitLen(n) {
-  let len;
-  for (len = 0; n > _0n; n >>= _1n, len += 1)
-    ;
-  return len;
-}
-function bitGet(n, pos) {
-  return n >> BigInt(pos) & _1n;
-}
-var bitSet = (n, pos, value) => {
-  return n | (value ? _1n : _0n) << BigInt(pos);
-};
-var bitMask = (n) => (_2n << BigInt(n - 1)) - _1n;
-var u8n = (data) => new Uint8Array(data);
-var u8fr = (arr) => Uint8Array.from(arr);
-function createHmacDrbg(hashLen, qByteLen, hmacFn) {
-  if (typeof hashLen !== "number" || hashLen < 2)
-    throw new Error("hashLen must be a number");
-  if (typeof qByteLen !== "number" || qByteLen < 2)
-    throw new Error("qByteLen must be a number");
-  if (typeof hmacFn !== "function")
-    throw new Error("hmacFn must be a function");
-  let v = u8n(hashLen);
-  let k = u8n(hashLen);
-  let i = 0;
-  const reset = () => {
-    v.fill(1);
-    k.fill(0);
-    i = 0;
-  };
-  const h = (...b) => hmacFn(k, v, ...b);
-  const reseed = (seed = u8n()) => {
-    k = h(u8fr([0]), seed);
-    v = h();
-    if (seed.length === 0)
-      return;
-    k = h(u8fr([1]), seed);
-    v = h();
-  };
-  const gen = () => {
-    if (i++ >= 1e3)
-      throw new Error("drbg: tried 1000 values");
-    let len = 0;
-    const out = [];
-    while (len < qByteLen) {
-      v = h();
-      const sl = v.slice();
-      out.push(sl);
-      len += v.length;
-    }
-    return concatBytes2(...out);
-  };
-  const genUntil = (seed, pred) => {
-    reset();
-    reseed(seed);
-    let res = void 0;
-    while (!(res = pred(gen())))
-      reseed();
-    reset();
-    return res;
-  };
-  return genUntil;
-}
-var validatorFns = {
-  bigint: (val) => typeof val === "bigint",
-  function: (val) => typeof val === "function",
-  boolean: (val) => typeof val === "boolean",
-  string: (val) => typeof val === "string",
-  isSafeInteger: (val) => Number.isSafeInteger(val),
-  array: (val) => Array.isArray(val),
-  field: (val, object) => object.Fp.isValid(val),
-  hash: (val) => typeof val === "function" && Number.isSafeInteger(val.outputLen)
-};
-function validateObject(object, validators, optValidators = {}) {
-  const checkField = (fieldName, type, isOptional) => {
-    const checkVal = validatorFns[type];
-    if (typeof checkVal !== "function")
-      throw new Error(`Invalid validator "${type}", expected function`);
-    const val = object[fieldName];
-    if (isOptional && val === void 0)
-      return;
-    if (!checkVal(val, object)) {
-      throw new Error(`Invalid param ${String(fieldName)}=${val} (${typeof val}), expected ${type}`);
-    }
-  };
-  for (const [fieldName, type] of Object.entries(validators))
-    checkField(fieldName, type, false);
-  for (const [fieldName, type] of Object.entries(optValidators))
-    checkField(fieldName, type, true);
-  return object;
-}
-
-// ../../node_modules/.pnpm/@noble+curves@1.1.0/node_modules/@noble/curves/esm/abstract/modular.js
-var _0n2 = BigInt(0);
-var _1n2 = BigInt(1);
-var _2n2 = BigInt(2);
-var _3n = BigInt(3);
-var _4n = BigInt(4);
-var _5n = BigInt(5);
-var _8n = BigInt(8);
-var _9n = BigInt(9);
-var _16n = BigInt(16);
-function mod(a, b) {
-  const result = a % b;
-  return result >= _0n2 ? result : b + result;
-}
-function pow(num, power, modulo) {
-  if (modulo <= _0n2 || power < _0n2)
-    throw new Error("Expected power/modulo > 0");
-  if (modulo === _1n2)
-    return _0n2;
-  let res = _1n2;
-  while (power > _0n2) {
-    if (power & _1n2)
-      res = res * num % modulo;
-    num = num * num % modulo;
-    power >>= _1n2;
-  }
-  return res;
-}
-function pow2(x, power, modulo) {
-  let res = x;
-  while (power-- > _0n2) {
-    res *= res;
-    res %= modulo;
-  }
-  return res;
-}
-function invert(number2, modulo) {
-  if (number2 === _0n2 || modulo <= _0n2) {
-    throw new Error(`invert: expected positive integers, got n=${number2} mod=${modulo}`);
-  }
-  let a = mod(number2, modulo);
-  let b = modulo;
-  let x = _0n2, y = _1n2, u = _1n2, v = _0n2;
-  while (a !== _0n2) {
-    const q = b / a;
-    const r = b % a;
-    const m = x - u * q;
-    const n = y - v * q;
-    b = a, a = r, x = u, y = v, u = m, v = n;
-  }
-  const gcd = b;
-  if (gcd !== _1n2)
-    throw new Error("invert: does not exist");
-  return mod(x, modulo);
-}
-function tonelliShanks(P) {
-  const legendreC = (P - _1n2) / _2n2;
-  let Q, S, Z;
-  for (Q = P - _1n2, S = 0; Q % _2n2 === _0n2; Q /= _2n2, S++)
-    ;
-  for (Z = _2n2; Z < P && pow(Z, legendreC, P) !== P - _1n2; Z++)
-    ;
-  if (S === 1) {
-    const p1div4 = (P + _1n2) / _4n;
-    return function tonelliFast(Fp3, n) {
-      const root = Fp3.pow(n, p1div4);
-      if (!Fp3.eql(Fp3.sqr(root), n))
-        throw new Error("Cannot find square root");
-      return root;
-    };
-  }
-  const Q1div2 = (Q + _1n2) / _2n2;
-  return function tonelliSlow(Fp3, n) {
-    if (Fp3.pow(n, legendreC) === Fp3.neg(Fp3.ONE))
-      throw new Error("Cannot find square root");
-    let r = S;
-    let g = Fp3.pow(Fp3.mul(Fp3.ONE, Z), Q);
-    let x = Fp3.pow(n, Q1div2);
-    let b = Fp3.pow(n, Q);
-    while (!Fp3.eql(b, Fp3.ONE)) {
-      if (Fp3.eql(b, Fp3.ZERO))
-        return Fp3.ZERO;
-      let m = 1;
-      for (let t2 = Fp3.sqr(b); m < r; m++) {
-        if (Fp3.eql(t2, Fp3.ONE))
-          break;
-        t2 = Fp3.sqr(t2);
-      }
-      const ge = Fp3.pow(g, _1n2 << BigInt(r - m - 1));
-      g = Fp3.sqr(ge);
-      x = Fp3.mul(x, ge);
-      b = Fp3.mul(b, g);
-      r = m;
-    }
-    return x;
-  };
-}
-function FpSqrt(P) {
-  if (P % _4n === _3n) {
-    const p1div4 = (P + _1n2) / _4n;
-    return function sqrt3mod4(Fp3, n) {
-      const root = Fp3.pow(n, p1div4);
-      if (!Fp3.eql(Fp3.sqr(root), n))
-        throw new Error("Cannot find square root");
-      return root;
-    };
-  }
-  if (P % _8n === _5n) {
-    const c1 = (P - _5n) / _8n;
-    return function sqrt5mod8(Fp3, n) {
-      const n2 = Fp3.mul(n, _2n2);
-      const v = Fp3.pow(n2, c1);
-      const nv = Fp3.mul(n, v);
-      const i = Fp3.mul(Fp3.mul(nv, _2n2), v);
-      const root = Fp3.mul(nv, Fp3.sub(i, Fp3.ONE));
-      if (!Fp3.eql(Fp3.sqr(root), n))
-        throw new Error("Cannot find square root");
-      return root;
-    };
-  }
-  if (P % _16n === _9n) {
-  }
-  return tonelliShanks(P);
-}
-var FIELD_FIELDS = [
-  "create",
-  "isValid",
-  "is0",
-  "neg",
-  "inv",
-  "sqrt",
-  "sqr",
-  "eql",
-  "add",
-  "sub",
-  "mul",
-  "pow",
-  "div",
-  "addN",
-  "subN",
-  "mulN",
-  "sqrN"
-];
-function validateField(field) {
-  const initial = {
-    ORDER: "bigint",
-    MASK: "bigint",
-    BYTES: "isSafeInteger",
-    BITS: "isSafeInteger"
-  };
-  const opts = FIELD_FIELDS.reduce((map, val) => {
-    map[val] = "function";
-    return map;
-  }, initial);
-  return validateObject(field, opts);
-}
-function FpPow(f, num, power) {
-  if (power < _0n2)
-    throw new Error("Expected power > 0");
-  if (power === _0n2)
-    return f.ONE;
-  if (power === _1n2)
-    return num;
-  let p = f.ONE;
-  let d = num;
-  while (power > _0n2) {
-    if (power & _1n2)
-      p = f.mul(p, d);
-    d = f.sqr(d);
-    power >>= _1n2;
-  }
-  return p;
-}
-function FpInvertBatch(f, nums) {
-  const tmp = new Array(nums.length);
-  const lastMultiplied = nums.reduce((acc, num, i) => {
-    if (f.is0(num))
-      return acc;
-    tmp[i] = acc;
-    return f.mul(acc, num);
-  }, f.ONE);
-  const inverted = f.inv(lastMultiplied);
-  nums.reduceRight((acc, num, i) => {
-    if (f.is0(num))
-      return acc;
-    tmp[i] = f.mul(acc, tmp[i]);
-    return f.mul(acc, num);
-  }, inverted);
-  return tmp;
-}
-function nLength(n, nBitLength) {
-  const _nBitLength = nBitLength !== void 0 ? nBitLength : n.toString(2).length;
-  const nByteLength = Math.ceil(_nBitLength / 8);
-  return { nBitLength: _nBitLength, nByteLength };
-}
-function Field(ORDER, bitLen2, isLE2 = false, redef = {}) {
-  if (ORDER <= _0n2)
-    throw new Error(`Expected Fp ORDER > 0, got ${ORDER}`);
-  const { nBitLength: BITS, nByteLength: BYTES } = nLength(ORDER, bitLen2);
-  if (BYTES > 2048)
-    throw new Error("Field lengths over 2048 bytes are not supported");
-  const sqrtP = FpSqrt(ORDER);
-  const f = Object.freeze({
-    ORDER,
-    BITS,
-    BYTES,
-    MASK: bitMask(BITS),
-    ZERO: _0n2,
-    ONE: _1n2,
-    create: (num) => mod(num, ORDER),
-    isValid: (num) => {
-      if (typeof num !== "bigint")
-        throw new Error(`Invalid field element: expected bigint, got ${typeof num}`);
-      return _0n2 <= num && num < ORDER;
-    },
-    is0: (num) => num === _0n2,
-    isOdd: (num) => (num & _1n2) === _1n2,
-    neg: (num) => mod(-num, ORDER),
-    eql: (lhs, rhs) => lhs === rhs,
-    sqr: (num) => mod(num * num, ORDER),
-    add: (lhs, rhs) => mod(lhs + rhs, ORDER),
-    sub: (lhs, rhs) => mod(lhs - rhs, ORDER),
-    mul: (lhs, rhs) => mod(lhs * rhs, ORDER),
-    pow: (num, power) => FpPow(f, num, power),
-    div: (lhs, rhs) => mod(lhs * invert(rhs, ORDER), ORDER),
-    sqrN: (num) => num * num,
-    addN: (lhs, rhs) => lhs + rhs,
-    subN: (lhs, rhs) => lhs - rhs,
-    mulN: (lhs, rhs) => lhs * rhs,
-    inv: (num) => invert(num, ORDER),
-    sqrt: redef.sqrt || ((n) => sqrtP(f, n)),
-    invertBatch: (lst) => FpInvertBatch(f, lst),
-    cmov: (a, b, c) => c ? b : a,
-    toBytes: (num) => isLE2 ? numberToBytesLE(num, BYTES) : numberToBytesBE(num, BYTES),
-    fromBytes: (bytes2) => {
-      if (bytes2.length !== BYTES)
-        throw new Error(`Fp.fromBytes: expected ${BYTES}, got ${bytes2.length}`);
-      return isLE2 ? bytesToNumberLE(bytes2) : bytesToNumberBE(bytes2);
-    }
-  });
-  return Object.freeze(f);
-}
-function hashToPrivateScalar(hash2, groupOrder, isLE2 = false) {
-  hash2 = ensureBytes("privateHash", hash2);
-  const hashLen = hash2.length;
-  const minLen = nLength(groupOrder).nByteLength + 8;
-  if (minLen < 24 || hashLen < minLen || hashLen > 1024)
-    throw new Error(`hashToPrivateScalar: expected ${minLen}-1024 bytes of input, got ${hashLen}`);
-  const num = isLE2 ? bytesToNumberLE(hash2) : bytesToNumberBE(hash2);
-  return mod(num, groupOrder - _1n2) + _1n2;
-}
-
-// ../../node_modules/.pnpm/@noble+curves@1.1.0/node_modules/@noble/curves/esm/abstract/curve.js
-var _0n3 = BigInt(0);
-var _1n3 = BigInt(1);
-function wNAF(c, bits) {
-  const constTimeNegate = (condition, item) => {
-    const neg = item.negate();
-    return condition ? neg : item;
-  };
-  const opts = (W) => {
-    const windows = Math.ceil(bits / W) + 1;
-    const windowSize = 2 ** (W - 1);
-    return { windows, windowSize };
-  };
-  return {
-    constTimeNegate,
-    unsafeLadder(elm, n) {
-      let p = c.ZERO;
-      let d = elm;
-      while (n > _0n3) {
-        if (n & _1n3)
-          p = p.add(d);
-        d = d.double();
-        n >>= _1n3;
-      }
-      return p;
-    },
-    precomputeWindow(elm, W) {
-      const { windows, windowSize } = opts(W);
-      const points = [];
-      let p = elm;
-      let base3 = p;
-      for (let window = 0; window < windows; window++) {
-        base3 = p;
-        points.push(base3);
-        for (let i = 1; i < windowSize; i++) {
-          base3 = base3.add(p);
-          points.push(base3);
-        }
-        p = base3.double();
-      }
-      return points;
-    },
-    wNAF(W, precomputes, n) {
-      const { windows, windowSize } = opts(W);
-      let p = c.ZERO;
-      let f = c.BASE;
-      const mask = BigInt(2 ** W - 1);
-      const maxNumber = 2 ** W;
-      const shiftBy = BigInt(W);
-      for (let window = 0; window < windows; window++) {
-        const offset = window * windowSize;
-        let wbits = Number(n & mask);
-        n >>= shiftBy;
-        if (wbits > windowSize) {
-          wbits -= maxNumber;
-          n += _1n3;
-        }
-        const offset1 = offset;
-        const offset2 = offset + Math.abs(wbits) - 1;
-        const cond1 = window % 2 !== 0;
-        const cond2 = wbits < 0;
-        if (wbits === 0) {
-          f = f.add(constTimeNegate(cond1, precomputes[offset1]));
-        } else {
-          p = p.add(constTimeNegate(cond2, precomputes[offset2]));
-        }
-      }
-      return { p, f };
-    },
-    wNAFCached(P, precomputesMap, n, transform) {
-      const W = P._WINDOW_SIZE || 1;
-      let comp = precomputesMap.get(P);
-      if (!comp) {
-        comp = this.precomputeWindow(P, W);
-        if (W !== 1) {
-          precomputesMap.set(P, transform(comp));
-        }
-      }
-      return this.wNAF(W, comp, n);
-    }
-  };
-}
-function validateBasic(curve) {
-  validateField(curve.Fp);
-  validateObject(curve, {
-    n: "bigint",
-    h: "bigint",
-    Gx: "field",
-    Gy: "field"
-  }, {
-    nBitLength: "isSafeInteger",
-    nByteLength: "isSafeInteger"
-  });
-  return Object.freeze({
-    ...nLength(curve.n, curve.nBitLength),
-    ...curve,
-    ...{ p: curve.Fp.ORDER }
-  });
-}
-
-// ../../node_modules/.pnpm/@noble+curves@1.1.0/node_modules/@noble/curves/esm/abstract/weierstrass.js
-function validatePointOpts(curve) {
-  const opts = validateBasic(curve);
-  validateObject(opts, {
-    a: "field",
-    b: "field"
-  }, {
-    allowedPrivateKeyLengths: "array",
-    wrapPrivateKey: "boolean",
-    isTorsionFree: "function",
-    clearCofactor: "function",
-    allowInfinityPoint: "boolean",
-    fromBytes: "function",
-    toBytes: "function"
-  });
-  const { endo, Fp: Fp3, a } = opts;
-  if (endo) {
-    if (!Fp3.eql(a, Fp3.ZERO)) {
-      throw new Error("Endomorphism can only be defined for Koblitz curves that have a=0");
-    }
-    if (typeof endo !== "object" || typeof endo.beta !== "bigint" || typeof endo.splitScalar !== "function") {
-      throw new Error("Expected endomorphism with beta: bigint and splitScalar: function");
-    }
-  }
-  return Object.freeze({ ...opts });
-}
-var { bytesToNumberBE: b2n, hexToBytes: h2b } = utils_exports;
-var DER = {
-  Err: class DERErr extends Error {
-    constructor(m = "") {
-      super(m);
-    }
-  },
-  _parseInt(data) {
-    const { Err: E } = DER;
-    if (data.length < 2 || data[0] !== 2)
-      throw new E("Invalid signature integer tag");
-    const len = data[1];
-    const res = data.subarray(2, len + 2);
-    if (!len || res.length !== len)
-      throw new E("Invalid signature integer: wrong length");
-    if (res[0] & 128)
-      throw new E("Invalid signature integer: negative");
-    if (res[0] === 0 && !(res[1] & 128))
-      throw new E("Invalid signature integer: unnecessary leading zero");
-    return { d: b2n(res), l: data.subarray(len + 2) };
-  },
-  toSig(hex) {
-    const { Err: E } = DER;
-    const data = typeof hex === "string" ? h2b(hex) : hex;
-    if (!(data instanceof Uint8Array))
-      throw new Error("ui8a expected");
-    let l = data.length;
-    if (l < 2 || data[0] != 48)
-      throw new E("Invalid signature tag");
-    if (data[1] !== l - 2)
-      throw new E("Invalid signature: incorrect length");
-    const { d: r, l: sBytes } = DER._parseInt(data.subarray(2));
-    const { d: s, l: rBytesLeft } = DER._parseInt(sBytes);
-    if (rBytesLeft.length)
-      throw new E("Invalid signature: left bytes after parsing");
-    return { r, s };
-  },
-  hexFromSig(sig) {
-    const slice = (s2) => Number.parseInt(s2[0], 16) & 8 ? "00" + s2 : s2;
-    const h = (num) => {
-      const hex = num.toString(16);
-      return hex.length & 1 ? `0${hex}` : hex;
-    };
-    const s = slice(h(sig.s));
-    const r = slice(h(sig.r));
-    const shl = s.length / 2;
-    const rhl = r.length / 2;
-    const sl = h(shl);
-    const rl = h(rhl);
-    return `30${h(rhl + shl + 4)}02${rl}${r}02${sl}${s}`;
-  }
-};
-var _0n4 = BigInt(0);
-var _1n4 = BigInt(1);
-var _2n3 = BigInt(2);
-var _3n2 = BigInt(3);
-var _4n2 = BigInt(4);
-function weierstrassPoints(opts) {
-  const CURVE = validatePointOpts(opts);
-  const { Fp: Fp3 } = CURVE;
-  const toBytes2 = CURVE.toBytes || ((c, point, isCompressed) => {
-    const a = point.toAffine();
-    return concatBytes2(Uint8Array.from([4]), Fp3.toBytes(a.x), Fp3.toBytes(a.y));
-  });
-  const fromBytes = CURVE.fromBytes || ((bytes2) => {
-    const tail = bytes2.subarray(1);
-    const x = Fp3.fromBytes(tail.subarray(0, Fp3.BYTES));
-    const y = Fp3.fromBytes(tail.subarray(Fp3.BYTES, 2 * Fp3.BYTES));
-    return { x, y };
-  });
-  function weierstrassEquation(x) {
-    const { a, b } = CURVE;
-    const x2 = Fp3.sqr(x);
-    const x3 = Fp3.mul(x2, x);
-    return Fp3.add(Fp3.add(x3, Fp3.mul(x, a)), b);
-  }
-  if (!Fp3.eql(Fp3.sqr(CURVE.Gy), weierstrassEquation(CURVE.Gx)))
-    throw new Error("bad generator point: equation left != right");
-  function isWithinCurveOrder(num) {
-    return typeof num === "bigint" && _0n4 < num && num < CURVE.n;
-  }
-  function assertGE(num) {
-    if (!isWithinCurveOrder(num))
-      throw new Error("Expected valid bigint: 0 < bigint < curve.n");
-  }
-  function normPrivateKeyToScalar(key) {
-    const { allowedPrivateKeyLengths: lengths, nByteLength, wrapPrivateKey, n } = CURVE;
-    if (lengths && typeof key !== "bigint") {
-      if (key instanceof Uint8Array)
-        key = bytesToHex(key);
-      if (typeof key !== "string" || !lengths.includes(key.length))
-        throw new Error("Invalid key");
-      key = key.padStart(nByteLength * 2, "0");
-    }
-    let num;
-    try {
-      num = typeof key === "bigint" ? key : bytesToNumberBE(ensureBytes("private key", key, nByteLength));
-    } catch (error) {
-      throw new Error(`private key must be ${nByteLength} bytes, hex or bigint, not ${typeof key}`);
-    }
-    if (wrapPrivateKey)
-      num = mod(num, n);
-    assertGE(num);
-    return num;
-  }
-  const pointPrecomputes = /* @__PURE__ */ new Map();
-  function assertPrjPoint(other) {
-    if (!(other instanceof Point2))
-      throw new Error("ProjectivePoint expected");
-  }
-  class Point2 {
-    constructor(px, py, pz) {
-      this.px = px;
-      this.py = py;
-      this.pz = pz;
-      if (px == null || !Fp3.isValid(px))
-        throw new Error("x required");
-      if (py == null || !Fp3.isValid(py))
-        throw new Error("y required");
-      if (pz == null || !Fp3.isValid(pz))
-        throw new Error("z required");
-    }
-    static fromAffine(p) {
-      const { x, y } = p || {};
-      if (!p || !Fp3.isValid(x) || !Fp3.isValid(y))
-        throw new Error("invalid affine point");
-      if (p instanceof Point2)
-        throw new Error("projective point not allowed");
-      const is0 = (i) => Fp3.eql(i, Fp3.ZERO);
-      if (is0(x) && is0(y))
-        return Point2.ZERO;
-      return new Point2(x, y, Fp3.ONE);
-    }
-    get x() {
-      return this.toAffine().x;
-    }
-    get y() {
-      return this.toAffine().y;
-    }
-    static normalizeZ(points) {
-      const toInv = Fp3.invertBatch(points.map((p) => p.pz));
-      return points.map((p, i) => p.toAffine(toInv[i])).map(Point2.fromAffine);
-    }
-    static fromHex(hex) {
-      const P = Point2.fromAffine(fromBytes(ensureBytes("pointHex", hex)));
-      P.assertValidity();
-      return P;
-    }
-    static fromPrivateKey(privateKey) {
-      return Point2.BASE.multiply(normPrivateKeyToScalar(privateKey));
-    }
-    _setWindowSize(windowSize) {
-      this._WINDOW_SIZE = windowSize;
-      pointPrecomputes.delete(this);
-    }
-    assertValidity() {
-      if (this.is0()) {
-        if (CURVE.allowInfinityPoint)
-          return;
-        throw new Error("bad point: ZERO");
-      }
-      const { x, y } = this.toAffine();
-      if (!Fp3.isValid(x) || !Fp3.isValid(y))
-        throw new Error("bad point: x or y not FE");
-      const left = Fp3.sqr(y);
-      const right = weierstrassEquation(x);
-      if (!Fp3.eql(left, right))
-        throw new Error("bad point: equation left != right");
-      if (!this.isTorsionFree())
-        throw new Error("bad point: not in prime-order subgroup");
-    }
-    hasEvenY() {
-      const { y } = this.toAffine();
-      if (Fp3.isOdd)
-        return !Fp3.isOdd(y);
-      throw new Error("Field doesn't support isOdd");
-    }
-    equals(other) {
-      assertPrjPoint(other);
-      const { px: X1, py: Y1, pz: Z1 } = this;
-      const { px: X2, py: Y2, pz: Z2 } = other;
-      const U1 = Fp3.eql(Fp3.mul(X1, Z2), Fp3.mul(X2, Z1));
-      const U2 = Fp3.eql(Fp3.mul(Y1, Z2), Fp3.mul(Y2, Z1));
-      return U1 && U2;
-    }
-    negate() {
-      return new Point2(this.px, Fp3.neg(this.py), this.pz);
-    }
-    double() {
-      const { a, b } = CURVE;
-      const b3 = Fp3.mul(b, _3n2);
-      const { px: X1, py: Y1, pz: Z1 } = this;
-      let X3 = Fp3.ZERO, Y3 = Fp3.ZERO, Z3 = Fp3.ZERO;
-      let t0 = Fp3.mul(X1, X1);
-      let t1 = Fp3.mul(Y1, Y1);
-      let t2 = Fp3.mul(Z1, Z1);
-      let t3 = Fp3.mul(X1, Y1);
-      t3 = Fp3.add(t3, t3);
-      Z3 = Fp3.mul(X1, Z1);
-      Z3 = Fp3.add(Z3, Z3);
-      X3 = Fp3.mul(a, Z3);
-      Y3 = Fp3.mul(b3, t2);
-      Y3 = Fp3.add(X3, Y3);
-      X3 = Fp3.sub(t1, Y3);
-      Y3 = Fp3.add(t1, Y3);
-      Y3 = Fp3.mul(X3, Y3);
-      X3 = Fp3.mul(t3, X3);
-      Z3 = Fp3.mul(b3, Z3);
-      t2 = Fp3.mul(a, t2);
-      t3 = Fp3.sub(t0, t2);
-      t3 = Fp3.mul(a, t3);
-      t3 = Fp3.add(t3, Z3);
-      Z3 = Fp3.add(t0, t0);
-      t0 = Fp3.add(Z3, t0);
-      t0 = Fp3.add(t0, t2);
-      t0 = Fp3.mul(t0, t3);
-      Y3 = Fp3.add(Y3, t0);
-      t2 = Fp3.mul(Y1, Z1);
-      t2 = Fp3.add(t2, t2);
-      t0 = Fp3.mul(t2, t3);
-      X3 = Fp3.sub(X3, t0);
-      Z3 = Fp3.mul(t2, t1);
-      Z3 = Fp3.add(Z3, Z3);
-      Z3 = Fp3.add(Z3, Z3);
-      return new Point2(X3, Y3, Z3);
-    }
-    add(other) {
-      assertPrjPoint(other);
-      const { px: X1, py: Y1, pz: Z1 } = this;
-      const { px: X2, py: Y2, pz: Z2 } = other;
-      let X3 = Fp3.ZERO, Y3 = Fp3.ZERO, Z3 = Fp3.ZERO;
-      const a = CURVE.a;
-      const b3 = Fp3.mul(CURVE.b, _3n2);
-      let t0 = Fp3.mul(X1, X2);
-      let t1 = Fp3.mul(Y1, Y2);
-      let t2 = Fp3.mul(Z1, Z2);
-      let t3 = Fp3.add(X1, Y1);
-      let t4 = Fp3.add(X2, Y2);
-      t3 = Fp3.mul(t3, t4);
-      t4 = Fp3.add(t0, t1);
-      t3 = Fp3.sub(t3, t4);
-      t4 = Fp3.add(X1, Z1);
-      let t5 = Fp3.add(X2, Z2);
-      t4 = Fp3.mul(t4, t5);
-      t5 = Fp3.add(t0, t2);
-      t4 = Fp3.sub(t4, t5);
-      t5 = Fp3.add(Y1, Z1);
-      X3 = Fp3.add(Y2, Z2);
-      t5 = Fp3.mul(t5, X3);
-      X3 = Fp3.add(t1, t2);
-      t5 = Fp3.sub(t5, X3);
-      Z3 = Fp3.mul(a, t4);
-      X3 = Fp3.mul(b3, t2);
-      Z3 = Fp3.add(X3, Z3);
-      X3 = Fp3.sub(t1, Z3);
-      Z3 = Fp3.add(t1, Z3);
-      Y3 = Fp3.mul(X3, Z3);
-      t1 = Fp3.add(t0, t0);
-      t1 = Fp3.add(t1, t0);
-      t2 = Fp3.mul(a, t2);
-      t4 = Fp3.mul(b3, t4);
-      t1 = Fp3.add(t1, t2);
-      t2 = Fp3.sub(t0, t2);
-      t2 = Fp3.mul(a, t2);
-      t4 = Fp3.add(t4, t2);
-      t0 = Fp3.mul(t1, t4);
-      Y3 = Fp3.add(Y3, t0);
-      t0 = Fp3.mul(t5, t4);
-      X3 = Fp3.mul(t3, X3);
-      X3 = Fp3.sub(X3, t0);
-      t0 = Fp3.mul(t3, t1);
-      Z3 = Fp3.mul(t5, Z3);
-      Z3 = Fp3.add(Z3, t0);
-      return new Point2(X3, Y3, Z3);
-    }
-    subtract(other) {
-      return this.add(other.negate());
-    }
-    is0() {
-      return this.equals(Point2.ZERO);
-    }
-    wNAF(n) {
-      return wnaf.wNAFCached(this, pointPrecomputes, n, (comp) => {
-        const toInv = Fp3.invertBatch(comp.map((p) => p.pz));
-        return comp.map((p, i) => p.toAffine(toInv[i])).map(Point2.fromAffine);
-      });
-    }
-    multiplyUnsafe(n) {
-      const I = Point2.ZERO;
-      if (n === _0n4)
-        return I;
-      assertGE(n);
-      if (n === _1n4)
-        return this;
-      const { endo } = CURVE;
-      if (!endo)
-        return wnaf.unsafeLadder(this, n);
-      let { k1neg, k1, k2neg, k2 } = endo.splitScalar(n);
-      let k1p = I;
-      let k2p = I;
-      let d = this;
-      while (k1 > _0n4 || k2 > _0n4) {
-        if (k1 & _1n4)
-          k1p = k1p.add(d);
-        if (k2 & _1n4)
-          k2p = k2p.add(d);
-        d = d.double();
-        k1 >>= _1n4;
-        k2 >>= _1n4;
-      }
-      if (k1neg)
-        k1p = k1p.negate();
-      if (k2neg)
-        k2p = k2p.negate();
-      k2p = new Point2(Fp3.mul(k2p.px, endo.beta), k2p.py, k2p.pz);
-      return k1p.add(k2p);
-    }
-    multiply(scalar) {
-      assertGE(scalar);
-      let n = scalar;
-      let point, fake;
-      const { endo } = CURVE;
-      if (endo) {
-        const { k1neg, k1, k2neg, k2 } = endo.splitScalar(n);
-        let { p: k1p, f: f1p } = this.wNAF(k1);
-        let { p: k2p, f: f2p } = this.wNAF(k2);
-        k1p = wnaf.constTimeNegate(k1neg, k1p);
-        k2p = wnaf.constTimeNegate(k2neg, k2p);
-        k2p = new Point2(Fp3.mul(k2p.px, endo.beta), k2p.py, k2p.pz);
-        point = k1p.add(k2p);
-        fake = f1p.add(f2p);
-      } else {
-        const { p, f } = this.wNAF(n);
-        point = p;
-        fake = f;
-      }
-      return Point2.normalizeZ([point, fake])[0];
-    }
-    multiplyAndAddUnsafe(Q, a, b) {
-      const G = Point2.BASE;
-      const mul = (P, a2) => a2 === _0n4 || a2 === _1n4 || !P.equals(G) ? P.multiplyUnsafe(a2) : P.multiply(a2);
-      const sum = mul(this, a).add(mul(Q, b));
-      return sum.is0() ? void 0 : sum;
-    }
-    toAffine(iz) {
-      const { px: x, py: y, pz: z } = this;
-      const is0 = this.is0();
-      if (iz == null)
-        iz = is0 ? Fp3.ONE : Fp3.inv(z);
-      const ax = Fp3.mul(x, iz);
-      const ay = Fp3.mul(y, iz);
-      const zz = Fp3.mul(z, iz);
-      if (is0)
-        return { x: Fp3.ZERO, y: Fp3.ZERO };
-      if (!Fp3.eql(zz, Fp3.ONE))
-        throw new Error("invZ was invalid");
-      return { x: ax, y: ay };
-    }
-    isTorsionFree() {
-      const { h: cofactor, isTorsionFree } = CURVE;
-      if (cofactor === _1n4)
-        return true;
-      if (isTorsionFree)
-        return isTorsionFree(Point2, this);
-      throw new Error("isTorsionFree() has not been declared for the elliptic curve");
-    }
-    clearCofactor() {
-      const { h: cofactor, clearCofactor } = CURVE;
-      if (cofactor === _1n4)
-        return this;
-      if (clearCofactor)
-        return clearCofactor(Point2, this);
-      return this.multiplyUnsafe(CURVE.h);
-    }
-    toRawBytes(isCompressed = true) {
-      this.assertValidity();
-      return toBytes2(Point2, this, isCompressed);
-    }
-    toHex(isCompressed = true) {
-      return bytesToHex(this.toRawBytes(isCompressed));
-    }
-  }
-  Point2.BASE = new Point2(CURVE.Gx, CURVE.Gy, Fp3.ONE);
-  Point2.ZERO = new Point2(Fp3.ZERO, Fp3.ONE, Fp3.ZERO);
-  const _bits = CURVE.nBitLength;
-  const wnaf = wNAF(Point2, CURVE.endo ? Math.ceil(_bits / 2) : _bits);
-  return {
-    CURVE,
-    ProjectivePoint: Point2,
-    normPrivateKeyToScalar,
-    weierstrassEquation,
-    isWithinCurveOrder
-  };
-}
-function validateOpts(curve) {
-  const opts = validateBasic(curve);
-  validateObject(opts, {
-    hash: "hash",
-    hmac: "function",
-    randomBytes: "function"
-  }, {
-    bits2int: "function",
-    bits2int_modN: "function",
-    lowS: "boolean"
-  });
-  return Object.freeze({ lowS: true, ...opts });
-}
-function weierstrass(curveDef) {
-  const CURVE = validateOpts(curveDef);
-  const { Fp: Fp3, n: CURVE_ORDER } = CURVE;
-  const compressedLen = Fp3.BYTES + 1;
-  const uncompressedLen = 2 * Fp3.BYTES + 1;
-  function isValidFieldElement(num) {
-    return _0n4 < num && num < Fp3.ORDER;
-  }
-  function modN(a) {
-    return mod(a, CURVE_ORDER);
-  }
-  function invN(a) {
-    return invert(a, CURVE_ORDER);
-  }
-  const { ProjectivePoint: Point2, normPrivateKeyToScalar, weierstrassEquation, isWithinCurveOrder } = weierstrassPoints({
-    ...CURVE,
-    toBytes(c, point, isCompressed) {
-      const a = point.toAffine();
-      const x = Fp3.toBytes(a.x);
-      const cat = concatBytes2;
-      if (isCompressed) {
-        return cat(Uint8Array.from([point.hasEvenY() ? 2 : 3]), x);
-      } else {
-        return cat(Uint8Array.from([4]), x, Fp3.toBytes(a.y));
-      }
-    },
-    fromBytes(bytes2) {
-      const len = bytes2.length;
-      const head = bytes2[0];
-      const tail = bytes2.subarray(1);
-      if (len === compressedLen && (head === 2 || head === 3)) {
-        const x = bytesToNumberBE(tail);
-        if (!isValidFieldElement(x))
-          throw new Error("Point is not on curve");
-        const y2 = weierstrassEquation(x);
-        let y = Fp3.sqrt(y2);
-        const isYOdd = (y & _1n4) === _1n4;
-        const isHeadOdd = (head & 1) === 1;
-        if (isHeadOdd !== isYOdd)
-          y = Fp3.neg(y);
-        return { x, y };
-      } else if (len === uncompressedLen && head === 4) {
-        const x = Fp3.fromBytes(tail.subarray(0, Fp3.BYTES));
-        const y = Fp3.fromBytes(tail.subarray(Fp3.BYTES, 2 * Fp3.BYTES));
-        return { x, y };
-      } else {
-        throw new Error(`Point of length ${len} was invalid. Expected ${compressedLen} compressed bytes or ${uncompressedLen} uncompressed bytes`);
-      }
-    }
-  });
-  const numToNByteStr = (num) => bytesToHex(numberToBytesBE(num, CURVE.nByteLength));
-  function isBiggerThanHalfOrder(number2) {
-    const HALF = CURVE_ORDER >> _1n4;
-    return number2 > HALF;
-  }
-  function normalizeS(s) {
-    return isBiggerThanHalfOrder(s) ? modN(-s) : s;
-  }
-  const slcNum = (b, from3, to) => bytesToNumberBE(b.slice(from3, to));
-  class Signature {
-    constructor(r, s, recovery) {
-      this.r = r;
-      this.s = s;
-      this.recovery = recovery;
-      this.assertValidity();
-    }
-    static fromCompact(hex) {
-      const l = CURVE.nByteLength;
-      hex = ensureBytes("compactSignature", hex, l * 2);
-      return new Signature(slcNum(hex, 0, l), slcNum(hex, l, 2 * l));
-    }
-    static fromDER(hex) {
-      const { r, s } = DER.toSig(ensureBytes("DER", hex));
-      return new Signature(r, s);
-    }
-    assertValidity() {
-      if (!isWithinCurveOrder(this.r))
-        throw new Error("r must be 0 < r < CURVE.n");
-      if (!isWithinCurveOrder(this.s))
-        throw new Error("s must be 0 < s < CURVE.n");
-    }
-    addRecoveryBit(recovery) {
-      return new Signature(this.r, this.s, recovery);
-    }
-    recoverPublicKey(msgHash) {
-      const { r, s, recovery: rec } = this;
-      const h = bits2int_modN(ensureBytes("msgHash", msgHash));
-      if (rec == null || ![0, 1, 2, 3].includes(rec))
-        throw new Error("recovery id invalid");
-      const radj = rec === 2 || rec === 3 ? r + CURVE.n : r;
-      if (radj >= Fp3.ORDER)
-        throw new Error("recovery id 2 or 3 invalid");
-      const prefix = (rec & 1) === 0 ? "02" : "03";
-      const R = Point2.fromHex(prefix + numToNByteStr(radj));
-      const ir = invN(radj);
-      const u1 = modN(-h * ir);
-      const u2 = modN(s * ir);
-      const Q = Point2.BASE.multiplyAndAddUnsafe(R, u1, u2);
-      if (!Q)
-        throw new Error("point at infinify");
-      Q.assertValidity();
-      return Q;
-    }
-    hasHighS() {
-      return isBiggerThanHalfOrder(this.s);
-    }
-    normalizeS() {
-      return this.hasHighS() ? new Signature(this.r, modN(-this.s), this.recovery) : this;
-    }
-    toDERRawBytes() {
-      return hexToBytes(this.toDERHex());
-    }
-    toDERHex() {
-      return DER.hexFromSig({ r: this.r, s: this.s });
-    }
-    toCompactRawBytes() {
-      return hexToBytes(this.toCompactHex());
-    }
-    toCompactHex() {
-      return numToNByteStr(this.r) + numToNByteStr(this.s);
-    }
-  }
-  const utils = {
-    isValidPrivateKey(privateKey) {
-      try {
-        normPrivateKeyToScalar(privateKey);
-        return true;
-      } catch (error) {
-        return false;
-      }
-    },
-    normPrivateKeyToScalar,
-    randomPrivateKey: () => {
-      const rand = CURVE.randomBytes(Fp3.BYTES + 8);
-      const num = hashToPrivateScalar(rand, CURVE_ORDER);
-      return numberToBytesBE(num, CURVE.nByteLength);
-    },
-    precompute(windowSize = 8, point = Point2.BASE) {
-      point._setWindowSize(windowSize);
-      point.multiply(BigInt(3));
-      return point;
-    }
-  };
-  function getPublicKey(privateKey, isCompressed = true) {
-    return Point2.fromPrivateKey(privateKey).toRawBytes(isCompressed);
-  }
-  function isProbPub(item) {
-    const arr = item instanceof Uint8Array;
-    const str = typeof item === "string";
-    const len = (arr || str) && item.length;
-    if (arr)
-      return len === compressedLen || len === uncompressedLen;
-    if (str)
-      return len === 2 * compressedLen || len === 2 * uncompressedLen;
-    if (item instanceof Point2)
-      return true;
-    return false;
-  }
-  function getSharedSecret(privateA, publicB, isCompressed = true) {
-    if (isProbPub(privateA))
-      throw new Error("first arg must be private key");
-    if (!isProbPub(publicB))
-      throw new Error("second arg must be public key");
-    const b = Point2.fromHex(publicB);
-    return b.multiply(normPrivateKeyToScalar(privateA)).toRawBytes(isCompressed);
-  }
-  const bits2int = CURVE.bits2int || function(bytes2) {
-    const num = bytesToNumberBE(bytes2);
-    const delta = bytes2.length * 8 - CURVE.nBitLength;
-    return delta > 0 ? num >> BigInt(delta) : num;
-  };
-  const bits2int_modN = CURVE.bits2int_modN || function(bytes2) {
-    return modN(bits2int(bytes2));
-  };
-  const ORDER_MASK = bitMask(CURVE.nBitLength);
-  function int2octets(num) {
-    if (typeof num !== "bigint")
-      throw new Error("bigint expected");
-    if (!(_0n4 <= num && num < ORDER_MASK))
-      throw new Error(`bigint expected < 2^${CURVE.nBitLength}`);
-    return numberToBytesBE(num, CURVE.nByteLength);
-  }
-  function prepSig(msgHash, privateKey, opts = defaultSigOpts) {
-    if (["recovered", "canonical"].some((k) => k in opts))
-      throw new Error("sign() legacy options not supported");
-    const { hash: hash2, randomBytes: randomBytes3 } = CURVE;
-    let { lowS, prehash, extraEntropy: ent } = opts;
-    if (lowS == null)
-      lowS = true;
-    msgHash = ensureBytes("msgHash", msgHash);
-    if (prehash)
-      msgHash = ensureBytes("prehashed msgHash", hash2(msgHash));
-    const h1int = bits2int_modN(msgHash);
-    const d = normPrivateKeyToScalar(privateKey);
-    const seedArgs = [int2octets(d), int2octets(h1int)];
-    if (ent != null) {
-      const e = ent === true ? randomBytes3(Fp3.BYTES) : ent;
-      seedArgs.push(ensureBytes("extraEntropy", e, Fp3.BYTES));
-    }
-    const seed = concatBytes2(...seedArgs);
-    const m = h1int;
-    function k2sig(kBytes) {
-      const k = bits2int(kBytes);
-      if (!isWithinCurveOrder(k))
-        return;
-      const ik = invN(k);
-      const q = Point2.BASE.multiply(k).toAffine();
-      const r = modN(q.x);
-      if (r === _0n4)
-        return;
-      const s = modN(ik * modN(m + r * d));
-      if (s === _0n4)
-        return;
-      let recovery = (q.x === r ? 0 : 2) | Number(q.y & _1n4);
-      let normS = s;
-      if (lowS && isBiggerThanHalfOrder(s)) {
-        normS = normalizeS(s);
-        recovery ^= 1;
-      }
-      return new Signature(r, normS, recovery);
-    }
-    return { seed, k2sig };
-  }
-  const defaultSigOpts = { lowS: CURVE.lowS, prehash: false };
-  const defaultVerOpts = { lowS: CURVE.lowS, prehash: false };
-  function sign(msgHash, privKey, opts = defaultSigOpts) {
-    const { seed, k2sig } = prepSig(msgHash, privKey, opts);
-    const C = CURVE;
-    const drbg = createHmacDrbg(C.hash.outputLen, C.nByteLength, C.hmac);
-    return drbg(seed, k2sig);
-  }
-  Point2.BASE._setWindowSize(8);
-  function verify(signature, msgHash, publicKey, opts = defaultVerOpts) {
-    const sg = signature;
-    msgHash = ensureBytes("msgHash", msgHash);
-    publicKey = ensureBytes("publicKey", publicKey);
-    if ("strict" in opts)
-      throw new Error("options.strict was renamed to lowS");
-    const { lowS, prehash } = opts;
-    let _sig = void 0;
-    let P;
-    try {
-      if (typeof sg === "string" || sg instanceof Uint8Array) {
-        try {
-          _sig = Signature.fromDER(sg);
-        } catch (derError) {
-          if (!(derError instanceof DER.Err))
-            throw derError;
-          _sig = Signature.fromCompact(sg);
-        }
-      } else if (typeof sg === "object" && typeof sg.r === "bigint" && typeof sg.s === "bigint") {
-        const { r: r2, s: s2 } = sg;
-        _sig = new Signature(r2, s2);
-      } else {
-        throw new Error("PARSE");
-      }
-      P = Point2.fromHex(publicKey);
-    } catch (error) {
-      if (error.message === "PARSE")
-        throw new Error(`signature must be Signature instance, Uint8Array or hex string`);
-      return false;
-    }
-    if (lowS && _sig.hasHighS())
-      return false;
-    if (prehash)
-      msgHash = CURVE.hash(msgHash);
-    const { r, s } = _sig;
-    const h = bits2int_modN(msgHash);
-    const is = invN(s);
-    const u1 = modN(h * is);
-    const u2 = modN(r * is);
-    const R = Point2.BASE.multiplyAndAddUnsafe(P, u1, u2)?.toAffine();
-    if (!R)
-      return false;
-    const v = modN(R.x);
-    return v === r;
-  }
-  return {
-    CURVE,
-    getPublicKey,
-    getSharedSecret,
-    sign,
-    verify,
-    ProjectivePoint: Point2,
-    Signature,
-    utils
-  };
-}
-
-// ../../node_modules/.pnpm/@noble+curves@1.1.0/node_modules/@noble/curves/esm/_shortw_utils.js
-function getHash(hash2) {
-  return {
-    hash: hash2,
-    hmac: (key, ...msgs) => hmac(hash2, key, concatBytes(...msgs)),
-    randomBytes
-  };
-}
-function createCurve(curveDef, defHash) {
-  const create2 = (hash2) => weierstrass({ ...curveDef, ...getHash(hash2) });
-  return Object.freeze({ ...create2(defHash), create: create2 });
-}
-
-// ../../node_modules/.pnpm/@noble+hashes@1.3.1/node_modules/@noble/hashes/esm/_sha2.js
-function setBigUint64(view, byteOffset, value, isLE2) {
-  if (typeof view.setBigUint64 === "function")
-    return view.setBigUint64(byteOffset, value, isLE2);
-  const _32n = BigInt(32);
-  const _u32_max = BigInt(4294967295);
-  const wh = Number(value >> _32n & _u32_max);
-  const wl = Number(value & _u32_max);
-  const h = isLE2 ? 4 : 0;
-  const l = isLE2 ? 0 : 4;
-  view.setUint32(byteOffset + h, wh, isLE2);
-  view.setUint32(byteOffset + l, wl, isLE2);
-}
-var SHA2 = class extends Hash {
-  constructor(blockLen, outputLen, padOffset, isLE2) {
-    super();
-    this.blockLen = blockLen;
-    this.outputLen = outputLen;
-    this.padOffset = padOffset;
-    this.isLE = isLE2;
-    this.finished = false;
-    this.length = 0;
-    this.pos = 0;
-    this.destroyed = false;
-    this.buffer = new Uint8Array(blockLen);
-    this.view = createView(this.buffer);
-  }
-  update(data) {
-    assert_default.exists(this);
-    const { view, buffer, blockLen } = this;
-    data = toBytes(data);
-    const len = data.length;
-    for (let pos = 0; pos < len; ) {
-      const take = Math.min(blockLen - this.pos, len - pos);
-      if (take === blockLen) {
-        const dataView = createView(data);
-        for (; blockLen <= len - pos; pos += blockLen)
-          this.process(dataView, pos);
-        continue;
-      }
-      buffer.set(data.subarray(pos, pos + take), this.pos);
-      this.pos += take;
-      pos += take;
-      if (this.pos === blockLen) {
-        this.process(view, 0);
-        this.pos = 0;
-      }
-    }
-    this.length += data.length;
-    this.roundClean();
-    return this;
-  }
-  digestInto(out) {
-    assert_default.exists(this);
-    assert_default.output(out, this);
-    this.finished = true;
-    const { buffer, view, blockLen, isLE: isLE2 } = this;
-    let { pos } = this;
-    buffer[pos++] = 128;
-    this.buffer.subarray(pos).fill(0);
-    if (this.padOffset > blockLen - pos) {
-      this.process(view, 0);
-      pos = 0;
-    }
-    for (let i = pos; i < blockLen; i++)
-      buffer[i] = 0;
-    setBigUint64(view, blockLen - 8, BigInt(this.length * 8), isLE2);
-    this.process(view, 0);
-    const oview = createView(out);
-    const len = this.outputLen;
-    if (len % 4)
-      throw new Error("_sha2: outputLen should be aligned to 32bit");
-    const outLen = len / 4;
-    const state = this.get();
-    if (outLen > state.length)
-      throw new Error("_sha2: outputLen bigger than state");
-    for (let i = 0; i < outLen; i++)
-      oview.setUint32(4 * i, state[i], isLE2);
-  }
-  digest() {
-    const { buffer, outputLen } = this;
-    this.digestInto(buffer);
-    const res = buffer.slice(0, outputLen);
-    this.destroy();
-    return res;
-  }
-  _cloneInto(to) {
-    to || (to = new this.constructor());
-    to.set(...this.get());
-    const { blockLen, buffer, length: length2, finished, destroyed, pos } = this;
-    to.length = length2;
-    to.pos = pos;
-    to.finished = finished;
-    to.destroyed = destroyed;
-    if (length2 % blockLen)
-      to.buffer.set(buffer);
-    return to;
-  }
-};
-
-// ../../node_modules/.pnpm/@noble+hashes@1.3.1/node_modules/@noble/hashes/esm/sha256.js
-var Chi = (a, b, c) => a & b ^ ~a & c;
-var Maj = (a, b, c) => a & b ^ a & c ^ b & c;
-var SHA256_K = new Uint32Array([
-  1116352408,
-  1899447441,
-  3049323471,
-  3921009573,
-  961987163,
-  1508970993,
-  2453635748,
-  2870763221,
-  3624381080,
-  310598401,
-  607225278,
-  1426881987,
-  1925078388,
-  2162078206,
-  2614888103,
-  3248222580,
-  3835390401,
-  4022224774,
-  264347078,
-  604807628,
-  770255983,
-  1249150122,
-  1555081692,
-  1996064986,
-  2554220882,
-  2821834349,
-  2952996808,
-  3210313671,
-  3336571891,
-  3584528711,
-  113926993,
-  338241895,
-  666307205,
-  773529912,
-  1294757372,
-  1396182291,
-  1695183700,
-  1986661051,
-  2177026350,
-  2456956037,
-  2730485921,
-  2820302411,
-  3259730800,
-  3345764771,
-  3516065817,
-  3600352804,
-  4094571909,
-  275423344,
-  430227734,
-  506948616,
-  659060556,
-  883997877,
-  958139571,
-  1322822218,
-  1537002063,
-  1747873779,
-  1955562222,
-  2024104815,
-  2227730452,
-  2361852424,
-  2428436474,
-  2756734187,
-  3204031479,
-  3329325298
-]);
-var IV = new Uint32Array([
-  1779033703,
-  3144134277,
-  1013904242,
-  2773480762,
-  1359893119,
-  2600822924,
-  528734635,
-  1541459225
-]);
-var SHA256_W = new Uint32Array(64);
-var SHA256 = class extends SHA2 {
-  constructor() {
-    super(64, 32, 8, false);
-    this.A = IV[0] | 0;
-    this.B = IV[1] | 0;
-    this.C = IV[2] | 0;
-    this.D = IV[3] | 0;
-    this.E = IV[4] | 0;
-    this.F = IV[5] | 0;
-    this.G = IV[6] | 0;
-    this.H = IV[7] | 0;
-  }
-  get() {
-    const { A, B, C, D, E, F, G, H } = this;
-    return [A, B, C, D, E, F, G, H];
-  }
-  set(A, B, C, D, E, F, G, H) {
-    this.A = A | 0;
-    this.B = B | 0;
-    this.C = C | 0;
-    this.D = D | 0;
-    this.E = E | 0;
-    this.F = F | 0;
-    this.G = G | 0;
-    this.H = H | 0;
-  }
-  process(view, offset) {
-    for (let i = 0; i < 16; i++, offset += 4)
-      SHA256_W[i] = view.getUint32(offset, false);
-    for (let i = 16; i < 64; i++) {
-      const W15 = SHA256_W[i - 15];
-      const W2 = SHA256_W[i - 2];
-      const s0 = rotr(W15, 7) ^ rotr(W15, 18) ^ W15 >>> 3;
-      const s1 = rotr(W2, 17) ^ rotr(W2, 19) ^ W2 >>> 10;
-      SHA256_W[i] = s1 + SHA256_W[i - 7] + s0 + SHA256_W[i - 16] | 0;
-    }
-    let { A, B, C, D, E, F, G, H } = this;
-    for (let i = 0; i < 64; i++) {
-      const sigma1 = rotr(E, 6) ^ rotr(E, 11) ^ rotr(E, 25);
-      const T1 = H + sigma1 + Chi(E, F, G) + SHA256_K[i] + SHA256_W[i] | 0;
-      const sigma0 = rotr(A, 2) ^ rotr(A, 13) ^ rotr(A, 22);
-      const T2 = sigma0 + Maj(A, B, C) | 0;
-      H = G;
-      G = F;
-      F = E;
-      E = D + T1 | 0;
-      D = C;
-      C = B;
-      B = A;
-      A = T1 + T2 | 0;
-    }
-    A = A + this.A | 0;
-    B = B + this.B | 0;
-    C = C + this.C | 0;
-    D = D + this.D | 0;
-    E = E + this.E | 0;
-    F = F + this.F | 0;
-    G = G + this.G | 0;
-    H = H + this.H | 0;
-    this.set(A, B, C, D, E, F, G, H);
-  }
-  roundClean() {
-    SHA256_W.fill(0);
-  }
-  destroy() {
-    this.set(0, 0, 0, 0, 0, 0, 0, 0);
-    this.buffer.fill(0);
-  }
-};
-var SHA224 = class extends SHA256 {
-  constructor() {
-    super();
-    this.A = 3238371032 | 0;
-    this.B = 914150663 | 0;
-    this.C = 812702999 | 0;
-    this.D = 4144912697 | 0;
-    this.E = 4290775857 | 0;
-    this.F = 1750603025 | 0;
-    this.G = 1694076839 | 0;
-    this.H = 3204075428 | 0;
-    this.outputLen = 28;
-  }
-};
-var sha2562 = wrapConstructor(() => new SHA256());
-var sha224 = wrapConstructor(() => new SHA224());
-
-// ../../node_modules/.pnpm/@noble+curves@1.1.0/node_modules/@noble/curves/esm/p256.js
-var Fp = Field(BigInt("0xffffffff00000001000000000000000000000000ffffffffffffffffffffffff"));
-var CURVE_A = Fp.create(BigInt("-3"));
-var CURVE_B = BigInt("0x5ac635d8aa3a93e7b3ebbd55769886bc651d06b0cc53b0f63bce3c3e27d2604b");
-var p256 = createCurve({
-  a: CURVE_A,
-  b: CURVE_B,
-  Fp,
-  n: BigInt("0xffffffff00000000ffffffffffffffffbce6faada7179e84f3b9cac2fc632551"),
-  Gx: BigInt("0x6b17d1f2e12c4247f8bce6e563a440f277037d812deb33a0f4a13945d898c296"),
-  Gy: BigInt("0x4fe342e2fe1a7f9b8ee7eb4a7c0f9e162bce33576b315ececbb6406837bf51f5"),
-  h: BigInt(1),
-  lowS: false
-}, sha2562);
-
-// src/p256/encoding.ts
-var compressPubkey = (pubkeyBytes) => {
-  const point = p256.ProjectivePoint.fromHex(pubkeyBytes);
-  return point.toRawBytes(true);
-};
-var decompressPubkey = (compressed) => {
-  if (compressed.length !== 33) {
-    throw new Error("Expected 33 byte compress pubkey");
-  }
-  const point = p256.ProjectivePoint.fromHex(compressed);
-  return point.toRawBytes(false);
-};
-
-// ../../node_modules/.pnpm/@noble+curves@1.1.0/node_modules/@noble/curves/esm/secp256k1.js
-var secp256k1P = BigInt("0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2f");
-var secp256k1N = BigInt("0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141");
-var _1n5 = BigInt(1);
-var _2n4 = BigInt(2);
-var divNearest = (a, b) => (a + b / _2n4) / b;
-function sqrtMod(y) {
-  const P = secp256k1P;
-  const _3n3 = BigInt(3), _6n = BigInt(6), _11n = BigInt(11), _22n = BigInt(22);
-  const _23n = BigInt(23), _44n = BigInt(44), _88n = BigInt(88);
-  const b2 = y * y * y % P;
-  const b3 = b2 * b2 * y % P;
-  const b6 = pow2(b3, _3n3, P) * b3 % P;
-  const b9 = pow2(b6, _3n3, P) * b3 % P;
-  const b11 = pow2(b9, _2n4, P) * b2 % P;
-  const b22 = pow2(b11, _11n, P) * b11 % P;
-  const b44 = pow2(b22, _22n, P) * b22 % P;
-  const b88 = pow2(b44, _44n, P) * b44 % P;
-  const b176 = pow2(b88, _88n, P) * b88 % P;
-  const b220 = pow2(b176, _44n, P) * b44 % P;
-  const b223 = pow2(b220, _3n3, P) * b3 % P;
-  const t1 = pow2(b223, _23n, P) * b22 % P;
-  const t2 = pow2(t1, _6n, P) * b2 % P;
-  const root = pow2(t2, _2n4, P);
-  if (!Fp2.eql(Fp2.sqr(root), y))
-    throw new Error("Cannot find square root");
-  return root;
-}
-var Fp2 = Field(secp256k1P, void 0, void 0, { sqrt: sqrtMod });
-var secp256k1 = createCurve({
-  a: BigInt(0),
-  b: BigInt(7),
-  Fp: Fp2,
-  n: secp256k1N,
-  Gx: BigInt("55066263022277343669578718895168534326250603453777594175500187360389116729240"),
-  Gy: BigInt("32670510020758816978083085130507043184471273380659243275938904335757337482424"),
-  h: BigInt(1),
-  lowS: true,
-  endo: {
-    beta: BigInt("0x7ae96a2b657c07106e64479eac3434e99cf0497512f58995c1396c28719501ee"),
-    splitScalar: (k) => {
-      const n = secp256k1N;
-      const a1 = BigInt("0x3086d221a7d46bcde86c90e49284eb15");
-      const b1 = -_1n5 * BigInt("0xe4437ed6010e88286f547fa90abfe4c3");
-      const a2 = BigInt("0x114ca50f7a8e2f3f657c1108d9d44cfd8");
-      const b2 = a1;
-      const POW_2_128 = BigInt("0x100000000000000000000000000000000");
-      const c1 = divNearest(b2 * k, n);
-      const c2 = divNearest(-b1 * k, n);
-      let k1 = mod(k - c1 * a1 - c2 * a2, n);
-      let k2 = mod(-c1 * b1 - c2 * b2, n);
-      const k1neg = k1 > POW_2_128;
-      const k2neg = k2 > POW_2_128;
-      if (k1neg)
-        k1 = n - k1;
-      if (k2neg)
-        k2 = n - k2;
-      if (k1 > POW_2_128 || k2 > POW_2_128) {
-        throw new Error("splitScalar: Endomorphism failed, k=" + k);
-      }
-      return { k1neg, k1, k2neg, k2 };
-    }
-  }
-}, sha2562);
-var _0n5 = BigInt(0);
-var Point = secp256k1.ProjectivePoint;
-
-// src/secp256k1/encoding.ts
-var compressPubkey2 = (pubkeyBytes) => {
-  const point = secp256k1.ProjectivePoint.fromHex(pubkeyBytes);
-  return point.toRawBytes(true);
-};
-var decompressPubkey2 = (compressed) => {
-  if (compressed.length !== 33) {
-    throw new Error("Expected 33 byte compress pubkey");
-  }
-  const point = secp256k1.ProjectivePoint.fromHex(compressed);
-  return point.toRawBytes(false);
-};
-
-// src/p256/operations.ts
-var verifyDidSig = async (did, data, sig, opts) => {
-  const { jwtAlg, keyBytes } = parseDidKey(did);
-  if (jwtAlg !== P256_JWT_ALG) {
-    throw new Error(`Not a P-256 did:key: ${did}`);
-  }
-  return verifySig(keyBytes, data, sig, opts);
-};
-var verifySig = async (publicKey, data, sig, opts) => {
-  const allowMalleable = opts?.allowMalleableSig ?? false;
-  const msgHash = await sha2562(data);
-  if (!allowMalleable && !isCompactFormat(sig)) {
-    return false;
-  }
-  return p256.verify(sig, msgHash, publicKey, {
-    lowS: !allowMalleable
-  });
-};
-var isCompactFormat = (sig) => {
-  try {
-    const parsed = p256.Signature.fromCompact(sig);
-    return equals(parsed.toCompactRawBytes(), sig);
-  } catch {
-    return false;
-  }
-};
-
-// src/p256/plugin.ts
-var p256Plugin = {
-  prefix: P256_DID_PREFIX,
-  jwtAlg: P256_JWT_ALG,
-  verifySignature: verifyDidSig
-};
-var plugin_default = p256Plugin;
-
-// src/secp256k1/operations.ts
-var verifyDidSig2 = async (did, data, sig, opts) => {
-  const { jwtAlg, keyBytes } = parseDidKey(did);
-  if (jwtAlg !== SECP256K1_JWT_ALG) {
-    throw new Error(`Not a secp256k1 did:key: ${did}`);
-  }
-  return verifySig2(keyBytes, data, sig, opts);
-};
-var verifySig2 = async (publicKey, data, sig, opts) => {
-  const allowMalleable = opts?.allowMalleableSig ?? false;
-  const msgHash = await sha2562(data);
-  if (!allowMalleable && !isCompactFormat2(sig)) {
-    return false;
-  }
-  return secp256k1.verify(sig, msgHash, publicKey, {
-    lowS: !allowMalleable
-  });
-};
-var isCompactFormat2 = (sig) => {
-  try {
-    const parsed = secp256k1.Signature.fromCompact(sig);
-    return equals(parsed.toCompactRawBytes(), sig);
-  } catch {
-    return false;
-  }
-};
-
-// src/secp256k1/plugin.ts
-var secp256k1Plugin = {
-  prefix: SECP256K1_DID_PREFIX,
-  jwtAlg: SECP256K1_JWT_ALG,
-  verifySignature: verifyDidSig2
-};
-var plugin_default2 = secp256k1Plugin;
-
-// src/plugins.ts
-var plugins = [plugin_default, plugin_default2];
-var plugins_default = plugins;
-
-// src/did.ts
-var parseMultikey = (multikey) => {
-  if (!multikey.startsWith(BASE58_MULTIBASE_PREFIX)) {
-    throw new Error(`Incorrect prefix for multikey: ${multikey}`);
-  }
-  const prefixedBytes = fromString2(multikey.slice(BASE58_MULTIBASE_PREFIX.length), "base58btc");
-  const plugin = plugins_default.find((p) => hasPrefix(prefixedBytes, p.prefix));
-  if (!plugin) {
-    throw new Error("Unsupported key type");
-  }
-  let keyBytes = prefixedBytes.slice(plugin.prefix.length);
-  if (plugin.jwtAlg === P256_JWT_ALG) {
-    keyBytes = decompressPubkey(keyBytes);
-  } else if (plugin.jwtAlg === SECP256K1_JWT_ALG) {
-    keyBytes = decompressPubkey2(keyBytes);
-  }
-  return {
-    jwtAlg: plugin.jwtAlg,
-    keyBytes
-  };
-};
-var formatMultikey = (jwtAlg, keyBytes) => {
-  const plugin = plugins_default.find((p) => p.jwtAlg === jwtAlg);
-  if (!plugin) {
-    throw new Error("Unsupported key type");
-  }
-  if (jwtAlg === P256_JWT_ALG) {
-    keyBytes = compressPubkey(keyBytes);
-  } else if (jwtAlg === SECP256K1_JWT_ALG) {
-    keyBytes = compressPubkey2(keyBytes);
-  }
-  const prefixedBytes = concat([plugin.prefix, keyBytes]);
-  return BASE58_MULTIBASE_PREFIX + toString2(prefixedBytes, "base58btc");
-};
-var parseDidKey = (did) => {
-  if (!did.startsWith(DID_KEY_PREFIX)) {
-    throw new Error(`Incorrect prefix for did:key: ${did}`);
-  }
-  return parseMultikey(did.slice(DID_KEY_PREFIX.length));
-};
-var formatDidKey = (jwtAlg, keyBytes) => {
-  return DID_KEY_PREFIX + formatMultikey(jwtAlg, keyBytes);
-};
-var hasPrefix = (bytes2, prefix) => {
-  return equals(prefix, bytes2.subarray(0, prefix.byteLength));
-};
-
-// src/multibase.ts
-var multibaseToBytes = (mb) => {
-  const base3 = mb[0];
-  const key = mb.slice(1);
-  switch (base3) {
-    case "f":
-      return fromString2(key, "base16");
-    case "F":
-      return fromString2(key, "base16upper");
-    case "b":
-      return fromString2(key, "base32");
-    case "B":
-      return fromString2(key, "base32upper");
-    case "z":
-      return fromString2(key, "base58btc");
-    case "m":
-      return fromString2(key, "base64");
-    case "u":
-      return fromString2(key, "base64url");
-    case "U":
-      return fromString2(key, "base64urlpad");
-    default:
-      throw new Error(`Unsupported multibase: :${mb}`);
-  }
-};
-var bytesToMultibase = (mb, encoding) => {
-  switch (encoding) {
-    case "base16":
-      return "f" + toString2(mb, encoding);
-    case "base16upper":
-      return "F" + toString2(mb, encoding);
-    case "base32":
-      return "b" + toString2(mb, encoding);
-    case "base32upper":
-      return "B" + toString2(mb, encoding);
-    case "base58btc":
-      return "z" + toString2(mb, encoding);
-    case "base64":
-      return "m" + toString2(mb, encoding);
-    case "base64url":
-      return "u" + toString2(mb, encoding);
-    case "base64urlpad":
-      return "U" + toString2(mb, encoding);
-    default:
-      throw new Error(`Unsupported multibase: :${mb}`);
-  }
-};
-
-// src/sha.ts
-var sha2563 = async (input) => {
-  const bytes2 = typeof input === "string" ? fromString2(input, "utf8") : input;
-  return sha2562(bytes2);
-};
-
-// src/random.ts
-var randomBytes2 = randomBytes;
-var randomStr = (byteLength, encoding) => {
-  const bytes2 = randomBytes2(byteLength);
-  return toString2(bytes2, encoding);
-};
-var randomIntFromSeed = async (seed, high, low = 0) => {
-  const hash2 = await sha2563(seed);
-  const number2 = Buffer.from(hash2).readUintBE(0, 6);
-  const range = high - low;
-  const normalized = number2 % range;
-  return normalized + low;
-};
-
-// src/verify.ts
-var verifySignature = (didKey, data, sig, opts) => {
-  const parsed = parseDidKey(didKey);
-  const plugin = plugins_default.find((p) => p.jwtAlg === parsed.jwtAlg);
-  if (!plugin) {
-    throw new Error(`Unsupported signature alg: ${parsed.jwtAlg}`);
-  }
-  return plugin.verifySignature(didKey, data, sig, opts);
-};
-var verifySignatureUtf8 = async (didKey, data, sig, opts) => {
-  const dataBytes = fromString2(data, "utf8");
-  const sigBytes = fromString2(sig, "base64url");
-  return verifySignature(didKey, dataBytes, sigBytes, opts);
-};
-
-// src/p256/keypair.ts
-var P256Keypair = class {
-  constructor(privateKey, exportable) {
-    this.privateKey = privateKey;
-    this.exportable = exportable;
-    this.jwtAlg = P256_JWT_ALG;
-    this.publicKey = p256.getPublicKey(privateKey);
-  }
-  static async create(opts) {
-    const { exportable = false } = opts || {};
-    const privKey = p256.utils.randomPrivateKey();
-    return new P256Keypair(privKey, exportable);
-  }
-  static async import(privKey, opts) {
-    const { exportable = false } = opts || {};
-    const privKeyBytes = typeof privKey === "string" ? fromString2(privKey, "hex") : privKey;
-    return new P256Keypair(privKeyBytes, exportable);
-  }
-  publicKeyBytes() {
-    return this.publicKey;
-  }
-  publicKeyStr(encoding = "base64pad") {
-    return toString2(this.publicKey, encoding);
-  }
-  did() {
-    return formatDidKey(this.jwtAlg, this.publicKey);
-  }
-  async sign(msg) {
-    const msgHash = await sha2562(msg);
-    const sig = await p256.sign(msgHash, this.privateKey, { lowS: true });
-    return sig.toCompactRawBytes();
-  }
-  async export() {
-    if (!this.exportable) {
-      throw new Error("Private key is not exportable");
-    }
-    return this.privateKey;
-  }
-};
-
-// src/secp256k1/keypair.ts
-var Secp256k1Keypair = class {
-  constructor(privateKey, exportable) {
-    this.privateKey = privateKey;
-    this.exportable = exportable;
-    this.jwtAlg = SECP256K1_JWT_ALG;
-    this.publicKey = secp256k1.getPublicKey(privateKey);
-  }
-  static async create(opts) {
-    const { exportable = false } = opts || {};
-    const privKey = secp256k1.utils.randomPrivateKey();
-    return new Secp256k1Keypair(privKey, exportable);
-  }
-  static async import(privKey, opts) {
-    const { exportable = false } = opts || {};
-    const privKeyBytes = typeof privKey === "string" ? fromString2(privKey, "hex") : privKey;
-    return new Secp256k1Keypair(privKeyBytes, exportable);
-  }
-  publicKeyBytes() {
-    return this.publicKey;
-  }
-  publicKeyStr(encoding = "base64pad") {
-    return toString2(this.publicKey, encoding);
-  }
-  did() {
-    return formatDidKey(this.jwtAlg, this.publicKey);
-  }
-  async sign(msg) {
-    const msgHash = await sha2562(msg);
-    const sig = await secp256k1.sign(msgHash, this.privateKey, { lowS: true });
-    return sig.toCompactRawBytes();
-  }
-  async export() {
-    if (!this.exportable) {
-      throw new Error("Private key is not exportable");
-    }
-    return this.privateKey;
-  }
-};
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  BASE58_MULTIBASE_PREFIX,
-  DID_KEY_PREFIX,
-  P256Keypair,
-  P256_DID_PREFIX,
-  P256_JWT_ALG,
-  SECP256K1_DID_PREFIX,
-  SECP256K1_JWT_ALG,
-  Secp256k1Keypair,
-  bytesToMultibase,
-  formatDidKey,
-  formatMultikey,
-  multibaseToBytes,
-  p256Plugin,
-  parseDidKey,
-  parseMultikey,
-  randomBytes,
-  randomIntFromSeed,
-  randomStr,
-  secp256k1Plugin,
-  sha256,
-  verifySignature,
-  verifySignatureUtf8
-});
-/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
-/*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) */
-//# sourceMappingURL=index.js.map
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./const"), exports);
+__exportStar(require("./did"), exports);
+__exportStar(require("./multibase"), exports);
+__exportStar(require("./random"), exports);
+__exportStar(require("./sha"), exports);
+__exportStar(require("./types"), exports);
+__exportStar(require("./verify"), exports);
+__exportStar(require("./p256/keypair"), exports);
+__exportStar(require("./p256/plugin"), exports);
+__exportStar(require("./secp256k1/keypair"), exports);
+__exportStar(require("./secp256k1/plugin"), exports);
+//# sourceMappingURL=index.js.map