@opendesign-plus-test/components 0.0.1-rc.20 → 0.0.1-rc.200

package/dist/treeshaking/_virtual/crypto-js/sha256.js.mjs

@@ -0,0 +1,125 @@
+import { __module as sha256$1 } from "./sha256.js2.mjs";
+import { __require as requireCore } from "./core.js.mjs";
+var sha256 = sha256$1.exports;
+var hasRequiredSha256;
+function requireSha256() {
+  if (hasRequiredSha256) return sha256$1.exports;
+  hasRequiredSha256 = 1;
+  (function(module, exports) {
+    (function(root, factory) {
+      {
+        module.exports = factory(requireCore());
+      }
+    })(sha256, function(CryptoJS) {
+      (function(Math2) {
+        var C = CryptoJS;
+        var C_lib = C.lib;
+        var WordArray = C_lib.WordArray;
+        var Hasher = C_lib.Hasher;
+        var C_algo = C.algo;
+        var H = [];
+        var K = [];
+        (function() {
+          function isPrime(n2) {
+            var sqrtN = Math2.sqrt(n2);
+            for (var factor = 2; factor <= sqrtN; factor++) {
+              if (!(n2 % factor)) {
+                return false;
+              }
+            }
+            return true;
+          }
+          function getFractionalBits(n2) {
+            return (n2 - (n2 | 0)) * 4294967296 | 0;
+          }
+          var n = 2;
+          var nPrime = 0;
+          while (nPrime < 64) {
+            if (isPrime(n)) {
+              if (nPrime < 8) {
+                H[nPrime] = getFractionalBits(Math2.pow(n, 1 / 2));
+              }
+              K[nPrime] = getFractionalBits(Math2.pow(n, 1 / 3));
+              nPrime++;
+            }
+            n++;
+          }
+        })();
+        var W = [];
+        var SHA256 = C_algo.SHA256 = Hasher.extend({
+          _doReset: function() {
+            this._hash = new WordArray.init(H.slice(0));
+          },
+          _doProcessBlock: function(M, offset) {
+            var H2 = this._hash.words;
+            var a = H2[0];
+            var b = H2[1];
+            var c = H2[2];
+            var d = H2[3];
+            var e = H2[4];
+            var f = H2[5];
+            var g = H2[6];
+            var h = H2[7];
+            for (var i = 0; i < 64; i++) {
+              if (i < 16) {
+                W[i] = M[offset + i] | 0;
+              } else {
+                var gamma0x = W[i - 15];
+                var gamma0 = (gamma0x << 25 | gamma0x >>> 7) ^ (gamma0x << 14 | gamma0x >>> 18) ^ gamma0x >>> 3;
+                var gamma1x = W[i - 2];
+                var gamma1 = (gamma1x << 15 | gamma1x >>> 17) ^ (gamma1x << 13 | gamma1x >>> 19) ^ gamma1x >>> 10;
+                W[i] = gamma0 + W[i - 7] + gamma1 + W[i - 16];
+              }
+              var ch = e & f ^ ~e & g;
+              var maj = a & b ^ a & c ^ b & c;
+              var sigma0 = (a << 30 | a >>> 2) ^ (a << 19 | a >>> 13) ^ (a << 10 | a >>> 22);
+              var sigma1 = (e << 26 | e >>> 6) ^ (e << 21 | e >>> 11) ^ (e << 7 | e >>> 25);
+              var t1 = h + sigma1 + ch + K[i] + W[i];
+              var t2 = sigma0 + maj;
+              h = g;
+              g = f;
+              f = e;
+              e = d + t1 | 0;
+              d = c;
+              c = b;
+              b = a;
+              a = t1 + t2 | 0;
+            }
+            H2[0] = H2[0] + a | 0;
+            H2[1] = H2[1] + b | 0;
+            H2[2] = H2[2] + c | 0;
+            H2[3] = H2[3] + d | 0;
+            H2[4] = H2[4] + e | 0;
+            H2[5] = H2[5] + f | 0;
+            H2[6] = H2[6] + g | 0;
+            H2[7] = H2[7] + h | 0;
+          },
+          _doFinalize: function() {
+            var data = this._data;
+            var dataWords = data.words;
+            var nBitsTotal = this._nDataBytes * 8;
+            var nBitsLeft = data.sigBytes * 8;
+            dataWords[nBitsLeft >>> 5] |= 128 << 24 - nBitsLeft % 32;
+            dataWords[(nBitsLeft + 64 >>> 9 << 4) + 14] = Math2.floor(nBitsTotal / 4294967296);
+            dataWords[(nBitsLeft + 64 >>> 9 << 4) + 15] = nBitsTotal;
+            data.sigBytes = dataWords.length * 4;
+            this._process();
+            return this._hash;
+          },
+          clone: function() {
+            var clone = Hasher.clone.call(this);
+            clone._hash = this._hash.clone();
+            return clone;
+          }
+        });
+        C.SHA256 = Hasher._createHelper(SHA256);
+        C.HmacSHA256 = Hasher._createHmacHelper(SHA256);
+      })(Math);
+      return CryptoJS.SHA256;
+    });
+  })(sha256$1);
+  return sha256$1.exports;
+}
+export {
+  requireSha256 as __require
+};

package/dist/treeshaking/_virtual/crypto-js/sha256.js2.mjs

@@ -0,0 +1,4 @@
+var sha256 = { exports: {} };
+export {
+  sha256 as __module
+};

package/dist/treeshaking/_virtual/crypto-js/sha3.js.mjs

@@ -0,0 +1,207 @@
+import { __module as sha3$1 } from "./sha3.js2.mjs";
+import { __require as requireCore } from "./core.js.mjs";
+import { __require as requireX64Core } from "./x64-core.js.mjs";
+var sha3 = sha3$1.exports;
+var hasRequiredSha3;
+function requireSha3() {
+  if (hasRequiredSha3) return sha3$1.exports;
+  hasRequiredSha3 = 1;
+  (function(module, exports) {
+    (function(root, factory, undef) {
+      {
+        module.exports = factory(requireCore(), requireX64Core());
+      }
+    })(sha3, function(CryptoJS) {
+      (function(Math2) {
+        var C = CryptoJS;
+        var C_lib = C.lib;
+        var WordArray = C_lib.WordArray;
+        var Hasher = C_lib.Hasher;
+        var C_x64 = C.x64;
+        var X64Word = C_x64.Word;
+        var C_algo = C.algo;
+        var RHO_OFFSETS = [];
+        var PI_INDEXES = [];
+        var ROUND_CONSTANTS = [];
+        (function() {
+          var x = 1, y = 0;
+          for (var t = 0; t < 24; t++) {
+            RHO_OFFSETS[x + 5 * y] = (t + 1) * (t + 2) / 2 % 64;
+            var newX = y % 5;
+            var newY = (2 * x + 3 * y) % 5;
+            x = newX;
+            y = newY;
+          }
+          for (var x = 0; x < 5; x++) {
+            for (var y = 0; y < 5; y++) {
+              PI_INDEXES[x + 5 * y] = y + (2 * x + 3 * y) % 5 * 5;
+            }
+          }
+          var LFSR = 1;
+          for (var i = 0; i < 24; i++) {
+            var roundConstantMsw = 0;
+            var roundConstantLsw = 0;
+            for (var j = 0; j < 7; j++) {
+              if (LFSR & 1) {
+                var bitPosition = (1 << j) - 1;
+                if (bitPosition < 32) {
+                  roundConstantLsw ^= 1 << bitPosition;
+                } else {
+                  roundConstantMsw ^= 1 << bitPosition - 32;
+                }
+              }
+              if (LFSR & 128) {
+                LFSR = LFSR << 1 ^ 113;
+              } else {
+                LFSR <<= 1;
+              }
+            }
+            ROUND_CONSTANTS[i] = X64Word.create(roundConstantMsw, roundConstantLsw);
+          }
+        })();
+        var T = [];
+        (function() {
+          for (var i = 0; i < 25; i++) {
+            T[i] = X64Word.create();
+          }
+        })();
+        var SHA3 = C_algo.SHA3 = Hasher.extend({
+          /**
+           * Configuration options.
+           *
+           * @property {number} outputLength
+           *   The desired number of bits in the output hash.
+           *   Only values permitted are: 224, 256, 384, 512.
+           *   Default: 512
+           */
+          cfg: Hasher.cfg.extend({
+            outputLength: 512
+          }),
+          _doReset: function() {
+            var state = this._state = [];
+            for (var i = 0; i < 25; i++) {
+              state[i] = new X64Word.init();
+            }
+            this.blockSize = (1600 - 2 * this.cfg.outputLength) / 32;
+          },
+          _doProcessBlock: function(M, offset) {
+            var state = this._state;
+            var nBlockSizeLanes = this.blockSize / 2;
+            for (var i = 0; i < nBlockSizeLanes; i++) {
+              var M2i = M[offset + 2 * i];
+              var M2i1 = M[offset + 2 * i + 1];
+              M2i = (M2i << 8 | M2i >>> 24) & 16711935 | (M2i << 24 | M2i >>> 8) & 4278255360;
+              M2i1 = (M2i1 << 8 | M2i1 >>> 24) & 16711935 | (M2i1 << 24 | M2i1 >>> 8) & 4278255360;
+              var lane = state[i];
+              lane.high ^= M2i1;
+              lane.low ^= M2i;
+            }
+            for (var round = 0; round < 24; round++) {
+              for (var x = 0; x < 5; x++) {
+                var tMsw = 0, tLsw = 0;
+                for (var y = 0; y < 5; y++) {
+                  var lane = state[x + 5 * y];
+                  tMsw ^= lane.high;
+                  tLsw ^= lane.low;
+                }
+                var Tx = T[x];
+                Tx.high = tMsw;
+                Tx.low = tLsw;
+              }
+              for (var x = 0; x < 5; x++) {
+                var Tx4 = T[(x + 4) % 5];
+                var Tx1 = T[(x + 1) % 5];
+                var Tx1Msw = Tx1.high;
+                var Tx1Lsw = Tx1.low;
+                var tMsw = Tx4.high ^ (Tx1Msw << 1 | Tx1Lsw >>> 31);
+                var tLsw = Tx4.low ^ (Tx1Lsw << 1 | Tx1Msw >>> 31);
+                for (var y = 0; y < 5; y++) {
+                  var lane = state[x + 5 * y];
+                  lane.high ^= tMsw;
+                  lane.low ^= tLsw;
+                }
+              }
+              for (var laneIndex = 1; laneIndex < 25; laneIndex++) {
+                var tMsw;
+                var tLsw;
+                var lane = state[laneIndex];
+                var laneMsw = lane.high;
+                var laneLsw = lane.low;
+                var rhoOffset = RHO_OFFSETS[laneIndex];
+                if (rhoOffset < 32) {
+                  tMsw = laneMsw << rhoOffset | laneLsw >>> 32 - rhoOffset;
+                  tLsw = laneLsw << rhoOffset | laneMsw >>> 32 - rhoOffset;
+                } else {
+                  tMsw = laneLsw << rhoOffset - 32 | laneMsw >>> 64 - rhoOffset;
+                  tLsw = laneMsw << rhoOffset - 32 | laneLsw >>> 64 - rhoOffset;
+                }
+                var TPiLane = T[PI_INDEXES[laneIndex]];
+                TPiLane.high = tMsw;
+                TPiLane.low = tLsw;
+              }
+              var T0 = T[0];
+              var state0 = state[0];
+              T0.high = state0.high;
+              T0.low = state0.low;
+              for (var x = 0; x < 5; x++) {
+                for (var y = 0; y < 5; y++) {
+                  var laneIndex = x + 5 * y;
+                  var lane = state[laneIndex];
+                  var TLane = T[laneIndex];
+                  var Tx1Lane = T[(x + 1) % 5 + 5 * y];
+                  var Tx2Lane = T[(x + 2) % 5 + 5 * y];
+                  lane.high = TLane.high ^ ~Tx1Lane.high & Tx2Lane.high;
+                  lane.low = TLane.low ^ ~Tx1Lane.low & Tx2Lane.low;
+                }
+              }
+              var lane = state[0];
+              var roundConstant = ROUND_CONSTANTS[round];
+              lane.high ^= roundConstant.high;
+              lane.low ^= roundConstant.low;
+            }
+          },
+          _doFinalize: function() {
+            var data = this._data;
+            var dataWords = data.words;
+            this._nDataBytes * 8;
+            var nBitsLeft = data.sigBytes * 8;
+            var blockSizeBits = this.blockSize * 32;
+            dataWords[nBitsLeft >>> 5] |= 1 << 24 - nBitsLeft % 32;
+            dataWords[(Math2.ceil((nBitsLeft + 1) / blockSizeBits) * blockSizeBits >>> 5) - 1] |= 128;
+            data.sigBytes = dataWords.length * 4;
+            this._process();
+            var state = this._state;
+            var outputLengthBytes = this.cfg.outputLength / 8;
+            var outputLengthLanes = outputLengthBytes / 8;
+            var hashWords = [];
+            for (var i = 0; i < outputLengthLanes; i++) {
+              var lane = state[i];
+              var laneMsw = lane.high;
+              var laneLsw = lane.low;
+              laneMsw = (laneMsw << 8 | laneMsw >>> 24) & 16711935 | (laneMsw << 24 | laneMsw >>> 8) & 4278255360;
+              laneLsw = (laneLsw << 8 | laneLsw >>> 24) & 16711935 | (laneLsw << 24 | laneLsw >>> 8) & 4278255360;
+              hashWords.push(laneLsw);
+              hashWords.push(laneMsw);
+            }
+            return new WordArray.init(hashWords, outputLengthBytes);
+          },
+          clone: function() {
+            var clone = Hasher.clone.call(this);
+            var state = clone._state = this._state.slice(0);
+            for (var i = 0; i < 25; i++) {
+              state[i] = state[i].clone();
+            }
+            return clone;
+          }
+        });
+        C.SHA3 = Hasher._createHelper(SHA3);
+        C.HmacSHA3 = Hasher._createHmacHelper(SHA3);
+      })(Math);
+      return CryptoJS.SHA3;
+    });
+  })(sha3$1);
+  return sha3$1.exports;
+}
+export {
+  requireSha3 as __require
+};

package/dist/treeshaking/_virtual/crypto-js/sha3.js2.mjs

@@ -0,0 +1,4 @@
+var sha3 = { exports: {} };
+export {
+  sha3 as __module
+};

package/dist/treeshaking/_virtual/crypto-js/sha384.js.mjs

@@ -0,0 +1,52 @@
+import { __module as sha384$1 } from "./sha384.js2.mjs";
+import { __require as requireCore } from "./core.js.mjs";
+import { __require as requireX64Core } from "./x64-core.js.mjs";
+import { __require as requireSha512 } from "./sha512.js.mjs";
+var sha384 = sha384$1.exports;
+var hasRequiredSha384;
+function requireSha384() {
+  if (hasRequiredSha384) return sha384$1.exports;
+  hasRequiredSha384 = 1;
+  (function(module, exports) {
+    (function(root, factory, undef) {
+      {
+        module.exports = factory(requireCore(), requireX64Core(), requireSha512());
+      }
+    })(sha384, function(CryptoJS) {
+      (function() {
+        var C = CryptoJS;
+        var C_x64 = C.x64;
+        var X64Word = C_x64.Word;
+        var X64WordArray = C_x64.WordArray;
+        var C_algo = C.algo;
+        var SHA512 = C_algo.SHA512;
+        var SHA384 = C_algo.SHA384 = SHA512.extend({
+          _doReset: function() {
+            this._hash = new X64WordArray.init([
+              new X64Word.init(3418070365, 3238371032),
+              new X64Word.init(1654270250, 914150663),
+              new X64Word.init(2438529370, 812702999),
+              new X64Word.init(355462360, 4144912697),
+              new X64Word.init(1731405415, 4290775857),
+              new X64Word.init(2394180231, 1750603025),
+              new X64Word.init(3675008525, 1694076839),
+              new X64Word.init(1203062813, 3204075428)
+            ]);
+          },
+          _doFinalize: function() {
+            var hash = SHA512._doFinalize.call(this);
+            hash.sigBytes -= 16;
+            return hash;
+          }
+        });
+        C.SHA384 = SHA512._createHelper(SHA384);
+        C.HmacSHA384 = SHA512._createHmacHelper(SHA384);
+      })();
+      return CryptoJS.SHA384;
+    });
+  })(sha384$1);
+  return sha384$1.exports;
+}
+export {
+  requireSha384 as __require
+};

package/dist/treeshaking/_virtual/crypto-js/sha384.js2.mjs

@@ -0,0 +1,4 @@
+var sha384 = { exports: {} };
+export {
+  sha384 as __module
+};

package/dist/treeshaking/_virtual/crypto-js/sha512.js.mjs

@@ -0,0 +1,287 @@
+import { __module as sha512$1 } from "./sha512.js2.mjs";
+import { __require as requireCore } from "./core.js.mjs";
+import { __require as requireX64Core } from "./x64-core.js.mjs";
+var sha512 = sha512$1.exports;
+var hasRequiredSha512;
+function requireSha512() {
+  if (hasRequiredSha512) return sha512$1.exports;
+  hasRequiredSha512 = 1;
+  (function(module, exports) {
+    (function(root, factory, undef) {
+      {
+        module.exports = factory(requireCore(), requireX64Core());
+      }
+    })(sha512, function(CryptoJS) {
+      (function() {
+        var C = CryptoJS;
+        var C_lib = C.lib;
+        var Hasher = C_lib.Hasher;
+        var C_x64 = C.x64;
+        var X64Word = C_x64.Word;
+        var X64WordArray = C_x64.WordArray;
+        var C_algo = C.algo;
+        function X64Word_create() {
+          return X64Word.create.apply(X64Word, arguments);
+        }
+        var K = [
+          X64Word_create(1116352408, 3609767458),
+          X64Word_create(1899447441, 602891725),
+          X64Word_create(3049323471, 3964484399),
+          X64Word_create(3921009573, 2173295548),
+          X64Word_create(961987163, 4081628472),
+          X64Word_create(1508970993, 3053834265),
+          X64Word_create(2453635748, 2937671579),
+          X64Word_create(2870763221, 3664609560),
+          X64Word_create(3624381080, 2734883394),
+          X64Word_create(310598401, 1164996542),
+          X64Word_create(607225278, 1323610764),
+          X64Word_create(1426881987, 3590304994),
+          X64Word_create(1925078388, 4068182383),
+          X64Word_create(2162078206, 991336113),
+          X64Word_create(2614888103, 633803317),
+          X64Word_create(3248222580, 3479774868),
+          X64Word_create(3835390401, 2666613458),
+          X64Word_create(4022224774, 944711139),
+          X64Word_create(264347078, 2341262773),
+          X64Word_create(604807628, 2007800933),
+          X64Word_create(770255983, 1495990901),
+          X64Word_create(1249150122, 1856431235),
+          X64Word_create(1555081692, 3175218132),
+          X64Word_create(1996064986, 2198950837),
+          X64Word_create(2554220882, 3999719339),
+          X64Word_create(2821834349, 766784016),
+          X64Word_create(2952996808, 2566594879),
+          X64Word_create(3210313671, 3203337956),
+          X64Word_create(3336571891, 1034457026),
+          X64Word_create(3584528711, 2466948901),
+          X64Word_create(113926993, 3758326383),
+          X64Word_create(338241895, 168717936),
+          X64Word_create(666307205, 1188179964),
+          X64Word_create(773529912, 1546045734),
+          X64Word_create(1294757372, 1522805485),
+          X64Word_create(1396182291, 2643833823),
+          X64Word_create(1695183700, 2343527390),
+          X64Word_create(1986661051, 1014477480),
+          X64Word_create(2177026350, 1206759142),
+          X64Word_create(2456956037, 344077627),
+          X64Word_create(2730485921, 1290863460),
+          X64Word_create(2820302411, 3158454273),
+          X64Word_create(3259730800, 3505952657),
+          X64Word_create(3345764771, 106217008),
+          X64Word_create(3516065817, 3606008344),
+          X64Word_create(3600352804, 1432725776),
+          X64Word_create(4094571909, 1467031594),
+          X64Word_create(275423344, 851169720),
+          X64Word_create(430227734, 3100823752),
+          X64Word_create(506948616, 1363258195),
+          X64Word_create(659060556, 3750685593),
+          X64Word_create(883997877, 3785050280),
+          X64Word_create(958139571, 3318307427),
+          X64Word_create(1322822218, 3812723403),
+          X64Word_create(1537002063, 2003034995),
+          X64Word_create(1747873779, 3602036899),
+          X64Word_create(1955562222, 1575990012),
+          X64Word_create(2024104815, 1125592928),
+          X64Word_create(2227730452, 2716904306),
+          X64Word_create(2361852424, 442776044),
+          X64Word_create(2428436474, 593698344),
+          X64Word_create(2756734187, 3733110249),
+          X64Word_create(3204031479, 2999351573),
+          X64Word_create(3329325298, 3815920427),
+          X64Word_create(3391569614, 3928383900),
+          X64Word_create(3515267271, 566280711),
+          X64Word_create(3940187606, 3454069534),
+          X64Word_create(4118630271, 4000239992),
+          X64Word_create(116418474, 1914138554),
+          X64Word_create(174292421, 2731055270),
+          X64Word_create(289380356, 3203993006),
+          X64Word_create(460393269, 320620315),
+          X64Word_create(685471733, 587496836),
+          X64Word_create(852142971, 1086792851),
+          X64Word_create(1017036298, 365543100),
+          X64Word_create(1126000580, 2618297676),
+          X64Word_create(1288033470, 3409855158),
+          X64Word_create(1501505948, 4234509866),
+          X64Word_create(1607167915, 987167468),
+          X64Word_create(1816402316, 1246189591)
+        ];
+        var W = [];
+        (function() {
+          for (var i = 0; i < 80; i++) {
+            W[i] = X64Word_create();
+          }
+        })();
+        var SHA512 = C_algo.SHA512 = Hasher.extend({
+          _doReset: function() {
+            this._hash = new X64WordArray.init([
+              new X64Word.init(1779033703, 4089235720),
+              new X64Word.init(3144134277, 2227873595),
+              new X64Word.init(1013904242, 4271175723),
+              new X64Word.init(2773480762, 1595750129),
+              new X64Word.init(1359893119, 2917565137),
+              new X64Word.init(2600822924, 725511199),
+              new X64Word.init(528734635, 4215389547),
+              new X64Word.init(1541459225, 327033209)
+            ]);
+          },
+          _doProcessBlock: function(M, offset) {
+            var H = this._hash.words;
+            var H0 = H[0];
+            var H1 = H[1];
+            var H2 = H[2];
+            var H3 = H[3];
+            var H4 = H[4];
+            var H5 = H[5];
+            var H6 = H[6];
+            var H7 = H[7];
+            var H0h = H0.high;
+            var H0l = H0.low;
+            var H1h = H1.high;
+            var H1l = H1.low;
+            var H2h = H2.high;
+            var H2l = H2.low;
+            var H3h = H3.high;
+            var H3l = H3.low;
+            var H4h = H4.high;
+            var H4l = H4.low;
+            var H5h = H5.high;
+            var H5l = H5.low;
+            var H6h = H6.high;
+            var H6l = H6.low;
+            var H7h = H7.high;
+            var H7l = H7.low;
+            var ah = H0h;
+            var al = H0l;
+            var bh = H1h;
+            var bl = H1l;
+            var ch = H2h;
+            var cl = H2l;
+            var dh = H3h;
+            var dl = H3l;
+            var eh = H4h;
+            var el = H4l;
+            var fh = H5h;
+            var fl = H5l;
+            var gh = H6h;
+            var gl = H6l;
+            var hh = H7h;
+            var hl = H7l;
+            for (var i = 0; i < 80; i++) {
+              var Wil;
+              var Wih;
+              var Wi = W[i];
+              if (i < 16) {
+                Wih = Wi.high = M[offset + i * 2] | 0;
+                Wil = Wi.low = M[offset + i * 2 + 1] | 0;
+              } else {
+                var gamma0x = W[i - 15];
+                var gamma0xh = gamma0x.high;
+                var gamma0xl = gamma0x.low;
+                var gamma0h = (gamma0xh >>> 1 | gamma0xl << 31) ^ (gamma0xh >>> 8 | gamma0xl << 24) ^ gamma0xh >>> 7;
+                var gamma0l = (gamma0xl >>> 1 | gamma0xh << 31) ^ (gamma0xl >>> 8 | gamma0xh << 24) ^ (gamma0xl >>> 7 | gamma0xh << 25);
+                var gamma1x = W[i - 2];
+                var gamma1xh = gamma1x.high;
+                var gamma1xl = gamma1x.low;
+                var gamma1h = (gamma1xh >>> 19 | gamma1xl << 13) ^ (gamma1xh << 3 | gamma1xl >>> 29) ^ gamma1xh >>> 6;
+                var gamma1l = (gamma1xl >>> 19 | gamma1xh << 13) ^ (gamma1xl << 3 | gamma1xh >>> 29) ^ (gamma1xl >>> 6 | gamma1xh << 26);
+                var Wi7 = W[i - 7];
+                var Wi7h = Wi7.high;
+                var Wi7l = Wi7.low;
+                var Wi16 = W[i - 16];
+                var Wi16h = Wi16.high;
+                var Wi16l = Wi16.low;
+                Wil = gamma0l + Wi7l;
+                Wih = gamma0h + Wi7h + (Wil >>> 0 < gamma0l >>> 0 ? 1 : 0);
+                Wil = Wil + gamma1l;
+                Wih = Wih + gamma1h + (Wil >>> 0 < gamma1l >>> 0 ? 1 : 0);
+                Wil = Wil + Wi16l;
+                Wih = Wih + Wi16h + (Wil >>> 0 < Wi16l >>> 0 ? 1 : 0);
+                Wi.high = Wih;
+                Wi.low = Wil;
+              }
+              var chh = eh & fh ^ ~eh & gh;
+              var chl = el & fl ^ ~el & gl;
+              var majh = ah & bh ^ ah & ch ^ bh & ch;
+              var majl = al & bl ^ al & cl ^ bl & cl;
+              var sigma0h = (ah >>> 28 | al << 4) ^ (ah << 30 | al >>> 2) ^ (ah << 25 | al >>> 7);
+              var sigma0l = (al >>> 28 | ah << 4) ^ (al << 30 | ah >>> 2) ^ (al << 25 | ah >>> 7);
+              var sigma1h = (eh >>> 14 | el << 18) ^ (eh >>> 18 | el << 14) ^ (eh << 23 | el >>> 9);
+              var sigma1l = (el >>> 14 | eh << 18) ^ (el >>> 18 | eh << 14) ^ (el << 23 | eh >>> 9);
+              var Ki = K[i];
+              var Kih = Ki.high;
+              var Kil = Ki.low;
+              var t1l = hl + sigma1l;
+              var t1h = hh + sigma1h + (t1l >>> 0 < hl >>> 0 ? 1 : 0);
+              var t1l = t1l + chl;
+              var t1h = t1h + chh + (t1l >>> 0 < chl >>> 0 ? 1 : 0);
+              var t1l = t1l + Kil;
+              var t1h = t1h + Kih + (t1l >>> 0 < Kil >>> 0 ? 1 : 0);
+              var t1l = t1l + Wil;
+              var t1h = t1h + Wih + (t1l >>> 0 < Wil >>> 0 ? 1 : 0);
+              var t2l = sigma0l + majl;
+              var t2h = sigma0h + majh + (t2l >>> 0 < sigma0l >>> 0 ? 1 : 0);
+              hh = gh;
+              hl = gl;
+              gh = fh;
+              gl = fl;
+              fh = eh;
+              fl = el;
+              el = dl + t1l | 0;
+              eh = dh + t1h + (el >>> 0 < dl >>> 0 ? 1 : 0) | 0;
+              dh = ch;
+              dl = cl;
+              ch = bh;
+              cl = bl;
+              bh = ah;
+              bl = al;
+              al = t1l + t2l | 0;
+              ah = t1h + t2h + (al >>> 0 < t1l >>> 0 ? 1 : 0) | 0;
+            }
+            H0l = H0.low = H0l + al;
+            H0.high = H0h + ah + (H0l >>> 0 < al >>> 0 ? 1 : 0);
+            H1l = H1.low = H1l + bl;
+            H1.high = H1h + bh + (H1l >>> 0 < bl >>> 0 ? 1 : 0);
+            H2l = H2.low = H2l + cl;
+            H2.high = H2h + ch + (H2l >>> 0 < cl >>> 0 ? 1 : 0);
+            H3l = H3.low = H3l + dl;
+            H3.high = H3h + dh + (H3l >>> 0 < dl >>> 0 ? 1 : 0);
+            H4l = H4.low = H4l + el;
+            H4.high = H4h + eh + (H4l >>> 0 < el >>> 0 ? 1 : 0);
+            H5l = H5.low = H5l + fl;
+            H5.high = H5h + fh + (H5l >>> 0 < fl >>> 0 ? 1 : 0);
+            H6l = H6.low = H6l + gl;
+            H6.high = H6h + gh + (H6l >>> 0 < gl >>> 0 ? 1 : 0);
+            H7l = H7.low = H7l + hl;
+            H7.high = H7h + hh + (H7l >>> 0 < hl >>> 0 ? 1 : 0);
+          },
+          _doFinalize: function() {
+            var data = this._data;
+            var dataWords = data.words;
+            var nBitsTotal = this._nDataBytes * 8;
+            var nBitsLeft = data.sigBytes * 8;
+            dataWords[nBitsLeft >>> 5] |= 128 << 24 - nBitsLeft % 32;
+            dataWords[(nBitsLeft + 128 >>> 10 << 5) + 30] = Math.floor(nBitsTotal / 4294967296);
+            dataWords[(nBitsLeft + 128 >>> 10 << 5) + 31] = nBitsTotal;
+            data.sigBytes = dataWords.length * 4;
+            this._process();
+            var hash = this._hash.toX32();
+            return hash;
+          },
+          clone: function() {
+            var clone = Hasher.clone.call(this);
+            clone._hash = this._hash.clone();
+            return clone;
+          },
+          blockSize: 1024 / 32
+        });
+        C.SHA512 = Hasher._createHelper(SHA512);
+        C.HmacSHA512 = Hasher._createHmacHelper(SHA512);
+      })();
+      return CryptoJS.SHA512;
+    });
+  })(sha512$1);
+  return sha512$1.exports;
+}
+export {
+  requireSha512 as __require
+};

package/dist/treeshaking/_virtual/crypto-js/sha512.js2.mjs

@@ -0,0 +1,4 @@
+var sha512 = { exports: {} };
+export {
+  sha512 as __module
+};