lakutata 0.0.1

package/build/chunk-BDJXMO44.js

@@ -0,0 +1,2920 @@
+import { AsymmetricEncryption } from './chunk-BKCT2HSQ.js';
+import { As } from './chunk-XO6M5AYN.js';
+import { init_esm_shims, __export, __name } from './chunk-5NK7E2HA.js';
+
+// src/lib/crypto/SM2.ts
+init_esm_shims();
+
+// node_modules/sm-crypto-v2/dist/index.mjs
+init_esm_shims();
+
+// node_modules/@noble/curves/esm/abstract/utils.js
+var utils_exports = {};
+__export(utils_exports, {
+  bitGet: () => bitGet,
+  bitLen: () => bitLen,
+  bitMask: () => bitMask,
+  bitSet: () => bitSet,
+  bytesToHex: () => bytesToHex,
+  bytesToNumberBE: () => bytesToNumberBE,
+  bytesToNumberLE: () => bytesToNumberLE,
+  concatBytes: () => concatBytes,
+  createHmacDrbg: () => createHmacDrbg,
+  ensureBytes: () => ensureBytes,
+  equalBytes: () => equalBytes,
+  hexToBytes: () => hexToBytes,
+  hexToNumber: () => hexToNumber,
+  numberToBytesBE: () => numberToBytesBE,
+  numberToBytesLE: () => numberToBytesLE,
+  numberToHexUnpadded: () => numberToHexUnpadded,
+  numberToVarBytesBE: () => numberToVarBytesBE,
+  utf8ToBytes: () => utf8ToBytes,
+  validateObject: () => validateObject
+});
+init_esm_shims();
+var _0n = BigInt(0);
+var _1n = BigInt(1);
+var _2n = BigInt(2);
+var u8a = /* @__PURE__ */ __name((a) => a instanceof Uint8Array, "u8a");
+var hexes = Array.from({ length: 256 }, (v, i) => i.toString(16).padStart(2, "0"));
+function bytesToHex(bytes) {
+  if (!u8a(bytes))
+    throw new Error("Uint8Array expected");
+  let hex = "";
+  for (let i = 0; i < bytes.length; i++) {
+    hex += hexes[bytes[i]];
+  }
+  return hex;
+}
+__name(bytesToHex, "bytesToHex");
+function numberToHexUnpadded(num) {
+  const hex = num.toString(16);
+  return hex.length & 1 ? `0${hex}` : hex;
+}
+__name(numberToHexUnpadded, "numberToHexUnpadded");
+function hexToNumber(hex) {
+  if (typeof hex !== "string")
+    throw new Error("hex string expected, got " + typeof hex);
+  return BigInt(hex === "" ? "0" : `0x${hex}`);
+}
+__name(hexToNumber, "hexToNumber");
+function hexToBytes(hex) {
+  if (typeof hex !== "string")
+    throw new Error("hex string expected, got " + typeof hex);
+  const len = hex.length;
+  if (len % 2)
+    throw new Error("padded hex string expected, got unpadded hex of length " + len);
+  const array = new Uint8Array(len / 2);
+  for (let i = 0; i < array.length; i++) {
+    const j = i * 2;
+    const hexByte = hex.slice(j, j + 2);
+    const byte = Number.parseInt(hexByte, 16);
+    if (Number.isNaN(byte) || byte < 0)
+      throw new Error("Invalid byte sequence");
+    array[i] = byte;
+  }
+  return array;
+}
+__name(hexToBytes, "hexToBytes");
+function bytesToNumberBE(bytes) {
+  return hexToNumber(bytesToHex(bytes));
+}
+__name(bytesToNumberBE, "bytesToNumberBE");
+function bytesToNumberLE(bytes) {
+  if (!u8a(bytes))
+    throw new Error("Uint8Array expected");
+  return hexToNumber(bytesToHex(Uint8Array.from(bytes).reverse()));
+}
+__name(bytesToNumberLE, "bytesToNumberLE");
+function numberToBytesBE(n, len) {
+  return hexToBytes(n.toString(16).padStart(len * 2, "0"));
+}
+__name(numberToBytesBE, "numberToBytesBE");
+function numberToBytesLE(n, len) {
+  return numberToBytesBE(n, len).reverse();
+}
+__name(numberToBytesLE, "numberToBytesLE");
+function numberToVarBytesBE(n) {
+  return hexToBytes(numberToHexUnpadded(n));
+}
+__name(numberToVarBytesBE, "numberToVarBytesBE");
+function ensureBytes(title, hex, expectedLength) {
+  let res;
+  if (typeof hex === "string") {
+    try {
+      res = hexToBytes(hex);
+    } catch (e) {
+      throw new Error(`${title} must be valid hex string, got "${hex}". Cause: ${e}`);
+    }
+  } else if (u8a(hex)) {
+    res = Uint8Array.from(hex);
+  } else {
+    throw new Error(`${title} must be hex string or Uint8Array`);
+  }
+  const len = res.length;
+  if (typeof expectedLength === "number" && len !== expectedLength)
+    throw new Error(`${title} expected ${expectedLength} bytes, got ${len}`);
+  return res;
+}
+__name(ensureBytes, "ensureBytes");
+function concatBytes(...arrays) {
+  const r = new Uint8Array(arrays.reduce((sum, a) => sum + a.length, 0));
+  let pad = 0;
+  arrays.forEach((a) => {
+    if (!u8a(a))
+      throw new Error("Uint8Array expected");
+    r.set(a, pad);
+    pad += a.length;
+  });
+  return r;
+}
+__name(concatBytes, "concatBytes");
+function equalBytes(b1, b2) {
+  if (b1.length !== b2.length)
+    return false;
+  for (let i = 0; i < b1.length; i++)
+    if (b1[i] !== b2[i])
+      return false;
+  return true;
+}
+__name(equalBytes, "equalBytes");
+function utf8ToBytes(str) {
+  if (typeof str !== "string")
+    throw new Error(`utf8ToBytes expected string, got ${typeof str}`);
+  return new Uint8Array(new TextEncoder().encode(str));
+}
+__name(utf8ToBytes, "utf8ToBytes");
+function bitLen(n) {
+  let len;
+  for (len = 0; n > _0n; n >>= _1n, len += 1)
+    ;
+  return len;
+}
+__name(bitLen, "bitLen");
+function bitGet(n, pos) {
+  return n >> BigInt(pos) & _1n;
+}
+__name(bitGet, "bitGet");
+var bitSet = /* @__PURE__ */ __name((n, pos, value) => {
+  return n | (value ? _1n : _0n) << BigInt(pos);
+}, "bitSet");
+var bitMask = /* @__PURE__ */ __name((n) => (_2n << BigInt(n - 1)) - _1n, "bitMask");
+var u8n = /* @__PURE__ */ __name((data) => new Uint8Array(data), "u8n");
+var u8fr = /* @__PURE__ */ __name((arr) => Uint8Array.from(arr), "u8fr");
+function createHmacDrbg(hashLen, qByteLen, hmacFn) {
+  if (typeof hashLen !== "number" || hashLen < 2)
+    throw new Error("hashLen must be a number");
+  if (typeof qByteLen !== "number" || qByteLen < 2)
+    throw new Error("qByteLen must be a number");
+  if (typeof hmacFn !== "function")
+    throw new Error("hmacFn must be a function");
+  let v = u8n(hashLen);
+  let k = u8n(hashLen);
+  let i = 0;
+  const reset = /* @__PURE__ */ __name(() => {
+    v.fill(1);
+    k.fill(0);
+    i = 0;
+  }, "reset");
+  const h = /* @__PURE__ */ __name((...b) => hmacFn(k, v, ...b), "h");
+  const reseed = /* @__PURE__ */ __name((seed = u8n()) => {
+    k = h(u8fr([0]), seed);
+    v = h();
+    if (seed.length === 0)
+      return;
+    k = h(u8fr([1]), seed);
+    v = h();
+  }, "reseed");
+  const gen = /* @__PURE__ */ __name(() => {
+    if (i++ >= 1e3)
+      throw new Error("drbg: tried 1000 values");
+    let len = 0;
+    const out = [];
+    while (len < qByteLen) {
+      v = h();
+      const sl = v.slice();
+      out.push(sl);
+      len += v.length;
+    }
+    return concatBytes(...out);
+  }, "gen");
+  const genUntil = /* @__PURE__ */ __name((seed, pred) => {
+    reset();
+    reseed(seed);
+    let res = void 0;
+    while (!(res = pred(gen())))
+      reseed();
+    reset();
+    return res;
+  }, "genUntil");
+  return genUntil;
+}
+__name(createHmacDrbg, "createHmacDrbg");
+var validatorFns = {
+  bigint: (val) => typeof val === "bigint",
+  function: (val) => typeof val === "function",
+  boolean: (val) => typeof val === "boolean",
+  string: (val) => typeof val === "string",
+  isSafeInteger: (val) => Number.isSafeInteger(val),
+  array: (val) => Array.isArray(val),
+  field: (val, object) => object.Fp.isValid(val),
+  hash: (val) => typeof val === "function" && Number.isSafeInteger(val.outputLen)
+};
+function validateObject(object, validators, optValidators = {}) {
+  const checkField = /* @__PURE__ */ __name((fieldName, type, isOptional) => {
+    const checkVal = validatorFns[type];
+    if (typeof checkVal !== "function")
+      throw new Error(`Invalid validator "${type}", expected function`);
+    const val = object[fieldName];
+    if (isOptional && val === void 0)
+      return;
+    if (!checkVal(val, object)) {
+      throw new Error(`Invalid param ${String(fieldName)}=${val} (${typeof val}), expected ${type}`);
+    }
+  }, "checkField");
+  for (const [fieldName, type] of Object.entries(validators))
+    checkField(fieldName, type, false);
+  for (const [fieldName, type] of Object.entries(optValidators))
+    checkField(fieldName, type, true);
+  return object;
+}
+__name(validateObject, "validateObject");
+
+// node_modules/@noble/curves/esm/abstract/weierstrass.js
+init_esm_shims();
+
+// node_modules/@noble/curves/esm/abstract/modular.js
+init_esm_shims();
+var _0n2 = BigInt(0);
+var _1n2 = BigInt(1);
+var _2n2 = BigInt(2);
+var _3n = BigInt(3);
+var _4n = BigInt(4);
+var _5n = BigInt(5);
+var _8n = BigInt(8);
+BigInt(9);
+BigInt(16);
+function mod(a, b) {
+  const result = a % b;
+  return result >= _0n2 ? result : b + result;
+}
+__name(mod, "mod");
+function pow(num, power, modulo) {
+  if (modulo <= _0n2 || power < _0n2)
+    throw new Error("Expected power/modulo > 0");
+  if (modulo === _1n2)
+    return _0n2;
+  let res = _1n2;
+  while (power > _0n2) {
+    if (power & _1n2)
+      res = res * num % modulo;
+    num = num * num % modulo;
+    power >>= _1n2;
+  }
+  return res;
+}
+__name(pow, "pow");
+function invert(number, modulo) {
+  if (number === _0n2 || modulo <= _0n2) {
+    throw new Error(`invert: expected positive integers, got n=${number} mod=${modulo}`);
+  }
+  let a = mod(number, modulo);
+  let b = modulo;
+  let x2 = _0n2, u = _1n2;
+  while (a !== _0n2) {
+    const q = b / a;
+    const r = b % a;
+    const m = x2 - u * q;
+    b = a, a = r, x2 = u, u = m;
+  }
+  const gcd = b;
+  if (gcd !== _1n2)
+    throw new Error("invert: does not exist");
+  return mod(x2, modulo);
+}
+__name(invert, "invert");
+function tonelliShanks(P) {
+  const legendreC = (P - _1n2) / _2n2;
+  let Q, S, Z;
+  for (Q = P - _1n2, S = 0; Q % _2n2 === _0n2; Q /= _2n2, S++)
+    ;
+  for (Z = _2n2; Z < P && pow(Z, legendreC, P) !== P - _1n2; Z++)
+    ;
+  if (S === 1) {
+    const p1div4 = (P + _1n2) / _4n;
+    return /* @__PURE__ */ __name(function tonelliFast(Fp, n) {
+      const root = Fp.pow(n, p1div4);
+      if (!Fp.eql(Fp.sqr(root), n))
+        throw new Error("Cannot find square root");
+      return root;
+    }, "tonelliFast");
+  }
+  const Q1div2 = (Q + _1n2) / _2n2;
+  return /* @__PURE__ */ __name(function tonelliSlow(Fp, n) {
+    if (Fp.pow(n, legendreC) === Fp.neg(Fp.ONE))
+      throw new Error("Cannot find square root");
+    let r = S;
+    let g = Fp.pow(Fp.mul(Fp.ONE, Z), Q);
+    let x2 = Fp.pow(n, Q1div2);
+    let b = Fp.pow(n, Q);
+    while (!Fp.eql(b, Fp.ONE)) {
+      if (Fp.eql(b, Fp.ZERO))
+        return Fp.ZERO;
+      let m = 1;
+      for (let t2 = Fp.sqr(b); m < r; m++) {
+        if (Fp.eql(t2, Fp.ONE))
+          break;
+        t2 = Fp.sqr(t2);
+      }
+      const ge = Fp.pow(g, _1n2 << BigInt(r - m - 1));
+      g = Fp.sqr(ge);
+      x2 = Fp.mul(x2, ge);
+      b = Fp.mul(b, g);
+      r = m;
+    }
+    return x2;
+  }, "tonelliSlow");
+}
+__name(tonelliShanks, "tonelliShanks");
+function FpSqrt(P) {
+  if (P % _4n === _3n) {
+    const p1div4 = (P + _1n2) / _4n;
+    return /* @__PURE__ */ __name(function sqrt3mod4(Fp, n) {
+      const root = Fp.pow(n, p1div4);
+      if (!Fp.eql(Fp.sqr(root), n))
+        throw new Error("Cannot find square root");
+      return root;
+    }, "sqrt3mod4");
+  }
+  if (P % _8n === _5n) {
+    const c1 = (P - _5n) / _8n;
+    return /* @__PURE__ */ __name(function sqrt5mod8(Fp, n) {
+      const n2 = Fp.mul(n, _2n2);
+      const v = Fp.pow(n2, c1);
+      const nv = Fp.mul(n, v);
+      const i = Fp.mul(Fp.mul(nv, _2n2), v);
+      const root = Fp.mul(nv, Fp.sub(i, Fp.ONE));
+      if (!Fp.eql(Fp.sqr(root), n))
+        throw new Error("Cannot find square root");
+      return root;
+    }, "sqrt5mod8");
+  }
+  return tonelliShanks(P);
+}
+__name(FpSqrt, "FpSqrt");
+var FIELD_FIELDS = [
+  "create",
+  "isValid",
+  "is0",
+  "neg",
+  "inv",
+  "sqrt",
+  "sqr",
+  "eql",
+  "add",
+  "sub",
+  "mul",
+  "pow",
+  "div",
+  "addN",
+  "subN",
+  "mulN",
+  "sqrN"
+];
+function validateField(field2) {
+  const initial = {
+    ORDER: "bigint",
+    MASK: "bigint",
+    BYTES: "isSafeInteger",
+    BITS: "isSafeInteger"
+  };
+  const opts = FIELD_FIELDS.reduce((map, val) => {
+    map[val] = "function";
+    return map;
+  }, initial);
+  return validateObject(field2, opts);
+}
+__name(validateField, "validateField");
+function FpPow(f, num, power) {
+  if (power < _0n2)
+    throw new Error("Expected power > 0");
+  if (power === _0n2)
+    return f.ONE;
+  if (power === _1n2)
+    return num;
+  let p = f.ONE;
+  let d = num;
+  while (power > _0n2) {
+    if (power & _1n2)
+      p = f.mul(p, d);
+    d = f.sqr(d);
+    power >>= _1n2;
+  }
+  return p;
+}
+__name(FpPow, "FpPow");
+function FpInvertBatch(f, nums) {
+  const tmp2 = new Array(nums.length);
+  const lastMultiplied = nums.reduce((acc, num, i) => {
+    if (f.is0(num))
+      return acc;
+    tmp2[i] = acc;
+    return f.mul(acc, num);
+  }, f.ONE);
+  const inverted = f.inv(lastMultiplied);
+  nums.reduceRight((acc, num, i) => {
+    if (f.is0(num))
+      return acc;
+    tmp2[i] = f.mul(acc, tmp2[i]);
+    return f.mul(acc, num);
+  }, inverted);
+  return tmp2;
+}
+__name(FpInvertBatch, "FpInvertBatch");
+function nLength(n, nBitLength) {
+  const _nBitLength = nBitLength !== void 0 ? nBitLength : n.toString(2).length;
+  const nByteLength = Math.ceil(_nBitLength / 8);
+  return { nBitLength: _nBitLength, nByteLength };
+}
+__name(nLength, "nLength");
+function Field(ORDER, bitLen2, isLE2 = false, redef = {}) {
+  if (ORDER <= _0n2)
+    throw new Error(`Expected Fp ORDER > 0, got ${ORDER}`);
+  const { nBitLength: BITS, nByteLength: BYTES } = nLength(ORDER, bitLen2);
+  if (BYTES > 2048)
+    throw new Error("Field lengths over 2048 bytes are not supported");
+  const sqrtP = FpSqrt(ORDER);
+  const f = Object.freeze({
+    ORDER,
+    BITS,
+    BYTES,
+    MASK: bitMask(BITS),
+    ZERO: _0n2,
+    ONE: _1n2,
+    create: (num) => mod(num, ORDER),
+    isValid: (num) => {
+      if (typeof num !== "bigint")
+        throw new Error(`Invalid field element: expected bigint, got ${typeof num}`);
+      return _0n2 <= num && num < ORDER;
+    },
+    is0: (num) => num === _0n2,
+    isOdd: (num) => (num & _1n2) === _1n2,
+    neg: (num) => mod(-num, ORDER),
+    eql: (lhs, rhs) => lhs === rhs,
+    sqr: (num) => mod(num * num, ORDER),
+    add: (lhs, rhs) => mod(lhs + rhs, ORDER),
+    sub: (lhs, rhs) => mod(lhs - rhs, ORDER),
+    mul: (lhs, rhs) => mod(lhs * rhs, ORDER),
+    pow: (num, power) => FpPow(f, num, power),
+    div: (lhs, rhs) => mod(lhs * invert(rhs, ORDER), ORDER),
+    // Same as above, but doesn't normalize
+    sqrN: (num) => num * num,
+    addN: (lhs, rhs) => lhs + rhs,
+    subN: (lhs, rhs) => lhs - rhs,
+    mulN: (lhs, rhs) => lhs * rhs,
+    inv: (num) => invert(num, ORDER),
+    sqrt: redef.sqrt || ((n) => sqrtP(f, n)),
+    invertBatch: (lst) => FpInvertBatch(f, lst),
+    // TODO: do we really need constant cmov?
+    // We don't have const-time bigints anyway, so probably will be not very useful
+    cmov: (a, b, c) => c ? b : a,
+    toBytes: (num) => isLE2 ? numberToBytesLE(num, BYTES) : numberToBytesBE(num, BYTES),
+    fromBytes: (bytes) => {
+      if (bytes.length !== BYTES)
+        throw new Error(`Fp.fromBytes: expected ${BYTES}, got ${bytes.length}`);
+      return isLE2 ? bytesToNumberLE(bytes) : bytesToNumberBE(bytes);
+    }
+  });
+  return Object.freeze(f);
+}
+__name(Field, "Field");
+function hashToPrivateScalar(hash, groupOrder, isLE2 = false) {
+  hash = ensureBytes("privateHash", hash);
+  const hashLen = hash.length;
+  const minLen = nLength(groupOrder).nByteLength + 8;
+  if (minLen < 24 || hashLen < minLen || hashLen > 1024)
+    throw new Error(`hashToPrivateScalar: expected ${minLen}-1024 bytes of input, got ${hashLen}`);
+  const num = isLE2 ? bytesToNumberLE(hash) : bytesToNumberBE(hash);
+  return mod(num, groupOrder - _1n2) + _1n2;
+}
+__name(hashToPrivateScalar, "hashToPrivateScalar");
+
+// node_modules/@noble/curves/esm/abstract/curve.js
+init_esm_shims();
+var _0n3 = BigInt(0);
+var _1n3 = BigInt(1);
+function wNAF(c, bits) {
+  const constTimeNegate = /* @__PURE__ */ __name((condition, item) => {
+    const neg = item.negate();
+    return condition ? neg : item;
+  }, "constTimeNegate");
+  const opts = /* @__PURE__ */ __name((W) => {
+    const windows = Math.ceil(bits / W) + 1;
+    const windowSize = 2 ** (W - 1);
+    return { windows, windowSize };
+  }, "opts");
+  return {
+    constTimeNegate,
+    // non-const time multiplication ladder
+    unsafeLadder(elm, n) {
+      let p = c.ZERO;
+      let d = elm;
+      while (n > _0n3) {
+        if (n & _1n3)
+          p = p.add(d);
+        d = d.double();
+        n >>= _1n3;
+      }
+      return p;
+    },
+    /**
+     * Creates a wNAF precomputation window. Used for caching.
+     * Default window size is set by `utils.precompute()` and is equal to 8.
+     * Number of precomputed points depends on the curve size:
+     * 2^(𝑊−1) * (Math.ceil(𝑛 / 𝑊) + 1), where:
+     * - 𝑊 is the window size
+     * - 𝑛 is the bitlength of the curve order.
+     * For a 256-bit curve and window size 8, the number of precomputed points is 128 * 33 = 4224.
+     * @returns precomputed point tables flattened to a single array
+     */
+    precomputeWindow(elm, W) {
+      const { windows, windowSize } = opts(W);
+      const points = [];
+      let p = elm;
+      let base = p;
+      for (let window = 0; window < windows; window++) {
+        base = p;
+        points.push(base);
+        for (let i = 1; i < windowSize; i++) {
+          base = base.add(p);
+          points.push(base);
+        }
+        p = base.double();
+      }
+      return points;
+    },
+    /**
+     * Implements ec multiplication using precomputed tables and w-ary non-adjacent form.
+     * @param W window size
+     * @param precomputes precomputed tables
+     * @param n scalar (we don't check here, but should be less than curve order)
+     * @returns real and fake (for const-time) points
+     */
+    wNAF(W, precomputes, n) {
+      const { windows, windowSize } = opts(W);
+      let p = c.ZERO;
+      let f = c.BASE;
+      const mask = BigInt(2 ** W - 1);
+      const maxNumber = 2 ** W;
+      const shiftBy = BigInt(W);
+      for (let window = 0; window < windows; window++) {
+        const offset = window * windowSize;
+        let wbits = Number(n & mask);
+        n >>= shiftBy;
+        if (wbits > windowSize) {
+          wbits -= maxNumber;
+          n += _1n3;
+        }
+        const offset1 = offset;
+        const offset2 = offset + Math.abs(wbits) - 1;
+        const cond1 = window % 2 !== 0;
+        const cond2 = wbits < 0;
+        if (wbits === 0) {
+          f = f.add(constTimeNegate(cond1, precomputes[offset1]));
+        } else {
+          p = p.add(constTimeNegate(cond2, precomputes[offset2]));
+        }
+      }
+      return { p, f };
+    },
+    wNAFCached(P, precomputesMap, n, transform) {
+      const W = P._WINDOW_SIZE || 1;
+      let comp = precomputesMap.get(P);
+      if (!comp) {
+        comp = this.precomputeWindow(P, W);
+        if (W !== 1) {
+          precomputesMap.set(P, transform(comp));
+        }
+      }
+      return this.wNAF(W, comp, n);
+    }
+  };
+}
+__name(wNAF, "wNAF");
+function validateBasic(curve) {
+  validateField(curve.Fp);
+  validateObject(curve, {
+    n: "bigint",
+    h: "bigint",
+    Gx: "field",
+    Gy: "field"
+  }, {
+    nBitLength: "isSafeInteger",
+    nByteLength: "isSafeInteger"
+  });
+  return Object.freeze({
+    ...nLength(curve.n, curve.nBitLength),
+    ...curve,
+    ...{ p: curve.Fp.ORDER }
+  });
+}
+__name(validateBasic, "validateBasic");
+
+// node_modules/@noble/curves/esm/abstract/weierstrass.js
+function validatePointOpts(curve) {
+  const opts = validateBasic(curve);
+  validateObject(opts, {
+    a: "field",
+    b: "field"
+  }, {
+    allowedPrivateKeyLengths: "array",
+    wrapPrivateKey: "boolean",
+    isTorsionFree: "function",
+    clearCofactor: "function",
+    allowInfinityPoint: "boolean",
+    fromBytes: "function",
+    toBytes: "function"
+  });
+  const { endo, Fp, a } = opts;
+  if (endo) {
+    if (!Fp.eql(a, Fp.ZERO)) {
+      throw new Error("Endomorphism can only be defined for Koblitz curves that have a=0");
+    }
+    if (typeof endo !== "object" || typeof endo.beta !== "bigint" || typeof endo.splitScalar !== "function") {
+      throw new Error("Expected endomorphism with beta: bigint and splitScalar: function");
+    }
+  }
+  return Object.freeze({ ...opts });
+}
+__name(validatePointOpts, "validatePointOpts");
+var { bytesToNumberBE: b2n, hexToBytes: h2b } = utils_exports;
+var _a;
+var DER = {
+  // asn.1 DER encoding utils
+  Err: (_a = class extends Error {
+    constructor(m = "") {
+      super(m);
+    }
+  }, __name(_a, "DERErr"), _a),
+  _parseInt(data) {
+    const { Err: E } = DER;
+    if (data.length < 2 || data[0] !== 2)
+      throw new E("Invalid signature integer tag");
+    const len = data[1];
+    const res = data.subarray(2, len + 2);
+    if (!len || res.length !== len)
+      throw new E("Invalid signature integer: wrong length");
+    if (res[0] & 128)
+      throw new E("Invalid signature integer: negative");
+    if (res[0] === 0 && !(res[1] & 128))
+      throw new E("Invalid signature integer: unnecessary leading zero");
+    return { d: b2n(res), l: data.subarray(len + 2) };
+  },
+  toSig(hex) {
+    const { Err: E } = DER;
+    const data = typeof hex === "string" ? h2b(hex) : hex;
+    if (!(data instanceof Uint8Array))
+      throw new Error("ui8a expected");
+    let l = data.length;
+    if (l < 2 || data[0] != 48)
+      throw new E("Invalid signature tag");
+    if (data[1] !== l - 2)
+      throw new E("Invalid signature: incorrect length");
+    const { d: r, l: sBytes } = DER._parseInt(data.subarray(2));
+    const { d: s, l: rBytesLeft } = DER._parseInt(sBytes);
+    if (rBytesLeft.length)
+      throw new E("Invalid signature: left bytes after parsing");
+    return { r, s };
+  },
+  hexFromSig(sig) {
+    const slice = /* @__PURE__ */ __name((s2) => Number.parseInt(s2[0], 16) & 8 ? "00" + s2 : s2, "slice");
+    const h = /* @__PURE__ */ __name((num) => {
+      const hex = num.toString(16);
+      return hex.length & 1 ? `0${hex}` : hex;
+    }, "h");
+    const s = slice(h(sig.s));
+    const r = slice(h(sig.r));
+    const shl = s.length / 2;
+    const rhl = r.length / 2;
+    const sl = h(shl);
+    const rl = h(rhl);
+    return `30${h(rhl + shl + 4)}02${rl}${r}02${sl}${s}`;
+  }
+};
+var _0n4 = BigInt(0);
+var _1n4 = BigInt(1);
+BigInt(2);
+var _3n2 = BigInt(3);
+BigInt(4);
+function weierstrassPoints(opts) {
+  const CURVE = validatePointOpts(opts);
+  const { Fp } = CURVE;
+  const toBytes2 = CURVE.toBytes || ((c, point, isCompressed) => {
+    const a = point.toAffine();
+    return concatBytes(Uint8Array.from([4]), Fp.toBytes(a.x), Fp.toBytes(a.y));
+  });
+  const fromBytes = CURVE.fromBytes || ((bytes) => {
+    const tail = bytes.subarray(1);
+    const x2 = Fp.fromBytes(tail.subarray(0, Fp.BYTES));
+    const y = Fp.fromBytes(tail.subarray(Fp.BYTES, 2 * Fp.BYTES));
+    return { x: x2, y };
+  });
+  function weierstrassEquation(x2) {
+    const { a, b } = CURVE;
+    const x22 = Fp.sqr(x2);
+    const x3 = Fp.mul(x22, x2);
+    return Fp.add(Fp.add(x3, Fp.mul(x2, a)), b);
+  }
+  __name(weierstrassEquation, "weierstrassEquation");
+  if (!Fp.eql(Fp.sqr(CURVE.Gy), weierstrassEquation(CURVE.Gx)))
+    throw new Error("bad generator point: equation left != right");
+  function isWithinCurveOrder(num) {
+    return typeof num === "bigint" && _0n4 < num && num < CURVE.n;
+  }
+  __name(isWithinCurveOrder, "isWithinCurveOrder");
+  function assertGE(num) {
+    if (!isWithinCurveOrder(num))
+      throw new Error("Expected valid bigint: 0 < bigint < curve.n");
+  }
+  __name(assertGE, "assertGE");
+  function normPrivateKeyToScalar(key) {
+    const { allowedPrivateKeyLengths: lengths, nByteLength, wrapPrivateKey, n } = CURVE;
+    if (lengths && typeof key !== "bigint") {
+      if (key instanceof Uint8Array)
+        key = bytesToHex(key);
+      if (typeof key !== "string" || !lengths.includes(key.length))
+        throw new Error("Invalid key");
+      key = key.padStart(nByteLength * 2, "0");
+    }
+    let num;
+    try {
+      num = typeof key === "bigint" ? key : bytesToNumberBE(ensureBytes("private key", key, nByteLength));
+    } catch (error) {
+      throw new Error(`private key must be ${nByteLength} bytes, hex or bigint, not ${typeof key}`);
+    }
+    if (wrapPrivateKey)
+      num = mod(num, n);
+    assertGE(num);
+    return num;
+  }
+  __name(normPrivateKeyToScalar, "normPrivateKeyToScalar");
+  const pointPrecomputes = /* @__PURE__ */ new Map();
+  function assertPrjPoint(other) {
+    if (!(other instanceof Point))
+      throw new Error("ProjectivePoint expected");
+  }
+  __name(assertPrjPoint, "assertPrjPoint");
+  const _Point = class _Point {
+    constructor(px, py, pz) {
+      this.px = px;
+      this.py = py;
+      this.pz = pz;
+      if (px == null || !Fp.isValid(px))
+        throw new Error("x required");
+      if (py == null || !Fp.isValid(py))
+        throw new Error("y required");
+      if (pz == null || !Fp.isValid(pz))
+        throw new Error("z required");
+    }
+    // Does not validate if the point is on-curve.
+    // Use fromHex instead, or call assertValidity() later.
+    static fromAffine(p) {
+      const { x: x2, y } = p || {};
+      if (!p || !Fp.isValid(x2) || !Fp.isValid(y))
+        throw new Error("invalid affine point");
+      if (p instanceof _Point)
+        throw new Error("projective point not allowed");
+      const is0 = /* @__PURE__ */ __name((i) => Fp.eql(i, Fp.ZERO), "is0");
+      if (is0(x2) && is0(y))
+        return _Point.ZERO;
+      return new _Point(x2, y, Fp.ONE);
+    }
+    get x() {
+      return this.toAffine().x;
+    }
+    get y() {
+      return this.toAffine().y;
+    }
+    /**
+     * Takes a bunch of Projective Points but executes only one
+     * inversion on all of them. Inversion is very slow operation,
+     * so this improves performance massively.
+     * Optimization: converts a list of projective points to a list of identical points with Z=1.
+     */
+    static normalizeZ(points) {
+      const toInv = Fp.invertBatch(points.map((p) => p.pz));
+      return points.map((p, i) => p.toAffine(toInv[i])).map(_Point.fromAffine);
+    }
+    /**
+     * Converts hash string or Uint8Array to Point.
+     * @param hex short/long ECDSA hex
+     */
+    static fromHex(hex) {
+      const P = _Point.fromAffine(fromBytes(ensureBytes("pointHex", hex)));
+      P.assertValidity();
+      return P;
+    }
+    // Multiplies generator point by privateKey.
+    static fromPrivateKey(privateKey) {
+      return _Point.BASE.multiply(normPrivateKeyToScalar(privateKey));
+    }
+    // "Private method", don't use it directly
+    _setWindowSize(windowSize) {
+      this._WINDOW_SIZE = windowSize;
+      pointPrecomputes.delete(this);
+    }
+    // A point on curve is valid if it conforms to equation.
+    assertValidity() {
+      if (this.is0()) {
+        if (CURVE.allowInfinityPoint)
+          return;
+        throw new Error("bad point: ZERO");
+      }
+      const { x: x2, y } = this.toAffine();
+      if (!Fp.isValid(x2) || !Fp.isValid(y))
+        throw new Error("bad point: x or y not FE");
+      const left = Fp.sqr(y);
+      const right = weierstrassEquation(x2);
+      if (!Fp.eql(left, right))
+        throw new Error("bad point: equation left != right");
+      if (!this.isTorsionFree())
+        throw new Error("bad point: not in prime-order subgroup");
+    }
+    hasEvenY() {
+      const { y } = this.toAffine();
+      if (Fp.isOdd)
+        return !Fp.isOdd(y);
+      throw new Error("Field doesn't support isOdd");
+    }
+    /**
+     * Compare one point to another.
+     */
+    equals(other) {
+      assertPrjPoint(other);
+      const { px: X1, py: Y1, pz: Z1 } = this;
+      const { px: X2, py: Y2, pz: Z2 } = other;
+      const U1 = Fp.eql(Fp.mul(X1, Z2), Fp.mul(X2, Z1));
+      const U2 = Fp.eql(Fp.mul(Y1, Z2), Fp.mul(Y2, Z1));
+      return U1 && U2;
+    }
+    /**
+     * Flips point to one corresponding to (x, -y) in Affine coordinates.
+     */
+    negate() {
+      return new _Point(this.px, Fp.neg(this.py), this.pz);
+    }
+    // Renes-Costello-Batina exception-free doubling formula.
+    // There is 30% faster Jacobian formula, but it is not complete.
+    // https://eprint.iacr.org/2015/1060, algorithm 3
+    // Cost: 8M + 3S + 3*a + 2*b3 + 15add.
+    double() {
+      const { a, b } = CURVE;
+      const b3 = Fp.mul(b, _3n2);
+      const { px: X1, py: Y1, pz: Z1 } = this;
+      let X3 = Fp.ZERO, Y3 = Fp.ZERO, Z3 = Fp.ZERO;
+      let t0 = Fp.mul(X1, X1);
+      let t1 = Fp.mul(Y1, Y1);
+      let t2 = Fp.mul(Z1, Z1);
+      let t3 = Fp.mul(X1, Y1);
+      t3 = Fp.add(t3, t3);
+      Z3 = Fp.mul(X1, Z1);
+      Z3 = Fp.add(Z3, Z3);
+      X3 = Fp.mul(a, Z3);
+      Y3 = Fp.mul(b3, t2);
+      Y3 = Fp.add(X3, Y3);
+      X3 = Fp.sub(t1, Y3);
+      Y3 = Fp.add(t1, Y3);
+      Y3 = Fp.mul(X3, Y3);
+      X3 = Fp.mul(t3, X3);
+      Z3 = Fp.mul(b3, Z3);
+      t2 = Fp.mul(a, t2);
+      t3 = Fp.sub(t0, t2);
+      t3 = Fp.mul(a, t3);
+      t3 = Fp.add(t3, Z3);
+      Z3 = Fp.add(t0, t0);
+      t0 = Fp.add(Z3, t0);
+      t0 = Fp.add(t0, t2);
+      t0 = Fp.mul(t0, t3);
+      Y3 = Fp.add(Y3, t0);
+      t2 = Fp.mul(Y1, Z1);
+      t2 = Fp.add(t2, t2);
+      t0 = Fp.mul(t2, t3);
+      X3 = Fp.sub(X3, t0);
+      Z3 = Fp.mul(t2, t1);
+      Z3 = Fp.add(Z3, Z3);
+      Z3 = Fp.add(Z3, Z3);
+      return new _Point(X3, Y3, Z3);
+    }
+    // Renes-Costello-Batina exception-free addition formula.
+    // There is 30% faster Jacobian formula, but it is not complete.
+    // https://eprint.iacr.org/2015/1060, algorithm 1
+    // Cost: 12M + 0S + 3*a + 3*b3 + 23add.
+    add(other) {
+      assertPrjPoint(other);
+      const { px: X1, py: Y1, pz: Z1 } = this;
+      const { px: X2, py: Y2, pz: Z2 } = other;
+      let X3 = Fp.ZERO, Y3 = Fp.ZERO, Z3 = Fp.ZERO;
+      const a = CURVE.a;
+      const b3 = Fp.mul(CURVE.b, _3n2);
+      let t0 = Fp.mul(X1, X2);
+      let t1 = Fp.mul(Y1, Y2);
+      let t2 = Fp.mul(Z1, Z2);
+      let t3 = Fp.add(X1, Y1);
+      let t4 = Fp.add(X2, Y2);
+      t3 = Fp.mul(t3, t4);
+      t4 = Fp.add(t0, t1);
+      t3 = Fp.sub(t3, t4);
+      t4 = Fp.add(X1, Z1);
+      let t5 = Fp.add(X2, Z2);
+      t4 = Fp.mul(t4, t5);
+      t5 = Fp.add(t0, t2);
+      t4 = Fp.sub(t4, t5);
+      t5 = Fp.add(Y1, Z1);
+      X3 = Fp.add(Y2, Z2);
+      t5 = Fp.mul(t5, X3);
+      X3 = Fp.add(t1, t2);
+      t5 = Fp.sub(t5, X3);
+      Z3 = Fp.mul(a, t4);
+      X3 = Fp.mul(b3, t2);
+      Z3 = Fp.add(X3, Z3);
+      X3 = Fp.sub(t1, Z3);
+      Z3 = Fp.add(t1, Z3);
+      Y3 = Fp.mul(X3, Z3);
+      t1 = Fp.add(t0, t0);
+      t1 = Fp.add(t1, t0);
+      t2 = Fp.mul(a, t2);
+      t4 = Fp.mul(b3, t4);
+      t1 = Fp.add(t1, t2);
+      t2 = Fp.sub(t0, t2);
+      t2 = Fp.mul(a, t2);
+      t4 = Fp.add(t4, t2);
+      t0 = Fp.mul(t1, t4);
+      Y3 = Fp.add(Y3, t0);
+      t0 = Fp.mul(t5, t4);
+      X3 = Fp.mul(t3, X3);
+      X3 = Fp.sub(X3, t0);
+      t0 = Fp.mul(t3, t1);
+      Z3 = Fp.mul(t5, Z3);
+      Z3 = Fp.add(Z3, t0);
+      return new _Point(X3, Y3, Z3);
+    }
+    subtract(other) {
+      return this.add(other.negate());
+    }
+    is0() {
+      return this.equals(_Point.ZERO);
+    }
+    wNAF(n) {
+      return wnaf.wNAFCached(this, pointPrecomputes, n, (comp) => {
+        const toInv = Fp.invertBatch(comp.map((p) => p.pz));
+        return comp.map((p, i) => p.toAffine(toInv[i])).map(_Point.fromAffine);
+      });
+    }
+    /**
+     * Non-constant-time multiplication. Uses double-and-add algorithm.
+     * It's faster, but should only be used when you don't care about
+     * an exposed private key e.g. sig verification, which works over *public* keys.
+     */
+    multiplyUnsafe(n) {
+      const I = _Point.ZERO;
+      if (n === _0n4)
+        return I;
+      assertGE(n);
+      if (n === _1n4)
+        return this;
+      const { endo } = CURVE;
+      if (!endo)
+        return wnaf.unsafeLadder(this, n);
+      let { k1neg, k1, k2neg, k2 } = endo.splitScalar(n);
+      let k1p = I;
+      let k2p = I;
+      let d = this;
+      while (k1 > _0n4 || k2 > _0n4) {
+        if (k1 & _1n4)
+          k1p = k1p.add(d);
+        if (k2 & _1n4)
+          k2p = k2p.add(d);
+        d = d.double();
+        k1 >>= _1n4;
+        k2 >>= _1n4;
+      }
+      if (k1neg)
+        k1p = k1p.negate();
+      if (k2neg)
+        k2p = k2p.negate();
+      k2p = new _Point(Fp.mul(k2p.px, endo.beta), k2p.py, k2p.pz);
+      return k1p.add(k2p);
+    }
+    /**
+     * Constant time multiplication.
+     * Uses wNAF method. Windowed method may be 10% faster,
+     * but takes 2x longer to generate and consumes 2x memory.
+     * Uses precomputes when available.
+     * Uses endomorphism for Koblitz curves.
+     * @param scalar by which the point would be multiplied
+     * @returns New point
+     */
+    multiply(scalar) {
+      assertGE(scalar);
+      let n = scalar;
+      let point, fake;
+      const { endo } = CURVE;
+      if (endo) {
+        const { k1neg, k1, k2neg, k2 } = endo.splitScalar(n);
+        let { p: k1p, f: f1p } = this.wNAF(k1);
+        let { p: k2p, f: f2p } = this.wNAF(k2);
+        k1p = wnaf.constTimeNegate(k1neg, k1p);
+        k2p = wnaf.constTimeNegate(k2neg, k2p);
+        k2p = new _Point(Fp.mul(k2p.px, endo.beta), k2p.py, k2p.pz);
+        point = k1p.add(k2p);
+        fake = f1p.add(f2p);
+      } else {
+        const { p, f } = this.wNAF(n);
+        point = p;
+        fake = f;
+      }
+      return _Point.normalizeZ([point, fake])[0];
+    }
+    /**
+     * Efficiently calculate `aP + bQ`. Unsafe, can expose private key, if used incorrectly.
+     * Not using Strauss-Shamir trick: precomputation tables are faster.
+     * The trick could be useful if both P and Q are not G (not in our case).
+     * @returns non-zero affine point
+     */
+    multiplyAndAddUnsafe(Q, a, b) {
+      const G = _Point.BASE;
+      const mul = /* @__PURE__ */ __name((P, a2) => a2 === _0n4 || a2 === _1n4 || !P.equals(G) ? P.multiplyUnsafe(a2) : P.multiply(a2), "mul");
+      const sum = mul(this, a).add(mul(Q, b));
+      return sum.is0() ? void 0 : sum;
+    }
+    // Converts Projective point to affine (x, y) coordinates.
+    // Can accept precomputed Z^-1 - for example, from invertBatch.
+    // (x, y, z) ∋ (x=x/z, y=y/z)
+    toAffine(iz) {
+      const { px: x2, py: y, pz: z } = this;
+      const is0 = this.is0();
+      if (iz == null)
+        iz = is0 ? Fp.ONE : Fp.inv(z);
+      const ax = Fp.mul(x2, iz);
+      const ay = Fp.mul(y, iz);
+      const zz = Fp.mul(z, iz);
+      if (is0)
+        return { x: Fp.ZERO, y: Fp.ZERO };
+      if (!Fp.eql(zz, Fp.ONE))
+        throw new Error("invZ was invalid");
+      return { x: ax, y: ay };
+    }
+    isTorsionFree() {
+      const { h: cofactor, isTorsionFree } = CURVE;
+      if (cofactor === _1n4)
+        return true;
+      if (isTorsionFree)
+        return isTorsionFree(_Point, this);
+      throw new Error("isTorsionFree() has not been declared for the elliptic curve");
+    }
+    clearCofactor() {
+      const { h: cofactor, clearCofactor } = CURVE;
+      if (cofactor === _1n4)
+        return this;
+      if (clearCofactor)
+        return clearCofactor(_Point, this);
+      return this.multiplyUnsafe(CURVE.h);
+    }
+    toRawBytes(isCompressed = true) {
+      this.assertValidity();
+      return toBytes2(_Point, this, isCompressed);
+    }
+    toHex(isCompressed = true) {
+      return bytesToHex(this.toRawBytes(isCompressed));
+    }
+  };
+  __name(_Point, "Point");
+  let Point = _Point;
+  Point.BASE = new Point(CURVE.Gx, CURVE.Gy, Fp.ONE);
+  Point.ZERO = new Point(Fp.ZERO, Fp.ONE, Fp.ZERO);
+  const _bits = CURVE.nBitLength;
+  const wnaf = wNAF(Point, CURVE.endo ? Math.ceil(_bits / 2) : _bits);
+  return {
+    CURVE,
+    ProjectivePoint: Point,
+    normPrivateKeyToScalar,
+    weierstrassEquation,
+    isWithinCurveOrder
+  };
+}
+__name(weierstrassPoints, "weierstrassPoints");
+function validateOpts(curve) {
+  const opts = validateBasic(curve);
+  validateObject(opts, {
+    hash: "hash",
+    hmac: "function",
+    randomBytes: "function"
+  }, {
+    bits2int: "function",
+    bits2int_modN: "function",
+    lowS: "boolean"
+  });
+  return Object.freeze({ lowS: true, ...opts });
+}
+__name(validateOpts, "validateOpts");
+function weierstrass(curveDef) {
+  const CURVE = validateOpts(curveDef);
+  const { Fp, n: CURVE_ORDER } = CURVE;
+  const compressedLen = Fp.BYTES + 1;
+  const uncompressedLen = 2 * Fp.BYTES + 1;
+  function isValidFieldElement(num) {
+    return _0n4 < num && num < Fp.ORDER;
+  }
+  __name(isValidFieldElement, "isValidFieldElement");
+  function modN(a) {
+    return mod(a, CURVE_ORDER);
+  }
+  __name(modN, "modN");
+  function invN(a) {
+    return invert(a, CURVE_ORDER);
+  }
+  __name(invN, "invN");
+  const { ProjectivePoint: Point, normPrivateKeyToScalar, weierstrassEquation, isWithinCurveOrder } = weierstrassPoints({
+    ...CURVE,
+    toBytes(c, point, isCompressed) {
+      const a = point.toAffine();
+      const x2 = Fp.toBytes(a.x);
+      const cat = concatBytes;
+      if (isCompressed) {
+        return cat(Uint8Array.from([point.hasEvenY() ? 2 : 3]), x2);
+      } else {
+        return cat(Uint8Array.from([4]), x2, Fp.toBytes(a.y));
+      }
+    },
+    fromBytes(bytes) {
+      const len = bytes.length;
+      const head = bytes[0];
+      const tail = bytes.subarray(1);
+      if (len === compressedLen && (head === 2 || head === 3)) {
+        const x2 = bytesToNumberBE(tail);
+        if (!isValidFieldElement(x2))
+          throw new Error("Point is not on curve");
+        const y2 = weierstrassEquation(x2);
+        let y = Fp.sqrt(y2);
+        const isYOdd = (y & _1n4) === _1n4;
+        const isHeadOdd = (head & 1) === 1;
+        if (isHeadOdd !== isYOdd)
+          y = Fp.neg(y);
+        return { x: x2, y };
+      } else if (len === uncompressedLen && head === 4) {
+        const x2 = Fp.fromBytes(tail.subarray(0, Fp.BYTES));
+        const y = Fp.fromBytes(tail.subarray(Fp.BYTES, 2 * Fp.BYTES));
+        return { x: x2, y };
+      } else {
+        throw new Error(`Point of length ${len} was invalid. Expected ${compressedLen} compressed bytes or ${uncompressedLen} uncompressed bytes`);
+      }
+    }
+  });
+  const numToNByteStr = /* @__PURE__ */ __name((num) => bytesToHex(numberToBytesBE(num, CURVE.nByteLength)), "numToNByteStr");
+  function isBiggerThanHalfOrder(number) {
+    const HALF = CURVE_ORDER >> _1n4;
+    return number > HALF;
+  }
+  __name(isBiggerThanHalfOrder, "isBiggerThanHalfOrder");
+  function normalizeS(s) {
+    return isBiggerThanHalfOrder(s) ? modN(-s) : s;
+  }
+  __name(normalizeS, "normalizeS");
+  const slcNum = /* @__PURE__ */ __name((b, from, to) => bytesToNumberBE(b.slice(from, to)), "slcNum");
+  const _Signature = class _Signature {
+    constructor(r, s, recovery) {
+      this.r = r;
+      this.s = s;
+      this.recovery = recovery;
+      this.assertValidity();
+    }
+    // pair (bytes of r, bytes of s)
+    static fromCompact(hex) {
+      const l = CURVE.nByteLength;
+      hex = ensureBytes("compactSignature", hex, l * 2);
+      return new _Signature(slcNum(hex, 0, l), slcNum(hex, l, 2 * l));
+    }
+    // DER encoded ECDSA signature
+    // https://bitcoin.stackexchange.com/questions/57644/what-are-the-parts-of-a-bitcoin-transaction-input-script
+    static fromDER(hex) {
+      const { r, s } = DER.toSig(ensureBytes("DER", hex));
+      return new _Signature(r, s);
+    }
+    assertValidity() {
+      if (!isWithinCurveOrder(this.r))
+        throw new Error("r must be 0 < r < CURVE.n");
+      if (!isWithinCurveOrder(this.s))
+        throw new Error("s must be 0 < s < CURVE.n");
+    }
+    addRecoveryBit(recovery) {
+      return new _Signature(this.r, this.s, recovery);
+    }
+    recoverPublicKey(msgHash) {
+      const { r, s, recovery: rec } = this;
+      const h = bits2int_modN(ensureBytes("msgHash", msgHash));
+      if (rec == null || ![0, 1, 2, 3].includes(rec))
+        throw new Error("recovery id invalid");
+      const radj = rec === 2 || rec === 3 ? r + CURVE.n : r;
+      if (radj >= Fp.ORDER)
+        throw new Error("recovery id 2 or 3 invalid");
+      const prefix = (rec & 1) === 0 ? "02" : "03";
+      const R = Point.fromHex(prefix + numToNByteStr(radj));
+      const ir = invN(radj);
+      const u1 = modN(-h * ir);
+      const u2 = modN(s * ir);
+      const Q = Point.BASE.multiplyAndAddUnsafe(R, u1, u2);
+      if (!Q)
+        throw new Error("point at infinify");
+      Q.assertValidity();
+      return Q;
+    }
+    // Signatures should be low-s, to prevent malleability.
+    hasHighS() {
+      return isBiggerThanHalfOrder(this.s);
+    }
+    normalizeS() {
+      return this.hasHighS() ? new _Signature(this.r, modN(-this.s), this.recovery) : this;
+    }
+    // DER-encoded
+    toDERRawBytes() {
+      return hexToBytes(this.toDERHex());
+    }
+    toDERHex() {
+      return DER.hexFromSig({ r: this.r, s: this.s });
+    }
+    // padded bytes of r, then padded bytes of s
+    toCompactRawBytes() {
+      return hexToBytes(this.toCompactHex());
+    }
+    toCompactHex() {
+      return numToNByteStr(this.r) + numToNByteStr(this.s);
+    }
+  };
+  __name(_Signature, "Signature");
+  let Signature = _Signature;
+  const utils = {
+    isValidPrivateKey(privateKey) {
+      try {
+        normPrivateKeyToScalar(privateKey);
+        return true;
+      } catch (error) {
+        return false;
+      }
+    },
+    normPrivateKeyToScalar,
+    /**
+     * Produces cryptographically secure private key from random of size (nBitLength+64)
+     * as per FIPS 186 B.4.1 with modulo bias being neglible.
+     */
+    randomPrivateKey: () => {
+      const rand = CURVE.randomBytes(Fp.BYTES + 8);
+      const num = hashToPrivateScalar(rand, CURVE_ORDER);
+      return numberToBytesBE(num, CURVE.nByteLength);
+    },
+    /**
+     * Creates precompute table for an arbitrary EC point. Makes point "cached".
+     * Allows to massively speed-up `point.multiply(scalar)`.
+     * @returns cached point
+     * @example
+     * const fast = utils.precompute(8, ProjectivePoint.fromHex(someonesPubKey));
+     * fast.multiply(privKey); // much faster ECDH now
+     */
+    precompute(windowSize = 8, point = Point.BASE) {
+      point._setWindowSize(windowSize);
+      point.multiply(BigInt(3));
+      return point;
+    }
+  };
+  function getPublicKey(privateKey, isCompressed = true) {
+    return Point.fromPrivateKey(privateKey).toRawBytes(isCompressed);
+  }
+  __name(getPublicKey, "getPublicKey");
+  function isProbPub(item) {
+    const arr = item instanceof Uint8Array;
+    const str = typeof item === "string";
+    const len = (arr || str) && item.length;
+    if (arr)
+      return len === compressedLen || len === uncompressedLen;
+    if (str)
+      return len === 2 * compressedLen || len === 2 * uncompressedLen;
+    if (item instanceof Point)
+      return true;
+    return false;
+  }
+  __name(isProbPub, "isProbPub");
+  function getSharedSecret(privateA, publicB, isCompressed = true) {
+    if (isProbPub(privateA))
+      throw new Error("first arg must be private key");
+    if (!isProbPub(publicB))
+      throw new Error("second arg must be public key");
+    const b = Point.fromHex(publicB);
+    return b.multiply(normPrivateKeyToScalar(privateA)).toRawBytes(isCompressed);
+  }
+  __name(getSharedSecret, "getSharedSecret");
+  const bits2int = CURVE.bits2int || function(bytes) {
+    const num = bytesToNumberBE(bytes);
+    const delta = bytes.length * 8 - CURVE.nBitLength;
+    return delta > 0 ? num >> BigInt(delta) : num;
+  };
+  const bits2int_modN = CURVE.bits2int_modN || function(bytes) {
+    return modN(bits2int(bytes));
+  };
+  const ORDER_MASK = bitMask(CURVE.nBitLength);
+  function int2octets(num) {
+    if (typeof num !== "bigint")
+      throw new Error("bigint expected");
+    if (!(_0n4 <= num && num < ORDER_MASK))
+      throw new Error(`bigint expected < 2^${CURVE.nBitLength}`);
+    return numberToBytesBE(num, CURVE.nByteLength);
+  }
+  __name(int2octets, "int2octets");
+  function prepSig(msgHash, privateKey, opts = defaultSigOpts) {
+    if (["recovered", "canonical"].some((k) => k in opts))
+      throw new Error("sign() legacy options not supported");
+    const { hash, randomBytes: randomBytes2 } = CURVE;
+    let { lowS, prehash, extraEntropy: ent } = opts;
+    if (lowS == null)
+      lowS = true;
+    msgHash = ensureBytes("msgHash", msgHash);
+    if (prehash)
+      msgHash = ensureBytes("prehashed msgHash", hash(msgHash));
+    const h1int = bits2int_modN(msgHash);
+    const d = normPrivateKeyToScalar(privateKey);
+    const seedArgs = [int2octets(d), int2octets(h1int)];
+    if (ent != null) {
+      const e = ent === true ? randomBytes2(Fp.BYTES) : ent;
+      seedArgs.push(ensureBytes("extraEntropy", e, Fp.BYTES));
+    }
+    const seed = concatBytes(...seedArgs);
+    const m = h1int;
+    function k2sig(kBytes) {
+      const k = bits2int(kBytes);
+      if (!isWithinCurveOrder(k))
+        return;
+      const ik = invN(k);
+      const q = Point.BASE.multiply(k).toAffine();
+      const r = modN(q.x);
+      if (r === _0n4)
+        return;
+      const s = modN(ik * modN(m + r * d));
+      if (s === _0n4)
+        return;
+      let recovery = (q.x === r ? 0 : 2) | Number(q.y & _1n4);
+      let normS = s;
+      if (lowS && isBiggerThanHalfOrder(s)) {
+        normS = normalizeS(s);
+        recovery ^= 1;
+      }
+      return new Signature(r, normS, recovery);
+    }
+    __name(k2sig, "k2sig");
+    return { seed, k2sig };
+  }
+  __name(prepSig, "prepSig");
+  const defaultSigOpts = { lowS: CURVE.lowS, prehash: false };
+  const defaultVerOpts = { lowS: CURVE.lowS, prehash: false };
+  function sign(msgHash, privKey, opts = defaultSigOpts) {
+    const { seed, k2sig } = prepSig(msgHash, privKey, opts);
+    const C = CURVE;
+    const drbg = createHmacDrbg(C.hash.outputLen, C.nByteLength, C.hmac);
+    return drbg(seed, k2sig);
+  }
+  __name(sign, "sign");
+  Point.BASE._setWindowSize(8);
+  function verify(signature, msgHash, publicKey, opts = defaultVerOpts) {
+    var _a9;
+    const sg = signature;
+    msgHash = ensureBytes("msgHash", msgHash);
+    publicKey = ensureBytes("publicKey", publicKey);
+    if ("strict" in opts)
+      throw new Error("options.strict was renamed to lowS");
+    const { lowS, prehash } = opts;
+    let _sig = void 0;
+    let P;
+    try {
+      if (typeof sg === "string" || sg instanceof Uint8Array) {
+        try {
+          _sig = Signature.fromDER(sg);
+        } catch (derError) {
+          if (!(derError instanceof DER.Err))
+            throw derError;
+          _sig = Signature.fromCompact(sg);
+        }
+      } else if (typeof sg === "object" && typeof sg.r === "bigint" && typeof sg.s === "bigint") {
+        const { r: r2, s: s2 } = sg;
+        _sig = new Signature(r2, s2);
+      } else {
+        throw new Error("PARSE");
+      }
+      P = Point.fromHex(publicKey);
+    } catch (error) {
+      if (error.message === "PARSE")
+        throw new Error(`signature must be Signature instance, Uint8Array or hex string`);
+      return false;
+    }
+    if (lowS && _sig.hasHighS())
+      return false;
+    if (prehash)
+      msgHash = CURVE.hash(msgHash);
+    const { r, s } = _sig;
+    const h = bits2int_modN(msgHash);
+    const is = invN(s);
+    const u1 = modN(h * is);
+    const u2 = modN(r * is);
+    const R = (_a9 = Point.BASE.multiplyAndAddUnsafe(P, u1, u2)) == null ? void 0 : _a9.toAffine();
+    if (!R)
+      return false;
+    const v = modN(R.x);
+    return v === r;
+  }
+  __name(verify, "verify");
+  return {
+    CURVE,
+    getPublicKey,
+    getSharedSecret,
+    sign,
+    verify,
+    ProjectivePoint: Point,
+    Signature,
+    utils
+  };
+}
+__name(weierstrass, "weierstrass");
+
+// node_modules/sm-crypto-v2/dist/index.mjs
+var __defProp = Object.defineProperty;
+var __export2 = /* @__PURE__ */ __name((target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+}, "__export");
+var sm2_exports = {};
+__export2(sm2_exports, {
+  EmptyArray: () => EmptyArray,
+  arrayToHex: () => arrayToHex,
+  arrayToUtf8: () => arrayToUtf8,
+  calculateSharedKey: () => calculateSharedKey,
+  comparePublicKeyHex: () => comparePublicKeyHex,
+  compressPublicKeyHex: () => compressPublicKeyHex,
+  doDecrypt: () => doDecrypt,
+  doEncrypt: () => doEncrypt,
+  doSignature: () => doSignature,
+  doVerifySignature: () => doVerifySignature,
+  generateKeyPairHex: () => generateKeyPairHex,
+  getHash: () => getHash,
+  getPoint: () => getPoint,
+  getPublicKeyFromPrivateKey: () => getPublicKeyFromPrivateKey,
+  getZ: () => getZ,
+  hexToArray: () => hexToArray,
+  initRNGPool: () => initRNGPool,
+  leftPad: () => leftPad,
+  precomputePublicKey: () => precomputePublicKey,
+  utf8ToHex: () => utf8ToHex,
+  verifyPublicKey: () => verifyPublicKey
+});
+var ZERO = BigInt(0);
+var ONE = BigInt(1);
+var TWO = BigInt(2);
+BigInt(3);
+function bigintToValue(bigint) {
+  let h = bigint.toString(16);
+  if (h[0] !== "-") {
+    if (h.length % 2 === 1)
+      h = "0" + h;
+    else if (!h.match(/^[0-7]/))
+      h = "00" + h;
+  } else {
+    h = h.substring(1);
+    let len = h.length;
+    if (len % 2 === 1)
+      len += 1;
+    else if (!h.match(/^[0-7]/))
+      len += 2;
+    let maskString = "";
+    for (let i = 0; i < len; i++)
+      maskString += "f";
+    let mask = hexToNumber(maskString);
+    let output = (mask ^ bigint) + ONE;
+    h = output.toString(16).replace(/^-/, "");
+  }
+  return h;
+}
+__name(bigintToValue, "bigintToValue");
+var _a2;
+var ASN1Object = (_a2 = class {
+  constructor(tlv = null, t = "00", l = "00", v = "") {
+    this.tlv = tlv;
+    this.t = t;
+    this.l = l;
+    this.v = v;
+  }
+  getEncodedHex() {
+    if (!this.tlv) {
+      this.v = this.getValue();
+      this.l = this.getLength();
+      this.tlv = this.t + this.l + this.v;
+    }
+    return this.tlv;
+  }
+  getLength() {
+    const n = this.v.length / 2;
+    let nHex = n.toString(16);
+    if (nHex.length % 2 === 1)
+      nHex = "0" + nHex;
+    if (n < 128) {
+      return nHex;
+    } else {
+      const head = 128 + nHex.length / 2;
+      return head.toString(16) + nHex;
+    }
+  }
+  getValue() {
+    return "";
+  }
+}, __name(_a2, "ASN1Object"), _a2);
+var _a3;
+var DERInteger = (_a3 = class extends ASN1Object {
+  constructor(bigint) {
+    super();
+    this.t = "02";
+    if (bigint)
+      this.v = bigintToValue(bigint);
+  }
+  getValue() {
+    return this.v;
+  }
+}, __name(_a3, "DERInteger"), _a3);
+var _a4;
+var DERSequence = (_a4 = class extends ASN1Object {
+  constructor(asn1Array) {
+    super();
+    this.asn1Array = asn1Array;
+  }
+  t = "30";
+  getValue() {
+    this.v = this.asn1Array.map((asn1Object) => asn1Object.getEncodedHex()).join("");
+    return this.v;
+  }
+}, __name(_a4, "DERSequence"), _a4);
+function getLenOfL(str, start) {
+  if (+str[start + 2] < 8)
+    return 1;
+  return +str.substring(start + 2, start + 4) & 127 + 1;
+}
+__name(getLenOfL, "getLenOfL");
+function getL(str, start) {
+  const len = getLenOfL(str, start);
+  const l = str.substring(start + 2, start + 2 + len * 2);
+  if (!l)
+    return -1;
+  const bigint = +l[0] < 8 ? hexToNumber(l) : hexToNumber(l.substring(2));
+  return +bigint.toString();
+}
+__name(getL, "getL");
+function getStartOfV(str, start) {
+  const len = getLenOfL(str, start);
+  return start + (len + 1) * 2;
+}
+__name(getStartOfV, "getStartOfV");
+function encodeDer(r, s) {
+  const derR = new DERInteger(r);
+  const derS = new DERInteger(s);
+  const derSeq = new DERSequence([derR, derS]);
+  return derSeq.getEncodedHex();
+}
+__name(encodeDer, "encodeDer");
+function decodeDer(input) {
+  const start = getStartOfV(input, 0);
+  const vIndexR = getStartOfV(input, start);
+  const lR = getL(input, start);
+  const vR = input.substr(vIndexR, lR * 2);
+  const nextStart = vIndexR + vR.length;
+  const vIndexS = getStartOfV(input, nextStart);
+  const lS = getL(input, nextStart);
+  const vS = input.substring(vIndexS, vIndexS + lS * 2);
+  const r = hexToNumber(vR);
+  const s = hexToNumber(vS);
+  return { r, s };
+}
+__name(decodeDer, "decodeDer");
+var DEFAULT_PRNG_POOL_SIZE = 16384;
+var prngPool = new Uint8Array(0);
+var _syncCrypto;
+async function initRNGPool() {
+  if ("crypto" in globalThis) {
+    _syncCrypto = globalThis.crypto;
+    return;
+  }
+  if (prngPool.length > DEFAULT_PRNG_POOL_SIZE / 2)
+    return;
+  if ("wx" in globalThis && "getRandomValues" in globalThis.wx) {
+    prngPool = await new Promise((r) => {
+      wx.getRandomValues({
+        length: DEFAULT_PRNG_POOL_SIZE,
+        success(res) {
+          r(new Uint8Array(res.randomValues));
+        }
+      });
+    });
+  } else {
+    try {
+      if (globalThis.crypto) {
+        _syncCrypto = globalThis.crypto;
+      } else {
+        const crypto = await import(
+          /* webpackIgnore: true */
+          'crypto'
+        );
+        _syncCrypto = crypto.webcrypto;
+      }
+      const array = new Uint8Array(DEFAULT_PRNG_POOL_SIZE);
+      _syncCrypto.getRandomValues(array);
+      prngPool = array;
+    } catch (error) {
+      throw new Error("no available csprng, abort.");
+    }
+  }
+}
+__name(initRNGPool, "initRNGPool");
+initRNGPool();
+function consumePool(length) {
+  if (prngPool.length > length) {
+    const prng = prngPool.slice(0, length);
+    prngPool = prngPool.slice(length);
+    initRNGPool();
+    return prng;
+  } else {
+    throw new Error("random number pool is not ready or insufficient, prevent getting too long random values or too often.");
+  }
+}
+__name(consumePool, "consumePool");
+function randomBytes(length = 0) {
+  const array = new Uint8Array(length);
+  if (_syncCrypto) {
+    return _syncCrypto.getRandomValues(array);
+  } else {
+    const result = consumePool(length);
+    return result;
+  }
+}
+__name(randomBytes, "randomBytes");
+var u8a2 = /* @__PURE__ */ __name((a) => a instanceof Uint8Array, "u8a");
+var createView = /* @__PURE__ */ __name((arr) => new DataView(arr.buffer, arr.byteOffset, arr.byteLength), "createView");
+var isLE = new Uint8Array(new Uint32Array([287454020]).buffer)[0] === 68;
+if (!isLE)
+  throw new Error("Non little-endian hardware is not supported");
+var hexes2 = Array.from({ length: 256 }, (v, i) => i.toString(16).padStart(2, "0"));
+function bytesToHex2(bytes) {
+  if (!u8a2(bytes))
+    throw new Error("Uint8Array expected");
+  let hex = "";
+  for (let i = 0; i < bytes.length; i++) {
+    hex += hexes2[bytes[i]];
+  }
+  return hex;
+}
+__name(bytesToHex2, "bytesToHex");
+function utf8ToBytes2(str) {
+  if (typeof str !== "string")
+    throw new Error(`utf8ToBytes expected string, got ${typeof str}`);
+  return new Uint8Array(new TextEncoder().encode(str));
+}
+__name(utf8ToBytes2, "utf8ToBytes");
+function toBytes(data) {
+  if (typeof data === "string")
+    data = utf8ToBytes2(data);
+  if (!u8a2(data))
+    throw new Error(`expected Uint8Array, got ${typeof data}`);
+  return data;
+}
+__name(toBytes, "toBytes");
+var _a5;
+var Hash = (_a5 = class {
+  clone() {
+    return this._cloneInto();
+  }
+}, __name(_a5, "Hash"), _a5);
+function wrapConstructor(hashCons) {
+  const hashC = /* @__PURE__ */ __name((msg) => hashCons().update(toBytes(msg)).digest(), "hashC");
+  const tmp2 = hashCons();
+  hashC.outputLen = tmp2.outputLen;
+  hashC.blockLen = tmp2.blockLen;
+  hashC.create = () => hashCons();
+  return hashC;
+}
+__name(wrapConstructor, "wrapConstructor");
+var BoolA = /* @__PURE__ */ __name((A, B, C) => A & B | A & C | B & C, "BoolA");
+var BoolB = /* @__PURE__ */ __name((A, B, C) => A ^ B ^ C, "BoolB");
+var BoolC = /* @__PURE__ */ __name((A, B, C) => A & B | ~A & C, "BoolC");
+function setBigUint64(view, byteOffset, value, isLE2) {
+  if (typeof view.setBigUint64 === "function")
+    return view.setBigUint64(byteOffset, value, isLE2);
+  const _32n = BigInt(32);
+  const _u32_max = BigInt(4294967295);
+  const wh = Number(value >> _32n & _u32_max);
+  const wl = Number(value & _u32_max);
+  const h = isLE2 ? 4 : 0;
+  const l = isLE2 ? 0 : 4;
+  view.setUint32(byteOffset + h, wh, isLE2);
+  view.setUint32(byteOffset + l, wl, isLE2);
+}
+__name(setBigUint64, "setBigUint64");
+function rotl(x2, n) {
+  const s = n & 31;
+  return x2 << s | x2 >>> 32 - s;
+}
+__name(rotl, "rotl");
+function P0(X) {
+  return X ^ rotl(X, 9) ^ rotl(X, 17);
+}
+__name(P0, "P0");
+function P1(X) {
+  return X ^ rotl(X, 15) ^ rotl(X, 23);
+}
+__name(P1, "P1");
+var _a6;
+var SHA2 = (_a6 = class extends Hash {
+  constructor(blockLen, outputLen, padOffset, isLE2) {
+    super();
+    this.blockLen = blockLen;
+    this.outputLen = outputLen;
+    this.padOffset = padOffset;
+    this.isLE = isLE2;
+    this.buffer = new Uint8Array(blockLen);
+    this.view = createView(this.buffer);
+  }
+  buffer;
+  view;
+  finished = false;
+  length = 0;
+  pos = 0;
+  destroyed = false;
+  update(data) {
+    const { view, buffer, blockLen } = this;
+    data = toBytes(data);
+    const len = data.length;
+    for (let pos = 0; pos < len; ) {
+      const take = Math.min(blockLen - this.pos, len - pos);
+      if (take === blockLen) {
+        const dataView = createView(data);
+        for (; blockLen <= len - pos; pos += blockLen)
+          this.process(dataView, pos);
+        continue;
+      }
+      buffer.set(data.subarray(pos, pos + take), this.pos);
+      this.pos += take;
+      pos += take;
+      if (this.pos === blockLen) {
+        this.process(view, 0);
+        this.pos = 0;
+      }
+    }
+    this.length += data.length;
+    this.roundClean();
+    return this;
+  }
+  digestInto(out) {
+    this.finished = true;
+    const { buffer, view, blockLen, isLE: isLE2 } = this;
+    let { pos } = this;
+    buffer[pos++] = 128;
+    this.buffer.subarray(pos).fill(0);
+    if (this.padOffset > blockLen - pos) {
+      this.process(view, 0);
+      pos = 0;
+    }
+    for (let i = pos; i < blockLen; i++)
+      buffer[i] = 0;
+    setBigUint64(view, blockLen - 8, BigInt(this.length * 8), isLE2);
+    this.process(view, 0);
+    const oview = createView(out);
+    const len = this.outputLen;
+    if (len % 4)
+      throw new Error("_sha2: outputLen should be aligned to 32bit");
+    const outLen = len / 4;
+    const state = this.get();
+    if (outLen > state.length)
+      throw new Error("_sha2: outputLen bigger than state");
+    for (let i = 0; i < outLen; i++)
+      oview.setUint32(4 * i, state[i], isLE2);
+  }
+  digest() {
+    const { buffer, outputLen } = this;
+    this.digestInto(buffer);
+    const res = buffer.slice(0, outputLen);
+    this.destroy();
+    return res;
+  }
+  _cloneInto(to) {
+    to ||= new this.constructor();
+    to.set(...this.get());
+    const { blockLen, buffer, length, finished, destroyed, pos } = this;
+    to.length = length;
+    to.pos = pos;
+    to.finished = finished;
+    to.destroyed = destroyed;
+    if (length % blockLen)
+      to.buffer.set(buffer);
+    return to;
+  }
+}, __name(_a6, "SHA2"), _a6);
+var IV = new Uint32Array([1937774191, 1226093241, 388252375, 3666478592, 2842636476, 372324522, 3817729613, 2969243214]);
+var SM3_W = new Uint32Array(68);
+var SM3_M = new Uint32Array(64);
+var T1 = 2043430169;
+var T2 = 2055708042;
+var _a7;
+var SM3 = (_a7 = class extends SHA2 {
+  A = IV[0] | 0;
+  B = IV[1] | 0;
+  C = IV[2] | 0;
+  D = IV[3] | 0;
+  E = IV[4] | 0;
+  F = IV[5] | 0;
+  G = IV[6] | 0;
+  H = IV[7] | 0;
+  constructor() {
+    super(64, 32, 8, false);
+  }
+  get() {
+    const { A, B, C, D, E, F, G, H } = this;
+    return [A, B, C, D, E, F, G, H];
+  }
+  set(A, B, C, D, E, F, G, H) {
+    this.A = A | 0;
+    this.B = B | 0;
+    this.C = C | 0;
+    this.D = D | 0;
+    this.E = E | 0;
+    this.F = F | 0;
+    this.G = G | 0;
+    this.H = H | 0;
+  }
+  process(view, offset) {
+    for (let i = 0; i < 16; i++, offset += 4)
+      SM3_W[i] = view.getUint32(offset, false);
+    for (let i = 16; i < 68; i++) {
+      SM3_W[i] = P1(SM3_W[i - 16] ^ SM3_W[i - 9] ^ rotl(SM3_W[i - 3], 15)) ^ rotl(SM3_W[i - 13], 7) ^ SM3_W[i - 6];
+    }
+    for (let i = 0; i < 64; i++) {
+      SM3_M[i] = SM3_W[i] ^ SM3_W[i + 4];
+    }
+    let { A, B, C, D, E, F, G, H } = this;
+    for (let j = 0; j < 64; j++) {
+      let small = j >= 0 && j <= 15;
+      let T = small ? T1 : T2;
+      let SS1 = rotl(rotl(A, 12) + E + rotl(T, j), 7);
+      let SS2 = SS1 ^ rotl(A, 12);
+      let TT1 = (small ? BoolB(A, B, C) : BoolA(A, B, C)) + D + SS2 + SM3_M[j] | 0;
+      let TT2 = (small ? BoolB(E, F, G) : BoolC(E, F, G)) + H + SS1 + SM3_W[j] | 0;
+      D = C;
+      C = rotl(B, 9);
+      B = A;
+      A = TT1;
+      H = G;
+      G = rotl(F, 19);
+      F = E;
+      E = P0(TT2);
+    }
+    A = A ^ this.A | 0;
+    B = B ^ this.B | 0;
+    C = C ^ this.C | 0;
+    D = D ^ this.D | 0;
+    E = E ^ this.E | 0;
+    F = F ^ this.F | 0;
+    G = G ^ this.G | 0;
+    H = H ^ this.H | 0;
+    this.set(A, B, C, D, E, F, G, H);
+  }
+  roundClean() {
+    SM3_W.fill(0);
+  }
+  destroy() {
+    this.set(0, 0, 0, 0, 0, 0, 0, 0);
+    this.buffer.fill(0);
+  }
+}, __name(_a7, "SM3"), _a7);
+var sm3 = wrapConstructor(() => new SM3());
+var _a8;
+var HMAC = (_a8 = class extends Hash {
+  oHash;
+  iHash;
+  blockLen;
+  outputLen;
+  finished = false;
+  destroyed = false;
+  constructor(hash, _key) {
+    super();
+    const key = toBytes(_key);
+    this.iHash = hash.create();
+    if (typeof this.iHash.update !== "function")
+      throw new Error("Expected instance of class which extends utils.Hash");
+    this.blockLen = this.iHash.blockLen;
+    this.outputLen = this.iHash.outputLen;
+    const blockLen = this.blockLen;
+    const pad = new Uint8Array(blockLen);
+    pad.set(key.length > blockLen ? hash.create().update(key).digest() : key);
+    for (let i = 0; i < pad.length; i++)
+      pad[i] ^= 54;
+    this.iHash.update(pad);
+    this.oHash = hash.create();
+    for (let i = 0; i < pad.length; i++)
+      pad[i] ^= 54 ^ 92;
+    this.oHash.update(pad);
+    pad.fill(0);
+  }
+  update(buf) {
+    this.iHash.update(buf);
+    return this;
+  }
+  digestInto(out) {
+    this.finished = true;
+    this.iHash.digestInto(out);
+    this.oHash.update(out);
+    this.oHash.digestInto(out);
+    this.destroy();
+  }
+  digest() {
+    const out = new Uint8Array(this.oHash.outputLen);
+    this.digestInto(out);
+    return out;
+  }
+  _cloneInto(to) {
+    to ||= Object.create(Object.getPrototypeOf(this), {});
+    const { oHash, iHash, finished, destroyed, blockLen, outputLen } = this;
+    to = to;
+    to.finished = finished;
+    to.destroyed = destroyed;
+    to.blockLen = blockLen;
+    to.outputLen = outputLen;
+    to.oHash = oHash._cloneInto(to.oHash);
+    to.iHash = iHash._cloneInto(to.iHash);
+    return to;
+  }
+  destroy() {
+    this.destroyed = true;
+    this.oHash.destroy();
+    this.iHash.destroy();
+  }
+}, __name(_a8, "HMAC"), _a8);
+var hmac = /* @__PURE__ */ __name((hash, key, message) => new HMAC(hash, key).update(message).digest(), "hmac");
+hmac.create = (hash, key) => new HMAC(hash, key);
+var sm2Fp = Field(BigInt("115792089210356248756420345214020892766250353991924191454421193933289684991999"));
+var sm2Curve = weierstrass({
+  a: BigInt("115792089210356248756420345214020892766250353991924191454421193933289684991996"),
+  b: BigInt("18505919022281880113072981827955639221458448578012075254857346196103069175443"),
+  Fp: sm2Fp,
+  h: ONE,
+  n: BigInt("115792089210356248756420345214020892766061623724957744567843809356293439045923"),
+  Gx: BigInt("22963146547237050559479531362550074578802567295341616970375194840604139615431"),
+  Gy: BigInt("85132369209828568825618990617112496413088388631904505083283536607588877201568"),
+  hash: sm3,
+  hmac: (key, ...msgs) => hmac(sm3, key, concatBytes(...msgs)),
+  randomBytes
+});
+var field = Field(BigInt(sm2Curve.CURVE.n));
+function generateKeyPairHex(str) {
+  const privateKey = str ? numberToBytesBE(mod(BigInt(str), ONE) + ONE, 32) : sm2Curve.utils.randomPrivateKey();
+  const publicKey = sm2Curve.getPublicKey(privateKey, false);
+  const privPad = leftPad(bytesToHex(privateKey), 64);
+  const pubPad = leftPad(bytesToHex(publicKey), 64);
+  return { privateKey: privPad, publicKey: pubPad };
+}
+__name(generateKeyPairHex, "generateKeyPairHex");
+function compressPublicKeyHex(s) {
+  if (s.length !== 130)
+    throw new Error("Invalid public key to compress");
+  const len = (s.length - 2) / 2;
+  const xHex = s.substring(2, 2 + len);
+  const y = hexToNumber(s.substring(len + 2, len + len + 2));
+  let prefix = "03";
+  if (mod(y, TWO) === ZERO)
+    prefix = "02";
+  return prefix + xHex;
+}
+__name(compressPublicKeyHex, "compressPublicKeyHex");
+function utf8ToHex(input) {
+  input = decodeURIComponent(encodeURIComponent(input));
+  const length = input.length;
+  const words = new Uint32Array((length >>> 2) + 1);
+  for (let i = 0; i < length; i++) {
+    words[i >>> 2] |= (input.charCodeAt(i) & 255) << 24 - i % 4 * 8;
+  }
+  const hexChars = [];
+  for (let i = 0; i < length; i++) {
+    const bite = words[i >>> 2] >>> 24 - i % 4 * 8 & 255;
+    hexChars.push((bite >>> 4).toString(16));
+    hexChars.push((bite & 15).toString(16));
+  }
+  return hexChars.join("");
+}
+__name(utf8ToHex, "utf8ToHex");
+function leftPad(input, num) {
+  if (input.length >= num)
+    return input;
+  return new Array(num - input.length + 1).join("0") + input;
+}
+__name(leftPad, "leftPad");
+function arrayToHex(arr) {
+  return arr.map((item) => {
+    const hex = item.toString(16);
+    return hex.length === 1 ? "0" + hex : hex;
+  }).join("");
+}
+__name(arrayToHex, "arrayToHex");
+function arrayToUtf8(arr) {
+  const str = [];
+  for (let i = 0, len = arr.length; i < len; i++) {
+    if (arr[i] >= 240 && arr[i] <= 247) {
+      str.push(String.fromCodePoint(((arr[i] & 7) << 18) + ((arr[i + 1] & 63) << 12) + ((arr[i + 2] & 63) << 6) + (arr[i + 3] & 63)));
+      i += 3;
+    } else if (arr[i] >= 224 && arr[i] <= 239) {
+      str.push(String.fromCodePoint(((arr[i] & 15) << 12) + ((arr[i + 1] & 63) << 6) + (arr[i + 2] & 63)));
+      i += 2;
+    } else if (arr[i] >= 192 && arr[i] <= 223) {
+      str.push(String.fromCodePoint(((arr[i] & 31) << 6) + (arr[i + 1] & 63)));
+      i++;
+    } else {
+      str.push(String.fromCodePoint(arr[i]));
+    }
+  }
+  return str.join("");
+}
+__name(arrayToUtf8, "arrayToUtf8");
+function hexToArray(hexStr) {
+  let hexStrLength = hexStr.length;
+  if (hexStrLength % 2 !== 0) {
+    hexStr = leftPad(hexStr, hexStrLength + 1);
+  }
+  hexStrLength = hexStr.length;
+  const wordLength = hexStrLength / 2;
+  const words = new Uint8Array(wordLength);
+  for (let i = 0; i < wordLength; i++) {
+    words[i] = parseInt(hexStr.substring(i * 2, i * 2 + 2), 16);
+  }
+  return words;
+}
+__name(hexToArray, "hexToArray");
+function verifyPublicKey(publicKey) {
+  const point = sm2Curve.ProjectivePoint.fromHex(publicKey);
+  if (!point)
+    return false;
+  try {
+    point.assertValidity();
+    return true;
+  } catch (error) {
+    return false;
+  }
+}
+__name(verifyPublicKey, "verifyPublicKey");
+function comparePublicKeyHex(publicKey1, publicKey2) {
+  const point1 = sm2Curve.ProjectivePoint.fromHex(publicKey1);
+  if (!point1)
+    return false;
+  const point2 = sm2Curve.ProjectivePoint.fromHex(publicKey2);
+  if (!point2)
+    return false;
+  return point1.equals(point2);
+}
+__name(comparePublicKeyHex, "comparePublicKeyHex");
+var wPow2 = hexToNumber("80000000000000000000000000000000");
+var wPow2Sub1 = hexToNumber("7fffffffffffffffffffffffffffffff");
+function hkdf(z, keylen) {
+  let msg = new Uint8Array(keylen);
+  let ct = 1;
+  let offset = 0;
+  let t = EmptyArray;
+  const ctShift = new Uint8Array(4);
+  const nextT = /* @__PURE__ */ __name(() => {
+    ctShift[0] = ct >> 24 & 255;
+    ctShift[1] = ct >> 16 & 255;
+    ctShift[2] = ct >> 8 & 255;
+    ctShift[3] = ct & 255;
+    t = sm3(concatBytes(z, ctShift));
+    ct++;
+    offset = 0;
+  }, "nextT");
+  nextT();
+  for (let i = 0, len = msg.length; i < len; i++) {
+    if (offset === t.length)
+      nextT();
+    msg[i] = t[offset++] & 255;
+  }
+  return msg;
+}
+__name(hkdf, "hkdf");
+function calculateSharedKey(keypairA, ephemeralKeypairA, publicKeyB, ephemeralPublicKeyB, sharedKeyLength, isRecipient = false, idA = "1234567812345678", idB = "1234567812345678") {
+  const RA = sm2Curve.ProjectivePoint.fromHex(ephemeralKeypairA.publicKey);
+  const RB = sm2Curve.ProjectivePoint.fromHex(ephemeralPublicKeyB);
+  const PB = sm2Curve.ProjectivePoint.fromHex(publicKeyB);
+  let ZA = getZ(keypairA.publicKey, idA);
+  let ZB = getZ(publicKeyB, idB);
+  if (isRecipient) {
+    [ZA, ZB] = [ZB, ZA];
+  }
+  const rA = hexToNumber(ephemeralKeypairA.privateKey);
+  const dA = hexToNumber(keypairA.privateKey);
+  const x1 = RA.x;
+  const x1_ = wPow2 + (x1 & wPow2Sub1);
+  const tA = field.add(dA, field.mulN(x1_, rA));
+  const x2 = RB.x;
+  const x2_ = field.add(wPow2, x2 & wPow2Sub1);
+  const U = RB.multiply(x2_).add(PB).multiply(tA);
+  const xU = hexToArray(leftPad(numberToHexUnpadded(U.x), 64));
+  const yU = hexToArray(leftPad(numberToHexUnpadded(U.y), 64));
+  const KA = hkdf(concatBytes(xU, yU, ZA, ZB), sharedKeyLength);
+  return KA;
+}
+__name(calculateSharedKey, "calculateSharedKey");
+var C1C2C3 = 0;
+var EmptyArray = new Uint8Array();
+function doEncrypt(msg, publicKey, cipherMode = 1) {
+  const msgArr = typeof msg === "string" ? hexToArray(utf8ToHex(msg)) : Uint8Array.from(msg);
+  const publicKeyPoint = typeof publicKey === "string" ? sm2Curve.ProjectivePoint.fromHex(publicKey) : publicKey;
+  const keypair = generateKeyPairHex();
+  const k = hexToNumber(keypair.privateKey);
+  let c1 = keypair.publicKey;
+  if (c1.length > 128)
+    c1 = c1.substring(c1.length - 128);
+  const p = publicKeyPoint.multiply(k);
+  const x2 = hexToArray(leftPad(numberToHexUnpadded(p.x), 64));
+  const y2 = hexToArray(leftPad(numberToHexUnpadded(p.y), 64));
+  const c3 = bytesToHex2(sm3(concatBytes(x2, msgArr, y2)));
+  xorCipherStream(x2, y2, msgArr);
+  const c2 = bytesToHex2(msgArr);
+  return cipherMode === C1C2C3 ? c1 + c2 + c3 : c1 + c3 + c2;
+}
+__name(doEncrypt, "doEncrypt");
+function xorCipherStream(x2, y2, msg) {
+  let ct = 1;
+  let offset = 0;
+  let t = EmptyArray;
+  const ctShift = new Uint8Array(4);
+  const nextT = /* @__PURE__ */ __name(() => {
+    ctShift[0] = ct >> 24 & 255;
+    ctShift[1] = ct >> 16 & 255;
+    ctShift[2] = ct >> 8 & 255;
+    ctShift[3] = ct & 255;
+    t = sm3(concatBytes(x2, y2, ctShift));
+    ct++;
+    offset = 0;
+  }, "nextT");
+  nextT();
+  for (let i = 0, len = msg.length; i < len; i++) {
+    if (offset === t.length)
+      nextT();
+    msg[i] ^= t[offset++] & 255;
+  }
+}
+__name(xorCipherStream, "xorCipherStream");
+function doDecrypt(encryptData, privateKey, cipherMode = 1, {
+  output = "string"
+} = {}) {
+  const privateKeyInteger = hexToNumber(privateKey);
+  let c3 = encryptData.substring(128, 128 + 64);
+  let c2 = encryptData.substring(128 + 64);
+  if (cipherMode === C1C2C3) {
+    c3 = encryptData.substring(encryptData.length - 64);
+    c2 = encryptData.substring(128, encryptData.length - 64);
+  }
+  const msg = hexToArray(c2);
+  const c1 = sm2Curve.ProjectivePoint.fromHex("04" + encryptData.substring(0, 128));
+  const p = c1.multiply(privateKeyInteger);
+  const x2 = hexToArray(leftPad(numberToHexUnpadded(p.x), 64));
+  const y2 = hexToArray(leftPad(numberToHexUnpadded(p.y), 64));
+  xorCipherStream(x2, y2, msg);
+  const checkC3 = arrayToHex(Array.from(sm3(concatBytes(x2, msg, y2))));
+  if (checkC3 === c3.toLowerCase()) {
+    return output === "array" ? msg : arrayToUtf8(msg);
+  } else {
+    return output === "array" ? [] : "";
+  }
+}
+__name(doDecrypt, "doDecrypt");
+function doSignature(msg, privateKey, options = {}) {
+  let {
+    pointPool,
+    der,
+    hash,
+    publicKey,
+    userId
+  } = options;
+  let hashHex = typeof msg === "string" ? utf8ToHex(msg) : arrayToHex(Array.from(msg));
+  if (hash) {
+    publicKey = publicKey || getPublicKeyFromPrivateKey(privateKey);
+    hashHex = getHash(hashHex, publicKey, userId);
+  }
+  const dA = hexToNumber(privateKey);
+  const e = hexToNumber(hashHex);
+  let k = null;
+  let r = null;
+  let s = null;
+  do {
+    do {
+      let point;
+      if (pointPool && pointPool.length) {
+        point = pointPool.pop();
+      } else {
+        point = getPoint();
+      }
+      k = point.k;
+      r = field.add(e, point.x1);
+    } while (r === ZERO || r + k === sm2Curve.CURVE.n);
+    s = field.mul(field.inv(field.addN(dA, ONE)), field.subN(k, field.mulN(r, dA)));
+  } while (s === ZERO);
+  if (der)
+    return encodeDer(r, s);
+  return leftPad(numberToHexUnpadded(r), 64) + leftPad(numberToHexUnpadded(s), 64);
+}
+__name(doSignature, "doSignature");
+function doVerifySignature(msg, signHex, publicKey, options = {}) {
+  let hashHex;
+  const {
+    hash,
+    der,
+    userId
+  } = options;
+  const publicKeyHex = typeof publicKey === "string" ? publicKey : publicKey.toHex(false);
+  if (hash) {
+    hashHex = getHash(typeof msg === "string" ? utf8ToHex(msg) : msg, publicKeyHex, userId);
+  } else {
+    hashHex = typeof msg === "string" ? utf8ToHex(msg) : arrayToHex(Array.from(msg));
+  }
+  let r;
+  let s;
+  if (der) {
+    const decodeDerObj = decodeDer(signHex);
+    r = decodeDerObj.r;
+    s = decodeDerObj.s;
+  } else {
+    r = hexToNumber(signHex.substring(0, 64));
+    s = hexToNumber(signHex.substring(64));
+  }
+  const PA = typeof publicKey === "string" ? sm2Curve.ProjectivePoint.fromHex(publicKey) : publicKey;
+  const e = hexToNumber(hashHex);
+  const t = field.add(r, s);
+  if (t === ZERO)
+    return false;
+  const x1y1 = sm2Curve.ProjectivePoint.BASE.multiply(s).add(PA.multiply(t));
+  const R = field.add(e, x1y1.x);
+  return r === R;
+}
+__name(doVerifySignature, "doVerifySignature");
+function getZ(publicKey, userId = "1234567812345678") {
+  userId = utf8ToHex(userId);
+  const a = leftPad(numberToHexUnpadded(sm2Curve.CURVE.a), 64);
+  const b = leftPad(numberToHexUnpadded(sm2Curve.CURVE.b), 64);
+  const gx = leftPad(numberToHexUnpadded(sm2Curve.ProjectivePoint.BASE.x), 64);
+  const gy = leftPad(numberToHexUnpadded(sm2Curve.ProjectivePoint.BASE.y), 64);
+  let px;
+  let py;
+  if (publicKey.length === 128) {
+    px = publicKey.substring(0, 64);
+    py = publicKey.substring(64, 128);
+  } else {
+    const point = sm2Curve.ProjectivePoint.fromHex(publicKey);
+    px = leftPad(numberToHexUnpadded(point.x), 64);
+    py = leftPad(numberToHexUnpadded(point.y), 64);
+  }
+  const data = hexToArray(userId + a + b + gx + gy + px + py);
+  const entl = userId.length * 4;
+  const z = sm3(concatBytes(new Uint8Array([entl >> 8 & 255, entl & 255]), data));
+  return z;
+}
+__name(getZ, "getZ");
+function getHash(hashHex, publicKey, userId = "1234567812345678") {
+  const z = getZ(publicKey, userId);
+  return bytesToHex2(sm3(concatBytes(z, typeof hashHex === "string" ? hexToArray(hashHex) : hashHex)));
+}
+__name(getHash, "getHash");
+function precomputePublicKey(publicKey, windowSize) {
+  const point = sm2Curve.ProjectivePoint.fromHex(publicKey);
+  return sm2Curve.utils.precompute(windowSize, point);
+}
+__name(precomputePublicKey, "precomputePublicKey");
+function getPublicKeyFromPrivateKey(privateKey) {
+  const pubKey = sm2Curve.getPublicKey(privateKey, false);
+  const pubPad = leftPad(bytesToHex(pubKey), 64);
+  return pubPad;
+}
+__name(getPublicKeyFromPrivateKey, "getPublicKeyFromPrivateKey");
+function getPoint() {
+  const keypair = generateKeyPairHex();
+  const PA = sm2Curve.ProjectivePoint.fromHex(keypair.publicKey);
+  const k = hexToNumber(keypair.privateKey);
+  return {
+    ...keypair,
+    k,
+    x1: PA.x
+  };
+}
+__name(getPoint, "getPoint");
+function utf8ToArray(str) {
+  const arr = [];
+  for (let i = 0, len = str.length; i < len; i++) {
+    const point = str.codePointAt(i);
+    if (point <= 127) {
+      arr.push(point);
+    } else if (point <= 2047) {
+      arr.push(192 | point >>> 6);
+      arr.push(128 | point & 63);
+    } else if (point <= 55295 || point >= 57344 && point <= 65535) {
+      arr.push(224 | point >>> 12);
+      arr.push(128 | point >>> 6 & 63);
+      arr.push(128 | point & 63);
+    } else if (point >= 65536 && point <= 1114111) {
+      i++;
+      arr.push(240 | point >>> 18 & 28);
+      arr.push(128 | point >>> 12 & 63);
+      arr.push(128 | point >>> 6 & 63);
+      arr.push(128 | point & 63);
+    } else {
+      arr.push(point);
+      throw new Error("input is not supported");
+    }
+  }
+  return new Uint8Array(arr);
+}
+__name(utf8ToArray, "utf8ToArray");
+var sm4_exports = {};
+__export2(sm4_exports, {
+  decrypt: () => decrypt,
+  encrypt: () => encrypt,
+  sm4: () => sm4
+});
+var DECRYPT = 0;
+var ROUND = 32;
+var BLOCK = 16;
+var Sbox = Uint8Array.from([
+  214,
+  144,
+  233,
+  254,
+  204,
+  225,
+  61,
+  183,
+  22,
+  182,
+  20,
+  194,
+  40,
+  251,
+  44,
+  5,
+  43,
+  103,
+  154,
+  118,
+  42,
+  190,
+  4,
+  195,
+  170,
+  68,
+  19,
+  38,
+  73,
+  134,
+  6,
+  153,
+  156,
+  66,
+  80,
+  244,
+  145,
+  239,
+  152,
+  122,
+  51,
+  84,
+  11,
+  67,
+  237,
+  207,
+  172,
+  98,
+  228,
+  179,
+  28,
+  169,
+  201,
+  8,
+  232,
+  149,
+  128,
+  223,
+  148,
+  250,
+  117,
+  143,
+  63,
+  166,
+  71,
+  7,
+  167,
+  252,
+  243,
+  115,
+  23,
+  186,
+  131,
+  89,
+  60,
+  25,
+  230,
+  133,
+  79,
+  168,
+  104,
+  107,
+  129,
+  178,
+  113,
+  100,
+  218,
+  139,
+  248,
+  235,
+  15,
+  75,
+  112,
+  86,
+  157,
+  53,
+  30,
+  36,
+  14,
+  94,
+  99,
+  88,
+  209,
+  162,
+  37,
+  34,
+  124,
+  59,
+  1,
+  33,
+  120,
+  135,
+  212,
+  0,
+  70,
+  87,
+  159,
+  211,
+  39,
+  82,
+  76,
+  54,
+  2,
+  231,
+  160,
+  196,
+  200,
+  158,
+  234,
+  191,
+  138,
+  210,
+  64,
+  199,
+  56,
+  181,
+  163,
+  247,
+  242,
+  206,
+  249,
+  97,
+  21,
+  161,
+  224,
+  174,
+  93,
+  164,
+  155,
+  52,
+  26,
+  85,
+  173,
+  147,
+  50,
+  48,
+  245,
+  140,
+  177,
+  227,
+  29,
+  246,
+  226,
+  46,
+  130,
+  102,
+  202,
+  96,
+  192,
+  41,
+  35,
+  171,
+  13,
+  83,
+  78,
+  111,
+  213,
+  219,
+  55,
+  69,
+  222,
+  253,
+  142,
+  47,
+  3,
+  255,
+  106,
+  114,
+  109,
+  108,
+  91,
+  81,
+  141,
+  27,
+  175,
+  146,
+  187,
+  221,
+  188,
+  127,
+  17,
+  217,
+  92,
+  65,
+  31,
+  16,
+  90,
+  216,
+  10,
+  193,
+  49,
+  136,
+  165,
+  205,
+  123,
+  189,
+  45,
+  116,
+  208,
+  18,
+  184,
+  229,
+  180,
+  176,
+  137,
+  105,
+  151,
+  74,
+  12,
+  150,
+  119,
+  126,
+  101,
+  185,
+  241,
+  9,
+  197,
+  110,
+  198,
+  132,
+  24,
+  240,
+  125,
+  236,
+  58,
+  220,
+  77,
+  32,
+  121,
+  238,
+  95,
+  62,
+  215,
+  203,
+  57,
+  72
+]);
+var CK = new Uint32Array([
+  462357,
+  472066609,
+  943670861,
+  1415275113,
+  1886879365,
+  2358483617,
+  2830087869,
+  3301692121,
+  3773296373,
+  4228057617,
+  404694573,
+  876298825,
+  1347903077,
+  1819507329,
+  2291111581,
+  2762715833,
+  3234320085,
+  3705924337,
+  4177462797,
+  337322537,
+  808926789,
+  1280531041,
+  1752135293,
+  2223739545,
+  2695343797,
+  3166948049,
+  3638552301,
+  4110090761,
+  269950501,
+  741554753,
+  1213159005,
+  1684763257
+]);
+function byteSub(a) {
+  return (Sbox[a >>> 24 & 255] & 255) << 24 | (Sbox[a >>> 16 & 255] & 255) << 16 | (Sbox[a >>> 8 & 255] & 255) << 8 | Sbox[a & 255] & 255;
+}
+__name(byteSub, "byteSub");
+function sms4Crypt(input, output, roundKey) {
+  let x0 = 0, x1 = 0, x2 = 0, x3 = 0, tmp0 = 0, tmp1 = 0, tmp2 = 0, tmp3 = 0;
+  tmp0 = input[0] & 255;
+  tmp1 = input[1] & 255;
+  tmp2 = input[2] & 255;
+  tmp3 = input[3] & 255;
+  x0 = tmp0 << 24 | tmp1 << 16 | tmp2 << 8 | tmp3;
+  tmp0 = input[4] & 255;
+  tmp1 = input[5] & 255;
+  tmp2 = input[6] & 255;
+  tmp3 = input[7] & 255;
+  x1 = tmp0 << 24 | tmp1 << 16 | tmp2 << 8 | tmp3;
+  tmp0 = input[8] & 255;
+  tmp1 = input[9] & 255;
+  tmp2 = input[10] & 255;
+  tmp3 = input[11] & 255;
+  x2 = tmp0 << 24 | tmp1 << 16 | tmp2 << 8 | tmp3;
+  tmp0 = input[12] & 255;
+  tmp1 = input[13] & 255;
+  tmp2 = input[14] & 255;
+  tmp3 = input[15] & 255;
+  x3 = tmp0 << 24 | tmp1 << 16 | tmp2 << 8 | tmp3;
+  for (let r = 0; r < 32; r += 4) {
+    tmp0 = x1 ^ x2 ^ x3 ^ roundKey[r];
+    tmp0 = byteSub(tmp0);
+    x0 ^= tmp0 ^ (tmp0 << 2 | tmp0 >>> 30) ^ (tmp0 << 10 | tmp0 >>> 22) ^ (tmp0 << 18 | tmp0 >>> 14) ^ (tmp0 << 24 | tmp0 >>> 8);
+    tmp1 = x2 ^ x3 ^ x0 ^ roundKey[r + 1];
+    tmp1 = byteSub(tmp1);
+    x1 ^= tmp1 ^ (tmp1 << 2 | tmp1 >>> 30) ^ (tmp1 << 10 | tmp1 >>> 22) ^ (tmp1 << 18 | tmp1 >>> 14) ^ (tmp1 << 24 | tmp1 >>> 8);
+    tmp2 = x3 ^ x0 ^ x1 ^ roundKey[r + 2];
+    tmp2 = byteSub(tmp2);
+    x2 ^= tmp2 ^ (tmp2 << 2 | tmp2 >>> 30) ^ (tmp2 << 10 | tmp2 >>> 22) ^ (tmp2 << 18 | tmp2 >>> 14) ^ (tmp2 << 24 | tmp2 >>> 8);
+    tmp3 = x0 ^ x1 ^ x2 ^ roundKey[r + 3];
+    tmp3 = byteSub(tmp3);
+    x3 ^= tmp3 ^ (tmp3 << 2 | tmp3 >>> 30) ^ (tmp3 << 10 | tmp3 >>> 22) ^ (tmp3 << 18 | tmp3 >>> 14) ^ (tmp3 << 24 | tmp3 >>> 8);
+  }
+  output[0] = x3 >>> 24 & 255;
+  output[1] = x3 >>> 16 & 255;
+  output[2] = x3 >>> 8 & 255;
+  output[3] = x3 & 255;
+  output[4] = x2 >>> 24 & 255;
+  output[5] = x2 >>> 16 & 255;
+  output[6] = x2 >>> 8 & 255;
+  output[7] = x2 & 255;
+  output[8] = x1 >>> 24 & 255;
+  output[9] = x1 >>> 16 & 255;
+  output[10] = x1 >>> 8 & 255;
+  output[11] = x1 & 255;
+  output[12] = x0 >>> 24 & 255;
+  output[13] = x0 >>> 16 & 255;
+  output[14] = x0 >>> 8 & 255;
+  output[15] = x0 & 255;
+}
+__name(sms4Crypt, "sms4Crypt");
+function sms4KeyExt(key, roundKey, cryptFlag) {
+  let x0 = 0, x1 = 0, x2 = 0, x3 = 0, mid = 0;
+  x0 = (key[0] & 255) << 24 | (key[1] & 255) << 16 | (key[2] & 255) << 8 | key[3] & 255;
+  x1 = (key[4] & 255) << 24 | (key[5] & 255) << 16 | (key[6] & 255) << 8 | key[7] & 255;
+  x2 = (key[8] & 255) << 24 | (key[9] & 255) << 16 | (key[10] & 255) << 8 | key[11] & 255;
+  x3 = (key[12] & 255) << 24 | (key[13] & 255) << 16 | (key[14] & 255) << 8 | key[15] & 255;
+  x0 ^= 2746333894;
+  x1 ^= 1453994832;
+  x2 ^= 1736282519;
+  x3 ^= 2993693404;
+  for (let r = 0; r < 32; r += 4) {
+    mid = x1 ^ x2 ^ x3 ^ CK[r + 0];
+    mid = byteSub(mid);
+    x0 ^= mid ^ (mid << 13 | mid >>> 19) ^ (mid << 23 | mid >>> 9);
+    roundKey[r + 0] = x0;
+    mid = x2 ^ x3 ^ x0 ^ CK[r + 1];
+    mid = byteSub(mid);
+    x1 ^= mid ^ (mid << 13 | mid >>> 19) ^ (mid << 23 | mid >>> 9);
+    roundKey[r + 1] = x1;
+    mid = x3 ^ x0 ^ x1 ^ CK[r + 2];
+    mid = byteSub(mid);
+    x2 ^= mid ^ (mid << 13 | mid >>> 19) ^ (mid << 23 | mid >>> 9);
+    roundKey[r + 2] = x2;
+    mid = x0 ^ x1 ^ x2 ^ CK[r + 3];
+    mid = byteSub(mid);
+    x3 ^= mid ^ (mid << 13 | mid >>> 19) ^ (mid << 23 | mid >>> 9);
+    roundKey[r + 3] = x3;
+  }
+  if (cryptFlag === DECRYPT) {
+    for (let r = 0; r < 16; r++) {
+      [roundKey[r], roundKey[31 - r]] = [roundKey[31 - r], roundKey[r]];
+    }
+  }
+}
+__name(sms4KeyExt, "sms4KeyExt");
+var blockOutput = new Uint8Array(16);
+function sm4(inArray, key, cryptFlag, options = {}) {
+  let {
+    padding = "pkcs#7",
+    mode,
+    iv = new Uint8Array(16),
+    output
+  } = options;
+  if (mode === "cbc") {
+    if (typeof iv === "string")
+      iv = hexToArray(iv);
+    if (iv.length !== 128 / 8) {
+      throw new Error("iv is invalid");
+    }
+  }
+  if (typeof key === "string")
+    key = hexToArray(key);
+  if (key.length !== 128 / 8) {
+    throw new Error("key is invalid");
+  }
+  if (typeof inArray === "string") {
+    if (cryptFlag !== DECRYPT) {
+      inArray = utf8ToArray(inArray);
+    } else {
+      inArray = hexToArray(inArray);
+    }
+  } else {
+    inArray = Uint8Array.from(inArray);
+  }
+  if ((padding === "pkcs#5" || padding === "pkcs#7") && cryptFlag !== DECRYPT) {
+    const paddingCount = BLOCK - inArray.length % BLOCK;
+    const newArray = new Uint8Array(inArray.length + paddingCount);
+    newArray.set(inArray, 0);
+    for (let i = 0; i < paddingCount; i++)
+      newArray[inArray.length + i] = paddingCount;
+    inArray = newArray;
+  }
+  const roundKey = new Uint32Array(ROUND);
+  sms4KeyExt(key, roundKey, cryptFlag);
+  let outArray = new Uint8Array(inArray.length);
+  let lastVector = iv;
+  let restLen = inArray.length;
+  let point = 0;
+  while (restLen >= BLOCK) {
+    const input = inArray.subarray(point, point + 16);
+    if (mode === "cbc") {
+      for (let i = 0; i < BLOCK; i++) {
+        if (cryptFlag !== DECRYPT) {
+          input[i] ^= lastVector[i];
+        }
+      }
+    }
+    sms4Crypt(input, blockOutput, roundKey);
+    for (let i = 0; i < BLOCK; i++) {
+      if (mode === "cbc") {
+        if (cryptFlag === DECRYPT) {
+          blockOutput[i] ^= lastVector[i];
+        }
+      }
+      outArray[point + i] = blockOutput[i];
+    }
+    if (mode === "cbc") {
+      if (cryptFlag !== DECRYPT) {
+        lastVector = blockOutput;
+      } else {
+        lastVector = input;
+      }
+    }
+    restLen -= BLOCK;
+    point += BLOCK;
+  }
+  if ((padding === "pkcs#5" || padding === "pkcs#7") && cryptFlag === DECRYPT) {
+    const len = outArray.length;
+    const paddingCount = outArray[len - 1];
+    for (let i = 1; i <= paddingCount; i++) {
+      if (outArray[len - i] !== paddingCount)
+        throw new Error("padding is invalid");
+    }
+    outArray = outArray.slice(0, len - paddingCount);
+  }
+  if (output !== "array") {
+    if (cryptFlag !== DECRYPT) {
+      return bytesToHex2(outArray);
+    } else {
+      return arrayToUtf8(outArray);
+    }
+  } else {
+    return outArray;
+  }
+}
+__name(sm4, "sm4");
+function encrypt(inArray, key, options = {}) {
+  return sm4(inArray, key, 1, options);
+}
+__name(encrypt, "encrypt");
+function decrypt(inArray, key, options = {}) {
+  return sm4(inArray, key, 0, options);
+}
+__name(decrypt, "decrypt");
+
+// src/lib/crypto/SM2.ts
+async function initRNGPool2(constructor) {
+  const metadataKey = "__$$RNGPoolInitialized";
+  if (Reflect.getOwnMetadata(metadataKey, constructor))
+    return;
+  await sm2_exports.initRNGPool();
+  Reflect.defineMetadata(metadataKey, true, constructor);
+}
+__name(initRNGPool2, "initRNGPool");
+var _SM2 = class _SM2 extends AsymmetricEncryption {
+  options = {
+    cipherMode: 1,
+    signatureSM3Hash: true,
+    signatureUserId: void 0
+  };
+  createPrivateKey(privateKeyString) {
+    return privateKeyString;
+  }
+  createPublicKey(publicKeyString) {
+    return publicKeyString;
+  }
+  decrypt(encryptedMessage) {
+    return sm2_exports.doDecrypt(Buffer.from(encryptedMessage, "base64").toString("hex"), this.privateKey, this.options.cipherMode, { output: "string" });
+  }
+  encrypt(message) {
+    return Buffer.from(sm2_exports.doEncrypt(message, this.publicKey, this.options.cipherMode), "hex").toString("base64");
+  }
+  async generateKeyPair(options) {
+    let { publicKey, privateKey } = sm2_exports.generateKeyPairHex();
+    if (options == null ? void 0 : options.compressPublicKey)
+      publicKey = sm2_exports.compressPublicKeyHex(publicKey);
+    return {
+      publicKey,
+      privateKey
+    };
+  }
+  sign(message) {
+    return Buffer.from(sm2_exports.doSignature(message, this.privateKey, {
+      hash: this.options.signatureSM3Hash,
+      publicKey: this.publicKey ? this.publicKey : void 0,
+      userId: this.options.signatureUserId
+    }), "hex").toString("base64");
+  }
+  verify(message, sign) {
+    return sm2_exports.doVerifySignature(message, Buffer.from(sign, "base64").toString("hex"), this.publicKey, {
+      hash: this.options.signatureSM3Hash,
+      userId: this.options.signatureUserId
+    });
+  }
+  static async generateKeyPair(options) {
+    await initRNGPool2(this);
+    return super.generateKeyPair(options);
+  }
+  static async loadKeyPair(keyPair, options) {
+    await initRNGPool2(this);
+    return As(super.loadKeyPair(keyPair, options));
+  }
+  static async loadPublicKey(inp, options) {
+    await initRNGPool2(this);
+    return super.loadPublicKey(inp, options);
+  }
+  static async loadPrivateKey(inp, options) {
+    await initRNGPool2(this);
+    return super.loadPrivateKey(inp, options);
+  }
+};
+__name(_SM2, "SM2");
+var SM2 = _SM2;
+/*! Bundled license information:
+
+@noble/curves/esm/abstract/utils.js:
+  (*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) *)
+
+@noble/curves/esm/abstract/modular.js:
+  (*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) *)
+
+@noble/curves/esm/abstract/curve.js:
+  (*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) *)
+
+@noble/curves/esm/abstract/weierstrass.js:
+  (*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) *)
+
+sm-crypto-v2/dist/index.mjs:
+  (*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) *)
+*/
+
+export { SM2 };
+//# sourceMappingURL=out.js.map
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["../src/lib/crypto/SM2.ts","../node_modules/sm-crypto-v2/dist/index.mjs","../node_modules/@noble/curves/src/abstract/utils.ts","../node_modules/@noble/curves/src/abstract/weierstrass.ts","../node_modules/@noble/curves/src/abstract/modular.ts","../node_modules/@noble/curves/src/abstract/curve.ts"],"names":["_0n","_1n","_2n","x","field","tmp","bitLen","isLE","s","_3n","_4n","toBytes","x2","a","randomBytes","_a","r","__export","u8a","hexes","bytesToHex","utf8ToBytes","initRNGPool"],"mappings":"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ACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF,CAAC;AACD,IAAI,KAAK,IAAI,YAAY;AAAA,EACvB;AAAA,EACA;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","sourcesContent":["import 'reflect-metadata'\nimport {\n    AsymmetricEncryption,\n    AsymmetricEncryptionKeyPair, AsymmetricEncryptionPrivate,\n    AsymmetricEncryptionPublic\n} from '../base/abstracts/AsymmetricEncryption.js'\nimport {sm2} from 'sm-crypto-v2'\nimport {As} from '../../Utilities.js'\nimport {PathLike} from 'fs'\nimport {IConstructor} from '../../interfaces/IConstructor.js'\n\nasync function initRNGPool(constructor: IConstructor<SM2>): Promise<void> {\n    const metadataKey: string = '__$$RNGPoolInitialized'\n    if (Reflect.getOwnMetadata(metadataKey, constructor)) return\n    await sm2.initRNGPool()\n    Reflect.defineMetadata(metadataKey, true, constructor)\n}\n\nexport interface SM2KeyPairOptions {\n    /**\n     * 是否将公钥长度进行压缩，从默认公钥的130位压缩至66位\n     * @default false\n     */\n    compressPublicKey?: boolean\n}\n\nexport interface SM2Options {\n    /**\n     * 加密模式\n     * 0 - C1C2C3\n     * 1 - C1C3C2\n     * @default 1\n     */\n    cipherMode?: 0 | 1\n    /**\n     * 是否在签名或验签当中使用SM3杂凑\n     * @default true\n     */\n    signatureSM3Hash?: boolean\n    /**\n     * 在签名或验签当中使用的用户标识\n     * @default undefined\n     */\n    signatureUserId?: string\n}\n\nexport class SM2 extends AsymmetricEncryption {\n\n    protected options: SM2Options = {\n        cipherMode: 1,\n        signatureSM3Hash: true,\n        signatureUserId: undefined\n    }\n\n    protected createPrivateKey(privateKeyString: string): string {\n        return privateKeyString\n    }\n\n    protected createPublicKey(publicKeyString: string): string {\n        return publicKeyString\n    }\n\n    protected decrypt(encryptedMessage: string): string {\n        return sm2.doDecrypt(Buffer.from(encryptedMessage, 'base64').toString('hex'), this.privateKey, this.options.cipherMode, {output: 'string'})\n    }\n\n    protected encrypt(message: string): string {\n        return Buffer.from(sm2.doEncrypt(message, this.publicKey, this.options.cipherMode), 'hex').toString('base64')\n    }\n\n    protected async generateKeyPair(options?: SM2KeyPairOptions): Promise<AsymmetricEncryptionKeyPair> {\n        let {publicKey, privateKey} = sm2.generateKeyPairHex()\n        if (options?.compressPublicKey) publicKey = sm2.compressPublicKeyHex(publicKey)\n        return {\n            publicKey: publicKey,\n            privateKey: privateKey\n        }\n    }\n\n    protected sign(message: string): string {\n        return Buffer.from(sm2.doSignature(message, this.privateKey, {\n            hash: this.options.signatureSM3Hash,\n            publicKey: this.publicKey ? this.publicKey : undefined,\n            userId: this.options.signatureUserId\n        }), 'hex').toString('base64')\n    }\n\n    protected verify(message: string, sign: string): boolean {\n        return sm2.doVerifySignature(message, Buffer.from(sign, 'base64').toString('hex'), this.publicKey, {\n            hash: this.options.signatureSM3Hash,\n            userId: this.options.signatureUserId\n        })\n    }\n\n    public static async generateKeyPair(options?: SM2KeyPairOptions): Promise<AsymmetricEncryptionKeyPair> {\n        await initRNGPool(this)\n        return super.generateKeyPair(options)\n    }\n\n    public static async loadKeyPair<T extends AsymmetricEncryption = SM2>(keyPair: AsymmetricEncryptionKeyPair, options?: SM2Options): Promise<T> {\n        await initRNGPool(this)\n        return As<T>(super.loadKeyPair<SM2>(keyPair, options))\n    }\n\n    public static async loadPublicKey(inp: PathLike | string, options?: SM2Options): Promise<AsymmetricEncryptionPublic> {\n        await initRNGPool(this)\n        return super.loadPublicKey(inp, options)\n    }\n\n    public static async loadPrivateKey(inp: string | PathLike, options?: SM2Options): Promise<AsymmetricEncryptionPrivate> {\n        await initRNGPool(this)\n        return super.loadPrivateKey(inp, options)\n    }\n}\n","var __defProp = Object.defineProperty;\nvar __export = (target, all) => {\n  for (var name in all)\n    __defProp(target, name, { get: all[name], enumerable: true });\n};\n\n// src/sm2/index.ts\nvar sm2_exports = {};\n__export(sm2_exports, {\n  EmptyArray: () => EmptyArray,\n  arrayToHex: () => arrayToHex,\n  arrayToUtf8: () => arrayToUtf8,\n  calculateSharedKey: () => calculateSharedKey,\n  comparePublicKeyHex: () => comparePublicKeyHex,\n  compressPublicKeyHex: () => compressPublicKeyHex,\n  doDecrypt: () => doDecrypt,\n  doEncrypt: () => doEncrypt,\n  doSignature: () => doSignature,\n  doVerifySignature: () => doVerifySignature,\n  generateKeyPairHex: () => generateKeyPairHex,\n  getHash: () => getHash,\n  getPoint: () => getPoint,\n  getPublicKeyFromPrivateKey: () => getPublicKeyFromPrivateKey,\n  getZ: () => getZ,\n  hexToArray: () => hexToArray,\n  initRNGPool: () => initRNGPool,\n  leftPad: () => leftPad,\n  precomputePublicKey: () => precomputePublicKey,\n  utf8ToHex: () => utf8ToHex,\n  verifyPublicKey: () => verifyPublicKey\n});\n\n// src/sm2/asn1.ts\nimport * as utils from \"@noble/curves/abstract/utils\";\n\n// src/sm2/bn.ts\nvar ZERO = BigInt(0);\nvar ONE = BigInt(1);\nvar TWO = BigInt(2);\nvar THREE = BigInt(3);\n\n// src/sm2/asn1.ts\nfunction bigintToValue(bigint) {\n  let h = bigint.toString(16);\n  if (h[0] !== \"-\") {\n    if (h.length % 2 === 1)\n      h = \"0\" + h;\n    else if (!h.match(/^[0-7]/))\n      h = \"00\" + h;\n  } else {\n    h = h.substring(1);\n    let len = h.length;\n    if (len % 2 === 1)\n      len += 1;\n    else if (!h.match(/^[0-7]/))\n      len += 2;\n    let maskString = \"\";\n    for (let i = 0; i < len; i++)\n      maskString += \"f\";\n    let mask = utils.hexToNumber(maskString);\n    let output = (mask ^ bigint) + ONE;\n    h = output.toString(16).replace(/^-/, \"\");\n  }\n  return h;\n}\nvar ASN1Object = class {\n  constructor(tlv = null, t = \"00\", l = \"00\", v = \"\") {\n    this.tlv = tlv;\n    this.t = t;\n    this.l = l;\n    this.v = v;\n  }\n  getEncodedHex() {\n    if (!this.tlv) {\n      this.v = this.getValue();\n      this.l = this.getLength();\n      this.tlv = this.t + this.l + this.v;\n    }\n    return this.tlv;\n  }\n  getLength() {\n    const n = this.v.length / 2;\n    let nHex = n.toString(16);\n    if (nHex.length % 2 === 1)\n      nHex = \"0\" + nHex;\n    if (n < 128) {\n      return nHex;\n    } else {\n      const head = 128 + nHex.length / 2;\n      return head.toString(16) + nHex;\n    }\n  }\n  getValue() {\n    return \"\";\n  }\n};\nvar DERInteger = class extends ASN1Object {\n  constructor(bigint) {\n    super();\n    this.t = \"02\";\n    if (bigint)\n      this.v = bigintToValue(bigint);\n  }\n  getValue() {\n    return this.v;\n  }\n};\nvar DERSequence = class extends ASN1Object {\n  constructor(asn1Array) {\n    super();\n    this.asn1Array = asn1Array;\n  }\n  t = \"30\";\n  getValue() {\n    this.v = this.asn1Array.map((asn1Object) => asn1Object.getEncodedHex()).join(\"\");\n    return this.v;\n  }\n};\nfunction getLenOfL(str, start) {\n  if (+str[start + 2] < 8)\n    return 1;\n  return +str.substring(start + 2, start + 4) & 127 + 1;\n}\nfunction getL(str, start) {\n  const len = getLenOfL(str, start);\n  const l = str.substring(start + 2, start + 2 + len * 2);\n  if (!l)\n    return -1;\n  const bigint = +l[0] < 8 ? utils.hexToNumber(l) : utils.hexToNumber(l.substring(2));\n  return +bigint.toString();\n}\nfunction getStartOfV(str, start) {\n  const len = getLenOfL(str, start);\n  return start + (len + 1) * 2;\n}\nfunction encodeDer(r, s) {\n  const derR = new DERInteger(r);\n  const derS = new DERInteger(s);\n  const derSeq = new DERSequence([derR, derS]);\n  return derSeq.getEncodedHex();\n}\nfunction decodeDer(input) {\n  const start = getStartOfV(input, 0);\n  const vIndexR = getStartOfV(input, start);\n  const lR = getL(input, start);\n  const vR = input.substr(vIndexR, lR * 2);\n  const nextStart = vIndexR + vR.length;\n  const vIndexS = getStartOfV(input, nextStart);\n  const lS = getL(input, nextStart);\n  const vS = input.substring(vIndexS, vIndexS + lS * 2);\n  const r = utils.hexToNumber(vR);\n  const s = utils.hexToNumber(vS);\n  return { r, s };\n}\n\n// src/sm2/utils.ts\nimport * as utils2 from \"@noble/curves/abstract/utils\";\n\n// src/sm2/ec.ts\nimport { weierstrass } from \"@noble/curves/abstract/weierstrass\";\nimport { Field } from \"@noble/curves/abstract/modular\";\n\n// src/sm2/rng.ts\nvar DEFAULT_PRNG_POOL_SIZE = 16384;\nvar prngPool = new Uint8Array(0);\nvar _syncCrypto;\nasync function initRNGPool() {\n  if (\"crypto\" in globalThis) {\n    _syncCrypto = globalThis.crypto;\n    return;\n  }\n  if (prngPool.length > DEFAULT_PRNG_POOL_SIZE / 2)\n    return;\n  if (\"wx\" in globalThis && \"getRandomValues\" in globalThis.wx) {\n    prngPool = await new Promise((r) => {\n      wx.getRandomValues({\n        length: DEFAULT_PRNG_POOL_SIZE,\n        success(res) {\n          r(new Uint8Array(res.randomValues));\n        }\n      });\n    });\n  } else {\n    try {\n      if (globalThis.crypto) {\n        _syncCrypto = globalThis.crypto;\n      } else {\n        const crypto = await import(\n          /* webpackIgnore: true */\n          \"crypto\"\n        );\n        _syncCrypto = crypto.webcrypto;\n      }\n      const array = new Uint8Array(DEFAULT_PRNG_POOL_SIZE);\n      _syncCrypto.getRandomValues(array);\n      prngPool = array;\n    } catch (error) {\n      throw new Error(\"no available csprng, abort.\");\n    }\n  }\n}\ninitRNGPool();\nfunction consumePool(length) {\n  if (prngPool.length > length) {\n    const prng = prngPool.slice(0, length);\n    prngPool = prngPool.slice(length);\n    initRNGPool();\n    return prng;\n  } else {\n    throw new Error(\"random number pool is not ready or insufficient, prevent getting too long random values or too often.\");\n  }\n}\nfunction randomBytes(length = 0) {\n  const array = new Uint8Array(length);\n  if (_syncCrypto) {\n    return _syncCrypto.getRandomValues(array);\n  } else {\n    const result = consumePool(length);\n    return result;\n  }\n}\n\n// src/sm3/utils.ts\nvar u8a = (a) => a instanceof Uint8Array;\nvar createView = (arr) => new DataView(arr.buffer, arr.byteOffset, arr.byteLength);\nvar isLE = new Uint8Array(new Uint32Array([287454020]).buffer)[0] === 68;\nif (!isLE)\n  throw new Error(\"Non little-endian hardware is not supported\");\nvar hexes = Array.from({ length: 256 }, (v, i) => i.toString(16).padStart(2, \"0\"));\nfunction bytesToHex(bytes) {\n  if (!u8a(bytes))\n    throw new Error(\"Uint8Array expected\");\n  let hex = \"\";\n  for (let i = 0; i < bytes.length; i++) {\n    hex += hexes[bytes[i]];\n  }\n  return hex;\n}\nfunction utf8ToBytes(str) {\n  if (typeof str !== \"string\")\n    throw new Error(`utf8ToBytes expected string, got ${typeof str}`);\n  return new Uint8Array(new TextEncoder().encode(str));\n}\nfunction toBytes(data) {\n  if (typeof data === \"string\")\n    data = utf8ToBytes(data);\n  if (!u8a(data))\n    throw new Error(`expected Uint8Array, got ${typeof data}`);\n  return data;\n}\nvar Hash = class {\n  clone() {\n    return this._cloneInto();\n  }\n};\nfunction wrapConstructor(hashCons) {\n  const hashC = (msg) => hashCons().update(toBytes(msg)).digest();\n  const tmp2 = hashCons();\n  hashC.outputLen = tmp2.outputLen;\n  hashC.blockLen = tmp2.blockLen;\n  hashC.create = () => hashCons();\n  return hashC;\n}\n\n// src/sm2/sm3.ts\nvar BoolA = (A, B, C) => A & B | A & C | B & C;\nvar BoolB = (A, B, C) => A ^ B ^ C;\nvar BoolC = (A, B, C) => A & B | ~A & C;\nfunction setBigUint64(view, byteOffset, value, isLE2) {\n  if (typeof view.setBigUint64 === \"function\")\n    return view.setBigUint64(byteOffset, value, isLE2);\n  const _32n = BigInt(32);\n  const _u32_max = BigInt(4294967295);\n  const wh = Number(value >> _32n & _u32_max);\n  const wl = Number(value & _u32_max);\n  const h = isLE2 ? 4 : 0;\n  const l = isLE2 ? 0 : 4;\n  view.setUint32(byteOffset + h, wh, isLE2);\n  view.setUint32(byteOffset + l, wl, isLE2);\n}\nfunction rotl(x2, n) {\n  const s = n & 31;\n  return x2 << s | x2 >>> 32 - s;\n}\nfunction P0(X) {\n  return X ^ rotl(X, 9) ^ rotl(X, 17);\n}\nfunction P1(X) {\n  return X ^ rotl(X, 15) ^ rotl(X, 23);\n}\nvar SHA2 = class extends Hash {\n  constructor(blockLen, outputLen, padOffset, isLE2) {\n    super();\n    this.blockLen = blockLen;\n    this.outputLen = outputLen;\n    this.padOffset = padOffset;\n    this.isLE = isLE2;\n    this.buffer = new Uint8Array(blockLen);\n    this.view = createView(this.buffer);\n  }\n  buffer;\n  view;\n  finished = false;\n  length = 0;\n  pos = 0;\n  destroyed = false;\n  update(data) {\n    const { view, buffer, blockLen } = this;\n    data = toBytes(data);\n    const len = data.length;\n    for (let pos = 0; pos < len; ) {\n      const take = Math.min(blockLen - this.pos, len - pos);\n      if (take === blockLen) {\n        const dataView = createView(data);\n        for (; blockLen <= len - pos; pos += blockLen)\n          this.process(dataView, pos);\n        continue;\n      }\n      buffer.set(data.subarray(pos, pos + take), this.pos);\n      this.pos += take;\n      pos += take;\n      if (this.pos === blockLen) {\n        this.process(view, 0);\n        this.pos = 0;\n      }\n    }\n    this.length += data.length;\n    this.roundClean();\n    return this;\n  }\n  digestInto(out) {\n    this.finished = true;\n    const { buffer, view, blockLen, isLE: isLE2 } = this;\n    let { pos } = this;\n    buffer[pos++] = 128;\n    this.buffer.subarray(pos).fill(0);\n    if (this.padOffset > blockLen - pos) {\n      this.process(view, 0);\n      pos = 0;\n    }\n    for (let i = pos; i < blockLen; i++)\n      buffer[i] = 0;\n    setBigUint64(view, blockLen - 8, BigInt(this.length * 8), isLE2);\n    this.process(view, 0);\n    const oview = createView(out);\n    const len = this.outputLen;\n    if (len % 4)\n      throw new Error(\"_sha2: outputLen should be aligned to 32bit\");\n    const outLen = len / 4;\n    const state = this.get();\n    if (outLen > state.length)\n      throw new Error(\"_sha2: outputLen bigger than state\");\n    for (let i = 0; i < outLen; i++)\n      oview.setUint32(4 * i, state[i], isLE2);\n  }\n  digest() {\n    const { buffer, outputLen } = this;\n    this.digestInto(buffer);\n    const res = buffer.slice(0, outputLen);\n    this.destroy();\n    return res;\n  }\n  _cloneInto(to) {\n    to ||= new this.constructor();\n    to.set(...this.get());\n    const { blockLen, buffer, length, finished, destroyed, pos } = this;\n    to.length = length;\n    to.pos = pos;\n    to.finished = finished;\n    to.destroyed = destroyed;\n    if (length % blockLen)\n      to.buffer.set(buffer);\n    return to;\n  }\n};\nvar IV = new Uint32Array([1937774191, 1226093241, 388252375, 3666478592, 2842636476, 372324522, 3817729613, 2969243214]);\nvar SM3_W = new Uint32Array(68);\nvar SM3_M = new Uint32Array(64);\nvar T1 = 2043430169;\nvar T2 = 2055708042;\nvar SM3 = class extends SHA2 {\n  A = IV[0] | 0;\n  B = IV[1] | 0;\n  C = IV[2] | 0;\n  D = IV[3] | 0;\n  E = IV[4] | 0;\n  F = IV[5] | 0;\n  G = IV[6] | 0;\n  H = IV[7] | 0;\n  constructor() {\n    super(64, 32, 8, false);\n  }\n  get() {\n    const { A, B, C, D, E, F, G, H } = this;\n    return [A, B, C, D, E, F, G, H];\n  }\n  set(A, B, C, D, E, F, G, H) {\n    this.A = A | 0;\n    this.B = B | 0;\n    this.C = C | 0;\n    this.D = D | 0;\n    this.E = E | 0;\n    this.F = F | 0;\n    this.G = G | 0;\n    this.H = H | 0;\n  }\n  process(view, offset) {\n    for (let i = 0; i < 16; i++, offset += 4)\n      SM3_W[i] = view.getUint32(offset, false);\n    for (let i = 16; i < 68; i++) {\n      SM3_W[i] = P1(SM3_W[i - 16] ^ SM3_W[i - 9] ^ rotl(SM3_W[i - 3], 15)) ^ rotl(SM3_W[i - 13], 7) ^ SM3_W[i - 6];\n    }\n    for (let i = 0; i < 64; i++) {\n      SM3_M[i] = SM3_W[i] ^ SM3_W[i + 4];\n    }\n    let { A, B, C, D, E, F, G, H } = this;\n    for (let j = 0; j < 64; j++) {\n      let small = j >= 0 && j <= 15;\n      let T = small ? T1 : T2;\n      let SS1 = rotl(rotl(A, 12) + E + rotl(T, j), 7);\n      let SS2 = SS1 ^ rotl(A, 12);\n      let TT1 = (small ? BoolB(A, B, C) : BoolA(A, B, C)) + D + SS2 + SM3_M[j] | 0;\n      let TT2 = (small ? BoolB(E, F, G) : BoolC(E, F, G)) + H + SS1 + SM3_W[j] | 0;\n      D = C;\n      C = rotl(B, 9);\n      B = A;\n      A = TT1;\n      H = G;\n      G = rotl(F, 19);\n      F = E;\n      E = P0(TT2);\n    }\n    A = A ^ this.A | 0;\n    B = B ^ this.B | 0;\n    C = C ^ this.C | 0;\n    D = D ^ this.D | 0;\n    E = E ^ this.E | 0;\n    F = F ^ this.F | 0;\n    G = G ^ this.G | 0;\n    H = H ^ this.H | 0;\n    this.set(A, B, C, D, E, F, G, H);\n  }\n  roundClean() {\n    SM3_W.fill(0);\n  }\n  destroy() {\n    this.set(0, 0, 0, 0, 0, 0, 0, 0);\n    this.buffer.fill(0);\n  }\n};\nvar sm3 = wrapConstructor(() => new SM3());\n\n// src/sm2/hmac.ts\nvar HMAC = class extends Hash {\n  oHash;\n  iHash;\n  blockLen;\n  outputLen;\n  finished = false;\n  destroyed = false;\n  constructor(hash, _key) {\n    super();\n    const key = toBytes(_key);\n    this.iHash = hash.create();\n    if (typeof this.iHash.update !== \"function\")\n      throw new Error(\"Expected instance of class which extends utils.Hash\");\n    this.blockLen = this.iHash.blockLen;\n    this.outputLen = this.iHash.outputLen;\n    const blockLen = this.blockLen;\n    const pad = new Uint8Array(blockLen);\n    pad.set(key.length > blockLen ? hash.create().update(key).digest() : key);\n    for (let i = 0; i < pad.length; i++)\n      pad[i] ^= 54;\n    this.iHash.update(pad);\n    this.oHash = hash.create();\n    for (let i = 0; i < pad.length; i++)\n      pad[i] ^= 54 ^ 92;\n    this.oHash.update(pad);\n    pad.fill(0);\n  }\n  update(buf) {\n    this.iHash.update(buf);\n    return this;\n  }\n  digestInto(out) {\n    this.finished = true;\n    this.iHash.digestInto(out);\n    this.oHash.update(out);\n    this.oHash.digestInto(out);\n    this.destroy();\n  }\n  digest() {\n    const out = new Uint8Array(this.oHash.outputLen);\n    this.digestInto(out);\n    return out;\n  }\n  _cloneInto(to) {\n    to ||= Object.create(Object.getPrototypeOf(this), {});\n    const { oHash, iHash, finished, destroyed, blockLen, outputLen } = this;\n    to = to;\n    to.finished = finished;\n    to.destroyed = destroyed;\n    to.blockLen = blockLen;\n    to.outputLen = outputLen;\n    to.oHash = oHash._cloneInto(to.oHash);\n    to.iHash = iHash._cloneInto(to.iHash);\n    return to;\n  }\n  destroy() {\n    this.destroyed = true;\n    this.oHash.destroy();\n    this.iHash.destroy();\n  }\n};\nvar hmac = (hash, key, message) => new HMAC(hash, key).update(message).digest();\nhmac.create = (hash, key) => new HMAC(hash, key);\n\n// src/sm2/ec.ts\nimport { concatBytes } from \"@noble/curves/abstract/utils\";\nvar sm2Fp = Field(BigInt(\"115792089210356248756420345214020892766250353991924191454421193933289684991999\"));\nvar sm2Curve = weierstrass({\n  a: BigInt(\"115792089210356248756420345214020892766250353991924191454421193933289684991996\"),\n  b: BigInt(\"18505919022281880113072981827955639221458448578012075254857346196103069175443\"),\n  Fp: sm2Fp,\n  h: ONE,\n  n: BigInt(\"115792089210356248756420345214020892766061623724957744567843809356293439045923\"),\n  Gx: BigInt(\"22963146547237050559479531362550074578802567295341616970375194840604139615431\"),\n  Gy: BigInt(\"85132369209828568825618990617112496413088388631904505083283536607588877201568\"),\n  hash: sm3,\n  hmac: (key, ...msgs) => hmac(sm3, key, concatBytes(...msgs)),\n  randomBytes\n});\nvar field = Field(BigInt(sm2Curve.CURVE.n));\n\n// src/sm2/utils.ts\nimport { mod } from \"@noble/curves/abstract/modular\";\nfunction generateKeyPairHex(str) {\n  const privateKey = str ? utils2.numberToBytesBE(mod(BigInt(str), ONE) + ONE, 32) : sm2Curve.utils.randomPrivateKey();\n  const publicKey = sm2Curve.getPublicKey(privateKey, false);\n  const privPad = leftPad(utils2.bytesToHex(privateKey), 64);\n  const pubPad = leftPad(utils2.bytesToHex(publicKey), 64);\n  return { privateKey: privPad, publicKey: pubPad };\n}\nfunction compressPublicKeyHex(s) {\n  if (s.length !== 130)\n    throw new Error(\"Invalid public key to compress\");\n  const len = (s.length - 2) / 2;\n  const xHex = s.substring(2, 2 + len);\n  const y = utils2.hexToNumber(s.substring(len + 2, len + len + 2));\n  let prefix = \"03\";\n  if (mod(y, TWO) === ZERO)\n    prefix = \"02\";\n  return prefix + xHex;\n}\nfunction utf8ToHex(input) {\n  input = decodeURIComponent(encodeURIComponent(input));\n  const length = input.length;\n  const words = new Uint32Array((length >>> 2) + 1);\n  for (let i = 0; i < length; i++) {\n    words[i >>> 2] |= (input.charCodeAt(i) & 255) << 24 - i % 4 * 8;\n  }\n  const hexChars = [];\n  for (let i = 0; i < length; i++) {\n    const bite = words[i >>> 2] >>> 24 - i % 4 * 8 & 255;\n    hexChars.push((bite >>> 4).toString(16));\n    hexChars.push((bite & 15).toString(16));\n  }\n  return hexChars.join(\"\");\n}\nfunction leftPad(input, num) {\n  if (input.length >= num)\n    return input;\n  return new Array(num - input.length + 1).join(\"0\") + input;\n}\nfunction arrayToHex(arr) {\n  return arr.map((item) => {\n    const hex = item.toString(16);\n    return hex.length === 1 ? \"0\" + hex : hex;\n  }).join(\"\");\n}\nfunction arrayToUtf8(arr) {\n  const str = [];\n  for (let i = 0, len = arr.length; i < len; i++) {\n    if (arr[i] >= 240 && arr[i] <= 247) {\n      str.push(String.fromCodePoint(((arr[i] & 7) << 18) + ((arr[i + 1] & 63) << 12) + ((arr[i + 2] & 63) << 6) + (arr[i + 3] & 63)));\n      i += 3;\n    } else if (arr[i] >= 224 && arr[i] <= 239) {\n      str.push(String.fromCodePoint(((arr[i] & 15) << 12) + ((arr[i + 1] & 63) << 6) + (arr[i + 2] & 63)));\n      i += 2;\n    } else if (arr[i] >= 192 && arr[i] <= 223) {\n      str.push(String.fromCodePoint(((arr[i] & 31) << 6) + (arr[i + 1] & 63)));\n      i++;\n    } else {\n      str.push(String.fromCodePoint(arr[i]));\n    }\n  }\n  return str.join(\"\");\n}\nfunction hexToArray(hexStr) {\n  let hexStrLength = hexStr.length;\n  if (hexStrLength % 2 !== 0) {\n    hexStr = leftPad(hexStr, hexStrLength + 1);\n  }\n  hexStrLength = hexStr.length;\n  const wordLength = hexStrLength / 2;\n  const words = new Uint8Array(wordLength);\n  for (let i = 0; i < wordLength; i++) {\n    words[i] = parseInt(hexStr.substring(i * 2, i * 2 + 2), 16);\n  }\n  return words;\n}\nfunction verifyPublicKey(publicKey) {\n  const point = sm2Curve.ProjectivePoint.fromHex(publicKey);\n  if (!point)\n    return false;\n  try {\n    point.assertValidity();\n    return true;\n  } catch (error) {\n    return false;\n  }\n}\nfunction comparePublicKeyHex(publicKey1, publicKey2) {\n  const point1 = sm2Curve.ProjectivePoint.fromHex(publicKey1);\n  if (!point1)\n    return false;\n  const point2 = sm2Curve.ProjectivePoint.fromHex(publicKey2);\n  if (!point2)\n    return false;\n  return point1.equals(point2);\n}\n\n// src/sm2/index.ts\nimport * as utils4 from \"@noble/curves/abstract/utils\";\n\n// src/sm2/kx.ts\nimport * as utils3 from \"@noble/curves/abstract/utils\";\nvar wPow2 = utils3.hexToNumber(\"80000000000000000000000000000000\");\nvar wPow2Sub1 = utils3.hexToNumber(\"7fffffffffffffffffffffffffffffff\");\nfunction hkdf(z, keylen) {\n  let msg = new Uint8Array(keylen);\n  let ct = 1;\n  let offset = 0;\n  let t = EmptyArray;\n  const ctShift = new Uint8Array(4);\n  const nextT = () => {\n    ctShift[0] = ct >> 24 & 255;\n    ctShift[1] = ct >> 16 & 255;\n    ctShift[2] = ct >> 8 & 255;\n    ctShift[3] = ct & 255;\n    t = sm3(utils3.concatBytes(z, ctShift));\n    ct++;\n    offset = 0;\n  };\n  nextT();\n  for (let i = 0, len = msg.length; i < len; i++) {\n    if (offset === t.length)\n      nextT();\n    msg[i] = t[offset++] & 255;\n  }\n  return msg;\n}\nfunction calculateSharedKey(keypairA, ephemeralKeypairA, publicKeyB, ephemeralPublicKeyB, sharedKeyLength, isRecipient = false, idA = \"1234567812345678\", idB = \"1234567812345678\") {\n  const RA = sm2Curve.ProjectivePoint.fromHex(ephemeralKeypairA.publicKey);\n  const RB = sm2Curve.ProjectivePoint.fromHex(ephemeralPublicKeyB);\n  const PB = sm2Curve.ProjectivePoint.fromHex(publicKeyB);\n  let ZA = getZ(keypairA.publicKey, idA);\n  let ZB = getZ(publicKeyB, idB);\n  if (isRecipient) {\n    [ZA, ZB] = [ZB, ZA];\n  }\n  const rA = utils3.hexToNumber(ephemeralKeypairA.privateKey);\n  const dA = utils3.hexToNumber(keypairA.privateKey);\n  const x1 = RA.x;\n  const x1_ = wPow2 + (x1 & wPow2Sub1);\n  const tA = field.add(dA, field.mulN(x1_, rA));\n  const x2 = RB.x;\n  const x2_ = field.add(wPow2, x2 & wPow2Sub1);\n  const U = RB.multiply(x2_).add(PB).multiply(tA);\n  const xU = hexToArray(leftPad(utils3.numberToHexUnpadded(U.x), 64));\n  const yU = hexToArray(leftPad(utils3.numberToHexUnpadded(U.y), 64));\n  const KA = hkdf(utils3.concatBytes(xU, yU, ZA, ZB), sharedKeyLength);\n  return KA;\n}\n\n// src/sm2/index.ts\nvar C1C2C3 = 0;\nvar EmptyArray = new Uint8Array();\nfunction doEncrypt(msg, publicKey, cipherMode = 1) {\n  const msgArr = typeof msg === \"string\" ? hexToArray(utf8ToHex(msg)) : Uint8Array.from(msg);\n  const publicKeyPoint = typeof publicKey === \"string\" ? sm2Curve.ProjectivePoint.fromHex(publicKey) : publicKey;\n  const keypair = generateKeyPairHex();\n  const k = utils4.hexToNumber(keypair.privateKey);\n  let c1 = keypair.publicKey;\n  if (c1.length > 128)\n    c1 = c1.substring(c1.length - 128);\n  const p = publicKeyPoint.multiply(k);\n  const x2 = hexToArray(leftPad(utils4.numberToHexUnpadded(p.x), 64));\n  const y2 = hexToArray(leftPad(utils4.numberToHexUnpadded(p.y), 64));\n  const c3 = bytesToHex(sm3(utils4.concatBytes(x2, msgArr, y2)));\n  xorCipherStream(x2, y2, msgArr);\n  const c2 = bytesToHex(msgArr);\n  return cipherMode === C1C2C3 ? c1 + c2 + c3 : c1 + c3 + c2;\n}\nfunction xorCipherStream(x2, y2, msg) {\n  let ct = 1;\n  let offset = 0;\n  let t = EmptyArray;\n  const ctShift = new Uint8Array(4);\n  const nextT = () => {\n    ctShift[0] = ct >> 24 & 255;\n    ctShift[1] = ct >> 16 & 255;\n    ctShift[2] = ct >> 8 & 255;\n    ctShift[3] = ct & 255;\n    t = sm3(utils4.concatBytes(x2, y2, ctShift));\n    ct++;\n    offset = 0;\n  };\n  nextT();\n  for (let i = 0, len = msg.length; i < len; i++) {\n    if (offset === t.length)\n      nextT();\n    msg[i] ^= t[offset++] & 255;\n  }\n}\nfunction doDecrypt(encryptData, privateKey, cipherMode = 1, {\n  output = \"string\"\n} = {}) {\n  const privateKeyInteger = utils4.hexToNumber(privateKey);\n  let c3 = encryptData.substring(128, 128 + 64);\n  let c2 = encryptData.substring(128 + 64);\n  if (cipherMode === C1C2C3) {\n    c3 = encryptData.substring(encryptData.length - 64);\n    c2 = encryptData.substring(128, encryptData.length - 64);\n  }\n  const msg = hexToArray(c2);\n  const c1 = sm2Curve.ProjectivePoint.fromHex(\"04\" + encryptData.substring(0, 128));\n  const p = c1.multiply(privateKeyInteger);\n  const x2 = hexToArray(leftPad(utils4.numberToHexUnpadded(p.x), 64));\n  const y2 = hexToArray(leftPad(utils4.numberToHexUnpadded(p.y), 64));\n  xorCipherStream(x2, y2, msg);\n  const checkC3 = arrayToHex(Array.from(sm3(utils4.concatBytes(x2, msg, y2))));\n  if (checkC3 === c3.toLowerCase()) {\n    return output === \"array\" ? msg : arrayToUtf8(msg);\n  } else {\n    return output === \"array\" ? [] : \"\";\n  }\n}\nfunction doSignature(msg, privateKey, options = {}) {\n  let {\n    pointPool,\n    der,\n    hash,\n    publicKey,\n    userId\n  } = options;\n  let hashHex = typeof msg === \"string\" ? utf8ToHex(msg) : arrayToHex(Array.from(msg));\n  if (hash) {\n    publicKey = publicKey || getPublicKeyFromPrivateKey(privateKey);\n    hashHex = getHash(hashHex, publicKey, userId);\n  }\n  const dA = utils4.hexToNumber(privateKey);\n  const e = utils4.hexToNumber(hashHex);\n  let k = null;\n  let r = null;\n  let s = null;\n  do {\n    do {\n      let point;\n      if (pointPool && pointPool.length) {\n        point = pointPool.pop();\n      } else {\n        point = getPoint();\n      }\n      k = point.k;\n      r = field.add(e, point.x1);\n    } while (r === ZERO || r + k === sm2Curve.CURVE.n);\n    s = field.mul(field.inv(field.addN(dA, ONE)), field.subN(k, field.mulN(r, dA)));\n  } while (s === ZERO);\n  if (der)\n    return encodeDer(r, s);\n  return leftPad(utils4.numberToHexUnpadded(r), 64) + leftPad(utils4.numberToHexUnpadded(s), 64);\n}\nfunction doVerifySignature(msg, signHex, publicKey, options = {}) {\n  let hashHex;\n  const {\n    hash,\n    der,\n    userId\n  } = options;\n  const publicKeyHex = typeof publicKey === \"string\" ? publicKey : publicKey.toHex(false);\n  if (hash) {\n    hashHex = getHash(typeof msg === \"string\" ? utf8ToHex(msg) : msg, publicKeyHex, userId);\n  } else {\n    hashHex = typeof msg === \"string\" ? utf8ToHex(msg) : arrayToHex(Array.from(msg));\n  }\n  let r;\n  let s;\n  if (der) {\n    const decodeDerObj = decodeDer(signHex);\n    r = decodeDerObj.r;\n    s = decodeDerObj.s;\n  } else {\n    r = utils4.hexToNumber(signHex.substring(0, 64));\n    s = utils4.hexToNumber(signHex.substring(64));\n  }\n  const PA = typeof publicKey === \"string\" ? sm2Curve.ProjectivePoint.fromHex(publicKey) : publicKey;\n  const e = utils4.hexToNumber(hashHex);\n  const t = field.add(r, s);\n  if (t === ZERO)\n    return false;\n  const x1y1 = sm2Curve.ProjectivePoint.BASE.multiply(s).add(PA.multiply(t));\n  const R = field.add(e, x1y1.x);\n  return r === R;\n}\nfunction getZ(publicKey, userId = \"1234567812345678\") {\n  userId = utf8ToHex(userId);\n  const a = leftPad(utils4.numberToHexUnpadded(sm2Curve.CURVE.a), 64);\n  const b = leftPad(utils4.numberToHexUnpadded(sm2Curve.CURVE.b), 64);\n  const gx = leftPad(utils4.numberToHexUnpadded(sm2Curve.ProjectivePoint.BASE.x), 64);\n  const gy = leftPad(utils4.numberToHexUnpadded(sm2Curve.ProjectivePoint.BASE.y), 64);\n  let px;\n  let py;\n  if (publicKey.length === 128) {\n    px = publicKey.substring(0, 64);\n    py = publicKey.substring(64, 128);\n  } else {\n    const point = sm2Curve.ProjectivePoint.fromHex(publicKey);\n    px = leftPad(utils4.numberToHexUnpadded(point.x), 64);\n    py = leftPad(utils4.numberToHexUnpadded(point.y), 64);\n  }\n  const data = hexToArray(userId + a + b + gx + gy + px + py);\n  const entl = userId.length * 4;\n  const z = sm3(utils4.concatBytes(new Uint8Array([entl >> 8 & 255, entl & 255]), data));\n  return z;\n}\nfunction getHash(hashHex, publicKey, userId = \"1234567812345678\") {\n  const z = getZ(publicKey, userId);\n  return bytesToHex(sm3(utils4.concatBytes(z, typeof hashHex === \"string\" ? hexToArray(hashHex) : hashHex)));\n}\nfunction precomputePublicKey(publicKey, windowSize) {\n  const point = sm2Curve.ProjectivePoint.fromHex(publicKey);\n  return sm2Curve.utils.precompute(windowSize, point);\n}\nfunction getPublicKeyFromPrivateKey(privateKey) {\n  const pubKey = sm2Curve.getPublicKey(privateKey, false);\n  const pubPad = leftPad(utils4.bytesToHex(pubKey), 64);\n  return pubPad;\n}\nfunction getPoint() {\n  const keypair = generateKeyPairHex();\n  const PA = sm2Curve.ProjectivePoint.fromHex(keypair.publicKey);\n  const k = utils4.hexToNumber(keypair.privateKey);\n  return {\n    ...keypair,\n    k,\n    x1: PA.x\n  };\n}\n\n// src/sm3/index.ts\nfunction utf8ToArray(str) {\n  const arr = [];\n  for (let i = 0, len = str.length; i < len; i++) {\n    const point = str.codePointAt(i);\n    if (point <= 127) {\n      arr.push(point);\n    } else if (point <= 2047) {\n      arr.push(192 | point >>> 6);\n      arr.push(128 | point & 63);\n    } else if (point <= 55295 || point >= 57344 && point <= 65535) {\n      arr.push(224 | point >>> 12);\n      arr.push(128 | point >>> 6 & 63);\n      arr.push(128 | point & 63);\n    } else if (point >= 65536 && point <= 1114111) {\n      i++;\n      arr.push(240 | point >>> 18 & 28);\n      arr.push(128 | point >>> 12 & 63);\n      arr.push(128 | point >>> 6 & 63);\n      arr.push(128 | point & 63);\n    } else {\n      arr.push(point);\n      throw new Error(\"input is not supported\");\n    }\n  }\n  return new Uint8Array(arr);\n}\nfunction sm32(input, options) {\n  input = typeof input === \"string\" ? utf8ToArray(input) : input;\n  if (options) {\n    const mode = options.mode || \"hmac\";\n    if (mode !== \"hmac\")\n      throw new Error(\"invalid mode\");\n    let key = options.key;\n    if (!key)\n      throw new Error(\"invalid key\");\n    key = typeof key === \"string\" ? hexToArray(key) : key;\n    return bytesToHex(hmac(sm3, key, input));\n  }\n  return bytesToHex(sm3(input));\n}\n\n// src/sm4/index.ts\nvar sm4_exports = {};\n__export(sm4_exports, {\n  decrypt: () => decrypt,\n  encrypt: () => encrypt,\n  sm4: () => sm4\n});\nvar DECRYPT = 0;\nvar ROUND = 32;\nvar BLOCK = 16;\nvar Sbox = Uint8Array.from([\n  214,\n  144,\n  233,\n  254,\n  204,\n  225,\n  61,\n  183,\n  22,\n  182,\n  20,\n  194,\n  40,\n  251,\n  44,\n  5,\n  43,\n  103,\n  154,\n  118,\n  42,\n  190,\n  4,\n  195,\n  170,\n  68,\n  19,\n  38,\n  73,\n  134,\n  6,\n  153,\n  156,\n  66,\n  80,\n  244,\n  145,\n  239,\n  152,\n  122,\n  51,\n  84,\n  11,\n  67,\n  237,\n  207,\n  172,\n  98,\n  228,\n  179,\n  28,\n  169,\n  201,\n  8,\n  232,\n  149,\n  128,\n  223,\n  148,\n  250,\n  117,\n  143,\n  63,\n  166,\n  71,\n  7,\n  167,\n  252,\n  243,\n  115,\n  23,\n  186,\n  131,\n  89,\n  60,\n  25,\n  230,\n  133,\n  79,\n  168,\n  104,\n  107,\n  129,\n  178,\n  113,\n  100,\n  218,\n  139,\n  248,\n  235,\n  15,\n  75,\n  112,\n  86,\n  157,\n  53,\n  30,\n  36,\n  14,\n  94,\n  99,\n  88,\n  209,\n  162,\n  37,\n  34,\n  124,\n  59,\n  1,\n  33,\n  120,\n  135,\n  212,\n  0,\n  70,\n  87,\n  159,\n  211,\n  39,\n  82,\n  76,\n  54,\n  2,\n  231,\n  160,\n  196,\n  200,\n  158,\n  234,\n  191,\n  138,\n  210,\n  64,\n  199,\n  56,\n  181,\n  163,\n  247,\n  242,\n  206,\n  249,\n  97,\n  21,\n  161,\n  224,\n  174,\n  93,\n  164,\n  155,\n  52,\n  26,\n  85,\n  173,\n  147,\n  50,\n  48,\n  245,\n  140,\n  177,\n  227,\n  29,\n  246,\n  226,\n  46,\n  130,\n  102,\n  202,\n  96,\n  192,\n  41,\n  35,\n  171,\n  13,\n  83,\n  78,\n  111,\n  213,\n  219,\n  55,\n  69,\n  222,\n  253,\n  142,\n  47,\n  3,\n  255,\n  106,\n  114,\n  109,\n  108,\n  91,\n  81,\n  141,\n  27,\n  175,\n  146,\n  187,\n  221,\n  188,\n  127,\n  17,\n  217,\n  92,\n  65,\n  31,\n  16,\n  90,\n  216,\n  10,\n  193,\n  49,\n  136,\n  165,\n  205,\n  123,\n  189,\n  45,\n  116,\n  208,\n  18,\n  184,\n  229,\n  180,\n  176,\n  137,\n  105,\n  151,\n  74,\n  12,\n  150,\n  119,\n  126,\n  101,\n  185,\n  241,\n  9,\n  197,\n  110,\n  198,\n  132,\n  24,\n  240,\n  125,\n  236,\n  58,\n  220,\n  77,\n  32,\n  121,\n  238,\n  95,\n  62,\n  215,\n  203,\n  57,\n  72\n]);\nvar CK = new Uint32Array([\n  462357,\n  472066609,\n  943670861,\n  1415275113,\n  1886879365,\n  2358483617,\n  2830087869,\n  3301692121,\n  3773296373,\n  4228057617,\n  404694573,\n  876298825,\n  1347903077,\n  1819507329,\n  2291111581,\n  2762715833,\n  3234320085,\n  3705924337,\n  4177462797,\n  337322537,\n  808926789,\n  1280531041,\n  1752135293,\n  2223739545,\n  2695343797,\n  3166948049,\n  3638552301,\n  4110090761,\n  269950501,\n  741554753,\n  1213159005,\n  1684763257\n]);\nfunction byteSub(a) {\n  return (Sbox[a >>> 24 & 255] & 255) << 24 | (Sbox[a >>> 16 & 255] & 255) << 16 | (Sbox[a >>> 8 & 255] & 255) << 8 | Sbox[a & 255] & 255;\n}\nvar x = new Uint32Array(4);\nvar tmp = new Uint32Array(4);\nfunction sms4Crypt(input, output, roundKey) {\n  let x0 = 0, x1 = 0, x2 = 0, x3 = 0, tmp0 = 0, tmp1 = 0, tmp2 = 0, tmp3 = 0;\n  tmp0 = input[0] & 255;\n  tmp1 = input[1] & 255;\n  tmp2 = input[2] & 255;\n  tmp3 = input[3] & 255;\n  x0 = tmp0 << 24 | tmp1 << 16 | tmp2 << 8 | tmp3;\n  tmp0 = input[4] & 255;\n  tmp1 = input[5] & 255;\n  tmp2 = input[6] & 255;\n  tmp3 = input[7] & 255;\n  x1 = tmp0 << 24 | tmp1 << 16 | tmp2 << 8 | tmp3;\n  tmp0 = input[8] & 255;\n  tmp1 = input[9] & 255;\n  tmp2 = input[10] & 255;\n  tmp3 = input[11] & 255;\n  x2 = tmp0 << 24 | tmp1 << 16 | tmp2 << 8 | tmp3;\n  tmp0 = input[12] & 255;\n  tmp1 = input[13] & 255;\n  tmp2 = input[14] & 255;\n  tmp3 = input[15] & 255;\n  x3 = tmp0 << 24 | tmp1 << 16 | tmp2 << 8 | tmp3;\n  for (let r = 0; r < 32; r += 4) {\n    tmp0 = x1 ^ x2 ^ x3 ^ roundKey[r];\n    tmp0 = byteSub(tmp0);\n    x0 ^= tmp0 ^ (tmp0 << 2 | tmp0 >>> 30) ^ (tmp0 << 10 | tmp0 >>> 22) ^ (tmp0 << 18 | tmp0 >>> 14) ^ (tmp0 << 24 | tmp0 >>> 8);\n    tmp1 = x2 ^ x3 ^ x0 ^ roundKey[r + 1];\n    tmp1 = byteSub(tmp1);\n    x1 ^= tmp1 ^ (tmp1 << 2 | tmp1 >>> 30) ^ (tmp1 << 10 | tmp1 >>> 22) ^ (tmp1 << 18 | tmp1 >>> 14) ^ (tmp1 << 24 | tmp1 >>> 8);\n    tmp2 = x3 ^ x0 ^ x1 ^ roundKey[r + 2];\n    tmp2 = byteSub(tmp2);\n    x2 ^= tmp2 ^ (tmp2 << 2 | tmp2 >>> 30) ^ (tmp2 << 10 | tmp2 >>> 22) ^ (tmp2 << 18 | tmp2 >>> 14) ^ (tmp2 << 24 | tmp2 >>> 8);\n    tmp3 = x0 ^ x1 ^ x2 ^ roundKey[r + 3];\n    tmp3 = byteSub(tmp3);\n    x3 ^= tmp3 ^ (tmp3 << 2 | tmp3 >>> 30) ^ (tmp3 << 10 | tmp3 >>> 22) ^ (tmp3 << 18 | tmp3 >>> 14) ^ (tmp3 << 24 | tmp3 >>> 8);\n  }\n  output[0] = x3 >>> 24 & 255;\n  output[1] = x3 >>> 16 & 255;\n  output[2] = x3 >>> 8 & 255;\n  output[3] = x3 & 255;\n  output[4] = x2 >>> 24 & 255;\n  output[5] = x2 >>> 16 & 255;\n  output[6] = x2 >>> 8 & 255;\n  output[7] = x2 & 255;\n  output[8] = x1 >>> 24 & 255;\n  output[9] = x1 >>> 16 & 255;\n  output[10] = x1 >>> 8 & 255;\n  output[11] = x1 & 255;\n  output[12] = x0 >>> 24 & 255;\n  output[13] = x0 >>> 16 & 255;\n  output[14] = x0 >>> 8 & 255;\n  output[15] = x0 & 255;\n}\nfunction sms4KeyExt(key, roundKey, cryptFlag) {\n  let x0 = 0, x1 = 0, x2 = 0, x3 = 0, mid = 0;\n  x0 = (key[0] & 255) << 24 | (key[1] & 255) << 16 | (key[2] & 255) << 8 | key[3] & 255;\n  x1 = (key[4] & 255) << 24 | (key[5] & 255) << 16 | (key[6] & 255) << 8 | key[7] & 255;\n  x2 = (key[8] & 255) << 24 | (key[9] & 255) << 16 | (key[10] & 255) << 8 | key[11] & 255;\n  x3 = (key[12] & 255) << 24 | (key[13] & 255) << 16 | (key[14] & 255) << 8 | key[15] & 255;\n  x0 ^= 2746333894;\n  x1 ^= 1453994832;\n  x2 ^= 1736282519;\n  x3 ^= 2993693404;\n  for (let r = 0; r < 32; r += 4) {\n    mid = x1 ^ x2 ^ x3 ^ CK[r + 0];\n    mid = byteSub(mid);\n    x0 ^= mid ^ (mid << 13 | mid >>> 19) ^ (mid << 23 | mid >>> 9);\n    roundKey[r + 0] = x0;\n    mid = x2 ^ x3 ^ x0 ^ CK[r + 1];\n    mid = byteSub(mid);\n    x1 ^= mid ^ (mid << 13 | mid >>> 19) ^ (mid << 23 | mid >>> 9);\n    roundKey[r + 1] = x1;\n    mid = x3 ^ x0 ^ x1 ^ CK[r + 2];\n    mid = byteSub(mid);\n    x2 ^= mid ^ (mid << 13 | mid >>> 19) ^ (mid << 23 | mid >>> 9);\n    roundKey[r + 2] = x2;\n    mid = x0 ^ x1 ^ x2 ^ CK[r + 3];\n    mid = byteSub(mid);\n    x3 ^= mid ^ (mid << 13 | mid >>> 19) ^ (mid << 23 | mid >>> 9);\n    roundKey[r + 3] = x3;\n  }\n  if (cryptFlag === DECRYPT) {\n    for (let r = 0; r < 16; r++) {\n      [roundKey[r], roundKey[31 - r]] = [roundKey[31 - r], roundKey[r]];\n    }\n  }\n}\nvar blockOutput = new Uint8Array(16);\nfunction sm4(inArray, key, cryptFlag, options = {}) {\n  let {\n    padding = \"pkcs#7\",\n    mode,\n    iv = new Uint8Array(16),\n    output\n  } = options;\n  if (mode === \"cbc\") {\n    if (typeof iv === \"string\")\n      iv = hexToArray(iv);\n    if (iv.length !== 128 / 8) {\n      throw new Error(\"iv is invalid\");\n    }\n  }\n  if (typeof key === \"string\")\n    key = hexToArray(key);\n  if (key.length !== 128 / 8) {\n    throw new Error(\"key is invalid\");\n  }\n  if (typeof inArray === \"string\") {\n    if (cryptFlag !== DECRYPT) {\n      inArray = utf8ToArray(inArray);\n    } else {\n      inArray = hexToArray(inArray);\n    }\n  } else {\n    inArray = Uint8Array.from(inArray);\n  }\n  if ((padding === \"pkcs#5\" || padding === \"pkcs#7\") && cryptFlag !== DECRYPT) {\n    const paddingCount = BLOCK - inArray.length % BLOCK;\n    const newArray = new Uint8Array(inArray.length + paddingCount);\n    newArray.set(inArray, 0);\n    for (let i = 0; i < paddingCount; i++)\n      newArray[inArray.length + i] = paddingCount;\n    inArray = newArray;\n  }\n  const roundKey = new Uint32Array(ROUND);\n  sms4KeyExt(key, roundKey, cryptFlag);\n  let outArray = new Uint8Array(inArray.length);\n  let lastVector = iv;\n  let restLen = inArray.length;\n  let point = 0;\n  while (restLen >= BLOCK) {\n    const input = inArray.subarray(point, point + 16);\n    if (mode === \"cbc\") {\n      for (let i = 0; i < BLOCK; i++) {\n        if (cryptFlag !== DECRYPT) {\n          input[i] ^= lastVector[i];\n        }\n      }\n    }\n    sms4Crypt(input, blockOutput, roundKey);\n    for (let i = 0; i < BLOCK; i++) {\n      if (mode === \"cbc\") {\n        if (cryptFlag === DECRYPT) {\n          blockOutput[i] ^= lastVector[i];\n        }\n      }\n      outArray[point + i] = blockOutput[i];\n    }\n    if (mode === \"cbc\") {\n      if (cryptFlag !== DECRYPT) {\n        lastVector = blockOutput;\n      } else {\n        lastVector = input;\n      }\n    }\n    restLen -= BLOCK;\n    point += BLOCK;\n  }\n  if ((padding === \"pkcs#5\" || padding === \"pkcs#7\") && cryptFlag === DECRYPT) {\n    const len = outArray.length;\n    const paddingCount = outArray[len - 1];\n    for (let i = 1; i <= paddingCount; i++) {\n      if (outArray[len - i] !== paddingCount)\n        throw new Error(\"padding is invalid\");\n    }\n    outArray = outArray.slice(0, len - paddingCount);\n  }\n  if (output !== \"array\") {\n    if (cryptFlag !== DECRYPT) {\n      return bytesToHex(outArray);\n    } else {\n      return arrayToUtf8(outArray);\n    }\n  } else {\n    return outArray;\n  }\n}\nfunction encrypt(inArray, key, options = {}) {\n  return sm4(inArray, key, 1, options);\n}\nfunction decrypt(inArray, key, options = {}) {\n  return sm4(inArray, key, 0, options);\n}\nexport {\n  sm2_exports as sm2,\n  sm32 as sm3,\n  sm4_exports as sm4\n};\n/*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) */\n","/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */\n// 100 lines of code in the file are duplicated from noble-hashes (utils).\n// This is OK: `abstract` directory does not use noble-hashes.\n// User may opt-in into using different hashing library. This way, noble-hashes\n// won't be included into their bundle.\nconst _0n = BigInt(0);\nconst _1n = BigInt(1);\nconst _2n = BigInt(2);\nconst u8a = (a: any): a is Uint8Array => a instanceof Uint8Array;\nexport type Hex = Uint8Array | string; // hex strings are accepted for simplicity\nexport type PrivKey = Hex | bigint; // bigints are accepted to ease learning curve\nexport type CHash = {\n  (message: Uint8Array | string): Uint8Array;\n  blockLen: number;\n  outputLen: number;\n  create(opts?: { dkLen?: number }): any; // For shake\n};\nexport type FHash = (message: Uint8Array | string) => Uint8Array;\n\nconst hexes = Array.from({ length: 256 }, (v, i) => i.toString(16).padStart(2, '0'));\n/**\n * @example bytesToHex(Uint8Array.from([0xca, 0xfe, 0x01, 0x23])) // 'cafe0123'\n */\nexport function bytesToHex(bytes: Uint8Array): string {\n  if (!u8a(bytes)) throw new Error('Uint8Array expected');\n  // pre-caching improves the speed 6x\n  let hex = '';\n  for (let i = 0; i < bytes.length; i++) {\n    hex += hexes[bytes[i]];\n  }\n  return hex;\n}\n\nexport function numberToHexUnpadded(num: number | bigint): string {\n  const hex = num.toString(16);\n  return hex.length & 1 ? `0${hex}` : hex;\n}\n\nexport function hexToNumber(hex: string): bigint {\n  if (typeof hex !== 'string') throw new Error('hex string expected, got ' + typeof hex);\n  // Big Endian\n  return BigInt(hex === '' ? '0' : `0x${hex}`);\n}\n\n/**\n * @example hexToBytes('cafe0123') // Uint8Array.from([0xca, 0xfe, 0x01, 0x23])\n */\nexport function hexToBytes(hex: string): Uint8Array {\n  if (typeof hex !== 'string') throw new Error('hex string expected, got ' + typeof hex);\n  const len = hex.length;\n  if (len % 2) throw new Error('padded hex string expected, got unpadded hex of length ' + len);\n  const array = new Uint8Array(len / 2);\n  for (let i = 0; i < array.length; i++) {\n    const j = i * 2;\n    const hexByte = hex.slice(j, j + 2);\n    const byte = Number.parseInt(hexByte, 16);\n    if (Number.isNaN(byte) || byte < 0) throw new Error('Invalid byte sequence');\n    array[i] = byte;\n  }\n  return array;\n}\n\n// BE: Big Endian, LE: Little Endian\nexport function bytesToNumberBE(bytes: Uint8Array): bigint {\n  return hexToNumber(bytesToHex(bytes));\n}\nexport function bytesToNumberLE(bytes: Uint8Array): bigint {\n  if (!u8a(bytes)) throw new Error('Uint8Array expected');\n  return hexToNumber(bytesToHex(Uint8Array.from(bytes).reverse()));\n}\n\nexport function numberToBytesBE(n: number | bigint, len: number): Uint8Array {\n  return hexToBytes(n.toString(16).padStart(len * 2, '0'));\n}\nexport function numberToBytesLE(n: number | bigint, len: number): Uint8Array {\n  return numberToBytesBE(n, len).reverse();\n}\n// Unpadded, rarely used\nexport function numberToVarBytesBE(n: number | bigint): Uint8Array {\n  return hexToBytes(numberToHexUnpadded(n));\n}\n\n/**\n * Takes hex string or Uint8Array, converts to Uint8Array.\n * Validates output length.\n * Will throw error for other types.\n * @param title descriptive title for an error e.g. 'private key'\n * @param hex hex string or Uint8Array\n * @param expectedLength optional, will compare to result array's length\n * @returns\n */\nexport function ensureBytes(title: string, hex: Hex, expectedLength?: number): Uint8Array {\n  let res: Uint8Array;\n  if (typeof hex === 'string') {\n    try {\n      res = hexToBytes(hex);\n    } catch (e) {\n      throw new Error(`${title} must be valid hex string, got \"${hex}\". Cause: ${e}`);\n    }\n  } else if (u8a(hex)) {\n    // Uint8Array.from() instead of hash.slice() because node.js Buffer\n    // is instance of Uint8Array, and its slice() creates **mutable** copy\n    res = Uint8Array.from(hex);\n  } else {\n    throw new Error(`${title} must be hex string or Uint8Array`);\n  }\n  const len = res.length;\n  if (typeof expectedLength === 'number' && len !== expectedLength)\n    throw new Error(`${title} expected ${expectedLength} bytes, got ${len}`);\n  return res;\n}\n\n/**\n * Copies several Uint8Arrays into one.\n */\nexport function concatBytes(...arrays: Uint8Array[]): Uint8Array {\n  const r = new Uint8Array(arrays.reduce((sum, a) => sum + a.length, 0));\n  let pad = 0; // walk through each item, ensure they have proper type\n  arrays.forEach((a) => {\n    if (!u8a(a)) throw new Error('Uint8Array expected');\n    r.set(a, pad);\n    pad += a.length;\n  });\n  return r;\n}\n\nexport function equalBytes(b1: Uint8Array, b2: Uint8Array) {\n  // We don't care about timing attacks here\n  if (b1.length !== b2.length) return false;\n  for (let i = 0; i < b1.length; i++) if (b1[i] !== b2[i]) return false;\n  return true;\n}\n\n// Global symbols in both browsers and Node.js since v11\n// See https://github.com/microsoft/TypeScript/issues/31535\ndeclare const TextEncoder: any;\n\n/**\n * @example utf8ToBytes('abc') // new Uint8Array([97, 98, 99])\n */\nexport function utf8ToBytes(str: string): Uint8Array {\n  if (typeof str !== 'string') throw new Error(`utf8ToBytes expected string, got ${typeof str}`);\n  return new Uint8Array(new TextEncoder().encode(str)); // https://bugzil.la/1681809\n}\n\n// Bit operations\n\n/**\n * Calculates amount of bits in a bigint.\n * Same as `n.toString(2).length`\n */\nexport function bitLen(n: bigint) {\n  let len;\n  for (len = 0; n > _0n; n >>= _1n, len += 1);\n  return len;\n}\n\n/**\n * Gets single bit at position.\n * NOTE: first bit position is 0 (same as arrays)\n * Same as `!!+Array.from(n.toString(2)).reverse()[pos]`\n */\nexport function bitGet(n: bigint, pos: number) {\n  return (n >> BigInt(pos)) & _1n;\n}\n\n/**\n * Sets single bit at position.\n */\nexport const bitSet = (n: bigint, pos: number, value: boolean) => {\n  return n | ((value ? _1n : _0n) << BigInt(pos));\n};\n\n/**\n * Calculate mask for N bits. Not using ** operator with bigints because of old engines.\n * Same as BigInt(`0b${Array(i).fill('1').join('')}`)\n */\nexport const bitMask = (n: number) => (_2n << BigInt(n - 1)) - _1n;\n\n// DRBG\n\nconst u8n = (data?: any) => new Uint8Array(data); // creates Uint8Array\nconst u8fr = (arr: any) => Uint8Array.from(arr); // another shortcut\ntype Pred<T> = (v: Uint8Array) => T | undefined;\n/**\n * Minimal HMAC-DRBG from NIST 800-90 for RFC6979 sigs.\n * @returns function that will call DRBG until 2nd arg returns something meaningful\n * @example\n *   const drbg = createHmacDRBG<Key>(32, 32, hmac);\n *   drbg(seed, bytesToKey); // bytesToKey must return Key or undefined\n */\nexport function createHmacDrbg<T>(\n  hashLen: number,\n  qByteLen: number,\n  hmacFn: (key: Uint8Array, ...messages: Uint8Array[]) => Uint8Array\n): (seed: Uint8Array, predicate: Pred<T>) => T {\n  if (typeof hashLen !== 'number' || hashLen < 2) throw new Error('hashLen must be a number');\n  if (typeof qByteLen !== 'number' || qByteLen < 2) throw new Error('qByteLen must be a number');\n  if (typeof hmacFn !== 'function') throw new Error('hmacFn must be a function');\n  // Step B, Step C: set hashLen to 8*ceil(hlen/8)\n  let v = u8n(hashLen); // Minimal non-full-spec HMAC-DRBG from NIST 800-90 for RFC6979 sigs.\n  let k = u8n(hashLen); // Steps B and C of RFC6979 3.2: set hashLen, in our case always same\n  let i = 0; // Iterations counter, will throw when over 1000\n  const reset = () => {\n    v.fill(1);\n    k.fill(0);\n    i = 0;\n  };\n  const h = (...b: Uint8Array[]) => hmacFn(k, v, ...b); // hmac(k)(v, ...values)\n  const reseed = (seed = u8n()) => {\n    // HMAC-DRBG reseed() function. Steps D-G\n    k = h(u8fr([0x00]), seed); // k = hmac(k || v || 0x00 || seed)\n    v = h(); // v = hmac(k || v)\n    if (seed.length === 0) return;\n    k = h(u8fr([0x01]), seed); // k = hmac(k || v || 0x01 || seed)\n    v = h(); // v = hmac(k || v)\n  };\n  const gen = () => {\n    // HMAC-DRBG generate() function\n    if (i++ >= 1000) throw new Error('drbg: tried 1000 values');\n    let len = 0;\n    const out: Uint8Array[] = [];\n    while (len < qByteLen) {\n      v = h();\n      const sl = v.slice();\n      out.push(sl);\n      len += v.length;\n    }\n    return concatBytes(...out);\n  };\n  const genUntil = (seed: Uint8Array, pred: Pred<T>): T => {\n    reset();\n    reseed(seed); // Steps D-G\n    let res: T | undefined = undefined; // Step H: grind until k is in [1..n-1]\n    while (!(res = pred(gen()))) reseed();\n    reset();\n    return res;\n  };\n  return genUntil;\n}\n\n// Validating curves and fields\n\nconst validatorFns = {\n  bigint: (val: any) => typeof val === 'bigint',\n  function: (val: any) => typeof val === 'function',\n  boolean: (val: any) => typeof val === 'boolean',\n  string: (val: any) => typeof val === 'string',\n  isSafeInteger: (val: any) => Number.isSafeInteger(val),\n  array: (val: any) => Array.isArray(val),\n  field: (val: any, object: any) => (object as any).Fp.isValid(val),\n  hash: (val: any) => typeof val === 'function' && Number.isSafeInteger(val.outputLen),\n} as const;\ntype Validator = keyof typeof validatorFns;\ntype ValMap<T extends Record<string, any>> = { [K in keyof T]?: Validator };\n// type Record<K extends string | number | symbol, T> = { [P in K]: T; }\n\nexport function validateObject<T extends Record<string, any>>(\n  object: T,\n  validators: ValMap<T>,\n  optValidators: ValMap<T> = {}\n) {\n  const checkField = (fieldName: keyof T, type: Validator, isOptional: boolean) => {\n    const checkVal = validatorFns[type];\n    if (typeof checkVal !== 'function')\n      throw new Error(`Invalid validator \"${type}\", expected function`);\n\n    const val = object[fieldName as keyof typeof object];\n    if (isOptional && val === undefined) return;\n    if (!checkVal(val, object)) {\n      throw new Error(\n        `Invalid param ${String(fieldName)}=${val} (${typeof val}), expected ${type}`\n      );\n    }\n  };\n  for (const [fieldName, type] of Object.entries(validators)) checkField(fieldName, type!, false);\n  for (const [fieldName, type] of Object.entries(optValidators)) checkField(fieldName, type!, true);\n  return object;\n}\n// validate type tests\n// const o: { a: number; b: number; c: number } = { a: 1, b: 5, c: 6 };\n// const z0 = validateObject(o, { a: 'isSafeInteger' }, { c: 'bigint' }); // Ok!\n// // Should fail type-check\n// const z1 = validateObject(o, { a: 'tmp' }, { c: 'zz' });\n// const z2 = validateObject(o, { a: 'isSafeInteger' }, { c: 'zz' });\n// const z3 = validateObject(o, { test: 'boolean', z: 'bug' });\n// const z4 = validateObject(o, { a: 'boolean', z: 'bug' });\n","/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */\n// Short Weierstrass curve. The formula is: y² = x³ + ax + b\nimport * as mod from './modular.js';\nimport * as ut from './utils.js';\nimport { CHash, Hex, PrivKey, ensureBytes } from './utils.js';\nimport { Group, GroupConstructor, wNAF, BasicCurve, validateBasic, AffinePoint } from './curve.js';\n\nexport type { AffinePoint };\ntype HmacFnSync = (key: Uint8Array, ...messages: Uint8Array[]) => Uint8Array;\ntype EndomorphismOpts = {\n  beta: bigint;\n  splitScalar: (k: bigint) => { k1neg: boolean; k1: bigint; k2neg: boolean; k2: bigint };\n};\nexport type BasicWCurve<T> = BasicCurve<T> & {\n  // Params: a, b\n  a: T;\n  b: T;\n\n  // Optional params\n  allowedPrivateKeyLengths?: readonly number[]; // for P521\n  wrapPrivateKey?: boolean; // bls12-381 requires mod(n) instead of rejecting keys >= n\n  endo?: EndomorphismOpts; // Endomorphism options for Koblitz curves\n  // When a cofactor != 1, there can be an effective methods to:\n  // 1. Determine whether a point is torsion-free\n  isTorsionFree?: (c: ProjConstructor<T>, point: ProjPointType<T>) => boolean;\n  // 2. Clear torsion component\n  clearCofactor?: (c: ProjConstructor<T>, point: ProjPointType<T>) => ProjPointType<T>;\n};\n\ntype Entropy = Hex | true;\nexport type SignOpts = { lowS?: boolean; extraEntropy?: Entropy; prehash?: boolean };\nexport type VerOpts = { lowS?: boolean; prehash?: boolean };\n\n/**\n * ### Design rationale for types\n *\n * * Interaction between classes from different curves should fail:\n *   `k256.Point.BASE.add(p256.Point.BASE)`\n * * For this purpose we want to use `instanceof` operator, which is fast and works during runtime\n * * Different calls of `curve()` would return different classes -\n *   `curve(params) !== curve(params)`: if somebody decided to monkey-patch their curve,\n *   it won't affect others\n *\n * TypeScript can't infer types for classes created inside a function. Classes is one instance of nominative types in TypeScript and interfaces only check for shape, so it's hard to create unique type for every function call.\n *\n * We can use generic types via some param, like curve opts, but that would:\n *     1. Enable interaction between `curve(params)` and `curve(params)` (curves of same params)\n *     which is hard to debug.\n *     2. Params can be generic and we can't enforce them to be constant value:\n *     if somebody creates curve from non-constant params,\n *     it would be allowed to interact with other curves with non-constant params\n *\n * TODO: https://www.typescriptlang.org/docs/handbook/release-notes/typescript-2-7.html#unique-symbol\n */\n\n// Instance for 3d XYZ points\nexport interface ProjPointType<T> extends Group<ProjPointType<T>> {\n  readonly px: T;\n  readonly py: T;\n  readonly pz: T;\n  get x(): T;\n  get y(): T;\n  multiply(scalar: bigint): ProjPointType<T>;\n  toAffine(iz?: T): AffinePoint<T>;\n  isTorsionFree(): boolean;\n  clearCofactor(): ProjPointType<T>;\n  assertValidity(): void;\n  hasEvenY(): boolean;\n  toRawBytes(isCompressed?: boolean): Uint8Array;\n  toHex(isCompressed?: boolean): string;\n\n  multiplyUnsafe(scalar: bigint): ProjPointType<T>;\n  multiplyAndAddUnsafe(Q: ProjPointType<T>, a: bigint, b: bigint): ProjPointType<T> | undefined;\n  _setWindowSize(windowSize: number): void;\n}\n// Static methods for 3d XYZ points\nexport interface ProjConstructor<T> extends GroupConstructor<ProjPointType<T>> {\n  new (x: T, y: T, z: T): ProjPointType<T>;\n  fromAffine(p: AffinePoint<T>): ProjPointType<T>;\n  fromHex(hex: Hex): ProjPointType<T>;\n  fromPrivateKey(privateKey: PrivKey): ProjPointType<T>;\n  normalizeZ(points: ProjPointType<T>[]): ProjPointType<T>[];\n}\n\nexport type CurvePointsType<T> = BasicWCurve<T> & {\n  // Bytes\n  fromBytes?: (bytes: Uint8Array) => AffinePoint<T>;\n  toBytes?: (c: ProjConstructor<T>, point: ProjPointType<T>, isCompressed: boolean) => Uint8Array;\n};\n\nfunction validatePointOpts<T>(curve: CurvePointsType<T>) {\n  const opts = validateBasic(curve);\n  ut.validateObject(\n    opts,\n    {\n      a: 'field',\n      b: 'field',\n    },\n    {\n      allowedPrivateKeyLengths: 'array',\n      wrapPrivateKey: 'boolean',\n      isTorsionFree: 'function',\n      clearCofactor: 'function',\n      allowInfinityPoint: 'boolean',\n      fromBytes: 'function',\n      toBytes: 'function',\n    }\n  );\n  const { endo, Fp, a } = opts;\n  if (endo) {\n    if (!Fp.eql(a, Fp.ZERO)) {\n      throw new Error('Endomorphism can only be defined for Koblitz curves that have a=0');\n    }\n    if (\n      typeof endo !== 'object' ||\n      typeof endo.beta !== 'bigint' ||\n      typeof endo.splitScalar !== 'function'\n    ) {\n      throw new Error('Expected endomorphism with beta: bigint and splitScalar: function');\n    }\n  }\n  return Object.freeze({ ...opts } as const);\n}\n\nexport type CurvePointsRes<T> = {\n  ProjectivePoint: ProjConstructor<T>;\n  normPrivateKeyToScalar: (key: PrivKey) => bigint;\n  weierstrassEquation: (x: T) => T;\n  isWithinCurveOrder: (num: bigint) => boolean;\n};\n\n// ASN.1 DER encoding utilities\nconst { bytesToNumberBE: b2n, hexToBytes: h2b } = ut;\nexport const DER = {\n  // asn.1 DER encoding utils\n  Err: class DERErr extends Error {\n    constructor(m = '') {\n      super(m);\n    }\n  },\n  _parseInt(data: Uint8Array): { d: bigint; l: Uint8Array } {\n    const { Err: E } = DER;\n    if (data.length < 2 || data[0] !== 0x02) throw new E('Invalid signature integer tag');\n    const len = data[1];\n    const res = data.subarray(2, len + 2);\n    if (!len || res.length !== len) throw new E('Invalid signature integer: wrong length');\n    // https://crypto.stackexchange.com/a/57734 Leftmost bit of first byte is 'negative' flag,\n    // since we always use positive integers here. It must always be empty:\n    // - add zero byte if exists\n    // - if next byte doesn't have a flag, leading zero is not allowed (minimal encoding)\n    if (res[0] & 0b10000000) throw new E('Invalid signature integer: negative');\n    if (res[0] === 0x00 && !(res[1] & 0b10000000))\n      throw new E('Invalid signature integer: unnecessary leading zero');\n    return { d: b2n(res), l: data.subarray(len + 2) }; // d is data, l is left\n  },\n  toSig(hex: string | Uint8Array): { r: bigint; s: bigint } {\n    // parse DER signature\n    const { Err: E } = DER;\n    const data = typeof hex === 'string' ? h2b(hex) : hex;\n    if (!(data instanceof Uint8Array)) throw new Error('ui8a expected');\n    let l = data.length;\n    if (l < 2 || data[0] != 0x30) throw new E('Invalid signature tag');\n    if (data[1] !== l - 2) throw new E('Invalid signature: incorrect length');\n    const { d: r, l: sBytes } = DER._parseInt(data.subarray(2));\n    const { d: s, l: rBytesLeft } = DER._parseInt(sBytes);\n    if (rBytesLeft.length) throw new E('Invalid signature: left bytes after parsing');\n    return { r, s };\n  },\n  hexFromSig(sig: { r: bigint; s: bigint }): string {\n    // Add leading zero if first byte has negative bit enabled. More details in '_parseInt'\n    const slice = (s: string): string => (Number.parseInt(s[0], 16) & 0b1000 ? '00' + s : s);\n    const h = (num: number | bigint) => {\n      const hex = num.toString(16);\n      return hex.length & 1 ? `0${hex}` : hex;\n    };\n    const s = slice(h(sig.s));\n    const r = slice(h(sig.r));\n    const shl = s.length / 2;\n    const rhl = r.length / 2;\n    const sl = h(shl);\n    const rl = h(rhl);\n    return `30${h(rhl + shl + 4)}02${rl}${r}02${sl}${s}`;\n  },\n};\n\n// Be friendly to bad ECMAScript parsers by not using bigint literals\n// prettier-ignore\nconst _0n = BigInt(0), _1n = BigInt(1), _2n = BigInt(2), _3n = BigInt(3), _4n = BigInt(4);\n\nexport function weierstrassPoints<T>(opts: CurvePointsType<T>) {\n  const CURVE = validatePointOpts(opts);\n  const { Fp } = CURVE; // All curves has same field / group length as for now, but they can differ\n\n  const toBytes =\n    CURVE.toBytes ||\n    ((c: ProjConstructor<T>, point: ProjPointType<T>, isCompressed: boolean) => {\n      const a = point.toAffine();\n      return ut.concatBytes(Uint8Array.from([0x04]), Fp.toBytes(a.x), Fp.toBytes(a.y));\n    });\n  const fromBytes =\n    CURVE.fromBytes ||\n    ((bytes: Uint8Array) => {\n      // const head = bytes[0];\n      const tail = bytes.subarray(1);\n      // if (head !== 0x04) throw new Error('Only non-compressed encoding is supported');\n      const x = Fp.fromBytes(tail.subarray(0, Fp.BYTES));\n      const y = Fp.fromBytes(tail.subarray(Fp.BYTES, 2 * Fp.BYTES));\n      return { x, y };\n    });\n\n  /**\n   * y² = x³ + ax + b: Short weierstrass curve formula\n   * @returns y²\n   */\n  function weierstrassEquation(x: T): T {\n    const { a, b } = CURVE;\n    const x2 = Fp.sqr(x); // x * x\n    const x3 = Fp.mul(x2, x); // x2 * x\n    return Fp.add(Fp.add(x3, Fp.mul(x, a)), b); // x3 + a * x + b\n  }\n  // Validate whether the passed curve params are valid.\n  // We check if curve equation works for generator point.\n  // `assertValidity()` won't work: `isTorsionFree()` is not available at this point in bls12-381.\n  // ProjectivePoint class has not been initialized yet.\n  if (!Fp.eql(Fp.sqr(CURVE.Gy), weierstrassEquation(CURVE.Gx)))\n    throw new Error('bad generator point: equation left != right');\n\n  // Valid group elements reside in range 1..n-1\n  function isWithinCurveOrder(num: bigint): boolean {\n    return typeof num === 'bigint' && _0n < num && num < CURVE.n;\n  }\n  function assertGE(num: bigint) {\n    if (!isWithinCurveOrder(num)) throw new Error('Expected valid bigint: 0 < bigint < curve.n');\n  }\n  // Validates if priv key is valid and converts it to bigint.\n  // Supports options allowedPrivateKeyLengths and wrapPrivateKey.\n  function normPrivateKeyToScalar(key: PrivKey): bigint {\n    const { allowedPrivateKeyLengths: lengths, nByteLength, wrapPrivateKey, n } = CURVE;\n    if (lengths && typeof key !== 'bigint') {\n      if (key instanceof Uint8Array) key = ut.bytesToHex(key);\n      // Normalize to hex string, pad. E.g. P521 would norm 130-132 char hex to 132-char bytes\n      if (typeof key !== 'string' || !lengths.includes(key.length)) throw new Error('Invalid key');\n      key = key.padStart(nByteLength * 2, '0');\n    }\n    let num: bigint;\n    try {\n      num =\n        typeof key === 'bigint'\n          ? key\n          : ut.bytesToNumberBE(ensureBytes('private key', key, nByteLength));\n    } catch (error) {\n      throw new Error(`private key must be ${nByteLength} bytes, hex or bigint, not ${typeof key}`);\n    }\n    if (wrapPrivateKey) num = mod.mod(num, n); // disabled by default, enabled for BLS\n    assertGE(num); // num in range [1..N-1]\n    return num;\n  }\n\n  const pointPrecomputes = new Map<Point, Point[]>();\n  function assertPrjPoint(other: unknown) {\n    if (!(other instanceof Point)) throw new Error('ProjectivePoint expected');\n  }\n  /**\n   * Projective Point works in 3d / projective (homogeneous) coordinates: (x, y, z) ∋ (x=x/z, y=y/z)\n   * Default Point works in 2d / affine coordinates: (x, y)\n   * We're doing calculations in projective, because its operations don't require costly inversion.\n   */\n  class Point implements ProjPointType<T> {\n    static readonly BASE = new Point(CURVE.Gx, CURVE.Gy, Fp.ONE);\n    static readonly ZERO = new Point(Fp.ZERO, Fp.ONE, Fp.ZERO);\n\n    constructor(readonly px: T, readonly py: T, readonly pz: T) {\n      if (px == null || !Fp.isValid(px)) throw new Error('x required');\n      if (py == null || !Fp.isValid(py)) throw new Error('y required');\n      if (pz == null || !Fp.isValid(pz)) throw new Error('z required');\n    }\n\n    // Does not validate if the point is on-curve.\n    // Use fromHex instead, or call assertValidity() later.\n    static fromAffine(p: AffinePoint<T>): Point {\n      const { x, y } = p || {};\n      if (!p || !Fp.isValid(x) || !Fp.isValid(y)) throw new Error('invalid affine point');\n      if (p instanceof Point) throw new Error('projective point not allowed');\n      const is0 = (i: T) => Fp.eql(i, Fp.ZERO);\n      // fromAffine(x:0, y:0) would produce (x:0, y:0, z:1), but we need (x:0, y:1, z:0)\n      if (is0(x) && is0(y)) return Point.ZERO;\n      return new Point(x, y, Fp.ONE);\n    }\n\n    get x(): T {\n      return this.toAffine().x;\n    }\n    get y(): T {\n      return this.toAffine().y;\n    }\n\n    /**\n     * Takes a bunch of Projective Points but executes only one\n     * inversion on all of them. Inversion is very slow operation,\n     * so this improves performance massively.\n     * Optimization: converts a list of projective points to a list of identical points with Z=1.\n     */\n    static normalizeZ(points: Point[]): Point[] {\n      const toInv = Fp.invertBatch(points.map((p) => p.pz));\n      return points.map((p, i) => p.toAffine(toInv[i])).map(Point.fromAffine);\n    }\n\n    /**\n     * Converts hash string or Uint8Array to Point.\n     * @param hex short/long ECDSA hex\n     */\n    static fromHex(hex: Hex): Point {\n      const P = Point.fromAffine(fromBytes(ensureBytes('pointHex', hex)));\n      P.assertValidity();\n      return P;\n    }\n\n    // Multiplies generator point by privateKey.\n    static fromPrivateKey(privateKey: PrivKey) {\n      return Point.BASE.multiply(normPrivateKeyToScalar(privateKey));\n    }\n\n    // We calculate precomputes for elliptic curve point multiplication\n    // using windowed method. This specifies window size and\n    // stores precomputed values. Usually only base point would be precomputed.\n    _WINDOW_SIZE?: number;\n\n    // \"Private method\", don't use it directly\n    _setWindowSize(windowSize: number) {\n      this._WINDOW_SIZE = windowSize;\n      pointPrecomputes.delete(this);\n    }\n\n    // A point on curve is valid if it conforms to equation.\n    assertValidity(): void {\n      // Zero is valid point too!\n      if (this.is0()) {\n        if (CURVE.allowInfinityPoint) return;\n        throw new Error('bad point: ZERO');\n      }\n      // Some 3rd-party test vectors require different wording between here & `fromCompressedHex`\n      const { x, y } = this.toAffine();\n      // Check if x, y are valid field elements\n      if (!Fp.isValid(x) || !Fp.isValid(y)) throw new Error('bad point: x or y not FE');\n      const left = Fp.sqr(y); // y²\n      const right = weierstrassEquation(x); // x³ + ax + b\n      if (!Fp.eql(left, right)) throw new Error('bad point: equation left != right');\n      if (!this.isTorsionFree()) throw new Error('bad point: not in prime-order subgroup');\n    }\n    hasEvenY(): boolean {\n      const { y } = this.toAffine();\n      if (Fp.isOdd) return !Fp.isOdd(y);\n      throw new Error(\"Field doesn't support isOdd\");\n    }\n\n    /**\n     * Compare one point to another.\n     */\n    equals(other: Point): boolean {\n      assertPrjPoint(other);\n      const { px: X1, py: Y1, pz: Z1 } = this;\n      const { px: X2, py: Y2, pz: Z2 } = other;\n      const U1 = Fp.eql(Fp.mul(X1, Z2), Fp.mul(X2, Z1));\n      const U2 = Fp.eql(Fp.mul(Y1, Z2), Fp.mul(Y2, Z1));\n      return U1 && U2;\n    }\n\n    /**\n     * Flips point to one corresponding to (x, -y) in Affine coordinates.\n     */\n    negate(): Point {\n      return new Point(this.px, Fp.neg(this.py), this.pz);\n    }\n\n    // Renes-Costello-Batina exception-free doubling formula.\n    // There is 30% faster Jacobian formula, but it is not complete.\n    // https://eprint.iacr.org/2015/1060, algorithm 3\n    // Cost: 8M + 3S + 3*a + 2*b3 + 15add.\n    double() {\n      const { a, b } = CURVE;\n      const b3 = Fp.mul(b, _3n);\n      const { px: X1, py: Y1, pz: Z1 } = this;\n      let X3 = Fp.ZERO, Y3 = Fp.ZERO, Z3 = Fp.ZERO; // prettier-ignore\n      let t0 = Fp.mul(X1, X1); // step 1\n      let t1 = Fp.mul(Y1, Y1);\n      let t2 = Fp.mul(Z1, Z1);\n      let t3 = Fp.mul(X1, Y1);\n      t3 = Fp.add(t3, t3); // step 5\n      Z3 = Fp.mul(X1, Z1);\n      Z3 = Fp.add(Z3, Z3);\n      X3 = Fp.mul(a, Z3);\n      Y3 = Fp.mul(b3, t2);\n      Y3 = Fp.add(X3, Y3); // step 10\n      X3 = Fp.sub(t1, Y3);\n      Y3 = Fp.add(t1, Y3);\n      Y3 = Fp.mul(X3, Y3);\n      X3 = Fp.mul(t3, X3);\n      Z3 = Fp.mul(b3, Z3); // step 15\n      t2 = Fp.mul(a, t2);\n      t3 = Fp.sub(t0, t2);\n      t3 = Fp.mul(a, t3);\n      t3 = Fp.add(t3, Z3);\n      Z3 = Fp.add(t0, t0); // step 20\n      t0 = Fp.add(Z3, t0);\n      t0 = Fp.add(t0, t2);\n      t0 = Fp.mul(t0, t3);\n      Y3 = Fp.add(Y3, t0);\n      t2 = Fp.mul(Y1, Z1); // step 25\n      t2 = Fp.add(t2, t2);\n      t0 = Fp.mul(t2, t3);\n      X3 = Fp.sub(X3, t0);\n      Z3 = Fp.mul(t2, t1);\n      Z3 = Fp.add(Z3, Z3); // step 30\n      Z3 = Fp.add(Z3, Z3);\n      return new Point(X3, Y3, Z3);\n    }\n\n    // Renes-Costello-Batina exception-free addition formula.\n    // There is 30% faster Jacobian formula, but it is not complete.\n    // https://eprint.iacr.org/2015/1060, algorithm 1\n    // Cost: 12M + 0S + 3*a + 3*b3 + 23add.\n    add(other: Point): Point {\n      assertPrjPoint(other);\n      const { px: X1, py: Y1, pz: Z1 } = this;\n      const { px: X2, py: Y2, pz: Z2 } = other;\n      let X3 = Fp.ZERO, Y3 = Fp.ZERO, Z3 = Fp.ZERO; // prettier-ignore\n      const a = CURVE.a;\n      const b3 = Fp.mul(CURVE.b, _3n);\n      let t0 = Fp.mul(X1, X2); // step 1\n      let t1 = Fp.mul(Y1, Y2);\n      let t2 = Fp.mul(Z1, Z2);\n      let t3 = Fp.add(X1, Y1);\n      let t4 = Fp.add(X2, Y2); // step 5\n      t3 = Fp.mul(t3, t4);\n      t4 = Fp.add(t0, t1);\n      t3 = Fp.sub(t3, t4);\n      t4 = Fp.add(X1, Z1);\n      let t5 = Fp.add(X2, Z2); // step 10\n      t4 = Fp.mul(t4, t5);\n      t5 = Fp.add(t0, t2);\n      t4 = Fp.sub(t4, t5);\n      t5 = Fp.add(Y1, Z1);\n      X3 = Fp.add(Y2, Z2); // step 15\n      t5 = Fp.mul(t5, X3);\n      X3 = Fp.add(t1, t2);\n      t5 = Fp.sub(t5, X3);\n      Z3 = Fp.mul(a, t4);\n      X3 = Fp.mul(b3, t2); // step 20\n      Z3 = Fp.add(X3, Z3);\n      X3 = Fp.sub(t1, Z3);\n      Z3 = Fp.add(t1, Z3);\n      Y3 = Fp.mul(X3, Z3);\n      t1 = Fp.add(t0, t0); // step 25\n      t1 = Fp.add(t1, t0);\n      t2 = Fp.mul(a, t2);\n      t4 = Fp.mul(b3, t4);\n      t1 = Fp.add(t1, t2);\n      t2 = Fp.sub(t0, t2); // step 30\n      t2 = Fp.mul(a, t2);\n      t4 = Fp.add(t4, t2);\n      t0 = Fp.mul(t1, t4);\n      Y3 = Fp.add(Y3, t0);\n      t0 = Fp.mul(t5, t4); // step 35\n      X3 = Fp.mul(t3, X3);\n      X3 = Fp.sub(X3, t0);\n      t0 = Fp.mul(t3, t1);\n      Z3 = Fp.mul(t5, Z3);\n      Z3 = Fp.add(Z3, t0); // step 40\n      return new Point(X3, Y3, Z3);\n    }\n\n    subtract(other: Point) {\n      return this.add(other.negate());\n    }\n\n    private is0() {\n      return this.equals(Point.ZERO);\n    }\n    private wNAF(n: bigint): { p: Point; f: Point } {\n      return wnaf.wNAFCached(this, pointPrecomputes, n, (comp: Point[]) => {\n        const toInv = Fp.invertBatch(comp.map((p) => p.pz));\n        return comp.map((p, i) => p.toAffine(toInv[i])).map(Point.fromAffine);\n      });\n    }\n\n    /**\n     * Non-constant-time multiplication. Uses double-and-add algorithm.\n     * It's faster, but should only be used when you don't care about\n     * an exposed private key e.g. sig verification, which works over *public* keys.\n     */\n    multiplyUnsafe(n: bigint): Point {\n      const I = Point.ZERO;\n      if (n === _0n) return I;\n      assertGE(n); // Will throw on 0\n      if (n === _1n) return this;\n      const { endo } = CURVE;\n      if (!endo) return wnaf.unsafeLadder(this, n);\n\n      // Apply endomorphism\n      let { k1neg, k1, k2neg, k2 } = endo.splitScalar(n);\n      let k1p = I;\n      let k2p = I;\n      let d: Point = this;\n      while (k1 > _0n || k2 > _0n) {\n        if (k1 & _1n) k1p = k1p.add(d);\n        if (k2 & _1n) k2p = k2p.add(d);\n        d = d.double();\n        k1 >>= _1n;\n        k2 >>= _1n;\n      }\n      if (k1neg) k1p = k1p.negate();\n      if (k2neg) k2p = k2p.negate();\n      k2p = new Point(Fp.mul(k2p.px, endo.beta), k2p.py, k2p.pz);\n      return k1p.add(k2p);\n    }\n\n    /**\n     * Constant time multiplication.\n     * Uses wNAF method. Windowed method may be 10% faster,\n     * but takes 2x longer to generate and consumes 2x memory.\n     * Uses precomputes when available.\n     * Uses endomorphism for Koblitz curves.\n     * @param scalar by which the point would be multiplied\n     * @returns New point\n     */\n    multiply(scalar: bigint): Point {\n      assertGE(scalar);\n      let n = scalar;\n      let point: Point, fake: Point; // Fake point is used to const-time mult\n      const { endo } = CURVE;\n      if (endo) {\n        const { k1neg, k1, k2neg, k2 } = endo.splitScalar(n);\n        let { p: k1p, f: f1p } = this.wNAF(k1);\n        let { p: k2p, f: f2p } = this.wNAF(k2);\n        k1p = wnaf.constTimeNegate(k1neg, k1p);\n        k2p = wnaf.constTimeNegate(k2neg, k2p);\n        k2p = new Point(Fp.mul(k2p.px, endo.beta), k2p.py, k2p.pz);\n        point = k1p.add(k2p);\n        fake = f1p.add(f2p);\n      } else {\n        const { p, f } = this.wNAF(n);\n        point = p;\n        fake = f;\n      }\n      // Normalize `z` for both points, but return only real one\n      return Point.normalizeZ([point, fake])[0];\n    }\n\n    /**\n     * Efficiently calculate `aP + bQ`. Unsafe, can expose private key, if used incorrectly.\n     * Not using Strauss-Shamir trick: precomputation tables are faster.\n     * The trick could be useful if both P and Q are not G (not in our case).\n     * @returns non-zero affine point\n     */\n    multiplyAndAddUnsafe(Q: Point, a: bigint, b: bigint): Point | undefined {\n      const G = Point.BASE; // No Strauss-Shamir trick: we have 10% faster G precomputes\n      const mul = (\n        P: Point,\n        a: bigint // Select faster multiply() method\n      ) => (a === _0n || a === _1n || !P.equals(G) ? P.multiplyUnsafe(a) : P.multiply(a));\n      const sum = mul(this, a).add(mul(Q, b));\n      return sum.is0() ? undefined : sum;\n    }\n\n    // Converts Projective point to affine (x, y) coordinates.\n    // Can accept precomputed Z^-1 - for example, from invertBatch.\n    // (x, y, z) ∋ (x=x/z, y=y/z)\n    toAffine(iz?: T): AffinePoint<T> {\n      const { px: x, py: y, pz: z } = this;\n      const is0 = this.is0();\n      // If invZ was 0, we return zero point. However we still want to execute\n      // all operations, so we replace invZ with a random number, 1.\n      if (iz == null) iz = is0 ? Fp.ONE : Fp.inv(z);\n      const ax = Fp.mul(x, iz);\n      const ay = Fp.mul(y, iz);\n      const zz = Fp.mul(z, iz);\n      if (is0) return { x: Fp.ZERO, y: Fp.ZERO };\n      if (!Fp.eql(zz, Fp.ONE)) throw new Error('invZ was invalid');\n      return { x: ax, y: ay };\n    }\n    isTorsionFree(): boolean {\n      const { h: cofactor, isTorsionFree } = CURVE;\n      if (cofactor === _1n) return true; // No subgroups, always torsion-free\n      if (isTorsionFree) return isTorsionFree(Point, this);\n      throw new Error('isTorsionFree() has not been declared for the elliptic curve');\n    }\n    clearCofactor(): Point {\n      const { h: cofactor, clearCofactor } = CURVE;\n      if (cofactor === _1n) return this; // Fast-path\n      if (clearCofactor) return clearCofactor(Point, this) as Point;\n      return this.multiplyUnsafe(CURVE.h);\n    }\n\n    toRawBytes(isCompressed = true): Uint8Array {\n      this.assertValidity();\n      return toBytes(Point, this, isCompressed);\n    }\n\n    toHex(isCompressed = true): string {\n      return ut.bytesToHex(this.toRawBytes(isCompressed));\n    }\n  }\n  const _bits = CURVE.nBitLength;\n  const wnaf = wNAF(Point, CURVE.endo ? Math.ceil(_bits / 2) : _bits);\n  // Validate if generator point is on curve\n  return {\n    CURVE,\n    ProjectivePoint: Point as ProjConstructor<T>,\n    normPrivateKeyToScalar,\n    weierstrassEquation,\n    isWithinCurveOrder,\n  };\n}\n\n// Instance\nexport interface SignatureType {\n  readonly r: bigint;\n  readonly s: bigint;\n  readonly recovery?: number;\n  assertValidity(): void;\n  addRecoveryBit(recovery: number): RecoveredSignatureType;\n  hasHighS(): boolean;\n  normalizeS(): SignatureType;\n  recoverPublicKey(msgHash: Hex): ProjPointType<bigint>;\n  toCompactRawBytes(): Uint8Array;\n  toCompactHex(): string;\n  // DER-encoded\n  toDERRawBytes(isCompressed?: boolean): Uint8Array;\n  toDERHex(isCompressed?: boolean): string;\n}\nexport type RecoveredSignatureType = SignatureType & {\n  readonly recovery: number;\n};\n// Static methods\nexport type SignatureConstructor = {\n  new (r: bigint, s: bigint): SignatureType;\n  fromCompact(hex: Hex): SignatureType;\n  fromDER(hex: Hex): SignatureType;\n};\ntype SignatureLike = { r: bigint; s: bigint };\n\nexport type PubKey = Hex | ProjPointType<bigint>;\n\nexport type CurveType = BasicWCurve<bigint> & {\n  hash: CHash; // CHash not FHash because we need outputLen for DRBG\n  hmac: HmacFnSync;\n  randomBytes: (bytesLength?: number) => Uint8Array;\n  lowS?: boolean;\n  bits2int?: (bytes: Uint8Array) => bigint;\n  bits2int_modN?: (bytes: Uint8Array) => bigint;\n};\n\nfunction validateOpts(curve: CurveType) {\n  const opts = validateBasic(curve);\n  ut.validateObject(\n    opts,\n    {\n      hash: 'hash',\n      hmac: 'function',\n      randomBytes: 'function',\n    },\n    {\n      bits2int: 'function',\n      bits2int_modN: 'function',\n      lowS: 'boolean',\n    }\n  );\n  return Object.freeze({ lowS: true, ...opts } as const);\n}\n\nexport type CurveFn = {\n  CURVE: ReturnType<typeof validateOpts>;\n  getPublicKey: (privateKey: PrivKey, isCompressed?: boolean) => Uint8Array;\n  getSharedSecret: (privateA: PrivKey, publicB: Hex, isCompressed?: boolean) => Uint8Array;\n  sign: (msgHash: Hex, privKey: PrivKey, opts?: SignOpts) => RecoveredSignatureType;\n  verify: (signature: Hex | SignatureLike, msgHash: Hex, publicKey: Hex, opts?: VerOpts) => boolean;\n  ProjectivePoint: ProjConstructor<bigint>;\n  Signature: SignatureConstructor;\n  utils: {\n    normPrivateKeyToScalar: (key: PrivKey) => bigint;\n    isValidPrivateKey(privateKey: PrivKey): boolean;\n    randomPrivateKey: () => Uint8Array;\n    precompute: (windowSize?: number, point?: ProjPointType<bigint>) => ProjPointType<bigint>;\n  };\n};\n\nexport function weierstrass(curveDef: CurveType): CurveFn {\n  const CURVE = validateOpts(curveDef) as ReturnType<typeof validateOpts>;\n  const { Fp, n: CURVE_ORDER } = CURVE;\n  const compressedLen = Fp.BYTES + 1; // e.g. 33 for 32\n  const uncompressedLen = 2 * Fp.BYTES + 1; // e.g. 65 for 32\n\n  function isValidFieldElement(num: bigint): boolean {\n    return _0n < num && num < Fp.ORDER; // 0 is banned since it's not invertible FE\n  }\n  function modN(a: bigint) {\n    return mod.mod(a, CURVE_ORDER);\n  }\n  function invN(a: bigint) {\n    return mod.invert(a, CURVE_ORDER);\n  }\n\n  const {\n    ProjectivePoint: Point,\n    normPrivateKeyToScalar,\n    weierstrassEquation,\n    isWithinCurveOrder,\n  } = weierstrassPoints({\n    ...CURVE,\n    toBytes(c, point, isCompressed: boolean): Uint8Array {\n      const a = point.toAffine();\n      const x = Fp.toBytes(a.x);\n      const cat = ut.concatBytes;\n      if (isCompressed) {\n        return cat(Uint8Array.from([point.hasEvenY() ? 0x02 : 0x03]), x);\n      } else {\n        return cat(Uint8Array.from([0x04]), x, Fp.toBytes(a.y));\n      }\n    },\n    fromBytes(bytes: Uint8Array) {\n      const len = bytes.length;\n      const head = bytes[0];\n      const tail = bytes.subarray(1);\n      // this.assertValidity() is done inside of fromHex\n      if (len === compressedLen && (head === 0x02 || head === 0x03)) {\n        const x = ut.bytesToNumberBE(tail);\n        if (!isValidFieldElement(x)) throw new Error('Point is not on curve');\n        const y2 = weierstrassEquation(x); // y² = x³ + ax + b\n        let y = Fp.sqrt(y2); // y = y² ^ (p+1)/4\n        const isYOdd = (y & _1n) === _1n;\n        // ECDSA\n        const isHeadOdd = (head & 1) === 1;\n        if (isHeadOdd !== isYOdd) y = Fp.neg(y);\n        return { x, y };\n      } else if (len === uncompressedLen && head === 0x04) {\n        const x = Fp.fromBytes(tail.subarray(0, Fp.BYTES));\n        const y = Fp.fromBytes(tail.subarray(Fp.BYTES, 2 * Fp.BYTES));\n        return { x, y };\n      } else {\n        throw new Error(\n          `Point of length ${len} was invalid. Expected ${compressedLen} compressed bytes or ${uncompressedLen} uncompressed bytes`\n        );\n      }\n    },\n  });\n  const numToNByteStr = (num: bigint): string =>\n    ut.bytesToHex(ut.numberToBytesBE(num, CURVE.nByteLength));\n\n  function isBiggerThanHalfOrder(number: bigint) {\n    const HALF = CURVE_ORDER >> _1n;\n    return number > HALF;\n  }\n\n  function normalizeS(s: bigint) {\n    return isBiggerThanHalfOrder(s) ? modN(-s) : s;\n  }\n  // slice bytes num\n  const slcNum = (b: Uint8Array, from: number, to: number) => ut.bytesToNumberBE(b.slice(from, to));\n\n  /**\n   * ECDSA signature with its (r, s) properties. Supports DER & compact representations.\n   */\n  class Signature implements SignatureType {\n    constructor(readonly r: bigint, readonly s: bigint, readonly recovery?: number) {\n      this.assertValidity();\n    }\n\n    // pair (bytes of r, bytes of s)\n    static fromCompact(hex: Hex) {\n      const l = CURVE.nByteLength;\n      hex = ensureBytes('compactSignature', hex, l * 2);\n      return new Signature(slcNum(hex, 0, l), slcNum(hex, l, 2 * l));\n    }\n\n    // DER encoded ECDSA signature\n    // https://bitcoin.stackexchange.com/questions/57644/what-are-the-parts-of-a-bitcoin-transaction-input-script\n    static fromDER(hex: Hex) {\n      const { r, s } = DER.toSig(ensureBytes('DER', hex));\n      return new Signature(r, s);\n    }\n\n    assertValidity(): void {\n      // can use assertGE here\n      if (!isWithinCurveOrder(this.r)) throw new Error('r must be 0 < r < CURVE.n');\n      if (!isWithinCurveOrder(this.s)) throw new Error('s must be 0 < s < CURVE.n');\n    }\n\n    addRecoveryBit(recovery: number): RecoveredSignature {\n      return new Signature(this.r, this.s, recovery) as RecoveredSignature;\n    }\n\n    recoverPublicKey(msgHash: Hex): typeof Point.BASE {\n      const { r, s, recovery: rec } = this;\n      const h = bits2int_modN(ensureBytes('msgHash', msgHash)); // Truncate hash\n      if (rec == null || ![0, 1, 2, 3].includes(rec)) throw new Error('recovery id invalid');\n      const radj = rec === 2 || rec === 3 ? r + CURVE.n : r;\n      if (radj >= Fp.ORDER) throw new Error('recovery id 2 or 3 invalid');\n      const prefix = (rec & 1) === 0 ? '02' : '03';\n      const R = Point.fromHex(prefix + numToNByteStr(radj));\n      const ir = invN(radj); // r^-1\n      const u1 = modN(-h * ir); // -hr^-1\n      const u2 = modN(s * ir); // sr^-1\n      const Q = Point.BASE.multiplyAndAddUnsafe(R, u1, u2); // (sr^-1)R-(hr^-1)G = -(hr^-1)G + (sr^-1)\n      if (!Q) throw new Error('point at infinify'); // unsafe is fine: no priv data leaked\n      Q.assertValidity();\n      return Q;\n    }\n\n    // Signatures should be low-s, to prevent malleability.\n    hasHighS(): boolean {\n      return isBiggerThanHalfOrder(this.s);\n    }\n\n    normalizeS() {\n      return this.hasHighS() ? new Signature(this.r, modN(-this.s), this.recovery) : this;\n    }\n\n    // DER-encoded\n    toDERRawBytes() {\n      return ut.hexToBytes(this.toDERHex());\n    }\n    toDERHex() {\n      return DER.hexFromSig({ r: this.r, s: this.s });\n    }\n\n    // padded bytes of r, then padded bytes of s\n    toCompactRawBytes() {\n      return ut.hexToBytes(this.toCompactHex());\n    }\n    toCompactHex() {\n      return numToNByteStr(this.r) + numToNByteStr(this.s);\n    }\n  }\n  type RecoveredSignature = Signature & { recovery: number };\n\n  const utils = {\n    isValidPrivateKey(privateKey: PrivKey) {\n      try {\n        normPrivateKeyToScalar(privateKey);\n        return true;\n      } catch (error) {\n        return false;\n      }\n    },\n    normPrivateKeyToScalar: normPrivateKeyToScalar,\n\n    /**\n     * Produces cryptographically secure private key from random of size (nBitLength+64)\n     * as per FIPS 186 B.4.1 with modulo bias being neglible.\n     */\n    randomPrivateKey: (): Uint8Array => {\n      const rand = CURVE.randomBytes(Fp.BYTES + 8);\n      const num = mod.hashToPrivateScalar(rand, CURVE_ORDER);\n      return ut.numberToBytesBE(num, CURVE.nByteLength);\n    },\n\n    /**\n     * Creates precompute table for an arbitrary EC point. Makes point \"cached\".\n     * Allows to massively speed-up `point.multiply(scalar)`.\n     * @returns cached point\n     * @example\n     * const fast = utils.precompute(8, ProjectivePoint.fromHex(someonesPubKey));\n     * fast.multiply(privKey); // much faster ECDH now\n     */\n    precompute(windowSize = 8, point = Point.BASE): typeof Point.BASE {\n      point._setWindowSize(windowSize);\n      point.multiply(BigInt(3)); // 3 is arbitrary, just need any number here\n      return point;\n    },\n  };\n\n  /**\n   * Computes public key for a private key. Checks for validity of the private key.\n   * @param privateKey private key\n   * @param isCompressed whether to return compact (default), or full key\n   * @returns Public key, full when isCompressed=false; short when isCompressed=true\n   */\n  function getPublicKey(privateKey: PrivKey, isCompressed = true): Uint8Array {\n    return Point.fromPrivateKey(privateKey).toRawBytes(isCompressed);\n  }\n\n  /**\n   * Quick and dirty check for item being public key. Does not validate hex, or being on-curve.\n   */\n  function isProbPub(item: PrivKey | PubKey): boolean {\n    const arr = item instanceof Uint8Array;\n    const str = typeof item === 'string';\n    const len = (arr || str) && (item as Hex).length;\n    if (arr) return len === compressedLen || len === uncompressedLen;\n    if (str) return len === 2 * compressedLen || len === 2 * uncompressedLen;\n    if (item instanceof Point) return true;\n    return false;\n  }\n\n  /**\n   * ECDH (Elliptic Curve Diffie Hellman).\n   * Computes shared public key from private key and public key.\n   * Checks: 1) private key validity 2) shared key is on-curve.\n   * Does NOT hash the result.\n   * @param privateA private key\n   * @param publicB different public key\n   * @param isCompressed whether to return compact (default), or full key\n   * @returns shared public key\n   */\n  function getSharedSecret(privateA: PrivKey, publicB: Hex, isCompressed = true): Uint8Array {\n    if (isProbPub(privateA)) throw new Error('first arg must be private key');\n    if (!isProbPub(publicB)) throw new Error('second arg must be public key');\n    const b = Point.fromHex(publicB); // check for being on-curve\n    return b.multiply(normPrivateKeyToScalar(privateA)).toRawBytes(isCompressed);\n  }\n\n  // RFC6979: ensure ECDSA msg is X bytes and < N. RFC suggests optional truncating via bits2octets.\n  // FIPS 186-4 4.6 suggests the leftmost min(nBitLen, outLen) bits, which matches bits2int.\n  // bits2int can produce res>N, we can do mod(res, N) since the bitLen is the same.\n  // int2octets can't be used; pads small msgs with 0: unacceptatble for trunc as per RFC vectors\n  const bits2int =\n    CURVE.bits2int ||\n    function (bytes: Uint8Array): bigint {\n      // For curves with nBitLength % 8 !== 0: bits2octets(bits2octets(m)) !== bits2octets(m)\n      // for some cases, since bytes.length * 8 is not actual bitLength.\n      const num = ut.bytesToNumberBE(bytes); // check for == u8 done here\n      const delta = bytes.length * 8 - CURVE.nBitLength; // truncate to nBitLength leftmost bits\n      return delta > 0 ? num >> BigInt(delta) : num;\n    };\n  const bits2int_modN =\n    CURVE.bits2int_modN ||\n    function (bytes: Uint8Array): bigint {\n      return modN(bits2int(bytes)); // can't use bytesToNumberBE here\n    };\n  // NOTE: pads output with zero as per spec\n  const ORDER_MASK = ut.bitMask(CURVE.nBitLength);\n  /**\n   * Converts to bytes. Checks if num in `[0..ORDER_MASK-1]` e.g.: `[0..2^256-1]`.\n   */\n  function int2octets(num: bigint): Uint8Array {\n    if (typeof num !== 'bigint') throw new Error('bigint expected');\n    if (!(_0n <= num && num < ORDER_MASK))\n      throw new Error(`bigint expected < 2^${CURVE.nBitLength}`);\n    // works with order, can have different size than numToField!\n    return ut.numberToBytesBE(num, CURVE.nByteLength);\n  }\n\n  // Steps A, D of RFC6979 3.2\n  // Creates RFC6979 seed; converts msg/privKey to numbers.\n  // Used only in sign, not in verify.\n  // NOTE: we cannot assume here that msgHash has same amount of bytes as curve order, this will be wrong at least for P521.\n  // Also it can be bigger for P224 + SHA256\n  function prepSig(msgHash: Hex, privateKey: PrivKey, opts = defaultSigOpts) {\n    if (['recovered', 'canonical'].some((k) => k in opts))\n      throw new Error('sign() legacy options not supported');\n    const { hash, randomBytes } = CURVE;\n    let { lowS, prehash, extraEntropy: ent } = opts; // generates low-s sigs by default\n    if (lowS == null) lowS = true; // RFC6979 3.2: we skip step A, because we already provide hash\n    msgHash = ensureBytes('msgHash', msgHash);\n    if (prehash) msgHash = ensureBytes('prehashed msgHash', hash(msgHash));\n\n    // We can't later call bits2octets, since nested bits2int is broken for curves\n    // with nBitLength % 8 !== 0. Because of that, we unwrap it here as int2octets call.\n    // const bits2octets = (bits) => int2octets(bits2int_modN(bits))\n    const h1int = bits2int_modN(msgHash);\n    const d = normPrivateKeyToScalar(privateKey); // validate private key, convert to bigint\n    const seedArgs = [int2octets(d), int2octets(h1int)];\n    // extraEntropy. RFC6979 3.6: additional k' (optional).\n    if (ent != null) {\n      // K = HMAC_K(V || 0x00 || int2octets(x) || bits2octets(h1) || k')\n      const e = ent === true ? randomBytes(Fp.BYTES) : ent; // generate random bytes OR pass as-is\n      seedArgs.push(ensureBytes('extraEntropy', e, Fp.BYTES)); // check for being of size BYTES\n    }\n    const seed = ut.concatBytes(...seedArgs); // Step D of RFC6979 3.2\n    const m = h1int; // NOTE: no need to call bits2int second time here, it is inside truncateHash!\n    // Converts signature params into point w r/s, checks result for validity.\n    function k2sig(kBytes: Uint8Array): RecoveredSignature | undefined {\n      // RFC 6979 Section 3.2, step 3: k = bits2int(T)\n      const k = bits2int(kBytes); // Cannot use fields methods, since it is group element\n      if (!isWithinCurveOrder(k)) return; // Important: all mod() calls here must be done over N\n      const ik = invN(k); // k^-1 mod n\n      const q = Point.BASE.multiply(k).toAffine(); // q = Gk\n      const r = modN(q.x); // r = q.x mod n\n      if (r === _0n) return;\n      // Can use scalar blinding b^-1(bm + bdr) where b ∈ [1,q−1] according to\n      // https://tches.iacr.org/index.php/TCHES/article/view/7337/6509. We've decided against it:\n      // a) dependency on CSPRNG b) 15% slowdown c) doesn't really help since bigints are not CT\n      const s = modN(ik * modN(m + r * d)); // Not using blinding here\n      if (s === _0n) return;\n      let recovery = (q.x === r ? 0 : 2) | Number(q.y & _1n); // recovery bit (2 or 3, when q.x > n)\n      let normS = s;\n      if (lowS && isBiggerThanHalfOrder(s)) {\n        normS = normalizeS(s); // if lowS was passed, ensure s is always\n        recovery ^= 1; // // in the bottom half of N\n      }\n      return new Signature(r, normS, recovery) as RecoveredSignature; // use normS, not s\n    }\n    return { seed, k2sig };\n  }\n  const defaultSigOpts: SignOpts = { lowS: CURVE.lowS, prehash: false };\n  const defaultVerOpts: VerOpts = { lowS: CURVE.lowS, prehash: false };\n\n  /**\n   * Signs message hash with a private key.\n   * ```\n   * sign(m, d, k) where\n   *   (x, y) = G × k\n   *   r = x mod n\n   *   s = (m + dr)/k mod n\n   * ```\n   * @param msgHash NOT message. msg needs to be hashed to `msgHash`, or use `prehash`.\n   * @param privKey private key\n   * @param opts lowS for non-malleable sigs. extraEntropy for mixing randomness into k. prehash will hash first arg.\n   * @returns signature with recovery param\n   */\n  function sign(msgHash: Hex, privKey: PrivKey, opts = defaultSigOpts): RecoveredSignature {\n    const { seed, k2sig } = prepSig(msgHash, privKey, opts); // Steps A, D of RFC6979 3.2.\n    const C = CURVE;\n    const drbg = ut.createHmacDrbg<RecoveredSignature>(C.hash.outputLen, C.nByteLength, C.hmac);\n    return drbg(seed, k2sig); // Steps B, C, D, E, F, G\n  }\n\n  // Enable precomputes. Slows down first publicKey computation by 20ms.\n  Point.BASE._setWindowSize(8);\n  // utils.precompute(8, ProjectivePoint.BASE)\n\n  /**\n   * Verifies a signature against message hash and public key.\n   * Rejects lowS signatures by default: to override,\n   * specify option `{lowS: false}`. Implements section 4.1.4 from https://www.secg.org/sec1-v2.pdf:\n   *\n   * ```\n   * verify(r, s, h, P) where\n   *   U1 = hs^-1 mod n\n   *   U2 = rs^-1 mod n\n   *   R = U1⋅G - U2⋅P\n   *   mod(R.x, n) == r\n   * ```\n   */\n  function verify(\n    signature: Hex | SignatureLike,\n    msgHash: Hex,\n    publicKey: Hex,\n    opts = defaultVerOpts\n  ): boolean {\n    const sg = signature;\n    msgHash = ensureBytes('msgHash', msgHash);\n    publicKey = ensureBytes('publicKey', publicKey);\n    if ('strict' in opts) throw new Error('options.strict was renamed to lowS');\n    const { lowS, prehash } = opts;\n\n    let _sig: Signature | undefined = undefined;\n    let P: ProjPointType<bigint>;\n    try {\n      if (typeof sg === 'string' || sg instanceof Uint8Array) {\n        // Signature can be represented in 2 ways: compact (2*nByteLength) & DER (variable-length).\n        // Since DER can also be 2*nByteLength bytes, we check for it first.\n        try {\n          _sig = Signature.fromDER(sg);\n        } catch (derError) {\n          if (!(derError instanceof DER.Err)) throw derError;\n          _sig = Signature.fromCompact(sg);\n        }\n      } else if (typeof sg === 'object' && typeof sg.r === 'bigint' && typeof sg.s === 'bigint') {\n        const { r, s } = sg;\n        _sig = new Signature(r, s);\n      } else {\n        throw new Error('PARSE');\n      }\n      P = Point.fromHex(publicKey);\n    } catch (error) {\n      if ((error as Error).message === 'PARSE')\n        throw new Error(`signature must be Signature instance, Uint8Array or hex string`);\n      return false;\n    }\n    if (lowS && _sig.hasHighS()) return false;\n    if (prehash) msgHash = CURVE.hash(msgHash);\n    const { r, s } = _sig;\n    const h = bits2int_modN(msgHash); // Cannot use fields methods, since it is group element\n    const is = invN(s); // s^-1\n    const u1 = modN(h * is); // u1 = hs^-1 mod n\n    const u2 = modN(r * is); // u2 = rs^-1 mod n\n    const R = Point.BASE.multiplyAndAddUnsafe(P, u1, u2)?.toAffine(); // R = u1⋅G + u2⋅P\n    if (!R) return false;\n    const v = modN(R.x);\n    return v === r;\n  }\n  return {\n    CURVE,\n    getPublicKey,\n    getSharedSecret,\n    sign,\n    verify,\n    ProjectivePoint: Point,\n    Signature,\n    utils,\n  };\n}\n\n/**\n * Implementation of the Shallue and van de Woestijne method for any weierstrass curve.\n * TODO: check if there is a way to merge this with uvRatio in Edwards; move to modular.\n * b = True and y = sqrt(u / v) if (u / v) is square in F, and\n * b = False and y = sqrt(Z * (u / v)) otherwise.\n * @param Fp\n * @param Z\n * @returns\n */\nexport function SWUFpSqrtRatio<T>(Fp: mod.IField<T>, Z: T) {\n  // Generic implementation\n  const q = Fp.ORDER;\n  let l = _0n;\n  for (let o = q - _1n; o % _2n === _0n; o /= _2n) l += _1n;\n  const c1 = l; // 1. c1, the largest integer such that 2^c1 divides q - 1.\n  // We need 2n ** c1 and 2n ** (c1-1). We can't use **; but we can use <<.\n  // 2n ** c1 == 2n << (c1-1)\n  const _2n_pow_c1_1 = _2n << (c1 - _1n - _1n);\n  const _2n_pow_c1 = _2n_pow_c1_1 * _2n;\n  const c2 = (q - _1n) / _2n_pow_c1; // 2. c2 = (q - 1) / (2^c1)  # Integer arithmetic\n  const c3 = (c2 - _1n) / _2n; // 3. c3 = (c2 - 1) / 2            # Integer arithmetic\n  const c4 = _2n_pow_c1 - _1n; // 4. c4 = 2^c1 - 1                # Integer arithmetic\n  const c5 = _2n_pow_c1_1; // 5. c5 = 2^(c1 - 1)                  # Integer arithmetic\n  const c6 = Fp.pow(Z, c2); // 6. c6 = Z^c2\n  const c7 = Fp.pow(Z, (c2 + _1n) / _2n); // 7. c7 = Z^((c2 + 1) / 2)\n  let sqrtRatio = (u: T, v: T): { isValid: boolean; value: T } => {\n    let tv1 = c6; // 1. tv1 = c6\n    let tv2 = Fp.pow(v, c4); // 2. tv2 = v^c4\n    let tv3 = Fp.sqr(tv2); // 3. tv3 = tv2^2\n    tv3 = Fp.mul(tv3, v); // 4. tv3 = tv3 * v\n    let tv5 = Fp.mul(u, tv3); // 5. tv5 = u * tv3\n    tv5 = Fp.pow(tv5, c3); // 6. tv5 = tv5^c3\n    tv5 = Fp.mul(tv5, tv2); // 7. tv5 = tv5 * tv2\n    tv2 = Fp.mul(tv5, v); // 8. tv2 = tv5 * v\n    tv3 = Fp.mul(tv5, u); // 9. tv3 = tv5 * u\n    let tv4 = Fp.mul(tv3, tv2); // 10. tv4 = tv3 * tv2\n    tv5 = Fp.pow(tv4, c5); // 11. tv5 = tv4^c5\n    let isQR = Fp.eql(tv5, Fp.ONE); // 12. isQR = tv5 == 1\n    tv2 = Fp.mul(tv3, c7); // 13. tv2 = tv3 * c7\n    tv5 = Fp.mul(tv4, tv1); // 14. tv5 = tv4 * tv1\n    tv3 = Fp.cmov(tv2, tv3, isQR); // 15. tv3 = CMOV(tv2, tv3, isQR)\n    tv4 = Fp.cmov(tv5, tv4, isQR); // 16. tv4 = CMOV(tv5, tv4, isQR)\n    // 17. for i in (c1, c1 - 1, ..., 2):\n    for (let i = c1; i > _1n; i--) {\n      let tv5 = i - _2n; // 18.    tv5 = i - 2\n      tv5 = _2n << (tv5 - _1n); // 19.    tv5 = 2^tv5\n      let tvv5 = Fp.pow(tv4, tv5); // 20.    tv5 = tv4^tv5\n      const e1 = Fp.eql(tvv5, Fp.ONE); // 21.    e1 = tv5 == 1\n      tv2 = Fp.mul(tv3, tv1); // 22.    tv2 = tv3 * tv1\n      tv1 = Fp.mul(tv1, tv1); // 23.    tv1 = tv1 * tv1\n      tvv5 = Fp.mul(tv4, tv1); // 24.    tv5 = tv4 * tv1\n      tv3 = Fp.cmov(tv2, tv3, e1); // 25.    tv3 = CMOV(tv2, tv3, e1)\n      tv4 = Fp.cmov(tvv5, tv4, e1); // 26.    tv4 = CMOV(tv5, tv4, e1)\n    }\n    return { isValid: isQR, value: tv3 };\n  };\n  if (Fp.ORDER % _4n === _3n) {\n    // sqrt_ratio_3mod4(u, v)\n    const c1 = (Fp.ORDER - _3n) / _4n; // 1. c1 = (q - 3) / 4     # Integer arithmetic\n    const c2 = Fp.sqrt(Fp.neg(Z)); // 2. c2 = sqrt(-Z)\n    sqrtRatio = (u: T, v: T) => {\n      let tv1 = Fp.sqr(v); // 1. tv1 = v^2\n      const tv2 = Fp.mul(u, v); // 2. tv2 = u * v\n      tv1 = Fp.mul(tv1, tv2); // 3. tv1 = tv1 * tv2\n      let y1 = Fp.pow(tv1, c1); // 4. y1 = tv1^c1\n      y1 = Fp.mul(y1, tv2); // 5. y1 = y1 * tv2\n      const y2 = Fp.mul(y1, c2); // 6. y2 = y1 * c2\n      const tv3 = Fp.mul(Fp.sqr(y1), v); // 7. tv3 = y1^2; 8. tv3 = tv3 * v\n      const isQR = Fp.eql(tv3, u); // 9. isQR = tv3 == u\n      let y = Fp.cmov(y2, y1, isQR); // 10. y = CMOV(y2, y1, isQR)\n      return { isValid: isQR, value: y }; // 11. return (isQR, y) isQR ? y : y*c2\n    };\n  }\n  // No curves uses that\n  // if (Fp.ORDER % _8n === _5n) // sqrt_ratio_5mod8\n  return sqrtRatio;\n}\n/**\n * From draft-irtf-cfrg-hash-to-curve-16\n */\nexport function mapToCurveSimpleSWU<T>(\n  Fp: mod.IField<T>,\n  opts: {\n    A: T;\n    B: T;\n    Z: T;\n  }\n) {\n  mod.validateField(Fp);\n  if (!Fp.isValid(opts.A) || !Fp.isValid(opts.B) || !Fp.isValid(opts.Z))\n    throw new Error('mapToCurveSimpleSWU: invalid opts');\n  const sqrtRatio = SWUFpSqrtRatio(Fp, opts.Z);\n  if (!Fp.isOdd) throw new Error('Fp.isOdd is not implemented!');\n  // Input: u, an element of F.\n  // Output: (x, y), a point on E.\n  return (u: T): { x: T; y: T } => {\n    // prettier-ignore\n    let tv1, tv2, tv3, tv4, tv5, tv6, x, y;\n    tv1 = Fp.sqr(u); // 1.  tv1 = u^2\n    tv1 = Fp.mul(tv1, opts.Z); // 2.  tv1 = Z * tv1\n    tv2 = Fp.sqr(tv1); // 3.  tv2 = tv1^2\n    tv2 = Fp.add(tv2, tv1); // 4.  tv2 = tv2 + tv1\n    tv3 = Fp.add(tv2, Fp.ONE); // 5.  tv3 = tv2 + 1\n    tv3 = Fp.mul(tv3, opts.B); // 6.  tv3 = B * tv3\n    tv4 = Fp.cmov(opts.Z, Fp.neg(tv2), !Fp.eql(tv2, Fp.ZERO)); // 7.  tv4 = CMOV(Z, -tv2, tv2 != 0)\n    tv4 = Fp.mul(tv4, opts.A); // 8.  tv4 = A * tv4\n    tv2 = Fp.sqr(tv3); // 9.  tv2 = tv3^2\n    tv6 = Fp.sqr(tv4); // 10. tv6 = tv4^2\n    tv5 = Fp.mul(tv6, opts.A); // 11. tv5 = A * tv6\n    tv2 = Fp.add(tv2, tv5); // 12. tv2 = tv2 + tv5\n    tv2 = Fp.mul(tv2, tv3); // 13. tv2 = tv2 * tv3\n    tv6 = Fp.mul(tv6, tv4); // 14. tv6 = tv6 * tv4\n    tv5 = Fp.mul(tv6, opts.B); // 15. tv5 = B * tv6\n    tv2 = Fp.add(tv2, tv5); // 16. tv2 = tv2 + tv5\n    x = Fp.mul(tv1, tv3); // 17.   x = tv1 * tv3\n    const { isValid, value } = sqrtRatio(tv2, tv6); // 18. (is_gx1_square, y1) = sqrt_ratio(tv2, tv6)\n    y = Fp.mul(tv1, u); // 19.   y = tv1 * u  -> Z * u^3 * y1\n    y = Fp.mul(y, value); // 20.   y = y * y1\n    x = Fp.cmov(x, tv3, isValid); // 21.   x = CMOV(x, tv3, is_gx1_square)\n    y = Fp.cmov(y, value, isValid); // 22.   y = CMOV(y, y1, is_gx1_square)\n    const e1 = Fp.isOdd!(u) === Fp.isOdd!(y); // 23.  e1 = sgn0(u) == sgn0(y)\n    y = Fp.cmov(Fp.neg(y), y, e1); // 24.   y = CMOV(-y, y, e1)\n    x = Fp.div(x, tv4); // 25.   x = x / tv4\n    return { x, y };\n  };\n}\n","/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */\n// Utilities for modular arithmetics and finite fields\nimport {\n  bitMask,\n  numberToBytesBE,\n  numberToBytesLE,\n  bytesToNumberBE,\n  bytesToNumberLE,\n  ensureBytes,\n  validateObject,\n} from './utils.js';\n// prettier-ignore\nconst _0n = BigInt(0), _1n = BigInt(1), _2n = BigInt(2), _3n = BigInt(3);\n// prettier-ignore\nconst _4n = BigInt(4), _5n = BigInt(5), _8n = BigInt(8);\n// prettier-ignore\nconst _9n = BigInt(9), _16n = BigInt(16);\n\n// Calculates a modulo b\nexport function mod(a: bigint, b: bigint): bigint {\n  const result = a % b;\n  return result >= _0n ? result : b + result;\n}\n/**\n * Efficiently raise num to power and do modular division.\n * Unsafe in some contexts: uses ladder, so can expose bigint bits.\n * @example\n * pow(2n, 6n, 11n) // 64n % 11n == 9n\n */\n// TODO: use field version && remove\nexport function pow(num: bigint, power: bigint, modulo: bigint): bigint {\n  if (modulo <= _0n || power < _0n) throw new Error('Expected power/modulo > 0');\n  if (modulo === _1n) return _0n;\n  let res = _1n;\n  while (power > _0n) {\n    if (power & _1n) res = (res * num) % modulo;\n    num = (num * num) % modulo;\n    power >>= _1n;\n  }\n  return res;\n}\n\n// Does x ^ (2 ^ power) mod p. pow2(30, 4) == 30 ^ (2 ^ 4)\nexport function pow2(x: bigint, power: bigint, modulo: bigint): bigint {\n  let res = x;\n  while (power-- > _0n) {\n    res *= res;\n    res %= modulo;\n  }\n  return res;\n}\n\n// Inverses number over modulo\nexport function invert(number: bigint, modulo: bigint): bigint {\n  if (number === _0n || modulo <= _0n) {\n    throw new Error(`invert: expected positive integers, got n=${number} mod=${modulo}`);\n  }\n  // Euclidean GCD https://brilliant.org/wiki/extended-euclidean-algorithm/\n  // Fermat's little theorem \"CT-like\" version inv(n) = n^(m-2) mod m is 30x slower.\n  let a = mod(number, modulo);\n  let b = modulo;\n  // prettier-ignore\n  let x = _0n, y = _1n, u = _1n, v = _0n;\n  while (a !== _0n) {\n    // JIT applies optimization if those two lines follow each other\n    const q = b / a;\n    const r = b % a;\n    const m = x - u * q;\n    const n = y - v * q;\n    // prettier-ignore\n    b = a, a = r, x = u, y = v, u = m, v = n;\n  }\n  const gcd = b;\n  if (gcd !== _1n) throw new Error('invert: does not exist');\n  return mod(x, modulo);\n}\n\n// Tonelli-Shanks algorithm\n// Paper 1: https://eprint.iacr.org/2012/685.pdf (page 12)\n// Paper 2: Square Roots from 1; 24, 51, 10 to Dan Shanks\nexport function tonelliShanks(P: bigint) {\n  // Legendre constant: used to calculate Legendre symbol (a | p),\n  // which denotes the value of a^((p-1)/2) (mod p).\n  // (a | p) ≡ 1    if a is a square (mod p)\n  // (a | p) ≡ -1   if a is not a square (mod p)\n  // (a | p) ≡ 0    if a ≡ 0 (mod p)\n  const legendreC = (P - _1n) / _2n;\n\n  let Q: bigint, S: number, Z: bigint;\n  // Step 1: By factoring out powers of 2 from p - 1,\n  // find q and s such that p - 1 = q*(2^s) with q odd\n  for (Q = P - _1n, S = 0; Q % _2n === _0n; Q /= _2n, S++);\n\n  // Step 2: Select a non-square z such that (z | p) ≡ -1 and set c ≡ zq\n  for (Z = _2n; Z < P && pow(Z, legendreC, P) !== P - _1n; Z++);\n\n  // Fast-path\n  if (S === 1) {\n    const p1div4 = (P + _1n) / _4n;\n    return function tonelliFast<T>(Fp: IField<T>, n: T) {\n      const root = Fp.pow(n, p1div4);\n      if (!Fp.eql(Fp.sqr(root), n)) throw new Error('Cannot find square root');\n      return root;\n    };\n  }\n\n  // Slow-path\n  const Q1div2 = (Q + _1n) / _2n;\n  return function tonelliSlow<T>(Fp: IField<T>, n: T): T {\n    // Step 0: Check that n is indeed a square: (n | p) should not be ≡ -1\n    if (Fp.pow(n, legendreC) === Fp.neg(Fp.ONE)) throw new Error('Cannot find square root');\n    let r = S;\n    // TODO: will fail at Fp2/etc\n    let g = Fp.pow(Fp.mul(Fp.ONE, Z), Q); // will update both x and b\n    let x = Fp.pow(n, Q1div2); // first guess at the square root\n    let b = Fp.pow(n, Q); // first guess at the fudge factor\n\n    while (!Fp.eql(b, Fp.ONE)) {\n      if (Fp.eql(b, Fp.ZERO)) return Fp.ZERO; // https://en.wikipedia.org/wiki/Tonelli%E2%80%93Shanks_algorithm (4. If t = 0, return r = 0)\n      // Find m such b^(2^m)==1\n      let m = 1;\n      for (let t2 = Fp.sqr(b); m < r; m++) {\n        if (Fp.eql(t2, Fp.ONE)) break;\n        t2 = Fp.sqr(t2); // t2 *= t2\n      }\n      // NOTE: r-m-1 can be bigger than 32, need to convert to bigint before shift, otherwise there will be overflow\n      const ge = Fp.pow(g, _1n << BigInt(r - m - 1)); // ge = 2^(r-m-1)\n      g = Fp.sqr(ge); // g = ge * ge\n      x = Fp.mul(x, ge); // x *= ge\n      b = Fp.mul(b, g); // b *= g\n      r = m;\n    }\n    return x;\n  };\n}\n\nexport function FpSqrt(P: bigint) {\n  // NOTE: different algorithms can give different roots, it is up to user to decide which one they want.\n  // For example there is FpSqrtOdd/FpSqrtEven to choice root based on oddness (used for hash-to-curve).\n\n  // P ≡ 3 (mod 4)\n  // √n = n^((P+1)/4)\n  if (P % _4n === _3n) {\n    // Not all roots possible!\n    // const ORDER =\n    //   0x1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a0f6b0f6241eabfffeb153ffffb9feffffffffaaabn;\n    // const NUM = 72057594037927816n;\n    const p1div4 = (P + _1n) / _4n;\n    return function sqrt3mod4<T>(Fp: IField<T>, n: T) {\n      const root = Fp.pow(n, p1div4);\n      // Throw if root**2 != n\n      if (!Fp.eql(Fp.sqr(root), n)) throw new Error('Cannot find square root');\n      return root;\n    };\n  }\n\n  // Atkin algorithm for q ≡ 5 (mod 8), https://eprint.iacr.org/2012/685.pdf (page 10)\n  if (P % _8n === _5n) {\n    const c1 = (P - _5n) / _8n;\n    return function sqrt5mod8<T>(Fp: IField<T>, n: T) {\n      const n2 = Fp.mul(n, _2n);\n      const v = Fp.pow(n2, c1);\n      const nv = Fp.mul(n, v);\n      const i = Fp.mul(Fp.mul(nv, _2n), v);\n      const root = Fp.mul(nv, Fp.sub(i, Fp.ONE));\n      if (!Fp.eql(Fp.sqr(root), n)) throw new Error('Cannot find square root');\n      return root;\n    };\n  }\n\n  // P ≡ 9 (mod 16)\n  if (P % _16n === _9n) {\n    // NOTE: tonelli is too slow for bls-Fp2 calculations even on start\n    // Means we cannot use sqrt for constants at all!\n    //\n    // const c1 = Fp.sqrt(Fp.negate(Fp.ONE)); //  1. c1 = sqrt(-1) in F, i.e., (c1^2) == -1 in F\n    // const c2 = Fp.sqrt(c1);                //  2. c2 = sqrt(c1) in F, i.e., (c2^2) == c1 in F\n    // const c3 = Fp.sqrt(Fp.negate(c1));     //  3. c3 = sqrt(-c1) in F, i.e., (c3^2) == -c1 in F\n    // const c4 = (P + _7n) / _16n;           //  4. c4 = (q + 7) / 16        # Integer arithmetic\n    // sqrt = (x) => {\n    //   let tv1 = Fp.pow(x, c4);             //  1. tv1 = x^c4\n    //   let tv2 = Fp.mul(c1, tv1);           //  2. tv2 = c1 * tv1\n    //   const tv3 = Fp.mul(c2, tv1);         //  3. tv3 = c2 * tv1\n    //   let tv4 = Fp.mul(c3, tv1);           //  4. tv4 = c3 * tv1\n    //   const e1 = Fp.equals(Fp.square(tv2), x); //  5.  e1 = (tv2^2) == x\n    //   const e2 = Fp.equals(Fp.square(tv3), x); //  6.  e2 = (tv3^2) == x\n    //   tv1 = Fp.cmov(tv1, tv2, e1); //  7. tv1 = CMOV(tv1, tv2, e1)  # Select tv2 if (tv2^2) == x\n    //   tv2 = Fp.cmov(tv4, tv3, e2); //  8. tv2 = CMOV(tv4, tv3, e2)  # Select tv3 if (tv3^2) == x\n    //   const e3 = Fp.equals(Fp.square(tv2), x); //  9.  e3 = (tv2^2) == x\n    //   return Fp.cmov(tv1, tv2, e3); //  10.  z = CMOV(tv1, tv2, e3)  # Select the sqrt from tv1 and tv2\n    // }\n  }\n\n  // Other cases: Tonelli-Shanks algorithm\n  return tonelliShanks(P);\n}\n\n// Little-endian check for first LE bit (last BE bit);\nexport const isNegativeLE = (num: bigint, modulo: bigint) => (mod(num, modulo) & _1n) === _1n;\n\n// Field is not always over prime, Fp2 for example has ORDER(q)=p^m\nexport interface IField<T> {\n  ORDER: bigint;\n  BYTES: number;\n  BITS: number;\n  MASK: bigint;\n  ZERO: T;\n  ONE: T;\n  // 1-arg\n  create: (num: T) => T;\n  isValid: (num: T) => boolean;\n  is0: (num: T) => boolean;\n  neg(num: T): T;\n  inv(num: T): T;\n  sqrt(num: T): T;\n  sqr(num: T): T;\n  // 2-args\n  eql(lhs: T, rhs: T): boolean;\n  add(lhs: T, rhs: T): T;\n  sub(lhs: T, rhs: T): T;\n  mul(lhs: T, rhs: T | bigint): T;\n  pow(lhs: T, power: bigint): T;\n  div(lhs: T, rhs: T | bigint): T;\n  // N for NonNormalized (for now)\n  addN(lhs: T, rhs: T): T;\n  subN(lhs: T, rhs: T): T;\n  mulN(lhs: T, rhs: T | bigint): T;\n  sqrN(num: T): T;\n\n  // Optional\n  // Should be same as sgn0 function in https://datatracker.ietf.org/doc/draft-irtf-cfrg-hash-to-curve/\n  // NOTE: sgn0 is 'negative in LE', which is same as odd. And negative in LE is kinda strange definition anyway.\n  isOdd?(num: T): boolean; // Odd instead of even since we have it for Fp2\n  // legendre?(num: T): T;\n  pow(lhs: T, power: bigint): T;\n  invertBatch: (lst: T[]) => T[];\n  toBytes(num: T): Uint8Array;\n  fromBytes(bytes: Uint8Array): T;\n  // If c is False, CMOV returns a, otherwise it returns b.\n  cmov(a: T, b: T, c: boolean): T;\n}\n// prettier-ignore\nconst FIELD_FIELDS = [\n  'create', 'isValid', 'is0', 'neg', 'inv', 'sqrt', 'sqr',\n  'eql', 'add', 'sub', 'mul', 'pow', 'div',\n  'addN', 'subN', 'mulN', 'sqrN'\n] as const;\nexport function validateField<T>(field: IField<T>) {\n  const initial = {\n    ORDER: 'bigint',\n    MASK: 'bigint',\n    BYTES: 'isSafeInteger',\n    BITS: 'isSafeInteger',\n  } as Record<string, string>;\n  const opts = FIELD_FIELDS.reduce((map, val: string) => {\n    map[val] = 'function';\n    return map;\n  }, initial);\n  return validateObject(field, opts);\n}\n\n// Generic field functions\nexport function FpPow<T>(f: IField<T>, num: T, power: bigint): T {\n  // Should have same speed as pow for bigints\n  // TODO: benchmark!\n  if (power < _0n) throw new Error('Expected power > 0');\n  if (power === _0n) return f.ONE;\n  if (power === _1n) return num;\n  let p = f.ONE;\n  let d = num;\n  while (power > _0n) {\n    if (power & _1n) p = f.mul(p, d);\n    d = f.sqr(d);\n    power >>= _1n;\n  }\n  return p;\n}\n\n// 0 is non-invertible: non-batched version will throw on 0\nexport function FpInvertBatch<T>(f: IField<T>, nums: T[]): T[] {\n  const tmp = new Array(nums.length);\n  // Walk from first to last, multiply them by each other MOD p\n  const lastMultiplied = nums.reduce((acc, num, i) => {\n    if (f.is0(num)) return acc;\n    tmp[i] = acc;\n    return f.mul(acc, num);\n  }, f.ONE);\n  // Invert last element\n  const inverted = f.inv(lastMultiplied);\n  // Walk from last to first, multiply them by inverted each other MOD p\n  nums.reduceRight((acc, num, i) => {\n    if (f.is0(num)) return acc;\n    tmp[i] = f.mul(acc, tmp[i]);\n    return f.mul(acc, num);\n  }, inverted);\n  return tmp;\n}\n\nexport function FpDiv<T>(f: IField<T>, lhs: T, rhs: T | bigint): T {\n  return f.mul(lhs, typeof rhs === 'bigint' ? invert(rhs, f.ORDER) : f.inv(rhs));\n}\n\n// This function returns True whenever the value x is a square in the field F.\nexport function FpIsSquare<T>(f: IField<T>) {\n  const legendreConst = (f.ORDER - _1n) / _2n; // Integer arithmetic\n  return (x: T): boolean => {\n    const p = f.pow(x, legendreConst);\n    return f.eql(p, f.ZERO) || f.eql(p, f.ONE);\n  };\n}\n\n// CURVE.n lengths\nexport function nLength(n: bigint, nBitLength?: number) {\n  // Bit size, byte size of CURVE.n\n  const _nBitLength = nBitLength !== undefined ? nBitLength : n.toString(2).length;\n  const nByteLength = Math.ceil(_nBitLength / 8);\n  return { nBitLength: _nBitLength, nByteLength };\n}\n\ntype FpField = IField<bigint> & Required<Pick<IField<bigint>, 'isOdd'>>;\n/**\n * Initializes a galois field over prime. Non-primes are not supported for now.\n * Do not init in loop: slow. Very fragile: always run a benchmark on change.\n * Major performance gains:\n * a) non-normalized operations like mulN instead of mul\n * b) `Object.freeze`\n * c) Same object shape: never add or remove keys\n * @param ORDER prime positive bigint\n * @param bitLen how many bits the field consumes\n * @param isLE (def: false) if encoding / decoding should be in little-endian\n * @param redef optional faster redefinitions of sqrt and other methods\n */\nexport function Field(\n  ORDER: bigint,\n  bitLen?: number,\n  isLE = false,\n  redef: Partial<IField<bigint>> = {}\n): Readonly<FpField> {\n  if (ORDER <= _0n) throw new Error(`Expected Fp ORDER > 0, got ${ORDER}`);\n  const { nBitLength: BITS, nByteLength: BYTES } = nLength(ORDER, bitLen);\n  if (BYTES > 2048) throw new Error('Field lengths over 2048 bytes are not supported');\n  const sqrtP = FpSqrt(ORDER);\n  const f: Readonly<FpField> = Object.freeze({\n    ORDER,\n    BITS,\n    BYTES,\n    MASK: bitMask(BITS),\n    ZERO: _0n,\n    ONE: _1n,\n    create: (num) => mod(num, ORDER),\n    isValid: (num) => {\n      if (typeof num !== 'bigint')\n        throw new Error(`Invalid field element: expected bigint, got ${typeof num}`);\n      return _0n <= num && num < ORDER; // 0 is valid element, but it's not invertible\n    },\n    is0: (num) => num === _0n,\n    isOdd: (num) => (num & _1n) === _1n,\n    neg: (num) => mod(-num, ORDER),\n    eql: (lhs, rhs) => lhs === rhs,\n\n    sqr: (num) => mod(num * num, ORDER),\n    add: (lhs, rhs) => mod(lhs + rhs, ORDER),\n    sub: (lhs, rhs) => mod(lhs - rhs, ORDER),\n    mul: (lhs, rhs) => mod(lhs * rhs, ORDER),\n    pow: (num, power) => FpPow(f, num, power),\n    div: (lhs, rhs) => mod(lhs * invert(rhs, ORDER), ORDER),\n\n    // Same as above, but doesn't normalize\n    sqrN: (num) => num * num,\n    addN: (lhs, rhs) => lhs + rhs,\n    subN: (lhs, rhs) => lhs - rhs,\n    mulN: (lhs, rhs) => lhs * rhs,\n\n    inv: (num) => invert(num, ORDER),\n    sqrt: redef.sqrt || ((n) => sqrtP(f, n)),\n    invertBatch: (lst) => FpInvertBatch(f, lst),\n    // TODO: do we really need constant cmov?\n    // We don't have const-time bigints anyway, so probably will be not very useful\n    cmov: (a, b, c) => (c ? b : a),\n    toBytes: (num) => (isLE ? numberToBytesLE(num, BYTES) : numberToBytesBE(num, BYTES)),\n    fromBytes: (bytes) => {\n      if (bytes.length !== BYTES)\n        throw new Error(`Fp.fromBytes: expected ${BYTES}, got ${bytes.length}`);\n      return isLE ? bytesToNumberLE(bytes) : bytesToNumberBE(bytes);\n    },\n  } as FpField);\n  return Object.freeze(f);\n}\n\nexport function FpSqrtOdd<T>(Fp: IField<T>, elm: T) {\n  if (!Fp.isOdd) throw new Error(`Field doesn't have isOdd`);\n  const root = Fp.sqrt(elm);\n  return Fp.isOdd(root) ? root : Fp.neg(root);\n}\n\nexport function FpSqrtEven<T>(Fp: IField<T>, elm: T) {\n  if (!Fp.isOdd) throw new Error(`Field doesn't have isOdd`);\n  const root = Fp.sqrt(elm);\n  return Fp.isOdd(root) ? Fp.neg(root) : root;\n}\n\n/**\n * FIPS 186 B.4.1-compliant \"constant-time\" private key generation utility.\n * Can take (n+8) or more bytes of uniform input e.g. from CSPRNG or KDF\n * and convert them into private scalar, with the modulo bias being negligible.\n * Needs at least 40 bytes of input for 32-byte private key.\n * https://research.kudelskisecurity.com/2020/07/28/the-definitive-guide-to-modulo-bias-and-how-to-avoid-it/\n * @param hash hash output from SHA3 or a similar function\n * @param groupOrder size of subgroup - (e.g. curveFn.CURVE.n)\n * @param isLE interpret hash bytes as LE num\n * @returns valid private scalar\n */\nexport function hashToPrivateScalar(\n  hash: string | Uint8Array,\n  groupOrder: bigint,\n  isLE = false\n): bigint {\n  hash = ensureBytes('privateHash', hash);\n  const hashLen = hash.length;\n  const minLen = nLength(groupOrder).nByteLength + 8;\n  if (minLen < 24 || hashLen < minLen || hashLen > 1024)\n    throw new Error(`hashToPrivateScalar: expected ${minLen}-1024 bytes of input, got ${hashLen}`);\n  const num = isLE ? bytesToNumberLE(hash) : bytesToNumberBE(hash);\n  return mod(num, groupOrder - _1n) + _1n;\n}\n","/*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */\n// Abelian group utilities\nimport { IField, validateField, nLength } from './modular.js';\nimport { validateObject } from './utils.js';\nconst _0n = BigInt(0);\nconst _1n = BigInt(1);\n\nexport type AffinePoint<T> = {\n  x: T;\n  y: T;\n} & { z?: never; t?: never };\n\nexport interface Group<T extends Group<T>> {\n  double(): T;\n  negate(): T;\n  add(other: T): T;\n  subtract(other: T): T;\n  equals(other: T): boolean;\n  multiply(scalar: bigint): T;\n}\n\nexport type GroupConstructor<T> = {\n  BASE: T;\n  ZERO: T;\n};\nexport type Mapper<T> = (i: T[]) => T[];\n\n// Elliptic curve multiplication of Point by scalar. Fragile.\n// Scalars should always be less than curve order: this should be checked inside of a curve itself.\n// Creates precomputation tables for fast multiplication:\n// - private scalar is split by fixed size windows of W bits\n// - every window point is collected from window's table & added to accumulator\n// - since windows are different, same point inside tables won't be accessed more than once per calc\n// - each multiplication is 'Math.ceil(CURVE_ORDER / 𝑊) + 1' point additions (fixed for any scalar)\n// - +1 window is neccessary for wNAF\n// - wNAF reduces table size: 2x less memory + 2x faster generation, but 10% slower multiplication\n// TODO: Research returning 2d JS array of windows, instead of a single window. This would allow\n// windows to be in different memory locations\nexport function wNAF<T extends Group<T>>(c: GroupConstructor<T>, bits: number) {\n  const constTimeNegate = (condition: boolean, item: T): T => {\n    const neg = item.negate();\n    return condition ? neg : item;\n  };\n  const opts = (W: number) => {\n    const windows = Math.ceil(bits / W) + 1; // +1, because\n    const windowSize = 2 ** (W - 1); // -1 because we skip zero\n    return { windows, windowSize };\n  };\n  return {\n    constTimeNegate,\n    // non-const time multiplication ladder\n    unsafeLadder(elm: T, n: bigint) {\n      let p = c.ZERO;\n      let d: T = elm;\n      while (n > _0n) {\n        if (n & _1n) p = p.add(d);\n        d = d.double();\n        n >>= _1n;\n      }\n      return p;\n    },\n\n    /**\n     * Creates a wNAF precomputation window. Used for caching.\n     * Default window size is set by `utils.precompute()` and is equal to 8.\n     * Number of precomputed points depends on the curve size:\n     * 2^(𝑊−1) * (Math.ceil(𝑛 / 𝑊) + 1), where:\n     * - 𝑊 is the window size\n     * - 𝑛 is the bitlength of the curve order.\n     * For a 256-bit curve and window size 8, the number of precomputed points is 128 * 33 = 4224.\n     * @returns precomputed point tables flattened to a single array\n     */\n    precomputeWindow(elm: T, W: number): Group<T>[] {\n      const { windows, windowSize } = opts(W);\n      const points: T[] = [];\n      let p: T = elm;\n      let base = p;\n      for (let window = 0; window < windows; window++) {\n        base = p;\n        points.push(base);\n        // =1, because we skip zero\n        for (let i = 1; i < windowSize; i++) {\n          base = base.add(p);\n          points.push(base);\n        }\n        p = base.double();\n      }\n      return points;\n    },\n\n    /**\n     * Implements ec multiplication using precomputed tables and w-ary non-adjacent form.\n     * @param W window size\n     * @param precomputes precomputed tables\n     * @param n scalar (we don't check here, but should be less than curve order)\n     * @returns real and fake (for const-time) points\n     */\n    wNAF(W: number, precomputes: T[], n: bigint): { p: T; f: T } {\n      // TODO: maybe check that scalar is less than group order? wNAF behavious is undefined otherwise\n      // But need to carefully remove other checks before wNAF. ORDER == bits here\n      const { windows, windowSize } = opts(W);\n\n      let p = c.ZERO;\n      let f = c.BASE;\n\n      const mask = BigInt(2 ** W - 1); // Create mask with W ones: 0b1111 for W=4 etc.\n      const maxNumber = 2 ** W;\n      const shiftBy = BigInt(W);\n\n      for (let window = 0; window < windows; window++) {\n        const offset = window * windowSize;\n        // Extract W bits.\n        let wbits = Number(n & mask);\n\n        // Shift number by W bits.\n        n >>= shiftBy;\n\n        // If the bits are bigger than max size, we'll split those.\n        // +224 => 256 - 32\n        if (wbits > windowSize) {\n          wbits -= maxNumber;\n          n += _1n;\n        }\n\n        // This code was first written with assumption that 'f' and 'p' will never be infinity point:\n        // since each addition is multiplied by 2 ** W, it cannot cancel each other. However,\n        // there is negate now: it is possible that negated element from low value\n        // would be the same as high element, which will create carry into next window.\n        // It's not obvious how this can fail, but still worth investigating later.\n\n        // Check if we're onto Zero point.\n        // Add random point inside current window to f.\n        const offset1 = offset;\n        const offset2 = offset + Math.abs(wbits) - 1; // -1 because we skip zero\n        const cond1 = window % 2 !== 0;\n        const cond2 = wbits < 0;\n        if (wbits === 0) {\n          // The most important part for const-time getPublicKey\n          f = f.add(constTimeNegate(cond1, precomputes[offset1]));\n        } else {\n          p = p.add(constTimeNegate(cond2, precomputes[offset2]));\n        }\n      }\n      // JIT-compiler should not eliminate f here, since it will later be used in normalizeZ()\n      // Even if the variable is still unused, there are some checks which will\n      // throw an exception, so compiler needs to prove they won't happen, which is hard.\n      // At this point there is a way to F be infinity-point even if p is not,\n      // which makes it less const-time: around 1 bigint multiply.\n      return { p, f };\n    },\n\n    wNAFCached(P: T, precomputesMap: Map<T, T[]>, n: bigint, transform: Mapper<T>): { p: T; f: T } {\n      // @ts-ignore\n      const W: number = P._WINDOW_SIZE || 1;\n      // Calculate precomputes on a first run, reuse them after\n      let comp = precomputesMap.get(P);\n      if (!comp) {\n        comp = this.precomputeWindow(P, W) as T[];\n        if (W !== 1) {\n          precomputesMap.set(P, transform(comp));\n        }\n      }\n      return this.wNAF(W, comp, n);\n    },\n  };\n}\n\n// Generic BasicCurve interface: works even for polynomial fields (BLS): P, n, h would be ok.\n// Though generator can be different (Fp2 / Fp6 for BLS).\nexport type BasicCurve<T> = {\n  Fp: IField<T>; // Field over which we'll do calculations (Fp)\n  n: bigint; // Curve order, total count of valid points in the field\n  nBitLength?: number; // bit length of curve order\n  nByteLength?: number; // byte length of curve order\n  h: bigint; // cofactor. we can assign default=1, but users will just ignore it w/o validation\n  hEff?: bigint; // Number to multiply to clear cofactor\n  Gx: T; // base point X coordinate\n  Gy: T; // base point Y coordinate\n  allowInfinityPoint?: boolean; // bls12-381 requires it. ZERO point is valid, but invalid pubkey\n};\n\nexport function validateBasic<FP, T>(curve: BasicCurve<FP> & T) {\n  validateField(curve.Fp);\n  validateObject(\n    curve,\n    {\n      n: 'bigint',\n      h: 'bigint',\n      Gx: 'field',\n      Gy: 'field',\n    },\n    {\n      nBitLength: 'isSafeInteger',\n      nByteLength: 'isSafeInteger',\n    }\n  );\n  // Set defaults\n  return Object.freeze({\n    ...nLength(curve.n, curve.nBitLength),\n    ...curve,\n    ...{ p: curve.Fp.ORDER },\n  } as const);\n}\n"]}