@windrun-huaiin/backend-core 12.0.0 → 13.0.0

package/dist/node_modules/.pnpm/crypto-js@4.2.0/node_modules/crypto-js/pad-ansix923.js

@@ -0,0 +1,60 @@
+'use strict';
+
+var padAnsix923$1 = require('../../../../../_virtual/pad-ansix923.js');
+var core = require('./core.js');
+var cipherCore = require('./cipher-core.js');
+
+var padAnsix923 = padAnsix923$1.__module.exports;
+
+var hasRequiredPadAnsix923;
+
+function requirePadAnsix923 () {
+	if (hasRequiredPadAnsix923) return padAnsix923$1.__module.exports;
+	hasRequiredPadAnsix923 = 1;
+	(function (module, exports) {
+(function (root, factory, undef) {
+			{
+				// CommonJS
+				module.exports = factory(core.__require(), cipherCore.__require());
+			}
+		}(padAnsix923, function (CryptoJS) {
+
+			/**
+			 * ANSI X.923 padding strategy.
+			 */
+			CryptoJS.pad.AnsiX923 = {
+			    pad: function (data, blockSize) {
+			        // Shortcuts
+			        var dataSigBytes = data.sigBytes;
+			        var blockSizeBytes = blockSize * 4;
+
+			        // Count padding bytes
+			        var nPaddingBytes = blockSizeBytes - dataSigBytes % blockSizeBytes;
+
+			        // Compute last byte position
+			        var lastBytePos = dataSigBytes + nPaddingBytes - 1;
+
+			        // Pad
+			        data.clamp();
+			        data.words[lastBytePos >>> 2] |= nPaddingBytes << (24 - (lastBytePos % 4) * 8);
+			        data.sigBytes += nPaddingBytes;
+			    },
+
+			    unpad: function (data) {
+			        // Get number of padding bytes from last byte
+			        var nPaddingBytes = data.words[(data.sigBytes - 1) >>> 2] & 0xff;
+
+			        // Remove padding
+			        data.sigBytes -= nPaddingBytes;
+			    }
+			};
+
+
+			return CryptoJS.pad.Ansix923;
+
+		})); 
+	} (padAnsix923$1.__module));
+	return padAnsix923$1.__module.exports;
+}
+
+exports.__require = requirePadAnsix923;

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

@@ -0,0 +1,58 @@
+import { __module as padAnsix923$1 } from '../../../../../_virtual/pad-ansix923.mjs';
+import { __require as requireCore } from './core.mjs';
+import { __require as requireCipherCore } from './cipher-core.mjs';
+
+var padAnsix923 = padAnsix923$1.exports;
+
+var hasRequiredPadAnsix923;
+
+function requirePadAnsix923 () {
+	if (hasRequiredPadAnsix923) return padAnsix923$1.exports;
+	hasRequiredPadAnsix923 = 1;
+	(function (module, exports) {
+(function (root, factory, undef) {
+			{
+				// CommonJS
+				module.exports = factory(requireCore(), requireCipherCore());
+			}
+		}(padAnsix923, function (CryptoJS) {
+
+			/**
+			 * ANSI X.923 padding strategy.
+			 */
+			CryptoJS.pad.AnsiX923 = {
+			    pad: function (data, blockSize) {
+			        // Shortcuts
+			        var dataSigBytes = data.sigBytes;
+			        var blockSizeBytes = blockSize * 4;
+
+			        // Count padding bytes
+			        var nPaddingBytes = blockSizeBytes - dataSigBytes % blockSizeBytes;
+
+			        // Compute last byte position
+			        var lastBytePos = dataSigBytes + nPaddingBytes - 1;
+
+			        // Pad
+			        data.clamp();
+			        data.words[lastBytePos >>> 2] |= nPaddingBytes << (24 - (lastBytePos % 4) * 8);
+			        data.sigBytes += nPaddingBytes;
+			    },
+
+			    unpad: function (data) {
+			        // Get number of padding bytes from last byte
+			        var nPaddingBytes = data.words[(data.sigBytes - 1) >>> 2] & 0xff;
+
+			        // Remove padding
+			        data.sigBytes -= nPaddingBytes;
+			    }
+			};
+
+
+			return CryptoJS.pad.Ansix923;
+
+		})); 
+	} (padAnsix923$1));
+	return padAnsix923$1.exports;
+}
+
+export { requirePadAnsix923 as __require };

package/dist/node_modules/.pnpm/crypto-js@4.2.0/node_modules/crypto-js/pad-iso10126.js

@@ -0,0 +1,55 @@
+'use strict';
+
+var padIso10126$1 = require('../../../../../_virtual/pad-iso10126.js');
+var core = require('./core.js');
+var cipherCore = require('./cipher-core.js');
+
+var padIso10126 = padIso10126$1.__module.exports;
+
+var hasRequiredPadIso10126;
+
+function requirePadIso10126 () {
+	if (hasRequiredPadIso10126) return padIso10126$1.__module.exports;
+	hasRequiredPadIso10126 = 1;
+	(function (module, exports) {
+(function (root, factory, undef) {
+			{
+				// CommonJS
+				module.exports = factory(core.__require(), cipherCore.__require());
+			}
+		}(padIso10126, function (CryptoJS) {
+
+			/**
+			 * ISO 10126 padding strategy.
+			 */
+			CryptoJS.pad.Iso10126 = {
+			    pad: function (data, blockSize) {
+			        // Shortcut
+			        var blockSizeBytes = blockSize * 4;
+
+			        // Count padding bytes
+			        var nPaddingBytes = blockSizeBytes - data.sigBytes % blockSizeBytes;
+
+			        // Pad
+			        data.concat(CryptoJS.lib.WordArray.random(nPaddingBytes - 1)).
+			             concat(CryptoJS.lib.WordArray.create([nPaddingBytes << 24], 1));
+			    },
+
+			    unpad: function (data) {
+			        // Get number of padding bytes from last byte
+			        var nPaddingBytes = data.words[(data.sigBytes - 1) >>> 2] & 0xff;
+
+			        // Remove padding
+			        data.sigBytes -= nPaddingBytes;
+			    }
+			};
+
+
+			return CryptoJS.pad.Iso10126;
+
+		})); 
+	} (padIso10126$1.__module));
+	return padIso10126$1.__module.exports;
+}
+
+exports.__require = requirePadIso10126;

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

@@ -0,0 +1,53 @@
+import { __module as padIso10126$1 } from '../../../../../_virtual/pad-iso10126.mjs';
+import { __require as requireCore } from './core.mjs';
+import { __require as requireCipherCore } from './cipher-core.mjs';
+
+var padIso10126 = padIso10126$1.exports;
+
+var hasRequiredPadIso10126;
+
+function requirePadIso10126 () {
+	if (hasRequiredPadIso10126) return padIso10126$1.exports;
+	hasRequiredPadIso10126 = 1;
+	(function (module, exports) {
+(function (root, factory, undef) {
+			{
+				// CommonJS
+				module.exports = factory(requireCore(), requireCipherCore());
+			}
+		}(padIso10126, function (CryptoJS) {
+
+			/**
+			 * ISO 10126 padding strategy.
+			 */
+			CryptoJS.pad.Iso10126 = {
+			    pad: function (data, blockSize) {
+			        // Shortcut
+			        var blockSizeBytes = blockSize * 4;
+
+			        // Count padding bytes
+			        var nPaddingBytes = blockSizeBytes - data.sigBytes % blockSizeBytes;
+
+			        // Pad
+			        data.concat(CryptoJS.lib.WordArray.random(nPaddingBytes - 1)).
+			             concat(CryptoJS.lib.WordArray.create([nPaddingBytes << 24], 1));
+			    },
+
+			    unpad: function (data) {
+			        // Get number of padding bytes from last byte
+			        var nPaddingBytes = data.words[(data.sigBytes - 1) >>> 2] & 0xff;
+
+			        // Remove padding
+			        data.sigBytes -= nPaddingBytes;
+			    }
+			};
+
+
+			return CryptoJS.pad.Iso10126;
+
+		})); 
+	} (padIso10126$1));
+	return padIso10126$1.exports;
+}
+
+export { requirePadIso10126 as __require };

package/dist/node_modules/.pnpm/crypto-js@4.2.0/node_modules/crypto-js/pad-iso97971.js

@@ -0,0 +1,51 @@
+'use strict';
+
+var padIso97971$1 = require('../../../../../_virtual/pad-iso97971.js');
+var core = require('./core.js');
+var cipherCore = require('./cipher-core.js');
+
+var padIso97971 = padIso97971$1.__module.exports;
+
+var hasRequiredPadIso97971;
+
+function requirePadIso97971 () {
+	if (hasRequiredPadIso97971) return padIso97971$1.__module.exports;
+	hasRequiredPadIso97971 = 1;
+	(function (module, exports) {
+(function (root, factory, undef) {
+			{
+				// CommonJS
+				module.exports = factory(core.__require(), cipherCore.__require());
+			}
+		}(padIso97971, function (CryptoJS) {
+
+			/**
+			 * ISO/IEC 9797-1 Padding Method 2.
+			 */
+			CryptoJS.pad.Iso97971 = {
+			    pad: function (data, blockSize) {
+			        // Add 0x80 byte
+			        data.concat(CryptoJS.lib.WordArray.create([0x80000000], 1));
+
+			        // Zero pad the rest
+			        CryptoJS.pad.ZeroPadding.pad(data, blockSize);
+			    },
+
+			    unpad: function (data) {
+			        // Remove zero padding
+			        CryptoJS.pad.ZeroPadding.unpad(data);
+
+			        // Remove one more byte -- the 0x80 byte
+			        data.sigBytes--;
+			    }
+			};
+
+
+			return CryptoJS.pad.Iso97971;
+
+		})); 
+	} (padIso97971$1.__module));
+	return padIso97971$1.__module.exports;
+}
+
+exports.__require = requirePadIso97971;

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

@@ -0,0 +1,49 @@
+import { __module as padIso97971$1 } from '../../../../../_virtual/pad-iso97971.mjs';
+import { __require as requireCore } from './core.mjs';
+import { __require as requireCipherCore } from './cipher-core.mjs';
+
+var padIso97971 = padIso97971$1.exports;
+
+var hasRequiredPadIso97971;
+
+function requirePadIso97971 () {
+	if (hasRequiredPadIso97971) return padIso97971$1.exports;
+	hasRequiredPadIso97971 = 1;
+	(function (module, exports) {
+(function (root, factory, undef) {
+			{
+				// CommonJS
+				module.exports = factory(requireCore(), requireCipherCore());
+			}
+		}(padIso97971, function (CryptoJS) {
+
+			/**
+			 * ISO/IEC 9797-1 Padding Method 2.
+			 */
+			CryptoJS.pad.Iso97971 = {
+			    pad: function (data, blockSize) {
+			        // Add 0x80 byte
+			        data.concat(CryptoJS.lib.WordArray.create([0x80000000], 1));
+
+			        // Zero pad the rest
+			        CryptoJS.pad.ZeroPadding.pad(data, blockSize);
+			    },
+
+			    unpad: function (data) {
+			        // Remove zero padding
+			        CryptoJS.pad.ZeroPadding.unpad(data);
+
+			        // Remove one more byte -- the 0x80 byte
+			        data.sigBytes--;
+			    }
+			};
+
+
+			return CryptoJS.pad.Iso97971;
+
+		})); 
+	} (padIso97971$1));
+	return padIso97971$1.exports;
+}
+
+export { requirePadIso97971 as __require };

package/dist/node_modules/.pnpm/crypto-js@4.2.0/node_modules/crypto-js/pad-nopadding.js

@@ -0,0 +1,41 @@
+'use strict';
+
+var padNopadding$1 = require('../../../../../_virtual/pad-nopadding.js');
+var core = require('./core.js');
+var cipherCore = require('./cipher-core.js');
+
+var padNopadding = padNopadding$1.__module.exports;
+
+var hasRequiredPadNopadding;
+
+function requirePadNopadding () {
+	if (hasRequiredPadNopadding) return padNopadding$1.__module.exports;
+	hasRequiredPadNopadding = 1;
+	(function (module, exports) {
+(function (root, factory, undef) {
+			{
+				// CommonJS
+				module.exports = factory(core.__require(), cipherCore.__require());
+			}
+		}(padNopadding, function (CryptoJS) {
+
+			/**
+			 * A noop padding strategy.
+			 */
+			CryptoJS.pad.NoPadding = {
+			    pad: function () {
+			    },
+
+			    unpad: function () {
+			    }
+			};
+
+
+			return CryptoJS.pad.NoPadding;
+
+		})); 
+	} (padNopadding$1.__module));
+	return padNopadding$1.__module.exports;
+}
+
+exports.__require = requirePadNopadding;

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

@@ -0,0 +1,39 @@
+import { __module as padNopadding$1 } from '../../../../../_virtual/pad-nopadding.mjs';
+import { __require as requireCore } from './core.mjs';
+import { __require as requireCipherCore } from './cipher-core.mjs';
+
+var padNopadding = padNopadding$1.exports;
+
+var hasRequiredPadNopadding;
+
+function requirePadNopadding () {
+	if (hasRequiredPadNopadding) return padNopadding$1.exports;
+	hasRequiredPadNopadding = 1;
+	(function (module, exports) {
+(function (root, factory, undef) {
+			{
+				// CommonJS
+				module.exports = factory(requireCore(), requireCipherCore());
+			}
+		}(padNopadding, function (CryptoJS) {
+
+			/**
+			 * A noop padding strategy.
+			 */
+			CryptoJS.pad.NoPadding = {
+			    pad: function () {
+			    },
+
+			    unpad: function () {
+			    }
+			};
+
+
+			return CryptoJS.pad.NoPadding;
+
+		})); 
+	} (padNopadding$1));
+	return padNopadding$1.exports;
+}
+
+export { requirePadNopadding as __require };

package/dist/node_modules/.pnpm/crypto-js@4.2.0/node_modules/crypto-js/pad-zeropadding.js

@@ -0,0 +1,58 @@
+'use strict';
+
+var padZeropadding$1 = require('../../../../../_virtual/pad-zeropadding.js');
+var core = require('./core.js');
+var cipherCore = require('./cipher-core.js');
+
+var padZeropadding = padZeropadding$1.__module.exports;
+
+var hasRequiredPadZeropadding;
+
+function requirePadZeropadding () {
+	if (hasRequiredPadZeropadding) return padZeropadding$1.__module.exports;
+	hasRequiredPadZeropadding = 1;
+	(function (module, exports) {
+(function (root, factory, undef) {
+			{
+				// CommonJS
+				module.exports = factory(core.__require(), cipherCore.__require());
+			}
+		}(padZeropadding, function (CryptoJS) {
+
+			/**
+			 * Zero padding strategy.
+			 */
+			CryptoJS.pad.ZeroPadding = {
+			    pad: function (data, blockSize) {
+			        // Shortcut
+			        var blockSizeBytes = blockSize * 4;
+
+			        // Pad
+			        data.clamp();
+			        data.sigBytes += blockSizeBytes - ((data.sigBytes % blockSizeBytes) || blockSizeBytes);
+			    },
+
+			    unpad: function (data) {
+			        // Shortcut
+			        var dataWords = data.words;
+
+			        // Unpad
+			        var i = data.sigBytes - 1;
+			        for (var i = data.sigBytes - 1; i >= 0; i--) {
+			            if (((dataWords[i >>> 2] >>> (24 - (i % 4) * 8)) & 0xff)) {
+			                data.sigBytes = i + 1;
+			                break;
+			            }
+			        }
+			    }
+			};
+
+
+			return CryptoJS.pad.ZeroPadding;
+
+		})); 
+	} (padZeropadding$1.__module));
+	return padZeropadding$1.__module.exports;
+}
+
+exports.__require = requirePadZeropadding;

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

@@ -0,0 +1,56 @@
+import { __module as padZeropadding$1 } from '../../../../../_virtual/pad-zeropadding.mjs';
+import { __require as requireCore } from './core.mjs';
+import { __require as requireCipherCore } from './cipher-core.mjs';
+
+var padZeropadding = padZeropadding$1.exports;
+
+var hasRequiredPadZeropadding;
+
+function requirePadZeropadding () {
+	if (hasRequiredPadZeropadding) return padZeropadding$1.exports;
+	hasRequiredPadZeropadding = 1;
+	(function (module, exports) {
+(function (root, factory, undef) {
+			{
+				// CommonJS
+				module.exports = factory(requireCore(), requireCipherCore());
+			}
+		}(padZeropadding, function (CryptoJS) {
+
+			/**
+			 * Zero padding strategy.
+			 */
+			CryptoJS.pad.ZeroPadding = {
+			    pad: function (data, blockSize) {
+			        // Shortcut
+			        var blockSizeBytes = blockSize * 4;
+
+			        // Pad
+			        data.clamp();
+			        data.sigBytes += blockSizeBytes - ((data.sigBytes % blockSizeBytes) || blockSizeBytes);
+			    },
+
+			    unpad: function (data) {
+			        // Shortcut
+			        var dataWords = data.words;
+
+			        // Unpad
+			        var i = data.sigBytes - 1;
+			        for (var i = data.sigBytes - 1; i >= 0; i--) {
+			            if (((dataWords[i >>> 2] >>> (24 - (i % 4) * 8)) & 0xff)) {
+			                data.sigBytes = i + 1;
+			                break;
+			            }
+			        }
+			    }
+			};
+
+
+			return CryptoJS.pad.ZeroPadding;
+
+		})); 
+	} (padZeropadding$1));
+	return padZeropadding$1.exports;
+}
+
+export { requirePadZeropadding as __require };

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

@@ -0,0 +1,157 @@
+'use strict';
+
+var pbkdf2$1 = require('../../../../../_virtual/pbkdf2.js');
+var core = require('./core.js');
+var sha256 = require('./sha256.js');
+var hmac = require('./hmac.js');
+
+var pbkdf2 = pbkdf2$1.__module.exports;
+
+var hasRequiredPbkdf2;
+
+function requirePbkdf2 () {
+	if (hasRequiredPbkdf2) return pbkdf2$1.__module.exports;
+	hasRequiredPbkdf2 = 1;
+	(function (module, exports) {
+(function (root, factory, undef) {
+			{
+				// CommonJS
+				module.exports = factory(core.__require(), sha256.__require(), hmac.__require());
+			}
+		}(pbkdf2, function (CryptoJS) {
+
+			(function () {
+			    // Shortcuts
+			    var C = CryptoJS;
+			    var C_lib = C.lib;
+			    var Base = C_lib.Base;
+			    var WordArray = C_lib.WordArray;
+			    var C_algo = C.algo;
+			    var SHA256 = C_algo.SHA256;
+			    var HMAC = C_algo.HMAC;
+
+			    /**
+			     * Password-Based Key Derivation Function 2 algorithm.
+			     */
+			    var PBKDF2 = C_algo.PBKDF2 = Base.extend({
+			        /**
+			         * Configuration options.
+			         *
+			         * @property {number} keySize The key size in words to generate. Default: 4 (128 bits)
+			         * @property {Hasher} hasher The hasher to use. Default: SHA256
+			         * @property {number} iterations The number of iterations to perform. Default: 250000
+			         */
+			        cfg: Base.extend({
+			            keySize: 128/32,
+			            hasher: SHA256,
+			            iterations: 250000
+			        }),
+
+			        /**
+			         * Initializes a newly created key derivation function.
+			         *
+			         * @param {Object} cfg (Optional) The configuration options to use for the derivation.
+			         *
+			         * @example
+			         *
+			         *     var kdf = CryptoJS.algo.PBKDF2.create();
+			         *     var kdf = CryptoJS.algo.PBKDF2.create({ keySize: 8 });
+			         *     var kdf = CryptoJS.algo.PBKDF2.create({ keySize: 8, iterations: 1000 });
+			         */
+			        init: function (cfg) {
+			            this.cfg = this.cfg.extend(cfg);
+			        },
+
+			        /**
+			         * Computes the Password-Based Key Derivation Function 2.
+			         *
+			         * @param {WordArray|string} password The password.
+			         * @param {WordArray|string} salt A salt.
+			         *
+			         * @return {WordArray} The derived key.
+			         *
+			         * @example
+			         *
+			         *     var key = kdf.compute(password, salt);
+			         */
+			        compute: function (password, salt) {
+			            // Shortcut
+			            var cfg = this.cfg;
+
+			            // Init HMAC
+			            var hmac = HMAC.create(cfg.hasher, password);
+
+			            // Initial values
+			            var derivedKey = WordArray.create();
+			            var blockIndex = WordArray.create([0x00000001]);
+
+			            // Shortcuts
+			            var derivedKeyWords = derivedKey.words;
+			            var blockIndexWords = blockIndex.words;
+			            var keySize = cfg.keySize;
+			            var iterations = cfg.iterations;
+
+			            // Generate key
+			            while (derivedKeyWords.length < keySize) {
+			                var block = hmac.update(salt).finalize(blockIndex);
+			                hmac.reset();
+
+			                // Shortcuts
+			                var blockWords = block.words;
+			                var blockWordsLength = blockWords.length;
+
+			                // Iterations
+			                var intermediate = block;
+			                for (var i = 1; i < iterations; i++) {
+			                    intermediate = hmac.finalize(intermediate);
+			                    hmac.reset();
+
+			                    // Shortcut
+			                    var intermediateWords = intermediate.words;
+
+			                    // XOR intermediate with block
+			                    for (var j = 0; j < blockWordsLength; j++) {
+			                        blockWords[j] ^= intermediateWords[j];
+			                    }
+			                }
+
+			                derivedKey.concat(block);
+			                blockIndexWords[0]++;
+			            }
+			            derivedKey.sigBytes = keySize * 4;
+
+			            return derivedKey;
+			        }
+			    });
+
+			    /**
+			     * Computes the Password-Based Key Derivation Function 2.
+			     *
+			     * @param {WordArray|string} password The password.
+			     * @param {WordArray|string} salt A salt.
+			     * @param {Object} cfg (Optional) The configuration options to use for this computation.
+			     *
+			     * @return {WordArray} The derived key.
+			     *
+			     * @static
+			     *
+			     * @example
+			     *
+			     *     var key = CryptoJS.PBKDF2(password, salt);
+			     *     var key = CryptoJS.PBKDF2(password, salt, { keySize: 8 });
+			     *     var key = CryptoJS.PBKDF2(password, salt, { keySize: 8, iterations: 1000 });
+			     */
+			    C.PBKDF2 = function (password, salt, cfg) {
+			        return PBKDF2.create(cfg).compute(password, salt);
+			    };
+			}());
+
+
+			return CryptoJS.PBKDF2;
+
+		})); 
+	} (pbkdf2$1.__module));
+	return pbkdf2$1.__module.exports;
+}
+
+exports.__require = requirePbkdf2;