@hinkal/common 0.0.116 → 0.0.118

package/Users/nkoreli/Documents/GitHub/Hinkal-Protocol/node_modules/hash.js/lib/hash/ripemd.mjs

@@ -0,0 +1,376 @@
+import { __exports as D } from "../../../../../../../../../_virtual/ripemd.mjs";
+import "./utils.mjs";
+import "./common.mjs";
+import { __exports as E } from "../../../../../../../../../_virtual/utils2.mjs";
+import { __exports as H } from "../../../../../../../../../_virtual/common.mjs";
+var a = E, S = H, x = a.rotl32, b = a.sum32, v = a.sum32_3, B = a.sum32_4, k = S.BlockHash;
+function s() {
+  if (!(this instanceof s))
+    return new s();
+  k.call(this), this.h = [1732584193, 4023233417, 2562383102, 271733878, 3285377520], this.endian = "little";
+}
+a.inherits(s, k);
+D.ripemd160 = s;
+s.blockSize = 512;
+s.outSize = 160;
+s.hmacStrength = 192;
+s.padLength = 64;
+s.prototype._update = function(e, h) {
+  for (var t = this.h[0], n = this.h[1], u = this.h[2], o = this.h[3], f = this.h[4], _ = t, c = n, m = u, d = o, p = f, i = 0; i < 80; i++) {
+    var l = b(
+      x(
+        B(t, g(i, n, u, o), e[K[i] + h], A(i)),
+        w[i]
+      ),
+      f
+    );
+    t = f, f = o, o = x(u, 10), u = n, n = l, l = b(
+      x(
+        B(_, g(79 - i, c, m, d), e[$[i] + h], C(i)),
+        I[i]
+      ),
+      p
+    ), _ = p, p = d, d = x(m, 10), m = c, c = l;
+  }
+  l = v(this.h[1], u, d), this.h[1] = v(this.h[2], o, p), this.h[2] = v(this.h[3], f, _), this.h[3] = v(this.h[4], t, c), this.h[4] = v(this.h[0], n, m), this.h[0] = l;
+};
+s.prototype._digest = function(e) {
+  return e === "hex" ? a.toHex32(this.h, "little") : a.split32(this.h, "little");
+};
+function g(r, e, h, t) {
+  return r <= 15 ? e ^ h ^ t : r <= 31 ? e & h | ~e & t : r <= 47 ? (e | ~h) ^ t : r <= 63 ? e & t | h & ~t : e ^ (h | ~t);
+}
+function A(r) {
+  return r <= 15 ? 0 : r <= 31 ? 1518500249 : r <= 47 ? 1859775393 : r <= 63 ? 2400959708 : 2840853838;
+}
+function C(r) {
+  return r <= 15 ? 1352829926 : r <= 31 ? 1548603684 : r <= 47 ? 1836072691 : r <= 63 ? 2053994217 : 0;
+}
+var K = [
+  0,
+  1,
+  2,
+  3,
+  4,
+  5,
+  6,
+  7,
+  8,
+  9,
+  10,
+  11,
+  12,
+  13,
+  14,
+  15,
+  7,
+  4,
+  13,
+  1,
+  10,
+  6,
+  15,
+  3,
+  12,
+  0,
+  9,
+  5,
+  2,
+  14,
+  11,
+  8,
+  3,
+  10,
+  14,
+  4,
+  9,
+  15,
+  8,
+  1,
+  2,
+  7,
+  0,
+  6,
+  13,
+  11,
+  5,
+  12,
+  1,
+  9,
+  11,
+  10,
+  0,
+  8,
+  12,
+  4,
+  13,
+  3,
+  7,
+  15,
+  14,
+  5,
+  6,
+  2,
+  4,
+  0,
+  5,
+  9,
+  7,
+  12,
+  2,
+  10,
+  14,
+  1,
+  3,
+  8,
+  11,
+  6,
+  15,
+  13
+], $ = [
+  5,
+  14,
+  7,
+  0,
+  9,
+  2,
+  11,
+  4,
+  13,
+  6,
+  15,
+  8,
+  1,
+  10,
+  3,
+  12,
+  6,
+  11,
+  3,
+  7,
+  0,
+  13,
+  5,
+  10,
+  14,
+  15,
+  8,
+  12,
+  4,
+  9,
+  1,
+  2,
+  15,
+  5,
+  1,
+  3,
+  7,
+  14,
+  6,
+  9,
+  11,
+  8,
+  12,
+  2,
+  10,
+  0,
+  4,
+  13,
+  8,
+  6,
+  4,
+  1,
+  3,
+  11,
+  15,
+  0,
+  5,
+  12,
+  2,
+  13,
+  9,
+  7,
+  10,
+  14,
+  12,
+  15,
+  10,
+  4,
+  1,
+  5,
+  8,
+  7,
+  6,
+  2,
+  13,
+  14,
+  0,
+  3,
+  9,
+  11
+], w = [
+  11,
+  14,
+  15,
+  12,
+  5,
+  8,
+  7,
+  9,
+  11,
+  13,
+  14,
+  15,
+  6,
+  7,
+  9,
+  8,
+  7,
+  6,
+  8,
+  13,
+  11,
+  9,
+  7,
+  15,
+  7,
+  12,
+  15,
+  9,
+  11,
+  7,
+  13,
+  12,
+  11,
+  13,
+  6,
+  7,
+  14,
+  9,
+  13,
+  15,
+  14,
+  8,
+  13,
+  6,
+  5,
+  12,
+  7,
+  5,
+  11,
+  12,
+  14,
+  15,
+  14,
+  15,
+  9,
+  8,
+  9,
+  14,
+  5,
+  6,
+  8,
+  6,
+  5,
+  12,
+  9,
+  15,
+  5,
+  11,
+  6,
+  8,
+  13,
+  12,
+  5,
+  12,
+  13,
+  14,
+  11,
+  8,
+  5,
+  6
+], I = [
+  8,
+  9,
+  9,
+  11,
+  13,
+  15,
+  15,
+  5,
+  7,
+  7,
+  8,
+  11,
+  14,
+  14,
+  12,
+  6,
+  9,
+  13,
+  15,
+  7,
+  12,
+  8,
+  9,
+  11,
+  7,
+  7,
+  12,
+  7,
+  6,
+  15,
+  13,
+  11,
+  9,
+  7,
+  15,
+  11,
+  8,
+  6,
+  6,
+  14,
+  12,
+  13,
+  5,
+  14,
+  13,
+  13,
+  7,
+  5,
+  15,
+  5,
+  8,
+  11,
+  14,
+  14,
+  6,
+  14,
+  6,
+  9,
+  12,
+  9,
+  12,
+  5,
+  15,
+  8,
+  8,
+  5,
+  12,
+  9,
+  12,
+  5,
+  14,
+  6,
+  8,
+  13,
+  6,
+  5,
+  15,
+  13,
+  11,
+  11
+];
+export {
+  D as default
+};

package/Users/nkoreli/Documents/GitHub/Hinkal-Protocol/node_modules/hash.js/lib/hash/sha/1.mjs

@@ -0,0 +1,47 @@
+import "../utils.mjs";
+import "../common.mjs";
+import "./common.mjs";
+import { __exports as l } from "../../../../../../../../../../_virtual/utils2.mjs";
+import { __exports as d } from "../../../../../../../../../../_virtual/common.mjs";
+import { __exports as g } from "../../../../../../../../../../_virtual/common2.mjs";
+var s = l, b = d, A = g, p = s.rotl32, o = s.sum32, B = s.sum32_5, C = A.ft_1, c = b.BlockHash, H = [
+  1518500249,
+  1859775393,
+  2400959708,
+  3395469782
+];
+function h() {
+  if (!(this instanceof h))
+    return new h();
+  c.call(this), this.h = [
+    1732584193,
+    4023233417,
+    2562383102,
+    271733878,
+    3285377520
+  ], this.W = new Array(80);
+}
+s.inherits(h, c);
+var w = h;
+h.blockSize = 512;
+h.outSize = 160;
+h.hmacStrength = 80;
+h.padLength = 64;
+h.prototype._update = function(n, u) {
+  for (var r = this.W, t = 0; t < 16; t++)
+    r[t] = n[u + t];
+  for (; t < r.length; t++)
+    r[t] = p(r[t - 3] ^ r[t - 8] ^ r[t - 14] ^ r[t - 16], 1);
+  var a = this.h[0], e = this.h[1], i = this.h[2], m = this.h[3], v = this.h[4];
+  for (t = 0; t < r.length; t++) {
+    var f = ~~(t / 20), x = B(p(a, 5), C(f, e, i, m), v, r[t], H[f]);
+    v = m, m = i, i = p(e, 30), e = a, a = x;
+  }
+  this.h[0] = o(this.h[0], a), this.h[1] = o(this.h[1], e), this.h[2] = o(this.h[2], i), this.h[3] = o(this.h[3], m), this.h[4] = o(this.h[4], v);
+};
+h.prototype._digest = function(n) {
+  return n === "hex" ? s.toHex32(this.h, "big") : s.split32(this.h, "big");
+};
+export {
+  w as _
+};

package/Users/nkoreli/Documents/GitHub/Hinkal-Protocol/node_modules/hash.js/lib/hash/sha/224.mjs

@@ -0,0 +1,30 @@
+import "../utils.mjs";
+import { _ as s } from "./256.mjs";
+import { __exports as o } from "../../../../../../../../../../_virtual/utils2.mjs";
+var i = o, e = s;
+function t() {
+  if (!(this instanceof t))
+    return new t();
+  e.call(this), this.h = [
+    3238371032,
+    914150663,
+    812702999,
+    4144912697,
+    4290775857,
+    1750603025,
+    1694076839,
+    3204075428
+  ];
+}
+i.inherits(t, e);
+var x = t;
+t.blockSize = 512;
+t.outSize = 224;
+t.hmacStrength = 192;
+t.padLength = 64;
+t.prototype._digest = function(r) {
+  return r === "hex" ? i.toHex32(this.h.slice(0, 7), "big") : i.split32(this.h.slice(0, 7), "big");
+};
+export {
+  x as _
+};

package/Users/nkoreli/Documents/GitHub/Hinkal-Protocol/node_modules/hash.js/lib/hash/sha/256.mjs

@@ -0,0 +1,111 @@
+import "../utils.mjs";
+import "../common.mjs";
+import "./common.mjs";
+import { m as l } from "../../../../minimalistic-assert/index.mjs";
+import { __exports as k } from "../../../../../../../../../../_virtual/utils2.mjs";
+import { __exports as H } from "../../../../../../../../../../_virtual/common.mjs";
+import { __exports as S } from "../../../../../../../../../../_virtual/common2.mjs";
+var s = k, y = H, c = S, A = l, x = s.sum32, W = s.sum32_4, $ = s.sum32_5, j = c.ch32, w = c.maj32, z = c.s0_256, B = c.s1_256, C = c.g0_256, K = c.g1_256, _ = y.BlockHash, L = [
+  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
+];
+function t() {
+  if (!(this instanceof t))
+    return new t();
+  _.call(this), this.h = [
+    1779033703,
+    3144134277,
+    1013904242,
+    2773480762,
+    1359893119,
+    2600822924,
+    528734635,
+    1541459225
+  ], this.k = L, this.W = new Array(64);
+}
+s.inherits(t, _);
+var M = t;
+t.blockSize = 512;
+t.outSize = 256;
+t.hmacStrength = 192;
+t.padLength = 64;
+t.prototype._update = function(m, u) {
+  for (var h = this.W, a = 0; a < 16; a++)
+    h[a] = m[u + a];
+  for (; a < h.length; a++)
+    h[a] = W(K(h[a - 2]), h[a - 7], C(h[a - 15]), h[a - 16]);
+  var e = this.h[0], f = this.h[1], i = this.h[2], v = this.h[3], r = this.h[4], b = this.h[5], o = this.h[6], d = this.h[7];
+  for (A(this.k.length === h.length), a = 0; a < h.length; a++) {
+    var n = $(d, B(r), j(r, b, o), this.k[a], h[a]), g = x(z(e), w(e, f, i));
+    d = o, o = b, b = r, r = x(v, n), v = i, i = f, f = e, e = x(n, g);
+  }
+  this.h[0] = x(this.h[0], e), this.h[1] = x(this.h[1], f), this.h[2] = x(this.h[2], i), this.h[3] = x(this.h[3], v), this.h[4] = x(this.h[4], r), this.h[5] = x(this.h[5], b), this.h[6] = x(this.h[6], o), this.h[7] = x(this.h[7], d);
+};
+t.prototype._digest = function(m) {
+  return m === "hex" ? s.toHex32(this.h, "big") : s.split32(this.h, "big");
+};
+export {
+  M as _
+};

package/Users/nkoreli/Documents/GitHub/Hinkal-Protocol/node_modules/hash.js/lib/hash/sha/384.mjs

@@ -0,0 +1,38 @@
+import "../utils.mjs";
+import { _ as r } from "./512.mjs";
+import { __exports as s } from "../../../../../../../../../../_virtual/utils2.mjs";
+var e = s, i = r;
+function t() {
+  if (!(this instanceof t))
+    return new t();
+  i.call(this), this.h = [
+    3418070365,
+    3238371032,
+    1654270250,
+    914150663,
+    2438529370,
+    812702999,
+    355462360,
+    4144912697,
+    1731405415,
+    4290775857,
+    2394180231,
+    1750603025,
+    3675008525,
+    1694076839,
+    1203062813,
+    3204075428
+  ];
+}
+e.inherits(t, i);
+var d = t;
+t.blockSize = 1024;
+t.outSize = 384;
+t.hmacStrength = 192;
+t.padLength = 128;
+t.prototype._digest = function(x) {
+  return x === "hex" ? e.toHex32(this.h.slice(0, 12), "big") : e.split32(this.h.slice(0, 12), "big");
+};
+export {
+  d as _
+};