{"version":3,"sources":["jsdelivr-header.js","/npm/scrypt-js@3.0.0/scrypt.js"],"names":[],"mappings":"AAAA;AACA;AACA;AACA;AACA;AACA;AACA,ACNA,cAEA,SAAU,GACN,MAAM,EAAY,WAIlB,SAAS,EAAO,GACZ,MAAM,EAAI,IAAI,YAAY,CACvB,WAAY,WAAY,WAAY,WAAY,UAChD,WAAY,WAAY,WAAY,WAAY,UAChD,UAAY,WAAY,WAAY,WAAY,WAChD,WAAY,WAAY,WAAY,UAAY,UAChD,UAAY,WAAY,WAAY,WAAY,WAChD,WAAY,WAAY,WAAY,WAAY,WAChD,UAAY,UAAY,UAAY,UAAY,WAChD,WAAY,WAAY,WAAY,WAAY,WAChD,WAAY,WAAY,WAAY,WAAY,WAChD,WAAY,WAAY,UAAY,UAAY,UAChD,UAAY,UAAY,UAAY,WAAY,WAChD,WAAY,WAAY,WAAY,WAAY,WAChD,WAAY,WAAY,WAAY,aAGvC,IAAI,EAAK,WAAY,EAAK,WAAY,EAAK,WAAY,EAAK,WACxD,EAAK,WAAY,EAAK,WAAY,EAAK,UAAY,EAAK,WAC5D,MAAM,EAAI,IAAI,YAAY,IAE1B,SAAS,EAAO,GACZ,IAAI,EAAM,EAAG,EAAM,EAAE,OACrB,KAAO,GAAO,IAAI,CACd,IAAoE,EAAG,EAAG,EAAG,EAAI,EAA7E,EAAI,EAAI,EAAI,EAAI,EAAI,EAAI,EAAI,EAAI,EAAI,EAAI,EAAI,EAAI,EAAI,EAAI,EAAI,EAEhE,IAAK,EAAI,EAAG,EAAI,GAAI,IAChB,EAAI,EAAQ,EAAF,EACV,EAAE,IAAc,IAAP,EAAE,KAAY,IAAiB,IAAT,EAAE,EAAE,KAAY,IACpC,IAAT,EAAE,EAAE,KAAY,EAAe,IAAT,EAAE,EAAE,GAGhC,IAAK,EAAI,GAAI,EAAI,GAAI,IACjB,EAAI,EAAE,EAAE,GACR,GAAO,IAAI,GAAO,GAAG,KAAc,IAAI,GAAO,GAAG,IAAa,IAAI,GAElE,EAAI,EAAE,EAAE,IACR,GAAO,IAAI,EAAM,GAAG,KAAa,IAAI,GAAO,GAAG,IAAa,IAAI,EAEhE,EAAE,IAAQ,EAAK,EAAE,EAAE,GAAM,IAAO,EAAK,EAAE,EAAE,IAAO,GAAM,EAG1D,IAAK,EAAI,EAAG,EAAI,GAAI,IAChB,KAAW,IAAI,EAAM,GAAG,KAAa,IAAI,GAAO,GAAG,KACxC,IAAI,GAAO,GAAG,KAAe,EAAI,GAAO,EAAI,GAAO,IACtD,GAAM,EAAE,GAAK,EAAE,GAAM,GAAM,GAAM,EAEzC,IAAS,IAAI,EAAM,GAAG,KAAa,IAAI,GAAO,GAAG,KACxC,IAAI,GAAO,GAAG,MAAe,EAAI,EAAM,EAAI,EAAM,EAAI,GAAO,EAErE,EAAI,EACJ,EAAI,EACJ,EAAI,EACJ,EAAK,EAAI,EAAM,EACf,EAAI,EACJ,EAAI,EACJ,EAAI,EACJ,EAAK,EAAK,EAAM,EAGpB,EAAM,EAAK,EAAK,EAChB,EAAM,EAAK,EAAK,EAChB,EAAM,EAAK,EAAK,EAChB,EAAM,EAAK,EAAK,EAChB,EAAM,EAAK,EAAK,EAChB,EAAM,EAAK,EAAK,EAChB,EAAM,EAAK,EAAK,EAChB,EAAM,EAAK,EAAK,EAEhB,GAAO,GACP,GAAO,EACX,CACJ,CAEA,EAAO,GAEP,IAAI,EAAG,EAAY,EAAE,OAAS,GAC9B,EAAY,EAAE,OAAS,UAAc,EACrC,EAAW,EAAE,QAAU,EACvB,EAAY,EAAY,GAAM,GAAK,IACnC,EAAI,EAAE,MAAM,EAAE,OAAS,EAAW,EAAE,QAGpC,IADA,EAAE,KAAK,KACF,EAAI,EAAY,EAAG,EAAI,EAAU,IAAO,EAAE,KAAK,GAYpD,OAXA,EAAE,KAAM,IAAa,GAAM,KAC3B,EAAE,KAAM,IAAa,GAAM,KAC3B,EAAE,KAAM,IAAa,EAAM,KAC3B,EAAE,KAAM,IAAa,EAAM,KAC3B,EAAE,KAAM,IAAa,GAAM,KAC3B,EAAE,KAAM,IAAa,GAAM,KAC3B,EAAE,KAAM,IAAa,EAAM,KAC3B,EAAE,KAAM,IAAa,EAAM,KAE3B,EAAO,GAEA,CACF,IAAO,GAAM,IAAO,IAAO,GAAM,IAAO,IAAO,EAAK,IAAO,IAAO,EAAK,IACvE,IAAO,GAAM,IAAO,IAAO,GAAM,IAAO,IAAO,EAAK,IAAO,IAAO,EAAK,IACvE,IAAO,GAAM,IAAO,IAAO,GAAM,IAAO,IAAO,EAAK,IAAO,IAAO,EAAK,IACvE,IAAO,GAAM,IAAO,IAAO,GAAM,IAAO,IAAO,EAAK,IAAO,IAAO,EAAK,IACvE,IAAO,GAAM,IAAO,IAAO,GAAM,IAAO,IAAO,EAAK,IAAO,IAAO,EAAK,IACvE,IAAO,GAAM,IAAO,IAAO,GAAM,IAAO,IAAO,EAAK,IAAO,IAAO,EAAK,IACvE,IAAO,GAAM,IAAO,IAAO,GAAM,IAAO,IAAO,EAAK,IAAO,IAAO,EAAK,IACvE,IAAO,GAAM,IAAO,IAAO,GAAM,IAAO,IAAO,EAAK,IAAO,IAAO,EAAK,IAEhF,CAEA,SAAS,EAA2B,EAAU,EAAM,GAEhD,EAAY,EAAS,QAAU,GAAM,EAAW,EAAO,GAEvD,MAAM,EAAW,GAAK,EAAK,OAAS,EAC9B,EAAQ,IAAI,MAAM,GAClB,EAAW,IAAI,MAAM,IAE3B,IAAI,EACA,EAAK,GAGT,IAAK,EAAI,EAAG,EAAI,GAAI,IAAO,EAAM,GAAK,GACtC,IAAK,EAAI,EAAG,EAAI,EAAS,OAAQ,IAAO,EAAM,IAAM,EAAS,GAC7D,IAAK,EAAI,EAAG,EAAI,EAAK,OAAQ,IAAO,EAAM,GAAK,GAAK,EAAK,GACzD,IAAK,EAAI,EAAW,EAAG,EAAI,EAAU,IAAO,EAAM,GAAK,EAGvD,IAAK,EAAI,EAAG,EAAI,GAAI,IAAK,EAAS,GAAK,GACvC,IAAK,EAAI,EAAG,EAAI,EAAS,OAAQ,IAAK,EAAS,IAAM,EAAS,GAG9D,SAAS,IACL,IAAK,IAAI,EAAI,EAAW,EAAG,GAAK,EAAW,EAAG,IAAK,CAE/C,GADA,EAAM,KACF,EAAM,IAAM,IAAM,OACtB,EAAM,GAAK,CACf,CACJ,CAGA,KAAO,GAAS,IACZ,IACA,EAAK,EAAG,OAAO,EAAO,EAAS,OAAO,EAAO,MAC7C,GAAS,GAOb,OALI,EAAQ,IACR,IACA,EAAK,EAAG,OAAO,EAAO,EAAS,OAAO,EAAO,KAAS,MAAM,EAAG,KAG5D,CACX,CAIA,SAAS,EAAgB,EAAI,EAAI,EAAG,EAAG,GACnC,IAAI,EAGJ,IADA,EAAU,EAAkB,IAAb,EAAI,EAAI,GAAS,EAAI,EAAG,IAClC,EAAI,EAAG,EAAI,EAAI,EAAG,IACnB,EAAS,EAAQ,GAAJ,EAAQ,EAAI,IACzB,EAAU,EAAI,GACd,EAAU,EAAI,EAAG,EAAI,EAAU,GAAJ,EAAS,IAGxC,IAAK,EAAI,EAAG,EAAI,EAAG,IACf,EAAU,EAAI,EAAU,EAAJ,EAAS,GAAI,EAAS,GAAJ,EAAS,IAGnD,IAAK,EAAI,EAAG,EAAI,EAAG,IACf,EAAU,EAAI,EAAmB,IAAT,EAAJ,EAAQ,GAAS,EAAc,IAAT,EAAI,GAAS,GAE/D,CAEA,SAAS,EAAE,EAAG,GACV,OAAQ,GAAK,EAAM,IAAO,GAAK,CACnC,CAEA,SAAS,EAAU,EAAG,GAClB,EAAU,EAAG,EAAG,EAAG,EAAG,IAEtB,IAAK,IAAI,EAAI,EAAG,EAAI,EAAG,GAAK,EACxB,EAAG,IAAM,EAAE,EAAG,GAAK,EAAE,IAAK,GAC1B,EAAG,IAAM,EAAE,EAAG,GAAK,EAAG,GAAI,GAC1B,EAAE,KAAO,EAAE,EAAG,GAAK,EAAG,GAAI,IAC1B,EAAG,IAAM,EAAE,EAAE,IAAM,EAAG,GAAI,IAC1B,EAAG,IAAM,EAAE,EAAG,GAAK,EAAG,GAAI,GAC1B,EAAE,KAAO,EAAE,EAAG,GAAK,EAAG,GAAI,GAC1B,EAAG,IAAM,EAAE,EAAE,IAAM,EAAG,GAAI,IAC1B,EAAG,IAAM,EAAE,EAAG,GAAK,EAAE,IAAK,IAC1B,EAAE,KAAO,EAAE,EAAE,IAAM,EAAG,GAAI,GAC1B,EAAG,IAAM,EAAE,EAAE,IAAM,EAAE,IAAK,GAC1B,EAAG,IAAM,EAAE,EAAG,GAAK,EAAE,IAAK,IAC1B,EAAE,KAAO,EAAE,EAAG,GAAK,EAAG,GAAI,IAC1B,EAAG,IAAM,EAAE,EAAE,IAAM,EAAE,IAAK,GAC1B,EAAG,IAAM,EAAE,EAAG,GAAK,EAAE,IAAK,GAC1B,EAAE,KAAO,EAAE,EAAG,GAAK,EAAG,GAAI,IAC1B,EAAE,KAAO,EAAE,EAAE,IAAM,EAAG,GAAI,IAC1B,EAAG,IAAM,EAAE,EAAG,GAAK,EAAG,GAAI,GAC1B,EAAG,IAAM,EAAE,EAAG,GAAK,EAAG,GAAI,GAC1B,EAAG,IAAM,EAAE,EAAG,GAAK,EAAG,GAAI,IAC1B,EAAG,IAAM,EAAE,EAAG,GAAK,EAAG,GAAI,IAC1B,EAAG,IAAM,EAAE,EAAG,GAAK,EAAG,GAAI,GAC1B,EAAG,IAAM,EAAE,EAAG,GAAK,EAAG,GAAI,GAC1B,EAAG,IAAM,EAAE,EAAG,GAAK,EAAG,GAAI,IAC1B,EAAG,IAAM,EAAE,EAAG,GAAK,EAAG,GAAI,IAC1B,EAAE,KAAO,EAAE,EAAE,IAAM,EAAG,GAAI,GAC1B,EAAG,IAAM,EAAE,EAAE,IAAM,EAAE,IAAK,GAC1B,EAAG,IAAM,EAAE,EAAG,GAAK,EAAE,IAAK,IAC1B,EAAE,KAAO,EAAE,EAAG,GAAK,EAAG,GAAI,IAC1B,EAAE,KAAO,EAAE,EAAE,IAAM,EAAE,IAAK,GAC1B,EAAE,KAAO,EAAE,EAAE,IAAM,EAAE,IAAK,GAC1B,EAAE,KAAO,EAAE,EAAE,IAAM,EAAE,IAAK,IAC1B,EAAE,KAAO,EAAE,EAAE,IAAM,EAAE,IAAK,IAG9B,IAAK,IAAI,EAAI,EAAG,EAAI,KAAM,EACtB,EAAE,IAAM,EAAE,EAElB,CAGA,SAAS,EAAS,EAAG,EAAI,EAAG,GACxB,IAAK,IAAI,EAAI,EAAG,EAAI,EAAK,IACrB,EAAE,IAAM,EAAE,EAAK,EAEvB,CAEA,SAAS,EAAU,EAAK,EAAQ,EAAM,EAAS,GAC3C,KAAO,KACH,EAAK,KAAa,EAAI,IAE9B,CAEA,SAAS,EAAe,GACpB,IAAK,GAA0B,iBAAd,EAAQ,OAAkB,OAAO,EAElD,IAAK,IAAI,EAAI,EAAG,EAAI,EAAE,OAAQ,IAAK,CAC/B,MAAM,EAAI,EAAE,GACZ,GAAkB,iBAAR,GAAoB,EAAI,GAAK,EAAI,GAAK,GAAK,IACjD,OAAO,CAEf,CAEA,OAAO,CACX,CAEA,SAAS,EAAc,EAAO,GAC1B,GAAsB,iBAAZ,GAAyB,EAAQ,EAAM,MAAM,IAAI,MAAM,WAAa,GAC9E,OAAO,CACX,CAIA,SAAS,EAAQ,EAAU,EAAM,EAAG,EAAG,EAAG,EAAO,GAQ7C,GANA,EAAI,EAAc,EAAG,KACrB,EAAI,EAAc,EAAG,KACrB,EAAI,EAAc,EAAG,KAErB,EAAQ,EAAc,EAAO,SAEnB,IAAN,GAAY,EAAK,EAAI,EAAa,MAAM,IAAI,MAAM,wBAEtD,GAAI,EAAI,EAAY,IAAM,EAAK,MAAM,IAAI,MAAM,eAC/C,GAAI,EAAI,EAAY,IAAM,EAAK,MAAM,IAAI,MAAM,eAE/C,IAAK,EAAe,GAChB,MAAM,IAAI,MAAM,uCAIpB,GAFA,EAAW,MAAM,UAAU,MAAM,KAAK,IAEjC,EAAe,GAChB,MAAM,IAAI,MAAM,mCAEpB,EAAO,MAAM,UAAU,MAAM,KAAK,GAElC,IAAI,EAAI,EAA2B,EAAU,EAAU,IAAJ,EAAU,GAC7D,MAAM,EAAI,IAAI,YAAgB,GAAJ,EAAS,GACnC,IAAK,IAAI,EAAI,EAAG,EAAI,EAAE,OAAQ,IAAK,CAC/B,MAAM,EAAQ,EAAJ,EACV,EAAE,IAAkB,IAAX,EAAE,EAAI,KAAc,IACT,IAAX,EAAE,EAAI,KAAc,IACT,IAAX,EAAE,EAAI,KAAc,EACT,IAAX,EAAE,EAAI,EACnB,CAEA,MAAM,EAAK,IAAI,YAAY,GAAK,GAC1B,EAAI,IAAI,YAAY,GAAK,EAAI,GAE7B,EAAK,GAAK,EAGV,EAAI,IAAI,YAAY,IACpB,EAAK,IAAI,YAAY,IAErB,EAAW,EAAI,EAAI,EACzB,IAQY,EACR,EATA,EAAY,EACZ,EAAgB,KAGhB,GAAO,EAGP,EAAQ,EACR,EAAK,EAIT,MAAM,EAAQ,EAAW,SAAS,IAAO,GAAI,WAGvC,EAAqC,oBAAnB,aAAkC,aAAe,WAInE,EAAkB,WACpB,GAAI,EACA,OAAO,EAAS,IAAI,MAAM,aAAc,EAAY,GAGxD,IAAI,EAEJ,OAAQ,GACJ,KAAK,EAED,EAAU,GAAL,EAAU,EAEf,EAAU,EAAG,EAAI,EAAI,EAAG,GAExB,EAAQ,EACR,EAAK,EAIT,KAAK,EAGD,EAAQ,EAAI,EACR,EAAQ,IAAS,EAAQ,GAC7B,IAAK,IAAI,EAAI,EAAG,EAAI,EAAO,IACvB,EAAU,EAAI,EAAG,GAAI,EAAK,GAAK,EAAI,GACnC,EAAgB,EAAI,EAAI,EAAG,EAAG,GAOlC,GAHA,GAAM,EACN,GAAa,EAET,EAAU,CAEV,MAAM,EAAY,SAAS,IAAO,EAAY,GAC9C,GAAI,IAAc,EAAe,CAE7B,GADA,EAAO,EAAS,KAAM,EAAY,GAC9B,EAAQ,MACZ,EAAgB,CACpB,CACJ,CAEA,GAAI,EAAK,EAAK,MAEd,EAAK,EACL,EAAQ,EAIZ,KAAK,EAGD,EAAQ,EAAI,EACR,EAAQ,IAAS,EAAQ,GAC7B,IAAK,IAAI,EAAI,EAAG,EAAI,EAAO,IAAK,CAC5B,MACM,EAAI,EADmB,IAAb,EAAI,EAAI,IACA,EAAI,EAC5B,EAAS,EAAG,EAAI,EAAI,EAAI,GACxB,EAAgB,EAAI,EAAI,EAAG,EAAG,EAClC,CAOA,GAJA,GAAM,EACN,GAAa,EAGT,EAAU,CACV,MAAM,EAAY,SAAS,IAAO,EAAY,GAC9C,GAAI,IAAc,EAAe,CAE7B,GADA,EAAO,EAAS,KAAM,EAAY,GAC9B,EAAQ,MACZ,EAAgB,CACpB,CACJ,CAEA,GAAI,EAAK,EAAK,MAMd,GAJA,EAAU,EAAI,EAAG,EAAG,EAAI,GAGxB,IACI,EAAK,EAAG,CACR,EAAQ,EACR,KACJ,CAEA,EAAI,GACJ,IAAK,IAAI,EAAI,EAAG,EAAI,EAAE,OAAQ,IAC1B,EAAE,KAAoB,IAAd,EAAE,IACV,EAAE,KAAM,EAAE,IAAO,EAAK,KACtB,EAAE,KAAM,EAAE,IAAM,GAAM,KACtB,EAAE,KAAM,EAAE,IAAM,GAAM,KAG1B,MAAM,EAAa,EAA2B,EAAU,EAAG,GAM3D,OAHI,GAAY,EAAS,KAAM,EAAK,GAG7B,EAIX,GAAY,EAAS,EAC7B,EAGA,IAAK,EACD,OAAa,CACT,MAAM,EAAa,IACnB,GAAkB,MAAd,EAA2B,OAAO,CAC1C,CAIJ,GACJ,CAEA,MAAM,EAAM,CACR,OAAQ,SAAS,EAAU,EAAM,EAAG,EAAG,EAAG,EAAO,GAC7C,OAAO,IAAI,SAAQ,SAAS,EAAS,GACjC,IAAI,EAAe,EACf,GAAoB,EAAiB,GACzC,EAAQ,EAAU,EAAM,EAAG,EAAG,EAAG,GAAO,SAAS,EAAO,EAAU,GAC9D,GAAI,EACA,EAAO,QACJ,GAAI,EACH,GAAqC,IAAjB,GACpB,EAAiB,GAErB,EAAQ,IAAI,WAAW,SACpB,GAAI,GAAoB,IAAa,EAExC,OADA,EAAe,EACR,EAAiB,EAEhC,GACJ,GACJ,EACA,WAAY,SAAS,EAAU,EAAM,EAAG,EAAG,EAAG,GAC1C,OAAO,IAAI,WAAW,EAAQ,EAAU,EAAM,EAAG,EAAG,EAAG,GAC3D,GAIoB,oBAAd,QACP,OAAO,QAAU,EAKU,mBAAb,QAA2B,OAAO,IAC/C,OAAO,GAGA,IAGH,EAAK,SACL,EAAK,QAAU,EAAK,QAGxB,EAAK,OAAS,EAGrB,CAreD,CAqeG","file":"/npm/scrypt-js@3.0.0/scrypt.js","sourceRoot":"","sourcesContent":["/**\n * Minified by jsDelivr using Terser v5.39.0.\n * Original file: /npm/scrypt-js@3.0.0/scrypt.js\n *\n * Do NOT use SRI with dynamically generated files! More information: https://www.jsdelivr.com/using-sri-with-dynamic-files\n */\n","\"use strict\";\n\n(function(root) {\n    const MAX_VALUE = 0x7fffffff;\n\n    // The SHA256 and PBKDF2 implementation are from scrypt-async-js:\n    // See: https://github.com/dchest/scrypt-async-js\n    function SHA256(m) {\n        const K = new Uint32Array([\n           0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b,\n           0x59f111f1, 0x923f82a4, 0xab1c5ed5, 0xd807aa98, 0x12835b01,\n           0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7,\n           0xc19bf174, 0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc,\n           0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da, 0x983e5152,\n           0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147,\n           0x06ca6351, 0x14292967, 0x27b70a85, 0x2e1b2138, 0x4d2c6dfc,\n           0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,\n           0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819,\n           0xd6990624, 0xf40e3585, 0x106aa070, 0x19a4c116, 0x1e376c08,\n           0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f,\n           0x682e6ff3, 0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208,\n           0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2\n       ]);\n\n        let h0 = 0x6a09e667, h1 = 0xbb67ae85, h2 = 0x3c6ef372, h3 = 0xa54ff53a;\n        let h4 = 0x510e527f, h5 = 0x9b05688c, h6 = 0x1f83d9ab, h7 = 0x5be0cd19;\n        const w = new Uint32Array(64);\n\n        function blocks(p) {\n            let off = 0, len = p.length;\n            while (len >= 64) {\n                let a = h0, b = h1, c = h2, d = h3, e = h4, f = h5, g = h6, h = h7, u, i, j, t1, t2;\n\n                for (i = 0; i < 16; i++) {\n                    j = off + i*4;\n                    w[i] = ((p[j] & 0xff)<<24) | ((p[j+1] & 0xff)<<16) |\n                    ((p[j+2] & 0xff)<<8) | (p[j+3] & 0xff);\n                }\n\n                for (i = 16; i < 64; i++) {\n                    u = w[i-2];\n                    t1 = ((u>>>17) | (u<<(32-17))) ^ ((u>>>19) | (u<<(32-19))) ^ (u>>>10);\n\n                    u = w[i-15];\n                    t2 = ((u>>>7) | (u<<(32-7))) ^ ((u>>>18) | (u<<(32-18))) ^ (u>>>3);\n\n                    w[i] = (((t1 + w[i-7]) | 0) + ((t2 + w[i-16]) | 0)) | 0;\n                }\n\n                for (i = 0; i < 64; i++) {\n                    t1 = ((((((e>>>6) | (e<<(32-6))) ^ ((e>>>11) | (e<<(32-11))) ^\n                             ((e>>>25) | (e<<(32-25)))) + ((e & f) ^ (~e & g))) | 0) +\n                          ((h + ((K[i] + w[i]) | 0)) | 0)) | 0;\n\n                    t2 = ((((a>>>2) | (a<<(32-2))) ^ ((a>>>13) | (a<<(32-13))) ^\n                           ((a>>>22) | (a<<(32-22)))) + ((a & b) ^ (a & c) ^ (b & c))) | 0;\n\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                h0 = (h0 + a) | 0;\n                h1 = (h1 + b) | 0;\n                h2 = (h2 + c) | 0;\n                h3 = (h3 + d) | 0;\n                h4 = (h4 + e) | 0;\n                h5 = (h5 + f) | 0;\n                h6 = (h6 + g) | 0;\n                h7 = (h7 + h) | 0;\n\n                off += 64;\n                len -= 64;\n            }\n        }\n\n        blocks(m);\n\n        let i, bytesLeft = m.length % 64,\n        bitLenHi = (m.length / 0x20000000) | 0,\n        bitLenLo = m.length << 3,\n        numZeros = (bytesLeft < 56) ? 56 : 120,\n        p = m.slice(m.length - bytesLeft, m.length);\n\n        p.push(0x80);\n        for (i = bytesLeft + 1; i < numZeros; i++) { p.push(0); }\n        p.push((bitLenHi >>> 24) & 0xff);\n        p.push((bitLenHi >>> 16) & 0xff);\n        p.push((bitLenHi >>> 8)  & 0xff);\n        p.push((bitLenHi >>> 0)  & 0xff);\n        p.push((bitLenLo >>> 24) & 0xff);\n        p.push((bitLenLo >>> 16) & 0xff);\n        p.push((bitLenLo >>> 8)  & 0xff);\n        p.push((bitLenLo >>> 0)  & 0xff);\n\n        blocks(p);\n\n        return [\n            (h0 >>> 24) & 0xff, (h0 >>> 16) & 0xff, (h0 >>> 8) & 0xff, (h0 >>> 0) & 0xff,\n            (h1 >>> 24) & 0xff, (h1 >>> 16) & 0xff, (h1 >>> 8) & 0xff, (h1 >>> 0) & 0xff,\n            (h2 >>> 24) & 0xff, (h2 >>> 16) & 0xff, (h2 >>> 8) & 0xff, (h2 >>> 0) & 0xff,\n            (h3 >>> 24) & 0xff, (h3 >>> 16) & 0xff, (h3 >>> 8) & 0xff, (h3 >>> 0) & 0xff,\n            (h4 >>> 24) & 0xff, (h4 >>> 16) & 0xff, (h4 >>> 8) & 0xff, (h4 >>> 0) & 0xff,\n            (h5 >>> 24) & 0xff, (h5 >>> 16) & 0xff, (h5 >>> 8) & 0xff, (h5 >>> 0) & 0xff,\n            (h6 >>> 24) & 0xff, (h6 >>> 16) & 0xff, (h6 >>> 8) & 0xff, (h6 >>> 0) & 0xff,\n            (h7 >>> 24) & 0xff, (h7 >>> 16) & 0xff, (h7 >>> 8) & 0xff, (h7 >>> 0) & 0xff\n        ];\n    }\n\n    function PBKDF2_HMAC_SHA256_OneIter(password, salt, dkLen) {\n        // compress password if it's longer than hash block length\n        password = (password.length <= 64) ? password : SHA256(password);\n\n        const innerLen = 64 + salt.length + 4;\n        const inner = new Array(innerLen);\n        const outerKey = new Array(64);\n\n        let i;\n        let dk = [];\n\n        // inner = (password ^ ipad) || salt || counter\n        for (i = 0; i < 64; i++) { inner[i] = 0x36; }\n        for (i = 0; i < password.length; i++) { inner[i] ^= password[i]; }\n        for (i = 0; i < salt.length; i++) { inner[64 + i] = salt[i]; }\n        for (i = innerLen - 4; i < innerLen; i++) { inner[i] = 0; }\n\n        // outerKey = password ^ opad\n        for (i = 0; i < 64; i++) outerKey[i] = 0x5c;\n        for (i = 0; i < password.length; i++) outerKey[i] ^= password[i];\n\n        // increments counter inside inner\n        function incrementCounter() {\n            for (let i = innerLen - 1; i >= innerLen - 4; i--) {\n                inner[i]++;\n                if (inner[i] <= 0xff) return;\n                inner[i] = 0;\n            }\n        }\n\n        // output blocks = SHA256(outerKey || SHA256(inner)) ...\n        while (dkLen >= 32) {\n            incrementCounter();\n            dk = dk.concat(SHA256(outerKey.concat(SHA256(inner))));\n            dkLen -= 32;\n        }\n        if (dkLen > 0) {\n            incrementCounter();\n            dk = dk.concat(SHA256(outerKey.concat(SHA256(inner))).slice(0, dkLen));\n        }\n\n        return dk;\n    }\n\n    // The following is an adaptation of scryptsy\n    // See: https://www.npmjs.com/package/scryptsy\n    function blockmix_salsa8(BY, Yi, r, x, _X) {\n        let i;\n\n        arraycopy(BY, (2 * r - 1) * 16, _X, 0, 16);\n        for (i = 0; i < 2 * r; i++) {\n            blockxor(BY, i * 16, _X, 16);\n            salsa20_8(_X, x);\n            arraycopy(_X, 0, BY, Yi + (i * 16), 16);\n        }\n\n        for (i = 0; i < r; i++) {\n            arraycopy(BY, Yi + (i * 2) * 16, BY, (i * 16), 16);\n        }\n\n        for (i = 0; i < r; i++) {\n            arraycopy(BY, Yi + (i * 2 + 1) * 16, BY, (i + r) * 16, 16);\n        }\n    }\n\n    function R(a, b) {\n        return (a << b) | (a >>> (32 - b));\n    }\n\n    function salsa20_8(B, x) {\n        arraycopy(B, 0, x, 0, 16);\n\n        for (let i = 8; i > 0; i -= 2) {\n            x[ 4] ^= R(x[ 0] + x[12], 7);\n            x[ 8] ^= R(x[ 4] + x[ 0], 9);\n            x[12] ^= R(x[ 8] + x[ 4], 13);\n            x[ 0] ^= R(x[12] + x[ 8], 18);\n            x[ 9] ^= R(x[ 5] + x[ 1], 7);\n            x[13] ^= R(x[ 9] + x[ 5], 9);\n            x[ 1] ^= R(x[13] + x[ 9], 13);\n            x[ 5] ^= R(x[ 1] + x[13], 18);\n            x[14] ^= R(x[10] + x[ 6], 7);\n            x[ 2] ^= R(x[14] + x[10], 9);\n            x[ 6] ^= R(x[ 2] + x[14], 13);\n            x[10] ^= R(x[ 6] + x[ 2], 18);\n            x[ 3] ^= R(x[15] + x[11], 7);\n            x[ 7] ^= R(x[ 3] + x[15], 9);\n            x[11] ^= R(x[ 7] + x[ 3], 13);\n            x[15] ^= R(x[11] + x[ 7], 18);\n            x[ 1] ^= R(x[ 0] + x[ 3], 7);\n            x[ 2] ^= R(x[ 1] + x[ 0], 9);\n            x[ 3] ^= R(x[ 2] + x[ 1], 13);\n            x[ 0] ^= R(x[ 3] + x[ 2], 18);\n            x[ 6] ^= R(x[ 5] + x[ 4], 7);\n            x[ 7] ^= R(x[ 6] + x[ 5], 9);\n            x[ 4] ^= R(x[ 7] + x[ 6], 13);\n            x[ 5] ^= R(x[ 4] + x[ 7], 18);\n            x[11] ^= R(x[10] + x[ 9], 7);\n            x[ 8] ^= R(x[11] + x[10], 9);\n            x[ 9] ^= R(x[ 8] + x[11], 13);\n            x[10] ^= R(x[ 9] + x[ 8], 18);\n            x[12] ^= R(x[15] + x[14], 7);\n            x[13] ^= R(x[12] + x[15], 9);\n            x[14] ^= R(x[13] + x[12], 13);\n            x[15] ^= R(x[14] + x[13], 18);\n        }\n\n        for (let i = 0; i < 16; ++i) {\n            B[i] += x[i];\n        }\n    }\n\n    // naive approach... going back to loop unrolling may yield additional performance\n    function blockxor(S, Si, D, len) {\n        for (let i = 0; i < len; i++) {\n            D[i] ^= S[Si + i]\n        }\n    }\n\n    function arraycopy(src, srcPos, dest, destPos, length) {\n        while (length--) {\n            dest[destPos++] = src[srcPos++];\n        }\n    }\n\n    function checkBufferish(o) {\n        if (!o || typeof(o.length) !== 'number') { return false; }\n\n        for (let i = 0; i < o.length; i++) {\n            const v = o[i];\n            if (typeof(v) !== 'number' || v % 1 || v < 0 || v >= 256) {\n                return false;\n            }\n        }\n\n        return true;\n    }\n\n    function ensureInteger(value, name) {\n        if (typeof(value) !== \"number\" || (value % 1)) { throw new Error('invalid ' + name); }\n        return value;\n    }\n\n    // N = Cpu cost, r = Memory cost, p = parallelization cost\n    // callback(error, progress, key)\n    function _scrypt(password, salt, N, r, p, dkLen, callback) {\n\n        N = ensureInteger(N, 'N');\n        r = ensureInteger(r, 'r');\n        p = ensureInteger(p, 'p');\n\n        dkLen = ensureInteger(dkLen, 'dkLen');\n\n        if (N === 0 || (N & (N - 1)) !== 0) { throw new Error('N must be power of 2'); }\n\n        if (N > MAX_VALUE / 128 / r) { throw new Error('N too large'); }\n        if (r > MAX_VALUE / 128 / p) { throw new Error('r too large'); }\n\n        if (!checkBufferish(password)) {\n            throw new Error('password must be an array or buffer');\n        }\n        password = Array.prototype.slice.call(password);\n\n        if (!checkBufferish(salt)) {\n            throw new Error('salt must be an array or buffer');\n        }\n        salt = Array.prototype.slice.call(salt);\n\n        let b = PBKDF2_HMAC_SHA256_OneIter(password, salt, p * 128 * r);\n        const B = new Uint32Array(p * 32 * r)\n        for (let i = 0; i < B.length; i++) {\n            const j = i * 4;\n            B[i] = ((b[j + 3] & 0xff) << 24) |\n                   ((b[j + 2] & 0xff) << 16) |\n                   ((b[j + 1] & 0xff) << 8) |\n                   ((b[j + 0] & 0xff) << 0);\n        }\n\n        const XY = new Uint32Array(64 * r);\n        const V = new Uint32Array(32 * r * N);\n\n        const Yi = 32 * r;\n\n        // scratch space\n        const x = new Uint32Array(16);       // salsa20_8\n        const _X = new Uint32Array(16);      // blockmix_salsa8\n\n        const totalOps = p * N * 2;\n        let currentOp = 0;\n        let lastPercent10 = null;\n\n        // Set this to true to abandon the scrypt on the next step\n        let stop = false;\n\n        // State information\n        let state = 0;\n        let i0 = 0, i1;\n        let Bi;\n\n        // How many blockmix_salsa8 can we do per step?\n        const limit = callback ? parseInt(1000 / r): 0xffffffff;\n\n        // Trick from scrypt-async; if there is a setImmediate shim in place, use it\n        const nextTick = (typeof(setImmediate) !== 'undefined') ? setImmediate : setTimeout;\n\n        // This is really all I changed; making scryptsy a state machine so we occasionally\n        // stop and give other evnts on the evnt loop a chance to run. ~RicMoo\n        const incrementalSMix = function() {\n            if (stop) {\n                return callback(new Error('cancelled'), currentOp / totalOps);\n            }\n\n            let steps;\n\n            switch (state) {\n                case 0:\n                    // for (var i = 0; i < p; i++)...\n                    Bi = i0 * 32 * r;\n\n                    arraycopy(B, Bi, XY, 0, Yi);                       // ROMix - 1\n\n                    state = 1;                                         // Move to ROMix 2\n                    i1 = 0;\n\n                    // Fall through\n\n                case 1:\n\n                    // Run up to 1000 steps of the first inner smix loop\n                    steps = N - i1;\n                    if (steps > limit) { steps = limit; }\n                    for (let i = 0; i < steps; i++) {                  // ROMix - 2\n                        arraycopy(XY, 0, V, (i1 + i) * Yi, Yi)         // ROMix - 3\n                        blockmix_salsa8(XY, Yi, r, x, _X);             // ROMix - 4\n                    }\n\n                    // for (var i = 0; i < N; i++)\n                    i1 += steps;\n                    currentOp += steps;\n\n                    if (callback) {\n                        // Call the callback with the progress (optionally stopping us)\n                        const percent10 = parseInt(1000 * currentOp / totalOps);\n                        if (percent10 !== lastPercent10) {\n                            stop = callback(null, currentOp / totalOps);\n                            if (stop) { break; }\n                            lastPercent10 = percent10;\n                        }\n                    }\n\n                    if (i1 < N) { break; }\n\n                    i1 = 0;                                          // Move to ROMix 6\n                    state = 2;\n\n                    // Fall through\n\n                case 2:\n\n                    // Run up to 1000 steps of the second inner smix loop\n                    steps = N - i1;\n                    if (steps > limit) { steps = limit; }\n                    for (let i = 0; i < steps; i++) {                // ROMix - 6\n                        const offset = (2 * r - 1) * 16;             // ROMix - 7\n                        const j = XY[offset] & (N - 1);\n                        blockxor(V, j * Yi, XY, Yi);                 // ROMix - 8 (inner)\n                        blockmix_salsa8(XY, Yi, r, x, _X);           // ROMix - 9 (outer)\n                    }\n\n                    // for (var i = 0; i < N; i++)...\n                    i1 += steps;\n                    currentOp += steps;\n\n                    // Call the callback with the progress (optionally stopping us)\n                    if (callback) {\n                        const percent10 = parseInt(1000 * currentOp / totalOps);\n                        if (percent10 !== lastPercent10) {\n                            stop = callback(null, currentOp / totalOps);\n                            if (stop) { break; }\n                            lastPercent10 = percent10;\n                        }\n                    }\n\n                    if (i1 < N) { break; }\n\n                    arraycopy(XY, 0, B, Bi, Yi);                     // ROMix - 10\n\n                    // for (var i = 0; i < p; i++)...\n                    i0++;\n                    if (i0 < p) {\n                        state = 0;\n                        break;\n                    }\n\n                    b = [];\n                    for (let i = 0; i < B.length; i++) {\n                        b.push((B[i] >>  0) & 0xff);\n                        b.push((B[i] >>  8) & 0xff);\n                        b.push((B[i] >> 16) & 0xff);\n                        b.push((B[i] >> 24) & 0xff);\n                    }\n\n                    const derivedKey = PBKDF2_HMAC_SHA256_OneIter(password, b, dkLen);\n\n                    // Send the result to the callback\n                    if (callback) { callback(null, 1.0, derivedKey); }\n\n                    // Done; don't break (which would reschedule)\n                    return derivedKey;\n            }\n\n            // Schedule the next steps\n            if (callback) { nextTick(incrementalSMix); }\n        }\n\n        // Run the smix state machine until completion\n        if (!callback) {\n            while (true) {\n                const derivedKey = incrementalSMix();\n                if (derivedKey != undefined) { return derivedKey; }\n            }\n        }\n\n        // Bootstrap the async incremental smix\n        incrementalSMix();\n    }\n\n    const lib = {\n        scrypt: function(password, salt, N, r, p, dkLen, progressCallback) {\n            return new Promise(function(resolve, reject) {\n                let lastProgress = 0;\n                if (progressCallback) { progressCallback(0); }\n                _scrypt(password, salt, N, r, p, dkLen, function(error, progress, key) {\n                    if (error) {\n                        reject(error);\n                    } else if (key) {\n                        if (progressCallback && lastProgress !== 1) {\n                            progressCallback(1);\n                        }\n                        resolve(new Uint8Array(key));\n                    } else if (progressCallback && progress !== lastProgress) {\n                        lastProgress = progress;\n                        return progressCallback(progress);\n                    }\n                });\n            });\n        },\n        syncScrypt: function(password, salt, N, r, p, dkLen) {\n            return new Uint8Array(_scrypt(password, salt, N, r, p, dkLen));\n        }\n    };\n\n    // node.js\n    if (typeof(exports) !== 'undefined') {\n       module.exports = lib;\n\n    // RequireJS/AMD\n    // http://www.requirejs.org/docs/api.html\n    // https://github.com/amdjs/amdjs-api/wiki/AMD\n    } else if (typeof(define) === 'function' && define.amd) {\n        define(lib);\n\n    // Web Browsers\n    } else if (root) {\n\n        // If there was an existing library \"scrypt\", make sure it is still available\n        if (root.scrypt) {\n            root._scrypt = root.scrypt;\n        }\n\n        root.scrypt = lib;\n    }\n\n})(this);\n"]}