{"version":3,"sources":["webpack:///./node_modules/crypto-browserify/index.js","webpack:///./node_modules/crypto-js/sha256.js","webpack:///./node_modules/crypto-js/core.js"],"names":["exports","randomBytes","rng","pseudoRandomBytes","prng","createHash","Hash","createHmac","Hmac","algos","algoKeys","Object","keys","hashes","concat","getHashes","p","pbkdf2","pbkdf2Sync","aes","Cipher","createCipher","Cipheriv","createCipheriv","Decipher","createDecipher","Decipheriv","createDecipheriv","getCiphers","listCiphers","dh","DiffieHellmanGroup","createDiffieHellmanGroup","getDiffieHellman","createDiffieHellman","DiffieHellman","sign","createSign","Sign","createVerify","Verify","createECDH","publicEncrypt","privateEncrypt","publicDecrypt","privateDecrypt","rf","randomFill","randomFillSync","createCredentials","Error","join","constants","CryptoJS","module","Math","C","C_lib","lib","WordArray","Hasher","C_algo","algo","H","K","isPrime","n","sqrtN","sqrt","factor","getFractionalBits","nPrime","pow","W","SHA256","extend","_doReset","this","_hash","init","slice","_doProcessBlock","M","offset","words","a","b","c","d","e","f","g","h","i","gamma0x","gamma0","gamma1x","gamma1","maj","sigma0","t1","_doFinalize","data","_data","dataWords","nBitsTotal","_nDataBytes","nBitsLeft","sigBytes","floor","length","_process","clone","call","_createHelper","HmacSHA256","_createHmacHelper","undefined","crypto","window","msCrypto","global","err","cryptoSecureRandomInt","getRandomValues","Uint32Array","readInt32LE","create","F","obj","subtype","prototype","Base","overrides","mixIn","hasOwnProperty","$super","apply","arguments","instance","properties","propertyName","toString","encoder","Hex","stringify","wordArray","thisWords","thatWords","thisSigBytes","thatSigBytes","clamp","thatByte","ceil","random","nBytes","push","C_enc","enc","hexChars","bite","parse","hexStr","hexStrLength","parseInt","substr","Latin1","latin1Chars","String","fromCharCode","latin1Str","latin1StrLength","charCodeAt","Utf8","decodeURIComponent","escape","utf8Str","unescape","encodeURIComponent","BufferedBlockAlgorithm","reset","_append","doFlush","processedWords","dataSigBytes","blockSize","nBlocksReady","nWordsReady","max","_minBufferSize","nBytesReady","min","splice","cfg","update","messageUpdate","finalize","hasher","message","key","HMAC"],"mappings":"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","file":"js/index~3fd49b24-6b6765447400007e01db.chunk.js","sourcesContent":["'use strict';\n\nexports.randomBytes = exports.rng = exports.pseudoRandomBytes = exports.prng = require('randombytes');\nexports.createHash = exports.Hash = require('create-hash');\nexports.createHmac = exports.Hmac = require('create-hmac');\nvar algos = require('browserify-sign/algos');\nvar algoKeys = Object.keys(algos);\nvar hashes = ['sha1', 'sha224', 'sha256', 'sha384', 'sha512', 'md5', 'rmd160'].concat(algoKeys);\nexports.getHashes = function () {\n  return hashes;\n};\nvar p = require('pbkdf2');\nexports.pbkdf2 = p.pbkdf2;\nexports.pbkdf2Sync = p.pbkdf2Sync;\nvar aes = require('browserify-cipher');\nexports.Cipher = aes.Cipher;\nexports.createCipher = aes.createCipher;\nexports.Cipheriv = aes.Cipheriv;\nexports.createCipheriv = aes.createCipheriv;\nexports.Decipher = aes.Decipher;\nexports.createDecipher = aes.createDecipher;\nexports.Decipheriv = aes.Decipheriv;\nexports.createDecipheriv = aes.createDecipheriv;\nexports.getCiphers = aes.getCiphers;\nexports.listCiphers = aes.listCiphers;\nvar dh = require('diffie-hellman');\nexports.DiffieHellmanGroup = dh.DiffieHellmanGroup;\nexports.createDiffieHellmanGroup = dh.createDiffieHellmanGroup;\nexports.getDiffieHellman = dh.getDiffieHellman;\nexports.createDiffieHellman = dh.createDiffieHellman;\nexports.DiffieHellman = dh.DiffieHellman;\nvar sign = require('browserify-sign');\nexports.createSign = sign.createSign;\nexports.Sign = sign.Sign;\nexports.createVerify = sign.createVerify;\nexports.Verify = sign.Verify;\nexports.createECDH = require('create-ecdh');\nvar publicEncrypt = require('public-encrypt');\nexports.publicEncrypt = publicEncrypt.publicEncrypt;\nexports.privateEncrypt = publicEncrypt.privateEncrypt;\nexports.publicDecrypt = publicEncrypt.publicDecrypt;\nexports.privateDecrypt = publicEncrypt.privateDecrypt;\n\n// the least I can do is make error messages for the rest of the node.js/crypto api.\n// ;[\n//   'createCredentials'\n// ].forEach(function (name) {\n//   exports[name] = function () {\n//     throw new Error([\n//       'sorry, ' + name + ' is not implemented yet',\n//       'we accept pull requests',\n//       'https://github.com/crypto-browserify/crypto-browserify'\n//     ].join('\\n'))\n//   }\n// })\n\nvar rf = require('randomfill');\nexports.randomFill = rf.randomFill;\nexports.randomFillSync = rf.randomFillSync;\nexports.createCredentials = function () {\n  throw new Error(['sorry, createCredentials is not implemented yet', 'we accept pull requests', 'https://github.com/crypto-browserify/crypto-browserify'].join('\\n'));\n};\nexports.constants = {\n  'DH_CHECK_P_NOT_SAFE_PRIME': 2,\n  'DH_CHECK_P_NOT_PRIME': 1,\n  'DH_UNABLE_TO_CHECK_GENERATOR': 4,\n  'DH_NOT_SUITABLE_GENERATOR': 8,\n  'NPN_ENABLED': 1,\n  'ALPN_ENABLED': 1,\n  'RSA_PKCS1_PADDING': 1,\n  'RSA_SSLV23_PADDING': 2,\n  'RSA_NO_PADDING': 3,\n  'RSA_PKCS1_OAEP_PADDING': 4,\n  'RSA_X931_PADDING': 5,\n  'RSA_PKCS1_PSS_PADDING': 6,\n  'POINT_CONVERSION_COMPRESSED': 2,\n  'POINT_CONVERSION_UNCOMPRESSED': 4,\n  'POINT_CONVERSION_HYBRID': 6\n};",";\n(function (root, factory) {\n  if (typeof exports === \"object\") {\n    // CommonJS\n    module.exports = exports = factory(require(\"./core\"));\n  } else if (typeof define === \"function\" && define.amd) {\n    // AMD\n    define([\"./core\"], factory);\n  } else {\n    // Global (browser)\n    factory(root.CryptoJS);\n  }\n})(this, function (CryptoJS) {\n  (function (Math) {\n    // Shortcuts\n    var C = CryptoJS;\n    var C_lib = C.lib;\n    var WordArray = C_lib.WordArray;\n    var Hasher = C_lib.Hasher;\n    var C_algo = C.algo;\n\n    // Initialization and round constants tables\n    var H = [];\n    var K = [];\n\n    // Compute constants\n    (function () {\n      function isPrime(n) {\n        var sqrtN = Math.sqrt(n);\n        for (var factor = 2; factor <= sqrtN; factor++) {\n          if (!(n % factor)) {\n            return false;\n          }\n        }\n        return true;\n      }\n      function getFractionalBits(n) {\n        return (n - (n | 0)) * 0x100000000 | 0;\n      }\n      var n = 2;\n      var nPrime = 0;\n      while (nPrime < 64) {\n        if (isPrime(n)) {\n          if (nPrime < 8) {\n            H[nPrime] = getFractionalBits(Math.pow(n, 1 / 2));\n          }\n          K[nPrime] = getFractionalBits(Math.pow(n, 1 / 3));\n          nPrime++;\n        }\n        n++;\n      }\n    })();\n\n    // Reusable object\n    var W = [];\n\n    /**\n     * SHA-256 hash algorithm.\n     */\n    var SHA256 = C_algo.SHA256 = Hasher.extend({\n      _doReset: function () {\n        this._hash = new WordArray.init(H.slice(0));\n      },\n      _doProcessBlock: function (M, offset) {\n        // Shortcut\n        var H = this._hash.words;\n\n        // Working variables\n        var a = H[0];\n        var b = H[1];\n        var c = H[2];\n        var d = H[3];\n        var e = H[4];\n        var f = H[5];\n        var g = H[6];\n        var h = H[7];\n\n        // Computation\n        for (var i = 0; i < 64; i++) {\n          if (i < 16) {\n            W[i] = M[offset + i] | 0;\n          } else {\n            var gamma0x = W[i - 15];\n            var gamma0 = (gamma0x << 25 | gamma0x >>> 7) ^ (gamma0x << 14 | gamma0x >>> 18) ^ gamma0x >>> 3;\n            var gamma1x = W[i - 2];\n            var gamma1 = (gamma1x << 15 | gamma1x >>> 17) ^ (gamma1x << 13 | gamma1x >>> 19) ^ gamma1x >>> 10;\n            W[i] = gamma0 + W[i - 7] + gamma1 + W[i - 16];\n          }\n          var ch = e & f ^ ~e & g;\n          var maj = a & b ^ a & c ^ b & c;\n          var sigma0 = (a << 30 | a >>> 2) ^ (a << 19 | a >>> 13) ^ (a << 10 | a >>> 22);\n          var sigma1 = (e << 26 | e >>> 6) ^ (e << 21 | e >>> 11) ^ (e << 7 | e >>> 25);\n          var t1 = h + sigma1 + ch + K[i] + W[i];\n          var t2 = sigma0 + maj;\n          h = g;\n          g = f;\n          f = e;\n          e = d + t1 | 0;\n          d = c;\n          c = b;\n          b = a;\n          a = t1 + t2 | 0;\n        }\n\n        // Intermediate hash value\n        H[0] = H[0] + a | 0;\n        H[1] = H[1] + b | 0;\n        H[2] = H[2] + c | 0;\n        H[3] = H[3] + d | 0;\n        H[4] = H[4] + e | 0;\n        H[5] = H[5] + f | 0;\n        H[6] = H[6] + g | 0;\n        H[7] = H[7] + h | 0;\n      },\n      _doFinalize: function () {\n        // Shortcuts\n        var data = this._data;\n        var dataWords = data.words;\n        var nBitsTotal = this._nDataBytes * 8;\n        var nBitsLeft = data.sigBytes * 8;\n\n        // Add padding\n        dataWords[nBitsLeft >>> 5] |= 0x80 << 24 - nBitsLeft % 32;\n        dataWords[(nBitsLeft + 64 >>> 9 << 4) + 14] = Math.floor(nBitsTotal / 0x100000000);\n        dataWords[(nBitsLeft + 64 >>> 9 << 4) + 15] = nBitsTotal;\n        data.sigBytes = dataWords.length * 4;\n\n        // Hash final blocks\n        this._process();\n\n        // Return final computed hash\n        return this._hash;\n      },\n      clone: function () {\n        var clone = Hasher.clone.call(this);\n        clone._hash = this._hash.clone();\n        return clone;\n      }\n    });\n\n    /**\n     * Shortcut function to the hasher's object interface.\n     *\n     * @param {WordArray|string} message The message to hash.\n     *\n     * @return {WordArray} The hash.\n     *\n     * @static\n     *\n     * @example\n     *\n     *     var hash = CryptoJS.SHA256('message');\n     *     var hash = CryptoJS.SHA256(wordArray);\n     */\n    C.SHA256 = Hasher._createHelper(SHA256);\n\n    /**\n     * Shortcut function to the HMAC's object interface.\n     *\n     * @param {WordArray|string} message The message to hash.\n     * @param {WordArray|string} key The secret key.\n     *\n     * @return {WordArray} The HMAC.\n     *\n     * @static\n     *\n     * @example\n     *\n     *     var hmac = CryptoJS.HmacSHA256(message, key);\n     */\n    C.HmacSHA256 = Hasher._createHmacHelper(SHA256);\n  })(Math);\n  return CryptoJS.SHA256;\n});",";\n(function (root, factory) {\n  if (typeof exports === \"object\") {\n    // CommonJS\n    module.exports = exports = factory();\n  } else if (typeof define === \"function\" && define.amd) {\n    // AMD\n    define([], factory);\n  } else {\n    // Global (browser)\n    root.CryptoJS = factory();\n  }\n})(this, function () {\n  /*globals window, global, require*/\n\n  /**\n   * CryptoJS core components.\n   */\n  var CryptoJS = CryptoJS || function (Math, undefined) {\n    var crypto;\n\n    // Native crypto from window (Browser)\n    if (typeof window !== 'undefined' && window.crypto) {\n      crypto = window.crypto;\n    }\n\n    // Native (experimental IE 11) crypto from window (Browser)\n    if (!crypto && typeof window !== 'undefined' && window.msCrypto) {\n      crypto = window.msCrypto;\n    }\n\n    // Native crypto from global (NodeJS)\n    if (!crypto && typeof global !== 'undefined' && global.crypto) {\n      crypto = global.crypto;\n    }\n\n    // Native crypto import via require (NodeJS)\n    if (!crypto && typeof require === 'function') {\n      try {\n        crypto = require('crypto');\n      } catch (err) {}\n    }\n\n    /*\n     * Cryptographically secure pseudorandom number generator\n     *\n     * As Math.random() is cryptographically not safe to use\n     */\n    var cryptoSecureRandomInt = function () {\n      if (crypto) {\n        // Use getRandomValues method (Browser)\n        if (typeof crypto.getRandomValues === 'function') {\n          try {\n            return crypto.getRandomValues(new Uint32Array(1))[0];\n          } catch (err) {}\n        }\n\n        // Use randomBytes method (NodeJS)\n        if (typeof crypto.randomBytes === 'function') {\n          try {\n            return crypto.randomBytes(4).readInt32LE();\n          } catch (err) {}\n        }\n      }\n      throw new Error('Native crypto module could not be used to get secure random number.');\n    };\n\n    /*\n     * Local polyfill of Object.create\n      */\n    var create = Object.create || function () {\n      function F() {}\n      return function (obj) {\n        var subtype;\n        F.prototype = obj;\n        subtype = new F();\n        F.prototype = null;\n        return subtype;\n      };\n    }();\n\n    /**\n     * CryptoJS namespace.\n     */\n    var C = {};\n\n    /**\n     * Library namespace.\n     */\n    var C_lib = C.lib = {};\n\n    /**\n     * Base object for prototypal inheritance.\n     */\n    var Base = C_lib.Base = function () {\n      return {\n        /**\n         * Creates a new object that inherits from this object.\n         *\n         * @param {Object} overrides Properties to copy into the new object.\n         *\n         * @return {Object} The new object.\n         *\n         * @static\n         *\n         * @example\n         *\n         *     var MyType = CryptoJS.lib.Base.extend({\n         *         field: 'value',\n         *\n         *         method: function () {\n         *         }\n         *     });\n         */\n        extend: function (overrides) {\n          // Spawn\n          var subtype = create(this);\n\n          // Augment\n          if (overrides) {\n            subtype.mixIn(overrides);\n          }\n\n          // Create default initializer\n          if (!subtype.hasOwnProperty('init') || this.init === subtype.init) {\n            subtype.init = function () {\n              subtype.$super.init.apply(this, arguments);\n            };\n          }\n\n          // Initializer's prototype is the subtype object\n          subtype.init.prototype = subtype;\n\n          // Reference supertype\n          subtype.$super = this;\n          return subtype;\n        },\n        /**\n         * Extends this object and runs the init method.\n         * Arguments to create() will be passed to init().\n         *\n         * @return {Object} The new object.\n         *\n         * @static\n         *\n         * @example\n         *\n         *     var instance = MyType.create();\n         */\n        create: function () {\n          var instance = this.extend();\n          instance.init.apply(instance, arguments);\n          return instance;\n        },\n        /**\n         * Initializes a newly created object.\n         * Override this method to add some logic when your objects are created.\n         *\n         * @example\n         *\n         *     var MyType = CryptoJS.lib.Base.extend({\n         *         init: function () {\n         *             // ...\n         *         }\n         *     });\n         */\n        init: function () {},\n        /**\n         * Copies properties into this object.\n         *\n         * @param {Object} properties The properties to mix in.\n         *\n         * @example\n         *\n         *     MyType.mixIn({\n         *         field: 'value'\n         *     });\n         */\n        mixIn: function (properties) {\n          for (var propertyName in properties) {\n            if (properties.hasOwnProperty(propertyName)) {\n              this[propertyName] = properties[propertyName];\n            }\n          }\n\n          // IE won't copy toString using the loop above\n          if (properties.hasOwnProperty('toString')) {\n            this.toString = properties.toString;\n          }\n        },\n        /**\n         * Creates a copy of this object.\n         *\n         * @return {Object} The clone.\n         *\n         * @example\n         *\n         *     var clone = instance.clone();\n         */\n        clone: function () {\n          return this.init.prototype.extend(this);\n        }\n      };\n    }();\n\n    /**\n     * An array of 32-bit words.\n     *\n     * @property {Array} words The array of 32-bit words.\n     * @property {number} sigBytes The number of significant bytes in this word array.\n     */\n    var WordArray = C_lib.WordArray = Base.extend({\n      /**\n       * Initializes a newly created word array.\n       *\n       * @param {Array} words (Optional) An array of 32-bit words.\n       * @param {number} sigBytes (Optional) The number of significant bytes in the words.\n       *\n       * @example\n       *\n       *     var wordArray = CryptoJS.lib.WordArray.create();\n       *     var wordArray = CryptoJS.lib.WordArray.create([0x00010203, 0x04050607]);\n       *     var wordArray = CryptoJS.lib.WordArray.create([0x00010203, 0x04050607], 6);\n       */\n      init: function (words, sigBytes) {\n        words = this.words = words || [];\n        if (sigBytes != undefined) {\n          this.sigBytes = sigBytes;\n        } else {\n          this.sigBytes = words.length * 4;\n        }\n      },\n      /**\n       * Converts this word array to a string.\n       *\n       * @param {Encoder} encoder (Optional) The encoding strategy to use. Default: CryptoJS.enc.Hex\n       *\n       * @return {string} The stringified word array.\n       *\n       * @example\n       *\n       *     var string = wordArray + '';\n       *     var string = wordArray.toString();\n       *     var string = wordArray.toString(CryptoJS.enc.Utf8);\n       */\n      toString: function (encoder) {\n        return (encoder || Hex).stringify(this);\n      },\n      /**\n       * Concatenates a word array to this word array.\n       *\n       * @param {WordArray} wordArray The word array to append.\n       *\n       * @return {WordArray} This word array.\n       *\n       * @example\n       *\n       *     wordArray1.concat(wordArray2);\n       */\n      concat: function (wordArray) {\n        // Shortcuts\n        var thisWords = this.words;\n        var thatWords = wordArray.words;\n        var thisSigBytes = this.sigBytes;\n        var thatSigBytes = wordArray.sigBytes;\n\n        // Clamp excess bits\n        this.clamp();\n\n        // Concat\n        if (thisSigBytes % 4) {\n          // Copy one byte at a time\n          for (var i = 0; i < thatSigBytes; i++) {\n            var thatByte = thatWords[i >>> 2] >>> 24 - i % 4 * 8 & 0xff;\n            thisWords[thisSigBytes + i >>> 2] |= thatByte << 24 - (thisSigBytes + i) % 4 * 8;\n          }\n        } else {\n          // Copy one word at a time\n          for (var i = 0; i < thatSigBytes; i += 4) {\n            thisWords[thisSigBytes + i >>> 2] = thatWords[i >>> 2];\n          }\n        }\n        this.sigBytes += thatSigBytes;\n\n        // Chainable\n        return this;\n      },\n      /**\n       * Removes insignificant bits.\n       *\n       * @example\n       *\n       *     wordArray.clamp();\n       */\n      clamp: function () {\n        // Shortcuts\n        var words = this.words;\n        var sigBytes = this.sigBytes;\n\n        // Clamp\n        words[sigBytes >>> 2] &= 0xffffffff << 32 - sigBytes % 4 * 8;\n        words.length = Math.ceil(sigBytes / 4);\n      },\n      /**\n       * Creates a copy of this word array.\n       *\n       * @return {WordArray} The clone.\n       *\n       * @example\n       *\n       *     var clone = wordArray.clone();\n       */\n      clone: function () {\n        var clone = Base.clone.call(this);\n        clone.words = this.words.slice(0);\n        return clone;\n      },\n      /**\n       * Creates a word array filled with random bytes.\n       *\n       * @param {number} nBytes The number of random bytes to generate.\n       *\n       * @return {WordArray} The random word array.\n       *\n       * @static\n       *\n       * @example\n       *\n       *     var wordArray = CryptoJS.lib.WordArray.random(16);\n       */\n      random: function (nBytes) {\n        var words = [];\n        for (var i = 0; i < nBytes; i += 4) {\n          words.push(cryptoSecureRandomInt());\n        }\n        return new WordArray.init(words, nBytes);\n      }\n    });\n\n    /**\n     * Encoder namespace.\n     */\n    var C_enc = C.enc = {};\n\n    /**\n     * Hex encoding strategy.\n     */\n    var Hex = C_enc.Hex = {\n      /**\n       * Converts a word array to a hex string.\n       *\n       * @param {WordArray} wordArray The word array.\n       *\n       * @return {string} The hex string.\n       *\n       * @static\n       *\n       * @example\n       *\n       *     var hexString = CryptoJS.enc.Hex.stringify(wordArray);\n       */\n      stringify: function (wordArray) {\n        // Shortcuts\n        var words = wordArray.words;\n        var sigBytes = wordArray.sigBytes;\n\n        // Convert\n        var hexChars = [];\n        for (var i = 0; i < sigBytes; i++) {\n          var bite = words[i >>> 2] >>> 24 - i % 4 * 8 & 0xff;\n          hexChars.push((bite >>> 4).toString(16));\n          hexChars.push((bite & 0x0f).toString(16));\n        }\n        return hexChars.join('');\n      },\n      /**\n       * Converts a hex string to a word array.\n       *\n       * @param {string} hexStr The hex string.\n       *\n       * @return {WordArray} The word array.\n       *\n       * @static\n       *\n       * @example\n       *\n       *     var wordArray = CryptoJS.enc.Hex.parse(hexString);\n       */\n      parse: function (hexStr) {\n        // Shortcut\n        var hexStrLength = hexStr.length;\n\n        // Convert\n        var words = [];\n        for (var i = 0; i < hexStrLength; i += 2) {\n          words[i >>> 3] |= parseInt(hexStr.substr(i, 2), 16) << 24 - i % 8 * 4;\n        }\n        return new WordArray.init(words, hexStrLength / 2);\n      }\n    };\n\n    /**\n     * Latin1 encoding strategy.\n     */\n    var Latin1 = C_enc.Latin1 = {\n      /**\n       * Converts a word array to a Latin1 string.\n       *\n       * @param {WordArray} wordArray The word array.\n       *\n       * @return {string} The Latin1 string.\n       *\n       * @static\n       *\n       * @example\n       *\n       *     var latin1String = CryptoJS.enc.Latin1.stringify(wordArray);\n       */\n      stringify: function (wordArray) {\n        // Shortcuts\n        var words = wordArray.words;\n        var sigBytes = wordArray.sigBytes;\n\n        // Convert\n        var latin1Chars = [];\n        for (var i = 0; i < sigBytes; i++) {\n          var bite = words[i >>> 2] >>> 24 - i % 4 * 8 & 0xff;\n          latin1Chars.push(String.fromCharCode(bite));\n        }\n        return latin1Chars.join('');\n      },\n      /**\n       * Converts a Latin1 string to a word array.\n       *\n       * @param {string} latin1Str The Latin1 string.\n       *\n       * @return {WordArray} The word array.\n       *\n       * @static\n       *\n       * @example\n       *\n       *     var wordArray = CryptoJS.enc.Latin1.parse(latin1String);\n       */\n      parse: function (latin1Str) {\n        // Shortcut\n        var latin1StrLength = latin1Str.length;\n\n        // Convert\n        var words = [];\n        for (var i = 0; i < latin1StrLength; i++) {\n          words[i >>> 2] |= (latin1Str.charCodeAt(i) & 0xff) << 24 - i % 4 * 8;\n        }\n        return new WordArray.init(words, latin1StrLength);\n      }\n    };\n\n    /**\n     * UTF-8 encoding strategy.\n     */\n    var Utf8 = C_enc.Utf8 = {\n      /**\n       * Converts a word array to a UTF-8 string.\n       *\n       * @param {WordArray} wordArray The word array.\n       *\n       * @return {string} The UTF-8 string.\n       *\n       * @static\n       *\n       * @example\n       *\n       *     var utf8String = CryptoJS.enc.Utf8.stringify(wordArray);\n       */\n      stringify: function (wordArray) {\n        try {\n          return decodeURIComponent(escape(Latin1.stringify(wordArray)));\n        } catch (e) {\n          throw new Error('Malformed UTF-8 data');\n        }\n      },\n      /**\n       * Converts a UTF-8 string to a word array.\n       *\n       * @param {string} utf8Str The UTF-8 string.\n       *\n       * @return {WordArray} The word array.\n       *\n       * @static\n       *\n       * @example\n       *\n       *     var wordArray = CryptoJS.enc.Utf8.parse(utf8String);\n       */\n      parse: function (utf8Str) {\n        return Latin1.parse(unescape(encodeURIComponent(utf8Str)));\n      }\n    };\n\n    /**\n     * Abstract buffered block algorithm template.\n     *\n     * The property blockSize must be implemented in a concrete subtype.\n     *\n     * @property {number} _minBufferSize The number of blocks that should be kept unprocessed in the buffer. Default: 0\n     */\n    var BufferedBlockAlgorithm = C_lib.BufferedBlockAlgorithm = Base.extend({\n      /**\n       * Resets this block algorithm's data buffer to its initial state.\n       *\n       * @example\n       *\n       *     bufferedBlockAlgorithm.reset();\n       */\n      reset: function () {\n        // Initial values\n        this._data = new WordArray.init();\n        this._nDataBytes = 0;\n      },\n      /**\n       * Adds new data to this block algorithm's buffer.\n       *\n       * @param {WordArray|string} data The data to append. Strings are converted to a WordArray using UTF-8.\n       *\n       * @example\n       *\n       *     bufferedBlockAlgorithm._append('data');\n       *     bufferedBlockAlgorithm._append(wordArray);\n       */\n      _append: function (data) {\n        // Convert string to WordArray, else assume WordArray already\n        if (typeof data == 'string') {\n          data = Utf8.parse(data);\n        }\n\n        // Append\n        this._data.concat(data);\n        this._nDataBytes += data.sigBytes;\n      },\n      /**\n       * Processes available data blocks.\n       *\n       * This method invokes _doProcessBlock(offset), which must be implemented by a concrete subtype.\n       *\n       * @param {boolean} doFlush Whether all blocks and partial blocks should be processed.\n       *\n       * @return {WordArray} The processed data.\n       *\n       * @example\n       *\n       *     var processedData = bufferedBlockAlgorithm._process();\n       *     var processedData = bufferedBlockAlgorithm._process(!!'flush');\n       */\n      _process: function (doFlush) {\n        var processedWords;\n\n        // Shortcuts\n        var data = this._data;\n        var dataWords = data.words;\n        var dataSigBytes = data.sigBytes;\n        var blockSize = this.blockSize;\n        var blockSizeBytes = blockSize * 4;\n\n        // Count blocks ready\n        var nBlocksReady = dataSigBytes / blockSizeBytes;\n        if (doFlush) {\n          // Round up to include partial blocks\n          nBlocksReady = Math.ceil(nBlocksReady);\n        } else {\n          // Round down to include only full blocks,\n          // less the number of blocks that must remain in the buffer\n          nBlocksReady = Math.max((nBlocksReady | 0) - this._minBufferSize, 0);\n        }\n\n        // Count words ready\n        var nWordsReady = nBlocksReady * blockSize;\n\n        // Count bytes ready\n        var nBytesReady = Math.min(nWordsReady * 4, dataSigBytes);\n\n        // Process blocks\n        if (nWordsReady) {\n          for (var offset = 0; offset < nWordsReady; offset += blockSize) {\n            // Perform concrete-algorithm logic\n            this._doProcessBlock(dataWords, offset);\n          }\n\n          // Remove processed words\n          processedWords = dataWords.splice(0, nWordsReady);\n          data.sigBytes -= nBytesReady;\n        }\n\n        // Return processed words\n        return new WordArray.init(processedWords, nBytesReady);\n      },\n      /**\n       * Creates a copy of this object.\n       *\n       * @return {Object} The clone.\n       *\n       * @example\n       *\n       *     var clone = bufferedBlockAlgorithm.clone();\n       */\n      clone: function () {\n        var clone = Base.clone.call(this);\n        clone._data = this._data.clone();\n        return clone;\n      },\n      _minBufferSize: 0\n    });\n\n    /**\n     * Abstract hasher template.\n     *\n     * @property {number} blockSize The number of 32-bit words this hasher operates on. Default: 16 (512 bits)\n     */\n    var Hasher = C_lib.Hasher = BufferedBlockAlgorithm.extend({\n      /**\n       * Configuration options.\n       */\n      cfg: Base.extend(),\n      /**\n       * Initializes a newly created hasher.\n       *\n       * @param {Object} cfg (Optional) The configuration options to use for this hash computation.\n       *\n       * @example\n       *\n       *     var hasher = CryptoJS.algo.SHA256.create();\n       */\n      init: function (cfg) {\n        // Apply config defaults\n        this.cfg = this.cfg.extend(cfg);\n\n        // Set initial values\n        this.reset();\n      },\n      /**\n       * Resets this hasher to its initial state.\n       *\n       * @example\n       *\n       *     hasher.reset();\n       */\n      reset: function () {\n        // Reset data buffer\n        BufferedBlockAlgorithm.reset.call(this);\n\n        // Perform concrete-hasher logic\n        this._doReset();\n      },\n      /**\n       * Updates this hasher with a message.\n       *\n       * @param {WordArray|string} messageUpdate The message to append.\n       *\n       * @return {Hasher} This hasher.\n       *\n       * @example\n       *\n       *     hasher.update('message');\n       *     hasher.update(wordArray);\n       */\n      update: function (messageUpdate) {\n        // Append\n        this._append(messageUpdate);\n\n        // Update the hash\n        this._process();\n\n        // Chainable\n        return this;\n      },\n      /**\n       * Finalizes the hash computation.\n       * Note that the finalize operation is effectively a destructive, read-once operation.\n       *\n       * @param {WordArray|string} messageUpdate (Optional) A final message update.\n       *\n       * @return {WordArray} The hash.\n       *\n       * @example\n       *\n       *     var hash = hasher.finalize();\n       *     var hash = hasher.finalize('message');\n       *     var hash = hasher.finalize(wordArray);\n       */\n      finalize: function (messageUpdate) {\n        // Final message update\n        if (messageUpdate) {\n          this._append(messageUpdate);\n        }\n\n        // Perform concrete-hasher logic\n        var hash = this._doFinalize();\n        return hash;\n      },\n      blockSize: 512 / 32,\n      /**\n       * Creates a shortcut function to a hasher's object interface.\n       *\n       * @param {Hasher} hasher The hasher to create a helper for.\n       *\n       * @return {Function} The shortcut function.\n       *\n       * @static\n       *\n       * @example\n       *\n       *     var SHA256 = CryptoJS.lib.Hasher._createHelper(CryptoJS.algo.SHA256);\n       */\n      _createHelper: function (hasher) {\n        return function (message, cfg) {\n          return new hasher.init(cfg).finalize(message);\n        };\n      },\n      /**\n       * Creates a shortcut function to the HMAC's object interface.\n       *\n       * @param {Hasher} hasher The hasher to use in this HMAC helper.\n       *\n       * @return {Function} The shortcut function.\n       *\n       * @static\n       *\n       * @example\n       *\n       *     var HmacSHA256 = CryptoJS.lib.Hasher._createHmacHelper(CryptoJS.algo.SHA256);\n       */\n      _createHmacHelper: function (hasher) {\n        return function (message, key) {\n          return new C_algo.HMAC.init(hasher, key).finalize(message);\n        };\n      }\n    });\n\n    /**\n     * Algorithm namespace.\n     */\n    var C_algo = C.algo = {};\n    return C;\n  }(Math);\n  return CryptoJS;\n});"],"sourceRoot":""}