@atproto/crypto 0.0.1

package/dist/index.js

@@ -0,0 +1,3955 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __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 });
+};
+var __copyProps = (to, from3, except, desc) => {
+  if (from3 && typeof from3 === "object" || typeof from3 === "function") {
+    for (let key of __getOwnPropNames(from3))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from3[key], enumerable: !(desc = __getOwnPropDesc(from3, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod2, isNodeMode, target) => (target = mod2 != null ? __create(__getProtoOf(mod2)) : {}, __copyProps(
+  isNodeMode || !mod2 || !mod2.__esModule ? __defProp(target, "default", { value: mod2, enumerable: true }) : target,
+  mod2
+));
+var __toCommonJS = (mod2) => __copyProps(__defProp({}, "__esModule", { value: true }), mod2);
+
+// ../../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,
+  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,
+  formatDidKey: () => formatDidKey,
+  multibaseToBytes: () => multibaseToBytes,
+  p256Plugin: () => p256Plugin,
+  parseDidKey: () => parseDidKey,
+  randomBytes: () => randomBytes,
+  randomIV: () => randomIV,
+  randomStr: () => randomStr,
+  secp256k1Plugin: () => secp256k1Plugin,
+  sha256: () => sha2562,
+  sha256Stream: () => sha256Stream,
+  verifyDidSig: () => verifyDidSig3
+});
+module.exports = __toCommonJS(src_exports2);
+
+// ../../node_modules/one-webcrypto/node.mjs
+var import_crypto = __toESM(require("crypto"), 1);
+var webcrypto = import_crypto.default.webcrypto;
+
+// ../../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);
+  let offset = 0;
+  for (const arr of arrays) {
+    output.set(arr, offset);
+    offset += arr.length;
+  }
+  return output;
+}
+
+// ../../node_modules/uint8arrays/esm/src/equals.js
+function equals(a, b) {
+  if (a === b) {
+    return true;
+  }
+  if (a.byteLength !== b.byteLength) {
+    return false;
+  }
+  for (let i = 0; i < a.byteLength; i++) {
+    if (a[i] !== b[i]) {
+      return false;
+    }
+  }
+  return true;
+}
+
+// ../../node_modules/multiformats/esm/src/bases/identity.js
+var identity_exports = {};
+__export(identity_exports, {
+  identity: () => identity
+});
+
+// ../../node_modules/multiformats/esm/vendor/base-x.js
+function base(ALPHABET, name2) {
+  if (ALPHABET.length >= 255) {
+    throw new TypeError("Alphabet too long");
+  }
+  var BASE_MAP = new Uint8Array(256);
+  for (var j = 0; j < BASE_MAP.length; j++) {
+    BASE_MAP[j] = 255;
+  }
+  for (var i = 0; i < ALPHABET.length; i++) {
+    var x = ALPHABET.charAt(i);
+    var xc = x.charCodeAt(0);
+    if (BASE_MAP[xc] !== 255) {
+      throw new TypeError(x + " is ambiguous");
+    }
+    BASE_MAP[xc] = i;
+  }
+  var BASE = ALPHABET.length;
+  var LEADER = ALPHABET.charAt(0);
+  var FACTOR = Math.log(BASE) / Math.log(256);
+  var iFACTOR = Math.log(256) / Math.log(BASE);
+  function encode5(source) {
+    if (source instanceof Uint8Array)
+      ;
+    else if (ArrayBuffer.isView(source)) {
+      source = new Uint8Array(source.buffer, source.byteOffset, source.byteLength);
+    } else if (Array.isArray(source)) {
+      source = Uint8Array.from(source);
+    }
+    if (!(source instanceof Uint8Array)) {
+      throw new TypeError("Expected Uint8Array");
+    }
+    if (source.length === 0) {
+      return "";
+    }
+    var zeroes = 0;
+    var length2 = 0;
+    var pbegin = 0;
+    var pend = source.length;
+    while (pbegin !== pend && source[pbegin] === 0) {
+      pbegin++;
+      zeroes++;
+    }
+    var size = (pend - pbegin) * iFACTOR + 1 >>> 0;
+    var b58 = new Uint8Array(size);
+    while (pbegin !== pend) {
+      var carry = source[pbegin];
+      var i2 = 0;
+      for (var it1 = size - 1; (carry !== 0 || i2 < length2) && it1 !== -1; it1--, i2++) {
+        carry += 256 * b58[it1] >>> 0;
+        b58[it1] = carry % BASE >>> 0;
+        carry = carry / BASE >>> 0;
+      }
+      if (carry !== 0) {
+        throw new Error("Non-zero carry");
+      }
+      length2 = i2;
+      pbegin++;
+    }
+    var it2 = size - length2;
+    while (it2 !== size && b58[it2] === 0) {
+      it2++;
+    }
+    var str = LEADER.repeat(zeroes);
+    for (; it2 < size; ++it2) {
+      str += ALPHABET.charAt(b58[it2]);
+    }
+    return str;
+  }
+  function decodeUnsafe(source) {
+    if (typeof source !== "string") {
+      throw new TypeError("Expected String");
+    }
+    if (source.length === 0) {
+      return new Uint8Array();
+    }
+    var psz = 0;
+    if (source[psz] === " ") {
+      return;
+    }
+    var zeroes = 0;
+    var length2 = 0;
+    while (source[psz] === LEADER) {
+      zeroes++;
+      psz++;
+    }
+    var size = (source.length - psz) * FACTOR + 1 >>> 0;
+    var b256 = new Uint8Array(size);
+    while (source[psz]) {
+      var carry = BASE_MAP[source.charCodeAt(psz)];
+      if (carry === 255) {
+        return;
+      }
+      var i2 = 0;
+      for (var it3 = size - 1; (carry !== 0 || i2 < length2) && it3 !== -1; it3--, i2++) {
+        carry += BASE * b256[it3] >>> 0;
+        b256[it3] = carry % 256 >>> 0;
+        carry = carry / 256 >>> 0;
+      }
+      if (carry !== 0) {
+        throw new Error("Non-zero carry");
+      }
+      length2 = i2;
+      psz++;
+    }
+    if (source[psz] === " ") {
+      return;
+    }
+    var it4 = size - length2;
+    while (it4 !== size && b256[it4] === 0) {
+      it4++;
+    }
+    var vch = new Uint8Array(zeroes + (size - it4));
+    var j2 = zeroes;
+    while (it4 !== size) {
+      vch[j2++] = b256[it4++];
+    }
+    return vch;
+  }
+  function decode6(string2) {
+    var buffer = decodeUnsafe(string2);
+    if (buffer) {
+      return buffer;
+    }
+    throw new Error(`Non-${name2} character`);
+  }
+  return {
+    encode: encode5,
+    decodeUnsafe,
+    decode: decode6
+  };
+}
+var src = base;
+var _brrp__multiformats_scope_baseX = src;
+var base_x_default = _brrp__multiformats_scope_baseX;
+
+// ../../node_modules/multiformats/esm/src/bytes.js
+var empty = new Uint8Array(0);
+var equals2 = (aa, bb) => {
+  if (aa === bb)
+    return true;
+  if (aa.byteLength !== bb.byteLength) {
+    return false;
+  }
+  for (let ii = 0; ii < aa.byteLength; ii++) {
+    if (aa[ii] !== bb[ii]) {
+      return false;
+    }
+  }
+  return true;
+};
+var coerce = (o) => {
+  if (o instanceof Uint8Array && o.constructor.name === "Uint8Array")
+    return o;
+  if (o instanceof ArrayBuffer)
+    return new Uint8Array(o);
+  if (ArrayBuffer.isView(o)) {
+    return new Uint8Array(o.buffer, o.byteOffset, o.byteLength);
+  }
+  throw new Error("Unknown type, must be binary type");
+};
+var fromString = (str) => new TextEncoder().encode(str);
+var toString = (b) => new TextDecoder().decode(b);
+
+// ../../node_modules/multiformats/esm/src/bases/base.js
+var Encoder = class {
+  constructor(name2, prefix, baseEncode) {
+    this.name = name2;
+    this.prefix = prefix;
+    this.baseEncode = baseEncode;
+  }
+  encode(bytes) {
+    if (bytes instanceof Uint8Array) {
+      return `${this.prefix}${this.baseEncode(bytes)}`;
+    } else {
+      throw Error("Unknown type, must be binary type");
+    }
+  }
+};
+var Decoder = class {
+  constructor(name2, prefix, baseDecode) {
+    this.name = name2;
+    this.prefix = prefix;
+    if (prefix.codePointAt(0) === void 0) {
+      throw new Error("Invalid prefix character");
+    }
+    this.prefixCodePoint = prefix.codePointAt(0);
+    this.baseDecode = baseDecode;
+  }
+  decode(text) {
+    if (typeof text === "string") {
+      if (text.codePointAt(0) !== this.prefixCodePoint) {
+        throw Error(`Unable to decode multibase string ${JSON.stringify(text)}, ${this.name} decoder only supports inputs prefixed with ${this.prefix}`);
+      }
+      return this.baseDecode(text.slice(this.prefix.length));
+    } else {
+      throw Error("Can only multibase decode strings");
+    }
+  }
+  or(decoder) {
+    return or(this, decoder);
+  }
+};
+var ComposedDecoder = class {
+  constructor(decoders) {
+    this.decoders = decoders;
+  }
+  or(decoder) {
+    return or(this, decoder);
+  }
+  decode(input) {
+    const prefix = input[0];
+    const decoder = this.decoders[prefix];
+    if (decoder) {
+      return decoder.decode(input);
+    } else {
+      throw RangeError(`Unable to decode multibase string ${JSON.stringify(input)}, only inputs prefixed with ${Object.keys(this.decoders)} are supported`);
+    }
+  }
+};
+var or = (left, right) => new ComposedDecoder({
+  ...left.decoders || { [left.prefix]: left },
+  ...right.decoders || { [right.prefix]: right }
+});
+var Codec = class {
+  constructor(name2, prefix, baseEncode, baseDecode) {
+    this.name = name2;
+    this.prefix = prefix;
+    this.baseEncode = baseEncode;
+    this.baseDecode = baseDecode;
+    this.encoder = new Encoder(name2, prefix, baseEncode);
+    this.decoder = new Decoder(name2, prefix, baseDecode);
+  }
+  encode(input) {
+    return this.encoder.encode(input);
+  }
+  decode(input) {
+    return this.decoder.decode(input);
+  }
+};
+var from = ({ name: name2, prefix, encode: encode5, decode: decode6 }) => new Codec(name2, prefix, encode5, decode6);
+var baseX = ({ prefix, name: name2, alphabet: alphabet2 }) => {
+  const { encode: encode5, decode: decode6 } = base_x_default(alphabet2, name2);
+  return from({
+    prefix,
+    name: name2,
+    encode: encode5,
+    decode: (text) => coerce(decode6(text))
+  });
+};
+var decode = (string2, alphabet2, bitsPerChar, name2) => {
+  const codes = {};
+  for (let i = 0; i < alphabet2.length; ++i) {
+    codes[alphabet2[i]] = i;
+  }
+  let end = string2.length;
+  while (string2[end - 1] === "=") {
+    --end;
+  }
+  const out = new Uint8Array(end * bitsPerChar / 8 | 0);
+  let bits = 0;
+  let buffer = 0;
+  let written = 0;
+  for (let i = 0; i < end; ++i) {
+    const value = codes[string2[i]];
+    if (value === void 0) {
+      throw new SyntaxError(`Non-${name2} character`);
+    }
+    buffer = buffer << bitsPerChar | value;
+    bits += bitsPerChar;
+    if (bits >= 8) {
+      bits -= 8;
+      out[written++] = 255 & buffer >> bits;
+    }
+  }
+  if (bits >= bitsPerChar || 255 & buffer << 8 - bits) {
+    throw new SyntaxError("Unexpected end of data");
+  }
+  return out;
+};
+var encode = (data, alphabet2, bitsPerChar) => {
+  const pad = alphabet2[alphabet2.length - 1] === "=";
+  const mask = (1 << bitsPerChar) - 1;
+  let out = "";
+  let bits = 0;
+  let buffer = 0;
+  for (let i = 0; i < data.length; ++i) {
+    buffer = buffer << 8 | data[i];
+    bits += 8;
+    while (bits > bitsPerChar) {
+      bits -= bitsPerChar;
+      out += alphabet2[mask & buffer >> bits];
+    }
+  }
+  if (bits) {
+    out += alphabet2[mask & buffer << bitsPerChar - bits];
+  }
+  if (pad) {
+    while (out.length * bitsPerChar & 7) {
+      out += "=";
+    }
+  }
+  return out;
+};
+var rfc4648 = ({ name: name2, prefix, bitsPerChar, alphabet: alphabet2 }) => {
+  return from({
+    prefix,
+    name: name2,
+    encode(input) {
+      return encode(input, alphabet2, bitsPerChar);
+    },
+    decode(input) {
+      return decode(input, alphabet2, bitsPerChar, name2);
+    }
+  });
+};
+
+// ../../node_modules/multiformats/esm/src/bases/identity.js
+var identity = from({
+  prefix: "\0",
+  name: "identity",
+  encode: (buf) => toString(buf),
+  decode: (str) => fromString(str)
+});
+
+// ../../node_modules/multiformats/esm/src/bases/base2.js
+var base2_exports = {};
+__export(base2_exports, {
+  base2: () => base2
+});
+var base2 = rfc4648({
+  prefix: "0",
+  name: "base2",
+  alphabet: "01",
+  bitsPerChar: 1
+});
+
+// ../../node_modules/multiformats/esm/src/bases/base8.js
+var base8_exports = {};
+__export(base8_exports, {
+  base8: () => base8
+});
+var base8 = rfc4648({
+  prefix: "7",
+  name: "base8",
+  alphabet: "01234567",
+  bitsPerChar: 3
+});
+
+// ../../node_modules/multiformats/esm/src/bases/base10.js
+var base10_exports = {};
+__export(base10_exports, {
+  base10: () => base10
+});
+var base10 = baseX({
+  prefix: "9",
+  name: "base10",
+  alphabet: "0123456789"
+});
+
+// ../../node_modules/multiformats/esm/src/bases/base16.js
+var base16_exports = {};
+__export(base16_exports, {
+  base16: () => base16,
+  base16upper: () => base16upper
+});
+var base16 = rfc4648({
+  prefix: "f",
+  name: "base16",
+  alphabet: "0123456789abcdef",
+  bitsPerChar: 4
+});
+var base16upper = rfc4648({
+  prefix: "F",
+  name: "base16upper",
+  alphabet: "0123456789ABCDEF",
+  bitsPerChar: 4
+});
+
+// ../../node_modules/multiformats/esm/src/bases/base32.js
+var base32_exports = {};
+__export(base32_exports, {
+  base32: () => base32,
+  base32hex: () => base32hex,
+  base32hexpad: () => base32hexpad,
+  base32hexpadupper: () => base32hexpadupper,
+  base32hexupper: () => base32hexupper,
+  base32pad: () => base32pad,
+  base32padupper: () => base32padupper,
+  base32upper: () => base32upper,
+  base32z: () => base32z
+});
+var base32 = rfc4648({
+  prefix: "b",
+  name: "base32",
+  alphabet: "abcdefghijklmnopqrstuvwxyz234567",
+  bitsPerChar: 5
+});
+var base32upper = rfc4648({
+  prefix: "B",
+  name: "base32upper",
+  alphabet: "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567",
+  bitsPerChar: 5
+});
+var base32pad = rfc4648({
+  prefix: "c",
+  name: "base32pad",
+  alphabet: "abcdefghijklmnopqrstuvwxyz234567=",
+  bitsPerChar: 5
+});
+var base32padupper = rfc4648({
+  prefix: "C",
+  name: "base32padupper",
+  alphabet: "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567=",
+  bitsPerChar: 5
+});
+var base32hex = rfc4648({
+  prefix: "v",
+  name: "base32hex",
+  alphabet: "0123456789abcdefghijklmnopqrstuv",
+  bitsPerChar: 5
+});
+var base32hexupper = rfc4648({
+  prefix: "V",
+  name: "base32hexupper",
+  alphabet: "0123456789ABCDEFGHIJKLMNOPQRSTUV",
+  bitsPerChar: 5
+});
+var base32hexpad = rfc4648({
+  prefix: "t",
+  name: "base32hexpad",
+  alphabet: "0123456789abcdefghijklmnopqrstuv=",
+  bitsPerChar: 5
+});
+var base32hexpadupper = rfc4648({
+  prefix: "T",
+  name: "base32hexpadupper",
+  alphabet: "0123456789ABCDEFGHIJKLMNOPQRSTUV=",
+  bitsPerChar: 5
+});
+var base32z = rfc4648({
+  prefix: "h",
+  name: "base32z",
+  alphabet: "ybndrfg8ejkmcpqxot1uwisza345h769",
+  bitsPerChar: 5
+});
+
+// ../../node_modules/multiformats/esm/src/bases/base36.js
+var base36_exports = {};
+__export(base36_exports, {
+  base36: () => base36,
+  base36upper: () => base36upper
+});
+var base36 = baseX({
+  prefix: "k",
+  name: "base36",
+  alphabet: "0123456789abcdefghijklmnopqrstuvwxyz"
+});
+var base36upper = baseX({
+  prefix: "K",
+  name: "base36upper",
+  alphabet: "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+});
+
+// ../../node_modules/multiformats/esm/src/bases/base58.js
+var base58_exports = {};
+__export(base58_exports, {
+  base58btc: () => base58btc,
+  base58flickr: () => base58flickr
+});
+var base58btc = baseX({
+  name: "base58btc",
+  prefix: "z",
+  alphabet: "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"
+});
+var base58flickr = baseX({
+  name: "base58flickr",
+  prefix: "Z",
+  alphabet: "123456789abcdefghijkmnopqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ"
+});
+
+// ../../node_modules/multiformats/esm/src/bases/base64.js
+var base64_exports = {};
+__export(base64_exports, {
+  base64: () => base64,
+  base64pad: () => base64pad,
+  base64url: () => base64url,
+  base64urlpad: () => base64urlpad
+});
+var base64 = rfc4648({
+  prefix: "m",
+  name: "base64",
+  alphabet: "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/",
+  bitsPerChar: 6
+});
+var base64pad = rfc4648({
+  prefix: "M",
+  name: "base64pad",
+  alphabet: "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=",
+  bitsPerChar: 6
+});
+var base64url = rfc4648({
+  prefix: "u",
+  name: "base64url",
+  alphabet: "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_",
+  bitsPerChar: 6
+});
+var base64urlpad = rfc4648({
+  prefix: "U",
+  name: "base64urlpad",
+  alphabet: "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_=",
+  bitsPerChar: 6
+});
+
+// ../../node_modules/multiformats/esm/src/bases/base256emoji.js
+var base256emoji_exports = {};
+__export(base256emoji_exports, {
+  base256emoji: () => base256emoji
+});
+var alphabet = Array.from("\u{1F680}\u{1FA90}\u2604\u{1F6F0}\u{1F30C}\u{1F311}\u{1F312}\u{1F313}\u{1F314}\u{1F315}\u{1F316}\u{1F317}\u{1F318}\u{1F30D}\u{1F30F}\u{1F30E}\u{1F409}\u2600\u{1F4BB}\u{1F5A5}\u{1F4BE}\u{1F4BF}\u{1F602}\u2764\u{1F60D}\u{1F923}\u{1F60A}\u{1F64F}\u{1F495}\u{1F62D}\u{1F618}\u{1F44D}\u{1F605}\u{1F44F}\u{1F601}\u{1F525}\u{1F970}\u{1F494}\u{1F496}\u{1F499}\u{1F622}\u{1F914}\u{1F606}\u{1F644}\u{1F4AA}\u{1F609}\u263A\u{1F44C}\u{1F917}\u{1F49C}\u{1F614}\u{1F60E}\u{1F607}\u{1F339}\u{1F926}\u{1F389}\u{1F49E}\u270C\u2728\u{1F937}\u{1F631}\u{1F60C}\u{1F338}\u{1F64C}\u{1F60B}\u{1F497}\u{1F49A}\u{1F60F}\u{1F49B}\u{1F642}\u{1F493}\u{1F929}\u{1F604}\u{1F600}\u{1F5A4}\u{1F603}\u{1F4AF}\u{1F648}\u{1F447}\u{1F3B6}\u{1F612}\u{1F92D}\u2763\u{1F61C}\u{1F48B}\u{1F440}\u{1F62A}\u{1F611}\u{1F4A5}\u{1F64B}\u{1F61E}\u{1F629}\u{1F621}\u{1F92A}\u{1F44A}\u{1F973}\u{1F625}\u{1F924}\u{1F449}\u{1F483}\u{1F633}\u270B\u{1F61A}\u{1F61D}\u{1F634}\u{1F31F}\u{1F62C}\u{1F643}\u{1F340}\u{1F337}\u{1F63B}\u{1F613}\u2B50\u2705\u{1F97A}\u{1F308}\u{1F608}\u{1F918}\u{1F4A6}\u2714\u{1F623}\u{1F3C3}\u{1F490}\u2639\u{1F38A}\u{1F498}\u{1F620}\u261D\u{1F615}\u{1F33A}\u{1F382}\u{1F33B}\u{1F610}\u{1F595}\u{1F49D}\u{1F64A}\u{1F639}\u{1F5E3}\u{1F4AB}\u{1F480}\u{1F451}\u{1F3B5}\u{1F91E}\u{1F61B}\u{1F534}\u{1F624}\u{1F33C}\u{1F62B}\u26BD\u{1F919}\u2615\u{1F3C6}\u{1F92B}\u{1F448}\u{1F62E}\u{1F646}\u{1F37B}\u{1F343}\u{1F436}\u{1F481}\u{1F632}\u{1F33F}\u{1F9E1}\u{1F381}\u26A1\u{1F31E}\u{1F388}\u274C\u270A\u{1F44B}\u{1F630}\u{1F928}\u{1F636}\u{1F91D}\u{1F6B6}\u{1F4B0}\u{1F353}\u{1F4A2}\u{1F91F}\u{1F641}\u{1F6A8}\u{1F4A8}\u{1F92C}\u2708\u{1F380}\u{1F37A}\u{1F913}\u{1F619}\u{1F49F}\u{1F331}\u{1F616}\u{1F476}\u{1F974}\u25B6\u27A1\u2753\u{1F48E}\u{1F4B8}\u2B07\u{1F628}\u{1F31A}\u{1F98B}\u{1F637}\u{1F57A}\u26A0\u{1F645}\u{1F61F}\u{1F635}\u{1F44E}\u{1F932}\u{1F920}\u{1F927}\u{1F4CC}\u{1F535}\u{1F485}\u{1F9D0}\u{1F43E}\u{1F352}\u{1F617}\u{1F911}\u{1F30A}\u{1F92F}\u{1F437}\u260E\u{1F4A7}\u{1F62F}\u{1F486}\u{1F446}\u{1F3A4}\u{1F647}\u{1F351}\u2744\u{1F334}\u{1F4A3}\u{1F438}\u{1F48C}\u{1F4CD}\u{1F940}\u{1F922}\u{1F445}\u{1F4A1}\u{1F4A9}\u{1F450}\u{1F4F8}\u{1F47B}\u{1F910}\u{1F92E}\u{1F3BC}\u{1F975}\u{1F6A9}\u{1F34E}\u{1F34A}\u{1F47C}\u{1F48D}\u{1F4E3}\u{1F942}");
+var alphabetBytesToChars = alphabet.reduce((p, c, i) => {
+  p[i] = c;
+  return p;
+}, []);
+var alphabetCharsToBytes = alphabet.reduce((p, c, i) => {
+  p[c.codePointAt(0)] = i;
+  return p;
+}, []);
+function encode2(data) {
+  return data.reduce((p, c) => {
+    p += alphabetBytesToChars[c];
+    return p;
+  }, "");
+}
+function decode2(str) {
+  const byts = [];
+  for (const char of str) {
+    const byt = alphabetCharsToBytes[char.codePointAt(0)];
+    if (byt === void 0) {
+      throw new Error(`Non-base256emoji character: ${char}`);
+    }
+    byts.push(byt);
+  }
+  return new Uint8Array(byts);
+}
+var base256emoji = from({
+  prefix: "\u{1F680}",
+  name: "base256emoji",
+  encode: encode2,
+  decode: decode2
+});
+
+// ../../node_modules/multiformats/esm/src/hashes/sha2.js
+var sha2_exports = {};
+__export(sha2_exports, {
+  sha256: () => sha256,
+  sha512: () => sha512
+});
+var import_crypto2 = __toESM(require("crypto"), 1);
+
+// ../../node_modules/multiformats/esm/vendor/varint.js
+var encode_1 = encode3;
+var MSB = 128;
+var REST = 127;
+var MSBALL = ~REST;
+var INT = Math.pow(2, 31);
+function encode3(num, out, offset) {
+  out = out || [];
+  offset = offset || 0;
+  var oldOffset = offset;
+  while (num >= INT) {
+    out[offset++] = num & 255 | MSB;
+    num /= 128;
+  }
+  while (num & MSBALL) {
+    out[offset++] = num & 255 | MSB;
+    num >>>= 7;
+  }
+  out[offset] = num | 0;
+  encode3.bytes = offset - oldOffset + 1;
+  return out;
+}
+var decode3 = read;
+var MSB$1 = 128;
+var REST$1 = 127;
+function read(buf, offset) {
+  var res = 0, offset = offset || 0, shift = 0, counter = offset, b, l = buf.length;
+  do {
+    if (counter >= l) {
+      read.bytes = 0;
+      throw new RangeError("Could not decode varint");
+    }
+    b = buf[counter++];
+    res += shift < 28 ? (b & REST$1) << shift : (b & REST$1) * Math.pow(2, shift);
+    shift += 7;
+  } while (b >= MSB$1);
+  read.bytes = counter - offset;
+  return res;
+}
+var N1 = Math.pow(2, 7);
+var N2 = Math.pow(2, 14);
+var N3 = Math.pow(2, 21);
+var N4 = Math.pow(2, 28);
+var N5 = Math.pow(2, 35);
+var N6 = Math.pow(2, 42);
+var N7 = Math.pow(2, 49);
+var N8 = Math.pow(2, 56);
+var N9 = Math.pow(2, 63);
+var length = function(value) {
+  return value < N1 ? 1 : value < N2 ? 2 : value < N3 ? 3 : value < N4 ? 4 : value < N5 ? 5 : value < N6 ? 6 : value < N7 ? 7 : value < N8 ? 8 : value < N9 ? 9 : 10;
+};
+var varint = {
+  encode: encode_1,
+  decode: decode3,
+  encodingLength: length
+};
+var _brrp_varint = varint;
+var varint_default = _brrp_varint;
+
+// ../../node_modules/multiformats/esm/src/varint.js
+var decode4 = (data, offset = 0) => {
+  const code2 = varint_default.decode(data, offset);
+  return [
+    code2,
+    varint_default.decode.bytes
+  ];
+};
+var encodeTo = (int, target, offset = 0) => {
+  varint_default.encode(int, target, offset);
+  return target;
+};
+var encodingLength = (int) => {
+  return varint_default.encodingLength(int);
+};
+
+// ../../node_modules/multiformats/esm/src/hashes/digest.js
+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);
+};
+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);
+  if (digest2.byteLength !== size) {
+    throw new Error("Incorrect length");
+  }
+  return new Digest(code2, size, digest2, bytes);
+};
+var equals3 = (a, b) => {
+  if (a === b) {
+    return true;
+  } else {
+    return a.code === b.code && a.size === b.size && equals2(a.bytes, b.bytes);
+  }
+};
+var Digest = class {
+  constructor(code2, size, digest2, bytes) {
+    this.code = code2;
+    this.size = size;
+    this.digest = digest2;
+    this.bytes = bytes;
+  }
+};
+
+// ../../node_modules/multiformats/esm/src/hashes/hasher.js
+var from2 = ({ name: name2, code: code2, encode: encode5 }) => new Hasher(name2, code2, encode5);
+var Hasher = class {
+  constructor(name2, code2, encode5) {
+    this.name = name2;
+    this.code = code2;
+    this.encode = encode5;
+  }
+  digest(input) {
+    if (input instanceof Uint8Array) {
+      const result = this.encode(input);
+      return result instanceof Uint8Array ? create(this.code, result) : result.then((digest2) => create(this.code, digest2));
+    } else {
+      throw Error("Unknown type, must be binary type");
+    }
+  }
+};
+
+// ../../node_modules/multiformats/esm/src/hashes/sha2.js
+var sha256 = from2({
+  name: "sha2-256",
+  code: 18,
+  encode: (input) => coerce(import_crypto2.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())
+});
+
+// ../../node_modules/multiformats/esm/src/hashes/identity.js
+var identity_exports2 = {};
+__export(identity_exports2, {
+  identity: () => identity2
+});
+var code = 0;
+var name = "identity";
+var encode4 = coerce;
+var digest = (input) => create(code, encode4(input));
+var identity2 = {
+  code,
+  name,
+  encode: encode4,
+  digest
+};
+
+// ../../node_modules/multiformats/esm/src/codecs/json.js
+var textEncoder = new TextEncoder();
+var textDecoder = new TextDecoder();
+
+// ../../node_modules/multiformats/esm/src/cid.js
+var CID = class {
+  constructor(version2, code2, multihash, bytes) {
+    this.code = code2;
+    this.version = version2;
+    this.multihash = multihash;
+    this.bytes = bytes;
+    this.byteOffset = bytes.byteOffset;
+    this.byteLength = bytes.byteLength;
+    this.asCID = this;
+    this._baseCache = /* @__PURE__ */ new Map();
+    Object.defineProperties(this, {
+      byteOffset: hidden,
+      byteLength: hidden,
+      code: readonly,
+      version: readonly,
+      multihash: readonly,
+      bytes: readonly,
+      _baseCache: hidden,
+      asCID: hidden
+    });
+  }
+  toV0() {
+    switch (this.version) {
+      case 0: {
+        return this;
+      }
+      default: {
+        const { code: code2, multihash } = this;
+        if (code2 !== DAG_PB_CODE) {
+          throw new Error("Cannot convert a non dag-pb CID to CIDv0");
+        }
+        if (multihash.code !== SHA_256_CODE) {
+          throw new Error("Cannot convert non sha2-256 multihash CID to CIDv0");
+        }
+        return CID.createV0(multihash);
+      }
+    }
+  }
+  toV1() {
+    switch (this.version) {
+      case 0: {
+        const { code: code2, digest: digest2 } = this.multihash;
+        const multihash = create(code2, digest2);
+        return CID.createV1(this.code, multihash);
+      }
+      case 1: {
+        return this;
+      }
+      default: {
+        throw Error(`Can not convert CID version ${this.version} to version 0. This is a bug please report`);
+      }
+    }
+  }
+  equals(other) {
+    return other && this.code === other.code && this.version === other.version && equals3(this.multihash, other.multihash);
+  }
+  toString(base3) {
+    const { bytes, version: version2, _baseCache } = this;
+    switch (version2) {
+      case 0:
+        return toStringV0(bytes, _baseCache, base3 || base58btc.encoder);
+      default:
+        return toStringV1(bytes, _baseCache, base3 || base32.encoder);
+    }
+  }
+  toJSON() {
+    return {
+      code: this.code,
+      version: this.version,
+      hash: this.multihash.bytes
+    };
+  }
+  get [Symbol.toStringTag]() {
+    return "CID";
+  }
+  [Symbol.for("nodejs.util.inspect.custom")]() {
+    return "CID(" + this.toString() + ")";
+  }
+  static isCID(value) {
+    deprecate(/^0\.0/, IS_CID_DEPRECATION);
+    return !!(value && (value[cidSymbol] || value.asCID === value));
+  }
+  get toBaseEncodedString() {
+    throw new Error("Deprecated, use .toString()");
+  }
+  get codec() {
+    throw new Error('"codec" property is deprecated, use integer "code" property instead');
+  }
+  get buffer() {
+    throw new Error("Deprecated .buffer property, use .bytes to get Uint8Array instead");
+  }
+  get multibaseName() {
+    throw new Error('"multibaseName" property is deprecated');
+  }
+  get prefix() {
+    throw new Error('"prefix" property is deprecated');
+  }
+  static asCID(value) {
+    if (value instanceof CID) {
+      return value;
+    } else if (value != null && value.asCID === value) {
+      const { version: version2, code: code2, multihash, bytes } = value;
+      return new CID(version2, code2, multihash, bytes || encodeCID(version2, code2, multihash.bytes));
+    } else if (value != null && value[cidSymbol] === true) {
+      const { version: version2, multihash, code: code2 } = value;
+      const digest2 = decode5(multihash);
+      return CID.create(version2, code2, digest2);
+    } else {
+      return null;
+    }
+  }
+  static create(version2, code2, digest2) {
+    if (typeof code2 !== "number") {
+      throw new Error("String codecs are no longer supported");
+    }
+    switch (version2) {
+      case 0: {
+        if (code2 !== DAG_PB_CODE) {
+          throw new Error(`Version 0 CID must use dag-pb (code: ${DAG_PB_CODE}) block encoding`);
+        } else {
+          return new CID(version2, code2, digest2, digest2.bytes);
+        }
+      }
+      case 1: {
+        const bytes = encodeCID(version2, code2, digest2.bytes);
+        return new CID(version2, code2, digest2, bytes);
+      }
+      default: {
+        throw new Error("Invalid version");
+      }
+    }
+  }
+  static createV0(digest2) {
+    return CID.create(0, DAG_PB_CODE, digest2);
+  }
+  static createV1(code2, digest2) {
+    return CID.create(1, code2, digest2);
+  }
+  static decode(bytes) {
+    const [cid, remainder] = CID.decodeFirst(bytes);
+    if (remainder.length) {
+      throw new Error("Incorrect length");
+    }
+    return cid;
+  }
+  static decodeFirst(bytes) {
+    const specs = CID.inspectBytes(bytes);
+    const prefixSize = specs.size - specs.multihashSize;
+    const multihashBytes = coerce(bytes.subarray(prefixSize, prefixSize + specs.multihashSize));
+    if (multihashBytes.byteLength !== specs.multihashSize) {
+      throw new Error("Incorrect length");
+    }
+    const digestBytes = multihashBytes.subarray(specs.multihashSize - specs.digestSize);
+    const digest2 = new Digest(specs.multihashCode, specs.digestSize, digestBytes, multihashBytes);
+    const cid = specs.version === 0 ? CID.createV0(digest2) : CID.createV1(specs.codec, digest2);
+    return [
+      cid,
+      bytes.subarray(specs.size)
+    ];
+  }
+  static inspectBytes(initialBytes) {
+    let offset = 0;
+    const next = () => {
+      const [i, length2] = decode4(initialBytes.subarray(offset));
+      offset += length2;
+      return i;
+    };
+    let version2 = next();
+    let codec = DAG_PB_CODE;
+    if (version2 === 18) {
+      version2 = 0;
+      offset = 0;
+    } else if (version2 === 1) {
+      codec = next();
+    }
+    if (version2 !== 0 && version2 !== 1) {
+      throw new RangeError(`Invalid CID version ${version2}`);
+    }
+    const prefixSize = offset;
+    const multihashCode = next();
+    const digestSize = next();
+    const size = offset + digestSize;
+    const multihashSize = size - prefixSize;
+    return {
+      version: version2,
+      codec,
+      multihashCode,
+      digestSize,
+      multihashSize,
+      size
+    };
+  }
+  static parse(source, base3) {
+    const [prefix, bytes] = parseCIDtoBytes(source, base3);
+    const cid = CID.decode(bytes);
+    cid._baseCache.set(prefix, source);
+    return cid;
+  }
+};
+var parseCIDtoBytes = (source, base3) => {
+  switch (source[0]) {
+    case "Q": {
+      const decoder = base3 || base58btc;
+      return [
+        base58btc.prefix,
+        decoder.decode(`${base58btc.prefix}${source}`)
+      ];
+    }
+    case base58btc.prefix: {
+      const decoder = base3 || base58btc;
+      return [
+        base58btc.prefix,
+        decoder.decode(source)
+      ];
+    }
+    case base32.prefix: {
+      const decoder = base3 || base32;
+      return [
+        base32.prefix,
+        decoder.decode(source)
+      ];
+    }
+    default: {
+      if (base3 == null) {
+        throw Error("To parse non base32 or base58btc encoded CID multibase decoder must be provided");
+      }
+      return [
+        source[0],
+        base3.decode(source)
+      ];
+    }
+  }
+};
+var toStringV0 = (bytes, 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);
+    cache.set(prefix, cid2);
+    return cid2;
+  } else {
+    return cid;
+  }
+};
+var toStringV1 = (bytes, cache, base3) => {
+  const { prefix } = base3;
+  const cid = cache.get(prefix);
+  if (cid == null) {
+    const cid2 = base3.encode(bytes);
+    cache.set(prefix, cid2);
+    return cid2;
+  } else {
+    return cid;
+  }
+};
+var DAG_PB_CODE = 112;
+var SHA_256_CODE = 18;
+var encodeCID = (version2, code2, multihash) => {
+  const codeOffset = encodingLength(version2);
+  const hashOffset = codeOffset + encodingLength(code2);
+  const bytes = new Uint8Array(hashOffset + multihash.byteLength);
+  encodeTo(version2, bytes, 0);
+  encodeTo(code2, bytes, codeOffset);
+  bytes.set(multihash, hashOffset);
+  return bytes;
+};
+var cidSymbol = Symbol.for("@ipld/js-cid/CID");
+var readonly = {
+  writable: false,
+  configurable: false,
+  enumerable: true
+};
+var hidden = {
+  writable: false,
+  enumerable: false,
+  configurable: false
+};
+var version = "0.0.0-dev";
+var deprecate = (range, message) => {
+  if (range.test(version)) {
+    console.warn(message);
+  } else {
+    throw new Error(message);
+  }
+};
+var IS_CID_DEPRECATION = `CID.isCID(v) is deprecated and will be removed in the next major release.
+Following code pattern:
+
+if (CID.isCID(value)) {
+  doSomethingWithCID(value)
+}
+
+Is replaced with:
+
+const cid = CID.asCID(value)
+if (cid) {
+  // Make sure to use cid instead of value
+  doSomethingWithCID(cid)
+}
+`;
+
+// ../../node_modules/multiformats/esm/src/basics.js
+var bases = {
+  ...identity_exports,
+  ...base2_exports,
+  ...base8_exports,
+  ...base10_exports,
+  ...base16_exports,
+  ...base32_exports,
+  ...base36_exports,
+  ...base58_exports,
+  ...base64_exports,
+  ...base256emoji_exports
+};
+var hashes = {
+  ...sha2_exports,
+  ...identity_exports2
+};
+
+// ../../node_modules/uint8arrays/esm/src/util/bases.js
+function createCodec(name2, prefix, encode5, decode6) {
+  return {
+    name: name2,
+    prefix,
+    encoder: {
+      name: name2,
+      prefix,
+      encode: encode5
+    },
+    decoder: { decode: decode6 }
+  };
+}
+var string = createCodec("utf8", "u", (buf) => {
+  const decoder = new TextDecoder("utf8");
+  return "u" + decoder.decode(buf);
+}, (str) => {
+  const encoder = new TextEncoder();
+  return encoder.encode(str.substring(1));
+});
+var ascii = createCodec("ascii", "a", (buf) => {
+  let string2 = "a";
+  for (let i = 0; i < buf.length; i++) {
+    string2 += String.fromCharCode(buf[i]);
+  }
+  return string2;
+}, (str) => {
+  str = str.substring(1);
+  const buf = new Uint8Array(str.length);
+  for (let i = 0; i < str.length; i++) {
+    buf[i] = str.charCodeAt(i);
+  }
+  return buf;
+});
+var BASES = {
+  utf8: string,
+  "utf-8": string,
+  hex: bases.base16,
+  latin1: ascii,
+  ascii,
+  binary: ascii,
+  ...bases
+};
+var bases_default = BASES;
+
+// ../../node_modules/uint8arrays/esm/src/from-string.js
+function fromString2(string2, encoding = "utf8") {
+  const base3 = bases_default[encoding];
+  if (!base3) {
+    throw new Error(`Unsupported encoding "${encoding}"`);
+  }
+  return base3.decoder.decode(`${base3.prefix}${string2}`);
+}
+
+// ../../node_modules/uint8arrays/esm/src/to-string.js
+function toString2(array, encoding = "utf8") {
+  const base3 = bases_default[encoding];
+  if (!base3) {
+    throw new Error(`Unsupported encoding "${encoding}"`);
+  }
+  return base3.encoder.encode(array).substring(1);
+}
+
+// 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");
+  }
+};
+
+// 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";
+
+// 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);
+  }
+  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;
+};
+
+// ../../node_modules/@noble/secp256k1/lib/esm/index.js
+var nodeCrypto = __toESM(require("crypto"), 1);
+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 JacobianPoint = class {
+  constructor(x, y, z) {
+    this.x = x;
+    this.y = y;
+    this.z = z;
+  }
+  static fromAffine(p) {
+    if (!(p instanceof Point)) {
+      throw new TypeError("JacobianPoint#fromAffine: expected Point");
+    }
+    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);
+  }
+  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 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;
+}
+function hexToNumber(hex) {
+  if (typeof hex !== "string") {
+    throw new TypeError("hexToNumber: expected string, got " + typeof hex);
+  }
+  return BigInt(`0x${hex}`);
+}
+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;
+  }
+  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;
+}
+function pow2(x, power) {
+  const { P } = CURVE;
+  let res = x;
+  while (power-- > _0n) {
+    res *= res;
+    res %= P;
+  }
+  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}`);
+  }
+  let a = mod(number, modulo);
+  let b = modulo;
+  let x = _0n, y = _1n, u = _1n, v = _0n;
+  while (a !== _0n) {
+    const q = b / a;
+    const r = b % a;
+    const m = x - u * q;
+    const n = y - v * q;
+    b = a, a = r, x = u, y = v, u = m, v = n;
+  }
+  const gcd = b;
+  if (gcd !== _1n)
+    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);
+  }
+  async generate() {
+    this.incr();
+    this.v = await this.hmac(this.v);
+    return this.v;
+  }
+  generateSync() {
+    this.checkSync();
+    this.incr();
+    this.v = this.hmacSync(this.v);
+    return this.v;
+  }
+};
+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 (!isWithinCurveOrder(num))
+    throw new Error("Expected private key: 0 < key < n");
+  return num;
+}
+function normalizePublicKey(publicKey) {
+  if (publicKey instanceof Point) {
+    publicKey.assertValidity();
+    return publicKey;
+  } else {
+    return Point.fromHex(publicKey);
+  }
+}
+function normalizeSignature(signature) {
+  if (signature instanceof Signature) {
+    signature.assertValidity();
+    return signature;
+  }
+  try {
+    return Signature.fromDER(signature);
+  } catch (error) {
+    return Signature.fromCompact(signature);
+  }
+}
+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 bits2octets(bytes) {
+  const z1 = bits2int(bytes);
+  const z2 = mod(z1, CURVE.n);
+  return int2octets(z2 < _0n ? z1 : z2);
+}
+function int2octets(num) {
+  return numTo32b(num);
+}
+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 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;
+}
+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);
+}
+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;
+  }
+  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;
+}
+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;
+    }
+  },
+  _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");
+    }
+  },
+  randomPrivateKey: () => {
+    return utils.hashToPrivateKey(utils.randomBytes(40));
+  },
+  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");
+    }
+  },
+  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");
+    }
+  },
+  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;
+    },
+    set(val) {
+      if (!_sha256Sync)
+        _sha256Sync = val;
+    }
+  },
+  hmacSha256Sync: {
+    configurable: false,
+    get() {
+      return _hmacSha256Sync;
+    },
+    set(val) {
+      if (!_hmacSha256Sync)
+        _hmacSha256Sync = val;
+    }
+  }
+});
+
+// src/secp256k1/encoding.ts
+var compressPubkey2 = (pubkeyBytes) => {
+  const hex = utils.bytesToHex(pubkeyBytes);
+  const point = Point.fromHex(hex);
+  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);
+  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);
+};
+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"]
+  );
+};
+
+// src/p256/plugin.ts
+var p256Plugin = {
+  prefix: P256_DID_PREFIX,
+  jwtAlg: P256_JWT_ALG,
+  verifySignature: verifyDidSig
+};
+var plugin_default = p256Plugin;
+
+// src/secp256k1/operations.ts
+var verifyDidSig2 = async (did, data, sig) => {
+  const { jwtAlg, keyBytes } = parseDidKey(did);
+  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);
+};
+
+// src/secp256k1/plugin.ts
+var secp256k1Plugin = {
+  prefix: SECP256K1_DID_PREFIX,
+  jwtAlg: SECP256K1_JWT_ALG,
+  verifySignature: verifyDidSig2
+};
+var plugin_default2 = secp256k1Plugin;
+
+// src/plugins.ts
+var plugins = [plugin_default, plugin_default2];
+var plugins_default = plugins;
+
+// src/did.ts
+var 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}`);
+  }
+  const prefixedBytes = fromString2(
+    did.slice(DID_KEY_BASE58_PREFIX.length),
+    "base58btc"
+  );
+  const plugin = plugins_default.find((p) => hasPrefix(prefixedBytes, p.prefix));
+  if (!plugin) {
+    throw new Error("Unsupported key type");
+  }
+  let keyBytes = prefixedBytes.slice(plugin.prefix.length);
+  if (plugin.jwtAlg === P256_JWT_ALG) {
+    keyBytes = decompressPubkey(keyBytes);
+  } else if (plugin.jwtAlg === SECP256K1_JWT_ALG) {
+    keyBytes = decompressPubkey2(keyBytes);
+  }
+  return {
+    jwtAlg: plugin.jwtAlg,
+    keyBytes
+  };
+};
+var formatDidKey = (jwtAlg, keyBytes) => {
+  const plugin = plugins_default.find((p) => p.jwtAlg === jwtAlg);
+  if (!plugin) {
+    throw new Error("Unsupported key type");
+  }
+  if (jwtAlg === P256_JWT_ALG) {
+    keyBytes = compressPubkey(keyBytes);
+  } else if (jwtAlg === SECP256K1_JWT_ALG) {
+    keyBytes = compressPubkey2(keyBytes);
+  }
+  const prefixedBytes = concat([plugin.prefix, keyBytes]);
+  return DID_KEY_BASE58_PREFIX + toString2(prefixedBytes, "base58btc");
+};
+var hasPrefix = (bytes, prefix) => {
+  return equals(prefix, bytes.subarray(0, prefix.byteLength));
+};
+
+// src/multibase.ts
+var multibaseToBytes = (mb) => {
+  const base3 = mb[0];
+  const key = mb.slice(1);
+  switch (base3) {
+    case "f":
+      return fromString2(key, "base16");
+    case "F":
+      return fromString2(key, "base16upper");
+    case "b":
+      return fromString2(key, "base32");
+    case "B":
+      return fromString2(key, "base32upper");
+    case "z":
+      return fromString2(key, "base58btc");
+    case "m":
+      return fromString2(key, "base64");
+    case "u":
+      return fromString2(key, "base64url");
+    case "U":
+      return fromString2(key, "base64urlpad");
+    default:
+      throw new Error(`Unsupported multibase: :${mb}`);
+  }
+};
+
+// 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 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/verify.ts
+var verifyDidSig3 = (did, data, sig) => {
+  const parsed = parseDidKey(did);
+  const plugin = plugins_default.find((p) => p.jwtAlg === parsed.jwtAlg);
+  if (!plugin) {
+    throw new Error(`Unsupported signature alg: :${parsed.jwtAlg}`);
+  }
+  return plugin.verifySignature(did, data, sig);
+};
+
+// src/p256/keypair.ts
+var EcdsaKeypair = class {
+  constructor(keypair, publicKey, exportable) {
+    this.jwtAlg = P256_JWT_ALG;
+    this.keypair = keypair;
+    this.publicKey = publicKey;
+    this.exportable = exportable;
+  }
+  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 { 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);
+  }
+  publicKeyBytes() {
+    return this.publicKey;
+  }
+  publicKeyStr(encoding = "base64pad") {
+    return toString2(this.publicKey, encoding);
+  }
+  did() {
+    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);
+  }
+  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;
+  }
+};
+
+// src/secp256k1/keypair.ts
+var Secp256k1Keypair = class {
+  constructor(privateKey, exportable) {
+    this.privateKey = privateKey;
+    this.exportable = exportable;
+    this.jwtAlg = SECP256K1_JWT_ALG;
+    this.publicKey = getPublicKey(privateKey);
+  }
+  static async create(opts) {
+    const { exportable = false } = opts || {};
+    const privKey = utils.randomPrivateKey();
+    return new Secp256k1Keypair(privKey, exportable);
+  }
+  static async import(privKey, opts) {
+    const { exportable = false } = opts || {};
+    const privKeyBytes = typeof privKey === "string" ? fromString2(privKey, "hex") : privKey;
+    return new Secp256k1Keypair(privKeyBytes, exportable);
+  }
+  publicKeyBytes() {
+    return this.publicKey;
+  }
+  publicKeyStr(encoding = "base64pad") {
+    return toString2(this.publicKey, encoding);
+  }
+  did() {
+    return formatDidKey(this.jwtAlg, this.publicKey);
+  }
+  async sign(msg) {
+    const msgHash = await utils.sha256(msg);
+    return sign(msgHash, this.privateKey, { der: false });
+  }
+  async export() {
+    if (!this.exportable) {
+      throw new Error("Private key is not exportable");
+    }
+    return this.privateKey;
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AesKey,
+  BASE58_DID_PREFIX,
+  DID_KEY_BASE58_PREFIX,
+  EcdsaKeypair,
+  P256_DID_PREFIX,
+  P256_JWT_ALG,
+  SECP256K1_DID_PREFIX,
+  SECP256K1_JWT_ALG,
+  Secp256k1Keypair,
+  formatDidKey,
+  multibaseToBytes,
+  p256Plugin,
+  parseDidKey,
+  randomBytes,
+  randomIV,
+  randomStr,
+  secp256k1Plugin,
+  sha256,
+  sha256Stream,
+  verifyDidSig
+});
+/*! noble-secp256k1 - MIT License (c) 2019 Paul Miller (paulmillr.com) */
+//# sourceMappingURL=index.js.map