@windrun-huaiin/backend-core 12.0.0 → 13.0.0

package/dist/node_modules/.pnpm/crypto-js@4.2.0/node_modules/crypto-js/enc-utf16.js

@@ -0,0 +1,159 @@
+'use strict';
+
+var encUtf16$1 = require('../../../../../_virtual/enc-utf16.js');
+var core = require('./core.js');
+
+var encUtf16 = encUtf16$1.__module.exports;
+
+var hasRequiredEncUtf16;
+
+function requireEncUtf16 () {
+	if (hasRequiredEncUtf16) return encUtf16$1.__module.exports;
+	hasRequiredEncUtf16 = 1;
+	(function (module, exports) {
+(function (root, factory) {
+			{
+				// CommonJS
+				module.exports = factory(core.__require());
+			}
+		}(encUtf16, function (CryptoJS) {
+
+			(function () {
+			    // Shortcuts
+			    var C = CryptoJS;
+			    var C_lib = C.lib;
+			    var WordArray = C_lib.WordArray;
+			    var C_enc = C.enc;
+
+			    /**
+			     * UTF-16 BE encoding strategy.
+			     */
+			    C_enc.Utf16 = C_enc.Utf16BE = {
+			        /**
+			         * Converts a word array to a UTF-16 BE string.
+			         *
+			         * @param {WordArray} wordArray The word array.
+			         *
+			         * @return {string} The UTF-16 BE string.
+			         *
+			         * @static
+			         *
+			         * @example
+			         *
+			         *     var utf16String = CryptoJS.enc.Utf16.stringify(wordArray);
+			         */
+			        stringify: function (wordArray) {
+			            // Shortcuts
+			            var words = wordArray.words;
+			            var sigBytes = wordArray.sigBytes;
+
+			            // Convert
+			            var utf16Chars = [];
+			            for (var i = 0; i < sigBytes; i += 2) {
+			                var codePoint = (words[i >>> 2] >>> (16 - (i % 4) * 8)) & 0xffff;
+			                utf16Chars.push(String.fromCharCode(codePoint));
+			            }
+
+			            return utf16Chars.join('');
+			        },
+
+			        /**
+			         * Converts a UTF-16 BE string to a word array.
+			         *
+			         * @param {string} utf16Str The UTF-16 BE string.
+			         *
+			         * @return {WordArray} The word array.
+			         *
+			         * @static
+			         *
+			         * @example
+			         *
+			         *     var wordArray = CryptoJS.enc.Utf16.parse(utf16String);
+			         */
+			        parse: function (utf16Str) {
+			            // Shortcut
+			            var utf16StrLength = utf16Str.length;
+
+			            // Convert
+			            var words = [];
+			            for (var i = 0; i < utf16StrLength; i++) {
+			                words[i >>> 1] |= utf16Str.charCodeAt(i) << (16 - (i % 2) * 16);
+			            }
+
+			            return WordArray.create(words, utf16StrLength * 2);
+			        }
+			    };
+
+			    /**
+			     * UTF-16 LE encoding strategy.
+			     */
+			    C_enc.Utf16LE = {
+			        /**
+			         * Converts a word array to a UTF-16 LE string.
+			         *
+			         * @param {WordArray} wordArray The word array.
+			         *
+			         * @return {string} The UTF-16 LE string.
+			         *
+			         * @static
+			         *
+			         * @example
+			         *
+			         *     var utf16Str = CryptoJS.enc.Utf16LE.stringify(wordArray);
+			         */
+			        stringify: function (wordArray) {
+			            // Shortcuts
+			            var words = wordArray.words;
+			            var sigBytes = wordArray.sigBytes;
+
+			            // Convert
+			            var utf16Chars = [];
+			            for (var i = 0; i < sigBytes; i += 2) {
+			                var codePoint = swapEndian((words[i >>> 2] >>> (16 - (i % 4) * 8)) & 0xffff);
+			                utf16Chars.push(String.fromCharCode(codePoint));
+			            }
+
+			            return utf16Chars.join('');
+			        },
+
+			        /**
+			         * Converts a UTF-16 LE string to a word array.
+			         *
+			         * @param {string} utf16Str The UTF-16 LE string.
+			         *
+			         * @return {WordArray} The word array.
+			         *
+			         * @static
+			         *
+			         * @example
+			         *
+			         *     var wordArray = CryptoJS.enc.Utf16LE.parse(utf16Str);
+			         */
+			        parse: function (utf16Str) {
+			            // Shortcut
+			            var utf16StrLength = utf16Str.length;
+
+			            // Convert
+			            var words = [];
+			            for (var i = 0; i < utf16StrLength; i++) {
+			                words[i >>> 1] |= swapEndian(utf16Str.charCodeAt(i) << (16 - (i % 2) * 16));
+			            }
+
+			            return WordArray.create(words, utf16StrLength * 2);
+			        }
+			    };
+
+			    function swapEndian(word) {
+			        return ((word << 8) & 0xff00ff00) | ((word >>> 8) & 0x00ff00ff);
+			    }
+			}());
+
+
+			return CryptoJS.enc.Utf16;
+
+		})); 
+	} (encUtf16$1.__module));
+	return encUtf16$1.__module.exports;
+}
+
+exports.__require = requireEncUtf16;

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

@@ -0,0 +1,157 @@
+import { __module as encUtf16$1 } from '../../../../../_virtual/enc-utf16.mjs';
+import { __require as requireCore } from './core.mjs';
+
+var encUtf16 = encUtf16$1.exports;
+
+var hasRequiredEncUtf16;
+
+function requireEncUtf16 () {
+	if (hasRequiredEncUtf16) return encUtf16$1.exports;
+	hasRequiredEncUtf16 = 1;
+	(function (module, exports) {
+(function (root, factory) {
+			{
+				// CommonJS
+				module.exports = factory(requireCore());
+			}
+		}(encUtf16, function (CryptoJS) {
+
+			(function () {
+			    // Shortcuts
+			    var C = CryptoJS;
+			    var C_lib = C.lib;
+			    var WordArray = C_lib.WordArray;
+			    var C_enc = C.enc;
+
+			    /**
+			     * UTF-16 BE encoding strategy.
+			     */
+			    C_enc.Utf16 = C_enc.Utf16BE = {
+			        /**
+			         * Converts a word array to a UTF-16 BE string.
+			         *
+			         * @param {WordArray} wordArray The word array.
+			         *
+			         * @return {string} The UTF-16 BE string.
+			         *
+			         * @static
+			         *
+			         * @example
+			         *
+			         *     var utf16String = CryptoJS.enc.Utf16.stringify(wordArray);
+			         */
+			        stringify: function (wordArray) {
+			            // Shortcuts
+			            var words = wordArray.words;
+			            var sigBytes = wordArray.sigBytes;
+
+			            // Convert
+			            var utf16Chars = [];
+			            for (var i = 0; i < sigBytes; i += 2) {
+			                var codePoint = (words[i >>> 2] >>> (16 - (i % 4) * 8)) & 0xffff;
+			                utf16Chars.push(String.fromCharCode(codePoint));
+			            }
+
+			            return utf16Chars.join('');
+			        },
+
+			        /**
+			         * Converts a UTF-16 BE string to a word array.
+			         *
+			         * @param {string} utf16Str The UTF-16 BE string.
+			         *
+			         * @return {WordArray} The word array.
+			         *
+			         * @static
+			         *
+			         * @example
+			         *
+			         *     var wordArray = CryptoJS.enc.Utf16.parse(utf16String);
+			         */
+			        parse: function (utf16Str) {
+			            // Shortcut
+			            var utf16StrLength = utf16Str.length;
+
+			            // Convert
+			            var words = [];
+			            for (var i = 0; i < utf16StrLength; i++) {
+			                words[i >>> 1] |= utf16Str.charCodeAt(i) << (16 - (i % 2) * 16);
+			            }
+
+			            return WordArray.create(words, utf16StrLength * 2);
+			        }
+			    };
+
+			    /**
+			     * UTF-16 LE encoding strategy.
+			     */
+			    C_enc.Utf16LE = {
+			        /**
+			         * Converts a word array to a UTF-16 LE string.
+			         *
+			         * @param {WordArray} wordArray The word array.
+			         *
+			         * @return {string} The UTF-16 LE string.
+			         *
+			         * @static
+			         *
+			         * @example
+			         *
+			         *     var utf16Str = CryptoJS.enc.Utf16LE.stringify(wordArray);
+			         */
+			        stringify: function (wordArray) {
+			            // Shortcuts
+			            var words = wordArray.words;
+			            var sigBytes = wordArray.sigBytes;
+
+			            // Convert
+			            var utf16Chars = [];
+			            for (var i = 0; i < sigBytes; i += 2) {
+			                var codePoint = swapEndian((words[i >>> 2] >>> (16 - (i % 4) * 8)) & 0xffff);
+			                utf16Chars.push(String.fromCharCode(codePoint));
+			            }
+
+			            return utf16Chars.join('');
+			        },
+
+			        /**
+			         * Converts a UTF-16 LE string to a word array.
+			         *
+			         * @param {string} utf16Str The UTF-16 LE string.
+			         *
+			         * @return {WordArray} The word array.
+			         *
+			         * @static
+			         *
+			         * @example
+			         *
+			         *     var wordArray = CryptoJS.enc.Utf16LE.parse(utf16Str);
+			         */
+			        parse: function (utf16Str) {
+			            // Shortcut
+			            var utf16StrLength = utf16Str.length;
+
+			            // Convert
+			            var words = [];
+			            for (var i = 0; i < utf16StrLength; i++) {
+			                words[i >>> 1] |= swapEndian(utf16Str.charCodeAt(i) << (16 - (i % 2) * 16));
+			            }
+
+			            return WordArray.create(words, utf16StrLength * 2);
+			        }
+			    };
+
+			    function swapEndian(word) {
+			        return ((word << 8) & 0xff00ff00) | ((word >>> 8) & 0x00ff00ff);
+			    }
+			}());
+
+
+			return CryptoJS.enc.Utf16;
+
+		})); 
+	} (encUtf16$1));
+	return encUtf16$1.exports;
+}
+
+export { requireEncUtf16 as __require };

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

@@ -0,0 +1,146 @@
+'use strict';
+
+var evpkdf$1 = require('../../../../../_virtual/evpkdf.js');
+var core = require('./core.js');
+var sha1 = require('./sha1.js');
+var hmac = require('./hmac.js');
+
+var evpkdf = evpkdf$1.__module.exports;
+
+var hasRequiredEvpkdf;
+
+function requireEvpkdf () {
+	if (hasRequiredEvpkdf) return evpkdf$1.__module.exports;
+	hasRequiredEvpkdf = 1;
+	(function (module, exports) {
+(function (root, factory, undef) {
+			{
+				// CommonJS
+				module.exports = factory(core.__require(), sha1.__require(), hmac.__require());
+			}
+		}(evpkdf, 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 MD5 = C_algo.MD5;
+
+			    /**
+			     * This key derivation function is meant to conform with EVP_BytesToKey.
+			     * www.openssl.org/docs/crypto/EVP_BytesToKey.html
+			     */
+			    var EvpKDF = C_algo.EvpKDF = Base.extend({
+			        /**
+			         * Configuration options.
+			         *
+			         * @property {number} keySize The key size in words to generate. Default: 4 (128 bits)
+			         * @property {Hasher} hasher The hash algorithm to use. Default: MD5
+			         * @property {number} iterations The number of iterations to perform. Default: 1
+			         */
+			        cfg: Base.extend({
+			            keySize: 128/32,
+			            hasher: MD5,
+			            iterations: 1
+			        }),
+
+			        /**
+			         * Initializes a newly created key derivation function.
+			         *
+			         * @param {Object} cfg (Optional) The configuration options to use for the derivation.
+			         *
+			         * @example
+			         *
+			         *     var kdf = CryptoJS.algo.EvpKDF.create();
+			         *     var kdf = CryptoJS.algo.EvpKDF.create({ keySize: 8 });
+			         *     var kdf = CryptoJS.algo.EvpKDF.create({ keySize: 8, iterations: 1000 });
+			         */
+			        init: function (cfg) {
+			            this.cfg = this.cfg.extend(cfg);
+			        },
+
+			        /**
+			         * Derives a key from a password.
+			         *
+			         * @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) {
+			            var block;
+
+			            // Shortcut
+			            var cfg = this.cfg;
+
+			            // Init hasher
+			            var hasher = cfg.hasher.create();
+
+			            // Initial values
+			            var derivedKey = WordArray.create();
+
+			            // Shortcuts
+			            var derivedKeyWords = derivedKey.words;
+			            var keySize = cfg.keySize;
+			            var iterations = cfg.iterations;
+
+			            // Generate key
+			            while (derivedKeyWords.length < keySize) {
+			                if (block) {
+			                    hasher.update(block);
+			                }
+			                block = hasher.update(password).finalize(salt);
+			                hasher.reset();
+
+			                // Iterations
+			                for (var i = 1; i < iterations; i++) {
+			                    block = hasher.finalize(block);
+			                    hasher.reset();
+			                }
+
+			                derivedKey.concat(block);
+			            }
+			            derivedKey.sigBytes = keySize * 4;
+
+			            return derivedKey;
+			        }
+			    });
+
+			    /**
+			     * Derives a key from a password.
+			     *
+			     * @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.EvpKDF(password, salt);
+			     *     var key = CryptoJS.EvpKDF(password, salt, { keySize: 8 });
+			     *     var key = CryptoJS.EvpKDF(password, salt, { keySize: 8, iterations: 1000 });
+			     */
+			    C.EvpKDF = function (password, salt, cfg) {
+			        return EvpKDF.create(cfg).compute(password, salt);
+			    };
+			}());
+
+
+			return CryptoJS.EvpKDF;
+
+		})); 
+	} (evpkdf$1.__module));
+	return evpkdf$1.__module.exports;
+}
+
+exports.__require = requireEvpkdf;

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

@@ -0,0 +1,144 @@
+import { __module as evpkdf$1 } from '../../../../../_virtual/evpkdf.mjs';
+import { __require as requireCore } from './core.mjs';
+import { __require as requireSha1 } from './sha1.mjs';
+import { __require as requireHmac } from './hmac.mjs';
+
+var evpkdf = evpkdf$1.exports;
+
+var hasRequiredEvpkdf;
+
+function requireEvpkdf () {
+	if (hasRequiredEvpkdf) return evpkdf$1.exports;
+	hasRequiredEvpkdf = 1;
+	(function (module, exports) {
+(function (root, factory, undef) {
+			{
+				// CommonJS
+				module.exports = factory(requireCore(), requireSha1(), requireHmac());
+			}
+		}(evpkdf, 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 MD5 = C_algo.MD5;
+
+			    /**
+			     * This key derivation function is meant to conform with EVP_BytesToKey.
+			     * www.openssl.org/docs/crypto/EVP_BytesToKey.html
+			     */
+			    var EvpKDF = C_algo.EvpKDF = Base.extend({
+			        /**
+			         * Configuration options.
+			         *
+			         * @property {number} keySize The key size in words to generate. Default: 4 (128 bits)
+			         * @property {Hasher} hasher The hash algorithm to use. Default: MD5
+			         * @property {number} iterations The number of iterations to perform. Default: 1
+			         */
+			        cfg: Base.extend({
+			            keySize: 128/32,
+			            hasher: MD5,
+			            iterations: 1
+			        }),
+
+			        /**
+			         * Initializes a newly created key derivation function.
+			         *
+			         * @param {Object} cfg (Optional) The configuration options to use for the derivation.
+			         *
+			         * @example
+			         *
+			         *     var kdf = CryptoJS.algo.EvpKDF.create();
+			         *     var kdf = CryptoJS.algo.EvpKDF.create({ keySize: 8 });
+			         *     var kdf = CryptoJS.algo.EvpKDF.create({ keySize: 8, iterations: 1000 });
+			         */
+			        init: function (cfg) {
+			            this.cfg = this.cfg.extend(cfg);
+			        },
+
+			        /**
+			         * Derives a key from a password.
+			         *
+			         * @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) {
+			            var block;
+
+			            // Shortcut
+			            var cfg = this.cfg;
+
+			            // Init hasher
+			            var hasher = cfg.hasher.create();
+
+			            // Initial values
+			            var derivedKey = WordArray.create();
+
+			            // Shortcuts
+			            var derivedKeyWords = derivedKey.words;
+			            var keySize = cfg.keySize;
+			            var iterations = cfg.iterations;
+
+			            // Generate key
+			            while (derivedKeyWords.length < keySize) {
+			                if (block) {
+			                    hasher.update(block);
+			                }
+			                block = hasher.update(password).finalize(salt);
+			                hasher.reset();
+
+			                // Iterations
+			                for (var i = 1; i < iterations; i++) {
+			                    block = hasher.finalize(block);
+			                    hasher.reset();
+			                }
+
+			                derivedKey.concat(block);
+			            }
+			            derivedKey.sigBytes = keySize * 4;
+
+			            return derivedKey;
+			        }
+			    });
+
+			    /**
+			     * Derives a key from a password.
+			     *
+			     * @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.EvpKDF(password, salt);
+			     *     var key = CryptoJS.EvpKDF(password, salt, { keySize: 8 });
+			     *     var key = CryptoJS.EvpKDF(password, salt, { keySize: 8, iterations: 1000 });
+			     */
+			    C.EvpKDF = function (password, salt, cfg) {
+			        return EvpKDF.create(cfg).compute(password, salt);
+			    };
+			}());
+
+
+			return CryptoJS.EvpKDF;
+
+		})); 
+	} (evpkdf$1));
+	return evpkdf$1.exports;
+}
+
+export { requireEvpkdf as __require };

package/dist/node_modules/.pnpm/crypto-js@4.2.0/node_modules/crypto-js/format-hex.js

@@ -0,0 +1,77 @@
+'use strict';
+
+var formatHex$1 = require('../../../../../_virtual/format-hex.js');
+var core = require('./core.js');
+var cipherCore = require('./cipher-core.js');
+
+var formatHex = formatHex$1.__module.exports;
+
+var hasRequiredFormatHex;
+
+function requireFormatHex () {
+	if (hasRequiredFormatHex) return formatHex$1.__module.exports;
+	hasRequiredFormatHex = 1;
+	(function (module, exports) {
+(function (root, factory, undef) {
+			{
+				// CommonJS
+				module.exports = factory(core.__require(), cipherCore.__require());
+			}
+		}(formatHex, function (CryptoJS) {
+
+			(function (undefined$1) {
+			    // Shortcuts
+			    var C = CryptoJS;
+			    var C_lib = C.lib;
+			    var CipherParams = C_lib.CipherParams;
+			    var C_enc = C.enc;
+			    var Hex = C_enc.Hex;
+			    var C_format = C.format;
+
+			    C_format.Hex = {
+			        /**
+			         * Converts the ciphertext of a cipher params object to a hexadecimally encoded string.
+			         *
+			         * @param {CipherParams} cipherParams The cipher params object.
+			         *
+			         * @return {string} The hexadecimally encoded string.
+			         *
+			         * @static
+			         *
+			         * @example
+			         *
+			         *     var hexString = CryptoJS.format.Hex.stringify(cipherParams);
+			         */
+			        stringify: function (cipherParams) {
+			            return cipherParams.ciphertext.toString(Hex);
+			        },
+
+			        /**
+			         * Converts a hexadecimally encoded ciphertext string to a cipher params object.
+			         *
+			         * @param {string} input The hexadecimally encoded string.
+			         *
+			         * @return {CipherParams} The cipher params object.
+			         *
+			         * @static
+			         *
+			         * @example
+			         *
+			         *     var cipherParams = CryptoJS.format.Hex.parse(hexString);
+			         */
+			        parse: function (input) {
+			            var ciphertext = Hex.parse(input);
+			            return CipherParams.create({ ciphertext: ciphertext });
+			        }
+			    };
+			}());
+
+
+			return CryptoJS.format.Hex;
+
+		})); 
+	} (formatHex$1.__module));
+	return formatHex$1.__module.exports;
+}
+
+exports.__require = requireFormatHex;