@atproto/crypto 0.1.1 → 0.2.1

package/dist/index.js

@@ -5,9 +5,6 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __commonJS = (cb, mod2) => function __require() {
-  return mod2 || (0, cb[__getOwnPropNames(cb)[0]])((mod2 = { exports: {} }).exports, mod2), mod2.exports;
-};
 var __export = (target, all) => {
   for (var name2 in all)
     __defProp(target, name2, { get: all[name2], enumerable: true });
@@ -26,1404 +23,54 @@ var __toESM = (mod2, isNodeMode, target) => (target = mod2 != null ? __create(__
 ));
 var __toCommonJS = (mod2) => __copyProps(__defProp({}, "__esModule", { value: true }), mod2);
 
-// ../../node_modules/big-integer/BigInteger.js
-var require_BigInteger = __commonJS({
-  "../../node_modules/big-integer/BigInteger.js"(exports, module2) {
-    var bigInt2 = function(undefined2) {
-      "use strict";
-      var BASE = 1e7, LOG_BASE = 7, MAX_INT = 9007199254740992, MAX_INT_ARR = smallToArray(MAX_INT), DEFAULT_ALPHABET = "0123456789abcdefghijklmnopqrstuvwxyz";
-      var supportsNativeBigInt = typeof BigInt === "function";
-      function Integer(v, radix, alphabet2, caseSensitive) {
-        if (typeof v === "undefined")
-          return Integer[0];
-        if (typeof radix !== "undefined")
-          return +radix === 10 && !alphabet2 ? parseValue(v) : parseBase(v, radix, alphabet2, caseSensitive);
-        return parseValue(v);
-      }
-      function BigInteger(value, sign2) {
-        this.value = value;
-        this.sign = sign2;
-        this.isSmall = false;
-      }
-      BigInteger.prototype = Object.create(Integer.prototype);
-      function SmallInteger(value) {
-        this.value = value;
-        this.sign = value < 0;
-        this.isSmall = true;
-      }
-      SmallInteger.prototype = Object.create(Integer.prototype);
-      function NativeBigInt(value) {
-        this.value = value;
-      }
-      NativeBigInt.prototype = Object.create(Integer.prototype);
-      function isPrecise(n) {
-        return -MAX_INT < n && n < MAX_INT;
-      }
-      function smallToArray(n) {
-        if (n < 1e7)
-          return [n];
-        if (n < 1e14)
-          return [n % 1e7, Math.floor(n / 1e7)];
-        return [n % 1e7, Math.floor(n / 1e7) % 1e7, Math.floor(n / 1e14)];
-      }
-      function arrayToSmall(arr) {
-        trim(arr);
-        var length2 = arr.length;
-        if (length2 < 4 && compareAbs(arr, MAX_INT_ARR) < 0) {
-          switch (length2) {
-            case 0:
-              return 0;
-            case 1:
-              return arr[0];
-            case 2:
-              return arr[0] + arr[1] * BASE;
-            default:
-              return arr[0] + (arr[1] + arr[2] * BASE) * BASE;
-          }
-        }
-        return arr;
-      }
-      function trim(v) {
-        var i2 = v.length;
-        while (v[--i2] === 0)
-          ;
-        v.length = i2 + 1;
-      }
-      function createArray(length2) {
-        var x = new Array(length2);
-        var i2 = -1;
-        while (++i2 < length2) {
-          x[i2] = 0;
-        }
-        return x;
-      }
-      function truncate(n) {
-        if (n > 0)
-          return Math.floor(n);
-        return Math.ceil(n);
-      }
-      function add(a, b) {
-        var l_a = a.length, l_b = b.length, r = new Array(l_a), carry = 0, base3 = BASE, sum, i2;
-        for (i2 = 0; i2 < l_b; i2++) {
-          sum = a[i2] + b[i2] + carry;
-          carry = sum >= base3 ? 1 : 0;
-          r[i2] = sum - carry * base3;
-        }
-        while (i2 < l_a) {
-          sum = a[i2] + carry;
-          carry = sum === base3 ? 1 : 0;
-          r[i2++] = sum - carry * base3;
-        }
-        if (carry > 0)
-          r.push(carry);
-        return r;
-      }
-      function addAny(a, b) {
-        if (a.length >= b.length)
-          return add(a, b);
-        return add(b, a);
-      }
-      function addSmall(a, carry) {
-        var l = a.length, r = new Array(l), base3 = BASE, sum, i2;
-        for (i2 = 0; i2 < l; i2++) {
-          sum = a[i2] - base3 + carry;
-          carry = Math.floor(sum / base3);
-          r[i2] = sum - carry * base3;
-          carry += 1;
-        }
-        while (carry > 0) {
-          r[i2++] = carry % base3;
-          carry = Math.floor(carry / base3);
-        }
-        return r;
-      }
-      BigInteger.prototype.add = function(v) {
-        var n = parseValue(v);
-        if (this.sign !== n.sign) {
-          return this.subtract(n.negate());
-        }
-        var a = this.value, b = n.value;
-        if (n.isSmall) {
-          return new BigInteger(addSmall(a, Math.abs(b)), this.sign);
-        }
-        return new BigInteger(addAny(a, b), this.sign);
-      };
-      BigInteger.prototype.plus = BigInteger.prototype.add;
-      SmallInteger.prototype.add = function(v) {
-        var n = parseValue(v);
-        var a = this.value;
-        if (a < 0 !== n.sign) {
-          return this.subtract(n.negate());
-        }
-        var b = n.value;
-        if (n.isSmall) {
-          if (isPrecise(a + b))
-            return new SmallInteger(a + b);
-          b = smallToArray(Math.abs(b));
-        }
-        return new BigInteger(addSmall(b, Math.abs(a)), a < 0);
-      };
-      SmallInteger.prototype.plus = SmallInteger.prototype.add;
-      NativeBigInt.prototype.add = function(v) {
-        return new NativeBigInt(this.value + parseValue(v).value);
-      };
-      NativeBigInt.prototype.plus = NativeBigInt.prototype.add;
-      function subtract(a, b) {
-        var a_l = a.length, b_l = b.length, r = new Array(a_l), borrow = 0, base3 = BASE, i2, difference;
-        for (i2 = 0; i2 < b_l; i2++) {
-          difference = a[i2] - borrow - b[i2];
-          if (difference < 0) {
-            difference += base3;
-            borrow = 1;
-          } else
-            borrow = 0;
-          r[i2] = difference;
-        }
-        for (i2 = b_l; i2 < a_l; i2++) {
-          difference = a[i2] - borrow;
-          if (difference < 0)
-            difference += base3;
-          else {
-            r[i2++] = difference;
-            break;
-          }
-          r[i2] = difference;
-        }
-        for (; i2 < a_l; i2++) {
-          r[i2] = a[i2];
-        }
-        trim(r);
-        return r;
-      }
-      function subtractAny(a, b, sign2) {
-        var value;
-        if (compareAbs(a, b) >= 0) {
-          value = subtract(a, b);
-        } else {
-          value = subtract(b, a);
-          sign2 = !sign2;
-        }
-        value = arrayToSmall(value);
-        if (typeof value === "number") {
-          if (sign2)
-            value = -value;
-          return new SmallInteger(value);
-        }
-        return new BigInteger(value, sign2);
-      }
-      function subtractSmall(a, b, sign2) {
-        var l = a.length, r = new Array(l), carry = -b, base3 = BASE, i2, difference;
-        for (i2 = 0; i2 < l; i2++) {
-          difference = a[i2] + carry;
-          carry = Math.floor(difference / base3);
-          difference %= base3;
-          r[i2] = difference < 0 ? difference + base3 : difference;
-        }
-        r = arrayToSmall(r);
-        if (typeof r === "number") {
-          if (sign2)
-            r = -r;
-          return new SmallInteger(r);
-        }
-        return new BigInteger(r, sign2);
-      }
-      BigInteger.prototype.subtract = function(v) {
-        var n = parseValue(v);
-        if (this.sign !== n.sign) {
-          return this.add(n.negate());
-        }
-        var a = this.value, b = n.value;
-        if (n.isSmall)
-          return subtractSmall(a, Math.abs(b), this.sign);
-        return subtractAny(a, b, this.sign);
-      };
-      BigInteger.prototype.minus = BigInteger.prototype.subtract;
-      SmallInteger.prototype.subtract = function(v) {
-        var n = parseValue(v);
-        var a = this.value;
-        if (a < 0 !== n.sign) {
-          return this.add(n.negate());
-        }
-        var b = n.value;
-        if (n.isSmall) {
-          return new SmallInteger(a - b);
-        }
-        return subtractSmall(b, Math.abs(a), a >= 0);
-      };
-      SmallInteger.prototype.minus = SmallInteger.prototype.subtract;
-      NativeBigInt.prototype.subtract = function(v) {
-        return new NativeBigInt(this.value - parseValue(v).value);
-      };
-      NativeBigInt.prototype.minus = NativeBigInt.prototype.subtract;
-      BigInteger.prototype.negate = function() {
-        return new BigInteger(this.value, !this.sign);
-      };
-      SmallInteger.prototype.negate = function() {
-        var sign2 = this.sign;
-        var small = new SmallInteger(-this.value);
-        small.sign = !sign2;
-        return small;
-      };
-      NativeBigInt.prototype.negate = function() {
-        return new NativeBigInt(-this.value);
-      };
-      BigInteger.prototype.abs = function() {
-        return new BigInteger(this.value, false);
-      };
-      SmallInteger.prototype.abs = function() {
-        return new SmallInteger(Math.abs(this.value));
-      };
-      NativeBigInt.prototype.abs = function() {
-        return new NativeBigInt(this.value >= 0 ? this.value : -this.value);
-      };
-      function multiplyLong(a, b) {
-        var a_l = a.length, b_l = b.length, l = a_l + b_l, r = createArray(l), base3 = BASE, product, carry, i2, a_i, b_j;
-        for (i2 = 0; i2 < a_l; ++i2) {
-          a_i = a[i2];
-          for (var j = 0; j < b_l; ++j) {
-            b_j = b[j];
-            product = a_i * b_j + r[i2 + j];
-            carry = Math.floor(product / base3);
-            r[i2 + j] = product - carry * base3;
-            r[i2 + j + 1] += carry;
-          }
-        }
-        trim(r);
-        return r;
-      }
-      function multiplySmall(a, b) {
-        var l = a.length, r = new Array(l), base3 = BASE, carry = 0, product, i2;
-        for (i2 = 0; i2 < l; i2++) {
-          product = a[i2] * b + carry;
-          carry = Math.floor(product / base3);
-          r[i2] = product - carry * base3;
-        }
-        while (carry > 0) {
-          r[i2++] = carry % base3;
-          carry = Math.floor(carry / base3);
-        }
-        return r;
-      }
-      function shiftLeft(x, n) {
-        var r = [];
-        while (n-- > 0)
-          r.push(0);
-        return r.concat(x);
-      }
-      function multiplyKaratsuba(x, y) {
-        var n = Math.max(x.length, y.length);
-        if (n <= 30)
-          return multiplyLong(x, y);
-        n = Math.ceil(n / 2);
-        var b = x.slice(n), a = x.slice(0, n), d = y.slice(n), c = y.slice(0, n);
-        var ac = multiplyKaratsuba(a, c), bd = multiplyKaratsuba(b, d), abcd = multiplyKaratsuba(addAny(a, b), addAny(c, d));
-        var product = addAny(addAny(ac, shiftLeft(subtract(subtract(abcd, ac), bd), n)), shiftLeft(bd, 2 * n));
-        trim(product);
-        return product;
-      }
-      function useKaratsuba(l1, l2) {
-        return -0.012 * l1 - 0.012 * l2 + 15e-6 * l1 * l2 > 0;
-      }
-      BigInteger.prototype.multiply = function(v) {
-        var n = parseValue(v), a = this.value, b = n.value, sign2 = this.sign !== n.sign, abs;
-        if (n.isSmall) {
-          if (b === 0)
-            return Integer[0];
-          if (b === 1)
-            return this;
-          if (b === -1)
-            return this.negate();
-          abs = Math.abs(b);
-          if (abs < BASE) {
-            return new BigInteger(multiplySmall(a, abs), sign2);
-          }
-          b = smallToArray(abs);
-        }
-        if (useKaratsuba(a.length, b.length))
-          return new BigInteger(multiplyKaratsuba(a, b), sign2);
-        return new BigInteger(multiplyLong(a, b), sign2);
-      };
-      BigInteger.prototype.times = BigInteger.prototype.multiply;
-      function multiplySmallAndArray(a, b, sign2) {
-        if (a < BASE) {
-          return new BigInteger(multiplySmall(b, a), sign2);
-        }
-        return new BigInteger(multiplyLong(b, smallToArray(a)), sign2);
-      }
-      SmallInteger.prototype._multiplyBySmall = function(a) {
-        if (isPrecise(a.value * this.value)) {
-          return new SmallInteger(a.value * this.value);
-        }
-        return multiplySmallAndArray(Math.abs(a.value), smallToArray(Math.abs(this.value)), this.sign !== a.sign);
-      };
-      BigInteger.prototype._multiplyBySmall = function(a) {
-        if (a.value === 0)
-          return Integer[0];
-        if (a.value === 1)
-          return this;
-        if (a.value === -1)
-          return this.negate();
-        return multiplySmallAndArray(Math.abs(a.value), this.value, this.sign !== a.sign);
-      };
-      SmallInteger.prototype.multiply = function(v) {
-        return parseValue(v)._multiplyBySmall(this);
-      };
-      SmallInteger.prototype.times = SmallInteger.prototype.multiply;
-      NativeBigInt.prototype.multiply = function(v) {
-        return new NativeBigInt(this.value * parseValue(v).value);
-      };
-      NativeBigInt.prototype.times = NativeBigInt.prototype.multiply;
-      function square(a) {
-        var l = a.length, r = createArray(l + l), base3 = BASE, product, carry, i2, a_i, a_j;
-        for (i2 = 0; i2 < l; i2++) {
-          a_i = a[i2];
-          carry = 0 - a_i * a_i;
-          for (var j = i2; j < l; j++) {
-            a_j = a[j];
-            product = 2 * (a_i * a_j) + r[i2 + j] + carry;
-            carry = Math.floor(product / base3);
-            r[i2 + j] = product - carry * base3;
-          }
-          r[i2 + l] = carry;
-        }
-        trim(r);
-        return r;
-      }
-      BigInteger.prototype.square = function() {
-        return new BigInteger(square(this.value), false);
-      };
-      SmallInteger.prototype.square = function() {
-        var value = this.value * this.value;
-        if (isPrecise(value))
-          return new SmallInteger(value);
-        return new BigInteger(square(smallToArray(Math.abs(this.value))), false);
-      };
-      NativeBigInt.prototype.square = function(v) {
-        return new NativeBigInt(this.value * this.value);
-      };
-      function divMod1(a, b) {
-        var a_l = a.length, b_l = b.length, base3 = BASE, result = createArray(b.length), divisorMostSignificantDigit = b[b_l - 1], lambda = Math.ceil(base3 / (2 * divisorMostSignificantDigit)), remainder = multiplySmall(a, lambda), divisor = multiplySmall(b, lambda), quotientDigit, shift, carry, borrow, i2, l, q;
-        if (remainder.length <= a_l)
-          remainder.push(0);
-        divisor.push(0);
-        divisorMostSignificantDigit = divisor[b_l - 1];
-        for (shift = a_l - b_l; shift >= 0; shift--) {
-          quotientDigit = base3 - 1;
-          if (remainder[shift + b_l] !== divisorMostSignificantDigit) {
-            quotientDigit = Math.floor((remainder[shift + b_l] * base3 + remainder[shift + b_l - 1]) / divisorMostSignificantDigit);
-          }
-          carry = 0;
-          borrow = 0;
-          l = divisor.length;
-          for (i2 = 0; i2 < l; i2++) {
-            carry += quotientDigit * divisor[i2];
-            q = Math.floor(carry / base3);
-            borrow += remainder[shift + i2] - (carry - q * base3);
-            carry = q;
-            if (borrow < 0) {
-              remainder[shift + i2] = borrow + base3;
-              borrow = -1;
-            } else {
-              remainder[shift + i2] = borrow;
-              borrow = 0;
-            }
-          }
-          while (borrow !== 0) {
-            quotientDigit -= 1;
-            carry = 0;
-            for (i2 = 0; i2 < l; i2++) {
-              carry += remainder[shift + i2] - base3 + divisor[i2];
-              if (carry < 0) {
-                remainder[shift + i2] = carry + base3;
-                carry = 0;
-              } else {
-                remainder[shift + i2] = carry;
-                carry = 1;
-              }
-            }
-            borrow += carry;
-          }
-          result[shift] = quotientDigit;
-        }
-        remainder = divModSmall(remainder, lambda)[0];
-        return [arrayToSmall(result), arrayToSmall(remainder)];
-      }
-      function divMod2(a, b) {
-        var a_l = a.length, b_l = b.length, result = [], part = [], base3 = BASE, guess, xlen, highx, highy, check;
-        while (a_l) {
-          part.unshift(a[--a_l]);
-          trim(part);
-          if (compareAbs(part, b) < 0) {
-            result.push(0);
-            continue;
-          }
-          xlen = part.length;
-          highx = part[xlen - 1] * base3 + part[xlen - 2];
-          highy = b[b_l - 1] * base3 + b[b_l - 2];
-          if (xlen > b_l) {
-            highx = (highx + 1) * base3;
-          }
-          guess = Math.ceil(highx / highy);
-          do {
-            check = multiplySmall(b, guess);
-            if (compareAbs(check, part) <= 0)
-              break;
-            guess--;
-          } while (guess);
-          result.push(guess);
-          part = subtract(part, check);
-        }
-        result.reverse();
-        return [arrayToSmall(result), arrayToSmall(part)];
-      }
-      function divModSmall(value, lambda) {
-        var length2 = value.length, quotient = createArray(length2), base3 = BASE, i2, q, remainder, divisor;
-        remainder = 0;
-        for (i2 = length2 - 1; i2 >= 0; --i2) {
-          divisor = remainder * base3 + value[i2];
-          q = truncate(divisor / lambda);
-          remainder = divisor - q * lambda;
-          quotient[i2] = q | 0;
-        }
-        return [quotient, remainder | 0];
-      }
-      function divModAny(self2, v) {
-        var value, n = parseValue(v);
-        if (supportsNativeBigInt) {
-          return [new NativeBigInt(self2.value / n.value), new NativeBigInt(self2.value % n.value)];
-        }
-        var a = self2.value, b = n.value;
-        var quotient;
-        if (b === 0)
-          throw new Error("Cannot divide by zero");
-        if (self2.isSmall) {
-          if (n.isSmall) {
-            return [new SmallInteger(truncate(a / b)), new SmallInteger(a % b)];
-          }
-          return [Integer[0], self2];
-        }
-        if (n.isSmall) {
-          if (b === 1)
-            return [self2, Integer[0]];
-          if (b == -1)
-            return [self2.negate(), Integer[0]];
-          var abs = Math.abs(b);
-          if (abs < BASE) {
-            value = divModSmall(a, abs);
-            quotient = arrayToSmall(value[0]);
-            var remainder = value[1];
-            if (self2.sign)
-              remainder = -remainder;
-            if (typeof quotient === "number") {
-              if (self2.sign !== n.sign)
-                quotient = -quotient;
-              return [new SmallInteger(quotient), new SmallInteger(remainder)];
-            }
-            return [new BigInteger(quotient, self2.sign !== n.sign), new SmallInteger(remainder)];
-          }
-          b = smallToArray(abs);
-        }
-        var comparison = compareAbs(a, b);
-        if (comparison === -1)
-          return [Integer[0], self2];
-        if (comparison === 0)
-          return [Integer[self2.sign === n.sign ? 1 : -1], Integer[0]];
-        if (a.length + b.length <= 200)
-          value = divMod1(a, b);
-        else
-          value = divMod2(a, b);
-        quotient = value[0];
-        var qSign = self2.sign !== n.sign, mod2 = value[1], mSign = self2.sign;
-        if (typeof quotient === "number") {
-          if (qSign)
-            quotient = -quotient;
-          quotient = new SmallInteger(quotient);
-        } else
-          quotient = new BigInteger(quotient, qSign);
-        if (typeof mod2 === "number") {
-          if (mSign)
-            mod2 = -mod2;
-          mod2 = new SmallInteger(mod2);
-        } else
-          mod2 = new BigInteger(mod2, mSign);
-        return [quotient, mod2];
-      }
-      BigInteger.prototype.divmod = function(v) {
-        var result = divModAny(this, v);
-        return {
-          quotient: result[0],
-          remainder: result[1]
-        };
-      };
-      NativeBigInt.prototype.divmod = SmallInteger.prototype.divmod = BigInteger.prototype.divmod;
-      BigInteger.prototype.divide = function(v) {
-        return divModAny(this, v)[0];
-      };
-      NativeBigInt.prototype.over = NativeBigInt.prototype.divide = function(v) {
-        return new NativeBigInt(this.value / parseValue(v).value);
-      };
-      SmallInteger.prototype.over = SmallInteger.prototype.divide = BigInteger.prototype.over = BigInteger.prototype.divide;
-      BigInteger.prototype.mod = function(v) {
-        return divModAny(this, v)[1];
-      };
-      NativeBigInt.prototype.mod = NativeBigInt.prototype.remainder = function(v) {
-        return new NativeBigInt(this.value % parseValue(v).value);
-      };
-      SmallInteger.prototype.remainder = SmallInteger.prototype.mod = BigInteger.prototype.remainder = BigInteger.prototype.mod;
-      BigInteger.prototype.pow = function(v) {
-        var n = parseValue(v), a = this.value, b = n.value, value, x, y;
-        if (b === 0)
-          return Integer[1];
-        if (a === 0)
-          return Integer[0];
-        if (a === 1)
-          return Integer[1];
-        if (a === -1)
-          return n.isEven() ? Integer[1] : Integer[-1];
-        if (n.sign) {
-          return Integer[0];
-        }
-        if (!n.isSmall)
-          throw new Error("The exponent " + n.toString() + " is too large.");
-        if (this.isSmall) {
-          if (isPrecise(value = Math.pow(a, b)))
-            return new SmallInteger(truncate(value));
-        }
-        x = this;
-        y = Integer[1];
-        while (true) {
-          if (b & true) {
-            y = y.times(x);
-            --b;
-          }
-          if (b === 0)
-            break;
-          b /= 2;
-          x = x.square();
-        }
-        return y;
-      };
-      SmallInteger.prototype.pow = BigInteger.prototype.pow;
-      NativeBigInt.prototype.pow = function(v) {
-        var n = parseValue(v);
-        var a = this.value, b = n.value;
-        var _0 = BigInt(0), _1 = BigInt(1), _2 = BigInt(2);
-        if (b === _0)
-          return Integer[1];
-        if (a === _0)
-          return Integer[0];
-        if (a === _1)
-          return Integer[1];
-        if (a === BigInt(-1))
-          return n.isEven() ? Integer[1] : Integer[-1];
-        if (n.isNegative())
-          return new NativeBigInt(_0);
-        var x = this;
-        var y = Integer[1];
-        while (true) {
-          if ((b & _1) === _1) {
-            y = y.times(x);
-            --b;
-          }
-          if (b === _0)
-            break;
-          b /= _2;
-          x = x.square();
-        }
-        return y;
-      };
-      BigInteger.prototype.modPow = function(exp, mod2) {
-        exp = parseValue(exp);
-        mod2 = parseValue(mod2);
-        if (mod2.isZero())
-          throw new Error("Cannot take modPow with modulus 0");
-        var r = Integer[1], base3 = this.mod(mod2);
-        if (exp.isNegative()) {
-          exp = exp.multiply(Integer[-1]);
-          base3 = base3.modInv(mod2);
-        }
-        while (exp.isPositive()) {
-          if (base3.isZero())
-            return Integer[0];
-          if (exp.isOdd())
-            r = r.multiply(base3).mod(mod2);
-          exp = exp.divide(2);
-          base3 = base3.square().mod(mod2);
-        }
-        return r;
-      };
-      NativeBigInt.prototype.modPow = SmallInteger.prototype.modPow = BigInteger.prototype.modPow;
-      function compareAbs(a, b) {
-        if (a.length !== b.length) {
-          return a.length > b.length ? 1 : -1;
-        }
-        for (var i2 = a.length - 1; i2 >= 0; i2--) {
-          if (a[i2] !== b[i2])
-            return a[i2] > b[i2] ? 1 : -1;
-        }
-        return 0;
-      }
-      BigInteger.prototype.compareAbs = function(v) {
-        var n = parseValue(v), a = this.value, b = n.value;
-        if (n.isSmall)
-          return 1;
-        return compareAbs(a, b);
-      };
-      SmallInteger.prototype.compareAbs = function(v) {
-        var n = parseValue(v), a = Math.abs(this.value), b = n.value;
-        if (n.isSmall) {
-          b = Math.abs(b);
-          return a === b ? 0 : a > b ? 1 : -1;
-        }
-        return -1;
-      };
-      NativeBigInt.prototype.compareAbs = function(v) {
-        var a = this.value;
-        var b = parseValue(v).value;
-        a = a >= 0 ? a : -a;
-        b = b >= 0 ? b : -b;
-        return a === b ? 0 : a > b ? 1 : -1;
-      };
-      BigInteger.prototype.compare = function(v) {
-        if (v === Infinity) {
-          return -1;
-        }
-        if (v === -Infinity) {
-          return 1;
-        }
-        var n = parseValue(v), a = this.value, b = n.value;
-        if (this.sign !== n.sign) {
-          return n.sign ? 1 : -1;
-        }
-        if (n.isSmall) {
-          return this.sign ? -1 : 1;
-        }
-        return compareAbs(a, b) * (this.sign ? -1 : 1);
-      };
-      BigInteger.prototype.compareTo = BigInteger.prototype.compare;
-      SmallInteger.prototype.compare = function(v) {
-        if (v === Infinity) {
-          return -1;
-        }
-        if (v === -Infinity) {
-          return 1;
-        }
-        var n = parseValue(v), a = this.value, b = n.value;
-        if (n.isSmall) {
-          return a == b ? 0 : a > b ? 1 : -1;
-        }
-        if (a < 0 !== n.sign) {
-          return a < 0 ? -1 : 1;
-        }
-        return a < 0 ? 1 : -1;
-      };
-      SmallInteger.prototype.compareTo = SmallInteger.prototype.compare;
-      NativeBigInt.prototype.compare = function(v) {
-        if (v === Infinity) {
-          return -1;
-        }
-        if (v === -Infinity) {
-          return 1;
-        }
-        var a = this.value;
-        var b = parseValue(v).value;
-        return a === b ? 0 : a > b ? 1 : -1;
-      };
-      NativeBigInt.prototype.compareTo = NativeBigInt.prototype.compare;
-      BigInteger.prototype.equals = function(v) {
-        return this.compare(v) === 0;
-      };
-      NativeBigInt.prototype.eq = NativeBigInt.prototype.equals = SmallInteger.prototype.eq = SmallInteger.prototype.equals = BigInteger.prototype.eq = BigInteger.prototype.equals;
-      BigInteger.prototype.notEquals = function(v) {
-        return this.compare(v) !== 0;
-      };
-      NativeBigInt.prototype.neq = NativeBigInt.prototype.notEquals = SmallInteger.prototype.neq = SmallInteger.prototype.notEquals = BigInteger.prototype.neq = BigInteger.prototype.notEquals;
-      BigInteger.prototype.greater = function(v) {
-        return this.compare(v) > 0;
-      };
-      NativeBigInt.prototype.gt = NativeBigInt.prototype.greater = SmallInteger.prototype.gt = SmallInteger.prototype.greater = BigInteger.prototype.gt = BigInteger.prototype.greater;
-      BigInteger.prototype.lesser = function(v) {
-        return this.compare(v) < 0;
-      };
-      NativeBigInt.prototype.lt = NativeBigInt.prototype.lesser = SmallInteger.prototype.lt = SmallInteger.prototype.lesser = BigInteger.prototype.lt = BigInteger.prototype.lesser;
-      BigInteger.prototype.greaterOrEquals = function(v) {
-        return this.compare(v) >= 0;
-      };
-      NativeBigInt.prototype.geq = NativeBigInt.prototype.greaterOrEquals = SmallInteger.prototype.geq = SmallInteger.prototype.greaterOrEquals = BigInteger.prototype.geq = BigInteger.prototype.greaterOrEquals;
-      BigInteger.prototype.lesserOrEquals = function(v) {
-        return this.compare(v) <= 0;
-      };
-      NativeBigInt.prototype.leq = NativeBigInt.prototype.lesserOrEquals = SmallInteger.prototype.leq = SmallInteger.prototype.lesserOrEquals = BigInteger.prototype.leq = BigInteger.prototype.lesserOrEquals;
-      BigInteger.prototype.isEven = function() {
-        return (this.value[0] & 1) === 0;
-      };
-      SmallInteger.prototype.isEven = function() {
-        return (this.value & 1) === 0;
-      };
-      NativeBigInt.prototype.isEven = function() {
-        return (this.value & BigInt(1)) === BigInt(0);
-      };
-      BigInteger.prototype.isOdd = function() {
-        return (this.value[0] & 1) === 1;
-      };
-      SmallInteger.prototype.isOdd = function() {
-        return (this.value & 1) === 1;
-      };
-      NativeBigInt.prototype.isOdd = function() {
-        return (this.value & BigInt(1)) === BigInt(1);
-      };
-      BigInteger.prototype.isPositive = function() {
-        return !this.sign;
-      };
-      SmallInteger.prototype.isPositive = function() {
-        return this.value > 0;
-      };
-      NativeBigInt.prototype.isPositive = SmallInteger.prototype.isPositive;
-      BigInteger.prototype.isNegative = function() {
-        return this.sign;
-      };
-      SmallInteger.prototype.isNegative = function() {
-        return this.value < 0;
-      };
-      NativeBigInt.prototype.isNegative = SmallInteger.prototype.isNegative;
-      BigInteger.prototype.isUnit = function() {
-        return false;
-      };
-      SmallInteger.prototype.isUnit = function() {
-        return Math.abs(this.value) === 1;
-      };
-      NativeBigInt.prototype.isUnit = function() {
-        return this.abs().value === BigInt(1);
-      };
-      BigInteger.prototype.isZero = function() {
-        return false;
-      };
-      SmallInteger.prototype.isZero = function() {
-        return this.value === 0;
-      };
-      NativeBigInt.prototype.isZero = function() {
-        return this.value === BigInt(0);
-      };
-      BigInteger.prototype.isDivisibleBy = function(v) {
-        var n = parseValue(v);
-        if (n.isZero())
-          return false;
-        if (n.isUnit())
-          return true;
-        if (n.compareAbs(2) === 0)
-          return this.isEven();
-        return this.mod(n).isZero();
-      };
-      NativeBigInt.prototype.isDivisibleBy = SmallInteger.prototype.isDivisibleBy = BigInteger.prototype.isDivisibleBy;
-      function isBasicPrime(v) {
-        var n = v.abs();
-        if (n.isUnit())
-          return false;
-        if (n.equals(2) || n.equals(3) || n.equals(5))
-          return true;
-        if (n.isEven() || n.isDivisibleBy(3) || n.isDivisibleBy(5))
-          return false;
-        if (n.lesser(49))
-          return true;
-      }
-      function millerRabinTest(n, a) {
-        var nPrev = n.prev(), b = nPrev, r = 0, d, t, i2, x;
-        while (b.isEven())
-          b = b.divide(2), r++;
-        next:
-          for (i2 = 0; i2 < a.length; i2++) {
-            if (n.lesser(a[i2]))
-              continue;
-            x = bigInt2(a[i2]).modPow(b, n);
-            if (x.isUnit() || x.equals(nPrev))
-              continue;
-            for (d = r - 1; d != 0; d--) {
-              x = x.square().mod(n);
-              if (x.isUnit())
-                return false;
-              if (x.equals(nPrev))
-                continue next;
-            }
-            return false;
-          }
-        return true;
-      }
-      BigInteger.prototype.isPrime = function(strict) {
-        var isPrime = isBasicPrime(this);
-        if (isPrime !== undefined2)
-          return isPrime;
-        var n = this.abs();
-        var bits = n.bitLength();
-        if (bits <= 64)
-          return millerRabinTest(n, [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37]);
-        var logN = Math.log(2) * bits.toJSNumber();
-        var t = Math.ceil(strict === true ? 2 * Math.pow(logN, 2) : logN);
-        for (var a = [], i2 = 0; i2 < t; i2++) {
-          a.push(bigInt2(i2 + 2));
-        }
-        return millerRabinTest(n, a);
-      };
-      NativeBigInt.prototype.isPrime = SmallInteger.prototype.isPrime = BigInteger.prototype.isPrime;
-      BigInteger.prototype.isProbablePrime = function(iterations, rng) {
-        var isPrime = isBasicPrime(this);
-        if (isPrime !== undefined2)
-          return isPrime;
-        var n = this.abs();
-        var t = iterations === undefined2 ? 5 : iterations;
-        for (var a = [], i2 = 0; i2 < t; i2++) {
-          a.push(bigInt2.randBetween(2, n.minus(2), rng));
-        }
-        return millerRabinTest(n, a);
-      };
-      NativeBigInt.prototype.isProbablePrime = SmallInteger.prototype.isProbablePrime = BigInteger.prototype.isProbablePrime;
-      BigInteger.prototype.modInv = function(n) {
-        var t = bigInt2.zero, newT = bigInt2.one, r = parseValue(n), newR = this.abs(), q, lastT, lastR;
-        while (!newR.isZero()) {
-          q = r.divide(newR);
-          lastT = t;
-          lastR = r;
-          t = newT;
-          r = newR;
-          newT = lastT.subtract(q.multiply(newT));
-          newR = lastR.subtract(q.multiply(newR));
-        }
-        if (!r.isUnit())
-          throw new Error(this.toString() + " and " + n.toString() + " are not co-prime");
-        if (t.compare(0) === -1) {
-          t = t.add(n);
-        }
-        if (this.isNegative()) {
-          return t.negate();
-        }
-        return t;
-      };
-      NativeBigInt.prototype.modInv = SmallInteger.prototype.modInv = BigInteger.prototype.modInv;
-      BigInteger.prototype.next = function() {
-        var value = this.value;
-        if (this.sign) {
-          return subtractSmall(value, 1, this.sign);
-        }
-        return new BigInteger(addSmall(value, 1), this.sign);
-      };
-      SmallInteger.prototype.next = function() {
-        var value = this.value;
-        if (value + 1 < MAX_INT)
-          return new SmallInteger(value + 1);
-        return new BigInteger(MAX_INT_ARR, false);
-      };
-      NativeBigInt.prototype.next = function() {
-        return new NativeBigInt(this.value + BigInt(1));
-      };
-      BigInteger.prototype.prev = function() {
-        var value = this.value;
-        if (this.sign) {
-          return new BigInteger(addSmall(value, 1), true);
-        }
-        return subtractSmall(value, 1, this.sign);
-      };
-      SmallInteger.prototype.prev = function() {
-        var value = this.value;
-        if (value - 1 > -MAX_INT)
-          return new SmallInteger(value - 1);
-        return new BigInteger(MAX_INT_ARR, true);
-      };
-      NativeBigInt.prototype.prev = function() {
-        return new NativeBigInt(this.value - BigInt(1));
-      };
-      var powersOfTwo = [1];
-      while (2 * powersOfTwo[powersOfTwo.length - 1] <= BASE)
-        powersOfTwo.push(2 * powersOfTwo[powersOfTwo.length - 1]);
-      var powers2Length = powersOfTwo.length, highestPower2 = powersOfTwo[powers2Length - 1];
-      function shift_isSmall(n) {
-        return Math.abs(n) <= BASE;
-      }
-      BigInteger.prototype.shiftLeft = function(v) {
-        var n = parseValue(v).toJSNumber();
-        if (!shift_isSmall(n)) {
-          throw new Error(String(n) + " is too large for shifting.");
-        }
-        if (n < 0)
-          return this.shiftRight(-n);
-        var result = this;
-        if (result.isZero())
-          return result;
-        while (n >= powers2Length) {
-          result = result.multiply(highestPower2);
-          n -= powers2Length - 1;
-        }
-        return result.multiply(powersOfTwo[n]);
-      };
-      NativeBigInt.prototype.shiftLeft = SmallInteger.prototype.shiftLeft = BigInteger.prototype.shiftLeft;
-      BigInteger.prototype.shiftRight = function(v) {
-        var remQuo;
-        var n = parseValue(v).toJSNumber();
-        if (!shift_isSmall(n)) {
-          throw new Error(String(n) + " is too large for shifting.");
-        }
-        if (n < 0)
-          return this.shiftLeft(-n);
-        var result = this;
-        while (n >= powers2Length) {
-          if (result.isZero() || result.isNegative() && result.isUnit())
-            return result;
-          remQuo = divModAny(result, highestPower2);
-          result = remQuo[1].isNegative() ? remQuo[0].prev() : remQuo[0];
-          n -= powers2Length - 1;
-        }
-        remQuo = divModAny(result, powersOfTwo[n]);
-        return remQuo[1].isNegative() ? remQuo[0].prev() : remQuo[0];
-      };
-      NativeBigInt.prototype.shiftRight = SmallInteger.prototype.shiftRight = BigInteger.prototype.shiftRight;
-      function bitwise(x, y, fn) {
-        y = parseValue(y);
-        var xSign = x.isNegative(), ySign = y.isNegative();
-        var xRem = xSign ? x.not() : x, yRem = ySign ? y.not() : y;
-        var xDigit = 0, yDigit = 0;
-        var xDivMod = null, yDivMod = null;
-        var result = [];
-        while (!xRem.isZero() || !yRem.isZero()) {
-          xDivMod = divModAny(xRem, highestPower2);
-          xDigit = xDivMod[1].toJSNumber();
-          if (xSign) {
-            xDigit = highestPower2 - 1 - xDigit;
-          }
-          yDivMod = divModAny(yRem, highestPower2);
-          yDigit = yDivMod[1].toJSNumber();
-          if (ySign) {
-            yDigit = highestPower2 - 1 - yDigit;
-          }
-          xRem = xDivMod[0];
-          yRem = yDivMod[0];
-          result.push(fn(xDigit, yDigit));
-        }
-        var sum = fn(xSign ? 1 : 0, ySign ? 1 : 0) !== 0 ? bigInt2(-1) : bigInt2(0);
-        for (var i2 = result.length - 1; i2 >= 0; i2 -= 1) {
-          sum = sum.multiply(highestPower2).add(bigInt2(result[i2]));
-        }
-        return sum;
-      }
-      BigInteger.prototype.not = function() {
-        return this.negate().prev();
-      };
-      NativeBigInt.prototype.not = SmallInteger.prototype.not = BigInteger.prototype.not;
-      BigInteger.prototype.and = function(n) {
-        return bitwise(this, n, function(a, b) {
-          return a & b;
-        });
-      };
-      NativeBigInt.prototype.and = SmallInteger.prototype.and = BigInteger.prototype.and;
-      BigInteger.prototype.or = function(n) {
-        return bitwise(this, n, function(a, b) {
-          return a | b;
-        });
-      };
-      NativeBigInt.prototype.or = SmallInteger.prototype.or = BigInteger.prototype.or;
-      BigInteger.prototype.xor = function(n) {
-        return bitwise(this, n, function(a, b) {
-          return a ^ b;
-        });
-      };
-      NativeBigInt.prototype.xor = SmallInteger.prototype.xor = BigInteger.prototype.xor;
-      var LOBMASK_I = 1 << 30, LOBMASK_BI = (BASE & -BASE) * (BASE & -BASE) | LOBMASK_I;
-      function roughLOB(n) {
-        var v = n.value, x = typeof v === "number" ? v | LOBMASK_I : typeof v === "bigint" ? v | BigInt(LOBMASK_I) : v[0] + v[1] * BASE | LOBMASK_BI;
-        return x & -x;
-      }
-      function integerLogarithm(value, base3) {
-        if (base3.compareTo(value) <= 0) {
-          var tmp = integerLogarithm(value, base3.square(base3));
-          var p = tmp.p;
-          var e = tmp.e;
-          var t = p.multiply(base3);
-          return t.compareTo(value) <= 0 ? { p: t, e: e * 2 + 1 } : { p, e: e * 2 };
-        }
-        return { p: bigInt2(1), e: 0 };
-      }
-      BigInteger.prototype.bitLength = function() {
-        var n = this;
-        if (n.compareTo(bigInt2(0)) < 0) {
-          n = n.negate().subtract(bigInt2(1));
-        }
-        if (n.compareTo(bigInt2(0)) === 0) {
-          return bigInt2(0);
-        }
-        return bigInt2(integerLogarithm(n, bigInt2(2)).e).add(bigInt2(1));
-      };
-      NativeBigInt.prototype.bitLength = SmallInteger.prototype.bitLength = BigInteger.prototype.bitLength;
-      function max(a, b) {
-        a = parseValue(a);
-        b = parseValue(b);
-        return a.greater(b) ? a : b;
-      }
-      function min(a, b) {
-        a = parseValue(a);
-        b = parseValue(b);
-        return a.lesser(b) ? a : b;
-      }
-      function gcd(a, b) {
-        a = parseValue(a).abs();
-        b = parseValue(b).abs();
-        if (a.equals(b))
-          return a;
-        if (a.isZero())
-          return b;
-        if (b.isZero())
-          return a;
-        var c = Integer[1], d, t;
-        while (a.isEven() && b.isEven()) {
-          d = min(roughLOB(a), roughLOB(b));
-          a = a.divide(d);
-          b = b.divide(d);
-          c = c.multiply(d);
-        }
-        while (a.isEven()) {
-          a = a.divide(roughLOB(a));
-        }
-        do {
-          while (b.isEven()) {
-            b = b.divide(roughLOB(b));
-          }
-          if (a.greater(b)) {
-            t = b;
-            b = a;
-            a = t;
-          }
-          b = b.subtract(a);
-        } while (!b.isZero());
-        return c.isUnit() ? a : a.multiply(c);
-      }
-      function lcm(a, b) {
-        a = parseValue(a).abs();
-        b = parseValue(b).abs();
-        return a.divide(gcd(a, b)).multiply(b);
-      }
-      function randBetween(a, b, rng) {
-        a = parseValue(a);
-        b = parseValue(b);
-        var usedRNG = rng || Math.random;
-        var low = min(a, b), high = max(a, b);
-        var range = high.subtract(low).add(1);
-        if (range.isSmall)
-          return low.add(Math.floor(usedRNG() * range));
-        var digits = toBase(range, BASE).value;
-        var result = [], restricted = true;
-        for (var i2 = 0; i2 < digits.length; i2++) {
-          var top = restricted ? digits[i2] + (i2 + 1 < digits.length ? digits[i2 + 1] / BASE : 0) : BASE;
-          var digit = truncate(usedRNG() * top);
-          result.push(digit);
-          if (digit < digits[i2])
-            restricted = false;
-        }
-        return low.add(Integer.fromArray(result, BASE, false));
-      }
-      var parseBase = function(text, base3, alphabet2, caseSensitive) {
-        alphabet2 = alphabet2 || DEFAULT_ALPHABET;
-        text = String(text);
-        if (!caseSensitive) {
-          text = text.toLowerCase();
-          alphabet2 = alphabet2.toLowerCase();
-        }
-        var length2 = text.length;
-        var i2;
-        var absBase = Math.abs(base3);
-        var alphabetValues = {};
-        for (i2 = 0; i2 < alphabet2.length; i2++) {
-          alphabetValues[alphabet2[i2]] = i2;
-        }
-        for (i2 = 0; i2 < length2; i2++) {
-          var c = text[i2];
-          if (c === "-")
-            continue;
-          if (c in alphabetValues) {
-            if (alphabetValues[c] >= absBase) {
-              if (c === "1" && absBase === 1)
-                continue;
-              throw new Error(c + " is not a valid digit in base " + base3 + ".");
-            }
-          }
-        }
-        base3 = parseValue(base3);
-        var digits = [];
-        var isNegative = text[0] === "-";
-        for (i2 = isNegative ? 1 : 0; i2 < text.length; i2++) {
-          var c = text[i2];
-          if (c in alphabetValues)
-            digits.push(parseValue(alphabetValues[c]));
-          else if (c === "<") {
-            var start = i2;
-            do {
-              i2++;
-            } while (text[i2] !== ">" && i2 < text.length);
-            digits.push(parseValue(text.slice(start + 1, i2)));
-          } else
-            throw new Error(c + " is not a valid character");
-        }
-        return parseBaseFromArray(digits, base3, isNegative);
-      };
-      function parseBaseFromArray(digits, base3, isNegative) {
-        var val = Integer[0], pow = Integer[1], i2;
-        for (i2 = digits.length - 1; i2 >= 0; i2--) {
-          val = val.add(digits[i2].times(pow));
-          pow = pow.times(base3);
-        }
-        return isNegative ? val.negate() : val;
-      }
-      function stringify(digit, alphabet2) {
-        alphabet2 = alphabet2 || DEFAULT_ALPHABET;
-        if (digit < alphabet2.length) {
-          return alphabet2[digit];
-        }
-        return "<" + digit + ">";
-      }
-      function toBase(n, base3) {
-        base3 = bigInt2(base3);
-        if (base3.isZero()) {
-          if (n.isZero())
-            return { value: [0], isNegative: false };
-          throw new Error("Cannot convert nonzero numbers to base 0.");
-        }
-        if (base3.equals(-1)) {
-          if (n.isZero())
-            return { value: [0], isNegative: false };
-          if (n.isNegative())
-            return {
-              value: [].concat.apply(
-                [],
-                Array.apply(null, Array(-n.toJSNumber())).map(Array.prototype.valueOf, [1, 0])
-              ),
-              isNegative: false
-            };
-          var arr = Array.apply(null, Array(n.toJSNumber() - 1)).map(Array.prototype.valueOf, [0, 1]);
-          arr.unshift([1]);
-          return {
-            value: [].concat.apply([], arr),
-            isNegative: false
-          };
-        }
-        var neg = false;
-        if (n.isNegative() && base3.isPositive()) {
-          neg = true;
-          n = n.abs();
-        }
-        if (base3.isUnit()) {
-          if (n.isZero())
-            return { value: [0], isNegative: false };
-          return {
-            value: Array.apply(null, Array(n.toJSNumber())).map(Number.prototype.valueOf, 1),
-            isNegative: neg
-          };
-        }
-        var out = [];
-        var left = n, divmod;
-        while (left.isNegative() || left.compareAbs(base3) >= 0) {
-          divmod = left.divmod(base3);
-          left = divmod.quotient;
-          var digit = divmod.remainder;
-          if (digit.isNegative()) {
-            digit = base3.minus(digit).abs();
-            left = left.next();
-          }
-          out.push(digit.toJSNumber());
-        }
-        out.push(left.toJSNumber());
-        return { value: out.reverse(), isNegative: neg };
-      }
-      function toBaseString(n, base3, alphabet2) {
-        var arr = toBase(n, base3);
-        return (arr.isNegative ? "-" : "") + arr.value.map(function(x) {
-          return stringify(x, alphabet2);
-        }).join("");
-      }
-      BigInteger.prototype.toArray = function(radix) {
-        return toBase(this, radix);
-      };
-      SmallInteger.prototype.toArray = function(radix) {
-        return toBase(this, radix);
-      };
-      NativeBigInt.prototype.toArray = function(radix) {
-        return toBase(this, radix);
-      };
-      BigInteger.prototype.toString = function(radix, alphabet2) {
-        if (radix === undefined2)
-          radix = 10;
-        if (radix !== 10)
-          return toBaseString(this, radix, alphabet2);
-        var v = this.value, l = v.length, str = String(v[--l]), zeros = "0000000", digit;
-        while (--l >= 0) {
-          digit = String(v[l]);
-          str += zeros.slice(digit.length) + digit;
-        }
-        var sign2 = this.sign ? "-" : "";
-        return sign2 + str;
-      };
-      SmallInteger.prototype.toString = function(radix, alphabet2) {
-        if (radix === undefined2)
-          radix = 10;
-        if (radix != 10)
-          return toBaseString(this, radix, alphabet2);
-        return String(this.value);
-      };
-      NativeBigInt.prototype.toString = SmallInteger.prototype.toString;
-      NativeBigInt.prototype.toJSON = BigInteger.prototype.toJSON = SmallInteger.prototype.toJSON = function() {
-        return this.toString();
-      };
-      BigInteger.prototype.valueOf = function() {
-        return parseInt(this.toString(), 10);
-      };
-      BigInteger.prototype.toJSNumber = BigInteger.prototype.valueOf;
-      SmallInteger.prototype.valueOf = function() {
-        return this.value;
-      };
-      SmallInteger.prototype.toJSNumber = SmallInteger.prototype.valueOf;
-      NativeBigInt.prototype.valueOf = NativeBigInt.prototype.toJSNumber = function() {
-        return parseInt(this.toString(), 10);
-      };
-      function parseStringValue(v) {
-        if (isPrecise(+v)) {
-          var x = +v;
-          if (x === truncate(x))
-            return supportsNativeBigInt ? new NativeBigInt(BigInt(x)) : new SmallInteger(x);
-          throw new Error("Invalid integer: " + v);
-        }
-        var sign2 = v[0] === "-";
-        if (sign2)
-          v = v.slice(1);
-        var split = v.split(/e/i);
-        if (split.length > 2)
-          throw new Error("Invalid integer: " + split.join("e"));
-        if (split.length === 2) {
-          var exp = split[1];
-          if (exp[0] === "+")
-            exp = exp.slice(1);
-          exp = +exp;
-          if (exp !== truncate(exp) || !isPrecise(exp))
-            throw new Error("Invalid integer: " + exp + " is not a valid exponent.");
-          var text = split[0];
-          var decimalPlace = text.indexOf(".");
-          if (decimalPlace >= 0) {
-            exp -= text.length - decimalPlace - 1;
-            text = text.slice(0, decimalPlace) + text.slice(decimalPlace + 1);
-          }
-          if (exp < 0)
-            throw new Error("Cannot include negative exponent part for integers");
-          text += new Array(exp + 1).join("0");
-          v = text;
-        }
-        var isValid = /^([0-9][0-9]*)$/.test(v);
-        if (!isValid)
-          throw new Error("Invalid integer: " + v);
-        if (supportsNativeBigInt) {
-          return new NativeBigInt(BigInt(sign2 ? "-" + v : v));
-        }
-        var r = [], max2 = v.length, l = LOG_BASE, min2 = max2 - l;
-        while (max2 > 0) {
-          r.push(+v.slice(min2, max2));
-          min2 -= l;
-          if (min2 < 0)
-            min2 = 0;
-          max2 -= l;
-        }
-        trim(r);
-        return new BigInteger(r, sign2);
-      }
-      function parseNumberValue(v) {
-        if (supportsNativeBigInt) {
-          return new NativeBigInt(BigInt(v));
-        }
-        if (isPrecise(v)) {
-          if (v !== truncate(v))
-            throw new Error(v + " is not an integer.");
-          return new SmallInteger(v);
-        }
-        return parseStringValue(v.toString());
-      }
-      function parseValue(v) {
-        if (typeof v === "number") {
-          return parseNumberValue(v);
-        }
-        if (typeof v === "string") {
-          return parseStringValue(v);
-        }
-        if (typeof v === "bigint") {
-          return new NativeBigInt(v);
-        }
-        return v;
-      }
-      for (var i = 0; i < 1e3; i++) {
-        Integer[i] = parseValue(i);
-        if (i > 0)
-          Integer[-i] = parseValue(-i);
-      }
-      Integer.one = Integer[1];
-      Integer.zero = Integer[0];
-      Integer.minusOne = Integer[-1];
-      Integer.max = max;
-      Integer.min = min;
-      Integer.gcd = gcd;
-      Integer.lcm = lcm;
-      Integer.isInstance = function(x) {
-        return x instanceof BigInteger || x instanceof SmallInteger || x instanceof NativeBigInt;
-      };
-      Integer.randBetween = randBetween;
-      Integer.fromArray = function(digits, base3, isNegative) {
-        return parseBaseFromArray(digits.map(parseValue), parseValue(base3 || 10), isNegative);
-      };
-      return Integer;
-    }();
-    if (typeof module2 !== "undefined" && module2.hasOwnProperty("exports")) {
-      module2.exports = bigInt2;
-    }
-    if (typeof define === "function" && define.amd) {
-      define(function() {
-        return bigInt2;
-      });
-    }
-  }
-});
-
 // src/index.ts
 var src_exports2 = {};
 __export(src_exports2, {
-  AesKey: () => AesKey,
-  BASE58_DID_PREFIX: () => BASE58_DID_PREFIX,
-  DID_KEY_BASE58_PREFIX: () => DID_KEY_BASE58_PREFIX,
-  EcdsaKeypair: () => EcdsaKeypair,
+  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,
-  randomBytes: () => randomBytes,
-  randomIV: () => randomIV,
+  parseMultikey: () => parseMultikey,
+  randomBytes: () => randomBytes2,
+  randomIntFromSeed: () => randomIntFromSeed,
   randomStr: () => randomStr,
   secp256k1Plugin: () => secp256k1Plugin,
-  sha256: () => sha2562,
-  sha256Stream: () => sha256Stream,
+  sha256: () => sha2563,
   verifySignature: () => verifySignature,
   verifySignatureUtf8: () => verifySignatureUtf8
 });
 module.exports = __toCommonJS(src_exports2);
 
-// ../../node_modules/one-webcrypto/node.mjs
-var import_crypto = __toESM(require("crypto"), 1);
-var webcrypto = import_crypto.default.webcrypto;
+// 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/uint8arrays/esm/src/concat.js
 function concat(arrays, length2) {
   if (!length2) {
     length2 = arrays.reduce((acc, curr) => acc + curr.length, 0);
   }
-  const output = new Uint8Array(length2);
+  const output2 = new Uint8Array(length2);
   let offset = 0;
   for (const arr of arrays) {
-    output.set(arr, offset);
+    output2.set(arr, offset);
     offset += arr.length;
   }
-  return output;
+  return output2;
 }
 
 // ../../node_modules/uint8arrays/esm/src/equals.js
@@ -1619,9 +266,9 @@ var Encoder = class {
     this.prefix = prefix;
     this.baseEncode = baseEncode;
   }
-  encode(bytes) {
-    if (bytes instanceof Uint8Array) {
-      return `${this.prefix}${this.baseEncode(bytes)}`;
+  encode(bytes2) {
+    if (bytes2 instanceof Uint8Array) {
+      return `${this.prefix}${this.baseEncode(bytes2)}`;
     } else {
       throw Error("Unknown type, must be binary type");
     }
@@ -2006,7 +653,7 @@ __export(sha2_exports, {
   sha256: () => sha256,
   sha512: () => sha512
 });
-var import_crypto2 = __toESM(require("crypto"), 1);
+var import_crypto = __toESM(require("crypto"), 1);
 
 // ../../node_modules/multiformats/esm/vendor/varint.js
 var encode_1 = encode3;
@@ -2088,21 +735,21 @@ var create = (code2, digest2) => {
   const size = digest2.byteLength;
   const sizeOffset = encodingLength(code2);
   const digestOffset = sizeOffset + encodingLength(size);
-  const bytes = new Uint8Array(digestOffset + size);
-  encodeTo(code2, bytes, 0);
-  encodeTo(size, bytes, sizeOffset);
-  bytes.set(digest2, digestOffset);
-  return new Digest(code2, size, digest2, bytes);
+  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 bytes = coerce(multihash);
-  const [code2, sizeOffset] = decode4(bytes);
-  const [size, digestOffset] = decode4(bytes.subarray(sizeOffset));
-  const digest2 = bytes.subarray(sizeOffset + digestOffset);
+  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, bytes);
+  return new Digest(code2, size, digest2, bytes2);
 };
 var equals3 = (a, b) => {
   if (a === b) {
@@ -2112,11 +759,11 @@ var equals3 = (a, b) => {
   }
 };
 var Digest = class {
-  constructor(code2, size, digest2, bytes) {
+  constructor(code2, size, digest2, bytes2) {
     this.code = code2;
     this.size = size;
     this.digest = digest2;
-    this.bytes = bytes;
+    this.bytes = bytes2;
   }
 };
 
@@ -2142,12 +789,12 @@ var Hasher = class {
 var sha256 = from2({
   name: "sha2-256",
   code: 18,
-  encode: (input) => coerce(import_crypto2.default.createHash("sha256").update(input).digest())
+  encode: (input) => coerce(import_crypto.default.createHash("sha256").update(input).digest())
 });
 var sha512 = from2({
   name: "sha2-512",
   code: 19,
-  encode: (input) => coerce(import_crypto2.default.createHash("sha512").update(input).digest())
+  encode: (input) => coerce(import_crypto.default.createHash("sha512").update(input).digest())
 });
 
 // ../../node_modules/multiformats/esm/src/hashes/identity.js
@@ -2172,13 +819,13 @@ var textDecoder = new TextDecoder();
 
 // ../../node_modules/multiformats/esm/src/cid.js
 var CID = class {
-  constructor(version2, code2, multihash, bytes) {
+  constructor(version2, code2, multihash, bytes2) {
     this.code = code2;
     this.version = version2;
     this.multihash = multihash;
-    this.bytes = bytes;
-    this.byteOffset = bytes.byteOffset;
-    this.byteLength = bytes.byteLength;
+    this.bytes = bytes2;
+    this.byteOffset = bytes2.byteOffset;
+    this.byteLength = bytes2.byteLength;
     this.asCID = this;
     this._baseCache = /* @__PURE__ */ new Map();
     Object.defineProperties(this, {
@@ -2228,12 +875,12 @@ var CID = class {
     return other && this.code === other.code && this.version === other.version && equals3(this.multihash, other.multihash);
   }
   toString(base3) {
-    const { bytes, version: version2, _baseCache } = this;
+    const { bytes: bytes2, version: version2, _baseCache } = this;
     switch (version2) {
       case 0:
-        return toStringV0(bytes, _baseCache, base3 || base58btc.encoder);
+        return toStringV0(bytes2, _baseCache, base3 || base58btc.encoder);
       default:
-        return toStringV1(bytes, _baseCache, base3 || base32.encoder);
+        return toStringV1(bytes2, _baseCache, base3 || base32.encoder);
     }
   }
   toJSON() {
@@ -2272,8 +919,8 @@ var CID = class {
     if (value instanceof CID) {
       return value;
     } else if (value != null && value.asCID === value) {
-      const { version: version2, code: code2, multihash, bytes } = value;
-      return new CID(version2, code2, multihash, bytes || encodeCID(version2, code2, multihash.bytes));
+      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);
@@ -2295,8 +942,8 @@ var CID = class {
         }
       }
       case 1: {
-        const bytes = encodeCID(version2, code2, digest2.bytes);
-        return new CID(version2, code2, digest2, bytes);
+        const bytes2 = encodeCID(version2, code2, digest2.bytes);
+        return new CID(version2, code2, digest2, bytes2);
       }
       default: {
         throw new Error("Invalid version");
@@ -2309,17 +956,17 @@ var CID = class {
   static createV1(code2, digest2) {
     return CID.create(1, code2, digest2);
   }
-  static decode(bytes) {
-    const [cid, remainder] = CID.decodeFirst(bytes);
+  static decode(bytes2) {
+    const [cid, remainder] = CID.decodeFirst(bytes2);
     if (remainder.length) {
       throw new Error("Incorrect length");
     }
     return cid;
   }
-  static decodeFirst(bytes) {
-    const specs = CID.inspectBytes(bytes);
+  static decodeFirst(bytes2) {
+    const specs = CID.inspectBytes(bytes2);
     const prefixSize = specs.size - specs.multihashSize;
-    const multihashBytes = coerce(bytes.subarray(prefixSize, prefixSize + specs.multihashSize));
+    const multihashBytes = coerce(bytes2.subarray(prefixSize, prefixSize + specs.multihashSize));
     if (multihashBytes.byteLength !== specs.multihashSize) {
       throw new Error("Incorrect length");
     }
@@ -2328,7 +975,7 @@ var CID = class {
     const cid = specs.version === 0 ? CID.createV0(digest2) : CID.createV1(specs.codec, digest2);
     return [
       cid,
-      bytes.subarray(specs.size)
+      bytes2.subarray(specs.size)
     ];
   }
   static inspectBytes(initialBytes) {
@@ -2364,8 +1011,8 @@ var CID = class {
     };
   }
   static parse(source, base3) {
-    const [prefix, bytes] = parseCIDtoBytes(source, base3);
-    const cid = CID.decode(bytes);
+    const [prefix, bytes2] = parseCIDtoBytes(source, base3);
+    const cid = CID.decode(bytes2);
     cid._baseCache.set(prefix, source);
     return cid;
   }
@@ -2404,25 +1051,25 @@ var parseCIDtoBytes = (source, base3) => {
     }
   }
 };
-var toStringV0 = (bytes, cache, base3) => {
+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(bytes).slice(1);
+    const cid2 = base3.encode(bytes2).slice(1);
     cache.set(prefix, cid2);
     return cid2;
   } else {
     return cid;
   }
 };
-var toStringV1 = (bytes, cache, base3) => {
+var toStringV1 = (bytes2, cache, base3) => {
   const { prefix } = base3;
   const cid = cache.get(prefix);
   if (cid == null) {
-    const cid2 = base3.encode(bytes);
+    const cid2 = base3.encode(bytes2);
     cache.set(prefix, cid2);
     return cid2;
   } else {
@@ -2434,11 +1081,11 @@ var SHA_256_CODE = 18;
 var encodeCID = (version2, code2, multihash) => {
   const codeOffset = encodingLength(version2);
   const hashOffset = codeOffset + encodingLength(code2);
-  const bytes = new Uint8Array(hashOffset + multihash.byteLength);
-  encodeTo(version2, bytes, 0);
-  encodeTo(code2, bytes, codeOffset);
-  bytes.set(multihash, hashOffset);
-  return bytes;
+  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 = {
@@ -2556,717 +1203,428 @@ function toString2(array, encoding = "utf8") {
   return base3.encoder.encode(array).substring(1);
 }
 
-// src/random.ts
-var randomBytes = (length2) => {
-  return webcrypto.getRandomValues(new Uint8Array(length2));
-};
-var randomIV = () => {
-  return randomBytes(12);
-};
-var randomStr = (byteLength, encoding) => {
-  const bytes = randomBytes(byteLength);
-  return toString2(bytes, encoding);
-};
-
-// src/aes.ts
-var AesKey = class {
-  constructor(key) {
-    this.key = key;
-  }
-  static async create() {
-    const key = await webcrypto.subtle.generateKey(
-      {
-        name: "AES-GCM",
-        length: 256
-      },
-      true,
-      ["encrypt", "decrypt"]
-    );
-    return new AesKey(key);
-  }
-  async encrypt(data) {
-    const iv = randomIV();
-    const dataBytes = fromString2(data, "utf8");
-    const buf = await webcrypto.subtle.encrypt(
-      {
-        name: "AES-GCM",
-        iv
-      },
-      this.key,
-      dataBytes
-    );
-    const encryptedBytes = new Uint8Array(buf);
-    const encrypted = toString2(
-      concat([iv, encryptedBytes]),
-      "base64pad"
-    );
-    return encrypted;
-  }
-  async decrypt(data) {
-    const dataBytes = fromString2(data, "base64pad");
-    const iv = dataBytes.slice(0, 12);
-    const encrypted = dataBytes.slice(12);
-    const buf = await webcrypto.subtle.decrypt(
-      {
-        name: "AES-GCM",
-        iv
-      },
-      this.key,
-      encrypted
-    );
-    const decryptedBytes = new Uint8Array(buf);
-    return toString2(decryptedBytes, "utf8");
+// ../../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;
 
-// src/const.ts
-var P256_DID_PREFIX = new Uint8Array([128, 36]);
-var SECP256K1_DID_PREFIX = new Uint8Array([231, 1]);
-var BASE58_DID_PREFIX = "did:key:z";
-var P256_JWT_ALG = "ES256";
-var SECP256K1_JWT_ALG = "ES256K";
+// ../../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;
 
-// src/p256/encoding.ts
-var import_big_integer = __toESM(require_BigInteger());
-var compressPubkey = (pubkeyBytes) => {
-  if (pubkeyBytes.length !== 65) {
-    throw new Error("Expected 65 byte pubkey");
-  } else if (pubkeyBytes[0] !== 4) {
-    throw new Error("Expected first byte to be 0x04");
-  }
-  const x = pubkeyBytes.slice(1, 33);
-  const y = pubkeyBytes.slice(33, 65);
-  const out = new Uint8Array(x.length + 1);
-  out[0] = 2 + (y[y.length - 1] & 1);
-  out.set(x, 1);
-  return out;
-};
-var decompressPubkey = (compressed) => {
-  if (compressed.length !== 33) {
-    throw new Error("Expected 33 byte compress pubkey");
-  } else if (compressed[0] !== 2 && compressed[0] !== 3) {
-    throw new Error("Expected first byte to be 0x02 or 0x03");
-  }
-  const two = (0, import_big_integer.default)(2);
-  const prime = two.pow(256).subtract(two.pow(224)).add(two.pow(192)).add(two.pow(96)).subtract(1);
-  const b = (0, import_big_integer.default)(
-    "41058363725152142129326129780047268409114441015993725554835256314039467401291"
-  );
-  const pIdent = prime.add(1).divide(4);
-  const signY = (0, import_big_integer.default)(compressed[0] - 2);
-  const x = compressed.slice(1);
-  const xBig = (0, import_big_integer.default)(toString2(x, "base10"));
-  const maybeY = xBig.pow(3).subtract(xBig.multiply(3)).add(b).modPow(pIdent, prime);
-  let yBig;
-  if (maybeY.mod(2).equals(signY)) {
-    yBig = maybeY;
-  } else {
-    yBig = prime.subtract(maybeY);
+// ../../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));
   }
-  const y = fromString2(yBig.toString(10), "base10");
-  const offset = 32 - y.length;
-  const yPadded = new Uint8Array(32);
-  yPadded.set(y, offset);
-  const publicKey = concat([[4], x, yPadded]);
-  return publicKey;
-};
+  throw new Error("crypto.getRandomValues must be defined");
+}
 
-// ../../node_modules/@noble/secp256k1/lib/esm/index.js
-var nodeCrypto = __toESM(require("crypto"), 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/@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 _3n = BigInt(3);
-var _8n = BigInt(8);
-var CURVE = Object.freeze({
-  a: _0n,
-  b: BigInt(7),
-  P: BigInt("0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2f"),
-  n: BigInt("0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141"),
-  h: _1n,
-  Gx: BigInt("55066263022277343669578718895168534326250603453777594175500187360389116729240"),
-  Gy: BigInt("32670510020758816978083085130507043184471273380659243275938904335757337482424"),
-  beta: BigInt("0x7ae96a2b657c07106e64479eac3434e99cf0497512f58995c1396c28719501ee")
-});
-function weistrass(x) {
-  const { a, b } = CURVE;
-  const x2 = mod(x * x);
-  const x3 = mod(x2 * x);
-  return mod(x3 + a * x + b);
-}
-var USE_ENDOMORPHISM = CURVE.a === _0n;
-var ShaError = class extends Error {
-  constructor(message) {
-    super(message);
+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]];
   }
-};
-var JacobianPoint = class {
-  constructor(x, y, z) {
-    this.x = x;
-    this.y = y;
-    this.z = z;
+  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;
   }
-  static fromAffine(p) {
-    if (!(p instanceof Point)) {
-      throw new TypeError("JacobianPoint#fromAffine: expected Point");
+  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}`);
     }
-    return new JacobianPoint(p.x, p.y, _1n);
-  }
-  static toAffineBatch(points) {
-    const toInv = invertBatch(points.map((p) => p.z));
-    return points.map((p, i) => p.toAffine(toInv[i]));
-  }
-  static normalizeZ(points) {
-    return JacobianPoint.toAffineBatch(points).map(JacobianPoint.fromAffine);
+  } else if (u8a2(hex)) {
+    res = Uint8Array.from(hex);
+  } else {
+    throw new Error(`${title} must be hex string or Uint8Array`);
   }
-  equals(other) {
-    if (!(other instanceof JacobianPoint))
-      throw new TypeError("JacobianPoint expected");
-    const { x: X1, y: Y1, z: Z1 } = this;
-    const { x: X2, y: Y2, z: Z2 } = other;
-    const Z1Z1 = mod(Z1 * Z1);
-    const Z2Z2 = mod(Z2 * Z2);
-    const U1 = mod(X1 * Z2Z2);
-    const U2 = mod(X2 * Z1Z1);
-    const S1 = mod(mod(Y1 * Z2) * Z2Z2);
-    const S2 = mod(mod(Y2 * Z1) * Z1Z1);
-    return U1 === U2 && S1 === S2;
-  }
-  negate() {
-    return new JacobianPoint(this.x, mod(-this.y), this.z);
-  }
-  double() {
-    const { x: X1, y: Y1, z: Z1 } = this;
-    const A = mod(X1 * X1);
-    const B = mod(Y1 * Y1);
-    const C = mod(B * B);
-    const x1b = X1 + B;
-    const D = mod(_2n * (mod(x1b * x1b) - A - C));
-    const E = mod(_3n * A);
-    const F = mod(E * E);
-    const X3 = mod(F - _2n * D);
-    const Y3 = mod(E * (D - X3) - _8n * C);
-    const Z3 = mod(_2n * Y1 * Z1);
-    return new JacobianPoint(X3, Y3, Z3);
-  }
-  add(other) {
-    if (!(other instanceof JacobianPoint))
-      throw new TypeError("JacobianPoint expected");
-    const { x: X1, y: Y1, z: Z1 } = this;
-    const { x: X2, y: Y2, z: Z2 } = other;
-    if (X2 === _0n || Y2 === _0n)
-      return this;
-    if (X1 === _0n || Y1 === _0n)
-      return other;
-    const Z1Z1 = mod(Z1 * Z1);
-    const Z2Z2 = mod(Z2 * Z2);
-    const U1 = mod(X1 * Z2Z2);
-    const U2 = mod(X2 * Z1Z1);
-    const S1 = mod(mod(Y1 * Z2) * Z2Z2);
-    const S2 = mod(mod(Y2 * Z1) * Z1Z1);
-    const H = mod(U2 - U1);
-    const r = mod(S2 - S1);
-    if (H === _0n) {
-      if (r === _0n) {
-        return this.double();
-      } else {
-        return JacobianPoint.ZERO;
-      }
+  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}`);
     }
-    const HH = mod(H * H);
-    const HHH = mod(H * HH);
-    const V = mod(U1 * HH);
-    const X3 = mod(r * r - HHH - _2n * V);
-    const Y3 = mod(r * (V - X3) - S1 * HHH);
-    const Z3 = mod(Z1 * Z2 * H);
-    return new JacobianPoint(X3, Y3, Z3);
-  }
-  subtract(other) {
-    return this.add(other.negate());
-  }
-  multiplyUnsafe(scalar) {
-    const P0 = JacobianPoint.ZERO;
-    if (typeof scalar === "bigint" && scalar === _0n)
-      return P0;
-    let n = normalizeScalar(scalar);
-    if (n === _1n)
-      return this;
-    if (!USE_ENDOMORPHISM) {
-      let p = P0;
-      let d2 = this;
-      while (n > _0n) {
-        if (n & _1n)
-          p = p.add(d2);
-        d2 = d2.double();
-        n >>= _1n;
-      }
-      return p;
-    }
-    let { k1neg, k1, k2neg, k2 } = splitScalarEndo(n);
-    let k1p = P0;
-    let k2p = P0;
-    let d = this;
-    while (k1 > _0n || k2 > _0n) {
-      if (k1 & _1n)
-        k1p = k1p.add(d);
-      if (k2 & _1n)
-        k2p = k2p.add(d);
-      d = d.double();
-      k1 >>= _1n;
-      k2 >>= _1n;
-    }
-    if (k1neg)
-      k1p = k1p.negate();
-    if (k2neg)
-      k2p = k2p.negate();
-    k2p = new JacobianPoint(mod(k2p.x * CURVE.beta), k2p.y, k2p.z);
-    return k1p.add(k2p);
-  }
-  precomputeWindow(W) {
-    const windows = USE_ENDOMORPHISM ? 128 / W + 1 : 256 / W + 1;
-    const points = [];
-    let p = this;
-    let base3 = p;
-    for (let window = 0; window < windows; window++) {
-      base3 = p;
-      points.push(base3);
-      for (let i = 1; i < 2 ** (W - 1); i++) {
-        base3 = base3.add(p);
-        points.push(base3);
-      }
-      p = base3.double();
-    }
-    return points;
-  }
-  wNAF(n, affinePoint) {
-    if (!affinePoint && this.equals(JacobianPoint.BASE))
-      affinePoint = Point.BASE;
-    const W = affinePoint && affinePoint._WINDOW_SIZE || 1;
-    if (256 % W) {
-      throw new Error("Point#wNAF: Invalid precomputation window, must be power of 2");
-    }
-    let precomputes = affinePoint && pointPrecomputes.get(affinePoint);
-    if (!precomputes) {
-      precomputes = this.precomputeWindow(W);
-      if (affinePoint && W !== 1) {
-        precomputes = JacobianPoint.normalizeZ(precomputes);
-        pointPrecomputes.set(affinePoint, precomputes);
-      }
-    }
-    let p = JacobianPoint.ZERO;
-    let f = JacobianPoint.ZERO;
-    const windows = 1 + (USE_ENDOMORPHISM ? 128 / W : 256 / W);
-    const windowSize = 2 ** (W - 1);
-    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 += _1n;
-      }
-      if (wbits === 0) {
-        let pr = precomputes[offset];
-        if (window % 2)
-          pr = pr.negate();
-        f = f.add(pr);
-      } else {
-        let cached = precomputes[offset + Math.abs(wbits) - 1];
-        if (wbits < 0)
-          cached = cached.negate();
-        p = p.add(cached);
-      }
-    }
-    return { p, f };
-  }
-  multiply(scalar, affinePoint) {
-    let n = normalizeScalar(scalar);
-    let point;
-    let fake;
-    if (USE_ENDOMORPHISM) {
-      const { k1neg, k1, k2neg, k2 } = splitScalarEndo(n);
-      let { p: k1p, f: f1p } = this.wNAF(k1, affinePoint);
-      let { p: k2p, f: f2p } = this.wNAF(k2, affinePoint);
-      if (k1neg)
-        k1p = k1p.negate();
-      if (k2neg)
-        k2p = k2p.negate();
-      k2p = new JacobianPoint(mod(k2p.x * CURVE.beta), k2p.y, k2p.z);
-      point = k1p.add(k2p);
-      fake = f1p.add(f2p);
-    } else {
-      const { p, f } = this.wNAF(n, affinePoint);
-      point = p;
-      fake = f;
-    }
-    return JacobianPoint.normalizeZ([point, fake])[0];
-  }
-  toAffine(invZ = invert(this.z)) {
-    const { x, y, z } = this;
-    const iz1 = invZ;
-    const iz2 = mod(iz1 * iz1);
-    const iz3 = mod(iz2 * iz1);
-    const ax = mod(x * iz2);
-    const ay = mod(y * iz3);
-    const zz = mod(z * iz1);
-    if (zz !== _1n)
-      throw new Error("invZ was invalid");
-    return new Point(ax, ay);
-  }
-};
-JacobianPoint.BASE = new JacobianPoint(CURVE.Gx, CURVE.Gy, _1n);
-JacobianPoint.ZERO = new JacobianPoint(_0n, _1n, _0n);
-var pointPrecomputes = /* @__PURE__ */ new WeakMap();
-var Point = class {
-  constructor(x, y) {
-    this.x = x;
-    this.y = y;
-  }
-  _setWindowSize(windowSize) {
-    this._WINDOW_SIZE = windowSize;
-    pointPrecomputes.delete(this);
-  }
-  hasEvenY() {
-    return this.y % _2n === _0n;
-  }
-  static fromCompressedHex(bytes) {
-    const isShort = bytes.length === 32;
-    const x = bytesToNumber(isShort ? bytes : bytes.subarray(1));
-    if (!isValidFieldElement(x))
-      throw new Error("Point is not on curve");
-    const y2 = weistrass(x);
-    let y = sqrtMod(y2);
-    const isYOdd = (y & _1n) === _1n;
-    if (isShort) {
-      if (isYOdd)
-        y = mod(-y);
-    } else {
-      const isFirstByteOdd = (bytes[0] & 1) === 1;
-      if (isFirstByteOdd !== isYOdd)
-        y = mod(-y);
-    }
-    const point = new Point(x, y);
-    point.assertValidity();
-    return point;
-  }
-  static fromUncompressedHex(bytes) {
-    const x = bytesToNumber(bytes.subarray(1, 33));
-    const y = bytesToNumber(bytes.subarray(33, 65));
-    const point = new Point(x, y);
-    point.assertValidity();
-    return point;
-  }
-  static fromHex(hex) {
-    const bytes = ensureBytes(hex);
-    const len = bytes.length;
-    const header = bytes[0];
-    if (len === 32 || len === 33 && (header === 2 || header === 3)) {
-      return this.fromCompressedHex(bytes);
-    }
-    if (len === 65 && header === 4)
-      return this.fromUncompressedHex(bytes);
-    throw new Error(`Point.fromHex: received invalid point. Expected 32-33 compressed bytes or 65 uncompressed bytes, not ${len}`);
-  }
-  static fromPrivateKey(privateKey) {
-    return Point.BASE.multiply(normalizePrivateKey(privateKey));
-  }
-  static fromSignature(msgHash, signature, recovery) {
-    msgHash = ensureBytes(msgHash);
-    const h = truncateHash(msgHash);
-    const { r, s } = normalizeSignature(signature);
-    if (recovery !== 0 && recovery !== 1) {
-      throw new Error("Cannot recover signature: invalid recovery bit");
-    }
-    const prefix = recovery & 1 ? "03" : "02";
-    const R = Point.fromHex(prefix + numTo32bStr(r));
-    const { n } = CURVE;
-    const rinv = invert(r, n);
-    const u1 = mod(-h * rinv, n);
-    const u2 = mod(s * rinv, n);
-    const Q = Point.BASE.multiplyAndAddUnsafe(R, u1, u2);
-    if (!Q)
-      throw new Error("Cannot recover signature: point at infinify");
-    Q.assertValidity();
-    return Q;
-  }
-  toRawBytes(isCompressed = false) {
-    return hexToBytes(this.toHex(isCompressed));
-  }
-  toHex(isCompressed = false) {
-    const x = numTo32bStr(this.x);
-    if (isCompressed) {
-      const prefix = this.hasEvenY() ? "02" : "03";
-      return `${prefix}${x}`;
-    } else {
-      return `04${x}${numTo32bStr(this.y)}`;
-    }
-  }
-  toHexX() {
-    return this.toHex(true).slice(2);
-  }
-  toRawX() {
-    return this.toRawBytes(true).slice(1);
-  }
-  assertValidity() {
-    const msg = "Point is not on elliptic curve";
-    const { x, y } = this;
-    if (!isValidFieldElement(x) || !isValidFieldElement(y))
-      throw new Error(msg);
-    const left = mod(y * y);
-    const right = weistrass(x);
-    if (mod(left - right) !== _0n)
-      throw new Error(msg);
-  }
-  equals(other) {
-    return this.x === other.x && this.y === other.y;
-  }
-  negate() {
-    return new Point(this.x, mod(-this.y));
-  }
-  double() {
-    return JacobianPoint.fromAffine(this).double().toAffine();
-  }
-  add(other) {
-    return JacobianPoint.fromAffine(this).add(JacobianPoint.fromAffine(other)).toAffine();
-  }
-  subtract(other) {
-    return this.add(other.negate());
-  }
-  multiply(scalar) {
-    return JacobianPoint.fromAffine(this).multiply(scalar, this).toAffine();
-  }
-  multiplyAndAddUnsafe(Q, a, b) {
-    const P = JacobianPoint.fromAffine(this);
-    const aP = a === _0n || a === _1n || this !== Point.BASE ? P.multiplyUnsafe(a) : P.multiply(a);
-    const bQ = JacobianPoint.fromAffine(Q).multiplyUnsafe(b);
-    const sum = aP.add(bQ);
-    return sum.equals(JacobianPoint.ZERO) ? void 0 : sum.toAffine();
-  }
-};
-Point.BASE = new Point(CURVE.Gx, CURVE.Gy);
-Point.ZERO = new Point(_0n, _0n);
-function sliceDER(s) {
-  return Number.parseInt(s[0], 16) >= 8 ? "00" + s : s;
-}
-function parseDERInt(data) {
-  if (data.length < 2 || data[0] !== 2) {
-    throw new Error(`Invalid signature integer tag: ${bytesToHex(data)}`);
-  }
-  const len = data[1];
-  const res = data.subarray(2, len + 2);
-  if (!len || res.length !== len) {
-    throw new Error(`Invalid signature integer: wrong length`);
-  }
-  if (res[0] === 0 && res[1] <= 127) {
-    throw new Error("Invalid signature integer: trailing length");
-  }
-  return { data: bytesToNumber(res), left: data.subarray(len + 2) };
-}
-function parseDERSignature(data) {
-  if (data.length < 2 || data[0] != 48) {
-    throw new Error(`Invalid signature tag: ${bytesToHex(data)}`);
-  }
-  if (data[1] !== data.length - 2) {
-    throw new Error("Invalid signature: incorrect length");
-  }
-  const { data: r, left: sBytes } = parseDERInt(data.subarray(2));
-  const { data: s, left: rBytesLeft } = parseDERInt(sBytes);
-  if (rBytesLeft.length) {
-    throw new Error(`Invalid signature: left bytes after parsing: ${bytesToHex(rBytesLeft)}`);
-  }
-  return { r, s };
-}
-var Signature = class {
-  constructor(r, s) {
-    this.r = r;
-    this.s = s;
-    this.assertValidity();
-  }
-  static fromCompact(hex) {
-    const arr = hex instanceof Uint8Array;
-    const name2 = "Signature.fromCompact";
-    if (typeof hex !== "string" && !arr)
-      throw new TypeError(`${name2}: Expected string or Uint8Array`);
-    const str = arr ? bytesToHex(hex) : hex;
-    if (str.length !== 128)
-      throw new Error(`${name2}: Expected 64-byte hex`);
-    return new Signature(hexToNumber(str.slice(0, 64)), hexToNumber(str.slice(64, 128)));
-  }
-  static fromDER(hex) {
-    const arr = hex instanceof Uint8Array;
-    if (typeof hex !== "string" && !arr)
-      throw new TypeError(`Signature.fromDER: Expected string or Uint8Array`);
-    const { r, s } = parseDERSignature(arr ? hex : hexToBytes(hex));
-    return new Signature(r, s);
-  }
-  static fromHex(hex) {
-    return this.fromDER(hex);
-  }
-  assertValidity() {
-    const { r, s } = this;
-    if (!isWithinCurveOrder(r))
-      throw new Error("Invalid Signature: r must be 0 < r < n");
-    if (!isWithinCurveOrder(s))
-      throw new Error("Invalid Signature: s must be 0 < s < n");
-  }
-  hasHighS() {
-    const HALF = CURVE.n >> _1n;
-    return this.s > HALF;
-  }
-  normalizeS() {
-    return this.hasHighS() ? new Signature(this.r, CURVE.n - this.s) : this;
-  }
-  toDERRawBytes(isCompressed = false) {
-    return hexToBytes(this.toDERHex(isCompressed));
-  }
-  toDERHex(isCompressed = false) {
-    const sHex = sliceDER(numberToHexUnpadded(this.s));
-    if (isCompressed)
-      return sHex;
-    const rHex = sliceDER(numberToHexUnpadded(this.r));
-    const rLen = numberToHexUnpadded(rHex.length / 2);
-    const sLen = numberToHexUnpadded(sHex.length / 2);
-    const length2 = numberToHexUnpadded(rHex.length / 2 + sHex.length / 2 + 4);
-    return `30${length2}02${rLen}${rHex}02${sLen}${sHex}`;
-  }
-  toRawBytes() {
-    return this.toDERRawBytes();
-  }
-  toHex() {
-    return this.toDERHex();
-  }
-  toCompactRawBytes() {
-    return hexToBytes(this.toCompactHex());
-  }
-  toCompactHex() {
-    return numTo32bStr(this.r) + numTo32bStr(this.s);
-  }
-};
-function concatBytes(...arrays) {
-  if (!arrays.every((b) => b instanceof Uint8Array))
-    throw new Error("Uint8Array list expected");
-  if (arrays.length === 1)
-    return arrays[0];
-  const length2 = arrays.reduce((a, arr) => a + arr.length, 0);
-  const result = new Uint8Array(length2);
-  for (let i = 0, pad = 0; i < arrays.length; i++) {
-    const arr = arrays[i];
-    result.set(arr, pad);
-    pad += arr.length;
-  }
-  return result;
-}
-var hexes = Array.from({ length: 256 }, (v, i) => i.toString(16).padStart(2, "0"));
-function bytesToHex(uint8a) {
-  if (!(uint8a instanceof Uint8Array))
-    throw new Error("Expected Uint8Array");
-  let hex = "";
-  for (let i = 0; i < uint8a.length; i++) {
-    hex += hexes[uint8a[i]];
-  }
-  return hex;
-}
-var POW_2_256 = BigInt("0x10000000000000000000000000000000000000000000000000000000000000000");
-function numTo32bStr(num) {
-  if (typeof num !== "bigint")
-    throw new Error("Expected bigint");
-  if (!(_0n <= num && num < POW_2_256))
-    throw new Error("Expected number < 2^256");
-  return num.toString(16).padStart(64, "0");
-}
-function numTo32b(num) {
-  const b = hexToBytes(numTo32bStr(num));
-  if (b.length !== 32)
-    throw new Error("Error: expected 32 bytes");
-  return b;
-}
-function numberToHexUnpadded(num) {
-  const hex = num.toString(16);
-  return hex.length & 1 ? `0${hex}` : hex;
+  };
+  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;
 }
-function hexToNumber(hex) {
-  if (typeof hex !== "string") {
-    throw new TypeError("hexToNumber: expected string, got " + typeof hex);
-  }
-  return BigInt(`0x${hex}`);
+
+// ../../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 hexToBytes(hex) {
-  if (typeof hex !== "string") {
-    throw new TypeError("hexToBytes: expected string, got " + typeof hex);
-  }
-  if (hex.length % 2)
-    throw new Error("hexToBytes: received invalid unpadded hex" + hex.length);
-  const array = new Uint8Array(hex.length / 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;
+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 array;
-}
-function bytesToNumber(bytes) {
-  return hexToNumber(bytesToHex(bytes));
-}
-function ensureBytes(hex) {
-  return hex instanceof Uint8Array ? Uint8Array.from(hex) : hexToBytes(hex);
-}
-function normalizeScalar(num) {
-  if (typeof num === "number" && Number.isSafeInteger(num) && num > 0)
-    return BigInt(num);
-  if (typeof num === "bigint" && isWithinCurveOrder(num))
-    return num;
-  throw new TypeError("Expected valid private scalar: 0 < scalar < curve.n");
-}
-function mod(a, b = CURVE.P) {
-  const result = a % b;
-  return result >= _0n ? result : b + result;
+  return res;
 }
-function pow2(x, power) {
-  const { P } = CURVE;
+function pow2(x, power, modulo) {
   let res = x;
-  while (power-- > _0n) {
+  while (power-- > _0n2) {
     res *= res;
-    res %= P;
+    res %= modulo;
   }
   return res;
 }
-function sqrtMod(x) {
-  const { P } = CURVE;
-  const _6n = BigInt(6);
-  const _11n = BigInt(11);
-  const _22n = BigInt(22);
-  const _23n = BigInt(23);
-  const _44n = BigInt(44);
-  const _88n = BigInt(88);
-  const b2 = x * x * x % P;
-  const b3 = b2 * b2 * x % P;
-  const b6 = pow2(b3, _3n) * b3 % P;
-  const b9 = pow2(b6, _3n) * b3 % P;
-  const b11 = pow2(b9, _2n) * b2 % P;
-  const b22 = pow2(b11, _11n) * b11 % P;
-  const b44 = pow2(b22, _22n) * b22 % P;
-  const b88 = pow2(b44, _44n) * b44 % P;
-  const b176 = pow2(b88, _88n) * b88 % P;
-  const b220 = pow2(b176, _44n) * b44 % P;
-  const b223 = pow2(b220, _3n) * b3 % P;
-  const t1 = pow2(b223, _23n) * b22 % P;
-  const t2 = pow2(t1, _6n) * b2 % P;
-  return pow2(t2, _2n);
-}
-function invert(number, modulo = CURVE.P) {
-  if (number === _0n || modulo <= _0n) {
-    throw new Error(`invert: expected positive integers, got n=${number} mod=${modulo}`);
+function invert(number2, modulo) {
+  if (number2 === _0n2 || modulo <= _0n2) {
+    throw new Error(`invert: expected positive integers, got n=${number2} mod=${modulo}`);
   }
-  let a = mod(number, modulo);
+  let a = mod(number2, modulo);
   let b = modulo;
-  let x = _0n, y = _1n, u = _1n, v = _0n;
-  while (a !== _0n) {
+  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;
@@ -3274,440 +1632,1427 @@ function invert(number, modulo = CURVE.P) {
     b = a, a = r, x = u, y = v, u = m, v = n;
   }
   const gcd = b;
-  if (gcd !== _1n)
+  if (gcd !== _1n2)
     throw new Error("invert: does not exist");
   return mod(x, modulo);
 }
-function invertBatch(nums, p = CURVE.P) {
-  const scratch = new Array(nums.length);
-  const lastMultiplied = nums.reduce((acc, num, i) => {
-    if (num === _0n)
-      return acc;
-    scratch[i] = acc;
-    return mod(acc * num, p);
-  }, _1n);
-  const inverted = invert(lastMultiplied, p);
-  nums.reduceRight((acc, num, i) => {
-    if (num === _0n)
-      return acc;
-    scratch[i] = mod(acc * scratch[i], p);
-    return mod(acc * num, p);
-  }, inverted);
-  return scratch;
-}
-var divNearest = (a, b) => (a + b / _2n) / b;
-var ENDO = {
-  a1: BigInt("0x3086d221a7d46bcde86c90e49284eb15"),
-  b1: -_1n * BigInt("0xe4437ed6010e88286f547fa90abfe4c3"),
-  a2: BigInt("0x114ca50f7a8e2f3f657c1108d9d44cfd8"),
-  b2: BigInt("0x3086d221a7d46bcde86c90e49284eb15"),
-  POW_2_128: BigInt("0x100000000000000000000000000000000")
-};
-function splitScalarEndo(k) {
-  const { n } = CURVE;
-  const { a1, b1, a2, b2, POW_2_128 } = ENDO;
-  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("splitScalarEndo: Endomorphism failed, k=" + k);
-  }
-  return { k1neg, k1, k2neg, k2 };
-}
-function truncateHash(hash) {
-  const { n } = CURVE;
-  const byteLength = hash.length;
-  const delta = byteLength * 8 - 256;
-  let h = bytesToNumber(hash);
-  if (delta > 0)
-    h = h >> BigInt(delta);
-  if (h >= n)
-    h -= n;
-  return h;
-}
-var _sha256Sync;
-var _hmacSha256Sync;
-var HmacDrbg = class {
-  constructor() {
-    this.v = new Uint8Array(32).fill(1);
-    this.k = new Uint8Array(32).fill(0);
-    this.counter = 0;
-  }
-  hmac(...values) {
-    return utils.hmacSha256(this.k, ...values);
-  }
-  hmacSync(...values) {
-    return _hmacSha256Sync(this.k, ...values);
-  }
-  checkSync() {
-    if (typeof _hmacSha256Sync !== "function")
-      throw new ShaError("hmacSha256Sync needs to be set");
-  }
-  incr() {
-    if (this.counter >= 1e3)
-      throw new Error("Tried 1,000 k values for sign(), all were invalid");
-    this.counter += 1;
-  }
-  async reseed(seed = new Uint8Array()) {
-    this.k = await this.hmac(this.v, Uint8Array.from([0]), seed);
-    this.v = await this.hmac(this.v);
-    if (seed.length === 0)
-      return;
-    this.k = await this.hmac(this.v, Uint8Array.from([1]), seed);
-    this.v = await this.hmac(this.v);
-  }
-  reseedSync(seed = new Uint8Array()) {
-    this.checkSync();
-    this.k = this.hmacSync(this.v, Uint8Array.from([0]), seed);
-    this.v = this.hmacSync(this.v);
-    if (seed.length === 0)
-      return;
-    this.k = this.hmacSync(this.v, Uint8Array.from([1]), seed);
-    this.v = this.hmacSync(this.v);
+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;
+    };
   }
-  async generate() {
-    this.incr();
-    this.v = await this.hmac(this.v);
-    return this.v;
+  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;
+    };
   }
-  generateSync() {
-    this.checkSync();
-    this.incr();
-    this.v = this.hmacSync(this.v);
-    return this.v;
+  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;
+    };
   }
-};
-function isWithinCurveOrder(num) {
-  return _0n < num && num < CURVE.n;
-}
-function isValidFieldElement(num) {
-  return _0n < num && num < CURVE.P;
-}
-function kmdToSig(kBytes, m, d) {
-  const k = bytesToNumber(kBytes);
-  if (!isWithinCurveOrder(k))
-    return;
-  const { n } = CURVE;
-  const q = Point.BASE.multiply(k);
-  const r = mod(q.x, n);
-  if (r === _0n)
-    return;
-  const s = mod(invert(k, n) * mod(m + d * r, n), n);
-  if (s === _0n)
-    return;
-  const sig = new Signature(r, s);
-  const recovery = (q.x === sig.r ? 0 : 2) | Number(q.y & _1n);
-  return { sig, recovery };
-}
-function normalizePrivateKey(key) {
-  let num;
-  if (typeof key === "bigint") {
-    num = key;
-  } else if (typeof key === "number" && Number.isSafeInteger(key) && key > 0) {
-    num = BigInt(key);
-  } else if (typeof key === "string") {
-    if (key.length !== 64)
-      throw new Error("Expected 32 bytes of private key");
-    num = hexToNumber(key);
-  } else if (key instanceof Uint8Array) {
-    if (key.length !== 32)
-      throw new Error("Expected 32 bytes of private key");
-    num = bytesToNumber(key);
-  } else {
-    throw new TypeError("Expected valid private key");
+  if (P % _16n === _9n) {
   }
-  if (!isWithinCurveOrder(num))
-    throw new Error("Expected private key: 0 < key < n");
-  return num;
+  return tonelliShanks(P);
 }
-function normalizePublicKey(publicKey) {
-  if (publicKey instanceof Point) {
-    publicKey.assertValidity();
-    return publicKey;
-  } else {
-    return Point.fromHex(publicKey);
-  }
+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 normalizeSignature(signature) {
-  if (signature instanceof Signature) {
-    signature.assertValidity();
-    return signature;
-  }
-  try {
-    return Signature.fromDER(signature);
-  } catch (error) {
-    return Signature.fromCompact(signature);
+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 getPublicKey(privateKey, isCompressed = false) {
-  return Point.fromPrivateKey(privateKey).toRawBytes(isCompressed);
-}
-function bits2int(bytes) {
-  const slice = bytes.length > 32 ? bytes.slice(0, 32) : bytes;
-  return bytesToNumber(slice);
+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 bits2octets(bytes) {
-  const z1 = bits2int(bytes);
-  const z2 = mod(z1, CURVE.n);
-  return int2octets(z2 < _0n ? z1 : z2);
+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 int2octets(num) {
-  return numTo32b(num);
+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 initSigArgs(msgHash, privateKey, extraEntropy) {
-  if (msgHash == null)
-    throw new Error(`sign: expected valid message hash, not "${msgHash}"`);
-  const h1 = ensureBytes(msgHash);
-  const d = normalizePrivateKey(privateKey);
-  const seedArgs = [int2octets(d), bits2octets(h1)];
-  if (extraEntropy != null) {
-    if (extraEntropy === true)
-      extraEntropy = utils.randomBytes(32);
-    const e = ensureBytes(extraEntropy);
-    if (e.length !== 32)
-      throw new Error("sign: Expected 32 bytes of extra data");
-    seedArgs.push(e);
-  }
-  const seed = concatBytes(...seedArgs);
-  const m = bits2int(h1);
-  return { seed, m, d };
+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;
 }
-function finalizeSig(recSig, opts) {
-  let { sig, recovery } = recSig;
-  const { canonical, der, recovered } = Object.assign({ canonical: true, der: true }, opts);
-  if (canonical && sig.hasHighS()) {
-    sig = sig.normalizeS();
-    recovery ^= 1;
-  }
-  const hashed = der ? sig.toDERRawBytes() : sig.toCompactRawBytes();
-  return recovered ? [hashed, recovery] : hashed;
+
+// ../../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);
+    }
+  };
 }
-async function sign(msgHash, privKey, opts = {}) {
-  const { seed, m, d } = initSigArgs(msgHash, privKey, opts.extraEntropy);
-  let sig;
-  const drbg = new HmacDrbg();
-  await drbg.reseed(seed);
-  while (!(sig = kmdToSig(await drbg.generate(), m, d)))
-    await drbg.reseed();
-  return finalizeSig(sig, opts);
+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 }
+  });
 }
-var vopts = { strict: true };
-function verify(signature, msgHash, publicKey, opts = vopts) {
-  let sig;
-  try {
-    sig = normalizeSignature(signature);
-    msgHash = ensureBytes(msgHash);
-  } catch (error) {
-    return false;
-  }
-  const { r, s } = sig;
-  if (opts.strict && sig.hasHighS())
-    return false;
-  const h = truncateHash(msgHash);
-  let P;
-  try {
-    P = normalizePublicKey(publicKey);
-  } catch (error) {
-    return false;
+
+// ../../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");
+    }
   }
-  const { n } = CURVE;
-  const sinv = invert(s, n);
-  const u1 = mod(h * sinv, n);
-  const u2 = mod(r * sinv, n);
-  const R = Point.BASE.multiplyAndAddUnsafe(P, u1, u2);
-  if (!R)
-    return false;
-  const v = mod(R.x, n);
-  return v === r;
+  return Object.freeze({ ...opts });
 }
-Point.BASE._setWindowSize(8);
-var crypto3 = {
-  node: nodeCrypto,
-  web: typeof self === "object" && "crypto" in self ? self.crypto : void 0
-};
-var TAGGED_HASH_PREFIXES = {};
-var utils = {
-  bytesToHex,
-  hexToBytes,
-  concatBytes,
-  mod,
-  invert,
-  isValidPrivateKey(privateKey) {
-    try {
-      normalizePrivateKey(privateKey);
-      return true;
-    } catch (error) {
-      return false;
+var { bytesToNumberBE: b2n, hexToBytes: h2b } = utils_exports;
+var DER = {
+  Err: class DERErr extends Error {
+    constructor(m = "") {
+      super(m);
     }
   },
-  _bigintTo32Bytes: numTo32b,
-  _normalizePrivateKey: normalizePrivateKey,
-  hashToPrivateKey: (hash) => {
-    hash = ensureBytes(hash);
-    if (hash.length < 40 || hash.length > 1024)
-      throw new Error("Expected 40-1024 bytes of private key as per FIPS 186");
-    const num = mod(bytesToNumber(hash), CURVE.n - _1n) + _1n;
-    return numTo32b(num);
-  },
-  randomBytes: (bytesLength = 32) => {
-    if (crypto3.web) {
-      return crypto3.web.getRandomValues(new Uint8Array(bytesLength));
-    } else if (crypto3.node) {
-      const { randomBytes: randomBytes2 } = crypto3.node;
-      return Uint8Array.from(randomBytes2(bytesLength));
-    } else {
-      throw new Error("The environment doesn't have randomBytes function");
-    }
+  _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) };
   },
-  randomPrivateKey: () => {
-    return utils.hashToPrivateKey(utils.randomBytes(40));
+  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 };
   },
-  sha256: async (...messages) => {
-    if (crypto3.web) {
-      const buffer = await crypto3.web.subtle.digest("SHA-256", concatBytes(...messages));
-      return new Uint8Array(buffer);
-    } else if (crypto3.node) {
-      const { createHash } = crypto3.node;
-      const hash = createHash("sha256");
-      messages.forEach((m) => hash.update(m));
-      return Uint8Array.from(hash.digest());
-    } else {
-      throw new Error("The environment doesn't have sha256 function");
+  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}`);
     }
-  },
-  hmacSha256: async (key, ...messages) => {
-    if (crypto3.web) {
-      const ckey = await crypto3.web.subtle.importKey("raw", key, { name: "HMAC", hash: { name: "SHA-256" } }, false, ["sign"]);
-      const message = concatBytes(...messages);
-      const buffer = await crypto3.web.subtle.sign("HMAC", ckey, message);
-      return new Uint8Array(buffer);
-    } else if (crypto3.node) {
-      const { createHmac } = crypto3.node;
-      const hash = createHmac("sha256", key);
-      messages.forEach((m) => hash.update(m));
-      return Uint8Array.from(hash.digest());
-    } else {
-      throw new Error("The environment doesn't have hmac-sha256 function");
+    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);
+      });
     }
-  },
-  sha256Sync: void 0,
-  hmacSha256Sync: void 0,
-  taggedHash: async (tag, ...messages) => {
-    let tagP = TAGGED_HASH_PREFIXES[tag];
-    if (tagP === void 0) {
-      const tagH = await utils.sha256(Uint8Array.from(tag, (c) => c.charCodeAt(0)));
-      tagP = concatBytes(tagH, tagH);
-      TAGGED_HASH_PREFIXES[tag] = tagP;
-    }
-    return utils.sha256(tagP, ...messages);
-  },
-  taggedHashSync: (tag, ...messages) => {
-    if (typeof _sha256Sync !== "function")
-      throw new ShaError("sha256Sync is undefined, you need to set it");
-    let tagP = TAGGED_HASH_PREFIXES[tag];
-    if (tagP === void 0) {
-      const tagH = _sha256Sync(Uint8Array.from(tag, (c) => c.charCodeAt(0)));
-      tagP = concatBytes(tagH, tagH);
-      TAGGED_HASH_PREFIXES[tag] = tagP;
-    }
-    return _sha256Sync(tagP, ...messages);
-  },
-  precompute(windowSize = 8, point = Point.BASE) {
-    const cached = point === Point.BASE ? point : new Point(point.x, point.y);
-    cached._setWindowSize(windowSize);
-    cached.multiply(_3n);
-    return cached;
-  }
-};
-Object.defineProperties(utils, {
-  sha256Sync: {
-    configurable: false,
-    get() {
-      return _sha256Sync;
+    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));
+      }
     },
-    set(val) {
-      if (!_sha256Sync)
-        _sha256Sync = val;
+    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`);
+      }
     }
-  },
-  hmacSha256Sync: {
-    configurable: false,
-    get() {
-      return _hmacSha256Sync;
+  });
+  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);
     },
-    set(val) {
-      if (!_hmacSha256Sync)
-        _hmacSha256Sync = val;
+    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/@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/@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/@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/@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/@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 hex = utils.bytesToHex(pubkeyBytes);
-  const point = Point.fromHex(hex);
+  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 hex = utils.bytesToHex(compressed);
-  const point = Point.fromHex(hex);
+  const point = secp256k1.ProjectivePoint.fromHex(compressed);
   return point.toRawBytes(false);
 };
 
 // src/p256/operations.ts
-var importKeypairJwk = async (jwk, exportable = false) => {
-  const privateKey = await webcrypto.subtle.importKey(
-    "jwk",
-    jwk,
-    { name: "ECDSA", namedCurve: "P-256" },
-    exportable,
-    ["sign"]
-  );
-  const { kty, crv, x, y } = jwk;
-  const pubKeyJwk = { kty, crv, x, y };
-  const publicKey = await webcrypto.subtle.importKey(
-    "jwk",
-    pubKeyJwk,
-    { name: "ECDSA", namedCurve: "P-256" },
-    true,
-    ["verify"]
-  );
-  return { privateKey, publicKey };
-};
 var verifyDidSig = async (did, data, sig) => {
   const { jwtAlg, keyBytes } = parseDidKey(did);
   if (jwtAlg !== P256_JWT_ALG) {
     throw new Error(`Not a P-256 did:key: ${did}`);
   }
-  return verify2(keyBytes, data, sig);
+  return verifySig(keyBytes, data, sig);
 };
-var verify2 = async (publicKey, data, sig) => {
-  const importedKey = await importEcdsaPublicKey(publicKey);
-  return webcrypto.subtle.verify(
-    { name: "ECDSA", hash: { name: "SHA-256" } },
-    importedKey,
-    sig,
-    data
-  );
-};
-var importEcdsaPublicKey = async (keyBytes) => {
-  return webcrypto.subtle.importKey(
-    "raw",
-    keyBytes,
-    { name: "ECDSA", namedCurve: "P-256" },
-    true,
-    ["verify"]
-  );
+var verifySig = async (publicKey, data, sig) => {
+  const msgHash = await sha2562(data);
+  return p256.verify(sig, msgHash, publicKey, { lowS: true });
 };
 
 // src/p256/plugin.ts
@@ -3724,8 +3069,11 @@ var verifyDidSig2 = async (did, data, sig) => {
   if (jwtAlg !== SECP256K1_JWT_ALG) {
     throw new Error(`Not a secp256k1 did:key: ${did}`);
   }
-  const msgHash = await utils.sha256(data);
-  return verify(sig, msgHash, keyBytes);
+  return verifySig2(keyBytes, data, sig);
+};
+var verifySig2 = async (publicKey, data, sig) => {
+  const msgHash = await sha2562(data);
+  return secp256k1.verify(sig, msgHash, publicKey, { lowS: true });
 };
 
 // src/secp256k1/plugin.ts
@@ -3741,13 +3089,12 @@ var plugins = [plugin_default, plugin_default2];
 var plugins_default = plugins;
 
 // src/did.ts
-var DID_KEY_BASE58_PREFIX = "did:key:z";
-var parseDidKey = (did) => {
-  if (!did.startsWith(DID_KEY_BASE58_PREFIX)) {
-    throw new Error(`Incorrect prefix for did:key: ${did}`);
+var parseMultikey = (multikey) => {
+  if (!multikey.startsWith(BASE58_MULTIBASE_PREFIX)) {
+    throw new Error(`Incorrect prefix for multikey: ${multikey}`);
   }
   const prefixedBytes = fromString2(
-    did.slice(DID_KEY_BASE58_PREFIX.length),
+    multikey.slice(BASE58_MULTIBASE_PREFIX.length),
     "base58btc"
   );
   const plugin = plugins_default.find((p) => hasPrefix(prefixedBytes, p.prefix));
@@ -3765,7 +3112,7 @@ var parseDidKey = (did) => {
     keyBytes
   };
 };
-var formatDidKey = (jwtAlg, keyBytes) => {
+var formatMultikey = (jwtAlg, keyBytes) => {
   const plugin = plugins_default.find((p) => p.jwtAlg === jwtAlg);
   if (!plugin) {
     throw new Error("Unsupported key type");
@@ -3776,10 +3123,19 @@ var formatDidKey = (jwtAlg, keyBytes) => {
     keyBytes = compressPubkey2(keyBytes);
   }
   const prefixedBytes = concat([plugin.prefix, keyBytes]);
-  return DID_KEY_BASE58_PREFIX + toString2(prefixedBytes, "base58btc");
+  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 = (bytes, prefix) => {
-  return equals(prefix, bytes.subarray(0, prefix.byteLength));
+var hasPrefix = (bytes2, prefix) => {
+  return equals(prefix, bytes2.subarray(0, prefix.byteLength));
 };
 
 // src/multibase.ts
@@ -3807,26 +3163,47 @@ var multibaseToBytes = (mb) => {
       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 import_crypto3 = __toESM(require("crypto"));
-var sha2562 = async (input) => {
-  const bytes = typeof input === "string" ? fromString2(input, "utf8") : input;
-  const hash = await sha256.digest(bytes);
-  return hash.digest;
+var sha2563 = async (input) => {
+  const bytes2 = typeof input === "string" ? fromString2(input, "utf8") : input;
+  return sha2562(bytes2);
 };
-var sha256Stream = async (stream) => {
-  const hash = import_crypto3.default.createHash("sha256");
-  try {
-    for await (const chunk of stream) {
-      hash.write(chunk);
-    }
-  } catch (err) {
-    hash.end();
-    throw err;
-  }
-  hash.end();
-  return hash.read();
+
+// 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
@@ -3845,30 +3222,22 @@ var verifySignatureUtf8 = async (didKey, data, sig) => {
 };
 
 // src/p256/keypair.ts
-var EcdsaKeypair = class {
-  constructor(keypair, publicKey, exportable) {
-    this.jwtAlg = P256_JWT_ALG;
-    this.keypair = keypair;
-    this.publicKey = publicKey;
+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 keypair = await webcrypto.subtle.generateKey(
-      { name: "ECDSA", namedCurve: "P-256" },
-      exportable,
-      ["sign", "verify"]
-    );
-    const pubkeyBuf = await webcrypto.subtle.exportKey("raw", keypair.publicKey);
-    const pubkeyBytes = new Uint8Array(pubkeyBuf);
-    return new EcdsaKeypair(keypair, pubkeyBytes, exportable);
-  }
-  static async import(jwk, opts) {
+    const privKey = p256.utils.randomPrivateKey();
+    return new P256Keypair(privKey, exportable);
+  }
+  static async import(privKey, opts) {
     const { exportable = false } = opts || {};
-    const keypair = await importKeypairJwk(jwk, exportable);
-    const pubkeyBuf = await webcrypto.subtle.exportKey("raw", keypair.publicKey);
-    const pubkeyBytes = new Uint8Array(pubkeyBuf);
-    return new EcdsaKeypair(keypair, pubkeyBytes, exportable);
+    const privKeyBytes = typeof privKey === "string" ? fromString2(privKey, "hex") : privKey;
+    return new P256Keypair(privKeyBytes, exportable);
   }
   publicKeyBytes() {
     return this.publicKey;
@@ -3880,19 +3249,15 @@ var EcdsaKeypair = class {
     return formatDidKey(this.jwtAlg, this.publicKey);
   }
   async sign(msg) {
-    const buf = await webcrypto.subtle.sign(
-      { name: "ECDSA", hash: { name: "SHA-256" } },
-      this.keypair.privateKey,
-      msg.buffer
-    );
-    return new Uint8Array(buf);
+    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");
     }
-    const jwk = await webcrypto.subtle.exportKey("jwk", this.keypair.privateKey);
-    return jwk;
+    return this.privateKey;
   }
 };
 
@@ -3902,11 +3267,11 @@ var Secp256k1Keypair = class {
     this.privateKey = privateKey;
     this.exportable = exportable;
     this.jwtAlg = SECP256K1_JWT_ALG;
-    this.publicKey = getPublicKey(privateKey);
+    this.publicKey = secp256k1.getPublicKey(privateKey);
   }
   static async create(opts) {
     const { exportable = false } = opts || {};
-    const privKey = utils.randomPrivateKey();
+    const privKey = secp256k1.utils.randomPrivateKey();
     return new Secp256k1Keypair(privKey, exportable);
   }
   static async import(privKey, opts) {
@@ -3924,8 +3289,9 @@ var Secp256k1Keypair = class {
     return formatDidKey(this.jwtAlg, this.publicKey);
   }
   async sign(msg) {
-    const msgHash = await utils.sha256(msg);
-    return sign(msgHash, this.privateKey, { der: false });
+    const msgHash = await sha2562(msg);
+    const sig = await secp256k1.sign(msgHash, this.privateKey, { lowS: true });
+    return sig.toCompactRawBytes();
   }
   async export() {
     if (!this.exportable) {
@@ -3936,27 +3302,29 @@ var Secp256k1Keypair = class {
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  AesKey,
-  BASE58_DID_PREFIX,
-  DID_KEY_BASE58_PREFIX,
-  EcdsaKeypair,
+  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,
-  randomIV,
+  randomIntFromSeed,
   randomStr,
   secp256k1Plugin,
   sha256,
-  sha256Stream,
   verifySignature,
   verifySignatureUtf8
 });
-/*! noble-secp256k1 - MIT License (c) 2019 Paul Miller (paulmillr.com) */
+/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+/*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) */
 //# sourceMappingURL=index.js.map