@springmicro/auth 0.7.20 → 0.7.22

package/dist/{parseEther-C7cmMVOE.js → parseEther-B1tMovDx.js}

@@ -1,4 +1,4 @@
-import { C as g } from "./Web3Auth-DG8Yz_cD.js";
+import { C as g } from "./Web3Auth-CYZ2tXRd.js";
 function u(i, n) {
   let [e, t = "0"] = i.split(".");
   const s = e.startsWith("-");

package/dist/sha256-D3FUdNrs.js

@@ -0,0 +1,178 @@
+import { H as B, j as H, e as y, t as m, f as U, k as _, a as w, c as C, l as x } from "./utils-DbgAoL44.js";
+function I(r, t, n, s) {
+  if (typeof r.setBigUint64 == "function")
+    return r.setBigUint64(t, n, s);
+  const i = BigInt(32), o = BigInt(4294967295), e = Number(n >> i & o), h = Number(n & o), f = s ? 4 : 0, a = s ? 0 : 4;
+  r.setUint32(t + f, e, s), r.setUint32(t + a, h, s);
+}
+function L(r, t, n) {
+  return r & t ^ ~r & n;
+}
+function D(r, t, n) {
+  return r & t ^ r & n ^ t & n;
+}
+class k extends B {
+  constructor(t, n, s, i) {
+    super(), this.finished = !1, this.length = 0, this.pos = 0, this.destroyed = !1, this.blockLen = t, this.outputLen = n, this.padOffset = s, this.isLE = i, this.buffer = new Uint8Array(t), this.view = H(this.buffer);
+  }
+  update(t) {
+    y(this), t = m(t), U(t);
+    const { view: n, buffer: s, blockLen: i } = this, o = t.length;
+    for (let e = 0; e < o; ) {
+      const h = Math.min(i - this.pos, o - e);
+      if (h === i) {
+        const f = H(t);
+        for (; i <= o - e; e += i)
+          this.process(f, e);
+        continue;
+      }
+      s.set(t.subarray(e, e + h), this.pos), this.pos += h, e += h, this.pos === i && (this.process(n, 0), this.pos = 0);
+    }
+    return this.length += t.length, this.roundClean(), this;
+  }
+  digestInto(t) {
+    y(this), _(t, this), this.finished = !0;
+    const { buffer: n, view: s, blockLen: i, isLE: o } = this;
+    let { pos: e } = this;
+    n[e++] = 128, w(this.buffer.subarray(e)), this.padOffset > i - e && (this.process(s, 0), e = 0);
+    for (let c = e; c < i; c++)
+      n[c] = 0;
+    I(s, i - 8, BigInt(this.length * 8), o), this.process(s, 0);
+    const h = H(t), f = this.outputLen;
+    if (f % 4)
+      throw new Error("_sha2: outputLen should be aligned to 32bit");
+    const a = f / 4, b = this.get();
+    if (a > b.length)
+      throw new Error("_sha2: outputLen bigger than state");
+    for (let c = 0; c < a; c++)
+      h.setUint32(4 * c, b[c], o);
+  }
+  digest() {
+    const { buffer: t, outputLen: n } = this;
+    this.digestInto(t);
+    const s = t.slice(0, n);
+    return this.destroy(), s;
+  }
+  _cloneInto(t) {
+    t || (t = new this.constructor()), t.set(...this.get());
+    const { blockLen: n, buffer: s, length: i, finished: o, destroyed: e, pos: h } = this;
+    return t.destroyed = e, t.finished = o, t.length = i, t.pos = h, i % n && t.buffer.set(s), t;
+  }
+  clone() {
+    return this._cloneInto();
+  }
+}
+const u = /* @__PURE__ */ Uint32Array.from([
+  1779033703,
+  3144134277,
+  1013904242,
+  2773480762,
+  1359893119,
+  2600822924,
+  528734635,
+  1541459225
+]), E = /* @__PURE__ */ Uint32Array.from([
+  1116352408,
+  1899447441,
+  3049323471,
+  3921009573,
+  961987163,
+  1508970993,
+  2453635748,
+  2870763221,
+  3624381080,
+  310598401,
+  607225278,
+  1426881987,
+  1925078388,
+  2162078206,
+  2614888103,
+  3248222580,
+  3835390401,
+  4022224774,
+  264347078,
+  604807628,
+  770255983,
+  1249150122,
+  1555081692,
+  1996064986,
+  2554220882,
+  2821834349,
+  2952996808,
+  3210313671,
+  3336571891,
+  3584528711,
+  113926993,
+  338241895,
+  666307205,
+  773529912,
+  1294757372,
+  1396182291,
+  1695183700,
+  1986661051,
+  2177026350,
+  2456956037,
+  2730485921,
+  2820302411,
+  3259730800,
+  3345764771,
+  3516065817,
+  3600352804,
+  4094571909,
+  275423344,
+  430227734,
+  506948616,
+  659060556,
+  883997877,
+  958139571,
+  1322822218,
+  1537002063,
+  1747873779,
+  1955562222,
+  2024104815,
+  2227730452,
+  2361852424,
+  2428436474,
+  2756734187,
+  3204031479,
+  3329325298
+]), d = /* @__PURE__ */ new Uint32Array(64);
+class F extends k {
+  constructor(t = 32) {
+    super(64, t, 8, !1), this.A = u[0] | 0, this.B = u[1] | 0, this.C = u[2] | 0, this.D = u[3] | 0, this.E = u[4] | 0, this.F = u[5] | 0, this.G = u[6] | 0, this.H = u[7] | 0;
+  }
+  get() {
+    const { A: t, B: n, C: s, D: i, E: o, F: e, G: h, H: f } = this;
+    return [t, n, s, i, o, e, h, f];
+  }
+  // prettier-ignore
+  set(t, n, s, i, o, e, h, f) {
+    this.A = t | 0, this.B = n | 0, this.C = s | 0, this.D = i | 0, this.E = o | 0, this.F = e | 0, this.G = h | 0, this.H = f | 0;
+  }
+  process(t, n) {
+    for (let c = 0; c < 16; c++, n += 4)
+      d[c] = t.getUint32(n, !1);
+    for (let c = 16; c < 64; c++) {
+      const p = d[c - 15], l = d[c - 2], A = x(p, 7) ^ x(p, 18) ^ p >>> 3, g = x(l, 17) ^ x(l, 19) ^ l >>> 10;
+      d[c] = g + d[c - 7] + A + d[c - 16] | 0;
+    }
+    let { A: s, B: i, C: o, D: e, E: h, F: f, G: a, H: b } = this;
+    for (let c = 0; c < 64; c++) {
+      const p = x(h, 6) ^ x(h, 11) ^ x(h, 25), l = b + p + L(h, f, a) + E[c] + d[c] | 0, g = (x(s, 2) ^ x(s, 13) ^ x(s, 22)) + D(s, i, o) | 0;
+      b = a, a = f, f = h, h = e + l | 0, e = o, o = i, i = s, s = l + g | 0;
+    }
+    s = s + this.A | 0, i = i + this.B | 0, o = o + this.C | 0, e = e + this.D | 0, h = h + this.E | 0, f = f + this.F | 0, a = a + this.G | 0, b = b + this.H | 0, this.set(s, i, o, e, h, f, a, b);
+  }
+  roundClean() {
+    w(d);
+  }
+  destroy() {
+    this.set(0, 0, 0, 0, 0, 0, 0, 0), w(this.buffer);
+  }
+}
+const G = /* @__PURE__ */ C(() => new F()), M = G;
+export {
+  k as H,
+  G as a,
+  M as s
+};

package/dist/utils-DbgAoL44.js

@@ -0,0 +1,119 @@
+const o = typeof globalThis == "object" && "crypto" in globalThis ? globalThis.crypto : void 0;
+/*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+function c(t) {
+  return t instanceof Uint8Array || ArrayBuffer.isView(t) && t.constructor.name === "Uint8Array";
+}
+function s(t) {
+  if (!Number.isSafeInteger(t) || t < 0)
+    throw new Error("positive integer expected, got " + t);
+}
+function i(t, ...e) {
+  if (!c(t))
+    throw new Error("Uint8Array expected");
+  if (e.length > 0 && !e.includes(t.length))
+    throw new Error("Uint8Array expected of length " + e + ", got length=" + t.length);
+}
+function d(t) {
+  if (typeof t != "function" || typeof t.create != "function")
+    throw new Error("Hash should be wrapped by utils.createHasher");
+  s(t.outputLen), s(t.blockLen);
+}
+function b(t, e = !0) {
+  if (t.destroyed)
+    throw new Error("Hash instance has been destroyed");
+  if (e && t.finished)
+    throw new Error("Hash#digest() has already been called");
+}
+function x(t, e) {
+  i(t);
+  const n = e.outputLen;
+  if (t.length < n)
+    throw new Error("digestInto() expects output buffer of length at least " + n);
+}
+function m(t) {
+  return new Uint32Array(t.buffer, t.byteOffset, Math.floor(t.byteLength / 4));
+}
+function A(...t) {
+  for (let e = 0; e < t.length; e++)
+    t[e].fill(0);
+}
+function U(t) {
+  return new DataView(t.buffer, t.byteOffset, t.byteLength);
+}
+function E(t, e) {
+  return t << 32 - e | t >>> e;
+}
+function H(t, e) {
+  return t << e | t >>> 32 - e >>> 0;
+}
+const a = new Uint8Array(new Uint32Array([287454020]).buffer)[0] === 68;
+function l(t) {
+  return t << 24 & 4278190080 | t << 8 & 16711680 | t >>> 8 & 65280 | t >>> 24 & 255;
+}
+function y(t) {
+  for (let e = 0; e < t.length; e++)
+    t[e] = l(t[e]);
+  return t;
+}
+const B = a ? (t) => t : y, h = /* @ts-ignore */ typeof Uint8Array.from([]).toHex == "function" && typeof Uint8Array.fromHex == "function", p = /* @__PURE__ */ Array.from({ length: 256 }, (t, e) => e.toString(16).padStart(2, "0"));
+function L(t) {
+  if (i(t), h)
+    return t.toHex();
+  let e = "";
+  for (let n = 0; n < t.length; n++)
+    e += p[t[n]];
+  return e;
+}
+function g(t) {
+  if (typeof t != "string")
+    throw new Error("string expected");
+  return new Uint8Array(new TextEncoder().encode(t));
+}
+function w(t) {
+  return typeof t == "string" && (t = g(t)), i(t), t;
+}
+function T(...t) {
+  let e = 0;
+  for (let r = 0; r < t.length; r++) {
+    const f = t[r];
+    i(f), e += f.length;
+  }
+  const n = new Uint8Array(e);
+  for (let r = 0, f = 0; r < t.length; r++) {
+    const u = t[r];
+    n.set(u, f), f += u.length;
+  }
+  return n;
+}
+class V {
+}
+function S(t) {
+  const e = (r) => t().update(w(r)).digest(), n = t();
+  return e.outputLen = n.outputLen, e.blockLen = n.blockLen, e.create = () => t(), e;
+}
+function k(t = 32) {
+  if (o && typeof o.getRandomValues == "function")
+    return o.getRandomValues(new Uint8Array(t));
+  if (o && typeof o.randomBytes == "function")
+    return Uint8Array.from(o.randomBytes(t));
+  throw new Error("crypto.getRandomValues must be defined");
+}
+export {
+  V as H,
+  A as a,
+  L as b,
+  S as c,
+  d,
+  b as e,
+  i as f,
+  s as g,
+  k as h,
+  T as i,
+  U as j,
+  x as k,
+  E as l,
+  H as r,
+  B as s,
+  w as t,
+  m as u
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@springmicro/auth",
-  "version": "0.7.20",
+  "version": "0.7.22",
   "private": false,
   "publishConfig": {
     "access": "public",
@@ -53,5 +53,5 @@
     "react-social-login-buttons": "^4.1.0",
     "uuid": "^9.0.1"
   },
-  "gitHead": "17216b9fa5725017f185d210dc57dca36e02f43c"
+  "gitHead": "8bd83cea14b624431c069e6bebba77f858483da6"
 }

package/dist/hmac-CW2mnXa8.js

@@ -1,47 +0,0 @@
-import { H as u, h as l, t as H, e as r, b as p } from "./sha256-C90UGNQg.js";
-class o extends u {
-  constructor(t, i) {
-    super(), this.finished = !1, this.destroyed = !1, l(t);
-    const h = H(i);
-    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 a = this.blockLen, e = new Uint8Array(a);
-    e.set(h.length > a ? t.create().update(h).digest() : h);
-    for (let s = 0; s < e.length; s++)
-      e[s] ^= 54;
-    this.iHash.update(e), this.oHash = t.create();
-    for (let s = 0; s < e.length; s++)
-      e[s] ^= 106;
-    this.oHash.update(e), e.fill(0);
-  }
-  update(t) {
-    return r(this), this.iHash.update(t), this;
-  }
-  digestInto(t) {
-    r(this), p(t, this.outputLen), 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: i, iHash: h, finished: a, destroyed: e, blockLen: s, outputLen: c } = this;
-    return t = t, t.finished = a, t.destroyed = e, t.blockLen = s, t.outputLen = c, t.oHash = i._cloneInto(t.oHash), t.iHash = h._cloneInto(t.iHash), t;
-  }
-  destroy() {
-    this.destroyed = !0, this.oHash.destroy(), this.iHash.destroy();
-  }
-}
-const d = (n, t, i) => new o(n, t).update(i).digest();
-d.create = (n, t) => new o(n, t);
-const y = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
-  __proto__: null,
-  HMAC: o,
-  hmac: d
-}, Symbol.toStringTag, { value: "Module" }));
-export {
-  y as a,
-  d as h
-};