module-develop-kit 1.3.1 → 1.4.0

package/dist/vendor/sm-crypto-v2/dist/index.js

@@ -0,0 +1,1004 @@
+import { hexToNumber as b, concatBytes as K, numberToBytesBE as Dt, bytesToHex as Y, numberToHexUnpadded as E } from "../../@noble/curves/esm/abstract/utils.js";
+import { weierstrass as Gt } from "../../@noble/curves/esm/abstract/weierstrass.js";
+import { Field as Ht, mod as At } from "../../@noble/curves/esm/abstract/modular.js";
+import { ghash as dt } from "../../@noble/ciphers/esm/_polyval.js";
+import { createView as pt, setBigUint64 as et } from "../../@noble/ciphers/esm/utils.js";
+var St = Object.defineProperty, Mt = (t, e, n) => e in t ? St(t, e, { enumerable: !0, configurable: !0, writable: !0, value: n }) : t[e] = n, Et = (t, e) => {
+  for (var n in e)
+    St(t, n, { get: e[n], enumerable: !0 });
+}, x = (t, e, n) => (Mt(t, typeof e != "symbol" ? e + "" : e, n), n), qt = {};
+Et(qt, {
+  EmptyArray: () => it,
+  arrayToHex: () => tt,
+  arrayToUtf8: () => z,
+  calculateSharedKey: () => pe,
+  comparePublicKeyHex: () => de,
+  compressPublicKeyHex: () => ue,
+  doDecrypt: () => we,
+  doEncrypt: () => ve,
+  doSignature: () => me,
+  doVerifySignature: () => xe,
+  ecdh: () => ye,
+  generateKeyPairHex: () => at,
+  getHash: () => ht,
+  getPoint: () => Ot,
+  getPublicKeyFromPrivateKey: () => Rt,
+  getZ: () => X,
+  hexToArray: () => P,
+  initRNGPool: () => lt,
+  leftPad: () => U,
+  precomputePublicKey: () => be,
+  utf8ToHex: () => N,
+  verifyPublicKey: () => ge
+});
+var J = BigInt(0), M = BigInt(1), Zt = BigInt(2);
+BigInt(3);
+function $t(t) {
+  let e = t.toString(16);
+  if (e[0] !== "-")
+    e.length % 2 === 1 ? e = "0" + e : e.match(/^[0-7]/) || (e = "00" + e);
+  else {
+    e = e.substring(1);
+    let n = e.length;
+    n % 2 === 1 ? n += 1 : e.match(/^[0-7]/) || (n += 2);
+    let s = "";
+    for (let c = 0; c < n; c++)
+      s += "f";
+    e = ((b(s) ^ t) + M).toString(16).replace(/^-/, "");
+  }
+  return e;
+}
+var ct = class {
+  constructor(t = null, e = "00", n = "00", s = "") {
+    this.tlv = t, this.t = e, this.l = n, this.v = s;
+  }
+  /**
+   * 获取 der 编码比特流16进制串
+   */
+  getEncodedHex() {
+    return this.tlv || (this.v = this.getValue(), this.l = this.getLength(), this.tlv = this.t + this.l + this.v), this.tlv;
+  }
+  getLength() {
+    const t = this.v.length / 2;
+    let e = t.toString(16);
+    return e.length % 2 === 1 && (e = "0" + e), t < 128 ? e : (128 + e.length / 2).toString(16) + e;
+  }
+  getValue() {
+    return "";
+  }
+}, Q = class extends ct {
+  constructor(t) {
+    super(), this.t = "02", t && (this.v = $t(t));
+  }
+  getValue() {
+    return this.v;
+  }
+}, yt = class extends ct {
+  constructor(t) {
+    super(), this.s = t, x(this, "hV", ""), this.t = "04", t && (this.v = t.toLowerCase());
+  }
+  getValue() {
+    return this.v;
+  }
+}, Lt = class extends ct {
+  constructor(t) {
+    super(), this.asn1Array = t, x(this, "t", "30");
+  }
+  getValue() {
+    return this.v = this.asn1Array.map((t) => t.getEncodedHex()).join(""), this.v;
+  }
+};
+function Bt(t, e) {
+  if (+t[e + 2] < 8)
+    return 1;
+  const s = t.slice(e + 2, e + 6).slice(0, 2);
+  return 1 + (parseInt(s, 16) - 128);
+}
+function st(t, e) {
+  const n = Bt(t, e), s = t.substring(e + 2, e + 2 + n * 2);
+  return s ? +(+s[0] < 8 ? b(s) : b(s.substring(2))).toString() : -1;
+}
+function G(t, e) {
+  const n = Bt(t, e);
+  return e + (n + 1) * 2;
+}
+function Wt(t, e) {
+  const n = new Q(t), s = new Q(e);
+  return new Lt([n, s]).getEncodedHex();
+}
+function vt(t, e, n, s) {
+  const r = new Q(t), i = new Q(e), c = new yt(n), o = new yt(s);
+  return new Lt([r, i, c, o]).getEncodedHex();
+}
+function Yt(t) {
+  const e = G(t, 0), n = G(t, e), s = st(t, e), r = t.substring(n, n + s * 2), i = n + r.length, c = G(t, i), o = st(t, i), l = t.substring(c, c + o * 2), a = b(r), f = b(l);
+  return { r: a, s: f };
+}
+function Jt(t) {
+  function e(g, p) {
+    const v = G(g, p), y = st(g, p), h = g.substring(v, v + y * 2), u = v + h.length;
+    return { value: h, nextStart: u };
+  }
+  const n = G(t, 0), { value: s, nextStart: r } = e(t, n), { value: i, nextStart: c } = e(t, r), { value: o, nextStart: l } = e(t, c), { value: a } = e(t, l), f = b(s), d = b(i);
+  return { x: f, y: d, hash: o, cipher: a };
+}
+var nt = 16384, R = new Uint8Array(0), k;
+async function lt() {
+  if ("crypto" in globalThis) {
+    k = globalThis.crypto;
+    return;
+  }
+  if (!(R.length > nt / 2))
+    if ("wx" in globalThis && "getRandomValues" in globalThis.wx)
+      R = await new Promise((t) => {
+        wx.getRandomValues({
+          length: nt,
+          success(e) {
+            t(new Uint8Array(e.randomValues));
+          }
+        });
+      });
+    else
+      try {
+        globalThis.crypto ? k = globalThis.crypto : k = (await import(
+          /* webpackIgnore: true */
+          "crypto"
+        )).webcrypto;
+        const t = new Uint8Array(nt);
+        k.getRandomValues(t), R = t;
+      } catch {
+        throw new Error("no available csprng, abort.");
+      }
+}
+lt();
+function Qt(t) {
+  if (R.length > t) {
+    const e = R.slice(0, t);
+    return R = R.slice(t), lt(), e;
+  } else
+    throw new Error("random number pool is not ready or insufficient, prevent getting too long random values or too often.");
+}
+function zt(t = 0) {
+  const e = new Uint8Array(t);
+  return k ? k.getRandomValues(e) : Qt(t);
+}
+var It = (t) => t instanceof Uint8Array, rt = (t) => new DataView(t.buffer, t.byteOffset, t.byteLength), Ft = new Uint8Array(new Uint32Array([287454020]).buffer)[0] === 68;
+if (!Ft)
+  throw new Error("Non little-endian hardware is not supported");
+var Xt = Array.from(
+  { length: 256 },
+  (t, e) => e.toString(16).padStart(2, "0")
+);
+function _(t) {
+  if (!It(t))
+    throw new Error("Uint8Array expected");
+  let e = "";
+  for (let n = 0; n < t.length; n++)
+    e += Xt[t[n]];
+  return e;
+}
+var wt = typeof TextEncoder < "u" && /* @__PURE__ */ new TextEncoder(), te = (t, e, n) => ((n == null || n > t.length) && (n = t.length), new Uint8Array(t.subarray(e, n)));
+function Tt(t) {
+  if (wt)
+    return wt.encode(t);
+  const e = t.length;
+  let n = new Uint8Array(t.length + (t.length >> 1)), s = 0;
+  const r = (i) => {
+    n[s++] = i;
+  };
+  for (let i = 0; i < e; ++i) {
+    if (s + 5 > n.length) {
+      const o = new Uint8Array(s + 8 + (e - i << 1));
+      o.set(n), n = o;
+    }
+    let c = t.charCodeAt(i);
+    c < 128 ? r(c) : c < 2048 ? (r(192 | c >> 6), r(128 | c & 63)) : c > 55295 && c < 57344 ? (c = 65536 + (c & 1047552) | t.charCodeAt(++i) & 1023, r(240 | c >> 18), r(128 | c >> 12 & 63), r(128 | c >> 6 & 63), r(128 | c & 63)) : (r(224 | c >> 12), r(128 | c >> 6 & 63), r(128 | c & 63));
+  }
+  return te(n, 0, s);
+}
+function ft(t) {
+  if (typeof t == "string" && (t = Tt(t)), !It(t))
+    throw new Error(`expected Uint8Array, got ${typeof t}`);
+  return t;
+}
+var Ct = class {
+  // Safe version that clones internal state
+  clone() {
+    return this._cloneInto();
+  }
+};
+function ee(t) {
+  const e = (s) => t().update(ft(s)).digest(), n = t();
+  return e.outputLen = n.outputLen, e.blockLen = n.blockLen, e.create = () => t(), e;
+}
+var ne = (t, e, n) => t & e | t & n | e & n, mt = (t, e, n) => t ^ e ^ n, re = (t, e, n) => t & e | ~t & n;
+function se(t, e, n, s) {
+  if (typeof t.setBigUint64 == "function")
+    return t.setBigUint64(e, n, s);
+  const r = BigInt(32), i = BigInt(4294967295), c = Number(n >> r & i), o = Number(n & i), l = s ? 4 : 0, a = s ? 0 : 4;
+  t.setUint32(e + l, c, s), t.setUint32(e + a, o, s);
+}
+function B(t, e) {
+  const n = e & 31;
+  return t << n | t >>> 32 - n;
+}
+function oe(t) {
+  return t ^ B(t, 9) ^ B(t, 17);
+}
+function ie(t) {
+  return t ^ B(t, 15) ^ B(t, 23);
+}
+var ce = class extends Ct {
+  constructor(t, e, n, s) {
+    super(), this.blockLen = t, this.outputLen = e, this.padOffset = n, this.isLE = s, x(this, "buffer"), x(this, "view"), x(this, "finished", !1), x(this, "length", 0), x(this, "pos", 0), x(this, "destroyed", !1), this.buffer = new Uint8Array(t), this.view = rt(this.buffer);
+  }
+  update(t) {
+    const { view: e, buffer: n, blockLen: s } = this;
+    t = ft(t);
+    const r = t.length;
+    for (let i = 0; i < r; ) {
+      const c = Math.min(s - this.pos, r - i);
+      if (c === s) {
+        const o = rt(t);
+        for (; s <= r - i; i += s)
+          this.process(o, i);
+        continue;
+      }
+      n.set(t.subarray(i, i + c), this.pos), this.pos += c, i += c, this.pos === s && (this.process(e, 0), this.pos = 0);
+    }
+    return this.length += t.length, this.roundClean(), this;
+  }
+  digestInto(t) {
+    this.finished = !0;
+    const { buffer: e, view: n, blockLen: s, isLE: r } = this;
+    let { pos: i } = this;
+    e[i++] = 128, this.buffer.subarray(i).fill(0), this.padOffset > s - i && (this.process(n, 0), i = 0);
+    for (let f = i; f < s; f++)
+      e[f] = 0;
+    se(n, s - 8, BigInt(this.length * 8), r), this.process(n, 0);
+    const c = rt(t), o = this.outputLen;
+    if (o % 4)
+      throw new Error("_sha2: outputLen should be aligned to 32bit");
+    const l = o / 4, a = this.get();
+    if (l > a.length)
+      throw new Error("_sha2: outputLen bigger than state");
+    for (let f = 0; f < l; f++)
+      c.setUint32(4 * f, a[f], r);
+  }
+  digest() {
+    const { buffer: t, outputLen: e } = this;
+    this.digestInto(t);
+    const n = t.slice(0, e);
+    return this.destroy(), n;
+  }
+  _cloneInto(t) {
+    t || (t = new this.constructor()), t.set(...this.get());
+    const { blockLen: e, buffer: n, length: s, finished: r, destroyed: i, pos: c } = this;
+    return t.length = s, t.pos = c, t.finished = r, t.destroyed = i, s % e && t.buffer.set(n), t;
+  }
+}, V = new Uint32Array([1937774191, 1226093241, 388252375, 3666478592, 2842636476, 372324522, 3817729613, 2969243214]), I = new Uint32Array(68), xt = new Uint32Array(64), le = 2043430169, fe = 2055708042, ae = class extends ce {
+  constructor() {
+    super(64, 32, 8, !1), x(this, "A", V[0] | 0), x(this, "B", V[1] | 0), x(this, "C", V[2] | 0), x(this, "D", V[3] | 0), x(this, "E", V[4] | 0), x(this, "F", V[5] | 0), x(this, "G", V[6] | 0), x(this, "H", V[7] | 0);
+  }
+  get() {
+    const { A: t, B: e, C: n, D: s, E: r, F: i, G: c, H: o } = this;
+    return [t, e, n, s, r, i, c, o];
+  }
+  // prettier-ignore
+  set(t, e, n, s, r, i, c, o) {
+    this.A = t | 0, this.B = e | 0, this.C = n | 0, this.D = s | 0, this.E = r | 0, this.F = i | 0, this.G = c | 0, this.H = o | 0;
+  }
+  process(t, e) {
+    for (let f = 0; f < 16; f++, e += 4)
+      I[f] = t.getUint32(e, !1);
+    for (let f = 16; f < 68; f++)
+      I[f] = ie(I[f - 16] ^ I[f - 9] ^ B(I[f - 3], 15)) ^ B(I[f - 13], 7) ^ I[f - 6];
+    for (let f = 0; f < 64; f++)
+      xt[f] = I[f] ^ I[f + 4];
+    let { A: n, B: s, C: r, D: i, E: c, F: o, G: l, H: a } = this;
+    for (let f = 0; f < 64; f++) {
+      let d = f >= 0 && f <= 15, g = d ? le : fe, p = B(B(n, 12) + c + B(g, f), 7), v = p ^ B(n, 12), y = (d ? mt(n, s, r) : ne(n, s, r)) + i + v + xt[f] | 0, h = (d ? mt(c, o, l) : re(c, o, l)) + a + p + I[f] | 0;
+      i = r, r = B(s, 9), s = n, n = y, a = l, l = B(o, 19), o = c, c = oe(h);
+    }
+    n = n ^ this.A | 0, s = s ^ this.B | 0, r = r ^ this.C | 0, i = i ^ this.D | 0, c = c ^ this.E | 0, o = o ^ this.F | 0, l = l ^ this.G | 0, a = a ^ this.H | 0, this.set(n, s, r, i, c, o, l, a);
+  }
+  roundClean() {
+    I.fill(0);
+  }
+  destroy() {
+    this.set(0, 0, 0, 0, 0, 0, 0, 0), this.buffer.fill(0);
+  }
+}, O = ee(() => new ae()), Vt = class extends Ct {
+  constructor(t, e) {
+    super(), x(this, "oHash"), x(this, "iHash"), x(this, "blockLen"), x(this, "outputLen"), x(this, "finished", !1), x(this, "destroyed", !1);
+    const n = ft(e);
+    if (this.iHash = t.create(), 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 s = this.blockLen, r = new Uint8Array(s);
+    r.set(n.length > s ? t.create().update(n).digest() : n);
+    for (let i = 0; i < r.length; i++)
+      r[i] ^= 54;
+    this.iHash.update(r), this.oHash = t.create();
+    for (let i = 0; i < r.length; i++)
+      r[i] ^= 106;
+    this.oHash.update(r), r.fill(0);
+  }
+  update(t) {
+    return this.iHash.update(t), this;
+  }
+  digestInto(t) {
+    this.finished = !0, this.iHash.digestInto(t), this.oHash.update(t), this.oHash.digestInto(t), this.destroy();
+  }
+  digest() {
+    const t = new Uint8Array(this.oHash.outputLen);
+    return this.digestInto(t), t;
+  }
+  _cloneInto(t) {
+    t || (t = Object.create(Object.getPrototypeOf(this), {}));
+    const { oHash: e, iHash: n, finished: s, destroyed: r, blockLen: i, outputLen: c } = this;
+    return t = t, t.finished = s, t.destroyed = r, t.blockLen = i, t.outputLen = c, t.oHash = e._cloneInto(t.oHash), t.iHash = n._cloneInto(t.iHash), t;
+  }
+  destroy() {
+    this.destroyed = !0, this.oHash.destroy(), this.iHash.destroy();
+  }
+}, _t = (t, e, n) => new Vt(t, e).update(n).digest();
+_t.create = (t, e) => new Vt(t, e);
+var he = Ht(BigInt("115792089210356248756420345214020892766250353991924191454421193933289684991999")), w = Gt({
+  // sm2: short weierstrass.
+  a: BigInt("115792089210356248756420345214020892766250353991924191454421193933289684991996"),
+  b: BigInt("18505919022281880113072981827955639221458448578012075254857346196103069175443"),
+  Fp: he,
+  h: M,
+  n: BigInt("115792089210356248756420345214020892766061623724957744567843809356293439045923"),
+  Gx: BigInt("22963146547237050559479531362550074578802567295341616970375194840604139615431"),
+  Gy: BigInt("85132369209828568825618990617112496413088388631904505083283536607588877201568"),
+  hash: O,
+  hmac: (t, ...e) => _t(O, t, K(...e)),
+  randomBytes: zt
+}), T = Ht(BigInt(w.CURVE.n));
+function at(t) {
+  const e = t ? Dt(At(BigInt(t), M) + M, 32) : w.utils.randomPrivateKey(), n = w.getPublicKey(e, !1), s = U(Y(e), 64), r = U(Y(n), 64);
+  return { privateKey: s, publicKey: r };
+}
+function ue(t) {
+  if (t.length !== 130)
+    throw new Error("Invalid public key to compress");
+  const e = (t.length - 2) / 2, n = t.substring(2, 2 + e), s = b(t.substring(e + 2, e + e + 2));
+  let r = "03";
+  return At(s, Zt) === J && (r = "02"), r + n;
+}
+function N(t) {
+  const e = Tt(t);
+  return Y(e);
+}
+function U(t, e) {
+  return t.length >= e ? t : new Array(e - t.length + 1).join("0") + t;
+}
+function tt(t) {
+  return t.map((e) => {
+    const n = e.toString(16);
+    return n.length === 1 ? "0" + n : n;
+  }).join("");
+}
+function z(t) {
+  const e = [];
+  for (let n = 0, s = t.length; n < s; n++)
+    t[n] >= 240 && t[n] <= 247 ? (e.push(String.fromCodePoint(((t[n] & 7) << 18) + ((t[n + 1] & 63) << 12) + ((t[n + 2] & 63) << 6) + (t[n + 3] & 63))), n += 3) : t[n] >= 224 && t[n] <= 239 ? (e.push(String.fromCodePoint(((t[n] & 15) << 12) + ((t[n + 1] & 63) << 6) + (t[n + 2] & 63))), n += 2) : t[n] >= 192 && t[n] <= 223 ? (e.push(String.fromCodePoint(((t[n] & 31) << 6) + (t[n + 1] & 63))), n++) : e.push(String.fromCodePoint(t[n]));
+  return e.join("");
+}
+function P(t) {
+  let e = t.length;
+  e % 2 !== 0 && (t = U(t, e + 1)), e = t.length;
+  const n = e / 2, s = new Uint8Array(n);
+  for (let r = 0; r < n; r++)
+    s[r] = parseInt(t.substring(r * 2, r * 2 + 2), 16);
+  return s;
+}
+function ge(t) {
+  const e = w.ProjectivePoint.fromHex(t);
+  if (!e)
+    return !1;
+  try {
+    return e.assertValidity(), !0;
+  } catch {
+    return !1;
+  }
+}
+function de(t, e) {
+  const n = w.ProjectivePoint.fromHex(t);
+  if (!n)
+    return !1;
+  const s = w.ProjectivePoint.fromHex(e);
+  return s ? n.equals(s) : !1;
+}
+function ot(t) {
+  const e = [];
+  for (let n = 0, s = t.length; n < s; n++) {
+    const r = t.codePointAt(n);
+    if (r <= 127)
+      e.push(r);
+    else if (r <= 2047)
+      e.push(192 | r >>> 6), e.push(128 | r & 63);
+    else if (r <= 55295 || r >= 57344 && r <= 65535)
+      e.push(224 | r >>> 12), e.push(128 | r >>> 6 & 63), e.push(128 | r & 63);
+    else if (r >= 65536 && r <= 1114111)
+      n++, e.push(240 | r >>> 18 & 28), e.push(128 | r >>> 12 & 63), e.push(128 | r >>> 6 & 63), e.push(128 | r & 63);
+    else
+      throw e.push(r), new Error("input is not supported");
+  }
+  return new Uint8Array(e);
+}
+function jt(t, e, n) {
+  t = typeof t == "string" ? ot(t) : t;
+  const s = it;
+  let r = new Uint8Array(e), i = 1, c = 0, o = it;
+  const l = new Uint8Array(4), a = () => {
+    l[0] = i >> 24 & 255, l[1] = i >> 16 & 255, l[2] = i >> 8 & 255, l[3] = i & 255, o = O(K(t, l, s)), i++, c = 0;
+  };
+  a();
+  for (let f = 0, d = r.length; f < d; f++)
+    c === o.length && a(), r[f] = o[c++] & 255;
+  return r;
+}
+var bt = b("80000000000000000000000000000000"), Pt = b("7fffffffffffffffffffffffffffffff");
+function pe(t, e, n, s, r, i = !1, c = "1234567812345678", o = "1234567812345678") {
+  const l = w.ProjectivePoint.fromHex(e.publicKey), a = w.ProjectivePoint.fromHex(s), f = w.ProjectivePoint.fromHex(n);
+  let d = X(t.publicKey, c), g = X(n, o);
+  i && ([d, g] = [g, d]);
+  const p = b(e.privateKey), v = b(t.privateKey), y = l.x, h = bt + (y & Pt), u = T.add(v, T.mulN(h, p)), m = a.x, A = T.add(bt, m & Pt), C = a.multiply(A).add(f).multiply(u), H = P(U(E(C.x), 64)), q = P(U(E(C.y), 64));
+  return jt(K(H, q, d, g), r);
+}
+var { getSharedSecret: ye } = w;
+function Kt(t, e, n) {
+  const s = jt(K(t, e), n.length);
+  for (let r = 0, i = n.length; r < i; r++)
+    n[r] ^= s[r] & 255;
+}
+var F = 0, it = new Uint8Array();
+function ve(t, e, n = 1, s) {
+  const r = typeof t == "string" ? P(N(t)) : Uint8Array.from(t), i = typeof e == "string" ? w.ProjectivePoint.fromHex(e) : e, c = at(), o = b(c.privateKey);
+  let l = c.publicKey;
+  l.length > 128 && (l = l.substring(l.length - 128));
+  const a = i.multiply(o), f = P(U(E(a.x), 64)), d = P(U(E(a.y), 64)), g = _(O(K(f, r, d)));
+  Kt(f, d, r);
+  const p = _(r);
+  if (s?.asn1) {
+    const v = w.ProjectivePoint.fromHex(c.publicKey);
+    return n === F ? vt(v.x, v.y, p, g) : vt(v.x, v.y, g, p);
+  }
+  return n === F ? l + p + g : l + g + p;
+}
+function we(t, e, n = 1, s) {
+  const { output: r = "string", asn1: i = !1 } = s || {}, c = b(e);
+  let o, l, a;
+  if (i) {
+    const { x: y, y: h, cipher: u, hash: m } = Jt(t);
+    o = w.ProjectivePoint.fromAffine({ x: y, y: h }), a = m, l = u, n === F && ([l, a] = [a, l]);
+  } else
+    o = w.ProjectivePoint.fromHex("04" + t.substring(0, 128)), a = t.substring(128, 192), l = t.substring(192), n === F && (a = t.substring(t.length - 64), l = t.substring(128, t.length - 64));
+  const f = P(l), d = o.multiply(c), g = P(U(E(d.x), 64)), p = P(U(E(d.y), 64));
+  return Kt(g, p, f), tt(Array.from(O(K(g, f, p)))) === a.toLowerCase() ? r === "array" ? f : z(f) : r === "array" ? [] : "";
+}
+function me(t, e, n = {}) {
+  let {
+    pointPool: s,
+    der: r,
+    hash: i,
+    publicKey: c,
+    userId: o
+  } = n, l = typeof t == "string" ? N(t) : tt(Array.from(t));
+  i && (c = c || Rt(e), l = ht(l, c, o));
+  const a = b(e), f = b(l);
+  let d = null, g = null, p = null;
+  do {
+    do {
+      let v;
+      s && s.length ? v = s.pop() : v = Ot(), d = v.k, g = T.add(f, v.x1);
+    } while (g === J || g + d === w.CURVE.n);
+    p = T.mul(T.inv(T.addN(a, M)), T.subN(d, T.mulN(g, a)));
+  } while (p === J);
+  return r ? Wt(g, p) : U(E(g), 64) + U(E(p), 64);
+}
+function xe(t, e, n, s = {}) {
+  let r;
+  const {
+    hash: i,
+    der: c,
+    userId: o
+  } = s, l = typeof n == "string" ? n : n.toHex(!1);
+  i ? r = ht(typeof t == "string" ? N(t) : t, l, o) : r = typeof t == "string" ? N(t) : tt(Array.from(t));
+  let a, f;
+  if (c) {
+    const h = Yt(e);
+    a = h.r, f = h.s;
+  } else
+    a = b(e.substring(0, 64)), f = b(e.substring(64));
+  const d = typeof n == "string" ? w.ProjectivePoint.fromHex(n) : n, g = b(r), p = T.add(a, f);
+  if (p === J)
+    return !1;
+  const v = w.ProjectivePoint.BASE.multiply(f).add(d.multiply(p)), y = T.add(g, v.x);
+  return a === y;
+}
+function X(t, e = "1234567812345678") {
+  e = N(e);
+  const n = U(E(w.CURVE.a), 64), s = U(E(w.CURVE.b), 64), r = U(E(w.ProjectivePoint.BASE.x), 64), i = U(E(w.ProjectivePoint.BASE.y), 64);
+  let c, o;
+  if (t.length === 128)
+    c = t.substring(0, 64), o = t.substring(64, 128);
+  else {
+    const d = w.ProjectivePoint.fromHex(t);
+    c = U(E(d.x), 64), o = U(E(d.y), 64);
+  }
+  const l = P(e + n + s + r + i + c + o), a = e.length * 4;
+  return O(K(new Uint8Array([a >> 8 & 255, a & 255]), l));
+}
+function ht(t, e, n = "1234567812345678") {
+  const s = X(e, n);
+  return _(O(K(s, typeof t == "string" ? P(t) : t)));
+}
+function be(t, e) {
+  const n = w.ProjectivePoint.fromHex(t);
+  return w.utils.precompute(e, n);
+}
+function Rt(t) {
+  const e = w.getPublicKey(t, !1);
+  return U(Y(e), 64);
+}
+function Ot() {
+  const t = at(), e = w.ProjectivePoint.fromHex(t.publicKey), n = b(t.privateKey);
+  return {
+    ...t,
+    k: n,
+    x1: e.x
+  };
+}
+var Pe = {};
+Et(Pe, {
+  decrypt: () => Ae,
+  encrypt: () => He,
+  sm4: () => ut
+});
+var S = 0, kt = 32, L = 16, Z = 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
+]), $ = 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 j(t) {
+  return (Z[t >>> 24 & 255] & 255) << 24 | (Z[t >>> 16 & 255] & 255) << 16 | (Z[t >>> 8 & 255] & 255) << 8 | Z[t & 255] & 255;
+}
+function D(t, e, n) {
+  let s = 0, r = 0, i = 0, c = 0, o = 0, l = 0, a = 0, f = 0;
+  o = t[0] & 255, l = t[1] & 255, a = t[2] & 255, f = t[3] & 255, s = o << 24 | l << 16 | a << 8 | f, o = t[4] & 255, l = t[5] & 255, a = t[6] & 255, f = t[7] & 255, r = o << 24 | l << 16 | a << 8 | f, o = t[8] & 255, l = t[9] & 255, a = t[10] & 255, f = t[11] & 255, i = o << 24 | l << 16 | a << 8 | f, o = t[12] & 255, l = t[13] & 255, a = t[14] & 255, f = t[15] & 255, c = o << 24 | l << 16 | a << 8 | f;
+  for (let d = 0; d < 32; d += 4)
+    o = r ^ i ^ c ^ n[d], o = j(o), s ^= o ^ (o << 2 | o >>> 30) ^ (o << 10 | o >>> 22) ^ (o << 18 | o >>> 14) ^ (o << 24 | o >>> 8), l = i ^ c ^ s ^ n[d + 1], l = j(l), r ^= l ^ (l << 2 | l >>> 30) ^ (l << 10 | l >>> 22) ^ (l << 18 | l >>> 14) ^ (l << 24 | l >>> 8), a = c ^ s ^ r ^ n[d + 2], a = j(a), i ^= a ^ (a << 2 | a >>> 30) ^ (a << 10 | a >>> 22) ^ (a << 18 | a >>> 14) ^ (a << 24 | a >>> 8), f = s ^ r ^ i ^ n[d + 3], f = j(f), c ^= f ^ (f << 2 | f >>> 30) ^ (f << 10 | f >>> 22) ^ (f << 18 | f >>> 14) ^ (f << 24 | f >>> 8);
+  e[0] = c >>> 24 & 255, e[1] = c >>> 16 & 255, e[2] = c >>> 8 & 255, e[3] = c & 255, e[4] = i >>> 24 & 255, e[5] = i >>> 16 & 255, e[6] = i >>> 8 & 255, e[7] = i & 255, e[8] = r >>> 24 & 255, e[9] = r >>> 16 & 255, e[10] = r >>> 8 & 255, e[11] = r & 255, e[12] = s >>> 24 & 255, e[13] = s >>> 16 & 255, e[14] = s >>> 8 & 255, e[15] = s & 255;
+}
+function Nt(t, e, n) {
+  let s = 0, r = 0, i = 0, c = 0, o = 0;
+  s = (t[0] & 255) << 24 | (t[1] & 255) << 16 | (t[2] & 255) << 8 | t[3] & 255, r = (t[4] & 255) << 24 | (t[5] & 255) << 16 | (t[6] & 255) << 8 | t[7] & 255, i = (t[8] & 255) << 24 | (t[9] & 255) << 16 | (t[10] & 255) << 8 | t[11] & 255, c = (t[12] & 255) << 24 | (t[13] & 255) << 16 | (t[14] & 255) << 8 | t[15] & 255, s ^= 2746333894, r ^= 1453994832, i ^= 1736282519, c ^= 2993693404;
+  for (let l = 0; l < 32; l += 4)
+    o = r ^ i ^ c ^ $[l + 0], o = j(o), s ^= o ^ (o << 13 | o >>> 19) ^ (o << 23 | o >>> 9), e[l + 0] = s, o = i ^ c ^ s ^ $[l + 1], o = j(o), r ^= o ^ (o << 13 | o >>> 19) ^ (o << 23 | o >>> 9), e[l + 1] = r, o = c ^ s ^ r ^ $[l + 2], o = j(o), i ^= o ^ (o << 13 | o >>> 19) ^ (o << 23 | o >>> 9), e[l + 2] = i, o = s ^ r ^ i ^ $[l + 3], o = j(o), c ^= o ^ (o << 13 | o >>> 19) ^ (o << 23 | o >>> 9), e[l + 3] = c;
+  if (n === S)
+    for (let l = 0; l < 16; l++)
+      [e[l], e[31 - l]] = [e[31 - l], e[l]];
+}
+function Ut(t) {
+  for (let e = t.length - 1; e >= 0 && (t[e]++, t[e] === 0); e--)
+    ;
+}
+function Ue(t, e, n, s, r, i) {
+  function c() {
+    const y = new Uint32Array(kt);
+    Nt(e, y, 1);
+    const h = new Uint8Array(16).fill(0), u = new Uint8Array(16);
+    D(h, u, y);
+    let m;
+    if (n.length === 12)
+      m = new Uint8Array(16), m.set(n, 0), m[15] = 1;
+    else {
+      const H = dt.create(u);
+      H.update(n);
+      const q = new Uint8Array(16), gt = pt(q);
+      et(gt, 8, BigInt(n.length * 8), !1), H.update(q), m = H.digest();
+    }
+    const A = new Uint8Array(m);
+    Ut(A);
+    const C = new Uint8Array(16);
+    return D(m, C, y), { roundKey: y, h: u, j0: m, counter: A, tagMask: C };
+  }
+  function o(y, h) {
+    const u = s.length, m = h.length, A = dt.create(y);
+    u > 0 && A.update(s), A.update(h);
+    const C = new Uint8Array(16), H = pt(C);
+    return et(H, 0, BigInt(u * 8), !1), et(H, 8, BigInt(m * 8), !1), A.update(C), A.digest();
+  }
+  const { roundKey: l, h: a, counter: f, tagMask: d } = c();
+  if (r === S && i) {
+    const y = o(a, t);
+    for (let u = 0; u < 16; u++)
+      y[u] ^= d[u];
+    let h = 0;
+    for (let u = 0; u < 16; u++)
+      h |= y[u] ^ i[u];
+    if (h !== 0)
+      throw new Error("authentication tag mismatch");
+  }
+  const g = new Uint8Array(t.length);
+  let p = 0, v = t.length;
+  for (; v >= L; ) {
+    const y = new Uint8Array(L);
+    D(f, y, l);
+    for (let h = 0; h < L && h < v; h++)
+      g[p + h] = t[p + h] ^ y[h];
+    Ut(f), p += L, v -= L;
+  }
+  if (v > 0) {
+    const y = new Uint8Array(L);
+    D(f, y, l);
+    for (let h = 0; h < v; h++)
+      g[p + h] = t[p + h] ^ y[h];
+  }
+  if (r !== S) {
+    const y = o(a, g);
+    for (let h = 0; h < 16; h++)
+      y[h] ^= d[h];
+    return { output: g, tag: y };
+  }
+  return { output: g };
+}
+var W = new Uint8Array(16);
+function ut(t, e, n, s = {}) {
+  let {
+    padding: r = "pkcs#7",
+    mode: i,
+    iv: c = new Uint8Array(16),
+    output: o,
+    associatedData: l,
+    outputTag: a,
+    tag: f
+  } = s;
+  if (i === "gcm") {
+    const h = typeof e == "string" ? P(e) : Uint8Array.from(e), u = typeof c == "string" ? P(c) : Uint8Array.from(c), m = l ? typeof l == "string" ? P(l) : Uint8Array.from(l) : new Uint8Array(0);
+    let A;
+    typeof t == "string" ? n !== S ? A = ot(t) : A = P(t) : A = Uint8Array.from(t);
+    const C = f ? typeof f == "string" ? P(f) : Uint8Array.from(f) : void 0, H = Ue(A, h, u, m, n, C);
+    return o === "array" ? a && n !== S ? H : H.output : a && n !== S ? {
+      output: _(H.output),
+      tag: H.tag ? _(H.tag) : void 0
+    } : n !== S ? {
+      output: _(H.output),
+      tag: H.tag ? _(H.tag) : void 0
+    } : z(H.output);
+  }
+  if (i === "cbc" && (typeof c == "string" && (c = P(c)), c.length !== 128 / 8))
+    throw new Error("iv is invalid");
+  if (typeof e == "string" && (e = P(e)), e.length !== 128 / 8)
+    throw new Error("key is invalid");
+  if (typeof t == "string" ? n !== S ? t = ot(t) : t = P(t) : t = Uint8Array.from(t), (r === "pkcs#5" || r === "pkcs#7") && n !== S) {
+    const h = L - t.length % L, u = new Uint8Array(t.length + h);
+    u.set(t, 0);
+    for (let m = 0; m < h; m++)
+      u[t.length + m] = h;
+    t = u;
+  }
+  const d = new Uint32Array(kt);
+  Nt(e, d, n);
+  let g = new Uint8Array(t.length), p = c, v = t.length, y = 0;
+  for (; v >= L; ) {
+    const h = t.subarray(y, y + 16);
+    if (i === "cbc")
+      for (let u = 0; u < L; u++)
+        n !== S && (h[u] ^= p[u]);
+    D(h, W, d);
+    for (let u = 0; u < L; u++)
+      i === "cbc" && n === S && (W[u] ^= p[u]), g[y + u] = W[u];
+    i === "cbc" && (n !== S ? p = W : p = h), v -= L, y += L;
+  }
+  if ((r === "pkcs#5" || r === "pkcs#7") && n === S) {
+    const h = g.length, u = g[h - 1];
+    for (let m = 1; m <= u; m++)
+      if (g[h - m] !== u)
+        throw new Error("padding is invalid");
+    g = g.slice(0, h - u);
+  }
+  return o !== "array" ? n !== S ? _(g) : z(g) : g;
+}
+function He(t, e, n = {}) {
+  return ut(t, e, 1, n);
+}
+function Ae(t, e, n = {}) {
+  return ut(t, e, 0, n);
+}
+/*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+export {
+  jt as kdf,
+  qt as sm2,
+  Pe as sm4
+};