ranuts 0.4.1-alpha.1 → 0.5.0

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

@@ -0,0 +1,56 @@
+import { getStrConverter as p } from "./converters.js";
+import { H_full as d, H_trunc as F, K_sha2 as m, TWO_PWR_32 as M, jsSHABase as C, parseInputOption as b, sha_variant_error as w } from "./common.js";
+import { ch_32 as y, gamma0_32 as z, gamma1_32 as E, maj_32 as K, safeAdd_32_2 as r, safeAdd_32_4 as T, safeAdd_32_5 as V, sigma0_32 as j, sigma1_32 as v } from "./primitives_32.js";
+function A(i) {
+  let t;
+  return i === "SHA-224" ? t = F.slice() : t = d.slice(), t;
+}
+function g(i, t) {
+  let u, e, c, n, o, a, l, h, _, S, s;
+  const f = [];
+  for (u = t[0], e = t[1], c = t[2], n = t[3], o = t[4], a = t[5], l = t[6], h = t[7], s = 0; s < 64; s += 1)
+    s < 16 ? f[s] = i[s] : f[s] = T(E(f[s - 2]), f[s - 7], z(f[s - 15]), f[s - 16]), _ = V(h, v(o), y(o, a, l), m[s], f[s]), S = r(j(u), K(u, e, c)), h = l, l = a, a = o, o = r(n, _), n = c, c = e, e = u, u = r(_, S);
+  return t[0] = r(u, t[0]), t[1] = r(e, t[1]), t[2] = r(c, t[2]), t[3] = r(n, t[3]), t[4] = r(o, t[4]), t[5] = r(a, t[5]), t[6] = r(l, t[6]), t[7] = r(h, t[7]), t;
+}
+function O(i, t, u, e, c) {
+  let n, o;
+  const a = (t + 65 >>> 9 << 4) + 15, l = 16, h = t + u;
+  for (; i.length <= a; ) i.push(0);
+  for (i[t >>> 5] |= 128 << 24 - t % 32, i[a] = h & 4294967295, i[a - 1] = h / M | 0, n = 0; n < i.length; n += l) e = g(i.slice(n, n + l), e);
+  return c === "SHA-224" ? o = [
+    e[0],
+    e[1],
+    e[2],
+    e[3],
+    e[4],
+    e[5],
+    e[6]
+  ] : o = e, o;
+}
+var B = class extends C {
+  intermediateState;
+  variantBlockSize;
+  bigEndianMod;
+  outputBinLen;
+  isVariableLen;
+  HMACSupported;
+  converterFunc;
+  roundFunc;
+  finalizeFunc;
+  stateCloneFunc;
+  newStateFunc;
+  getMAC;
+  constructor(i, t, u) {
+    if (!(i === "SHA-224" || i === "SHA-256")) throw new Error(w);
+    super(i, t, u);
+    const e = u || {};
+    this.getMAC = this._getHMAC, this.HMACSupported = !0, this.bigEndianMod = -1, this.converterFunc = p(this.inputFormat, this.utfType, this.bigEndianMod), this.roundFunc = g, this.stateCloneFunc = function(c) {
+      return c.slice();
+    }, this.newStateFunc = A, this.finalizeFunc = function(c, n, o, a) {
+      return O(c, n, o, a, i);
+    }, this.intermediateState = A(i), this.variantBlockSize = 512, this.outputBinLen = i === "SHA-224" ? 224 : 256, this.isVariableLen = !1, e.hmacKey && this._setHMACKey(b("hmacKey", e.hmacKey, this.bigEndianMod));
+  }
+};
+export {
+  B as default
+};

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

@@ -1,6 +1,6 @@
-import { jsSHABase } from './common';
-import type { CSHAKEOptionsEncodingType, CSHAKEOptionsNoEncodingType, FixedLengthOptionsEncodingType, FixedLengthOptionsNoEncodingType, FormatNoTextType, KMACOptionsEncodingType, KMACOptionsNoEncodingType, SHAKEOptionsEncodingType, SHAKEOptionsNoEncodingType, packedValue } from './custom_types';
-import { Int_64 } from './primitives_64';
+import { jsSHABase } from "./common.js";
+import type { CSHAKEOptionsEncodingType, CSHAKEOptionsNoEncodingType, FixedLengthOptionsEncodingType, FixedLengthOptionsNoEncodingType, FormatNoTextType, KMACOptionsEncodingType, KMACOptionsNoEncodingType, SHAKEOptionsEncodingType, SHAKEOptionsNoEncodingType, packedValue } from "./custom_types.js";
+import { Int_64 } from "./primitives_64.js";
 type FixedLengthVariantType = 'SHA3-224' | 'SHA3-256' | 'SHA3-384' | 'SHA3-512' | 'SHAKE128' | 'SHAKE256';
 type VariantType = FixedLengthVariantType | 'SHAKE128' | 'SHAKE256' | 'CSHAKE128' | 'CSHAKE256' | 'KMAC128' | 'KMAC256';
 export default class jsSHA extends jsSHABase<Int_64[][], VariantType> {

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

@@ -0,0 +1,253 @@
+import { getStrConverter as g } from "./converters.js";
+import { TWO_PWR_32 as M, jsSHABase as b, mac_rounds_error as z, packedLEConcat as A, parseInputOption as S, sha_variant_error as L } from "./common.js";
+import { Int_64 as r, rotl_64 as v, xor_64_2 as f, xor_64_5 as K } from "./primitives_64.js";
+var k = [
+  new r(0, 1),
+  new r(0, 32898),
+  new r(2147483648, 32906),
+  new r(2147483648, 2147516416),
+  new r(0, 32907),
+  new r(0, 2147483649),
+  new r(2147483648, 2147516545),
+  new r(2147483648, 32777),
+  new r(0, 138),
+  new r(0, 136),
+  new r(0, 2147516425),
+  new r(0, 2147483658),
+  new r(0, 2147516555),
+  new r(2147483648, 139),
+  new r(2147483648, 32905),
+  new r(2147483648, 32771),
+  new r(2147483648, 32770),
+  new r(2147483648, 128),
+  new r(0, 32778),
+  new r(2147483648, 2147483658),
+  new r(2147483648, 2147516545),
+  new r(2147483648, 32896),
+  new r(0, 2147483649),
+  new r(2147483648, 2147516424)
+], B = [
+  [
+    0,
+    36,
+    3,
+    41,
+    18
+  ],
+  [
+    1,
+    44,
+    10,
+    45,
+    2
+  ],
+  [
+    62,
+    6,
+    43,
+    15,
+    61
+  ],
+  [
+    28,
+    55,
+    25,
+    21,
+    56
+  ],
+  [
+    27,
+    20,
+    39,
+    8,
+    14
+  ]
+];
+function w(n) {
+  let t;
+  const s = [];
+  for (t = 0; t < 5; t += 1) s[t] = [
+    new r(0, 0),
+    new r(0, 0),
+    new r(0, 0),
+    new r(0, 0),
+    new r(0, 0)
+  ];
+  return s;
+}
+function y(n) {
+  let t;
+  const s = [];
+  for (t = 0; t < 5; t += 1) s[t] = n[t].slice();
+  return s;
+}
+function p(n, t) {
+  let s, e, i, a;
+  const u = [], o = [];
+  if (n != null) for (e = 0; e < n.length; e += 2) t[(e >>> 1) % 5][(e >>> 1) / 5 | 0] = f(t[(e >>> 1) % 5][(e >>> 1) / 5 | 0], new r(n[e + 1], n[e]));
+  for (s = 0; s < 24; s += 1) {
+    for (a = w("SHA3-384"), e = 0; e < 5; e += 1) u[e] = K(t[e][0], t[e][1], t[e][2], t[e][3], t[e][4]);
+    for (e = 0; e < 5; e += 1) o[e] = f(u[(e + 4) % 5], v(u[(e + 1) % 5], 1));
+    for (e = 0; e < 5; e += 1) for (i = 0; i < 5; i += 1) t[e][i] = f(t[e][i], o[e]);
+    for (e = 0; e < 5; e += 1) for (i = 0; i < 5; i += 1) a[i][(2 * e + 3 * i) % 5] = v(t[e][i], B[e][i]);
+    for (e = 0; e < 5; e += 1) for (i = 0; i < 5; i += 1) t[e][i] = f(a[e][i], new r(~a[(e + 1) % 5][i].highOrder & a[(e + 2) % 5][i].highOrder, ~a[(e + 1) % 5][i].lowOrder & a[(e + 2) % 5][i].lowOrder));
+    t[0][0] = f(t[0][0], k[s]);
+  }
+  return t;
+}
+function E(n, t, s, e, i, a, u) {
+  let o, h = 0, l;
+  const c = [], d = i >>> 5, H = t >>> 5;
+  for (o = 0; o < H && t >= i; o += d)
+    e = p(n.slice(o, o + d), e), t -= i;
+  for (n = n.slice(o), t = t % i; n.length < d; ) n.push(0);
+  for (o = t >>> 3, n[o >> 2] ^= a << 8 * (o % 4), n[d - 1] ^= 2147483648, e = p(n, e); c.length * 32 < u && (l = e[h % 5][h / 5 | 0], c.push(l.lowOrder), !(c.length * 32 >= u)); )
+    c.push(l.highOrder), h += 1, h * 64 % i === 0 && (p(null, e), h = 0);
+  return c;
+}
+function m(n) {
+  let t, s, e = 0;
+  const i = [0, 0], a = [n & 4294967295, n / M & 2097151];
+  for (t = 6; t >= 0; t--)
+    s = a[t >> 2] >>> 8 * t & 255, (s !== 0 || e !== 0) && (i[e + 1 >> 2] |= s << (e + 1) * 8, e += 1);
+  return e = e !== 0 ? e : 1, i[0] |= e, {
+    value: e + 1 > 4 ? i : [i[0]],
+    binLen: 8 + e * 8
+  };
+}
+function O(n) {
+  let t, s, e = 0;
+  const i = [0, 0], a = [n & 4294967295, n / M & 2097151];
+  for (t = 6; t >= 0; t--)
+    s = a[t >> 2] >>> 8 * t & 255, (s !== 0 || e !== 0) && (i[e >> 2] |= s << e * 8, e += 1);
+  return e = e !== 0 ? e : 1, i[e >> 2] |= e << e * 8, {
+    value: e + 1 > 4 ? i : [i[0]],
+    binLen: 8 + e * 8
+  };
+}
+function C(n) {
+  return A(m(n.binLen), n);
+}
+function _(n, t) {
+  let s = m(t), e;
+  s = A(s, n);
+  const i = t >>> 2, a = (i - s.value.length % i) % i;
+  for (e = 0; e < a; e++) s.value.push(0);
+  return s.value;
+}
+function F(n) {
+  const t = n || {};
+  return {
+    funcName: S("funcName", t.funcName, 1, {
+      value: [],
+      binLen: 0
+    }),
+    customization: S("Customization", t.customization, 1, {
+      value: [],
+      binLen: 0
+    })
+  };
+}
+function V(n) {
+  const t = n || {};
+  return {
+    kmacKey: S("kmacKey", t.kmacKey, 1),
+    funcName: {
+      value: [1128353099],
+      binLen: 32
+    },
+    customization: S("Customization", t.customization, 1, {
+      value: [],
+      binLen: 0
+    })
+  };
+}
+var R = class extends b {
+  intermediateState;
+  variantBlockSize;
+  bigEndianMod;
+  outputBinLen;
+  isVariableLen;
+  HMACSupported;
+  converterFunc;
+  roundFunc;
+  finalizeFunc;
+  stateCloneFunc;
+  newStateFunc;
+  getMAC;
+  constructor(n, t, s) {
+    let e = 6, i = 0;
+    super(n, t, s);
+    const a = s || {};
+    if (this.numRounds !== 1) {
+      if (a.kmacKey || a.hmacKey) throw new Error(z);
+      if (this.shaVariant === "CSHAKE128" || this.shaVariant === "CSHAKE256") throw new Error("Cannot set numRounds for CSHAKE variants");
+    }
+    switch (this.bigEndianMod = 1, this.converterFunc = g(this.inputFormat, this.utfType, this.bigEndianMod), this.roundFunc = p, this.stateCloneFunc = y, this.newStateFunc = w, this.intermediateState = w(n), this.isVariableLen = !1, n) {
+      case "SHA3-224":
+        this.variantBlockSize = i = 1152, this.outputBinLen = 224, this.HMACSupported = !0, this.getMAC = this._getHMAC;
+        break;
+      case "SHA3-256":
+        this.variantBlockSize = i = 1088, this.outputBinLen = 256, this.HMACSupported = !0, this.getMAC = this._getHMAC;
+        break;
+      case "SHA3-384":
+        this.variantBlockSize = i = 832, this.outputBinLen = 384, this.HMACSupported = !0, this.getMAC = this._getHMAC;
+        break;
+      case "SHA3-512":
+        this.variantBlockSize = i = 576, this.outputBinLen = 512, this.HMACSupported = !0, this.getMAC = this._getHMAC;
+        break;
+      case "SHAKE128":
+        e = 31, this.variantBlockSize = i = 1344, this.outputBinLen = -1, this.isVariableLen = !0, this.HMACSupported = !1, this.getMAC = null;
+        break;
+      case "SHAKE256":
+        e = 31, this.variantBlockSize = i = 1088, this.outputBinLen = -1, this.isVariableLen = !0, this.HMACSupported = !1, this.getMAC = null;
+        break;
+      case "KMAC128":
+        e = 4, this.variantBlockSize = i = 1344, this._initializeKMAC(s), this.outputBinLen = -1, this.isVariableLen = !0, this.HMACSupported = !1, this.getMAC = this._getKMAC;
+        break;
+      case "KMAC256":
+        e = 4, this.variantBlockSize = i = 1088, this._initializeKMAC(s), this.outputBinLen = -1, this.isVariableLen = !0, this.HMACSupported = !1, this.getMAC = this._getKMAC;
+        break;
+      case "CSHAKE128":
+        this.variantBlockSize = i = 1344, e = this._initializeCSHAKE(s), this.outputBinLen = -1, this.isVariableLen = !0, this.HMACSupported = !1, this.getMAC = null;
+        break;
+      case "CSHAKE256":
+        this.variantBlockSize = i = 1088, e = this._initializeCSHAKE(s), this.outputBinLen = -1, this.isVariableLen = !0, this.HMACSupported = !1, this.getMAC = null;
+        break;
+      default:
+        throw new Error(L);
+    }
+    this.finalizeFunc = function(u, o, h, l, c) {
+      return E(u, o, h, l, i, e, c);
+    }, a.hmacKey && this._setHMACKey(S("hmacKey", a.hmacKey, this.bigEndianMod));
+  }
+  _initializeCSHAKE(n, t) {
+    const s = F(n || {});
+    t && (s.funcName = t);
+    const e = A(C(s.funcName), C(s.customization));
+    if (s.customization.binLen !== 0 || s.funcName.binLen !== 0) {
+      const i = _(e, this.variantBlockSize >>> 3);
+      for (let a = 0; a < i.length; a += this.variantBlockSize >>> 5)
+        this.intermediateState = this.roundFunc(i.slice(a, a + (this.variantBlockSize >>> 5)), this.intermediateState), this.processedLen += this.variantBlockSize;
+      return 4;
+    } else return 31;
+  }
+  _initializeKMAC(n) {
+    const t = V(n || {});
+    this._initializeCSHAKE(n, t.funcName);
+    const s = _(C(t.kmacKey), this.variantBlockSize >>> 3);
+    for (let e = 0; e < s.length; e += this.variantBlockSize >>> 5)
+      this.intermediateState = this.roundFunc(s.slice(e, e + (this.variantBlockSize >>> 5)), this.intermediateState), this.processedLen += this.variantBlockSize;
+    this.macKeySet = !0;
+  }
+  _getKMAC(n) {
+    const t = A({
+      value: this.remainder.slice(),
+      binLen: this.remainderLen
+    }, O(n.outputLen));
+    return this.finalizeFunc(t.value, t.binLen, this.processedLen, this.stateCloneFunc(this.intermediateState), n.outputLen);
+  }
+};
+export {
+  R as default
+};

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

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

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

@@ -0,0 +1,177 @@
+import { getStrConverter as m } from "./converters.js";
+import { H_full as c, H_trunc as g, K_sha2 as n, TWO_PWR_32 as M, jsSHABase as C, parseInputOption as b, sha_variant_error as y } from "./common.js";
+import { Int_64 as e, ch_64 as K, gamma0_64 as z, gamma1_64 as E, maj_64 as v, safeAdd_64_2 as u, safeAdd_64_4 as T, safeAdd_64_5 as j, sigma0_64 as I, sigma1_64 as V } from "./primitives_64.js";
+var W = [
+  new e(n[0], 3609767458),
+  new e(n[1], 602891725),
+  new e(n[2], 3964484399),
+  new e(n[3], 2173295548),
+  new e(n[4], 4081628472),
+  new e(n[5], 3053834265),
+  new e(n[6], 2937671579),
+  new e(n[7], 3664609560),
+  new e(n[8], 2734883394),
+  new e(n[9], 1164996542),
+  new e(n[10], 1323610764),
+  new e(n[11], 3590304994),
+  new e(n[12], 4068182383),
+  new e(n[13], 991336113),
+  new e(n[14], 633803317),
+  new e(n[15], 3479774868),
+  new e(n[16], 2666613458),
+  new e(n[17], 944711139),
+  new e(n[18], 2341262773),
+  new e(n[19], 2007800933),
+  new e(n[20], 1495990901),
+  new e(n[21], 1856431235),
+  new e(n[22], 3175218132),
+  new e(n[23], 2198950837),
+  new e(n[24], 3999719339),
+  new e(n[25], 766784016),
+  new e(n[26], 2566594879),
+  new e(n[27], 3203337956),
+  new e(n[28], 1034457026),
+  new e(n[29], 2466948901),
+  new e(n[30], 3758326383),
+  new e(n[31], 168717936),
+  new e(n[32], 1188179964),
+  new e(n[33], 1546045734),
+  new e(n[34], 1522805485),
+  new e(n[35], 2643833823),
+  new e(n[36], 2343527390),
+  new e(n[37], 1014477480),
+  new e(n[38], 1206759142),
+  new e(n[39], 344077627),
+  new e(n[40], 1290863460),
+  new e(n[41], 3158454273),
+  new e(n[42], 3505952657),
+  new e(n[43], 106217008),
+  new e(n[44], 3606008344),
+  new e(n[45], 1432725776),
+  new e(n[46], 1467031594),
+  new e(n[47], 851169720),
+  new e(n[48], 3100823752),
+  new e(n[49], 1363258195),
+  new e(n[50], 3750685593),
+  new e(n[51], 3785050280),
+  new e(n[52], 3318307427),
+  new e(n[53], 3812723403),
+  new e(n[54], 2003034995),
+  new e(n[55], 3602036899),
+  new e(n[56], 1575990012),
+  new e(n[57], 1125592928),
+  new e(n[58], 2716904306),
+  new e(n[59], 442776044),
+  new e(n[60], 593698344),
+  new e(n[61], 3733110249),
+  new e(n[62], 2999351573),
+  new e(n[63], 3815920427),
+  new e(3391569614, 3928383900),
+  new e(3515267271, 566280711),
+  new e(3940187606, 3454069534),
+  new e(4118630271, 4000239992),
+  new e(116418474, 1914138554),
+  new e(174292421, 2731055270),
+  new e(289380356, 3203993006),
+  new e(460393269, 320620315),
+  new e(685471733, 587496836),
+  new e(852142971, 1086792851),
+  new e(1017036298, 365543100),
+  new e(1126000580, 2618297676),
+  new e(1288033470, 3409855158),
+  new e(1501505948, 4234509866),
+  new e(1607167915, 987167468),
+  new e(1816402316, 1246189591)
+];
+function p(t) {
+  return t === "SHA-384" ? [
+    new e(3418070365, g[0]),
+    new e(1654270250, g[1]),
+    new e(2438529370, g[2]),
+    new e(355462360, g[3]),
+    new e(1731405415, g[4]),
+    new e(41048885895, g[5]),
+    new e(3675008525, g[6]),
+    new e(1203062813, g[7])
+  ] : [
+    new e(c[0], 4089235720),
+    new e(c[1], 2227873595),
+    new e(c[2], 4271175723),
+    new e(c[3], 1595750129),
+    new e(c[4], 2917565137),
+    new e(c[5], 725511199),
+    new e(c[6], 4215389547),
+    new e(c[7], 327033209)
+  ];
+}
+function F(t, r) {
+  let s, w, d, h, o, l, a, O, _, A, i, S;
+  const f = [];
+  for (s = r[0], w = r[1], d = r[2], h = r[3], o = r[4], l = r[5], a = r[6], O = r[7], i = 0; i < 80; i += 1)
+    i < 16 ? (S = i * 2, f[i] = new e(t[S], t[S + 1])) : f[i] = T(E(f[i - 2]), f[i - 7], z(f[i - 15]), f[i - 16]), _ = j(O, V(o), K(o, l, a), W[i], f[i]), A = u(I(s), v(s, w, d)), O = a, a = l, l = o, o = u(h, _), h = d, d = w, w = s, s = u(_, A);
+  return r[0] = u(s, r[0]), r[1] = u(w, r[1]), r[2] = u(d, r[2]), r[3] = u(h, r[3]), r[4] = u(o, r[4]), r[5] = u(l, r[5]), r[6] = u(a, r[6]), r[7] = u(O, r[7]), r;
+}
+function x(t, r, s, w, d) {
+  let h, o;
+  const l = (r + 129 >>> 10 << 5) + 31, a = 32, O = r + s;
+  for (; t.length <= l; ) t.push(0);
+  for (t[r >>> 5] |= 128 << 24 - r % 32, t[l] = O & 4294967295, t[l - 1] = O / M | 0, h = 0; h < t.length; h += a) w = F(t.slice(h, h + a), w);
+  return d === "SHA-384" ? (w = w, o = [
+    w[0].highOrder,
+    w[0].lowOrder,
+    w[1].highOrder,
+    w[1].lowOrder,
+    w[2].highOrder,
+    w[2].lowOrder,
+    w[3].highOrder,
+    w[3].lowOrder,
+    w[4].highOrder,
+    w[4].lowOrder,
+    w[5].highOrder,
+    w[5].lowOrder
+  ]) : o = [
+    w[0].highOrder,
+    w[0].lowOrder,
+    w[1].highOrder,
+    w[1].lowOrder,
+    w[2].highOrder,
+    w[2].lowOrder,
+    w[3].highOrder,
+    w[3].lowOrder,
+    w[4].highOrder,
+    w[4].lowOrder,
+    w[5].highOrder,
+    w[5].lowOrder,
+    w[6].highOrder,
+    w[6].lowOrder,
+    w[7].highOrder,
+    w[7].lowOrder
+  ], o;
+}
+var N = class extends C {
+  intermediateState;
+  variantBlockSize;
+  bigEndianMod;
+  outputBinLen;
+  isVariableLen;
+  HMACSupported;
+  converterFunc;
+  roundFunc;
+  finalizeFunc;
+  stateCloneFunc;
+  newStateFunc;
+  getMAC;
+  constructor(t, r, s) {
+    if (!(t === "SHA-384" || t === "SHA-512")) throw new Error(y);
+    super(t, r, s);
+    const w = s || {};
+    this.getMAC = this._getHMAC, this.HMACSupported = !0, this.bigEndianMod = -1, this.converterFunc = m(this.inputFormat, this.utfType, this.bigEndianMod), this.roundFunc = F, this.stateCloneFunc = function(d) {
+      return d.slice();
+    }, this.newStateFunc = p, this.finalizeFunc = function(d, h, o, l) {
+      return x(d, h, o, l, t);
+    }, this.intermediateState = p(t), this.variantBlockSize = 1024, this.outputBinLen = t === "SHA-384" ? 384 : 512, this.isVariableLen = !1, w.hmacKey && this._setHMACKey(b("hmacKey", w.hmacKey, this.bigEndianMod));
+  }
+};
+export {
+  N as default
+};

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

@@ -0,0 +1,49 @@
+import d from "./sha/sha.js";
+var p = class {
+  static generate(t, o) {
+    const e = {
+      digits: 6,
+      algorithm: "SHA-1",
+      period: 30,
+      timestamp: Date.now(),
+      ...o
+    }, n = Math.floor(e.timestamp / 1e3), a = this.leftpad(this.dec2hex(Math.floor(n / e.period)), 16, "0"), i = new d(e.algorithm, "HEX");
+    i.setHMACKey(this.base32tohex(t), "HEX"), i.update(a);
+    const s = i.getHMAC("HEX"), h = this.hex2dec(s.substring(s.length - 1));
+    let r = (this.hex2dec(s.slice(h * 2, h * 2 + 8)) & this.hex2dec("7fffffff")) + "";
+    const c = Math.max(r.length - e.digits, 0);
+    r = r.substring(c, c + e.digits);
+    const l = Math.ceil((e.timestamp + 1) / (e.period * 1e3)) * e.period * 1e3;
+    return {
+      otp: r,
+      expires: l
+    };
+  }
+  static hex2dec(t) {
+    return parseInt(t, 16);
+  }
+  static dec2hex(t) {
+    return (t < 15.5 ? "0" : "") + Math.round(t).toString(16);
+  }
+  static base32tohex(t) {
+    const o = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567";
+    let e = "", n = "";
+    const a = t.endsWith("=") ? t.slice(0, t.lastIndexOf("=")) : t;
+    for (let i = 0; i < a.length; i++) {
+      const s = o.indexOf(t.charAt(i).toUpperCase());
+      if (s === -1) throw new Error("Invalid base32 character in key");
+      e += this.leftpad(s.toString(2), 5, "0");
+    }
+    for (let i = 0; i + 8 <= e.length; i += 8) {
+      const s = e.slice(i, i + 8);
+      n = n + this.leftpad(parseInt(s, 2).toString(16), 2, "0");
+    }
+    return n;
+  }
+  static leftpad(t, o, e) {
+    return o + 1 >= t.length && (t = Array(o + 1 - t.length).join(e) + t), t;
+  }
+};
+export {
+  p as TOTP
+};

package/dist/src/utils/tween.js

@@ -0,0 +1,59 @@
+var i = {
+  easeIn: function(n, r, u, e) {
+    return n >= e && (n = e), u * (n /= e) * n + r;
+  },
+  easeOut: function(n, r, u, e) {
+    return n >= e && (n = e), -u * (n /= e) * (n - 2) + r;
+  }
+}, a = {
+  easeIn: function(n, r, u, e) {
+    return n >= e && (n = e), u * (n /= e) * n * n + r;
+  },
+  easeOut: function(n, r, u, e) {
+    return n >= e && (n = e), u * ((n = n / e - 1) * n * n + 1) + r;
+  }
+}, f = {
+  easeIn: function(n, r, u, e) {
+    return n >= e && (n = e), u * (n /= e) * n * n * n + r;
+  },
+  easeOut: function(n, r, u, e) {
+    return n >= e && (n = e), -u * ((n = n / e - 1) * n * n * n - 1) + r;
+  }
+}, o = {
+  easeIn: function(n, r, u, e) {
+    return n >= e && (n = e), u * (n /= e) * n * n * n * n + r;
+  },
+  easeOut: function(n, r, u, e) {
+    return n >= e && (n = e), u * ((n = n / e - 1) * n * n * n * n + 1) + r;
+  }
+}, s = {
+  easeIn: function(n, r, u, e) {
+    return n >= e && (n = e), -u * Math.cos(n / e * (Math.PI / 2)) + u + r;
+  },
+  easeOut: function(n, r, u, e) {
+    return n >= e && (n = e), u * Math.sin(n / e * (Math.PI / 2)) + r;
+  }
+}, c = {
+  easeIn: function(n, r, u, e) {
+    return n >= e && (n = e), n === 0 ? r : u * Math.pow(2, 10 * (n / e - 1)) + r;
+  },
+  easeOut: function(n, r, u, e) {
+    return n >= e && (n = e), n === e ? r + u : u * (-Math.pow(2, -10 * n / e) + 1) + r;
+  }
+}, I = {
+  easeIn: function(n, r, u, e) {
+    return n >= e && (n = e), -u * (Math.sqrt(1 - (n /= e) * n) - 1) + r;
+  },
+  easeOut: function(n, r, u, e) {
+    return n >= e && (n = e), u * Math.sqrt(1 - (n = n / e - 1) * n) + r;
+  }
+};
+export {
+  I as circ,
+  a as cubic,
+  c as expo,
+  i as quad,
+  f as quart,
+  o as quint,
+  s as sine
+};

package/dist/src/utils/visual/application.d.ts

@@ -1,7 +1,7 @@
-import { Container } from '@/utils/visual/vertex/container';
-import { EventSystem } from '@/utils/visual/event';
-import type { Filter } from '@/utils/visual/render/filter';
-import type { IApplicationOptions } from '@/utils/visual/types';
+import { Container } from "./vertex/container.js";
+import { EventSystem } from "./event/index.js";
+import type { Filter } from "./render/filter.js";
+import type { IApplicationOptions } from "./types.js";
 export declare class Application {
     private readonly renderer;
     readonly stage: Container;

package/dist/src/utils/visual/application.js

@@ -0,0 +1,42 @@
+import { getRenderer as i } from "./render/index.js";
+import { Container as n } from "./vertex/container.js";
+import { EventSystem as a } from "./event/event.js";
+var c = class r {
+  renderer;
+  stage;
+  view;
+  animationFrameId;
+  eventSystem;
+  constructor(e) {
+    const { view: t = document.createElement("canvas") } = e;
+    this.view = t, this.renderer = i({
+      ...e,
+      view: t
+    }), this.stage = new n(), this.eventSystem = new a(this.view, this.stage);
+  }
+  static async create(e) {
+    const t = new r(e);
+    return await t.renderer.init(), t;
+  }
+  get filters() {
+    return this.renderer.filters;
+  }
+  set filters(e) {
+    this.renderer.filters = e;
+  }
+  render() {
+    this.renderer.render(this.stage);
+  }
+  start() {
+    const e = () => {
+      this.render(), this.animationFrameId = requestAnimationFrame(e);
+    };
+    e();
+  }
+  stop() {
+    this.animationFrameId && (cancelAnimationFrame(this.animationFrameId), this.animationFrameId = void 0);
+  }
+};
+export {
+  c as Application
+};

package/dist/src/utils/visual/enums.js

@@ -0,0 +1,19 @@
+var n = /* @__PURE__ */ (function(r) {
+  return r.RECTANGLE = "rectangle", r.POLYGON = "polygon", r.CIRCLE = "circle", r.ELLIPSE = "ellipse", r.ROUNDED_RECTANGLE = "rounded rectangle", r;
+})({}), e = /* @__PURE__ */ (function(r) {
+  return r.BUTT = "butt", r.ROUND = "round", r.SQUARE = "square", r;
+})({}), a = /* @__PURE__ */ (function(r) {
+  return r.MITER = "miter", r.BEVEL = "bevel", r.ROUND = "round", r;
+})({}), t = /* @__PURE__ */ (function(r) {
+  return r.WEB_GL = "webgl", r.CANVAS = "canvas", r.WEB_GPU = "webgpu", r;
+})({}), u = 65536, c = 12, o = "container", v = "graphics";
+export {
+  c as BYTES_PER_VERTEX,
+  o as CONTAINER,
+  v as GRAPHICS,
+  e as LINE_CAP,
+  a as LINE_JOIN,
+  u as MAX_VERTEX_COUNT,
+  t as RENDERER_TYPE,
+  n as SHAPE_TYPE
+};