@fast-china/utils 2.1.6 → 2.1.8

package/dist/crypto/index.mjs

@@ -1,19 +1,2226 @@
 import { createDecodedText, encodeUtf8, getTextDecoder } from "../internal/text.mjs";
 import { runtimeGlobals } from "../internal/runtime.mjs";
 import { decodeBase64Bytes, decodeBase64UrlBytes, encodeBase64Bytes, encodeBase64UrlBytes } from "../base64/index.mjs";
-import AES from "crypto-js/aes.js";
-import CryptoCore from "crypto-js/core.js";
-import Hex from "crypto-js/enc-hex.js";
-import Utf8 from "crypto-js/enc-utf8.js";
-import MD5 from "crypto-js/md5.js";
-import ECB from "crypto-js/mode-ecb.js";
-import "crypto-js/pad-ansix923.js";
-import Iso10126 from "crypto-js/pad-iso10126.js";
-import NoPadding from "crypto-js/pad-nopadding.js";
-import Pkcs7 from "crypto-js/pad-pkcs7.js";
-import ZeroPadding from "crypto-js/pad-zeropadding.js";
-import SHA1 from "crypto-js/sha1.js";
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJSMin = (cb, mod) => () => (mod || (cb((mod = { exports: {} }).exports, mod), cb = null), mod.exports);
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule || !__hasOwnProp.call(mod, "default") ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, { get: (a, b) => (typeof require !== "undefined" ? require : a)[b] }) : x)(function(x) {
+	if (typeof require !== "undefined") return require.apply(this, arguments);
+	throw Error("Calling `require` for \"" + x + "\" in an environment that doesn't expose the `require` function. See https://rolldown.rs/in-depth/bundling-cjs#require-external-modules for more details.");
+});
+//#endregion
+//#region node_modules/.pnpm/crypto-js@4.2.0/node_modules/crypto-js/core.js
+var require_core = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	(function(root, factory) {
+		if (typeof exports === "object") module.exports = exports = factory();
+		else if (typeof define === "function" && define.amd) define([], factory);
+		else root.CryptoJS = factory();
+	})(exports, function() {
+		/**
+		* CryptoJS core components.
+		*/
+		var CryptoJS = CryptoJS || function(Math, undefined) {
+			var crypto;
+			if (typeof window !== "undefined" && window.crypto) crypto = window.crypto;
+			if (typeof self !== "undefined" && self.crypto) crypto = self.crypto;
+			if (typeof globalThis !== "undefined" && globalThis.crypto) crypto = globalThis.crypto;
+			if (!crypto && typeof window !== "undefined" && window.msCrypto) crypto = window.msCrypto;
+			if (!crypto && typeof global !== "undefined" && global.crypto) crypto = global.crypto;
+			if (!crypto && typeof __require === "function") try {
+				crypto = __require("crypto");
+			} catch (err) {}
+			var cryptoSecureRandomInt = function() {
+				if (crypto) {
+					if (typeof crypto.getRandomValues === "function") try {
+						return crypto.getRandomValues(/* @__PURE__ */ new Uint32Array(1))[0];
+					} catch (err) {}
+					if (typeof crypto.randomBytes === "function") try {
+						return crypto.randomBytes(4).readInt32LE();
+					} catch (err) {}
+				}
+				throw new Error("Native crypto module could not be used to get secure random number.");
+			};
+			var create = Object.create || function() {
+				function F() {}
+				return function(obj) {
+					var subtype;
+					F.prototype = obj;
+					subtype = new F();
+					F.prototype = null;
+					return subtype;
+				};
+			}();
+			/**
+			* CryptoJS namespace.
+			*/
+			var C = {};
+			/**
+			* Library namespace.
+			*/
+			var C_lib = C.lib = {};
+			/**
+			* Base object for prototypal inheritance.
+			*/
+			var Base = C_lib.Base = function() {
+				return {
+					/**
+					* Creates a new object that inherits from this object.
+					*
+					* @param {Object} overrides Properties to copy into the new object.
+					*
+					* @return {Object} The new object.
+					*
+					* @static
+					*
+					* @example
+					*
+					*     var MyType = CryptoJS.lib.Base.extend({
+					*         field: 'value',
+					*
+					*         method: function () {
+					*         }
+					*     });
+					*/
+					extend: function(overrides) {
+						var subtype = create(this);
+						if (overrides) subtype.mixIn(overrides);
+						if (!subtype.hasOwnProperty("init") || this.init === subtype.init) subtype.init = function() {
+							subtype.$super.init.apply(this, arguments);
+						};
+						subtype.init.prototype = subtype;
+						subtype.$super = this;
+						return subtype;
+					},
+					/**
+					* Extends this object and runs the init method.
+					* Arguments to create() will be passed to init().
+					*
+					* @return {Object} The new object.
+					*
+					* @static
+					*
+					* @example
+					*
+					*     var instance = MyType.create();
+					*/
+					create: function() {
+						var instance = this.extend();
+						instance.init.apply(instance, arguments);
+						return instance;
+					},
+					/**
+					* Initializes a newly created object.
+					* Override this method to add some logic when your objects are created.
+					*
+					* @example
+					*
+					*     var MyType = CryptoJS.lib.Base.extend({
+					*         init: function () {
+					*             // ...
+					*         }
+					*     });
+					*/
+					init: function() {},
+					/**
+					* Copies properties into this object.
+					*
+					* @param {Object} properties The properties to mix in.
+					*
+					* @example
+					*
+					*     MyType.mixIn({
+					*         field: 'value'
+					*     });
+					*/
+					mixIn: function(properties) {
+						for (var propertyName in properties) if (properties.hasOwnProperty(propertyName)) this[propertyName] = properties[propertyName];
+						if (properties.hasOwnProperty("toString")) this.toString = properties.toString;
+					},
+					/**
+					* Creates a copy of this object.
+					*
+					* @return {Object} The clone.
+					*
+					* @example
+					*
+					*     var clone = instance.clone();
+					*/
+					clone: function() {
+						return this.init.prototype.extend(this);
+					}
+				};
+			}();
+			/**
+			* An array of 32-bit words.
+			*
+			* @property {Array} words The array of 32-bit words.
+			* @property {number} sigBytes The number of significant bytes in this word array.
+			*/
+			var WordArray = C_lib.WordArray = Base.extend({
+				/**
+				* Initializes a newly created word array.
+				*
+				* @param {Array} words (Optional) An array of 32-bit words.
+				* @param {number} sigBytes (Optional) The number of significant bytes in the words.
+				*
+				* @example
+				*
+				*     var wordArray = CryptoJS.lib.WordArray.create();
+				*     var wordArray = CryptoJS.lib.WordArray.create([0x00010203, 0x04050607]);
+				*     var wordArray = CryptoJS.lib.WordArray.create([0x00010203, 0x04050607], 6);
+				*/
+				init: function(words, sigBytes) {
+					words = this.words = words || [];
+					if (sigBytes != undefined) this.sigBytes = sigBytes;
+					else this.sigBytes = words.length * 4;
+				},
+				/**
+				* Converts this word array to a string.
+				*
+				* @param {Encoder} encoder (Optional) The encoding strategy to use. Default: CryptoJS.enc.Hex
+				*
+				* @return {string} The stringified word array.
+				*
+				* @example
+				*
+				*     var string = wordArray + '';
+				*     var string = wordArray.toString();
+				*     var string = wordArray.toString(CryptoJS.enc.Utf8);
+				*/
+				toString: function(encoder) {
+					return (encoder || Hex).stringify(this);
+				},
+				/**
+				* Concatenates a word array to this word array.
+				*
+				* @param {WordArray} wordArray The word array to append.
+				*
+				* @return {WordArray} This word array.
+				*
+				* @example
+				*
+				*     wordArray1.concat(wordArray2);
+				*/
+				concat: function(wordArray) {
+					var thisWords = this.words;
+					var thatWords = wordArray.words;
+					var thisSigBytes = this.sigBytes;
+					var thatSigBytes = wordArray.sigBytes;
+					this.clamp();
+					if (thisSigBytes % 4) for (var i = 0; i < thatSigBytes; i++) {
+						var thatByte = thatWords[i >>> 2] >>> 24 - i % 4 * 8 & 255;
+						thisWords[thisSigBytes + i >>> 2] |= thatByte << 24 - (thisSigBytes + i) % 4 * 8;
+					}
+					else for (var j = 0; j < thatSigBytes; j += 4) thisWords[thisSigBytes + j >>> 2] = thatWords[j >>> 2];
+					this.sigBytes += thatSigBytes;
+					return this;
+				},
+				/**
+				* Removes insignificant bits.
+				*
+				* @example
+				*
+				*     wordArray.clamp();
+				*/
+				clamp: function() {
+					var words = this.words;
+					var sigBytes = this.sigBytes;
+					words[sigBytes >>> 2] &= 4294967295 << 32 - sigBytes % 4 * 8;
+					words.length = Math.ceil(sigBytes / 4);
+				},
+				/**
+				* Creates a copy of this word array.
+				*
+				* @return {WordArray} The clone.
+				*
+				* @example
+				*
+				*     var clone = wordArray.clone();
+				*/
+				clone: function() {
+					var clone = Base.clone.call(this);
+					clone.words = this.words.slice(0);
+					return clone;
+				},
+				/**
+				* Creates a word array filled with random bytes.
+				*
+				* @param {number} nBytes The number of random bytes to generate.
+				*
+				* @return {WordArray} The random word array.
+				*
+				* @static
+				*
+				* @example
+				*
+				*     var wordArray = CryptoJS.lib.WordArray.random(16);
+				*/
+				random: function(nBytes) {
+					var words = [];
+					for (var i = 0; i < nBytes; i += 4) words.push(cryptoSecureRandomInt());
+					return new WordArray.init(words, nBytes);
+				}
+			});
+			/**
+			* Encoder namespace.
+			*/
+			var C_enc = C.enc = {};
+			/**
+			* Hex encoding strategy.
+			*/
+			var Hex = C_enc.Hex = {
+				/**
+				* Converts a word array to a hex string.
+				*
+				* @param {WordArray} wordArray The word array.
+				*
+				* @return {string} The hex string.
+				*
+				* @static
+				*
+				* @example
+				*
+				*     var hexString = CryptoJS.enc.Hex.stringify(wordArray);
+				*/
+				stringify: function(wordArray) {
+					var words = wordArray.words;
+					var sigBytes = wordArray.sigBytes;
+					var hexChars = [];
+					for (var i = 0; i < sigBytes; i++) {
+						var bite = words[i >>> 2] >>> 24 - i % 4 * 8 & 255;
+						hexChars.push((bite >>> 4).toString(16));
+						hexChars.push((bite & 15).toString(16));
+					}
+					return hexChars.join("");
+				},
+				/**
+				* Converts a hex string to a word array.
+				*
+				* @param {string} hexStr The hex string.
+				*
+				* @return {WordArray} The word array.
+				*
+				* @static
+				*
+				* @example
+				*
+				*     var wordArray = CryptoJS.enc.Hex.parse(hexString);
+				*/
+				parse: function(hexStr) {
+					var hexStrLength = hexStr.length;
+					var words = [];
+					for (var i = 0; i < hexStrLength; i += 2) words[i >>> 3] |= parseInt(hexStr.substr(i, 2), 16) << 24 - i % 8 * 4;
+					return new WordArray.init(words, hexStrLength / 2);
+				}
+			};
+			/**
+			* Latin1 encoding strategy.
+			*/
+			var Latin1 = C_enc.Latin1 = {
+				/**
+				* Converts a word array to a Latin1 string.
+				*
+				* @param {WordArray} wordArray The word array.
+				*
+				* @return {string} The Latin1 string.
+				*
+				* @static
+				*
+				* @example
+				*
+				*     var latin1String = CryptoJS.enc.Latin1.stringify(wordArray);
+				*/
+				stringify: function(wordArray) {
+					var words = wordArray.words;
+					var sigBytes = wordArray.sigBytes;
+					var latin1Chars = [];
+					for (var i = 0; i < sigBytes; i++) {
+						var bite = words[i >>> 2] >>> 24 - i % 4 * 8 & 255;
+						latin1Chars.push(String.fromCharCode(bite));
+					}
+					return latin1Chars.join("");
+				},
+				/**
+				* Converts a Latin1 string to a word array.
+				*
+				* @param {string} latin1Str The Latin1 string.
+				*
+				* @return {WordArray} The word array.
+				*
+				* @static
+				*
+				* @example
+				*
+				*     var wordArray = CryptoJS.enc.Latin1.parse(latin1String);
+				*/
+				parse: function(latin1Str) {
+					var latin1StrLength = latin1Str.length;
+					var words = [];
+					for (var i = 0; i < latin1StrLength; i++) words[i >>> 2] |= (latin1Str.charCodeAt(i) & 255) << 24 - i % 4 * 8;
+					return new WordArray.init(words, latin1StrLength);
+				}
+			};
+			/**
+			* UTF-8 encoding strategy.
+			*/
+			var Utf8 = C_enc.Utf8 = {
+				/**
+				* Converts a word array to a UTF-8 string.
+				*
+				* @param {WordArray} wordArray The word array.
+				*
+				* @return {string} The UTF-8 string.
+				*
+				* @static
+				*
+				* @example
+				*
+				*     var utf8String = CryptoJS.enc.Utf8.stringify(wordArray);
+				*/
+				stringify: function(wordArray) {
+					try {
+						return decodeURIComponent(escape(Latin1.stringify(wordArray)));
+					} catch (e) {
+						throw new Error("Malformed UTF-8 data");
+					}
+				},
+				/**
+				* Converts a UTF-8 string to a word array.
+				*
+				* @param {string} utf8Str The UTF-8 string.
+				*
+				* @return {WordArray} The word array.
+				*
+				* @static
+				*
+				* @example
+				*
+				*     var wordArray = CryptoJS.enc.Utf8.parse(utf8String);
+				*/
+				parse: function(utf8Str) {
+					return Latin1.parse(unescape(encodeURIComponent(utf8Str)));
+				}
+			};
+			/**
+			* Abstract buffered block algorithm template.
+			*
+			* The property blockSize must be implemented in a concrete subtype.
+			*
+			* @property {number} _minBufferSize The number of blocks that should be kept unprocessed in the buffer. Default: 0
+			*/
+			var BufferedBlockAlgorithm = C_lib.BufferedBlockAlgorithm = Base.extend({
+				/**
+				* Resets this block algorithm's data buffer to its initial state.
+				*
+				* @example
+				*
+				*     bufferedBlockAlgorithm.reset();
+				*/
+				reset: function() {
+					this._data = new WordArray.init();
+					this._nDataBytes = 0;
+				},
+				/**
+				* Adds new data to this block algorithm's buffer.
+				*
+				* @param {WordArray|string} data The data to append. Strings are converted to a WordArray using UTF-8.
+				*
+				* @example
+				*
+				*     bufferedBlockAlgorithm._append('data');
+				*     bufferedBlockAlgorithm._append(wordArray);
+				*/
+				_append: function(data) {
+					if (typeof data == "string") data = Utf8.parse(data);
+					this._data.concat(data);
+					this._nDataBytes += data.sigBytes;
+				},
+				/**
+				* Processes available data blocks.
+				*
+				* This method invokes _doProcessBlock(offset), which must be implemented by a concrete subtype.
+				*
+				* @param {boolean} doFlush Whether all blocks and partial blocks should be processed.
+				*
+				* @return {WordArray} The processed data.
+				*
+				* @example
+				*
+				*     var processedData = bufferedBlockAlgorithm._process();
+				*     var processedData = bufferedBlockAlgorithm._process(!!'flush');
+				*/
+				_process: function(doFlush) {
+					var processedWords;
+					var data = this._data;
+					var dataWords = data.words;
+					var dataSigBytes = data.sigBytes;
+					var blockSize = this.blockSize;
+					var nBlocksReady = dataSigBytes / (blockSize * 4);
+					if (doFlush) nBlocksReady = Math.ceil(nBlocksReady);
+					else nBlocksReady = Math.max((nBlocksReady | 0) - this._minBufferSize, 0);
+					var nWordsReady = nBlocksReady * blockSize;
+					var nBytesReady = Math.min(nWordsReady * 4, dataSigBytes);
+					if (nWordsReady) {
+						for (var offset = 0; offset < nWordsReady; offset += blockSize) this._doProcessBlock(dataWords, offset);
+						processedWords = dataWords.splice(0, nWordsReady);
+						data.sigBytes -= nBytesReady;
+					}
+					return new WordArray.init(processedWords, nBytesReady);
+				},
+				/**
+				* Creates a copy of this object.
+				*
+				* @return {Object} The clone.
+				*
+				* @example
+				*
+				*     var clone = bufferedBlockAlgorithm.clone();
+				*/
+				clone: function() {
+					var clone = Base.clone.call(this);
+					clone._data = this._data.clone();
+					return clone;
+				},
+				_minBufferSize: 0
+			});
+			C_lib.Hasher = BufferedBlockAlgorithm.extend({
+				/**
+				* Configuration options.
+				*/
+				cfg: Base.extend(),
+				/**
+				* Initializes a newly created hasher.
+				*
+				* @param {Object} cfg (Optional) The configuration options to use for this hash computation.
+				*
+				* @example
+				*
+				*     var hasher = CryptoJS.algo.SHA256.create();
+				*/
+				init: function(cfg) {
+					this.cfg = this.cfg.extend(cfg);
+					this.reset();
+				},
+				/**
+				* Resets this hasher to its initial state.
+				*
+				* @example
+				*
+				*     hasher.reset();
+				*/
+				reset: function() {
+					BufferedBlockAlgorithm.reset.call(this);
+					this._doReset();
+				},
+				/**
+				* Updates this hasher with a message.
+				*
+				* @param {WordArray|string} messageUpdate The message to append.
+				*
+				* @return {Hasher} This hasher.
+				*
+				* @example
+				*
+				*     hasher.update('message');
+				*     hasher.update(wordArray);
+				*/
+				update: function(messageUpdate) {
+					this._append(messageUpdate);
+					this._process();
+					return this;
+				},
+				/**
+				* Finalizes the hash computation.
+				* Note that the finalize operation is effectively a destructive, read-once operation.
+				*
+				* @param {WordArray|string} messageUpdate (Optional) A final message update.
+				*
+				* @return {WordArray} The hash.
+				*
+				* @example
+				*
+				*     var hash = hasher.finalize();
+				*     var hash = hasher.finalize('message');
+				*     var hash = hasher.finalize(wordArray);
+				*/
+				finalize: function(messageUpdate) {
+					if (messageUpdate) this._append(messageUpdate);
+					return this._doFinalize();
+				},
+				blockSize: 16,
+				/**
+				* Creates a shortcut function to a hasher's object interface.
+				*
+				* @param {Hasher} hasher The hasher to create a helper for.
+				*
+				* @return {Function} The shortcut function.
+				*
+				* @static
+				*
+				* @example
+				*
+				*     var SHA256 = CryptoJS.lib.Hasher._createHelper(CryptoJS.algo.SHA256);
+				*/
+				_createHelper: function(hasher) {
+					return function(message, cfg) {
+						return new hasher.init(cfg).finalize(message);
+					};
+				},
+				/**
+				* Creates a shortcut function to the HMAC's object interface.
+				*
+				* @param {Hasher} hasher The hasher to use in this HMAC helper.
+				*
+				* @return {Function} The shortcut function.
+				*
+				* @static
+				*
+				* @example
+				*
+				*     var HmacSHA256 = CryptoJS.lib.Hasher._createHmacHelper(CryptoJS.algo.SHA256);
+				*/
+				_createHmacHelper: function(hasher) {
+					return function(message, key) {
+						return new C_algo.HMAC.init(hasher, key).finalize(message);
+					};
+				}
+			});
+			/**
+			* Algorithm namespace.
+			*/
+			var C_algo = C.algo = {};
+			return C;
+		}(Math);
+		return CryptoJS;
+	});
+}));
+//#endregion
+//#region node_modules/.pnpm/crypto-js@4.2.0/node_modules/crypto-js/enc-base64.js
+var require_enc_base64 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	(function(root, factory) {
+		if (typeof exports === "object") module.exports = exports = factory(require_core());
+		else if (typeof define === "function" && define.amd) define(["./core"], factory);
+		else factory(root.CryptoJS);
+	})(exports, function(CryptoJS) {
+		(function() {
+			var C = CryptoJS;
+			var WordArray = C.lib.WordArray;
+			var C_enc = C.enc;
+			C_enc.Base64 = {
+				/**
+				* Converts a word array to a Base64 string.
+				*
+				* @param {WordArray} wordArray The word array.
+				*
+				* @return {string} The Base64 string.
+				*
+				* @static
+				*
+				* @example
+				*
+				*     var base64String = CryptoJS.enc.Base64.stringify(wordArray);
+				*/
+				stringify: function(wordArray) {
+					var words = wordArray.words;
+					var sigBytes = wordArray.sigBytes;
+					var map = this._map;
+					wordArray.clamp();
+					var base64Chars = [];
+					for (var i = 0; i < sigBytes; i += 3) {
+						var byte1 = words[i >>> 2] >>> 24 - i % 4 * 8 & 255;
+						var byte2 = words[i + 1 >>> 2] >>> 24 - (i + 1) % 4 * 8 & 255;
+						var byte3 = words[i + 2 >>> 2] >>> 24 - (i + 2) % 4 * 8 & 255;
+						var triplet = byte1 << 16 | byte2 << 8 | byte3;
+						for (var j = 0; j < 4 && i + j * .75 < sigBytes; j++) base64Chars.push(map.charAt(triplet >>> 6 * (3 - j) & 63));
+					}
+					var paddingChar = map.charAt(64);
+					if (paddingChar) while (base64Chars.length % 4) base64Chars.push(paddingChar);
+					return base64Chars.join("");
+				},
+				/**
+				* Converts a Base64 string to a word array.
+				*
+				* @param {string} base64Str The Base64 string.
+				*
+				* @return {WordArray} The word array.
+				*
+				* @static
+				*
+				* @example
+				*
+				*     var wordArray = CryptoJS.enc.Base64.parse(base64String);
+				*/
+				parse: function(base64Str) {
+					var base64StrLength = base64Str.length;
+					var map = this._map;
+					var reverseMap = this._reverseMap;
+					if (!reverseMap) {
+						reverseMap = this._reverseMap = [];
+						for (var j = 0; j < map.length; j++) reverseMap[map.charCodeAt(j)] = j;
+					}
+					var paddingChar = map.charAt(64);
+					if (paddingChar) {
+						var paddingIndex = base64Str.indexOf(paddingChar);
+						if (paddingIndex !== -1) base64StrLength = paddingIndex;
+					}
+					return parseLoop(base64Str, base64StrLength, reverseMap);
+				},
+				_map: "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/="
+			};
+			function parseLoop(base64Str, base64StrLength, reverseMap) {
+				var words = [];
+				var nBytes = 0;
+				for (var i = 0; i < base64StrLength; i++) if (i % 4) {
+					var bitsCombined = reverseMap[base64Str.charCodeAt(i - 1)] << i % 4 * 2 | reverseMap[base64Str.charCodeAt(i)] >>> 6 - i % 4 * 2;
+					words[nBytes >>> 2] |= bitsCombined << 24 - nBytes % 4 * 8;
+					nBytes++;
+				}
+				return WordArray.create(words, nBytes);
+			}
+		})();
+		return CryptoJS.enc.Base64;
+	});
+}));
+//#endregion
+//#region node_modules/.pnpm/crypto-js@4.2.0/node_modules/crypto-js/md5.js
+var require_md5 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	(function(root, factory) {
+		if (typeof exports === "object") module.exports = exports = factory(require_core());
+		else if (typeof define === "function" && define.amd) define(["./core"], factory);
+		else factory(root.CryptoJS);
+	})(exports, function(CryptoJS) {
+		(function(Math) {
+			var C = CryptoJS;
+			var C_lib = C.lib;
+			var WordArray = C_lib.WordArray;
+			var Hasher = C_lib.Hasher;
+			var C_algo = C.algo;
+			var T = [];
+			(function() {
+				for (var i = 0; i < 64; i++) T[i] = Math.abs(Math.sin(i + 1)) * 4294967296 | 0;
+			})();
+			/**
+			* MD5 hash algorithm.
+			*/
+			var MD5 = C_algo.MD5 = Hasher.extend({
+				_doReset: function() {
+					this._hash = new WordArray.init([
+						1732584193,
+						4023233417,
+						2562383102,
+						271733878
+					]);
+				},
+				_doProcessBlock: function(M, offset) {
+					for (var i = 0; i < 16; i++) {
+						var offset_i = offset + i;
+						var M_offset_i = M[offset_i];
+						M[offset_i] = (M_offset_i << 8 | M_offset_i >>> 24) & 16711935 | (M_offset_i << 24 | M_offset_i >>> 8) & 4278255360;
+					}
+					var H = this._hash.words;
+					var M_offset_0 = M[offset + 0];
+					var M_offset_1 = M[offset + 1];
+					var M_offset_2 = M[offset + 2];
+					var M_offset_3 = M[offset + 3];
+					var M_offset_4 = M[offset + 4];
+					var M_offset_5 = M[offset + 5];
+					var M_offset_6 = M[offset + 6];
+					var M_offset_7 = M[offset + 7];
+					var M_offset_8 = M[offset + 8];
+					var M_offset_9 = M[offset + 9];
+					var M_offset_10 = M[offset + 10];
+					var M_offset_11 = M[offset + 11];
+					var M_offset_12 = M[offset + 12];
+					var M_offset_13 = M[offset + 13];
+					var M_offset_14 = M[offset + 14];
+					var M_offset_15 = M[offset + 15];
+					var a = H[0];
+					var b = H[1];
+					var c = H[2];
+					var d = H[3];
+					a = FF(a, b, c, d, M_offset_0, 7, T[0]);
+					d = FF(d, a, b, c, M_offset_1, 12, T[1]);
+					c = FF(c, d, a, b, M_offset_2, 17, T[2]);
+					b = FF(b, c, d, a, M_offset_3, 22, T[3]);
+					a = FF(a, b, c, d, M_offset_4, 7, T[4]);
+					d = FF(d, a, b, c, M_offset_5, 12, T[5]);
+					c = FF(c, d, a, b, M_offset_6, 17, T[6]);
+					b = FF(b, c, d, a, M_offset_7, 22, T[7]);
+					a = FF(a, b, c, d, M_offset_8, 7, T[8]);
+					d = FF(d, a, b, c, M_offset_9, 12, T[9]);
+					c = FF(c, d, a, b, M_offset_10, 17, T[10]);
+					b = FF(b, c, d, a, M_offset_11, 22, T[11]);
+					a = FF(a, b, c, d, M_offset_12, 7, T[12]);
+					d = FF(d, a, b, c, M_offset_13, 12, T[13]);
+					c = FF(c, d, a, b, M_offset_14, 17, T[14]);
+					b = FF(b, c, d, a, M_offset_15, 22, T[15]);
+					a = GG(a, b, c, d, M_offset_1, 5, T[16]);
+					d = GG(d, a, b, c, M_offset_6, 9, T[17]);
+					c = GG(c, d, a, b, M_offset_11, 14, T[18]);
+					b = GG(b, c, d, a, M_offset_0, 20, T[19]);
+					a = GG(a, b, c, d, M_offset_5, 5, T[20]);
+					d = GG(d, a, b, c, M_offset_10, 9, T[21]);
+					c = GG(c, d, a, b, M_offset_15, 14, T[22]);
+					b = GG(b, c, d, a, M_offset_4, 20, T[23]);
+					a = GG(a, b, c, d, M_offset_9, 5, T[24]);
+					d = GG(d, a, b, c, M_offset_14, 9, T[25]);
+					c = GG(c, d, a, b, M_offset_3, 14, T[26]);
+					b = GG(b, c, d, a, M_offset_8, 20, T[27]);
+					a = GG(a, b, c, d, M_offset_13, 5, T[28]);
+					d = GG(d, a, b, c, M_offset_2, 9, T[29]);
+					c = GG(c, d, a, b, M_offset_7, 14, T[30]);
+					b = GG(b, c, d, a, M_offset_12, 20, T[31]);
+					a = HH(a, b, c, d, M_offset_5, 4, T[32]);
+					d = HH(d, a, b, c, M_offset_8, 11, T[33]);
+					c = HH(c, d, a, b, M_offset_11, 16, T[34]);
+					b = HH(b, c, d, a, M_offset_14, 23, T[35]);
+					a = HH(a, b, c, d, M_offset_1, 4, T[36]);
+					d = HH(d, a, b, c, M_offset_4, 11, T[37]);
+					c = HH(c, d, a, b, M_offset_7, 16, T[38]);
+					b = HH(b, c, d, a, M_offset_10, 23, T[39]);
+					a = HH(a, b, c, d, M_offset_13, 4, T[40]);
+					d = HH(d, a, b, c, M_offset_0, 11, T[41]);
+					c = HH(c, d, a, b, M_offset_3, 16, T[42]);
+					b = HH(b, c, d, a, M_offset_6, 23, T[43]);
+					a = HH(a, b, c, d, M_offset_9, 4, T[44]);
+					d = HH(d, a, b, c, M_offset_12, 11, T[45]);
+					c = HH(c, d, a, b, M_offset_15, 16, T[46]);
+					b = HH(b, c, d, a, M_offset_2, 23, T[47]);
+					a = II(a, b, c, d, M_offset_0, 6, T[48]);
+					d = II(d, a, b, c, M_offset_7, 10, T[49]);
+					c = II(c, d, a, b, M_offset_14, 15, T[50]);
+					b = II(b, c, d, a, M_offset_5, 21, T[51]);
+					a = II(a, b, c, d, M_offset_12, 6, T[52]);
+					d = II(d, a, b, c, M_offset_3, 10, T[53]);
+					c = II(c, d, a, b, M_offset_10, 15, T[54]);
+					b = II(b, c, d, a, M_offset_1, 21, T[55]);
+					a = II(a, b, c, d, M_offset_8, 6, T[56]);
+					d = II(d, a, b, c, M_offset_15, 10, T[57]);
+					c = II(c, d, a, b, M_offset_6, 15, T[58]);
+					b = II(b, c, d, a, M_offset_13, 21, T[59]);
+					a = II(a, b, c, d, M_offset_4, 6, T[60]);
+					d = II(d, a, b, c, M_offset_11, 10, T[61]);
+					c = II(c, d, a, b, M_offset_2, 15, T[62]);
+					b = II(b, c, d, a, M_offset_9, 21, T[63]);
+					H[0] = H[0] + a | 0;
+					H[1] = H[1] + b | 0;
+					H[2] = H[2] + c | 0;
+					H[3] = H[3] + d | 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;
+					var nBitsTotalH = Math.floor(nBitsTotal / 4294967296);
+					var nBitsTotalL = nBitsTotal;
+					dataWords[(nBitsLeft + 64 >>> 9 << 4) + 15] = (nBitsTotalH << 8 | nBitsTotalH >>> 24) & 16711935 | (nBitsTotalH << 24 | nBitsTotalH >>> 8) & 4278255360;
+					dataWords[(nBitsLeft + 64 >>> 9 << 4) + 14] = (nBitsTotalL << 8 | nBitsTotalL >>> 24) & 16711935 | (nBitsTotalL << 24 | nBitsTotalL >>> 8) & 4278255360;
+					data.sigBytes = (dataWords.length + 1) * 4;
+					this._process();
+					var hash = this._hash;
+					var H = hash.words;
+					for (var i = 0; i < 4; i++) {
+						var H_i = H[i];
+						H[i] = (H_i << 8 | H_i >>> 24) & 16711935 | (H_i << 24 | H_i >>> 8) & 4278255360;
+					}
+					return hash;
+				},
+				clone: function() {
+					var clone = Hasher.clone.call(this);
+					clone._hash = this._hash.clone();
+					return clone;
+				}
+			});
+			function FF(a, b, c, d, x, s, t) {
+				var n = a + (b & c | ~b & d) + x + t;
+				return (n << s | n >>> 32 - s) + b;
+			}
+			function GG(a, b, c, d, x, s, t) {
+				var n = a + (b & d | c & ~d) + x + t;
+				return (n << s | n >>> 32 - s) + b;
+			}
+			function HH(a, b, c, d, x, s, t) {
+				var n = a + (b ^ c ^ d) + x + t;
+				return (n << s | n >>> 32 - s) + b;
+			}
+			function II(a, b, c, d, x, s, t) {
+				var n = a + (c ^ (b | ~d)) + x + t;
+				return (n << s | n >>> 32 - s) + b;
+			}
+			/**
+			* 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.MD5('message');
+			*     var hash = CryptoJS.MD5(wordArray);
+			*/
+			C.MD5 = Hasher._createHelper(MD5);
+			/**
+			* 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.HmacMD5(message, key);
+			*/
+			C.HmacMD5 = Hasher._createHmacHelper(MD5);
+		})(Math);
+		return CryptoJS.MD5;
+	});
+}));
+//#endregion
+//#region node_modules/.pnpm/crypto-js@4.2.0/node_modules/crypto-js/sha1.js
+var require_sha1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	(function(root, factory) {
+		if (typeof exports === "object") module.exports = exports = factory(require_core());
+		else if (typeof define === "function" && define.amd) define(["./core"], factory);
+		else factory(root.CryptoJS);
+	})(exports, function(CryptoJS) {
+		(function() {
+			var C = CryptoJS;
+			var C_lib = C.lib;
+			var WordArray = C_lib.WordArray;
+			var Hasher = C_lib.Hasher;
+			var C_algo = C.algo;
+			var W = [];
+			/**
+			* SHA-1 hash algorithm.
+			*/
+			var SHA1 = C_algo.SHA1 = Hasher.extend({
+				_doReset: function() {
+					this._hash = new WordArray.init([
+						1732584193,
+						4023233417,
+						2562383102,
+						271733878,
+						3285377520
+					]);
+				},
+				_doProcessBlock: function(M, offset) {
+					var H = this._hash.words;
+					var a = H[0];
+					var b = H[1];
+					var c = H[2];
+					var d = H[3];
+					var e = H[4];
+					for (var i = 0; i < 80; i++) {
+						if (i < 16) W[i] = M[offset + i] | 0;
+						else {
+							var n = W[i - 3] ^ W[i - 8] ^ W[i - 14] ^ W[i - 16];
+							W[i] = n << 1 | n >>> 31;
+						}
+						var t = (a << 5 | a >>> 27) + e + W[i];
+						if (i < 20) t += (b & c | ~b & d) + 1518500249;
+						else if (i < 40) t += (b ^ c ^ d) + 1859775393;
+						else if (i < 60) t += (b & c | b & d | c & d) - 1894007588;
+						else t += (b ^ c ^ d) - 899497514;
+						e = d;
+						d = c;
+						c = b << 30 | b >>> 2;
+						b = a;
+						a = t;
+					}
+					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;
+				},
+				_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] = Math.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;
+				}
+			});
+			/**
+			* 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.SHA1('message');
+			*     var hash = CryptoJS.SHA1(wordArray);
+			*/
+			C.SHA1 = Hasher._createHelper(SHA1);
+			/**
+			* 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.HmacSHA1(message, key);
+			*/
+			C.HmacSHA1 = Hasher._createHmacHelper(SHA1);
+		})();
+		return CryptoJS.SHA1;
+	});
+}));
+//#endregion
+//#region node_modules/.pnpm/crypto-js@4.2.0/node_modules/crypto-js/hmac.js
+var require_hmac = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	(function(root, factory) {
+		if (typeof exports === "object") module.exports = exports = factory(require_core());
+		else if (typeof define === "function" && define.amd) define(["./core"], factory);
+		else factory(root.CryptoJS);
+	})(exports, function(CryptoJS) {
+		(function() {
+			var C = CryptoJS;
+			var Base = C.lib.Base;
+			var Utf8 = C.enc.Utf8;
+			var C_algo = C.algo;
+			C_algo.HMAC = Base.extend({
+				/**
+				* Initializes a newly created HMAC.
+				*
+				* @param {Hasher} hasher The hash algorithm to use.
+				* @param {WordArray|string} key The secret key.
+				*
+				* @example
+				*
+				*     var hmacHasher = CryptoJS.algo.HMAC.create(CryptoJS.algo.SHA256, key);
+				*/
+				init: function(hasher, key) {
+					hasher = this._hasher = new hasher.init();
+					if (typeof key == "string") key = Utf8.parse(key);
+					var hasherBlockSize = hasher.blockSize;
+					var hasherBlockSizeBytes = hasherBlockSize * 4;
+					if (key.sigBytes > hasherBlockSizeBytes) key = hasher.finalize(key);
+					key.clamp();
+					var oKey = this._oKey = key.clone();
+					var iKey = this._iKey = key.clone();
+					var oKeyWords = oKey.words;
+					var iKeyWords = iKey.words;
+					for (var i = 0; i < hasherBlockSize; i++) {
+						oKeyWords[i] ^= 1549556828;
+						iKeyWords[i] ^= 909522486;
+					}
+					oKey.sigBytes = iKey.sigBytes = hasherBlockSizeBytes;
+					this.reset();
+				},
+				/**
+				* Resets this HMAC to its initial state.
+				*
+				* @example
+				*
+				*     hmacHasher.reset();
+				*/
+				reset: function() {
+					var hasher = this._hasher;
+					hasher.reset();
+					hasher.update(this._iKey);
+				},
+				/**
+				* Updates this HMAC with a message.
+				*
+				* @param {WordArray|string} messageUpdate The message to append.
+				*
+				* @return {HMAC} This HMAC instance.
+				*
+				* @example
+				*
+				*     hmacHasher.update('message');
+				*     hmacHasher.update(wordArray);
+				*/
+				update: function(messageUpdate) {
+					this._hasher.update(messageUpdate);
+					return this;
+				},
+				/**
+				* Finalizes the HMAC computation.
+				* Note that the finalize operation is effectively a destructive, read-once operation.
+				*
+				* @param {WordArray|string} messageUpdate (Optional) A final message update.
+				*
+				* @return {WordArray} The HMAC.
+				*
+				* @example
+				*
+				*     var hmac = hmacHasher.finalize();
+				*     var hmac = hmacHasher.finalize('message');
+				*     var hmac = hmacHasher.finalize(wordArray);
+				*/
+				finalize: function(messageUpdate) {
+					var hasher = this._hasher;
+					var innerHash = hasher.finalize(messageUpdate);
+					hasher.reset();
+					return hasher.finalize(this._oKey.clone().concat(innerHash));
+				}
+			});
+		})();
+	});
+}));
+//#endregion
+//#region node_modules/.pnpm/crypto-js@4.2.0/node_modules/crypto-js/evpkdf.js
+var require_evpkdf = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	(function(root, factory, undef) {
+		if (typeof exports === "object") module.exports = exports = factory(require_core(), require_sha1(), require_hmac());
+		else if (typeof define === "function" && define.amd) define([
+			"./core",
+			"./sha1",
+			"./hmac"
+		], factory);
+		else factory(root.CryptoJS);
+	})(exports, function(CryptoJS) {
+		(function() {
+			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: 4,
+					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;
+					var cfg = this.cfg;
+					var hasher = cfg.hasher.create();
+					var derivedKey = WordArray.create();
+					var derivedKeyWords = derivedKey.words;
+					var keySize = cfg.keySize;
+					var iterations = cfg.iterations;
+					while (derivedKeyWords.length < keySize) {
+						if (block) hasher.update(block);
+						block = hasher.update(password).finalize(salt);
+						hasher.reset();
+						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;
+	});
+}));
+//#endregion
+//#region node_modules/.pnpm/crypto-js@4.2.0/node_modules/crypto-js/cipher-core.js
+var require_cipher_core = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	(function(root, factory, undef) {
+		if (typeof exports === "object") module.exports = exports = factory(require_core(), require_evpkdf());
+		else if (typeof define === "function" && define.amd) define(["./core", "./evpkdf"], factory);
+		else factory(root.CryptoJS);
+	})(exports, function(CryptoJS) {
+		/**
+		* Cipher core components.
+		*/
+		CryptoJS.lib.Cipher || function(undefined) {
+			var C = CryptoJS;
+			var C_lib = C.lib;
+			var Base = C_lib.Base;
+			var WordArray = C_lib.WordArray;
+			var BufferedBlockAlgorithm = C_lib.BufferedBlockAlgorithm;
+			var C_enc = C.enc;
+			C_enc.Utf8;
+			var Base64 = C_enc.Base64;
+			var EvpKDF = C.algo.EvpKDF;
+			/**
+			* Abstract base cipher template.
+			*
+			* @property {number} keySize This cipher's key size. Default: 4 (128 bits)
+			* @property {number} ivSize This cipher's IV size. Default: 4 (128 bits)
+			* @property {number} _ENC_XFORM_MODE A constant representing encryption mode.
+			* @property {number} _DEC_XFORM_MODE A constant representing decryption mode.
+			*/
+			var Cipher = C_lib.Cipher = BufferedBlockAlgorithm.extend({
+				/**
+				* Configuration options.
+				*
+				* @property {WordArray} iv The IV to use for this operation.
+				*/
+				cfg: Base.extend(),
+				/**
+				* Creates this cipher in encryption mode.
+				*
+				* @param {WordArray} key The key.
+				* @param {Object} cfg (Optional) The configuration options to use for this operation.
+				*
+				* @return {Cipher} A cipher instance.
+				*
+				* @static
+				*
+				* @example
+				*
+				*     var cipher = CryptoJS.algo.AES.createEncryptor(keyWordArray, { iv: ivWordArray });
+				*/
+				createEncryptor: function(key, cfg) {
+					return this.create(this._ENC_XFORM_MODE, key, cfg);
+				},
+				/**
+				* Creates this cipher in decryption mode.
+				*
+				* @param {WordArray} key The key.
+				* @param {Object} cfg (Optional) The configuration options to use for this operation.
+				*
+				* @return {Cipher} A cipher instance.
+				*
+				* @static
+				*
+				* @example
+				*
+				*     var cipher = CryptoJS.algo.AES.createDecryptor(keyWordArray, { iv: ivWordArray });
+				*/
+				createDecryptor: function(key, cfg) {
+					return this.create(this._DEC_XFORM_MODE, key, cfg);
+				},
+				/**
+				* Initializes a newly created cipher.
+				*
+				* @param {number} xformMode Either the encryption or decryption transormation mode constant.
+				* @param {WordArray} key The key.
+				* @param {Object} cfg (Optional) The configuration options to use for this operation.
+				*
+				* @example
+				*
+				*     var cipher = CryptoJS.algo.AES.create(CryptoJS.algo.AES._ENC_XFORM_MODE, keyWordArray, { iv: ivWordArray });
+				*/
+				init: function(xformMode, key, cfg) {
+					this.cfg = this.cfg.extend(cfg);
+					this._xformMode = xformMode;
+					this._key = key;
+					this.reset();
+				},
+				/**
+				* Resets this cipher to its initial state.
+				*
+				* @example
+				*
+				*     cipher.reset();
+				*/
+				reset: function() {
+					BufferedBlockAlgorithm.reset.call(this);
+					this._doReset();
+				},
+				/**
+				* Adds data to be encrypted or decrypted.
+				*
+				* @param {WordArray|string} dataUpdate The data to encrypt or decrypt.
+				*
+				* @return {WordArray} The data after processing.
+				*
+				* @example
+				*
+				*     var encrypted = cipher.process('data');
+				*     var encrypted = cipher.process(wordArray);
+				*/
+				process: function(dataUpdate) {
+					this._append(dataUpdate);
+					return this._process();
+				},
+				/**
+				* Finalizes the encryption or decryption process.
+				* Note that the finalize operation is effectively a destructive, read-once operation.
+				*
+				* @param {WordArray|string} dataUpdate The final data to encrypt or decrypt.
+				*
+				* @return {WordArray} The data after final processing.
+				*
+				* @example
+				*
+				*     var encrypted = cipher.finalize();
+				*     var encrypted = cipher.finalize('data');
+				*     var encrypted = cipher.finalize(wordArray);
+				*/
+				finalize: function(dataUpdate) {
+					if (dataUpdate) this._append(dataUpdate);
+					return this._doFinalize();
+				},
+				keySize: 4,
+				ivSize: 4,
+				_ENC_XFORM_MODE: 1,
+				_DEC_XFORM_MODE: 2,
+				/**
+				* Creates shortcut functions to a cipher's object interface.
+				*
+				* @param {Cipher} cipher The cipher to create a helper for.
+				*
+				* @return {Object} An object with encrypt and decrypt shortcut functions.
+				*
+				* @static
+				*
+				* @example
+				*
+				*     var AES = CryptoJS.lib.Cipher._createHelper(CryptoJS.algo.AES);
+				*/
+				_createHelper: function() {
+					function selectCipherStrategy(key) {
+						if (typeof key == "string") return PasswordBasedCipher;
+						else return SerializableCipher;
+					}
+					return function(cipher) {
+						return {
+							encrypt: function(message, key, cfg) {
+								return selectCipherStrategy(key).encrypt(cipher, message, key, cfg);
+							},
+							decrypt: function(ciphertext, key, cfg) {
+								return selectCipherStrategy(key).decrypt(cipher, ciphertext, key, cfg);
+							}
+						};
+					};
+				}()
+			});
+			C_lib.StreamCipher = Cipher.extend({
+				_doFinalize: function() {
+					return this._process(true);
+				},
+				blockSize: 1
+			});
+			/**
+			* Mode namespace.
+			*/
+			var C_mode = C.mode = {};
+			/**
+			* Abstract base block cipher mode template.
+			*/
+			var BlockCipherMode = C_lib.BlockCipherMode = Base.extend({
+				/**
+				* Creates this mode for encryption.
+				*
+				* @param {Cipher} cipher A block cipher instance.
+				* @param {Array} iv The IV words.
+				*
+				* @static
+				*
+				* @example
+				*
+				*     var mode = CryptoJS.mode.CBC.createEncryptor(cipher, iv.words);
+				*/
+				createEncryptor: function(cipher, iv) {
+					return this.Encryptor.create(cipher, iv);
+				},
+				/**
+				* Creates this mode for decryption.
+				*
+				* @param {Cipher} cipher A block cipher instance.
+				* @param {Array} iv The IV words.
+				*
+				* @static
+				*
+				* @example
+				*
+				*     var mode = CryptoJS.mode.CBC.createDecryptor(cipher, iv.words);
+				*/
+				createDecryptor: function(cipher, iv) {
+					return this.Decryptor.create(cipher, iv);
+				},
+				/**
+				* Initializes a newly created mode.
+				*
+				* @param {Cipher} cipher A block cipher instance.
+				* @param {Array} iv The IV words.
+				*
+				* @example
+				*
+				*     var mode = CryptoJS.mode.CBC.Encryptor.create(cipher, iv.words);
+				*/
+				init: function(cipher, iv) {
+					this._cipher = cipher;
+					this._iv = iv;
+				}
+			});
+			/**
+			* Cipher Block Chaining mode.
+			*/
+			var CBC = C_mode.CBC = function() {
+				/**
+				* Abstract base CBC mode.
+				*/
+				var CBC = BlockCipherMode.extend();
+				/**
+				* CBC encryptor.
+				*/
+				CBC.Encryptor = CBC.extend({ 
+				/**
+				* Processes the data block at offset.
+				*
+				* @param {Array} words The data words to operate on.
+				* @param {number} offset The offset where the block starts.
+				*
+				* @example
+				*
+				*     mode.processBlock(data.words, offset);
+				*/
+processBlock: function(words, offset) {
+					var cipher = this._cipher;
+					var blockSize = cipher.blockSize;
+					xorBlock.call(this, words, offset, blockSize);
+					cipher.encryptBlock(words, offset);
+					this._prevBlock = words.slice(offset, offset + blockSize);
+				} });
+				/**
+				* CBC decryptor.
+				*/
+				CBC.Decryptor = CBC.extend({ 
+				/**
+				* Processes the data block at offset.
+				*
+				* @param {Array} words The data words to operate on.
+				* @param {number} offset The offset where the block starts.
+				*
+				* @example
+				*
+				*     mode.processBlock(data.words, offset);
+				*/
+processBlock: function(words, offset) {
+					var cipher = this._cipher;
+					var blockSize = cipher.blockSize;
+					var thisBlock = words.slice(offset, offset + blockSize);
+					cipher.decryptBlock(words, offset);
+					xorBlock.call(this, words, offset, blockSize);
+					this._prevBlock = thisBlock;
+				} });
+				function xorBlock(words, offset, blockSize) {
+					var block;
+					var iv = this._iv;
+					if (iv) {
+						block = iv;
+						this._iv = undefined;
+					} else block = this._prevBlock;
+					for (var i = 0; i < blockSize; i++) words[offset + i] ^= block[i];
+				}
+				return CBC;
+			}();
+			/**
+			* Padding namespace.
+			*/
+			var C_pad = C.pad = {};
+			/**
+			* PKCS #5/7 padding strategy.
+			*/
+			var Pkcs7 = C_pad.Pkcs7 = {
+				/**
+				* Pads data using the algorithm defined in PKCS #5/7.
+				*
+				* @param {WordArray} data The data to pad.
+				* @param {number} blockSize The multiple that the data should be padded to.
+				*
+				* @static
+				*
+				* @example
+				*
+				*     CryptoJS.pad.Pkcs7.pad(wordArray, 4);
+				*/
+				pad: function(data, blockSize) {
+					var blockSizeBytes = blockSize * 4;
+					var nPaddingBytes = blockSizeBytes - data.sigBytes % blockSizeBytes;
+					var paddingWord = nPaddingBytes << 24 | nPaddingBytes << 16 | nPaddingBytes << 8 | nPaddingBytes;
+					var paddingWords = [];
+					for (var i = 0; i < nPaddingBytes; i += 4) paddingWords.push(paddingWord);
+					var padding = WordArray.create(paddingWords, nPaddingBytes);
+					data.concat(padding);
+				},
+				/**
+				* Unpads data that had been padded using the algorithm defined in PKCS #5/7.
+				*
+				* @param {WordArray} data The data to unpad.
+				*
+				* @static
+				*
+				* @example
+				*
+				*     CryptoJS.pad.Pkcs7.unpad(wordArray);
+				*/
+				unpad: function(data) {
+					var nPaddingBytes = data.words[data.sigBytes - 1 >>> 2] & 255;
+					data.sigBytes -= nPaddingBytes;
+				}
+			};
+			C_lib.BlockCipher = Cipher.extend({
+				/**
+				* Configuration options.
+				*
+				* @property {Mode} mode The block mode to use. Default: CBC
+				* @property {Padding} padding The padding strategy to use. Default: Pkcs7
+				*/
+				cfg: Cipher.cfg.extend({
+					mode: CBC,
+					padding: Pkcs7
+				}),
+				reset: function() {
+					var modeCreator;
+					Cipher.reset.call(this);
+					var cfg = this.cfg;
+					var iv = cfg.iv;
+					var mode = cfg.mode;
+					if (this._xformMode == this._ENC_XFORM_MODE) modeCreator = mode.createEncryptor;
+					else {
+						modeCreator = mode.createDecryptor;
+						this._minBufferSize = 1;
+					}
+					if (this._mode && this._mode.__creator == modeCreator) this._mode.init(this, iv && iv.words);
+					else {
+						this._mode = modeCreator.call(mode, this, iv && iv.words);
+						this._mode.__creator = modeCreator;
+					}
+				},
+				_doProcessBlock: function(words, offset) {
+					this._mode.processBlock(words, offset);
+				},
+				_doFinalize: function() {
+					var finalProcessedBlocks;
+					var padding = this.cfg.padding;
+					if (this._xformMode == this._ENC_XFORM_MODE) {
+						padding.pad(this._data, this.blockSize);
+						finalProcessedBlocks = this._process(true);
+					} else {
+						finalProcessedBlocks = this._process(true);
+						padding.unpad(finalProcessedBlocks);
+					}
+					return finalProcessedBlocks;
+				},
+				blockSize: 4
+			});
+			/**
+			* A collection of cipher parameters.
+			*
+			* @property {WordArray} ciphertext The raw ciphertext.
+			* @property {WordArray} key The key to this ciphertext.
+			* @property {WordArray} iv The IV used in the ciphering operation.
+			* @property {WordArray} salt The salt used with a key derivation function.
+			* @property {Cipher} algorithm The cipher algorithm.
+			* @property {Mode} mode The block mode used in the ciphering operation.
+			* @property {Padding} padding The padding scheme used in the ciphering operation.
+			* @property {number} blockSize The block size of the cipher.
+			* @property {Format} formatter The default formatting strategy to convert this cipher params object to a string.
+			*/
+			var CipherParams = C_lib.CipherParams = Base.extend({
+				/**
+				* Initializes a newly created cipher params object.
+				*
+				* @param {Object} cipherParams An object with any of the possible cipher parameters.
+				*
+				* @example
+				*
+				*     var cipherParams = CryptoJS.lib.CipherParams.create({
+				*         ciphertext: ciphertextWordArray,
+				*         key: keyWordArray,
+				*         iv: ivWordArray,
+				*         salt: saltWordArray,
+				*         algorithm: CryptoJS.algo.AES,
+				*         mode: CryptoJS.mode.CBC,
+				*         padding: CryptoJS.pad.PKCS7,
+				*         blockSize: 4,
+				*         formatter: CryptoJS.format.OpenSSL
+				*     });
+				*/
+				init: function(cipherParams) {
+					this.mixIn(cipherParams);
+				},
+				/**
+				* Converts this cipher params object to a string.
+				*
+				* @param {Format} formatter (Optional) The formatting strategy to use.
+				*
+				* @return {string} The stringified cipher params.
+				*
+				* @throws Error If neither the formatter nor the default formatter is set.
+				*
+				* @example
+				*
+				*     var string = cipherParams + '';
+				*     var string = cipherParams.toString();
+				*     var string = cipherParams.toString(CryptoJS.format.OpenSSL);
+				*/
+				toString: function(formatter) {
+					return (formatter || this.formatter).stringify(this);
+				}
+			});
+			/**
+			* Format namespace.
+			*/
+			var C_format = C.format = {};
+			/**
+			* OpenSSL formatting strategy.
+			*/
+			var OpenSSLFormatter = C_format.OpenSSL = {
+				/**
+				* Converts a cipher params object to an OpenSSL-compatible string.
+				*
+				* @param {CipherParams} cipherParams The cipher params object.
+				*
+				* @return {string} The OpenSSL-compatible string.
+				*
+				* @static
+				*
+				* @example
+				*
+				*     var openSSLString = CryptoJS.format.OpenSSL.stringify(cipherParams);
+				*/
+				stringify: function(cipherParams) {
+					var wordArray;
+					var ciphertext = cipherParams.ciphertext;
+					var salt = cipherParams.salt;
+					if (salt) wordArray = WordArray.create([1398893684, 1701076831]).concat(salt).concat(ciphertext);
+					else wordArray = ciphertext;
+					return wordArray.toString(Base64);
+				},
+				/**
+				* Converts an OpenSSL-compatible string to a cipher params object.
+				*
+				* @param {string} openSSLStr The OpenSSL-compatible string.
+				*
+				* @return {CipherParams} The cipher params object.
+				*
+				* @static
+				*
+				* @example
+				*
+				*     var cipherParams = CryptoJS.format.OpenSSL.parse(openSSLString);
+				*/
+				parse: function(openSSLStr) {
+					var salt;
+					var ciphertext = Base64.parse(openSSLStr);
+					var ciphertextWords = ciphertext.words;
+					if (ciphertextWords[0] == 1398893684 && ciphertextWords[1] == 1701076831) {
+						salt = WordArray.create(ciphertextWords.slice(2, 4));
+						ciphertextWords.splice(0, 4);
+						ciphertext.sigBytes -= 16;
+					}
+					return CipherParams.create({
+						ciphertext,
+						salt
+					});
+				}
+			};
+			/**
+			* A cipher wrapper that returns ciphertext as a serializable cipher params object.
+			*/
+			var SerializableCipher = C_lib.SerializableCipher = Base.extend({
+				/**
+				* Configuration options.
+				*
+				* @property {Formatter} format The formatting strategy to convert cipher param objects to and from a string. Default: OpenSSL
+				*/
+				cfg: Base.extend({ format: OpenSSLFormatter }),
+				/**
+				* Encrypts a message.
+				*
+				* @param {Cipher} cipher The cipher algorithm to use.
+				* @param {WordArray|string} message The message to encrypt.
+				* @param {WordArray} key The key.
+				* @param {Object} cfg (Optional) The configuration options to use for this operation.
+				*
+				* @return {CipherParams} A cipher params object.
+				*
+				* @static
+				*
+				* @example
+				*
+				*     var ciphertextParams = CryptoJS.lib.SerializableCipher.encrypt(CryptoJS.algo.AES, message, key);
+				*     var ciphertextParams = CryptoJS.lib.SerializableCipher.encrypt(CryptoJS.algo.AES, message, key, { iv: iv });
+				*     var ciphertextParams = CryptoJS.lib.SerializableCipher.encrypt(CryptoJS.algo.AES, message, key, { iv: iv, format: CryptoJS.format.OpenSSL });
+				*/
+				encrypt: function(cipher, message, key, cfg) {
+					cfg = this.cfg.extend(cfg);
+					var encryptor = cipher.createEncryptor(key, cfg);
+					var ciphertext = encryptor.finalize(message);
+					var cipherCfg = encryptor.cfg;
+					return CipherParams.create({
+						ciphertext,
+						key,
+						iv: cipherCfg.iv,
+						algorithm: cipher,
+						mode: cipherCfg.mode,
+						padding: cipherCfg.padding,
+						blockSize: cipher.blockSize,
+						formatter: cfg.format
+					});
+				},
+				/**
+				* Decrypts serialized ciphertext.
+				*
+				* @param {Cipher} cipher The cipher algorithm to use.
+				* @param {CipherParams|string} ciphertext The ciphertext to decrypt.
+				* @param {WordArray} key The key.
+				* @param {Object} cfg (Optional) The configuration options to use for this operation.
+				*
+				* @return {WordArray} The plaintext.
+				*
+				* @static
+				*
+				* @example
+				*
+				*     var plaintext = CryptoJS.lib.SerializableCipher.decrypt(CryptoJS.algo.AES, formattedCiphertext, key, { iv: iv, format: CryptoJS.format.OpenSSL });
+				*     var plaintext = CryptoJS.lib.SerializableCipher.decrypt(CryptoJS.algo.AES, ciphertextParams, key, { iv: iv, format: CryptoJS.format.OpenSSL });
+				*/
+				decrypt: function(cipher, ciphertext, key, cfg) {
+					cfg = this.cfg.extend(cfg);
+					ciphertext = this._parse(ciphertext, cfg.format);
+					return cipher.createDecryptor(key, cfg).finalize(ciphertext.ciphertext);
+				},
+				/**
+				* Converts serialized ciphertext to CipherParams,
+				* else assumed CipherParams already and returns ciphertext unchanged.
+				*
+				* @param {CipherParams|string} ciphertext The ciphertext.
+				* @param {Formatter} format The formatting strategy to use to parse serialized ciphertext.
+				*
+				* @return {CipherParams} The unserialized ciphertext.
+				*
+				* @static
+				*
+				* @example
+				*
+				*     var ciphertextParams = CryptoJS.lib.SerializableCipher._parse(ciphertextStringOrParams, format);
+				*/
+				_parse: function(ciphertext, format) {
+					if (typeof ciphertext == "string") return format.parse(ciphertext, this);
+					else return ciphertext;
+				}
+			});
+			/**
+			* Key derivation function namespace.
+			*/
+			var C_kdf = C.kdf = {};
+			/**
+			* OpenSSL key derivation function.
+			*/
+			var OpenSSLKdf = C_kdf.OpenSSL = { 
+			/**
+			* Derives a key and IV from a password.
+			*
+			* @param {string} password The password to derive from.
+			* @param {number} keySize The size in words of the key to generate.
+			* @param {number} ivSize The size in words of the IV to generate.
+			* @param {WordArray|string} salt (Optional) A 64-bit salt to use. If omitted, a salt will be generated randomly.
+			*
+			* @return {CipherParams} A cipher params object with the key, IV, and salt.
+			*
+			* @static
+			*
+			* @example
+			*
+			*     var derivedParams = CryptoJS.kdf.OpenSSL.execute('Password', 256/32, 128/32);
+			*     var derivedParams = CryptoJS.kdf.OpenSSL.execute('Password', 256/32, 128/32, 'saltsalt');
+			*/
+execute: function(password, keySize, ivSize, salt, hasher) {
+				if (!salt) salt = WordArray.random(8);
+				if (!hasher) var key = EvpKDF.create({ keySize: keySize + ivSize }).compute(password, salt);
+				else var key = EvpKDF.create({
+					keySize: keySize + ivSize,
+					hasher
+				}).compute(password, salt);
+				var iv = WordArray.create(key.words.slice(keySize), ivSize * 4);
+				key.sigBytes = keySize * 4;
+				return CipherParams.create({
+					key,
+					iv,
+					salt
+				});
+			} };
+			/**
+			* A serializable cipher wrapper that derives the key from a password,
+			* and returns ciphertext as a serializable cipher params object.
+			*/
+			var PasswordBasedCipher = C_lib.PasswordBasedCipher = SerializableCipher.extend({
+				/**
+				* Configuration options.
+				*
+				* @property {KDF} kdf The key derivation function to use to generate a key and IV from a password. Default: OpenSSL
+				*/
+				cfg: SerializableCipher.cfg.extend({ kdf: OpenSSLKdf }),
+				/**
+				* Encrypts a message using a password.
+				*
+				* @param {Cipher} cipher The cipher algorithm to use.
+				* @param {WordArray|string} message The message to encrypt.
+				* @param {string} password The password.
+				* @param {Object} cfg (Optional) The configuration options to use for this operation.
+				*
+				* @return {CipherParams} A cipher params object.
+				*
+				* @static
+				*
+				* @example
+				*
+				*     var ciphertextParams = CryptoJS.lib.PasswordBasedCipher.encrypt(CryptoJS.algo.AES, message, 'password');
+				*     var ciphertextParams = CryptoJS.lib.PasswordBasedCipher.encrypt(CryptoJS.algo.AES, message, 'password', { format: CryptoJS.format.OpenSSL });
+				*/
+				encrypt: function(cipher, message, password, cfg) {
+					cfg = this.cfg.extend(cfg);
+					var derivedParams = cfg.kdf.execute(password, cipher.keySize, cipher.ivSize, cfg.salt, cfg.hasher);
+					cfg.iv = derivedParams.iv;
+					var ciphertext = SerializableCipher.encrypt.call(this, cipher, message, derivedParams.key, cfg);
+					ciphertext.mixIn(derivedParams);
+					return ciphertext;
+				},
+				/**
+				* Decrypts serialized ciphertext using a password.
+				*
+				* @param {Cipher} cipher The cipher algorithm to use.
+				* @param {CipherParams|string} ciphertext The ciphertext to decrypt.
+				* @param {string} password The password.
+				* @param {Object} cfg (Optional) The configuration options to use for this operation.
+				*
+				* @return {WordArray} The plaintext.
+				*
+				* @static
+				*
+				* @example
+				*
+				*     var plaintext = CryptoJS.lib.PasswordBasedCipher.decrypt(CryptoJS.algo.AES, formattedCiphertext, 'password', { format: CryptoJS.format.OpenSSL });
+				*     var plaintext = CryptoJS.lib.PasswordBasedCipher.decrypt(CryptoJS.algo.AES, ciphertextParams, 'password', { format: CryptoJS.format.OpenSSL });
+				*/
+				decrypt: function(cipher, ciphertext, password, cfg) {
+					cfg = this.cfg.extend(cfg);
+					ciphertext = this._parse(ciphertext, cfg.format);
+					var derivedParams = cfg.kdf.execute(password, cipher.keySize, cipher.ivSize, ciphertext.salt, cfg.hasher);
+					cfg.iv = derivedParams.iv;
+					return SerializableCipher.decrypt.call(this, cipher, ciphertext, derivedParams.key, cfg);
+				}
+			});
+		}();
+	});
+}));
+//#endregion
+//#region node_modules/.pnpm/crypto-js@4.2.0/node_modules/crypto-js/aes.js
+var require_aes = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	(function(root, factory, undef) {
+		if (typeof exports === "object") module.exports = exports = factory(require_core(), require_enc_base64(), require_md5(), require_evpkdf(), require_cipher_core());
+		else if (typeof define === "function" && define.amd) define([
+			"./core",
+			"./enc-base64",
+			"./md5",
+			"./evpkdf",
+			"./cipher-core"
+		], factory);
+		else factory(root.CryptoJS);
+	})(exports, function(CryptoJS) {
+		(function() {
+			var C = CryptoJS;
+			var BlockCipher = C.lib.BlockCipher;
+			var C_algo = C.algo;
+			var SBOX = [];
+			var INV_SBOX = [];
+			var SUB_MIX_0 = [];
+			var SUB_MIX_1 = [];
+			var SUB_MIX_2 = [];
+			var SUB_MIX_3 = [];
+			var INV_SUB_MIX_0 = [];
+			var INV_SUB_MIX_1 = [];
+			var INV_SUB_MIX_2 = [];
+			var INV_SUB_MIX_3 = [];
+			(function() {
+				var d = [];
+				for (var i = 0; i < 256; i++) if (i < 128) d[i] = i << 1;
+				else d[i] = i << 1 ^ 283;
+				var x = 0;
+				var xi = 0;
+				for (var i = 0; i < 256; i++) {
+					var sx = xi ^ xi << 1 ^ xi << 2 ^ xi << 3 ^ xi << 4;
+					sx = sx >>> 8 ^ sx & 255 ^ 99;
+					SBOX[x] = sx;
+					INV_SBOX[sx] = x;
+					var x2 = d[x];
+					var x4 = d[x2];
+					var x8 = d[x4];
+					var t = d[sx] * 257 ^ sx * 16843008;
+					SUB_MIX_0[x] = t << 24 | t >>> 8;
+					SUB_MIX_1[x] = t << 16 | t >>> 16;
+					SUB_MIX_2[x] = t << 8 | t >>> 24;
+					SUB_MIX_3[x] = t;
+					var t = x8 * 16843009 ^ x4 * 65537 ^ x2 * 257 ^ x * 16843008;
+					INV_SUB_MIX_0[sx] = t << 24 | t >>> 8;
+					INV_SUB_MIX_1[sx] = t << 16 | t >>> 16;
+					INV_SUB_MIX_2[sx] = t << 8 | t >>> 24;
+					INV_SUB_MIX_3[sx] = t;
+					if (!x) x = xi = 1;
+					else {
+						x = x2 ^ d[d[d[x8 ^ x2]]];
+						xi ^= d[d[xi]];
+					}
+				}
+			})();
+			var RCON = [
+				0,
+				1,
+				2,
+				4,
+				8,
+				16,
+				32,
+				64,
+				128,
+				27,
+				54
+			];
+			/**
+			* AES block cipher algorithm.
+			*/
+			var AES = C_algo.AES = BlockCipher.extend({
+				_doReset: function() {
+					var t;
+					if (this._nRounds && this._keyPriorReset === this._key) return;
+					var key = this._keyPriorReset = this._key;
+					var keyWords = key.words;
+					var keySize = key.sigBytes / 4;
+					var ksRows = ((this._nRounds = keySize + 6) + 1) * 4;
+					var keySchedule = this._keySchedule = [];
+					for (var ksRow = 0; ksRow < ksRows; ksRow++) if (ksRow < keySize) keySchedule[ksRow] = keyWords[ksRow];
+					else {
+						t = keySchedule[ksRow - 1];
+						if (!(ksRow % keySize)) {
+							t = t << 8 | t >>> 24;
+							t = SBOX[t >>> 24] << 24 | SBOX[t >>> 16 & 255] << 16 | SBOX[t >>> 8 & 255] << 8 | SBOX[t & 255];
+							t ^= RCON[ksRow / keySize | 0] << 24;
+						} else if (keySize > 6 && ksRow % keySize == 4) t = SBOX[t >>> 24] << 24 | SBOX[t >>> 16 & 255] << 16 | SBOX[t >>> 8 & 255] << 8 | SBOX[t & 255];
+						keySchedule[ksRow] = keySchedule[ksRow - keySize] ^ t;
+					}
+					var invKeySchedule = this._invKeySchedule = [];
+					for (var invKsRow = 0; invKsRow < ksRows; invKsRow++) {
+						var ksRow = ksRows - invKsRow;
+						if (invKsRow % 4) var t = keySchedule[ksRow];
+						else var t = keySchedule[ksRow - 4];
+						if (invKsRow < 4 || ksRow <= 4) invKeySchedule[invKsRow] = t;
+						else invKeySchedule[invKsRow] = INV_SUB_MIX_0[SBOX[t >>> 24]] ^ INV_SUB_MIX_1[SBOX[t >>> 16 & 255]] ^ INV_SUB_MIX_2[SBOX[t >>> 8 & 255]] ^ INV_SUB_MIX_3[SBOX[t & 255]];
+					}
+				},
+				encryptBlock: function(M, offset) {
+					this._doCryptBlock(M, offset, this._keySchedule, SUB_MIX_0, SUB_MIX_1, SUB_MIX_2, SUB_MIX_3, SBOX);
+				},
+				decryptBlock: function(M, offset) {
+					var t = M[offset + 1];
+					M[offset + 1] = M[offset + 3];
+					M[offset + 3] = t;
+					this._doCryptBlock(M, offset, this._invKeySchedule, INV_SUB_MIX_0, INV_SUB_MIX_1, INV_SUB_MIX_2, INV_SUB_MIX_3, INV_SBOX);
+					var t = M[offset + 1];
+					M[offset + 1] = M[offset + 3];
+					M[offset + 3] = t;
+				},
+				_doCryptBlock: function(M, offset, keySchedule, SUB_MIX_0, SUB_MIX_1, SUB_MIX_2, SUB_MIX_3, SBOX) {
+					var nRounds = this._nRounds;
+					var s0 = M[offset] ^ keySchedule[0];
+					var s1 = M[offset + 1] ^ keySchedule[1];
+					var s2 = M[offset + 2] ^ keySchedule[2];
+					var s3 = M[offset + 3] ^ keySchedule[3];
+					var ksRow = 4;
+					for (var round = 1; round < nRounds; round++) {
+						var t0 = SUB_MIX_0[s0 >>> 24] ^ SUB_MIX_1[s1 >>> 16 & 255] ^ SUB_MIX_2[s2 >>> 8 & 255] ^ SUB_MIX_3[s3 & 255] ^ keySchedule[ksRow++];
+						var t1 = SUB_MIX_0[s1 >>> 24] ^ SUB_MIX_1[s2 >>> 16 & 255] ^ SUB_MIX_2[s3 >>> 8 & 255] ^ SUB_MIX_3[s0 & 255] ^ keySchedule[ksRow++];
+						var t2 = SUB_MIX_0[s2 >>> 24] ^ SUB_MIX_1[s3 >>> 16 & 255] ^ SUB_MIX_2[s0 >>> 8 & 255] ^ SUB_MIX_3[s1 & 255] ^ keySchedule[ksRow++];
+						var t3 = SUB_MIX_0[s3 >>> 24] ^ SUB_MIX_1[s0 >>> 16 & 255] ^ SUB_MIX_2[s1 >>> 8 & 255] ^ SUB_MIX_3[s2 & 255] ^ keySchedule[ksRow++];
+						s0 = t0;
+						s1 = t1;
+						s2 = t2;
+						s3 = t3;
+					}
+					var t0 = (SBOX[s0 >>> 24] << 24 | SBOX[s1 >>> 16 & 255] << 16 | SBOX[s2 >>> 8 & 255] << 8 | SBOX[s3 & 255]) ^ keySchedule[ksRow++];
+					var t1 = (SBOX[s1 >>> 24] << 24 | SBOX[s2 >>> 16 & 255] << 16 | SBOX[s3 >>> 8 & 255] << 8 | SBOX[s0 & 255]) ^ keySchedule[ksRow++];
+					var t2 = (SBOX[s2 >>> 24] << 24 | SBOX[s3 >>> 16 & 255] << 16 | SBOX[s0 >>> 8 & 255] << 8 | SBOX[s1 & 255]) ^ keySchedule[ksRow++];
+					var t3 = (SBOX[s3 >>> 24] << 24 | SBOX[s0 >>> 16 & 255] << 16 | SBOX[s1 >>> 8 & 255] << 8 | SBOX[s2 & 255]) ^ keySchedule[ksRow++];
+					M[offset] = t0;
+					M[offset + 1] = t1;
+					M[offset + 2] = t2;
+					M[offset + 3] = t3;
+				},
+				keySize: 8
+			});
+			/**
+			* Shortcut functions to the cipher's object interface.
+			*
+			* @example
+			*
+			*     var ciphertext = CryptoJS.AES.encrypt(message, key, cfg);
+			*     var plaintext  = CryptoJS.AES.decrypt(ciphertext, key, cfg);
+			*/
+			C.AES = BlockCipher._createHelper(AES);
+		})();
+		return CryptoJS.AES;
+	});
+}));
+//#endregion
+//#region node_modules/.pnpm/crypto-js@4.2.0/node_modules/crypto-js/enc-hex.js
+var require_enc_hex = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	(function(root, factory) {
+		if (typeof exports === "object") module.exports = exports = factory(require_core());
+		else if (typeof define === "function" && define.amd) define(["./core"], factory);
+		else factory(root.CryptoJS);
+	})(exports, function(CryptoJS) {
+		return CryptoJS.enc.Hex;
+	});
+}));
+//#endregion
+//#region node_modules/.pnpm/crypto-js@4.2.0/node_modules/crypto-js/enc-utf8.js
+var require_enc_utf8 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	(function(root, factory) {
+		if (typeof exports === "object") module.exports = exports = factory(require_core());
+		else if (typeof define === "function" && define.amd) define(["./core"], factory);
+		else factory(root.CryptoJS);
+	})(exports, function(CryptoJS) {
+		return CryptoJS.enc.Utf8;
+	});
+}));
+//#endregion
+//#region node_modules/.pnpm/crypto-js@4.2.0/node_modules/crypto-js/mode-ecb.js
+var require_mode_ecb = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	(function(root, factory, undef) {
+		if (typeof exports === "object") module.exports = exports = factory(require_core(), require_cipher_core());
+		else if (typeof define === "function" && define.amd) define(["./core", "./cipher-core"], factory);
+		else factory(root.CryptoJS);
+	})(exports, function(CryptoJS) {
+		/**
+		* Electronic Codebook block mode.
+		*/
+		CryptoJS.mode.ECB = function() {
+			var ECB = CryptoJS.lib.BlockCipherMode.extend();
+			ECB.Encryptor = ECB.extend({ processBlock: function(words, offset) {
+				this._cipher.encryptBlock(words, offset);
+			} });
+			ECB.Decryptor = ECB.extend({ processBlock: function(words, offset) {
+				this._cipher.decryptBlock(words, offset);
+			} });
+			return ECB;
+		}();
+		return CryptoJS.mode.ECB;
+	});
+}));
+//#endregion
+//#region node_modules/.pnpm/crypto-js@4.2.0/node_modules/crypto-js/pad-ansix923.js
+var require_pad_ansix923 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	(function(root, factory, undef) {
+		if (typeof exports === "object") module.exports = exports = factory(require_core(), require_cipher_core());
+		else if (typeof define === "function" && define.amd) define(["./core", "./cipher-core"], factory);
+		else factory(root.CryptoJS);
+	})(exports, function(CryptoJS) {
+		/**
+		* ANSI X.923 padding strategy.
+		*/
+		CryptoJS.pad.AnsiX923 = {
+			pad: function(data, blockSize) {
+				var dataSigBytes = data.sigBytes;
+				var blockSizeBytes = blockSize * 4;
+				var nPaddingBytes = blockSizeBytes - dataSigBytes % blockSizeBytes;
+				var lastBytePos = dataSigBytes + nPaddingBytes - 1;
+				data.clamp();
+				data.words[lastBytePos >>> 2] |= nPaddingBytes << 24 - lastBytePos % 4 * 8;
+				data.sigBytes += nPaddingBytes;
+			},
+			unpad: function(data) {
+				var nPaddingBytes = data.words[data.sigBytes - 1 >>> 2] & 255;
+				data.sigBytes -= nPaddingBytes;
+			}
+		};
+		return CryptoJS.pad.Ansix923;
+	});
+}));
+//#endregion
+//#region node_modules/.pnpm/crypto-js@4.2.0/node_modules/crypto-js/pad-iso10126.js
+var require_pad_iso10126 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	(function(root, factory, undef) {
+		if (typeof exports === "object") module.exports = exports = factory(require_core(), require_cipher_core());
+		else if (typeof define === "function" && define.amd) define(["./core", "./cipher-core"], factory);
+		else factory(root.CryptoJS);
+	})(exports, function(CryptoJS) {
+		/**
+		* ISO 10126 padding strategy.
+		*/
+		CryptoJS.pad.Iso10126 = {
+			pad: function(data, blockSize) {
+				var blockSizeBytes = blockSize * 4;
+				var nPaddingBytes = blockSizeBytes - data.sigBytes % blockSizeBytes;
+				data.concat(CryptoJS.lib.WordArray.random(nPaddingBytes - 1)).concat(CryptoJS.lib.WordArray.create([nPaddingBytes << 24], 1));
+			},
+			unpad: function(data) {
+				var nPaddingBytes = data.words[data.sigBytes - 1 >>> 2] & 255;
+				data.sigBytes -= nPaddingBytes;
+			}
+		};
+		return CryptoJS.pad.Iso10126;
+	});
+}));
+//#endregion
+//#region node_modules/.pnpm/crypto-js@4.2.0/node_modules/crypto-js/pad-nopadding.js
+var require_pad_nopadding = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	(function(root, factory, undef) {
+		if (typeof exports === "object") module.exports = exports = factory(require_core(), require_cipher_core());
+		else if (typeof define === "function" && define.amd) define(["./core", "./cipher-core"], factory);
+		else factory(root.CryptoJS);
+	})(exports, function(CryptoJS) {
+		/**
+		* A noop padding strategy.
+		*/
+		CryptoJS.pad.NoPadding = {
+			pad: function() {},
+			unpad: function() {}
+		};
+		return CryptoJS.pad.NoPadding;
+	});
+}));
+//#endregion
+//#region node_modules/.pnpm/crypto-js@4.2.0/node_modules/crypto-js/pad-pkcs7.js
+var require_pad_pkcs7 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	(function(root, factory, undef) {
+		if (typeof exports === "object") module.exports = exports = factory(require_core(), require_cipher_core());
+		else if (typeof define === "function" && define.amd) define(["./core", "./cipher-core"], factory);
+		else factory(root.CryptoJS);
+	})(exports, function(CryptoJS) {
+		return CryptoJS.pad.Pkcs7;
+	});
+}));
+//#endregion
+//#region node_modules/.pnpm/crypto-js@4.2.0/node_modules/crypto-js/pad-zeropadding.js
+var require_pad_zeropadding = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	(function(root, factory, undef) {
+		if (typeof exports === "object") module.exports = exports = factory(require_core(), require_cipher_core());
+		else if (typeof define === "function" && define.amd) define(["./core", "./cipher-core"], factory);
+		else factory(root.CryptoJS);
+	})(exports, function(CryptoJS) {
+		/**
+		* Zero padding strategy.
+		*/
+		CryptoJS.pad.ZeroPadding = {
+			pad: function(data, blockSize) {
+				var blockSizeBytes = blockSize * 4;
+				data.clamp();
+				data.sigBytes += blockSizeBytes - (data.sigBytes % blockSizeBytes || blockSizeBytes);
+			},
+			unpad: function(data) {
+				var dataWords = data.words;
+				var i = data.sigBytes - 1;
+				for (var i = data.sigBytes - 1; i >= 0; i--) if (dataWords[i >>> 2] >>> 24 - i % 4 * 8 & 255) {
+					data.sigBytes = i + 1;
+					break;
+				}
+			}
+		};
+		return CryptoJS.pad.ZeroPadding;
+	});
+}));
+//#endregion
 //#region src/crypto/index.ts
+var import_aes = /* @__PURE__ */ __toESM(require_aes(), 1);
+var import_core = /* @__PURE__ */ __toESM(require_core(), 1);
+var import_enc_hex = /* @__PURE__ */ __toESM(require_enc_hex(), 1);
+var import_enc_utf8 = /* @__PURE__ */ __toESM(require_enc_utf8(), 1);
+var import_md5 = /* @__PURE__ */ __toESM(require_md5(), 1);
+var import_mode_ecb = /* @__PURE__ */ __toESM(require_mode_ecb(), 1);
+require_pad_ansix923();
+var import_pad_iso10126 = /* @__PURE__ */ __toESM(require_pad_iso10126(), 1);
+var import_pad_nopadding = /* @__PURE__ */ __toESM(require_pad_nopadding(), 1);
+var import_pad_pkcs7 = /* @__PURE__ */ __toESM(require_pad_pkcs7(), 1);
+var import_pad_zeropadding = /* @__PURE__ */ __toESM(require_pad_zeropadding(), 1);
+var import_sha1 = /* @__PURE__ */ __toESM(require_sha1(), 1);
 /** PBKDF2 默认迭代次数。 */
 const defaultPbkdf2Iterations = 6e5;
 /** PBKDF2 允许的最小迭代次数。 */
@@ -206,7 +2413,7 @@ function FixedTimeEquals(left, right) {
 * @returns 32 字符小写十六进制摘要。
 */
 function MD5Encrypt(value) {
-	return MD5(value).toString(Hex);
+	return (0, import_md5.default)(value).toString(import_enc_hex.default);
 }
 /**
 * 计算 SHA-1 摘要并返回大写十六进制文本。
@@ -216,7 +2423,7 @@ function MD5Encrypt(value) {
 * @returns 40 字符大写十六进制摘要。
 */
 function SHA1Encrypt(value) {
-	return SHA1(value).toString(Hex).toUpperCase();
+	return (0, import_sha1.default)(value).toString(import_enc_hex.default).toUpperCase();
 }
 /**
 * 计算 SHA-256 摘要。
@@ -406,32 +2613,32 @@ async function HKDFSHA256(inputKeyMaterial, salt = /* @__PURE__ */ new Uint8Arra
 function AESEncrypt(dataStr, key, vector, cipherMode = "CBC", paddingMode = "PKCS7") {
 	if (dataStr.trim().length === 0 || key.trim().length === 0 || vector.trim().length === 0) return null;
 	assertAesCipherMode(cipherMode);
-	let padding = Pkcs7;
+	let padding = import_pad_pkcs7.default;
 	switch (paddingMode) {
 		case "None":
-			padding = NoPadding;
+			padding = import_pad_nopadding.default;
 			break;
 		case "PKCS7": break;
 		case "Zeros":
-			padding = ZeroPadding;
+			padding = import_pad_zeropadding.default;
 			break;
 		case "ANSIX923":
-			padding = CryptoCore.pad.AnsiX923;
+			padding = import_core.default.pad.AnsiX923;
 			break;
 		case "ISO10126":
-			padding = Iso10126;
+			padding = import_pad_iso10126.default;
 			break;
 		default: throw new RangeError("不支持当前 `paddingMode`。");
 	}
 	if (paddingMode === "None" && encodeUtf8(dataStr).length % 16 !== 0) throw new RangeError("当 `paddingMode` 为 `None` 时，AES 明文长度必须是 16 字节的整数倍。");
-	const keyBytes = Utf8.parse(key.padEnd(32, "f").slice(0, 32));
-	const vectorBytes = Utf8.parse(vector.padEnd(16, "f").slice(0, 16));
-	return AES.encrypt(dataStr, keyBytes, cipherMode === "CBC" ? {
+	const keyBytes = import_enc_utf8.default.parse(key.padEnd(32, "f").slice(0, 32));
+	const vectorBytes = import_enc_utf8.default.parse(vector.padEnd(16, "f").slice(0, 16));
+	return import_aes.default.encrypt(dataStr, keyBytes, cipherMode === "CBC" ? {
 		iv: vectorBytes,
 		padding
 	} : {
 		iv: vectorBytes,
-		mode: ECB,
+		mode: import_mode_ecb.default,
 		padding
 	}).toString();
 }
@@ -450,35 +2657,35 @@ function AESEncrypt(dataStr, key, vector, cipherMode = "CBC", paddingMode = "PKC
 function AESDecrypt(dataStr, key, vector, cipherMode = "CBC", paddingMode = "PKCS7") {
 	if (dataStr.trim().length === 0 || key.trim().length === 0 || vector.trim().length === 0) return null;
 	assertAesCipherMode(cipherMode);
-	let padding = Pkcs7;
+	let padding = import_pad_pkcs7.default;
 	switch (paddingMode) {
 		case "None":
-			padding = NoPadding;
+			padding = import_pad_nopadding.default;
 			break;
 		case "PKCS7": break;
 		case "Zeros":
-			padding = NoPadding;
+			padding = import_pad_nopadding.default;
 			break;
 		case "ANSIX923":
-			padding = CryptoCore.pad.AnsiX923;
+			padding = import_core.default.pad.AnsiX923;
 			break;
 		case "ISO10126":
-			padding = Iso10126;
+			padding = import_pad_iso10126.default;
 			break;
 		default: throw new RangeError("不支持当前 `paddingMode`。");
 	}
 	const ciphertextBytes = decodeBase64Bytes(dataStr);
 	if (ciphertextBytes.length === 0 || ciphertextBytes.length % 16 !== 0) throw new RangeError("AES 密文必须至少包含一个完整的 16 字节块。");
-	const keyBytes = Utf8.parse(key.padEnd(32, "f").slice(0, 32));
-	const vectorBytes = Utf8.parse(vector.padEnd(16, "f").slice(0, 16));
-	return createDecodedText(AES.decrypt(dataStr, keyBytes, cipherMode === "CBC" ? {
+	const keyBytes = import_enc_utf8.default.parse(key.padEnd(32, "f").slice(0, 32));
+	const vectorBytes = import_enc_utf8.default.parse(vector.padEnd(16, "f").slice(0, 16));
+	return createDecodedText(import_aes.default.decrypt(dataStr, keyBytes, cipherMode === "CBC" ? {
 		iv: vectorBytes,
 		padding
 	} : {
 		iv: vectorBytes,
-		mode: ECB,
+		mode: import_mode_ecb.default,
 		padding
-	}).toString(Utf8));
+	}).toString(import_enc_utf8.default));
 }
 /**
 * 使用 SHA-256 归一化文本密钥，再以 AES-256-GCM 认证加密 UTF-8 文本。