@windrun-huaiin/backend-core 12.0.0 → 13.0.0

package/dist/node_modules/.pnpm/crypto-js@4.2.0/node_modules/crypto-js/sha256.mjs

@@ -0,0 +1,207 @@
+import { __module as sha256$1 } from '../../../../../_virtual/sha256.mjs';
+import { __require as requireCore } from './core.mjs';
+
+var sha256 = sha256$1.exports;
+
+var hasRequiredSha256;
+
+function requireSha256 () {
+	if (hasRequiredSha256) return sha256$1.exports;
+	hasRequiredSha256 = 1;
+	(function (module, exports) {
+(function (root, factory) {
+			{
+				// CommonJS
+				module.exports = factory(requireCore());
+			}
+		}(sha256, function (CryptoJS) {
+
+			(function (Math) {
+			    // Shortcuts
+			    var C = CryptoJS;
+			    var C_lib = C.lib;
+			    var WordArray = C_lib.WordArray;
+			    var Hasher = C_lib.Hasher;
+			    var C_algo = C.algo;
+
+			    // Initialization and round constants tables
+			    var H = [];
+			    var K = [];
+
+			    // Compute constants
+			    (function () {
+			        function isPrime(n) {
+			            var sqrtN = Math.sqrt(n);
+			            for (var factor = 2; factor <= sqrtN; factor++) {
+			                if (!(n % factor)) {
+			                    return false;
+			                }
+			            }
+
+			            return true;
+			        }
+
+			        function getFractionalBits(n) {
+			            return ((n - (n | 0)) * 0x100000000) | 0;
+			        }
+
+			        var n = 2;
+			        var nPrime = 0;
+			        while (nPrime < 64) {
+			            if (isPrime(n)) {
+			                if (nPrime < 8) {
+			                    H[nPrime] = getFractionalBits(Math.pow(n, 1 / 2));
+			                }
+			                K[nPrime] = getFractionalBits(Math.pow(n, 1 / 3));
+
+			                nPrime++;
+			            }
+
+			            n++;
+			        }
+			    }());
+
+			    // Reusable object
+			    var W = [];
+
+			    /**
+			     * SHA-256 hash algorithm.
+			     */
+			    var SHA256 = C_algo.SHA256 = Hasher.extend({
+			        _doReset: function () {
+			            this._hash = new WordArray.init(H.slice(0));
+			        },
+
+			        _doProcessBlock: function (M, offset) {
+			            // Shortcut
+			            var H = this._hash.words;
+
+			            // Working variables
+			            var a = H[0];
+			            var b = H[1];
+			            var c = H[2];
+			            var d = H[3];
+			            var e = H[4];
+			            var f = H[5];
+			            var g = H[6];
+			            var h = H[7];
+
+			            // Computation
+			            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;
+			            }
+
+			            // Intermediate hash value
+			            H[0] = (H[0] + a) | 0;
+			            H[1] = (H[1] + b) | 0;
+			            H[2] = (H[2] + c) | 0;
+			            H[3] = (H[3] + d) | 0;
+			            H[4] = (H[4] + e) | 0;
+			            H[5] = (H[5] + f) | 0;
+			            H[6] = (H[6] + g) | 0;
+			            H[7] = (H[7] + h) | 0;
+			        },
+
+			        _doFinalize: function () {
+			            // Shortcuts
+			            var data = this._data;
+			            var dataWords = data.words;
+
+			            var nBitsTotal = this._nDataBytes * 8;
+			            var nBitsLeft = data.sigBytes * 8;
+
+			            // Add padding
+			            dataWords[nBitsLeft >>> 5] |= 0x80 << (24 - nBitsLeft % 32);
+			            dataWords[(((nBitsLeft + 64) >>> 9) << 4) + 14] = Math.floor(nBitsTotal / 0x100000000);
+			            dataWords[(((nBitsLeft + 64) >>> 9) << 4) + 15] = nBitsTotal;
+			            data.sigBytes = dataWords.length * 4;
+
+			            // Hash final blocks
+			            this._process();
+
+			            // Return final computed hash
+			            return this._hash;
+			        },
+
+			        clone: function () {
+			            var clone = Hasher.clone.call(this);
+			            clone._hash = this._hash.clone();
+
+			            return clone;
+			        }
+			    });
+
+			    /**
+			     * Shortcut function to the hasher's object interface.
+			     *
+			     * @param {WordArray|string} message The message to hash.
+			     *
+			     * @return {WordArray} The hash.
+			     *
+			     * @static
+			     *
+			     * @example
+			     *
+			     *     var hash = CryptoJS.SHA256('message');
+			     *     var hash = CryptoJS.SHA256(wordArray);
+			     */
+			    C.SHA256 = Hasher._createHelper(SHA256);
+
+			    /**
+			     * Shortcut function to the HMAC's object interface.
+			     *
+			     * @param {WordArray|string} message The message to hash.
+			     * @param {WordArray|string} key The secret key.
+			     *
+			     * @return {WordArray} The HMAC.
+			     *
+			     * @static
+			     *
+			     * @example
+			     *
+			     *     var hmac = CryptoJS.HmacSHA256(message, key);
+			     */
+			    C.HmacSHA256 = Hasher._createHmacHelper(SHA256);
+			}(Math));
+
+
+			return CryptoJS.SHA256;
+
+		})); 
+	} (sha256$1));
+	return sha256$1.exports;
+}
+
+export { requireSha256 as __require };

package/dist/node_modules/.pnpm/crypto-js@4.2.0/node_modules/crypto-js/sha3.js

@@ -0,0 +1,337 @@
+'use strict';
+
+var sha3$1 = require('../../../../../_virtual/sha3.js');
+var core = require('./core.js');
+var x64Core = require('./x64-core.js');
+
+var sha3 = sha3$1.__module.exports;
+
+var hasRequiredSha3;
+
+function requireSha3 () {
+	if (hasRequiredSha3) return sha3$1.__module.exports;
+	hasRequiredSha3 = 1;
+	(function (module, exports) {
+(function (root, factory, undef) {
+			{
+				// CommonJS
+				module.exports = factory(core.__require(), x64Core.__require());
+			}
+		}(sha3, function (CryptoJS) {
+
+			(function (Math) {
+			    // Shortcuts
+			    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;
+
+			    // Constants tables
+			    var RHO_OFFSETS = [];
+			    var PI_INDEXES  = [];
+			    var ROUND_CONSTANTS = [];
+
+			    // Compute Constants
+			    (function () {
+			        // Compute rho offset constants
+			        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;
+			        }
+
+			        // Compute pi index constants
+			        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;
+			            }
+			        }
+
+			        // Compute round constants
+			        var LFSR = 0x01;
+			        for (var i = 0; i < 24; i++) {
+			            var roundConstantMsw = 0;
+			            var roundConstantLsw = 0;
+
+			            for (var j = 0; j < 7; j++) {
+			                if (LFSR & 0x01) {
+			                    var bitPosition = (1 << j) - 1;
+			                    if (bitPosition < 32) {
+			                        roundConstantLsw ^= 1 << bitPosition;
+			                    } else /* if (bitPosition >= 32) */ {
+			                        roundConstantMsw ^= 1 << (bitPosition - 32);
+			                    }
+			                }
+
+			                // Compute next LFSR
+			                if (LFSR & 0x80) {
+			                    // Primitive polynomial over GF(2): x^8 + x^6 + x^5 + x^4 + 1
+			                    LFSR = (LFSR << 1) ^ 0x71;
+			                } else {
+			                    LFSR <<= 1;
+			                }
+			            }
+
+			            ROUND_CONSTANTS[i] = X64Word.create(roundConstantMsw, roundConstantLsw);
+			        }
+			    }());
+
+			    // Reusable objects for temporary values
+			    var T = [];
+			    (function () {
+			        for (var i = 0; i < 25; i++) {
+			            T[i] = X64Word.create();
+			        }
+			    }());
+
+			    /**
+			     * SHA-3 hash algorithm.
+			     */
+			    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) {
+			            // Shortcuts
+			            var state = this._state;
+			            var nBlockSizeLanes = this.blockSize / 2;
+
+			            // Absorb
+			            for (var i = 0; i < nBlockSizeLanes; i++) {
+			                // Shortcuts
+			                var M2i  = M[offset + 2 * i];
+			                var M2i1 = M[offset + 2 * i + 1];
+
+			                // Swap endian
+			                M2i = (
+			                    (((M2i << 8)  | (M2i >>> 24)) & 0x00ff00ff) |
+			                    (((M2i << 24) | (M2i >>> 8))  & 0xff00ff00)
+			                );
+			                M2i1 = (
+			                    (((M2i1 << 8)  | (M2i1 >>> 24)) & 0x00ff00ff) |
+			                    (((M2i1 << 24) | (M2i1 >>> 8))  & 0xff00ff00)
+			                );
+
+			                // Absorb message into state
+			                var lane = state[i];
+			                lane.high ^= M2i1;
+			                lane.low  ^= M2i;
+			            }
+
+			            // Rounds
+			            for (var round = 0; round < 24; round++) {
+			                // Theta
+			                for (var x = 0; x < 5; x++) {
+			                    // Mix column lanes
+			                    var tMsw = 0, tLsw = 0;
+			                    for (var y = 0; y < 5; y++) {
+			                        var lane = state[x + 5 * y];
+			                        tMsw ^= lane.high;
+			                        tLsw ^= lane.low;
+			                    }
+
+			                    // Temporary values
+			                    var Tx = T[x];
+			                    Tx.high = tMsw;
+			                    Tx.low  = tLsw;
+			                }
+			                for (var x = 0; x < 5; x++) {
+			                    // Shortcuts
+			                    var Tx4 = T[(x + 4) % 5];
+			                    var Tx1 = T[(x + 1) % 5];
+			                    var Tx1Msw = Tx1.high;
+			                    var Tx1Lsw = Tx1.low;
+
+			                    // Mix surrounding columns
+			                    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;
+			                    }
+			                }
+
+			                // Rho Pi
+			                for (var laneIndex = 1; laneIndex < 25; laneIndex++) {
+			                    var tMsw;
+			                    var tLsw;
+
+			                    // Shortcuts
+			                    var lane = state[laneIndex];
+			                    var laneMsw = lane.high;
+			                    var laneLsw = lane.low;
+			                    var rhoOffset = RHO_OFFSETS[laneIndex];
+
+			                    // Rotate lanes
+			                    if (rhoOffset < 32) {
+			                        tMsw = (laneMsw << rhoOffset) | (laneLsw >>> (32 - rhoOffset));
+			                        tLsw = (laneLsw << rhoOffset) | (laneMsw >>> (32 - rhoOffset));
+			                    } else /* if (rhoOffset >= 32) */ {
+			                        tMsw = (laneLsw << (rhoOffset - 32)) | (laneMsw >>> (64 - rhoOffset));
+			                        tLsw = (laneMsw << (rhoOffset - 32)) | (laneLsw >>> (64 - rhoOffset));
+			                    }
+
+			                    // Transpose lanes
+			                    var TPiLane = T[PI_INDEXES[laneIndex]];
+			                    TPiLane.high = tMsw;
+			                    TPiLane.low  = tLsw;
+			                }
+
+			                // Rho pi at x = y = 0
+			                var T0 = T[0];
+			                var state0 = state[0];
+			                T0.high = state0.high;
+			                T0.low  = state0.low;
+
+			                // Chi
+			                for (var x = 0; x < 5; x++) {
+			                    for (var y = 0; y < 5; y++) {
+			                        // Shortcuts
+			                        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];
+
+			                        // Mix rows
+			                        lane.high = TLane.high ^ (~Tx1Lane.high & Tx2Lane.high);
+			                        lane.low  = TLane.low  ^ (~Tx1Lane.low  & Tx2Lane.low);
+			                    }
+			                }
+
+			                // Iota
+			                var lane = state[0];
+			                var roundConstant = ROUND_CONSTANTS[round];
+			                lane.high ^= roundConstant.high;
+			                lane.low  ^= roundConstant.low;
+			            }
+			        },
+
+			        _doFinalize: function () {
+			            // Shortcuts
+			            var data = this._data;
+			            var dataWords = data.words;
+			            this._nDataBytes * 8;
+			            var nBitsLeft = data.sigBytes * 8;
+			            var blockSizeBits = this.blockSize * 32;
+
+			            // Add padding
+			            dataWords[nBitsLeft >>> 5] |= 0x1 << (24 - nBitsLeft % 32);
+			            dataWords[((Math.ceil((nBitsLeft + 1) / blockSizeBits) * blockSizeBits) >>> 5) - 1] |= 0x80;
+			            data.sigBytes = dataWords.length * 4;
+
+			            // Hash final blocks
+			            this._process();
+
+			            // Shortcuts
+			            var state = this._state;
+			            var outputLengthBytes = this.cfg.outputLength / 8;
+			            var outputLengthLanes = outputLengthBytes / 8;
+
+			            // Squeeze
+			            var hashWords = [];
+			            for (var i = 0; i < outputLengthLanes; i++) {
+			                // Shortcuts
+			                var lane = state[i];
+			                var laneMsw = lane.high;
+			                var laneLsw = lane.low;
+
+			                // Swap endian
+			                laneMsw = (
+			                    (((laneMsw << 8)  | (laneMsw >>> 24)) & 0x00ff00ff) |
+			                    (((laneMsw << 24) | (laneMsw >>> 8))  & 0xff00ff00)
+			                );
+			                laneLsw = (
+			                    (((laneLsw << 8)  | (laneLsw >>> 24)) & 0x00ff00ff) |
+			                    (((laneLsw << 24) | (laneLsw >>> 8))  & 0xff00ff00)
+			                );
+
+			                // Squeeze state to retrieve hash
+			                hashWords.push(laneLsw);
+			                hashWords.push(laneMsw);
+			            }
+
+			            // Return final computed hash
+			            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;
+			        }
+			    });
+
+			    /**
+			     * Shortcut function to the hasher's object interface.
+			     *
+			     * @param {WordArray|string} message The message to hash.
+			     *
+			     * @return {WordArray} The hash.
+			     *
+			     * @static
+			     *
+			     * @example
+			     *
+			     *     var hash = CryptoJS.SHA3('message');
+			     *     var hash = CryptoJS.SHA3(wordArray);
+			     */
+			    C.SHA3 = Hasher._createHelper(SHA3);
+
+			    /**
+			     * Shortcut function to the HMAC's object interface.
+			     *
+			     * @param {WordArray|string} message The message to hash.
+			     * @param {WordArray|string} key The secret key.
+			     *
+			     * @return {WordArray} The HMAC.
+			     *
+			     * @static
+			     *
+			     * @example
+			     *
+			     *     var hmac = CryptoJS.HmacSHA3(message, key);
+			     */
+			    C.HmacSHA3 = Hasher._createHmacHelper(SHA3);
+			}(Math));
+
+
+			return CryptoJS.SHA3;
+
+		})); 
+	} (sha3$1.__module));
+	return sha3$1.__module.exports;
+}
+
+exports.__require = requireSha3;