@wfrog/vc-ui 1.0.0

package/dist/es/chunk/BdDihk0t.mjs

@@ -0,0 +1,3420 @@
+import { a as getAugmentedNamespace, c as commonjsGlobal, g as getDefaultExportFromCjs } from './BAGoDD49.mjs';
+import { i as isObjectLike, b as baseGetTag } from './Fo0dZYnz.mjs';
+import { b as baseUnary, n as nodeUtil } from './O-uhUKF4.mjs';
+
+/** `Object#toString` result references. */
+var dateTag = '[object Date]';
+
+/**
+ * The base implementation of `_.isDate` without Node.js optimizations.
+ *
+ * @private
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a date object, else `false`.
+ */
+function baseIsDate(value) {
+  return isObjectLike(value) && baseGetTag(value) == dateTag;
+}
+
+/* Node.js helper references. */
+var nodeIsDate = nodeUtil && nodeUtil.isDate;
+
+/**
+ * Checks if `value` is classified as a `Date` object.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a date object, else `false`.
+ * @example
+ *
+ * _.isDate(new Date);
+ * // => true
+ *
+ * _.isDate('Mon April 23 2012');
+ * // => false
+ */
+var isDate = nodeIsDate ? baseUnary(nodeIsDate) : baseIsDate;
+
+/** `Object#toString` result references. */
+var numberTag = '[object Number]';
+
+/**
+ * Checks if `value` is classified as a `Number` primitive or object.
+ *
+ * **Note:** To exclude `Infinity`, `-Infinity`, and `NaN`, which are
+ * classified as numbers, use the `_.isFinite` method.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a number, else `false`.
+ * @example
+ *
+ * _.isNumber(3);
+ * // => true
+ *
+ * _.isNumber(Number.MIN_VALUE);
+ * // => true
+ *
+ * _.isNumber(Infinity);
+ * // => true
+ *
+ * _.isNumber('3');
+ * // => false
+ */
+function isNumber(value) {
+  return typeof value == 'number' ||
+    (isObjectLike(value) && baseGetTag(value) == numberTag);
+}
+
+var aes$1 = {exports: {}};
+
+function commonjsRequire(path) {
+	throw new Error('Could not dynamically require "' + path + '". Please configure the dynamicRequireTargets or/and ignoreDynamicRequires option of @rollup/plugin-commonjs appropriately for this require call to work.');
+}
+
+var core$1 = {exports: {}};
+
+const __viteBrowserExternal = {};
+
+const __viteBrowserExternal$1 = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
+  __proto__: null,
+  default: __viteBrowserExternal
+}, Symbol.toStringTag, { value: 'Module' }));
+
+const require$$0 = /*@__PURE__*/getAugmentedNamespace(__viteBrowserExternal$1);
+
+var core = core$1.exports;
+
+var hasRequiredCore;
+
+function requireCore () {
+	if (hasRequiredCore) return core$1.exports;
+	hasRequiredCore = 1;
+	(function (module, exports$1) {
+(function (root, factory) {
+			{
+				// CommonJS
+				module.exports = factory();
+			}
+		}(core, function () {
+
+			/*globals window, global, require*/
+
+			/**
+			 * CryptoJS core components.
+			 */
+			var CryptoJS = CryptoJS || (function (Math, undefined$1) {
+
+			    var crypto;
+
+			    // Native crypto from window (Browser)
+			    if (typeof window !== 'undefined' && window.crypto) {
+			        crypto = window.crypto;
+			    }
+
+			    // Native crypto in web worker (Browser)
+			    if (typeof self !== 'undefined' && self.crypto) {
+			        crypto = self.crypto;
+			    }
+
+			    // Native crypto from worker
+			    if (typeof globalThis !== 'undefined' && globalThis.crypto) {
+			        crypto = globalThis.crypto;
+			    }
+
+			    // Native (experimental IE 11) crypto from window (Browser)
+			    if (!crypto && typeof window !== 'undefined' && window.msCrypto) {
+			        crypto = window.msCrypto;
+			    }
+
+			    // Native crypto from global (NodeJS)
+			    if (!crypto && typeof commonjsGlobal !== 'undefined' && commonjsGlobal.crypto) {
+			        crypto = commonjsGlobal.crypto;
+			    }
+
+			    // Native crypto import via require (NodeJS)
+			    if (!crypto && typeof commonjsRequire === 'function') {
+			        try {
+			            crypto = require$$0;
+			        } catch (err) {}
+			    }
+
+			    /*
+			     * Cryptographically secure pseudorandom number generator
+			     *
+			     * As Math.random() is cryptographically not safe to use
+			     */
+			    var cryptoSecureRandomInt = function () {
+			        if (crypto) {
+			            // Use getRandomValues method (Browser)
+			            if (typeof crypto.getRandomValues === 'function') {
+			                try {
+			                    return crypto.getRandomValues(new Uint32Array(1))[0];
+			                } catch (err) {}
+			            }
+
+			            // Use randomBytes method (NodeJS)
+			            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.');
+			    };
+
+			    /*
+			     * Local polyfill of Object.create
+
+			     */
+			    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) {
+			                // Spawn
+			                var subtype = create(this);
+
+			                // Augment
+			                if (overrides) {
+			                    subtype.mixIn(overrides);
+			                }
+
+			                // Create default initializer
+			                if (!subtype.hasOwnProperty('init') || this.init === subtype.init) {
+			                    subtype.init = function () {
+			                        subtype.$super.init.apply(this, arguments);
+			                    };
+			                }
+
+			                // Initializer's prototype is the subtype object
+			                subtype.init.prototype = subtype;
+
+			                // Reference supertype
+			                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];
+			                    }
+			                }
+
+			                // IE won't copy toString using the loop above
+			                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$1) {
+			                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) {
+			            // Shortcuts
+			            var thisWords = this.words;
+			            var thatWords = wordArray.words;
+			            var thisSigBytes = this.sigBytes;
+			            var thatSigBytes = wordArray.sigBytes;
+
+			            // Clamp excess bits
+			            this.clamp();
+
+			            // Concat
+			            if (thisSigBytes % 4) {
+			                // Copy one byte at a time
+			                for (var i = 0; i < thatSigBytes; i++) {
+			                    var thatByte = (thatWords[i >>> 2] >>> (24 - (i % 4) * 8)) & 0xff;
+			                    thisWords[(thisSigBytes + i) >>> 2] |= thatByte << (24 - ((thisSigBytes + i) % 4) * 8);
+			                }
+			            } else {
+			                // Copy one word at a time
+			                for (var j = 0; j < thatSigBytes; j += 4) {
+			                    thisWords[(thisSigBytes + j) >>> 2] = thatWords[j >>> 2];
+			                }
+			            }
+			            this.sigBytes += thatSigBytes;
+
+			            // Chainable
+			            return this;
+			        },
+
+			        /**
+			         * Removes insignificant bits.
+			         *
+			         * @example
+			         *
+			         *     wordArray.clamp();
+			         */
+			        clamp: function () {
+			            // Shortcuts
+			            var words = this.words;
+			            var sigBytes = this.sigBytes;
+
+			            // Clamp
+			            words[sigBytes >>> 2] &= 0xffffffff << (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) {
+			            // Shortcuts
+			            var words = wordArray.words;
+			            var sigBytes = wordArray.sigBytes;
+
+			            // Convert
+			            var hexChars = [];
+			            for (var i = 0; i < sigBytes; i++) {
+			                var bite = (words[i >>> 2] >>> (24 - (i % 4) * 8)) & 0xff;
+			                hexChars.push((bite >>> 4).toString(16));
+			                hexChars.push((bite & 0x0f).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) {
+			            // Shortcut
+			            var hexStrLength = hexStr.length;
+
+			            // Convert
+			            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) {
+			            // Shortcuts
+			            var words = wordArray.words;
+			            var sigBytes = wordArray.sigBytes;
+
+			            // Convert
+			            var latin1Chars = [];
+			            for (var i = 0; i < sigBytes; i++) {
+			                var bite = (words[i >>> 2] >>> (24 - (i % 4) * 8)) & 0xff;
+			                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) {
+			            // Shortcut
+			            var latin1StrLength = latin1Str.length;
+
+			            // Convert
+			            var words = [];
+			            for (var i = 0; i < latin1StrLength; i++) {
+			                words[i >>> 2] |= (latin1Str.charCodeAt(i) & 0xff) << (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 () {
+			            // Initial values
+			            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) {
+			            // Convert string to WordArray, else assume WordArray already
+			            if (typeof data == 'string') {
+			                data = Utf8.parse(data);
+			            }
+
+			            // Append
+			            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;
+
+			            // Shortcuts
+			            var data = this._data;
+			            var dataWords = data.words;
+			            var dataSigBytes = data.sigBytes;
+			            var blockSize = this.blockSize;
+			            var blockSizeBytes = blockSize * 4;
+
+			            // Count blocks ready
+			            var nBlocksReady = dataSigBytes / blockSizeBytes;
+			            if (doFlush) {
+			                // Round up to include partial blocks
+			                nBlocksReady = Math.ceil(nBlocksReady);
+			            } else {
+			                // Round down to include only full blocks,
+			                // less the number of blocks that must remain in the buffer
+			                nBlocksReady = Math.max((nBlocksReady | 0) - this._minBufferSize, 0);
+			            }
+
+			            // Count words ready
+			            var nWordsReady = nBlocksReady * blockSize;
+
+			            // Count bytes ready
+			            var nBytesReady = Math.min(nWordsReady * 4, dataSigBytes);
+
+			            // Process blocks
+			            if (nWordsReady) {
+			                for (var offset = 0; offset < nWordsReady; offset += blockSize) {
+			                    // Perform concrete-algorithm logic
+			                    this._doProcessBlock(dataWords, offset);
+			                }
+
+			                // Remove processed words
+			                processedWords = dataWords.splice(0, nWordsReady);
+			                data.sigBytes -= nBytesReady;
+			            }
+
+			            // Return processed words
+			            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
+			    });
+
+			    /**
+			     * Abstract hasher template.
+			     *
+			     * @property {number} blockSize The number of 32-bit words this hasher operates on. Default: 16 (512 bits)
+			     */
+			    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) {
+			            // Apply config defaults
+			            this.cfg = this.cfg.extend(cfg);
+
+			            // Set initial values
+			            this.reset();
+			        },
+
+			        /**
+			         * Resets this hasher to its initial state.
+			         *
+			         * @example
+			         *
+			         *     hasher.reset();
+			         */
+			        reset: function () {
+			            // Reset data buffer
+			            BufferedBlockAlgorithm.reset.call(this);
+
+			            // Perform concrete-hasher logic
+			            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) {
+			            // Append
+			            this._append(messageUpdate);
+
+			            // Update the hash
+			            this._process();
+
+			            // Chainable
+			            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) {
+			            // Final message update
+			            if (messageUpdate) {
+			                this._append(messageUpdate);
+			            }
+
+			            // Perform concrete-hasher logic
+			            var hash = this._doFinalize();
+
+			            return hash;
+			        },
+
+			        blockSize: 512/32,
+
+			        /**
+			         * 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;
+
+		})); 
+	} (core$1));
+	return core$1.exports;
+}
+
+var encBase64$1 = {exports: {}};
+
+var encBase64 = encBase64$1.exports;
+
+var hasRequiredEncBase64;
+
+function requireEncBase64 () {
+	if (hasRequiredEncBase64) return encBase64$1.exports;
+	hasRequiredEncBase64 = 1;
+	(function (module, exports$1) {
+(function (root, factory) {
+			{
+				// CommonJS
+				module.exports = factory(requireCore());
+			}
+		}(encBase64, function (CryptoJS) {
+
+			(function () {
+			    // Shortcuts
+			    var C = CryptoJS;
+			    var C_lib = C.lib;
+			    var WordArray = C_lib.WordArray;
+			    var C_enc = C.enc;
+
+			    /**
+			     * Base64 encoding strategy.
+			     */
+			    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) {
+			            // Shortcuts
+			            var words = wordArray.words;
+			            var sigBytes = wordArray.sigBytes;
+			            var map = this._map;
+
+			            // Clamp excess bits
+			            wordArray.clamp();
+
+			            // Convert
+			            var base64Chars = [];
+			            for (var i = 0; i < sigBytes; i += 3) {
+			                var byte1 = (words[i >>> 2]       >>> (24 - (i % 4) * 8))       & 0xff;
+			                var byte2 = (words[(i + 1) >>> 2] >>> (24 - ((i + 1) % 4) * 8)) & 0xff;
+			                var byte3 = (words[(i + 2) >>> 2] >>> (24 - ((i + 2) % 4) * 8)) & 0xff;
+
+			                var triplet = (byte1 << 16) | (byte2 << 8) | byte3;
+
+			                for (var j = 0; (j < 4) && (i + j * 0.75 < sigBytes); j++) {
+			                    base64Chars.push(map.charAt((triplet >>> (6 * (3 - j))) & 0x3f));
+			                }
+			            }
+
+			            // Add padding
+			            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) {
+			            // Shortcuts
+			            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;
+			                    }
+			            }
+
+			            // Ignore padding
+			            var paddingChar = map.charAt(64);
+			            if (paddingChar) {
+			                var paddingIndex = base64Str.indexOf(paddingChar);
+			                if (paddingIndex !== -1) {
+			                    base64StrLength = paddingIndex;
+			                }
+			            }
+
+			            // Convert
+			            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 bits1 = reverseMap[base64Str.charCodeAt(i - 1)] << ((i % 4) * 2);
+			              var bits2 = reverseMap[base64Str.charCodeAt(i)] >>> (6 - (i % 4) * 2);
+			              var bitsCombined = bits1 | bits2;
+			              words[nBytes >>> 2] |= bitsCombined << (24 - (nBytes % 4) * 8);
+			              nBytes++;
+			          }
+			      }
+			      return WordArray.create(words, nBytes);
+			    }
+			}());
+
+
+			return CryptoJS.enc.Base64;
+
+		})); 
+	} (encBase64$1));
+	return encBase64$1.exports;
+}
+
+var md5$1 = {exports: {}};
+
+var md5 = md5$1.exports;
+
+var hasRequiredMd5;
+
+function requireMd5 () {
+	if (hasRequiredMd5) return md5$1.exports;
+	hasRequiredMd5 = 1;
+	(function (module, exports$1) {
+(function (root, factory) {
+			{
+				// CommonJS
+				module.exports = factory(requireCore());
+			}
+		}(md5, function (CryptoJS) {
+
+			(function (Math) {
+			    // Shortcuts
+			    var C = CryptoJS;
+			    var C_lib = C.lib;
+			    var WordArray = C_lib.WordArray;
+			    var Hasher = C_lib.Hasher;
+			    var C_algo = C.algo;
+
+			    // Constants table
+			    var T = [];
+
+			    // Compute constants
+			    (function () {
+			        for (var i = 0; i < 64; i++) {
+			            T[i] = (Math.abs(Math.sin(i + 1)) * 0x100000000) | 0;
+			        }
+			    }());
+
+			    /**
+			     * MD5 hash algorithm.
+			     */
+			    var MD5 = C_algo.MD5 = Hasher.extend({
+			        _doReset: function () {
+			            this._hash = new WordArray.init([
+			                0x67452301, 0xefcdab89,
+			                0x98badcfe, 0x10325476
+			            ]);
+			        },
+
+			        _doProcessBlock: function (M, offset) {
+			            // Swap endian
+			            for (var i = 0; i < 16; i++) {
+			                // Shortcuts
+			                var offset_i = offset + i;
+			                var M_offset_i = M[offset_i];
+
+			                M[offset_i] = (
+			                    (((M_offset_i << 8)  | (M_offset_i >>> 24)) & 0x00ff00ff) |
+			                    (((M_offset_i << 24) | (M_offset_i >>> 8))  & 0xff00ff00)
+			                );
+			            }
+
+			            // Shortcuts
+			            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];
+
+			            // Working varialbes
+			            var a = H[0];
+			            var b = H[1];
+			            var c = H[2];
+			            var d = H[3];
+
+			            // Computation
+			            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]);
+
+			            // Intermediate hash value
+			            H[0] = (H[0] + a) | 0;
+			            H[1] = (H[1] + b) | 0;
+			            H[2] = (H[2] + c) | 0;
+			            H[3] = (H[3] + d) | 0;
+			        },
+
+			        _doFinalize: function () {
+			            // Shortcuts
+			            var data = this._data;
+			            var dataWords = data.words;
+
+			            var nBitsTotal = this._nDataBytes * 8;
+			            var nBitsLeft = data.sigBytes * 8;
+
+			            // Add padding
+			            dataWords[nBitsLeft >>> 5] |= 0x80 << (24 - nBitsLeft % 32);
+
+			            var nBitsTotalH = Math.floor(nBitsTotal / 0x100000000);
+			            var nBitsTotalL = nBitsTotal;
+			            dataWords[(((nBitsLeft + 64) >>> 9) << 4) + 15] = (
+			                (((nBitsTotalH << 8)  | (nBitsTotalH >>> 24)) & 0x00ff00ff) |
+			                (((nBitsTotalH << 24) | (nBitsTotalH >>> 8))  & 0xff00ff00)
+			            );
+			            dataWords[(((nBitsLeft + 64) >>> 9) << 4) + 14] = (
+			                (((nBitsTotalL << 8)  | (nBitsTotalL >>> 24)) & 0x00ff00ff) |
+			                (((nBitsTotalL << 24) | (nBitsTotalL >>> 8))  & 0xff00ff00)
+			            );
+
+			            data.sigBytes = (dataWords.length + 1) * 4;
+
+			            // Hash final blocks
+			            this._process();
+
+			            // Shortcuts
+			            var hash = this._hash;
+			            var H = hash.words;
+
+			            // Swap endian
+			            for (var i = 0; i < 4; i++) {
+			                // Shortcut
+			                var H_i = H[i];
+
+			                H[i] = (((H_i << 8)  | (H_i >>> 24)) & 0x00ff00ff) |
+			                       (((H_i << 24) | (H_i >>> 8))  & 0xff00ff00);
+			            }
+
+			            // Return final computed hash
+			            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;
+
+		})); 
+	} (md5$1));
+	return md5$1.exports;
+}
+
+var evpkdf$1 = {exports: {}};
+
+var sha1$1 = {exports: {}};
+
+var sha1 = sha1$1.exports;
+
+var hasRequiredSha1;
+
+function requireSha1 () {
+	if (hasRequiredSha1) return sha1$1.exports;
+	hasRequiredSha1 = 1;
+	(function (module, exports$1) {
+(function (root, factory) {
+			{
+				// CommonJS
+				module.exports = factory(requireCore());
+			}
+		}(sha1, function (CryptoJS) {
+
+			(function () {
+			    // Shortcuts
+			    var C = CryptoJS;
+			    var C_lib = C.lib;
+			    var WordArray = C_lib.WordArray;
+			    var Hasher = C_lib.Hasher;
+			    var C_algo = C.algo;
+
+			    // Reusable object
+			    var W = [];
+
+			    /**
+			     * SHA-1 hash algorithm.
+			     */
+			    var SHA1 = C_algo.SHA1 = Hasher.extend({
+			        _doReset: function () {
+			            this._hash = new WordArray.init([
+			                0x67452301, 0xefcdab89,
+			                0x98badcfe, 0x10325476,
+			                0xc3d2e1f0
+			            ]);
+			        },
+
+			        _doProcessBlock: function (M, offset) {
+			            // Shortcut
+			            var H = this._hash.words;
+
+			            // Working variables
+			            var a = H[0];
+			            var b = H[1];
+			            var c = H[2];
+			            var d = H[3];
+			            var e = H[4];
+
+			            // Computation
+			            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)) + 0x5a827999;
+			                } else if (i < 40) {
+			                    t += (b ^ c ^ d) + 0x6ed9eba1;
+			                } else if (i < 60) {
+			                    t += ((b & c) | (b & d) | (c & d)) - 0x70e44324;
+			                } else /* if (i < 80) */ {
+			                    t += (b ^ c ^ d) - 0x359d3e2a;
+			                }
+
+			                e = d;
+			                d = c;
+			                c = (b << 30) | (b >>> 2);
+			                b = a;
+			                a = t;
+			            }
+
+			            // Intermediate hash value
+			            H[0] = (H[0] + a) | 0;
+			            H[1] = (H[1] + b) | 0;
+			            H[2] = (H[2] + c) | 0;
+			            H[3] = (H[3] + d) | 0;
+			            H[4] = (H[4] + e) | 0;
+			        },
+
+			        _doFinalize: function () {
+			            // Shortcuts
+			            var data = this._data;
+			            var dataWords = data.words;
+
+			            var nBitsTotal = this._nDataBytes * 8;
+			            var nBitsLeft = data.sigBytes * 8;
+
+			            // Add padding
+			            dataWords[nBitsLeft >>> 5] |= 0x80 << (24 - nBitsLeft % 32);
+			            dataWords[(((nBitsLeft + 64) >>> 9) << 4) + 14] = Math.floor(nBitsTotal / 0x100000000);
+			            dataWords[(((nBitsLeft + 64) >>> 9) << 4) + 15] = nBitsTotal;
+			            data.sigBytes = dataWords.length * 4;
+
+			            // Hash final blocks
+			            this._process();
+
+			            // Return final computed hash
+			            return this._hash;
+			        },
+
+			        clone: function () {
+			            var clone = Hasher.clone.call(this);
+			            clone._hash = this._hash.clone();
+
+			            return clone;
+			        }
+			    });
+
+			    /**
+			     * Shortcut function to the hasher's object interface.
+			     *
+			     * @param {WordArray|string} message The message to hash.
+			     *
+			     * @return {WordArray} The hash.
+			     *
+			     * @static
+			     *
+			     * @example
+			     *
+			     *     var hash = CryptoJS.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;
+
+		})); 
+	} (sha1$1));
+	return sha1$1.exports;
+}
+
+var hmac$1 = {exports: {}};
+
+var hmac = hmac$1.exports;
+
+var hasRequiredHmac;
+
+function requireHmac () {
+	if (hasRequiredHmac) return hmac$1.exports;
+	hasRequiredHmac = 1;
+	(function (module, exports$1) {
+(function (root, factory) {
+			{
+				// CommonJS
+				module.exports = factory(requireCore());
+			}
+		}(hmac, function (CryptoJS) {
+
+			(function () {
+			    // Shortcuts
+			    var C = CryptoJS;
+			    var C_lib = C.lib;
+			    var Base = C_lib.Base;
+			    var C_enc = C.enc;
+			    var Utf8 = C_enc.Utf8;
+			    var C_algo = C.algo;
+
+			    /**
+			     * HMAC algorithm.
+			     */
+			    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) {
+			            // Init hasher
+			            hasher = this._hasher = new hasher.init();
+
+			            // Convert string to WordArray, else assume WordArray already
+			            if (typeof key == 'string') {
+			                key = Utf8.parse(key);
+			            }
+
+			            // Shortcuts
+			            var hasherBlockSize = hasher.blockSize;
+			            var hasherBlockSizeBytes = hasherBlockSize * 4;
+
+			            // Allow arbitrary length keys
+			            if (key.sigBytes > hasherBlockSizeBytes) {
+			                key = hasher.finalize(key);
+			            }
+
+			            // Clamp excess bits
+			            key.clamp();
+
+			            // Clone key for inner and outer pads
+			            var oKey = this._oKey = key.clone();
+			            var iKey = this._iKey = key.clone();
+
+			            // Shortcuts
+			            var oKeyWords = oKey.words;
+			            var iKeyWords = iKey.words;
+
+			            // XOR keys with pad constants
+			            for (var i = 0; i < hasherBlockSize; i++) {
+			                oKeyWords[i] ^= 0x5c5c5c5c;
+			                iKeyWords[i] ^= 0x36363636;
+			            }
+			            oKey.sigBytes = iKey.sigBytes = hasherBlockSizeBytes;
+
+			            // Set initial values
+			            this.reset();
+			        },
+
+			        /**
+			         * Resets this HMAC to its initial state.
+			         *
+			         * @example
+			         *
+			         *     hmacHasher.reset();
+			         */
+			        reset: function () {
+			            // Shortcut
+			            var hasher = this._hasher;
+
+			            // Reset
+			            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);
+
+			            // Chainable
+			            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) {
+			            // Shortcut
+			            var hasher = this._hasher;
+
+			            // Compute HMAC
+			            var innerHash = hasher.finalize(messageUpdate);
+			            hasher.reset();
+			            var hmac = hasher.finalize(this._oKey.clone().concat(innerHash));
+
+			            return hmac;
+			        }
+			    });
+			}());
+
+
+		})); 
+	} (hmac$1));
+	return hmac$1.exports;
+}
+
+var evpkdf = evpkdf$1.exports;
+
+var hasRequiredEvpkdf;
+
+function requireEvpkdf () {
+	if (hasRequiredEvpkdf) return evpkdf$1.exports;
+	hasRequiredEvpkdf = 1;
+	(function (module, exports$1) {
+(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;
+}
+
+var cipherCore$1 = {exports: {}};
+
+var cipherCore = cipherCore$1.exports;
+
+var hasRequiredCipherCore;
+
+function requireCipherCore () {
+	if (hasRequiredCipherCore) return cipherCore$1.exports;
+	hasRequiredCipherCore = 1;
+	(function (module, exports$1) {
+(function (root, factory, undef) {
+			{
+				// CommonJS
+				module.exports = factory(requireCore(), requireEvpkdf());
+			}
+		}(cipherCore, function (CryptoJS) {
+
+			/**
+			 * Cipher core components.
+			 */
+			CryptoJS.lib.Cipher || (function (undefined$1) {
+			    // Shortcuts
+			    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 C_algo = C.algo;
+			    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) {
+			            // Apply config defaults
+			            this.cfg = this.cfg.extend(cfg);
+
+			            // Store transform mode and key
+			            this._xformMode = xformMode;
+			            this._key = key;
+
+			            // Set initial values
+			            this.reset();
+			        },
+
+			        /**
+			         * Resets this cipher to its initial state.
+			         *
+			         * @example
+			         *
+			         *     cipher.reset();
+			         */
+			        reset: function () {
+			            // Reset data buffer
+			            BufferedBlockAlgorithm.reset.call(this);
+
+			            // Perform concrete-cipher logic
+			            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) {
+			            // Append
+			            this._append(dataUpdate);
+
+			            // Process available blocks
+			            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) {
+			            // Final data update
+			            if (dataUpdate) {
+			                this._append(dataUpdate);
+			            }
+
+			            // Perform concrete-cipher logic
+			            var finalProcessedData = this._doFinalize();
+
+			            return finalProcessedData;
+			        },
+
+			        keySize: 128/32,
+
+			        ivSize: 128/32,
+
+			        _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);
+			                    }
+			                };
+			            };
+			        }())
+			    });
+
+			    /**
+			     * Abstract base stream cipher template.
+			     *
+			     * @property {number} blockSize The number of 32-bit words this cipher operates on. Default: 1 (32 bits)
+			     */
+			    C_lib.StreamCipher = Cipher.extend({
+			        _doFinalize: function () {
+			            // Process partial blocks
+			            var finalProcessedBlocks = this._process(true);
+
+			            return finalProcessedBlocks;
+			        },
+
+			        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) {
+			                // Shortcuts
+			                var cipher = this._cipher;
+			                var blockSize = cipher.blockSize;
+
+			                // XOR and encrypt
+			                xorBlock.call(this, words, offset, blockSize);
+			                cipher.encryptBlock(words, offset);
+
+			                // Remember this block to use with next block
+			                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) {
+			                // Shortcuts
+			                var cipher = this._cipher;
+			                var blockSize = cipher.blockSize;
+
+			                // Remember this block to use with next block
+			                var thisBlock = words.slice(offset, offset + blockSize);
+
+			                // Decrypt and XOR
+			                cipher.decryptBlock(words, offset);
+			                xorBlock.call(this, words, offset, blockSize);
+
+			                // This block becomes the previous block
+			                this._prevBlock = thisBlock;
+			            }
+			        });
+
+			        function xorBlock(words, offset, blockSize) {
+			            var block;
+
+			            // Shortcut
+			            var iv = this._iv;
+
+			            // Choose mixing block
+			            if (iv) {
+			                block = iv;
+
+			                // Remove IV for subsequent blocks
+			                this._iv = undefined$1;
+			            } else {
+			                block = this._prevBlock;
+			            }
+
+			            // XOR blocks
+			            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) {
+			            // Shortcut
+			            var blockSizeBytes = blockSize * 4;
+
+			            // Count padding bytes
+			            var nPaddingBytes = blockSizeBytes - data.sigBytes % blockSizeBytes;
+
+			            // Create padding word
+			            var paddingWord = (nPaddingBytes << 24) | (nPaddingBytes << 16) | (nPaddingBytes << 8) | nPaddingBytes;
+
+			            // Create padding
+			            var paddingWords = [];
+			            for (var i = 0; i < nPaddingBytes; i += 4) {
+			                paddingWords.push(paddingWord);
+			            }
+			            var padding = WordArray.create(paddingWords, nPaddingBytes);
+
+			            // Add padding
+			            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) {
+			            // Get number of padding bytes from last byte
+			            var nPaddingBytes = data.words[(data.sigBytes - 1) >>> 2] & 0xff;
+
+			            // Remove padding
+			            data.sigBytes -= nPaddingBytes;
+			        }
+			    };
+
+			    /**
+			     * Abstract base block cipher template.
+			     *
+			     * @property {number} blockSize The number of 32-bit words this cipher operates on. Default: 4 (128 bits)
+			     */
+			    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;
+
+			            // Reset cipher
+			            Cipher.reset.call(this);
+
+			            // Shortcuts
+			            var cfg = this.cfg;
+			            var iv = cfg.iv;
+			            var mode = cfg.mode;
+
+			            // Reset block mode
+			            if (this._xformMode == this._ENC_XFORM_MODE) {
+			                modeCreator = mode.createEncryptor;
+			            } else /* if (this._xformMode == this._DEC_XFORM_MODE) */ {
+			                modeCreator = mode.createDecryptor;
+			                // Keep at least one block in the buffer for unpadding
+			                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;
+
+			            // Shortcut
+			            var padding = this.cfg.padding;
+
+			            // Finalize
+			            if (this._xformMode == this._ENC_XFORM_MODE) {
+			                // Pad data
+			                padding.pad(this._data, this.blockSize);
+
+			                // Process final blocks
+			                finalProcessedBlocks = this._process(true);
+			            } else /* if (this._xformMode == this._DEC_XFORM_MODE) */ {
+			                // Process final blocks
+			                finalProcessedBlocks = this._process(true);
+
+			                // Unpad data
+			                padding.unpad(finalProcessedBlocks);
+			            }
+
+			            return finalProcessedBlocks;
+			        },
+
+			        blockSize: 128/32
+			    });
+
+			    /**
+			     * 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;
+
+			            // Shortcuts
+			            var ciphertext = cipherParams.ciphertext;
+			            var salt = cipherParams.salt;
+
+			            // Format
+			            if (salt) {
+			                wordArray = WordArray.create([0x53616c74, 0x65645f5f]).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;
+
+			            // Parse base64
+			            var ciphertext = Base64.parse(openSSLStr);
+
+			            // Shortcut
+			            var ciphertextWords = ciphertext.words;
+
+			            // Test for salt
+			            if (ciphertextWords[0] == 0x53616c74 && ciphertextWords[1] == 0x65645f5f) {
+			                // Extract salt
+			                salt = WordArray.create(ciphertextWords.slice(2, 4));
+
+			                // Remove salt from ciphertext
+			                ciphertextWords.splice(0, 4);
+			                ciphertext.sigBytes -= 16;
+			            }
+
+			            return CipherParams.create({ ciphertext: ciphertext, salt: 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) {
+			            // Apply config defaults
+			            cfg = this.cfg.extend(cfg);
+
+			            // Encrypt
+			            var encryptor = cipher.createEncryptor(key, cfg);
+			            var ciphertext = encryptor.finalize(message);
+
+			            // Shortcut
+			            var cipherCfg = encryptor.cfg;
+
+			            // Create and return serializable cipher params
+			            return CipherParams.create({
+			                ciphertext: ciphertext,
+			                key: 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) {
+			            // Apply config defaults
+			            cfg = this.cfg.extend(cfg);
+
+			            // Convert string to CipherParams
+			            ciphertext = this._parse(ciphertext, cfg.format);
+
+			            // Decrypt
+			            var plaintext = cipher.createDecryptor(key, cfg).finalize(ciphertext.ciphertext);
+
+			            return plaintext;
+			        },
+
+			        /**
+			         * 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) {
+			            // Generate random salt
+			            if (!salt) {
+			                salt = WordArray.random(64/8);
+			            }
+
+			            // Derive key and IV
+			            var key = EvpKDF.create({ keySize: keySize + ivSize }).compute(password, salt);
+
+			            // Separate key and IV
+			            var iv = WordArray.create(key.words.slice(keySize), ivSize * 4);
+			            key.sigBytes = keySize * 4;
+
+			            // Return params
+			            return CipherParams.create({ key: key, iv: iv, salt: 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) {
+			            // Apply config defaults
+			            cfg = this.cfg.extend(cfg);
+
+			            // Derive key and other params
+			            var derivedParams = cfg.kdf.execute(password, cipher.keySize, cipher.ivSize);
+
+			            // Add IV to config
+			            cfg.iv = derivedParams.iv;
+
+			            // Encrypt
+			            var ciphertext = SerializableCipher.encrypt.call(this, cipher, message, derivedParams.key, cfg);
+
+			            // Mix in derived params
+			            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) {
+			            // Apply config defaults
+			            cfg = this.cfg.extend(cfg);
+
+			            // Convert string to CipherParams
+			            ciphertext = this._parse(ciphertext, cfg.format);
+
+			            // Derive key and other params
+			            var derivedParams = cfg.kdf.execute(password, cipher.keySize, cipher.ivSize, ciphertext.salt);
+
+			            // Add IV to config
+			            cfg.iv = derivedParams.iv;
+
+			            // Decrypt
+			            var plaintext = SerializableCipher.decrypt.call(this, cipher, ciphertext, derivedParams.key, cfg);
+
+			            return plaintext;
+			        }
+			    });
+			}());
+
+
+		})); 
+	} (cipherCore$1));
+	return cipherCore$1.exports;
+}
+
+var aes = aes$1.exports;
+
+var hasRequiredAes;
+
+function requireAes () {
+	if (hasRequiredAes) return aes$1.exports;
+	hasRequiredAes = 1;
+	(function (module, exports$1) {
+(function (root, factory, undef) {
+			{
+				// CommonJS
+				module.exports = factory(requireCore(), requireEncBase64(), requireMd5(), requireEvpkdf(), requireCipherCore());
+			}
+		}(aes, function (CryptoJS) {
+
+			(function () {
+			    // Shortcuts
+			    var C = CryptoJS;
+			    var C_lib = C.lib;
+			    var BlockCipher = C_lib.BlockCipher;
+			    var C_algo = C.algo;
+
+			    // Lookup tables
+			    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 = [];
+
+			    // Compute lookup tables
+			    (function () {
+			        // Compute double table
+			        var d = [];
+			        for (var i = 0; i < 256; i++) {
+			            if (i < 128) {
+			                d[i] = i << 1;
+			            } else {
+			                d[i] = (i << 1) ^ 0x11b;
+			            }
+			        }
+
+			        // Walk GF(2^8)
+			        var x = 0;
+			        var xi = 0;
+			        for (var i = 0; i < 256; i++) {
+			            // Compute sbox
+			            var sx = xi ^ (xi << 1) ^ (xi << 2) ^ (xi << 3) ^ (xi << 4);
+			            sx = (sx >>> 8) ^ (sx & 0xff) ^ 0x63;
+			            SBOX[x] = sx;
+			            INV_SBOX[sx] = x;
+
+			            // Compute multiplication
+			            var x2 = d[x];
+			            var x4 = d[x2];
+			            var x8 = d[x4];
+
+			            // Compute sub bytes, mix columns tables
+			            var t = (d[sx] * 0x101) ^ (sx * 0x1010100);
+			            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;
+
+			            // Compute inv sub bytes, inv mix columns tables
+			            var t = (x8 * 0x1010101) ^ (x4 * 0x10001) ^ (x2 * 0x101) ^ (x * 0x1010100);
+			            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;
+
+			            // Compute next counter
+			            if (!x) {
+			                x = xi = 1;
+			            } else {
+			                x = x2 ^ d[d[d[x8 ^ x2]]];
+			                xi ^= d[d[xi]];
+			            }
+			        }
+			    }());
+
+			    // Precomputed Rcon lookup
+			    var RCON = [0x00, 0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36];
+
+			    /**
+			     * AES block cipher algorithm.
+			     */
+			    var AES = C_algo.AES = BlockCipher.extend({
+			        _doReset: function () {
+			            var t;
+
+			            // Skip reset of nRounds has been set before and key did not change
+			            if (this._nRounds && this._keyPriorReset === this._key) {
+			                return;
+			            }
+
+			            // Shortcuts
+			            var key = this._keyPriorReset = this._key;
+			            var keyWords = key.words;
+			            var keySize = key.sigBytes / 4;
+
+			            // Compute number of rounds
+			            var nRounds = this._nRounds = keySize + 6;
+
+			            // Compute number of key schedule rows
+			            var ksRows = (nRounds + 1) * 4;
+
+			            // Compute key schedule
+			            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)) {
+			                        // Rot word
+			                        t = (t << 8) | (t >>> 24);
+
+			                        // Sub word
+			                        t = (SBOX[t >>> 24] << 24) | (SBOX[(t >>> 16) & 0xff] << 16) | (SBOX[(t >>> 8) & 0xff] << 8) | SBOX[t & 0xff];
+
+			                        // Mix Rcon
+			                        t ^= RCON[(ksRow / keySize) | 0] << 24;
+			                    } else if (keySize > 6 && ksRow % keySize == 4) {
+			                        // Sub word
+			                        t = (SBOX[t >>> 24] << 24) | (SBOX[(t >>> 16) & 0xff] << 16) | (SBOX[(t >>> 8) & 0xff] << 8) | SBOX[t & 0xff];
+			                    }
+
+			                    keySchedule[ksRow] = keySchedule[ksRow - keySize] ^ t;
+			                }
+			            }
+
+			            // Compute inv key schedule
+			            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) & 0xff]] ^
+			                                               INV_SUB_MIX_2[SBOX[(t >>> 8) & 0xff]] ^ INV_SUB_MIX_3[SBOX[t & 0xff]];
+			                }
+			            }
+			        },
+
+			        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) {
+			            // Swap 2nd and 4th rows
+			            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);
+
+			            // Inv swap 2nd and 4th rows
+			            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) {
+			            // Shortcut
+			            var nRounds = this._nRounds;
+
+			            // Get input, add round key
+			            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];
+
+			            // Key schedule row counter
+			            var ksRow = 4;
+
+			            // Rounds
+			            for (var round = 1; round < nRounds; round++) {
+			                // Shift rows, sub bytes, mix columns, add round key
+			                var t0 = SUB_MIX_0[s0 >>> 24] ^ SUB_MIX_1[(s1 >>> 16) & 0xff] ^ SUB_MIX_2[(s2 >>> 8) & 0xff] ^ SUB_MIX_3[s3 & 0xff] ^ keySchedule[ksRow++];
+			                var t1 = SUB_MIX_0[s1 >>> 24] ^ SUB_MIX_1[(s2 >>> 16) & 0xff] ^ SUB_MIX_2[(s3 >>> 8) & 0xff] ^ SUB_MIX_3[s0 & 0xff] ^ keySchedule[ksRow++];
+			                var t2 = SUB_MIX_0[s2 >>> 24] ^ SUB_MIX_1[(s3 >>> 16) & 0xff] ^ SUB_MIX_2[(s0 >>> 8) & 0xff] ^ SUB_MIX_3[s1 & 0xff] ^ keySchedule[ksRow++];
+			                var t3 = SUB_MIX_0[s3 >>> 24] ^ SUB_MIX_1[(s0 >>> 16) & 0xff] ^ SUB_MIX_2[(s1 >>> 8) & 0xff] ^ SUB_MIX_3[s2 & 0xff] ^ keySchedule[ksRow++];
+
+			                // Update state
+			                s0 = t0;
+			                s1 = t1;
+			                s2 = t2;
+			                s3 = t3;
+			            }
+
+			            // Shift rows, sub bytes, add round key
+			            var t0 = ((SBOX[s0 >>> 24] << 24) | (SBOX[(s1 >>> 16) & 0xff] << 16) | (SBOX[(s2 >>> 8) & 0xff] << 8) | SBOX[s3 & 0xff]) ^ keySchedule[ksRow++];
+			            var t1 = ((SBOX[s1 >>> 24] << 24) | (SBOX[(s2 >>> 16) & 0xff] << 16) | (SBOX[(s3 >>> 8) & 0xff] << 8) | SBOX[s0 & 0xff]) ^ keySchedule[ksRow++];
+			            var t2 = ((SBOX[s2 >>> 24] << 24) | (SBOX[(s3 >>> 16) & 0xff] << 16) | (SBOX[(s0 >>> 8) & 0xff] << 8) | SBOX[s1 & 0xff]) ^ keySchedule[ksRow++];
+			            var t3 = ((SBOX[s3 >>> 24] << 24) | (SBOX[(s0 >>> 16) & 0xff] << 16) | (SBOX[(s1 >>> 8) & 0xff] << 8) | SBOX[s2 & 0xff]) ^ keySchedule[ksRow++];
+
+			            // Set output
+			            M[offset]     = t0;
+			            M[offset + 1] = t1;
+			            M[offset + 2] = t2;
+			            M[offset + 3] = t3;
+			        },
+
+			        keySize: 256/32
+			    });
+
+			    /**
+			     * 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;
+
+		})); 
+	} (aes$1));
+	return aes$1.exports;
+}
+
+var aesExports = requireAes();
+const AES = /*@__PURE__*/getDefaultExportFromCjs(aesExports);
+
+var encUtf8$2 = {exports: {}};
+
+var encUtf8$1 = encUtf8$2.exports;
+
+var hasRequiredEncUtf8;
+
+function requireEncUtf8 () {
+	if (hasRequiredEncUtf8) return encUtf8$2.exports;
+	hasRequiredEncUtf8 = 1;
+	(function (module, exports$1) {
+(function (root, factory) {
+			{
+				// CommonJS
+				module.exports = factory(requireCore());
+			}
+		}(encUtf8$1, function (CryptoJS) {
+
+			return CryptoJS.enc.Utf8;
+
+		})); 
+	} (encUtf8$2));
+	return encUtf8$2.exports;
+}
+
+var encUtf8Exports = requireEncUtf8();
+const encUtf8 = /*@__PURE__*/getDefaultExportFromCjs(encUtf8Exports);
+
+const defaultImageOption = {
+    format: 'image/png',
+    quality: 1,
+};
+// canvas转dataURL，todo：测试
+const canvasToDataURL = (canvas, option) => {
+    const myOption = { ...defaultImageOption, ...option };
+    return canvas.toDataURL(myOption.format, myOption.quality);
+};
+// img转canvas，可以是dataurl/src，todo：测试
+const imageToCanvas = (data) => new Promise((resolve, reject) => {
+    const canvas = document.createElement('CANVAS');
+    const ctx = canvas.getContext('2d');
+    const img = new Image();
+    img.onload = () => {
+        if (!ctx) {
+            return;
+        }
+        canvas.width = img.width;
+        canvas.height = img.height;
+        ctx.drawImage(img, 0, 0);
+        resolve(canvas);
+    };
+    img.onerror = () => {
+        reject(new Error('图片加载错误'));
+    };
+    img.src = data;
+});
+// canvas转image，todo：测试
+const canvasToImage = (canvas, option) => {
+    const img = new Image();
+    img.src = canvasToDataURL(canvas, option);
+    return img;
+};
+// File/Blob对象转DataURL，todo：测试
+const fileOrBlobToDataURL = (obj) => new Promise((resolve, reject) => {
+    const file = new FileReader();
+    file.readAsDataURL(obj);
+    file.onload = e => {
+        if (e.target && e.target.result) {
+            resolve(e.target.result);
+        }
+        else {
+            reject(new Error('文件加载失败'));
+        }
+    };
+    file.onerror = () => {
+        reject(new Error('文件加载错误'));
+    };
+});
+const dataURLtoUint8Array = (dataurl) => {
+    const arr = dataurl.split(',');
+    const match = arr[0].match(/:(.*?);/);
+    if (!match) {
+        throw new Error('dataURL数据错误');
+    }
+    const mime = match[1];
+    const bstr = atob(arr[1]);
+    let n = bstr.length;
+    const u8arr = new Uint8Array(n);
+    while (n--) {
+        u8arr[n] = bstr.charCodeAt(n);
+    }
+    return { uint8Array: u8arr, type: mime };
+};
+// DataURL转Blob对象，todo：测试
+const dataURLToBlob = (dataurl) => {
+    const data = dataURLtoUint8Array(dataurl);
+    return new Blob([data.uint8Array], { type: data.type });
+};
+// DataURL转File对象，todo：测试
+const dataURLToFile = (dataurl, fileName) => {
+    const data = dataURLtoUint8Array(dataurl);
+    return new File([data.uint8Array], fileName, { type: data.type });
+};
+const blobToFile = (blob, fileName) => new File([blob], fileName, { type: blob.type, lastModified: Date.now() });
+// Blob转image，todo：测试
+const blobToImage = (blob) => new Promise((resolve, reject) => {
+    fileOrBlobToDataURL(blob).then(dataurl => {
+        const img = new Image();
+        img.src = dataurl;
+        resolve(img);
+    }).then(e => reject(e));
+});
+// image转Blob，todo：测试
+const imageToBlob = (data) => new Promise((resolve, reject) => {
+    imageToCanvas(data).then(canvas => {
+        resolve(dataURLToBlob(canvasToDataURL(canvas)));
+    }).catch(e => reject(e));
+});
+// Blob图片转canvas，todo：测试
+const blobToCanvas = (blob) => new Promise((resolve, reject) => {
+    fileOrBlobToDataURL(blob).then(dataurl => {
+        imageToCanvas(dataurl)
+            .then(canvas => resolve(canvas))
+            .catch(e => reject(e));
+    }).catch(e => reject(e));
+});
+// canvas图片转Blob，todo：测试
+const canvasToBlob = (canvas) => dataURLToBlob(canvasToDataURL(canvas));
+// image（url/dataurl）转dataURL，todo：测试
+const imageToDataURL = (data) => new Promise((resolve, reject) => {
+    imageToCanvas(data)
+        .then(canvas => resolve(canvasToDataURL(canvas)))
+        .catch(e => reject(e));
+});
+// dataURL转image，todo：测试
+const dataURLToImage = (dataurl) => {
+    const img = new Image();
+    img.src = dataurl;
+    return img;
+};
+// 字符串转ArrayBuffer，todo：测试
+const stringToArrayBuffer = (s) => {
+    const buf = new ArrayBuffer(s.length);
+    const view = new Uint8Array(buf);
+    for (let i = 0; i !== s.length; i += 1) {
+        view[i] = s.charCodeAt(i) & 0xFF;
+    }
+    return buf;
+};
+var file = {
+    canvasToDataURL,
+    imageToCanvas,
+    canvasToImage,
+    fileOrBlobToDataURL,
+    dataURLtoUint8Array,
+    dataURLToBlob,
+    dataURLToFile,
+    blobToImage,
+    imageToBlob,
+    blobToCanvas,
+    blobToFile,
+    canvasToBlob,
+    imageToDataURL,
+    dataURLToImage,
+    stringToArrayBuffer,
+};
+
+const isClient = typeof window !== 'undefined';
+const defaultWindow =  isClient ? window : undefined;
+
+const SECRET_KEY = 'THIS_IS_SECRET';
+// 带有效期的localStorage
+// 删除指定的localStorge
+function remove(key, option) {
+    const { instance = localStorage } = option || {};
+    instance.removeItem(key);
+}
+// 设置localStorge
+function set(key, value, option) {
+    const { expires, encrypt, secret, instance = localStorage } = option || {};
+    let type = 'undefined';
+    isNumber(expires) && (type = 'number');
+    isDate(expires) && (type = 'date');
+    const createAt = new Date().getTime();
+    const val = encrypt ? AES.encrypt(JSON.stringify(value), secret || SECRET_KEY).toString() : value;
+    const item = {
+        val,
+        type,
+        createAt,
+        encrypt: !!encrypt,
+    };
+    const handle = {
+        date: () => { item.expires = new Date(expires).getTime(); },
+        number: () => { item.expires = expires ? +expires : 99999; },
+    };
+    handle[type] && handle[type]();
+    instance.setItem(key, JSON.stringify(item));
+}
+// 获取localStorge
+function get(key, option) {
+    const { secret, instance = localStorage } = option || {};
+    const val = instance.getItem(key);
+    if (val === null) {
+        return undefined;
+    }
+    const item = JSON.parse(val); // 未做类型转换
+    let result = undefined;
+    const handle = {
+        date() {
+            if (new Date() > new Date(item.expires)) { // 过期
+                remove(key);
+                result = undefined;
+            }
+            else {
+                result = item.val;
+            }
+        },
+        number() {
+            const ss = (new Date().getTime() - item.createAt) / 1000;
+            if (ss > +item.expires) { // 过期
+                remove(key);
+                result = undefined;
+            }
+            else {
+                result = item.val;
+            }
+        },
+        undefined() {
+            result = item.val;
+        },
+    };
+    handle[item.type] && handle[item.type]();
+    if (!result) {
+        return undefined;
+    }
+    try {
+        result = item.encrypt ? JSON.parse(AES.decrypt(result, secret || SECRET_KEY).toString(encUtf8)) : result;
+    }
+    catch (err) {
+        console.warn(err);
+        result = undefined;
+    }
+    return result;
+}
+const info = () => {
+    const count = (instance) => {
+        let size = 0;
+        for (const item in instance) {
+            if (Object.prototype.hasOwnProperty.call(instance, item)) {
+                size += instance.getItem(item)?.length || 0;
+            }
+        }
+        return `${(size / 1024).toFixed(2)} KB`;
+    };
+    const totalSpace = () => new Promise(resolve => {
+        let test = '0123456789';
+        do {
+            test += test;
+        } while (test.length < 10240);
+        let sum = test;
+        const timer = setInterval(() => {
+            sum += test;
+            try {
+                if (defaultWindow) {
+                    defaultWindow.localStorage.removeItem('test-storage-space');
+                    defaultWindow.localStorage.setItem('test-storage-space', sum);
+                }
+            }
+            catch {
+                resolve(`${sum.length / 1024} KB`);
+                clearInterval(timer);
+            }
+        }, 0);
+    });
+    return {
+        sessionSpace: count(sessionStorage),
+        localSpace: count(localStorage),
+        totalSpace,
+    };
+};
+var storage = {
+    set,
+    get,
+    remove,
+    info,
+};
+
+const baseCdnUrl = {
+    jsdelivr: '//cdn.jsdelivr.net/npm',
+    defaultBase: defaultWindow ? (defaultWindow.h_utils?.cdn?.host || '//cdn.staticfile.org') : '',
+    localCDN: defaultWindow ? (defaultWindow.h_utils?.cdn?.path || '/local-cdn') : '',
+};
+const cdnMapping = {
+    // 全屏
+    screenfull: (version = '5.2.0') => ({
+        version,
+        instance: () => defaultWindow ? defaultWindow.screenfull : undefined,
+        source: {
+            jsdelivr: { js: [`${baseCdnUrl.jsdelivr}/screenfull@${version}`] },
+            defaultBase: { js: [`${baseCdnUrl.defaultBase}/screenfull.js/${version}/screenfull.min.js`] },
+            localCDN: { js: [`${baseCdnUrl.localCDN}/screenfull/${version}/screenfull.min.js`] },
+        },
+    }),
+    // 复制黏贴
+    clipboard: (version = '2.0.8') => ({
+        version,
+        instance: () => defaultWindow ? defaultWindow.ClipboardJS : undefined,
+        source: {
+            jsdelivr: { js: [`${baseCdnUrl.jsdelivr}/clipboard@${version}`] },
+            defaultBase: { js: [`${baseCdnUrl.defaultBase}/clipboard.js/${version}/clipboard.min.js`] },
+            localCDN: { js: [`${baseCdnUrl.localCDN}/clipboard/${version}/clipboard.min.js`] },
+        },
+    }),
+    // 富文本编辑器
+    tinymce: (version = '5.8.1') => ({
+        version,
+        instance: () => defaultWindow ? defaultWindow.tinyMCE : undefined,
+        source: {
+            jsdelivr: { js: [`${baseCdnUrl.jsdelivr}/tinymce@${version}`] },
+            defaultBase: { js: [`${baseCdnUrl.defaultBase}/tinymce/${version}/tinymce.min.js`] },
+            localCDN: { js: [`${baseCdnUrl.localCDN}/tinymce/${version}/tinymce.min.js`] },
+        },
+    }),
+    // 二维码生成
+    qrcodeGe: (version = '1.4.4') => ({
+        version,
+        instance: () => defaultWindow ? defaultWindow.qrcode : undefined,
+        source: {
+            jsdelivr: { js: [`${baseCdnUrl.jsdelivr}/qrcode-generator@${version}`] },
+            defaultBase: { js: [`${baseCdnUrl.defaultBase}/qrcode-generator/${version}/qrcode.min.js`] },
+            localCDN: { js: [`${baseCdnUrl.localCDN}/qrcode-generator/${version}/qrcode.min.js`] },
+        },
+    }),
+    // 二维码生成
+    QRCode: (version = '1.5.1') => ({
+        version,
+        instance: () => defaultWindow ? defaultWindow.QRCode : undefined,
+        source: {
+            jsdelivr: { js: [`${baseCdnUrl.jsdelivr}/qrcode@${version}/build/qrcode.min.js`] },
+            defaultBase: { js: [`${baseCdnUrl.defaultBase}/qrcodejs/${version}/qrcode.min.js`] },
+            localCDN: { js: [`${baseCdnUrl.localCDN}/qrcode/${version}/qrcode.min.js`] },
+        },
+    }),
+    // 千分位
+    cleave: (version = '1.6.0') => ({
+        version,
+        instance: () => defaultWindow ? defaultWindow.Cleave : undefined,
+        source: {
+            jsdelivr: { js: [`${baseCdnUrl.jsdelivr}/cleave.js@${version}`] },
+            defaultBase: { js: [`${baseCdnUrl.defaultBase}/cleave.js/${version}/cleave.min.js`] },
+            localCDN: { js: [`${baseCdnUrl.localCDN}/cleave/${version}/cleave.min.js`] },
+        },
+    }),
+    // fontawesome 全量css版本
+    fontawesomeCss: (version = '6.1.2') => ({
+        version,
+        instance: () => defaultWindow,
+        source: {
+            jsdelivr: { js: [], css: [`${baseCdnUrl.jsdelivr}/@fortawesome/fontawesome-free@${version}/css/all.min.css`] },
+            defaultBase: { js: [], css: [`${baseCdnUrl.defaultBase}/font-awesome/${version}/css/all.min.css`] },
+            localCDN: { js: [], css: [`${baseCdnUrl.localCDN}/font-awesome/${version}/css/all.min.css`] },
+        },
+    }),
+    // fontawesome 全量js版本
+    fontawesomeJs: (version = '6.1.2') => ({
+        version,
+        instance: () => defaultWindow,
+        source: {
+            jsdelivr: { js: [`${baseCdnUrl.jsdelivr}/@fortawesome/fontawesome-free@${version}/js/all.min.js`] },
+            defaultBase: { js: [`${baseCdnUrl.defaultBase}/font-awesome/${version}/js/all.min.js`] },
+            localCDN: { js: [`${baseCdnUrl.localCDN}/font-awesome/${version}/js/all.min.js`] },
+        },
+    }),
+    cropper: (version = '1.5.12') => ({
+        version,
+        instance: () => defaultWindow ? defaultWindow.Cropper : undefined,
+        source: {
+            jsdelivr: { js: [`${baseCdnUrl.jsdelivr}/cropperjs@${version}`], css: [`${baseCdnUrl.jsdelivr}/cropperjs@${version}/dist/cropper.min.css`] },
+            defaultBase: { js: [`${baseCdnUrl.defaultBase}/cropperjs/${version}/cropper.min.js`], css: [`${baseCdnUrl.defaultBase}/cropperjs/${version}/cropper.min.css`] },
+            localCDN: { js: [`${baseCdnUrl.localCDN}/cropperjs/${version}/cropper.min.js`], css: [`${baseCdnUrl.localCDN}/cropperjs/${version}/cropper.min.css`] },
+        },
+    }),
+    // flagIcons
+    flagIcons: (version = '6.6.6') => ({
+        version,
+        instance: () => defaultWindow,
+        source: {
+            jsdelivr: { js: [], css: [`${baseCdnUrl.jsdelivr}/flag-icons@${version}/css/flag-icons.min.css`] },
+            defaultBase: { js: [], css: [`${baseCdnUrl.defaultBase}/flag-icons/${version}/css/flag-icons.min.css`] },
+            localCDN: { js: [], css: [`${baseCdnUrl.localCDN}/flag-icons/${version}/css/flag-icons.min.css`] },
+        },
+    }),
+};
+const cdnSource = (name, version) => {
+    if (!defaultWindow) {
+        return;
+    }
+    const cdnName = (window.h_utils?.cdn?.name || 'jsdelivr');
+    const resource = cdnMapping[name];
+    if (!resource) {
+        const defaultResource = {
+            instance: () => ({}),
+            js: [`${baseCdnUrl.defaultBase}/${cdnName}.js/${version}/${cdnName}.min.js`],
+            css: [`${baseCdnUrl.defaultBase}/${cdnName}/${version}/${cdnName}.min.css`],
+        };
+        return defaultResource;
+    }
+    const item = resource(version);
+    return Object.assign({ instance: undefined, js: [], css: [], version: '' }, { ...item.source[cdnName], instance: item.instance, version: item.version });
+};
+
+// 动态加载js文件和css文件
+const FLAG_LOADEED = 'yes';
+// 指定url的js是否已加载
+const isScriptLoaded = (url) => {
+    const script = url && document.querySelector(`script[src="${url}"]`);
+    return !!(script && script.dataset.loader === FLAG_LOADEED);
+};
+// 获取指定url正在加载中的的js，如还未加载返回null
+const getScript = (url) => {
+    const script = url && document.querySelector(`script[src="${url}"]`);
+    return script && !script.dataset.loader ? script : null;
+};
+// 指定url的css是否已加载
+const isCssLoaded = (url) => !!(url && document.querySelector(`link[href="${url}"]`));
+// 加载单个js
+const loadScriptSingle = (url) => new Promise((resolve, reject) => {
+    // 如果已经加载，直接返回
+    if (isScriptLoaded(url)) {
+        resolve(true);
+    }
+    else {
+        const myScript = getScript(url);
+        // （非）多个程序同时加载同一个cdn资源
+        if (!myScript) {
+            const head = document.getElementsByTagName('head')[0];
+            const script = document.createElement('script');
+            script.type = 'text/javascript';
+            script.src = url;
+            script.onload = () => {
+                script.dataset.loaded = FLAG_LOADEED;
+                resolve(true);
+            };
+            // 加载失败删除标签，并返回reject
+            script.onerror = () => {
+                head.removeChild(script);
+                reject(new Error('load failed'));
+            };
+            head.appendChild(script);
+        }
+        else { // 多个程序同时加载同一个cdn资源，则用计时器检测loader状态
+            const timeout = 10000; // 检测超时上限
+            const interval = 10; // 检测频率
+            let times = 0; // 已用时
+            const timer = setInterval(() => {
+                times += interval;
+                // 加载超时
+                if (times >= timeout) {
+                    clearInterval(timer);
+                    reject(new Error('time out!'));
+                }
+                if (myScript.dataset.loaded === FLAG_LOADEED) {
+                    clearInterval(timer);
+                    resolve(true);
+                }
+            }, interval);
+        }
+    }
+});
+// 加载js
+const loadScript = async (urls, options = { sequence: true }) => {
+    // 按顺序加载
+    if (options.sequence) {
+        try {
+            for (let i = 0; i < urls.length; i += 1) {
+                await loadScriptSingle(urls[i]);
+            }
+            return Promise.resolve(true);
+        }
+        catch (e) {
+            return Promise.reject(e);
+        }
+    }
+    return Promise.all(urls.map(url => loadScriptSingle(url)));
+};
+// 加载css
+const loadCss = (urls) => {
+    const head = document.getElementsByTagName('head')[0];
+    urls.filter(url => !isCssLoaded(url))
+        .forEach(url => {
+        const link = document.createElement('link');
+        link.type = 'text/css';
+        link.rel = 'stylesheet';
+        link.href = url;
+        head.appendChild(link);
+    });
+};
+// 按库名加载cdn资源
+const loadCdnSingle = (name, version) => {
+    const { js = [], css, instance } = cdnSource(name, version) || {};
+    Array.isArray(css) && css.length > 0 && loadCss(css);
+    return new Promise((resolve, reject) => {
+        loadScript(js)
+            .then(() => resolve(instance?.()))
+            .catch(() => reject(new Error(`加载 ${name} 失败`)));
+    });
+};
+// 按库名批量加载cdn资源
+const loadCdn = (names) => Promise.all(names.map(name => loadCdnSingle(name)));
+var index = {
+    loadScriptSingle,
+    loadScript,
+    loadCss,
+    loadCdnSingle,
+    loadCdn,
+    baseCdnUrl,
+    cdnMapping,
+    cdnSource,
+};
+
+export { defaultWindow as d, file as f, index as i, storage as s };