ranuts 0.4.1-alpha.2 → 0.5.0

package/dist/src/utils/totp/sha/common.js

@@ -0,0 +1,201 @@
+import { getOutputConverter as o, getStrConverter as d } from "./converters.js";
+var c = 4294967296, f = [
+  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
+], m = [
+  3238371032,
+  914150663,
+  812702999,
+  4144912697,
+  4290775857,
+  1750603025,
+  1694076839,
+  3204075428
+], L = [
+  1779033703,
+  3144134277,
+  1013904242,
+  2773480762,
+  1359893119,
+  2600822924,
+  528734635,
+  1541459225
+], v = "Chosen SHA variant is not supported", p = "Cannot set numRounds with MAC";
+function w(e, t) {
+  let n, i;
+  const r = e.binLen >>> 3, s = t.binLen >>> 3, a = r << 3, u = 4 - r << 3;
+  if (r % 4 !== 0) {
+    for (n = 0; n < s; n += 4)
+      i = r + n >>> 2, e.value[i] |= t.value[n >>> 2] << a, e.value.push(0), e.value[i + 1] |= t.value[n >>> 2] >>> u;
+    return (e.value.length << 2) - 4 >= s + r && e.value.pop(), {
+      value: e.value,
+      binLen: e.binLen + t.binLen
+    };
+  } else return {
+    value: e.value.concat(t.value),
+    binLen: e.binLen + t.binLen
+  };
+}
+function h(e) {
+  const t = {
+    outputUpper: !1,
+    b64Pad: "=",
+    outputLen: -1
+  }, n = e || {}, i = "Output length must be a multiple of 8";
+  if (t.outputUpper = n.outputUpper || !1, n.b64Pad && (t.b64Pad = n.b64Pad), n.outputLen) {
+    if (n.outputLen % 8 !== 0) throw new Error(i);
+    t.outputLen = n.outputLen;
+  } else if (n.shakeLen) {
+    if (n.shakeLen % 8 !== 0) throw new Error(i);
+    t.outputLen = n.shakeLen;
+  }
+  if (typeof t.outputUpper != "boolean") throw new Error("Invalid outputUpper formatting option");
+  if (typeof t.b64Pad != "string") throw new Error("Invalid b64Pad formatting option");
+  return t;
+}
+function S(e, t, n, i) {
+  const r = e + " must include a value and format";
+  if (!t) {
+    if (!i) throw new Error(r);
+    return i;
+  }
+  if (typeof t.value > "u" || !t.format) throw new Error(r);
+  return d(t.format, t.encoding || "UTF8", n)(t.value);
+}
+var C = class {
+  shaVariant;
+  inputFormat;
+  utfType;
+  numRounds;
+  keyWithIPad;
+  keyWithOPad;
+  remainder;
+  remainderLen;
+  updateCalled;
+  processedLen;
+  macKeySet;
+  constructor(e, t, n) {
+    const i = n || {};
+    if (this.inputFormat = t, this.utfType = i.encoding || "UTF8", this.numRounds = i.numRounds || 1, isNaN(this.numRounds) || this.numRounds !== parseInt(this.numRounds, 10) || 1 > this.numRounds) throw new Error("numRounds must a integer >= 1");
+    this.shaVariant = e, this.remainder = [], this.remainderLen = 0, this.updateCalled = !1, this.processedLen = 0, this.macKeySet = !1, this.keyWithIPad = [], this.keyWithOPad = [];
+  }
+  update(e) {
+    let t, n = 0;
+    const i = this.variantBlockSize >>> 5, r = this.converterFunc(e, this.remainder, this.remainderLen), s = r.binLen, a = r.value, u = s >>> 5;
+    for (t = 0; t < u; t += i) n + this.variantBlockSize <= s && (this.intermediateState = this.roundFunc(a.slice(t, t + i), this.intermediateState), n += this.variantBlockSize);
+    return this.processedLen += n, this.remainder = a.slice(n >>> 5), this.remainderLen = s % this.variantBlockSize, this.updateCalled = !0, this;
+  }
+  getHash(e, t) {
+    let n, i, r = this.outputBinLen;
+    const s = h(t);
+    if (this.isVariableLen) {
+      if (s.outputLen === -1) throw new Error("Output length must be specified in options");
+      r = s.outputLen;
+    }
+    const a = o(e, r, this.bigEndianMod, s);
+    if (this.macKeySet && this.getMAC) return a(this.getMAC(s));
+    for (i = this.finalizeFunc(this.remainder.slice(), this.remainderLen, this.processedLen, this.stateCloneFunc(this.intermediateState), r), n = 1; n < this.numRounds; n += 1)
+      this.isVariableLen && r % 32 !== 0 && (i[i.length - 1] &= 16777215 >>> 24 - r % 32), i = this.finalizeFunc(i, r, 0, this.newStateFunc(this.shaVariant), r);
+    return a(i);
+  }
+  setHMACKey(e, t, n) {
+    if (!this.HMACSupported) throw new Error("Variant does not support HMAC");
+    if (this.updateCalled) throw new Error("Cannot set MAC key after calling update");
+    const i = d(t, (n || {}).encoding || "UTF8", this.bigEndianMod);
+    this._setHMACKey(i(e));
+  }
+  _setHMACKey(e) {
+    const t = this.variantBlockSize >>> 3, n = t / 4 - 1;
+    let i;
+    if (this.numRounds !== 1) throw new Error(p);
+    if (this.macKeySet) throw new Error("MAC key already set");
+    for (t < e.binLen / 8 && (e.value = this.finalizeFunc(e.value, e.binLen, 0, this.newStateFunc(this.shaVariant), this.outputBinLen)); e.value.length <= n; ) e.value.push(0);
+    for (i = 0; i <= n; i += 1)
+      this.keyWithIPad[i] = e.value[i] ^ 909522486, this.keyWithOPad[i] = e.value[i] ^ 1549556828;
+    this.intermediateState = this.roundFunc(this.keyWithIPad, this.intermediateState), this.processedLen = this.variantBlockSize, this.macKeySet = !0;
+  }
+  getHMAC(e, t) {
+    const n = h(t);
+    return o(e, this.outputBinLen, this.bigEndianMod, n)(this._getHMAC());
+  }
+  _getHMAC() {
+    let e;
+    if (!this.macKeySet) throw new Error("Cannot call getHMAC without first setting MAC key");
+    const t = this.finalizeFunc(this.remainder.slice(), this.remainderLen, this.processedLen, this.stateCloneFunc(this.intermediateState), this.outputBinLen);
+    return e = this.roundFunc(this.keyWithOPad, this.newStateFunc(this.shaVariant)), e = this.finalizeFunc(t, this.outputBinLen, this.variantBlockSize, e, this.outputBinLen), e;
+  }
+};
+export {
+  L as H_full,
+  m as H_trunc,
+  f as K_sha2,
+  c as TWO_PWR_32,
+  h as getOutputOpts,
+  C as jsSHABase,
+  p as mac_rounds_error,
+  w as packedLEConcat,
+  S as parseInputOption,
+  v as sha_variant_error
+};

package/dist/src/utils/totp/sha/converters.d.ts

@@ -1,4 +1,4 @@
-import type { EncodingType, FormatType, packedValue } from './custom_types';
+import type { EncodingType, FormatType, packedValue } from "./custom_types.js";
 /**
  * Function that takes an input format and UTF encoding and returns the appropriate function used to convert the input.
  *

package/dist/src/utils/totp/sha/converters.js

@@ -0,0 +1,188 @@
+var y = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+function R(n, h, f, r, e) {
+  let t, u, c = 0, s, o, l, i, a, w;
+  r = r || 0;
+  const p = f || [0], A = r >>> 3;
+  if (h === "UTF8")
+    for (a = e === -1 ? 3 : 0, s = 0; s < n.length; s += 1)
+      for (t = n.charCodeAt(s), u = [], 128 > t ? u.push(t) : 2048 > t ? (u.push(192 | t >>> 6), u.push(128 | t & 63)) : 55296 > t || 57344 <= t ? u.push(224 | t >>> 12, 128 | t >>> 6 & 63, 128 | t & 63) : (s += 1, t = 65536 + ((t & 1023) << 10 | n.charCodeAt(s) & 1023), u.push(240 | t >>> 18, 128 | t >>> 12 & 63, 128 | t >>> 6 & 63, 128 | t & 63)), o = 0; o < u.length; o += 1) {
+        for (i = c + A, l = i >>> 2; p.length <= l; ) p.push(0);
+        p[l] |= u[o] << 8 * (a + e * (i % 4)), c += 1;
+      }
+  else
+    for (a = e === -1 ? 2 : 0, w = h === "UTF16LE" && e !== 1 || h !== "UTF16LE" && e === 1, s = 0; s < n.length; s += 1) {
+      for (t = n.charCodeAt(s), w === !0 && (o = t & 255, t = o << 8 | t >>> 8), i = c + A, l = i >>> 2; p.length <= l; ) p.push(0);
+      p[l] |= t << 8 * (a + e * (i % 4)), c += 2;
+    }
+  return {
+    value: p,
+    binLen: c * 8 + r
+  };
+}
+function B(n, h, f, r) {
+  let e, t, u, c;
+  if (n.length % 2 !== 0) throw new Error("String of HEX type must be in byte increments");
+  f = f || 0;
+  const s = h || [0], o = f >>> 3, l = r === -1 ? 3 : 0;
+  for (e = 0; e < n.length; e += 2) {
+    if (t = parseInt(n.substr(e, 2), 16), isNaN(t))
+      throw new Error("String of HEX type contains invalid characters");
+    for (c = (e >>> 1) + o, u = c >>> 2; s.length <= u; ) s.push(0);
+    s[u] |= t << 8 * (l + r * (c % 4));
+  }
+  return {
+    value: s,
+    binLen: n.length * 4 + f
+  };
+}
+function T(n, h, f, r) {
+  let e, t, u, c;
+  f = f || 0;
+  const s = h || [0], o = f >>> 3, l = r === -1 ? 3 : 0;
+  for (t = 0; t < n.length; t += 1)
+    e = n.charCodeAt(t), c = t + o, u = c >>> 2, s.length <= u && s.push(0), s[u] |= e << 8 * (l + r * (c % 4));
+  return {
+    value: s,
+    binLen: n.length * 8 + f
+  };
+}
+function F(n, h, f, r) {
+  let e = 0, t, u, c, s, o, l, i;
+  f = f || 0;
+  const a = h || [0], w = f >>> 3, p = r === -1 ? 3 : 0, A = n.indexOf("=");
+  if (n.search(/^[a-z\d=+/]+$/i) === -1) throw new Error("Invalid character in base-64 string");
+  if (n = n.replace(/=/g, ""), A !== -1 && A < n.length) throw new Error("Invalid '=' found in base-64 string");
+  for (u = 0; u < n.length; u += 4) {
+    for (o = n.substr(u, 4), s = 0, c = 0; c < o.length; c += 1)
+      t = y.indexOf(o.charAt(c)), s |= t << 18 - 6 * c;
+    for (c = 0; c < o.length - 1; c += 1) {
+      for (i = e + w, l = i >>> 2; a.length <= l; ) a.push(0);
+      a[l] |= (s >>> 16 - c * 8 & 255) << 8 * (p + r * (i % 4)), e += 1;
+    }
+  }
+  return {
+    value: a,
+    binLen: e * 8 + f
+  };
+}
+function U(n, h, f, r) {
+  let e, t, u;
+  f = f || 0;
+  const c = h || [0], s = f >>> 3, o = r === -1 ? 3 : 0;
+  for (e = 0; e < n.length; e += 1)
+    u = e + s, t = u >>> 2, c.length <= t && c.push(0), c[t] |= n[e] << 8 * (o + r * (u % 4));
+  return {
+    value: c,
+    binLen: n.length * 8 + f
+  };
+}
+function O(n, h, f, r) {
+  return U(new Uint8Array(n), h, f, r);
+}
+function I(n, h, f) {
+  switch (h) {
+    case "UTF8":
+    case "UTF16BE":
+    case "UTF16LE":
+      break;
+    default:
+      throw new Error("encoding must be UTF8, UTF16BE, or UTF16LE");
+  }
+  switch (n) {
+    case "HEX":
+      return function(r, e, t) {
+        return B(r, e, t, f);
+      };
+    case "TEXT":
+      return function(r, e, t) {
+        return R(r, h, e, t, f);
+      };
+    case "B64":
+      return function(r, e, t) {
+        return F(r, e, t, f);
+      };
+    case "BYTES":
+      return function(r, e, t) {
+        return T(r, e, t, f);
+      };
+    case "ARRAYBUFFER":
+      return function(r, e, t) {
+        return O(r, e, t, f);
+      };
+    case "UINT8ARRAY":
+      return function(r, e, t) {
+        return U(r, e, t, f);
+      };
+    default:
+      throw new Error("format must be HEX, TEXT, B64, BYTES, ARRAYBUFFER, or UINT8ARRAY");
+  }
+}
+function Y(n, h, f, r) {
+  const e = "0123456789abcdef";
+  let t = "", u, c;
+  const s = h / 8, o = f === -1 ? 3 : 0;
+  for (u = 0; u < s; u += 1)
+    c = n[u >>> 2] >>> 8 * (o + f * (u % 4)), t += e.charAt(c >>> 4 & 15) + e.charAt(c & 15);
+  return r.outputUpper ? t.toUpperCase() : t;
+}
+function v(n, h, f, r) {
+  let e = "", t, u, c, s, o;
+  const l = h / 8, i = f === -1 ? 3 : 0;
+  for (t = 0; t < l; t += 3)
+    for (s = t + 1 < l ? n[t + 1 >>> 2] : 0, o = t + 2 < l ? n[t + 2 >>> 2] : 0, c = (n[t >>> 2] >>> 8 * (i + f * (t % 4)) & 255) << 16 | (s >>> 8 * (i + f * ((t + 1) % 4)) & 255) << 8 | o >>> 8 * (i + f * ((t + 2) % 4)) & 255, u = 0; u < 4; u += 1) t * 8 + u * 6 <= h ? e += y.charAt(c >>> 6 * (3 - u) & 63) : e += r.b64Pad;
+  return e;
+}
+function C(n, h, f) {
+  let r = "", e, t;
+  const u = h / 8, c = f === -1 ? 3 : 0;
+  for (e = 0; e < u; e += 1)
+    t = n[e >>> 2] >>> 8 * (c + f * (e % 4)) & 255, r += String.fromCharCode(t);
+  return r;
+}
+function m(n, h, f) {
+  let r;
+  const e = h / 8, t = new ArrayBuffer(e), u = new Uint8Array(t), c = f === -1 ? 3 : 0;
+  for (r = 0; r < e; r += 1) u[r] = n[r >>> 2] >>> 8 * (c + f * (r % 4)) & 255;
+  return t;
+}
+function b(n, h, f) {
+  let r;
+  const e = h / 8, t = f === -1 ? 3 : 0, u = new Uint8Array(e);
+  for (r = 0; r < e; r += 1) u[r] = n[r >>> 2] >>> 8 * (t + f * (r % 4)) & 255;
+  return u;
+}
+function S(n, h, f, r) {
+  switch (n) {
+    case "HEX":
+      return function(e) {
+        return Y(e, h, f, r);
+      };
+    case "B64":
+      return function(e) {
+        return v(e, h, f, r);
+      };
+    case "BYTES":
+      return function(e) {
+        return C(e, h, f);
+      };
+    case "ARRAYBUFFER":
+      return function(e) {
+        return m(e, h, f);
+      };
+    case "UINT8ARRAY":
+      return function(e) {
+        return b(e, h, f);
+      };
+    default:
+      throw new Error("format must be HEX, B64, BYTES, ARRAYBUFFER, or UINT8ARRAY");
+  }
+}
+export {
+  S as getOutputConverter,
+  I as getStrConverter,
+  m as packed2arraybuffer,
+  v as packed2b64,
+  C as packed2bytes,
+  Y as packed2hex,
+  b as packed2uint8array
+};

package/dist/src/utils/totp/sha/primitives_32.js

@@ -0,0 +1,55 @@
+function _(n, t) {
+  return n << t | n >>> 32 - t;
+}
+function u(n, t) {
+  return n >>> t | n << 32 - t;
+}
+function i(n, t) {
+  return n >>> t;
+}
+function c(n, t, r) {
+  return n ^ t ^ r;
+}
+function s(n, t, r) {
+  return n & t ^ ~n & r;
+}
+function a(n, t, r) {
+  return n & t ^ n & r ^ t & r;
+}
+function m(n) {
+  return u(n, 2) ^ u(n, 13) ^ u(n, 22);
+}
+function d(n, t) {
+  const r = (n & 65535) + (t & 65535);
+  return ((n >>> 16) + (t >>> 16) + (r >>> 16) & 65535) << 16 | r & 65535;
+}
+function g(n, t, r, o) {
+  const e = (n & 65535) + (t & 65535) + (r & 65535) + (o & 65535);
+  return ((n >>> 16) + (t >>> 16) + (r >>> 16) + (o >>> 16) + (e >>> 16) & 65535) << 16 | e & 65535;
+}
+function l(n, t, r, o, e) {
+  const f = (n & 65535) + (t & 65535) + (r & 65535) + (o & 65535) + (e & 65535);
+  return ((n >>> 16) + (t >>> 16) + (r >>> 16) + (o >>> 16) + (e >>> 16) + (f >>> 16) & 65535) << 16 | f & 65535;
+}
+function w(n) {
+  return u(n, 17) ^ u(n, 19) ^ i(n, 10);
+}
+function A(n) {
+  return u(n, 7) ^ u(n, 18) ^ i(n, 3);
+}
+function h(n) {
+  return u(n, 6) ^ u(n, 11) ^ u(n, 25);
+}
+export {
+  s as ch_32,
+  A as gamma0_32,
+  w as gamma1_32,
+  a as maj_32,
+  c as parity_32,
+  _ as rotl_32,
+  d as safeAdd_32_2,
+  g as safeAdd_32_4,
+  l as safeAdd_32_5,
+  m as sigma0_32,
+  h as sigma1_32
+};

package/dist/src/utils/totp/sha/primitives_64.js

@@ -0,0 +1,85 @@
+var o = class {
+  highOrder;
+  lowOrder;
+  constructor(r, e) {
+    this.highOrder = r, this.lowOrder = e;
+  }
+};
+function s(r, e) {
+  let h;
+  return e > 32 ? (h = 64 - e, new o(r.lowOrder << e | r.highOrder >>> h, r.highOrder << e | r.lowOrder >>> h)) : e !== 0 ? (h = 32 - e, new o(r.highOrder << e | r.lowOrder >>> h, r.lowOrder << e | r.highOrder >>> h)) : r;
+}
+function w(r, e) {
+  let h;
+  return e < 32 ? (h = 32 - e, new o(r.highOrder >>> e | r.lowOrder << h, r.lowOrder >>> e | r.highOrder << h)) : (h = 64 - e, new o(r.lowOrder >>> e | r.highOrder << h, r.highOrder >>> e | r.lowOrder << h));
+}
+function t(r, e) {
+  return new o(r.highOrder >>> e, r.lowOrder >>> e | r.highOrder << 32 - e);
+}
+function u(r, e, h) {
+  return new o(r.highOrder & e.highOrder ^ ~r.highOrder & h.highOrder, r.lowOrder & e.lowOrder ^ ~r.lowOrder & h.lowOrder);
+}
+function c(r, e, h) {
+  return new o(r.highOrder & e.highOrder ^ r.highOrder & h.highOrder ^ e.highOrder & h.highOrder, r.lowOrder & e.lowOrder ^ r.lowOrder & h.lowOrder ^ e.lowOrder & h.lowOrder);
+}
+function f(r) {
+  const e = w(r, 28), h = w(r, 34), O = w(r, 39);
+  return new o(e.highOrder ^ h.highOrder ^ O.highOrder, e.lowOrder ^ h.lowOrder ^ O.lowOrder);
+}
+function _(r, e) {
+  let h, O;
+  h = (r.lowOrder & 65535) + (e.lowOrder & 65535), O = (r.lowOrder >>> 16) + (e.lowOrder >>> 16) + (h >>> 16);
+  const d = (O & 65535) << 16 | h & 65535;
+  h = (r.highOrder & 65535) + (e.highOrder & 65535) + (O >>> 16), O = (r.highOrder >>> 16) + (e.highOrder >>> 16) + (h >>> 16);
+  const i = (O & 65535) << 16 | h & 65535;
+  return new o(i, d);
+}
+function m(r, e, h, O) {
+  let d, i;
+  d = (r.lowOrder & 65535) + (e.lowOrder & 65535) + (h.lowOrder & 65535) + (O.lowOrder & 65535), i = (r.lowOrder >>> 16) + (e.lowOrder >>> 16) + (h.lowOrder >>> 16) + (O.lowOrder >>> 16) + (d >>> 16);
+  const l = (i & 65535) << 16 | d & 65535;
+  d = (r.highOrder & 65535) + (e.highOrder & 65535) + (h.highOrder & 65535) + (O.highOrder & 65535) + (i >>> 16), i = (r.highOrder >>> 16) + (e.highOrder >>> 16) + (h.highOrder >>> 16) + (O.highOrder >>> 16) + (d >>> 16);
+  const g = (i & 65535) << 16 | d & 65535;
+  return new o(g, l);
+}
+function a(r, e, h, O, d) {
+  let i, l;
+  i = (r.lowOrder & 65535) + (e.lowOrder & 65535) + (h.lowOrder & 65535) + (O.lowOrder & 65535) + (d.lowOrder & 65535), l = (r.lowOrder >>> 16) + (e.lowOrder >>> 16) + (h.lowOrder >>> 16) + (O.lowOrder >>> 16) + (d.lowOrder >>> 16) + (i >>> 16);
+  const g = (l & 65535) << 16 | i & 65535;
+  i = (r.highOrder & 65535) + (e.highOrder & 65535) + (h.highOrder & 65535) + (O.highOrder & 65535) + (d.highOrder & 65535) + (l >>> 16), l = (r.highOrder >>> 16) + (e.highOrder >>> 16) + (h.highOrder >>> 16) + (O.highOrder >>> 16) + (d.highOrder >>> 16) + (i >>> 16);
+  const n = (l & 65535) << 16 | i & 65535;
+  return new o(n, g);
+}
+function p(r, e) {
+  return new o(r.highOrder ^ e.highOrder, r.lowOrder ^ e.lowOrder);
+}
+function A(r, e, h, O, d) {
+  return new o(r.highOrder ^ e.highOrder ^ h.highOrder ^ O.highOrder ^ d.highOrder, r.lowOrder ^ e.lowOrder ^ h.lowOrder ^ O.lowOrder ^ d.lowOrder);
+}
+function j(r) {
+  const e = w(r, 19), h = w(r, 61), O = t(r, 6);
+  return new o(e.highOrder ^ h.highOrder ^ O.highOrder, e.lowOrder ^ h.lowOrder ^ O.lowOrder);
+}
+function v(r) {
+  const e = w(r, 1), h = w(r, 8), O = t(r, 7);
+  return new o(e.highOrder ^ h.highOrder ^ O.highOrder, e.lowOrder ^ h.lowOrder ^ O.lowOrder);
+}
+function I(r) {
+  const e = w(r, 14), h = w(r, 18), O = w(r, 41);
+  return new o(e.highOrder ^ h.highOrder ^ O.highOrder, e.lowOrder ^ h.lowOrder ^ O.lowOrder);
+}
+export {
+  o as Int_64,
+  u as ch_64,
+  v as gamma0_64,
+  j as gamma1_64,
+  c as maj_64,
+  s as rotl_64,
+  _ as safeAdd_64_2,
+  m as safeAdd_64_4,
+  a as safeAdd_64_5,
+  f as sigma0_64,
+  I as sigma1_64,
+  p as xor_64_2,
+  A as xor_64_5
+};

package/dist/src/utils/totp/sha/sha.d.ts

@@ -1,4 +1,4 @@
-import type { CSHAKEOptionsEncodingType, CSHAKEOptionsNoEncodingType, EncodingType, FixedLengthOptionsEncodingType, FixedLengthOptionsNoEncodingType, FormatNoTextType, KMACOptionsEncodingType, KMACOptionsNoEncodingType, SHAKEOptionsEncodingType, SHAKEOptionsNoEncodingType } from './custom_types';
+import type { CSHAKEOptionsEncodingType, CSHAKEOptionsNoEncodingType, EncodingType, FixedLengthOptionsEncodingType, FixedLengthOptionsNoEncodingType, FormatNoTextType, KMACOptionsEncodingType, KMACOptionsNoEncodingType, SHAKEOptionsEncodingType, SHAKEOptionsNoEncodingType } from "./custom_types.js";
 type FixedLengthVariantType = 'SHA-1' | 'SHA-224' | 'SHA-256' | 'SHA-384' | 'SHA-512' | 'SHA3-224' | 'SHA3-256' | 'SHA3-384' | 'SHA3-512';
 export default class jsSHA {
     private readonly shaObj;

package/dist/src/utils/totp/sha/sha.js

@@ -0,0 +1,30 @@
+import { sha_variant_error as H } from "./common.js";
+import h from "./sha1.js";
+import S from "./sha256.js";
+import j from "./sha512.js";
+import f from "./sha3.js";
+var o = class {
+  shaObj;
+  constructor(s, e, A) {
+    if (s === "SHA-1") this.shaObj = new h(s, e, A);
+    else if (s === "SHA-224" || s === "SHA-256") this.shaObj = new S(s, e, A);
+    else if (s === "SHA-384" || s === "SHA-512") this.shaObj = new j(s, e, A);
+    else if (s === "SHA3-224" || s === "SHA3-256" || s === "SHA3-384" || s === "SHA3-512" || s === "SHAKE128" || s === "SHAKE256" || s === "CSHAKE128" || s === "CSHAKE256" || s === "KMAC128" || s === "KMAC256") this.shaObj = new f(s, e, A);
+    else throw new Error(H);
+  }
+  update(s) {
+    return this.shaObj.update(s), this;
+  }
+  getHash(s, e) {
+    return this.shaObj.getHash(s, e);
+  }
+  setHMACKey(s, e, A) {
+    this.shaObj.setHMACKey(s, e, A);
+  }
+  getHMAC(s, e) {
+    return this.shaObj.getHMAC(s, e);
+  }
+};
+export {
+  o as default
+};

package/dist/src/utils/totp/sha/sha1.d.ts

@@ -1,5 +1,5 @@
-import { jsSHABase } from './common';
-import type { FixedLengthOptionsEncodingType, FixedLengthOptionsNoEncodingType, FormatNoTextType, packedValue } from './custom_types';
+import { jsSHABase } from "./common.js";
+import type { FixedLengthOptionsEncodingType, FixedLengthOptionsNoEncodingType, FormatNoTextType, packedValue } from "./custom_types.js";
 export default class jsSHA extends jsSHABase<number[], 'SHA-1'> {
     intermediateState: number[];
     variantBlockSize: number;

package/dist/src/utils/totp/sha/sha1.js

@@ -0,0 +1,51 @@
+import { getStrConverter as d } from "./converters.js";
+import { TWO_PWR_32 as A, jsSHABase as g, parseInputOption as F, sha_variant_error as M } from "./common.js";
+import { ch_32 as C, maj_32 as b, parity_32 as p, rotl_32 as c, safeAdd_32_2 as l, safeAdd_32_5 as f } from "./primitives_32.js";
+function S(s) {
+  return [
+    1732584193,
+    4023233417,
+    2562383102,
+    271733878,
+    3285377520
+  ];
+}
+function _(s, t) {
+  let o, n, i, u, r, h, e;
+  const a = [];
+  for (o = t[0], n = t[1], i = t[2], u = t[3], r = t[4], e = 0; e < 80; e += 1)
+    e < 16 ? a[e] = s[e] : a[e] = c(a[e - 3] ^ a[e - 8] ^ a[e - 14] ^ a[e - 16], 1), e < 20 ? h = f(c(o, 5), C(n, i, u), r, 1518500249, a[e]) : e < 40 ? h = f(c(o, 5), p(n, i, u), r, 1859775393, a[e]) : e < 60 ? h = f(c(o, 5), b(n, i, u), r, 2400959708, a[e]) : h = f(c(o, 5), p(n, i, u), r, 3395469782, a[e]), r = u, u = i, i = c(n, 30), n = o, o = h;
+  return t[0] = l(o, t[0]), t[1] = l(n, t[1]), t[2] = l(i, t[2]), t[3] = l(u, t[3]), t[4] = l(r, t[4]), t;
+}
+function v(s, t, o, n) {
+  let i;
+  const u = (t + 65 >>> 9 << 4) + 15, r = t + o;
+  for (; s.length <= u; ) s.push(0);
+  for (s[t >>> 5] |= 128 << 24 - t % 32, s[u] = r & 4294967295, s[u - 1] = r / A | 0, i = 0; i < s.length; i += 16) n = _(s.slice(i, i + 16), n);
+  return n;
+}
+var E = class extends g {
+  intermediateState;
+  variantBlockSize;
+  bigEndianMod;
+  outputBinLen;
+  isVariableLen;
+  HMACSupported;
+  converterFunc;
+  roundFunc;
+  finalizeFunc;
+  stateCloneFunc;
+  newStateFunc;
+  getMAC;
+  constructor(s, t, o) {
+    if (s !== "SHA-1") throw new Error(M);
+    super(s, t, o);
+    const n = o || {};
+    this.HMACSupported = !0, this.getMAC = this._getHMAC, this.bigEndianMod = -1, this.converterFunc = d(this.inputFormat, this.utfType, this.bigEndianMod), this.roundFunc = _, this.stateCloneFunc = function(i) {
+      return i.slice();
+    }, this.newStateFunc = S, this.finalizeFunc = v, this.intermediateState = S(s), this.variantBlockSize = 512, this.outputBinLen = 160, this.isVariableLen = !1, n.hmacKey && this._setHMACKey(F("hmacKey", n.hmacKey, this.bigEndianMod));
+  }
+};
+export {
+  E as default
+};

package/dist/src/utils/totp/sha/sha256.d.ts

@@ -1,5 +1,5 @@
-import { jsSHABase } from './common';
-import type { FixedLengthOptionsEncodingType, FixedLengthOptionsNoEncodingType, FormatNoTextType, packedValue } from './custom_types';
+import { jsSHABase } from "./common.js";
+import type { FixedLengthOptionsEncodingType, FixedLengthOptionsNoEncodingType, FormatNoTextType, packedValue } from "./custom_types.js";
 type VariantType = 'SHA-224' | 'SHA-256';
 export default class jsSHA extends jsSHABase<number[], VariantType> {
     intermediateState: number[];