{"version":3,"sources":["webpack:///webpack/universalModuleDefinition","webpack:///amazon-cognito-identity.min.js","webpack:///webpack/bootstrap 491cfc370b425e28b040","webpack:///./src/index.js","webpack:////Users/dnnoyes/release-repo/~/buffer/index.js","webpack:///./~/crypto-browserify/helpers.js","webpack:///./src/AuthenticationHelper.js","webpack:///./src/BigInteger.js","webpack:///./src/CognitoAccessToken.js","webpack:///./src/CognitoIdToken.js","webpack:///./src/CognitoJwtToken.js","webpack:///./src/CognitoRefreshToken.js","webpack:///./src/CognitoUser.js","webpack:///./src/CognitoUserAttribute.js","webpack:///./src/CognitoUserSession.js","webpack:///./src/DateHelper.js","webpack:///./src/StorageHelper.js","webpack:///./~/crypto-browserify/index.js","webpack:////Users/dnnoyes/release-repo/~/base64-js/index.js","webpack:////Users/dnnoyes/release-repo/~/ieee754/index.js","webpack:////Users/dnnoyes/release-repo/~/isarray/index.js","webpack:////Users/dnnoyes/release-repo/~/js-cookie/src/js.cookie.js","webpack:///./src/AuthenticationDetails.js","webpack:///./src/Client.js","webpack:///./src/CognitoUserPool.js","webpack:///./src/CookieStorage.js","webpack:///./src/UserAgent.js","webpack:///./~/crypto-browserify/md5.js","webpack:///./~/crypto-browserify/rng.js","webpack:///./~/crypto-browserify/sha.js","webpack:///./~/crypto-browserify/sha256.js"],"names":["root","factory","exports","module","define","amd","AmazonCognitoIdentity","this","modules","__webpack_require__","moduleId","installedModules","id","loaded","call","m","c","p","_interopRequireDefault","obj","__esModule","default","_AuthenticationDetails","Object","defineProperty","enumerable","get","_AuthenticationHelper","_CognitoAccessToken","_CognitoIdToken","_CognitoRefreshToken","_CognitoUser","_CognitoUserAttribute","_CognitoUserPool","_CognitoUserSession","_CookieStorage","_DateHelper","global","typedArraySupport","arr","Uint8Array","__proto__","prototype","foo","subarray","byteLength","e","kMaxLength","Buffer","TYPED_ARRAY_SUPPORT","createBuffer","that","length","RangeError","arg","encodingOrOffset","Error","allocUnsafe","from","value","TypeError","ArrayBuffer","fromArrayBuffer","fromString","fromObject","assertSize","size","alloc","fill","encoding","undefined","checked","i","string","isEncoding","actual","write","slice","fromArrayLike","array","byteOffset","isBuffer","len","copy","buffer","isnan","type","isArray","data","toString","SlowBuffer","isView","loweredCase","utf8ToBytes","base64ToBytes","toLowerCase","slowToString","start","end","hexSlice","utf8Slice","asciiSlice","latin1Slice","base64Slice","utf16leSlice","swap","b","n","bidirectionalIndexOf","val","dir","isNaN","arrayIndexOf","indexOf","lastIndexOf","read","buf","indexSize","readUInt16BE","arrLength","valLength","String","foundIndex","found","j","hexWrite","offset","Number","remaining","strLen","parsed","parseInt","substr","utf8Write","blitBuffer","asciiWrite","asciiToBytes","latin1Write","base64Write","ucs2Write","utf16leToBytes","base64","fromByteArray","Math","min","res","firstByte","codePoint","bytesPerSequence","secondByte","thirdByte","fourthByte","tempCodePoint","push","decodeCodePointsArray","codePoints","MAX_ARGUMENTS_LENGTH","fromCharCode","apply","ret","out","toHex","bytes","checkOffset","ext","checkInt","max","objectWriteUInt16","littleEndian","objectWriteUInt32","checkIEEE754","writeFloat","noAssert","ieee754","writeDouble","base64clean","str","stringtrim","replace","INVALID_BASE64_RE","trim","units","Infinity","leadSurrogate","charCodeAt","byteArray","hi","lo","toByteArray","src","dst","INSPECT_MAX_BYTES","poolSize","_augment","Symbol","species","configurable","allocUnsafeSlow","_isBuffer","compare","a","x","y","concat","list","pos","swap16","swap32","swap64","arguments","equals","inspect","match","join","target","thisStart","thisEnd","thisCopy","targetCopy","includes","isFinite","toJSON","Array","_arr","newBuf","sliceLen","readUIntLE","mul","readUIntBE","readUInt8","readUInt16LE","readUInt32LE","readUInt32BE","readIntLE","pow","readIntBE","readInt8","readInt16LE","readInt16BE","readInt32LE","readInt32BE","readFloatLE","readFloatBE","readDoubleLE","readDoubleBE","writeUIntLE","maxBytes","writeUIntBE","writeUInt8","floor","writeUInt16LE","writeUInt16BE","writeUInt32LE","writeUInt32BE","writeIntLE","limit","sub","writeIntBE","writeInt8","writeInt16LE","writeInt16BE","writeInt32LE","writeInt32BE","writeFloatLE","writeFloatBE","writeDoubleLE","writeDoubleBE","targetStart","set","code","toArray","bigEndian","intSize","zeroBuffer","fn","toBuffer","hash","hashSize","chrsz","_interopRequireWildcard","newObj","key","hasOwnProperty","_classCallCheck","instance","Constructor","_buffer","_cryptoBrowserify","crypto","_BigInteger","_BigInteger2","createHash","createHmac","randomBytes","initN","newPasswordRequiredChallengeUserAttributePrefix","AuthenticationHelper","PoolName","N","BigInteger","g","k","hexHash","smallAValue","generateRandomSmallA","getLargeAValue","infoBits","poolName","getSmallAValue","callback","_this","largeAValue","calculateA","err","hexRandom","randomBigInt","smallABigInt","mod","generateRandomString","getRandomPassword","randomPassword","getSaltDevices","SaltToHashDevices","getVerifierDevices","verifierDevices","generateHashDevice","deviceGroupKey","username","_this2","combinedString","hashedString","padHex","modPow","verifierDevicesNotPadded","_this3","A","ZERO","calculateU","B","UHexHash","finalU","hashHex","update","digest","hexStr","computehkdf","ikm","salt","prk","infoBitsUpdate","hmac","getPasswordAuthenticationKey","password","serverBValue","_this4","UValue","usernamePassword","usernamePasswordHash","xValue","calculateS","sValue","hkdf","_this5","gModPowXN","intValue2","subtract","multiply","add","err2","result","getNewPasswordRequiredChallengeUserAttributePrefix","bigInt","hashStr","nbi","am1","w","v","am2","xl","xh","l","h","am3","int2char","BI_RM","charAt","intAt","s","BI_RC","bnpCopyTo","r","t","bnpFromInt","DV","nbv","fromInt","bnpFromString","mi","sh","DB","clamp","subTo","bnpClamp","DM","bnToString","negate","d","km","bnNegate","bnAbs","bnCompareTo","nbits","bnBitLength","bnpDLShiftTo","bnpDRShiftTo","bnpLShiftTo","bs","cbs","bm","ds","bnpRShiftTo","bnpSubTo","bnpMultiplyTo","abs","am","bnpSquareTo","bnpDivRemTo","q","pm","pt","copyTo","ts","ms","nsh","lShiftTo","ys","y0","yt","F1","F2","d1","FV","d2","dlShiftTo","compareTo","ONE","qd","drShiftTo","rShiftTo","bnMod","divRemTo","bnpInvDigit","bnEquals","bnpAddTo","bnAdd","addTo","bnSubtract","bnMultiply","multiplyTo","bnDivide","Montgomery","mp","invDigit","mpl","mph","um","mt2","montConvert","montRevert","reduce","montReduce","u0","montSqrTo","squareTo","montMulTo","bnModPow","bitLength","z","k1","convert","g2","sqrTo","mulTo","is1","r2","revert","dbits","canary","j_lm","inBrowser","navigator","appName","BI_FP","rr","vv","divide","_possibleConstructorReturn","self","ReferenceError","_inherits","subClass","superClass","create","constructor","writable","setPrototypeOf","_CognitoJwtToken2","_CognitoJwtToken3","CognitoAccessToken","_CognitoJwtToken","_ref","AccessToken","CognitoJwtToken","CognitoIdToken","IdToken","token","jwtToken","payload","decodePayload","getJwtToken","getExpiration","exp","getIssuedAt","iat","split","JSON","parse","CognitoRefreshToken","RefreshToken","getToken","_AuthenticationHelper2","_CognitoAccessToken2","_CognitoIdToken2","_CognitoRefreshToken2","_CognitoUserSession2","_DateHelper2","_CognitoUserAttribute2","_StorageHelper","_StorageHelper2","CognitoUser","Username","Pool","pool","Session","client","signInUserSession","authenticationFlowType","storage","Storage","StorageHelper","getStorage","setSignInUserSession","clearCachedTokens","cacheTokens","getSignInUserSession","getUsername","getAuthenticationFlowType","setAuthenticationFlowType","initiateAuth","authDetails","authParameters","getAuthParameters","USERNAME","jsonReq","AuthFlow","ClientId","getClientId","AuthParameters","ClientMetadata","getValidationData","getUserContextData","UserContextData","request","onFailure","challengeName","ChallengeName","challengeParameters","ChallengeParameters","customChallenge","getCognitoUserSession","AuthenticationResult","onSuccess","authenticateUser","authenticateUserPlainUsernamePassword","authenticateUserDefaultAuth","authenticationHelper","getUserPoolId","dateHelper","DateHelper","deviceKey","DEVICE_KEY","errOnAValue","aValue","SRP_A","CHALLENGE_NAME","USER_ID_FOR_SRP","SRP_B","SALT","getCachedDeviceKeyAndPassword","getPassword","errOnHkdf","dateNow","getNowString","signatureString","SECRET_BLOCK","challengeResponses","PASSWORD_CLAIM_SECRET_BLOCK","TIMESTAMP","PASSWORD_CLAIM_SIGNATURE","respondToAuthChallenge","challenge","challengeCallback","errChallenge","dataChallenge","message","clearCachedDeviceKeyAndPassword","jsonReqResp","ChallengeResponses","errAuthenticate","dataAuthenticate","userAttributes","rawRequiredAttributes","requiredAttributes","userAttributesPrefix","newPasswordRequired","authenticateUserInternal","PASSWORD","authResult","mfaRequired","selectMFAType","mfaSetup","totpRequired","getDeviceResponse","newDeviceMetadata","NewDeviceMetadata","DeviceGroupKey","DeviceKey","errGenHash","deviceSecretVerifierConfig","Salt","PasswordVerifier","getAccessToken","DeviceSecretVerifierConfig","DeviceName","userAgent","errConfirm","dataConfirm","cacheDeviceKeyAndPassword","UserConfirmationNecessary","completeNewPasswordChallenge","newPassword","requiredAttributeData","finalUserAttributes","keys","forEach","NEW_PASSWORD","_this6","errAValue","errHkdf","confirmRegistration","confirmationCode","forceAliasCreation","ConfirmationCode","ForceAliasCreation","sendCustomChallengeAnswer","answerChallenge","_this7","ANSWER","sendMFACode","mfaType","_this8","SMS_MFA_CODE","mfaTypeSelection","SOFTWARE_TOKEN_MFA_CODE","changePassword","oldUserPassword","newUserPassword","isValid","PreviousPassword","ProposedPassword","enableMFA","mfaOptions","mfaEnabled","DeliveryMedium","AttributeName","MFAOptions","setUserMfaPreference","smsMfaSettings","softwareTokenMfaSettings","SMSMfaSettings","SoftwareTokenMfaSettings","disableMFA","deleteUser","_this9","updateAttributes","attributes","UserAttributes","getUserAttributes","userData","attributeList","attribute","Name","Value","userAttribute","CognitoUserAttribute","getMFAOptions","getUserData","deleteAttributes","UserAttributeNames","resendConfirmationCode","getSession","keyPrefix","idTokenKey","accessTokenKey","refreshTokenKey","clockDriftKey","getItem","idToken","accessToken","refreshToken","clockDrift","sessionData","ClockDrift","cachedSession","CognitoUserSession","refreshSession","_this10","REFRESH_TOKEN","lastUserKey","deviceKeyKey","authenticationResult","setItem","getIdToken","getRefreshToken","getClockDrift","randomPasswordKey","deviceGroupKeyKey","removeItem","forgotPassword","inputVerificationCode","confirmPassword","Password","getAttributeVerificationCode","attributeName","verifyAttribute","Code","getDevice","forgetSpecificDevice","forgetDevice","_this11","setDeviceStatusRemembered","DeviceRememberedStatus","setDeviceStatusNotRemembered","listDevices","paginationToken","Limit","PaginationToken","globalSignOut","_this12","signOut","sendMFASelectionAnswer","_this13","associateSoftwareToken","_this14","associateSecretCode","SecretCode","verifySoftwareToken","totpCode","friendlyDeviceName","_this15","UserCode","FriendlyDeviceName","errRespond","dataRespond","getValue","setValue","getName","setName","name","stringify","calculateClockDrift","now","Date","adjusted","monthNames","weekNames","weekDay","getUTCDay","month","getUTCMonth","day","getUTCDate","hours","getUTCHours","minutes","getUTCMinutes","seconds","getUTCSeconds","year","getUTCFullYear","dataMemory","MemoryStorage","clear","storageWindow","window","localStorage","exception","blocksize","ipad","opad","alg","algorithms","bufs","error","enc","each","f","sha","sha256","rng","md5","sha1","getLens","b64","validLen","placeHoldersLen","lens","_byteLength","tmp","Arr","curByte","revLookup","tripletToBase64","num","lookup","encodeChunk","uint8","output","extraBytes","parts","maxChunkLength","len2","isLE","mLen","nBytes","eLen","eMax","eBias","nBits","NaN","rt","log","LN2","__WEBPACK_AMD_DEFINE_FACTORY__","__WEBPACK_AMD_DEFINE_RESULT__","registeredInModuleLoader","o","OldCookies","Cookies","api","noConflict","extend","init","converter","document","path","defaults","expires","setMilliseconds","getMilliseconds","toUTCString","test","encodeURIComponent","decodeURIComponent","escape","stringifiedAttributes","cookie","cookies","rdecode","json","getJSON","remove","withConverter","AuthenticationDetails","ValidationData","validationData","_UserAgent","_UserAgent2","Client","region","endpoint","UserAgent","operation","params","headers","Content-Type","X-Amz-Target","X-Amz-User-Agent","options","method","mode","cache","body","response","fetch","then","resp","catch","ok","__type","pop","Message","statusCode","status","ex","_Client","_Client2","_CognitoUser2","CognitoUserPool","UserPoolId","AdvancedSecurityDataCollectionFlag","userPoolId","clientId","advancedSecurityDataCollectionFlag","signUp","cognitoUser","returnData","user","userConfirmed","UserConfirmed","userSub","UserSub","getCurrentUser","lastAuthUser","AmazonCognitoAdvancedSecurityData","amazonCognitoAdvancedSecurityDataConst","advancedSecurityData","getData","userContextData","EncodedData","_jsCookie","CookieStorage","domain","secure","index","core_md5","olda","oldb","oldc","oldd","md5_ff","md5_gg","md5_hh","md5_ii","safe_add","md5_cmn","bit_rol","lsw","msw","cnt","helpers","mathRNG","whatwgRNG","_global","random","getRandomValues","core_sha1","olde","rol","sha1_ft","sha1_kt","S","X","R","Ch","Maj","Sigma0256","Sigma1256","Gamma0256","Gamma1256","core_sha256","T1","T2","K","HASH","W"],"mappings":"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","file":"amazon-cognito-identity.min.js","sourcesContent":["(function webpackUniversalModuleDefinition(root, factory) {\n\tif(typeof exports === 'object' && typeof module === 'object')\n\t\tmodule.exports = factory();\n\telse if(typeof define === 'function' && define.amd)\n\t\tdefine([], factory);\n\telse if(typeof exports === 'object')\n\t\texports[\"AmazonCognitoIdentity\"] = factory();\n\telse\n\t\troot[\"AmazonCognitoIdentity\"] = factory();\n})(this, function() {\nreturn \n\n\n// WEBPACK FOOTER //\n// webpack/universalModuleDefinition","/*!\n * Copyright 2016 Amazon.com,\n * Inc. or its affiliates. All Rights Reserved.\n * \n * Licensed under the Amazon Software License (the \"License\").\n * You may not use this file except in compliance with the\n * License. A copy of the License is located at\n * \n *     http://aws.amazon.com/asl/\n * \n * or in the \"license\" file accompanying this file. This file is\n * distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR\n * CONDITIONS OF ANY KIND, express or implied. See the License\n * for the specific language governing permissions and\n * limitations under the License. \n */\n\n\n(function webpackUniversalModuleDefinition(root, factory) {\n\tif(typeof exports === 'object' && typeof module === 'object')\n\t\tmodule.exports = factory();\n\telse if(typeof define === 'function' && define.amd)\n\t\tdefine([], factory);\n\telse if(typeof exports === 'object')\n\t\texports[\"AmazonCognitoIdentity\"] = factory();\n\telse\n\t\troot[\"AmazonCognitoIdentity\"] = factory();\n})(this, function() {\nreturn /******/ (function(modules) { // webpackBootstrap\n/******/ \t// The module cache\n/******/ \tvar installedModules = {};\n/******/\n/******/ \t// The require function\n/******/ \tfunction __webpack_require__(moduleId) {\n/******/\n/******/ \t\t// Check if module is in cache\n/******/ \t\tif(installedModules[moduleId])\n/******/ \t\t\treturn installedModules[moduleId].exports;\n/******/\n/******/ \t\t// Create a new module (and put it into the cache)\n/******/ \t\tvar module = installedModules[moduleId] = {\n/******/ \t\t\texports: {},\n/******/ \t\t\tid: moduleId,\n/******/ \t\t\tloaded: false\n/******/ \t\t};\n/******/\n/******/ \t\t// Execute the module function\n/******/ \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n/******/\n/******/ \t\t// Flag the module as loaded\n/******/ \t\tmodule.loaded = true;\n/******/\n/******/ \t\t// Return the exports of the module\n/******/ \t\treturn module.exports;\n/******/ \t}\n/******/\n/******/\n/******/ \t// expose the modules object (__webpack_modules__)\n/******/ \t__webpack_require__.m = modules;\n/******/\n/******/ \t// expose the module cache\n/******/ \t__webpack_require__.c = installedModules;\n/******/\n/******/ \t// __webpack_public_path__\n/******/ \t__webpack_require__.p = \"\";\n/******/\n/******/ \t// Load entry module and return exports\n/******/ \treturn __webpack_require__(0);\n/******/ })\n/************************************************************************/\n/******/ ([\n/* 0 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\t'use strict';\n\t\n\texports.__esModule = true;\n\t\n\tvar _AuthenticationDetails = __webpack_require__(19);\n\t\n\tObject.defineProperty(exports, 'AuthenticationDetails', {\n\t  enumerable: true,\n\t  get: function get() {\n\t    return _interopRequireDefault(_AuthenticationDetails).default;\n\t  }\n\t});\n\t\n\tvar _AuthenticationHelper = __webpack_require__(3);\n\t\n\tObject.defineProperty(exports, 'AuthenticationHelper', {\n\t  enumerable: true,\n\t  get: function get() {\n\t    return _interopRequireDefault(_AuthenticationHelper).default;\n\t  }\n\t});\n\t\n\tvar _CognitoAccessToken = __webpack_require__(5);\n\t\n\tObject.defineProperty(exports, 'CognitoAccessToken', {\n\t  enumerable: true,\n\t  get: function get() {\n\t    return _interopRequireDefault(_CognitoAccessToken).default;\n\t  }\n\t});\n\t\n\tvar _CognitoIdToken = __webpack_require__(6);\n\t\n\tObject.defineProperty(exports, 'CognitoIdToken', {\n\t  enumerable: true,\n\t  get: function get() {\n\t    return _interopRequireDefault(_CognitoIdToken).default;\n\t  }\n\t});\n\t\n\tvar _CognitoRefreshToken = __webpack_require__(8);\n\t\n\tObject.defineProperty(exports, 'CognitoRefreshToken', {\n\t  enumerable: true,\n\t  get: function get() {\n\t    return _interopRequireDefault(_CognitoRefreshToken).default;\n\t  }\n\t});\n\t\n\tvar _CognitoUser = __webpack_require__(9);\n\t\n\tObject.defineProperty(exports, 'CognitoUser', {\n\t  enumerable: true,\n\t  get: function get() {\n\t    return _interopRequireDefault(_CognitoUser).default;\n\t  }\n\t});\n\t\n\tvar _CognitoUserAttribute = __webpack_require__(10);\n\t\n\tObject.defineProperty(exports, 'CognitoUserAttribute', {\n\t  enumerable: true,\n\t  get: function get() {\n\t    return _interopRequireDefault(_CognitoUserAttribute).default;\n\t  }\n\t});\n\t\n\tvar _CognitoUserPool = __webpack_require__(21);\n\t\n\tObject.defineProperty(exports, 'CognitoUserPool', {\n\t  enumerable: true,\n\t  get: function get() {\n\t    return _interopRequireDefault(_CognitoUserPool).default;\n\t  }\n\t});\n\t\n\tvar _CognitoUserSession = __webpack_require__(11);\n\t\n\tObject.defineProperty(exports, 'CognitoUserSession', {\n\t  enumerable: true,\n\t  get: function get() {\n\t    return _interopRequireDefault(_CognitoUserSession).default;\n\t  }\n\t});\n\t\n\tvar _CookieStorage = __webpack_require__(22);\n\t\n\tObject.defineProperty(exports, 'CookieStorage', {\n\t  enumerable: true,\n\t  get: function get() {\n\t    return _interopRequireDefault(_CookieStorage).default;\n\t  }\n\t});\n\t\n\tvar _DateHelper = __webpack_require__(12);\n\t\n\tObject.defineProperty(exports, 'DateHelper', {\n\t  enumerable: true,\n\t  get: function get() {\n\t    return _interopRequireDefault(_DateHelper).default;\n\t  }\n\t});\n\n\tfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\n/***/ }),\n/* 1 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\t/* WEBPACK VAR INJECTION */(function(global) {/*!\n\t * The buffer module from node.js, for the browser.\n\t *\n\t * @author   Feross Aboukhadijeh <feross@feross.org> <http://feross.org>\n\t * @license  MIT\n\t */\n\t/* eslint-disable no-proto */\n\t\n\t'use strict'\n\t\n\tvar base64 = __webpack_require__(15)\n\tvar ieee754 = __webpack_require__(16)\n\tvar isArray = __webpack_require__(17)\n\t\n\texports.Buffer = Buffer\n\texports.SlowBuffer = SlowBuffer\n\texports.INSPECT_MAX_BYTES = 50\n\t\n\t/**\n\t * If `Buffer.TYPED_ARRAY_SUPPORT`:\n\t *   === true    Use Uint8Array implementation (fastest)\n\t *   === false   Use Object implementation (most compatible, even IE6)\n\t *\n\t * Browsers that support typed arrays are IE 10+, Firefox 4+, Chrome 7+, Safari 5.1+,\n\t * Opera 11.6+, iOS 4.2+.\n\t *\n\t * Due to various browser bugs, sometimes the Object implementation will be used even\n\t * when the browser supports typed arrays.\n\t *\n\t * Note:\n\t *\n\t *   - Firefox 4-29 lacks support for adding new properties to `Uint8Array` instances,\n\t *     See: https://bugzilla.mozilla.org/show_bug.cgi?id=695438.\n\t *\n\t *   - Chrome 9-10 is missing the `TypedArray.prototype.subarray` function.\n\t *\n\t *   - IE10 has a broken `TypedArray.prototype.subarray` function which returns arrays of\n\t *     incorrect length in some situations.\n\t\n\t * We detect these buggy browsers and set `Buffer.TYPED_ARRAY_SUPPORT` to `false` so they\n\t * get the Object implementation, which is slower but behaves correctly.\n\t */\n\tBuffer.TYPED_ARRAY_SUPPORT = global.TYPED_ARRAY_SUPPORT !== undefined\n\t  ? global.TYPED_ARRAY_SUPPORT\n\t  : typedArraySupport()\n\t\n\t/*\n\t * Export kMaxLength after typed array support is determined.\n\t */\n\texports.kMaxLength = kMaxLength()\n\t\n\tfunction typedArraySupport () {\n\t  try {\n\t    var arr = new Uint8Array(1)\n\t    arr.__proto__ = {__proto__: Uint8Array.prototype, foo: function () { return 42 }}\n\t    return arr.foo() === 42 && // typed array instances can be augmented\n\t        typeof arr.subarray === 'function' && // chrome 9-10 lack `subarray`\n\t        arr.subarray(1, 1).byteLength === 0 // ie10 has broken `subarray`\n\t  } catch (e) {\n\t    return false\n\t  }\n\t}\n\t\n\tfunction kMaxLength () {\n\t  return Buffer.TYPED_ARRAY_SUPPORT\n\t    ? 0x7fffffff\n\t    : 0x3fffffff\n\t}\n\t\n\tfunction createBuffer (that, length) {\n\t  if (kMaxLength() < length) {\n\t    throw new RangeError('Invalid typed array length')\n\t  }\n\t  if (Buffer.TYPED_ARRAY_SUPPORT) {\n\t    // Return an augmented `Uint8Array` instance, for best performance\n\t    that = new Uint8Array(length)\n\t    that.__proto__ = Buffer.prototype\n\t  } else {\n\t    // Fallback: Return an object instance of the Buffer class\n\t    if (that === null) {\n\t      that = new Buffer(length)\n\t    }\n\t    that.length = length\n\t  }\n\t\n\t  return that\n\t}\n\t\n\t/**\n\t * The Buffer constructor returns instances of `Uint8Array` that have their\n\t * prototype changed to `Buffer.prototype`. Furthermore, `Buffer` is a subclass of\n\t * `Uint8Array`, so the returned instances will have all the node `Buffer` methods\n\t * and the `Uint8Array` methods. Square bracket notation works as expected -- it\n\t * returns a single octet.\n\t *\n\t * The `Uint8Array` prototype remains unmodified.\n\t */\n\t\n\tfunction Buffer (arg, encodingOrOffset, length) {\n\t  if (!Buffer.TYPED_ARRAY_SUPPORT && !(this instanceof Buffer)) {\n\t    return new Buffer(arg, encodingOrOffset, length)\n\t  }\n\t\n\t  // Common case.\n\t  if (typeof arg === 'number') {\n\t    if (typeof encodingOrOffset === 'string') {\n\t      throw new Error(\n\t        'If encoding is specified then the first argument must be a string'\n\t      )\n\t    }\n\t    return allocUnsafe(this, arg)\n\t  }\n\t  return from(this, arg, encodingOrOffset, length)\n\t}\n\t\n\tBuffer.poolSize = 8192 // not used by this implementation\n\t\n\t// TODO: Legacy, not needed anymore. Remove in next major version.\n\tBuffer._augment = function (arr) {\n\t  arr.__proto__ = Buffer.prototype\n\t  return arr\n\t}\n\t\n\tfunction from (that, value, encodingOrOffset, length) {\n\t  if (typeof value === 'number') {\n\t    throw new TypeError('\"value\" argument must not be a number')\n\t  }\n\t\n\t  if (typeof ArrayBuffer !== 'undefined' && value instanceof ArrayBuffer) {\n\t    return fromArrayBuffer(that, value, encodingOrOffset, length)\n\t  }\n\t\n\t  if (typeof value === 'string') {\n\t    return fromString(that, value, encodingOrOffset)\n\t  }\n\t\n\t  return fromObject(that, value)\n\t}\n\t\n\t/**\n\t * Functionally equivalent to Buffer(arg, encoding) but throws a TypeError\n\t * if value is a number.\n\t * Buffer.from(str[, encoding])\n\t * Buffer.from(array)\n\t * Buffer.from(buffer)\n\t * Buffer.from(arrayBuffer[, byteOffset[, length]])\n\t **/\n\tBuffer.from = function (value, encodingOrOffset, length) {\n\t  return from(null, value, encodingOrOffset, length)\n\t}\n\t\n\tif (Buffer.TYPED_ARRAY_SUPPORT) {\n\t  Buffer.prototype.__proto__ = Uint8Array.prototype\n\t  Buffer.__proto__ = Uint8Array\n\t  if (typeof Symbol !== 'undefined' && Symbol.species &&\n\t      Buffer[Symbol.species] === Buffer) {\n\t    // Fix subarray() in ES2016. See: https://github.com/feross/buffer/pull/97\n\t    Object.defineProperty(Buffer, Symbol.species, {\n\t      value: null,\n\t      configurable: true\n\t    })\n\t  }\n\t}\n\t\n\tfunction assertSize (size) {\n\t  if (typeof size !== 'number') {\n\t    throw new TypeError('\"size\" argument must be a number')\n\t  } else if (size < 0) {\n\t    throw new RangeError('\"size\" argument must not be negative')\n\t  }\n\t}\n\t\n\tfunction alloc (that, size, fill, encoding) {\n\t  assertSize(size)\n\t  if (size <= 0) {\n\t    return createBuffer(that, size)\n\t  }\n\t  if (fill !== undefined) {\n\t    // Only pay attention to encoding if it's a string. This\n\t    // prevents accidentally sending in a number that would\n\t    // be interpretted as a start offset.\n\t    return typeof encoding === 'string'\n\t      ? createBuffer(that, size).fill(fill, encoding)\n\t      : createBuffer(that, size).fill(fill)\n\t  }\n\t  return createBuffer(that, size)\n\t}\n\t\n\t/**\n\t * Creates a new filled Buffer instance.\n\t * alloc(size[, fill[, encoding]])\n\t **/\n\tBuffer.alloc = function (size, fill, encoding) {\n\t  return alloc(null, size, fill, encoding)\n\t}\n\t\n\tfunction allocUnsafe (that, size) {\n\t  assertSize(size)\n\t  that = createBuffer(that, size < 0 ? 0 : checked(size) | 0)\n\t  if (!Buffer.TYPED_ARRAY_SUPPORT) {\n\t    for (var i = 0; i < size; ++i) {\n\t      that[i] = 0\n\t    }\n\t  }\n\t  return that\n\t}\n\t\n\t/**\n\t * Equivalent to Buffer(num), by default creates a non-zero-filled Buffer instance.\n\t * */\n\tBuffer.allocUnsafe = function (size) {\n\t  return allocUnsafe(null, size)\n\t}\n\t/**\n\t * Equivalent to SlowBuffer(num), by default creates a non-zero-filled Buffer instance.\n\t */\n\tBuffer.allocUnsafeSlow = function (size) {\n\t  return allocUnsafe(null, size)\n\t}\n\t\n\tfunction fromString (that, string, encoding) {\n\t  if (typeof encoding !== 'string' || encoding === '') {\n\t    encoding = 'utf8'\n\t  }\n\t\n\t  if (!Buffer.isEncoding(encoding)) {\n\t    throw new TypeError('\"encoding\" must be a valid string encoding')\n\t  }\n\t\n\t  var length = byteLength(string, encoding) | 0\n\t  that = createBuffer(that, length)\n\t\n\t  var actual = that.write(string, encoding)\n\t\n\t  if (actual !== length) {\n\t    // Writing a hex string, for example, that contains invalid characters will\n\t    // cause everything after the first invalid character to be ignored. (e.g.\n\t    // 'abxxcd' will be treated as 'ab')\n\t    that = that.slice(0, actual)\n\t  }\n\t\n\t  return that\n\t}\n\t\n\tfunction fromArrayLike (that, array) {\n\t  var length = array.length < 0 ? 0 : checked(array.length) | 0\n\t  that = createBuffer(that, length)\n\t  for (var i = 0; i < length; i += 1) {\n\t    that[i] = array[i] & 255\n\t  }\n\t  return that\n\t}\n\t\n\tfunction fromArrayBuffer (that, array, byteOffset, length) {\n\t  array.byteLength // this throws if `array` is not a valid ArrayBuffer\n\t\n\t  if (byteOffset < 0 || array.byteLength < byteOffset) {\n\t    throw new RangeError('\\'offset\\' is out of bounds')\n\t  }\n\t\n\t  if (array.byteLength < byteOffset + (length || 0)) {\n\t    throw new RangeError('\\'length\\' is out of bounds')\n\t  }\n\t\n\t  if (byteOffset === undefined && length === undefined) {\n\t    array = new Uint8Array(array)\n\t  } else if (length === undefined) {\n\t    array = new Uint8Array(array, byteOffset)\n\t  } else {\n\t    array = new Uint8Array(array, byteOffset, length)\n\t  }\n\t\n\t  if (Buffer.TYPED_ARRAY_SUPPORT) {\n\t    // Return an augmented `Uint8Array` instance, for best performance\n\t    that = array\n\t    that.__proto__ = Buffer.prototype\n\t  } else {\n\t    // Fallback: Return an object instance of the Buffer class\n\t    that = fromArrayLike(that, array)\n\t  }\n\t  return that\n\t}\n\t\n\tfunction fromObject (that, obj) {\n\t  if (Buffer.isBuffer(obj)) {\n\t    var len = checked(obj.length) | 0\n\t    that = createBuffer(that, len)\n\t\n\t    if (that.length === 0) {\n\t      return that\n\t    }\n\t\n\t    obj.copy(that, 0, 0, len)\n\t    return that\n\t  }\n\t\n\t  if (obj) {\n\t    if ((typeof ArrayBuffer !== 'undefined' &&\n\t        obj.buffer instanceof ArrayBuffer) || 'length' in obj) {\n\t      if (typeof obj.length !== 'number' || isnan(obj.length)) {\n\t        return createBuffer(that, 0)\n\t      }\n\t      return fromArrayLike(that, obj)\n\t    }\n\t\n\t    if (obj.type === 'Buffer' && isArray(obj.data)) {\n\t      return fromArrayLike(that, obj.data)\n\t    }\n\t  }\n\t\n\t  throw new TypeError('First argument must be a string, Buffer, ArrayBuffer, Array, or array-like object.')\n\t}\n\t\n\tfunction checked (length) {\n\t  // Note: cannot use `length < kMaxLength()` here because that fails when\n\t  // length is NaN (which is otherwise coerced to zero.)\n\t  if (length >= kMaxLength()) {\n\t    throw new RangeError('Attempt to allocate Buffer larger than maximum ' +\n\t                         'size: 0x' + kMaxLength().toString(16) + ' bytes')\n\t  }\n\t  return length | 0\n\t}\n\t\n\tfunction SlowBuffer (length) {\n\t  if (+length != length) { // eslint-disable-line eqeqeq\n\t    length = 0\n\t  }\n\t  return Buffer.alloc(+length)\n\t}\n\t\n\tBuffer.isBuffer = function isBuffer (b) {\n\t  return !!(b != null && b._isBuffer)\n\t}\n\t\n\tBuffer.compare = function compare (a, b) {\n\t  if (!Buffer.isBuffer(a) || !Buffer.isBuffer(b)) {\n\t    throw new TypeError('Arguments must be Buffers')\n\t  }\n\t\n\t  if (a === b) return 0\n\t\n\t  var x = a.length\n\t  var y = b.length\n\t\n\t  for (var i = 0, len = Math.min(x, y); i < len; ++i) {\n\t    if (a[i] !== b[i]) {\n\t      x = a[i]\n\t      y = b[i]\n\t      break\n\t    }\n\t  }\n\t\n\t  if (x < y) return -1\n\t  if (y < x) return 1\n\t  return 0\n\t}\n\t\n\tBuffer.isEncoding = function isEncoding (encoding) {\n\t  switch (String(encoding).toLowerCase()) {\n\t    case 'hex':\n\t    case 'utf8':\n\t    case 'utf-8':\n\t    case 'ascii':\n\t    case 'latin1':\n\t    case 'binary':\n\t    case 'base64':\n\t    case 'ucs2':\n\t    case 'ucs-2':\n\t    case 'utf16le':\n\t    case 'utf-16le':\n\t      return true\n\t    default:\n\t      return false\n\t  }\n\t}\n\t\n\tBuffer.concat = function concat (list, length) {\n\t  if (!isArray(list)) {\n\t    throw new TypeError('\"list\" argument must be an Array of Buffers')\n\t  }\n\t\n\t  if (list.length === 0) {\n\t    return Buffer.alloc(0)\n\t  }\n\t\n\t  var i\n\t  if (length === undefined) {\n\t    length = 0\n\t    for (i = 0; i < list.length; ++i) {\n\t      length += list[i].length\n\t    }\n\t  }\n\t\n\t  var buffer = Buffer.allocUnsafe(length)\n\t  var pos = 0\n\t  for (i = 0; i < list.length; ++i) {\n\t    var buf = list[i]\n\t    if (!Buffer.isBuffer(buf)) {\n\t      throw new TypeError('\"list\" argument must be an Array of Buffers')\n\t    }\n\t    buf.copy(buffer, pos)\n\t    pos += buf.length\n\t  }\n\t  return buffer\n\t}\n\t\n\tfunction byteLength (string, encoding) {\n\t  if (Buffer.isBuffer(string)) {\n\t    return string.length\n\t  }\n\t  if (typeof ArrayBuffer !== 'undefined' && typeof ArrayBuffer.isView === 'function' &&\n\t      (ArrayBuffer.isView(string) || string instanceof ArrayBuffer)) {\n\t    return string.byteLength\n\t  }\n\t  if (typeof string !== 'string') {\n\t    string = '' + string\n\t  }\n\t\n\t  var len = string.length\n\t  if (len === 0) return 0\n\t\n\t  // Use a for loop to avoid recursion\n\t  var loweredCase = false\n\t  for (;;) {\n\t    switch (encoding) {\n\t      case 'ascii':\n\t      case 'latin1':\n\t      case 'binary':\n\t        return len\n\t      case 'utf8':\n\t      case 'utf-8':\n\t      case undefined:\n\t        return utf8ToBytes(string).length\n\t      case 'ucs2':\n\t      case 'ucs-2':\n\t      case 'utf16le':\n\t      case 'utf-16le':\n\t        return len * 2\n\t      case 'hex':\n\t        return len >>> 1\n\t      case 'base64':\n\t        return base64ToBytes(string).length\n\t      default:\n\t        if (loweredCase) return utf8ToBytes(string).length // assume utf8\n\t        encoding = ('' + encoding).toLowerCase()\n\t        loweredCase = true\n\t    }\n\t  }\n\t}\n\tBuffer.byteLength = byteLength\n\t\n\tfunction slowToString (encoding, start, end) {\n\t  var loweredCase = false\n\t\n\t  // No need to verify that \"this.length <= MAX_UINT32\" since it's a read-only\n\t  // property of a typed array.\n\t\n\t  // This behaves neither like String nor Uint8Array in that we set start/end\n\t  // to their upper/lower bounds if the value passed is out of range.\n\t  // undefined is handled specially as per ECMA-262 6th Edition,\n\t  // Section 13.3.3.7 Runtime Semantics: KeyedBindingInitialization.\n\t  if (start === undefined || start < 0) {\n\t    start = 0\n\t  }\n\t  // Return early if start > this.length. Done here to prevent potential uint32\n\t  // coercion fail below.\n\t  if (start > this.length) {\n\t    return ''\n\t  }\n\t\n\t  if (end === undefined || end > this.length) {\n\t    end = this.length\n\t  }\n\t\n\t  if (end <= 0) {\n\t    return ''\n\t  }\n\t\n\t  // Force coersion to uint32. This will also coerce falsey/NaN values to 0.\n\t  end >>>= 0\n\t  start >>>= 0\n\t\n\t  if (end <= start) {\n\t    return ''\n\t  }\n\t\n\t  if (!encoding) encoding = 'utf8'\n\t\n\t  while (true) {\n\t    switch (encoding) {\n\t      case 'hex':\n\t        return hexSlice(this, start, end)\n\t\n\t      case 'utf8':\n\t      case 'utf-8':\n\t        return utf8Slice(this, start, end)\n\t\n\t      case 'ascii':\n\t        return asciiSlice(this, start, end)\n\t\n\t      case 'latin1':\n\t      case 'binary':\n\t        return latin1Slice(this, start, end)\n\t\n\t      case 'base64':\n\t        return base64Slice(this, start, end)\n\t\n\t      case 'ucs2':\n\t      case 'ucs-2':\n\t      case 'utf16le':\n\t      case 'utf-16le':\n\t        return utf16leSlice(this, start, end)\n\t\n\t      default:\n\t        if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)\n\t        encoding = (encoding + '').toLowerCase()\n\t        loweredCase = true\n\t    }\n\t  }\n\t}\n\t\n\t// The property is used by `Buffer.isBuffer` and `is-buffer` (in Safari 5-7) to detect\n\t// Buffer instances.\n\tBuffer.prototype._isBuffer = true\n\t\n\tfunction swap (b, n, m) {\n\t  var i = b[n]\n\t  b[n] = b[m]\n\t  b[m] = i\n\t}\n\t\n\tBuffer.prototype.swap16 = function swap16 () {\n\t  var len = this.length\n\t  if (len % 2 !== 0) {\n\t    throw new RangeError('Buffer size must be a multiple of 16-bits')\n\t  }\n\t  for (var i = 0; i < len; i += 2) {\n\t    swap(this, i, i + 1)\n\t  }\n\t  return this\n\t}\n\t\n\tBuffer.prototype.swap32 = function swap32 () {\n\t  var len = this.length\n\t  if (len % 4 !== 0) {\n\t    throw new RangeError('Buffer size must be a multiple of 32-bits')\n\t  }\n\t  for (var i = 0; i < len; i += 4) {\n\t    swap(this, i, i + 3)\n\t    swap(this, i + 1, i + 2)\n\t  }\n\t  return this\n\t}\n\t\n\tBuffer.prototype.swap64 = function swap64 () {\n\t  var len = this.length\n\t  if (len % 8 !== 0) {\n\t    throw new RangeError('Buffer size must be a multiple of 64-bits')\n\t  }\n\t  for (var i = 0; i < len; i += 8) {\n\t    swap(this, i, i + 7)\n\t    swap(this, i + 1, i + 6)\n\t    swap(this, i + 2, i + 5)\n\t    swap(this, i + 3, i + 4)\n\t  }\n\t  return this\n\t}\n\t\n\tBuffer.prototype.toString = function toString () {\n\t  var length = this.length | 0\n\t  if (length === 0) return ''\n\t  if (arguments.length === 0) return utf8Slice(this, 0, length)\n\t  return slowToString.apply(this, arguments)\n\t}\n\t\n\tBuffer.prototype.equals = function equals (b) {\n\t  if (!Buffer.isBuffer(b)) throw new TypeError('Argument must be a Buffer')\n\t  if (this === b) return true\n\t  return Buffer.compare(this, b) === 0\n\t}\n\t\n\tBuffer.prototype.inspect = function inspect () {\n\t  var str = ''\n\t  var max = exports.INSPECT_MAX_BYTES\n\t  if (this.length > 0) {\n\t    str = this.toString('hex', 0, max).match(/.{2}/g).join(' ')\n\t    if (this.length > max) str += ' ... '\n\t  }\n\t  return '<Buffer ' + str + '>'\n\t}\n\t\n\tBuffer.prototype.compare = function compare (target, start, end, thisStart, thisEnd) {\n\t  if (!Buffer.isBuffer(target)) {\n\t    throw new TypeError('Argument must be a Buffer')\n\t  }\n\t\n\t  if (start === undefined) {\n\t    start = 0\n\t  }\n\t  if (end === undefined) {\n\t    end = target ? target.length : 0\n\t  }\n\t  if (thisStart === undefined) {\n\t    thisStart = 0\n\t  }\n\t  if (thisEnd === undefined) {\n\t    thisEnd = this.length\n\t  }\n\t\n\t  if (start < 0 || end > target.length || thisStart < 0 || thisEnd > this.length) {\n\t    throw new RangeError('out of range index')\n\t  }\n\t\n\t  if (thisStart >= thisEnd && start >= end) {\n\t    return 0\n\t  }\n\t  if (thisStart >= thisEnd) {\n\t    return -1\n\t  }\n\t  if (start >= end) {\n\t    return 1\n\t  }\n\t\n\t  start >>>= 0\n\t  end >>>= 0\n\t  thisStart >>>= 0\n\t  thisEnd >>>= 0\n\t\n\t  if (this === target) return 0\n\t\n\t  var x = thisEnd - thisStart\n\t  var y = end - start\n\t  var len = Math.min(x, y)\n\t\n\t  var thisCopy = this.slice(thisStart, thisEnd)\n\t  var targetCopy = target.slice(start, end)\n\t\n\t  for (var i = 0; i < len; ++i) {\n\t    if (thisCopy[i] !== targetCopy[i]) {\n\t      x = thisCopy[i]\n\t      y = targetCopy[i]\n\t      break\n\t    }\n\t  }\n\t\n\t  if (x < y) return -1\n\t  if (y < x) return 1\n\t  return 0\n\t}\n\t\n\t// Finds either the first index of `val` in `buffer` at offset >= `byteOffset`,\n\t// OR the last index of `val` in `buffer` at offset <= `byteOffset`.\n\t//\n\t// Arguments:\n\t// - buffer - a Buffer to search\n\t// - val - a string, Buffer, or number\n\t// - byteOffset - an index into `buffer`; will be clamped to an int32\n\t// - encoding - an optional encoding, relevant is val is a string\n\t// - dir - true for indexOf, false for lastIndexOf\n\tfunction bidirectionalIndexOf (buffer, val, byteOffset, encoding, dir) {\n\t  // Empty buffer means no match\n\t  if (buffer.length === 0) return -1\n\t\n\t  // Normalize byteOffset\n\t  if (typeof byteOffset === 'string') {\n\t    encoding = byteOffset\n\t    byteOffset = 0\n\t  } else if (byteOffset > 0x7fffffff) {\n\t    byteOffset = 0x7fffffff\n\t  } else if (byteOffset < -0x80000000) {\n\t    byteOffset = -0x80000000\n\t  }\n\t  byteOffset = +byteOffset  // Coerce to Number.\n\t  if (isNaN(byteOffset)) {\n\t    // byteOffset: it it's undefined, null, NaN, \"foo\", etc, search whole buffer\n\t    byteOffset = dir ? 0 : (buffer.length - 1)\n\t  }\n\t\n\t  // Normalize byteOffset: negative offsets start from the end of the buffer\n\t  if (byteOffset < 0) byteOffset = buffer.length + byteOffset\n\t  if (byteOffset >= buffer.length) {\n\t    if (dir) return -1\n\t    else byteOffset = buffer.length - 1\n\t  } else if (byteOffset < 0) {\n\t    if (dir) byteOffset = 0\n\t    else return -1\n\t  }\n\t\n\t  // Normalize val\n\t  if (typeof val === 'string') {\n\t    val = Buffer.from(val, encoding)\n\t  }\n\t\n\t  // Finally, search either indexOf (if dir is true) or lastIndexOf\n\t  if (Buffer.isBuffer(val)) {\n\t    // Special case: looking for empty string/buffer always fails\n\t    if (val.length === 0) {\n\t      return -1\n\t    }\n\t    return arrayIndexOf(buffer, val, byteOffset, encoding, dir)\n\t  } else if (typeof val === 'number') {\n\t    val = val & 0xFF // Search for a byte value [0-255]\n\t    if (Buffer.TYPED_ARRAY_SUPPORT &&\n\t        typeof Uint8Array.prototype.indexOf === 'function') {\n\t      if (dir) {\n\t        return Uint8Array.prototype.indexOf.call(buffer, val, byteOffset)\n\t      } else {\n\t        return Uint8Array.prototype.lastIndexOf.call(buffer, val, byteOffset)\n\t      }\n\t    }\n\t    return arrayIndexOf(buffer, [ val ], byteOffset, encoding, dir)\n\t  }\n\t\n\t  throw new TypeError('val must be string, number or Buffer')\n\t}\n\t\n\tfunction arrayIndexOf (arr, val, byteOffset, encoding, dir) {\n\t  var indexSize = 1\n\t  var arrLength = arr.length\n\t  var valLength = val.length\n\t\n\t  if (encoding !== undefined) {\n\t    encoding = String(encoding).toLowerCase()\n\t    if (encoding === 'ucs2' || encoding === 'ucs-2' ||\n\t        encoding === 'utf16le' || encoding === 'utf-16le') {\n\t      if (arr.length < 2 || val.length < 2) {\n\t        return -1\n\t      }\n\t      indexSize = 2\n\t      arrLength /= 2\n\t      valLength /= 2\n\t      byteOffset /= 2\n\t    }\n\t  }\n\t\n\t  function read (buf, i) {\n\t    if (indexSize === 1) {\n\t      return buf[i]\n\t    } else {\n\t      return buf.readUInt16BE(i * indexSize)\n\t    }\n\t  }\n\t\n\t  var i\n\t  if (dir) {\n\t    var foundIndex = -1\n\t    for (i = byteOffset; i < arrLength; i++) {\n\t      if (read(arr, i) === read(val, foundIndex === -1 ? 0 : i - foundIndex)) {\n\t        if (foundIndex === -1) foundIndex = i\n\t        if (i - foundIndex + 1 === valLength) return foundIndex * indexSize\n\t      } else {\n\t        if (foundIndex !== -1) i -= i - foundIndex\n\t        foundIndex = -1\n\t      }\n\t    }\n\t  } else {\n\t    if (byteOffset + valLength > arrLength) byteOffset = arrLength - valLength\n\t    for (i = byteOffset; i >= 0; i--) {\n\t      var found = true\n\t      for (var j = 0; j < valLength; j++) {\n\t        if (read(arr, i + j) !== read(val, j)) {\n\t          found = false\n\t          break\n\t        }\n\t      }\n\t      if (found) return i\n\t    }\n\t  }\n\t\n\t  return -1\n\t}\n\t\n\tBuffer.prototype.includes = function includes (val, byteOffset, encoding) {\n\t  return this.indexOf(val, byteOffset, encoding) !== -1\n\t}\n\t\n\tBuffer.prototype.indexOf = function indexOf (val, byteOffset, encoding) {\n\t  return bidirectionalIndexOf(this, val, byteOffset, encoding, true)\n\t}\n\t\n\tBuffer.prototype.lastIndexOf = function lastIndexOf (val, byteOffset, encoding) {\n\t  return bidirectionalIndexOf(this, val, byteOffset, encoding, false)\n\t}\n\t\n\tfunction hexWrite (buf, string, offset, length) {\n\t  offset = Number(offset) || 0\n\t  var remaining = buf.length - offset\n\t  if (!length) {\n\t    length = remaining\n\t  } else {\n\t    length = Number(length)\n\t    if (length > remaining) {\n\t      length = remaining\n\t    }\n\t  }\n\t\n\t  // must be an even number of digits\n\t  var strLen = string.length\n\t  if (strLen % 2 !== 0) throw new TypeError('Invalid hex string')\n\t\n\t  if (length > strLen / 2) {\n\t    length = strLen / 2\n\t  }\n\t  for (var i = 0; i < length; ++i) {\n\t    var parsed = parseInt(string.substr(i * 2, 2), 16)\n\t    if (isNaN(parsed)) return i\n\t    buf[offset + i] = parsed\n\t  }\n\t  return i\n\t}\n\t\n\tfunction utf8Write (buf, string, offset, length) {\n\t  return blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length)\n\t}\n\t\n\tfunction asciiWrite (buf, string, offset, length) {\n\t  return blitBuffer(asciiToBytes(string), buf, offset, length)\n\t}\n\t\n\tfunction latin1Write (buf, string, offset, length) {\n\t  return asciiWrite(buf, string, offset, length)\n\t}\n\t\n\tfunction base64Write (buf, string, offset, length) {\n\t  return blitBuffer(base64ToBytes(string), buf, offset, length)\n\t}\n\t\n\tfunction ucs2Write (buf, string, offset, length) {\n\t  return blitBuffer(utf16leToBytes(string, buf.length - offset), buf, offset, length)\n\t}\n\t\n\tBuffer.prototype.write = function write (string, offset, length, encoding) {\n\t  // Buffer#write(string)\n\t  if (offset === undefined) {\n\t    encoding = 'utf8'\n\t    length = this.length\n\t    offset = 0\n\t  // Buffer#write(string, encoding)\n\t  } else if (length === undefined && typeof offset === 'string') {\n\t    encoding = offset\n\t    length = this.length\n\t    offset = 0\n\t  // Buffer#write(string, offset[, length][, encoding])\n\t  } else if (isFinite(offset)) {\n\t    offset = offset | 0\n\t    if (isFinite(length)) {\n\t      length = length | 0\n\t      if (encoding === undefined) encoding = 'utf8'\n\t    } else {\n\t      encoding = length\n\t      length = undefined\n\t    }\n\t  // legacy write(string, encoding, offset, length) - remove in v0.13\n\t  } else {\n\t    throw new Error(\n\t      'Buffer.write(string, encoding, offset[, length]) is no longer supported'\n\t    )\n\t  }\n\t\n\t  var remaining = this.length - offset\n\t  if (length === undefined || length > remaining) length = remaining\n\t\n\t  if ((string.length > 0 && (length < 0 || offset < 0)) || offset > this.length) {\n\t    throw new RangeError('Attempt to write outside buffer bounds')\n\t  }\n\t\n\t  if (!encoding) encoding = 'utf8'\n\t\n\t  var loweredCase = false\n\t  for (;;) {\n\t    switch (encoding) {\n\t      case 'hex':\n\t        return hexWrite(this, string, offset, length)\n\t\n\t      case 'utf8':\n\t      case 'utf-8':\n\t        return utf8Write(this, string, offset, length)\n\t\n\t      case 'ascii':\n\t        return asciiWrite(this, string, offset, length)\n\t\n\t      case 'latin1':\n\t      case 'binary':\n\t        return latin1Write(this, string, offset, length)\n\t\n\t      case 'base64':\n\t        // Warning: maxLength not taken into account in base64Write\n\t        return base64Write(this, string, offset, length)\n\t\n\t      case 'ucs2':\n\t      case 'ucs-2':\n\t      case 'utf16le':\n\t      case 'utf-16le':\n\t        return ucs2Write(this, string, offset, length)\n\t\n\t      default:\n\t        if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)\n\t        encoding = ('' + encoding).toLowerCase()\n\t        loweredCase = true\n\t    }\n\t  }\n\t}\n\t\n\tBuffer.prototype.toJSON = function toJSON () {\n\t  return {\n\t    type: 'Buffer',\n\t    data: Array.prototype.slice.call(this._arr || this, 0)\n\t  }\n\t}\n\t\n\tfunction base64Slice (buf, start, end) {\n\t  if (start === 0 && end === buf.length) {\n\t    return base64.fromByteArray(buf)\n\t  } else {\n\t    return base64.fromByteArray(buf.slice(start, end))\n\t  }\n\t}\n\t\n\tfunction utf8Slice (buf, start, end) {\n\t  end = Math.min(buf.length, end)\n\t  var res = []\n\t\n\t  var i = start\n\t  while (i < end) {\n\t    var firstByte = buf[i]\n\t    var codePoint = null\n\t    var bytesPerSequence = (firstByte > 0xEF) ? 4\n\t      : (firstByte > 0xDF) ? 3\n\t      : (firstByte > 0xBF) ? 2\n\t      : 1\n\t\n\t    if (i + bytesPerSequence <= end) {\n\t      var secondByte, thirdByte, fourthByte, tempCodePoint\n\t\n\t      switch (bytesPerSequence) {\n\t        case 1:\n\t          if (firstByte < 0x80) {\n\t            codePoint = firstByte\n\t          }\n\t          break\n\t        case 2:\n\t          secondByte = buf[i + 1]\n\t          if ((secondByte & 0xC0) === 0x80) {\n\t            tempCodePoint = (firstByte & 0x1F) << 0x6 | (secondByte & 0x3F)\n\t            if (tempCodePoint > 0x7F) {\n\t              codePoint = tempCodePoint\n\t            }\n\t          }\n\t          break\n\t        case 3:\n\t          secondByte = buf[i + 1]\n\t          thirdByte = buf[i + 2]\n\t          if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80) {\n\t            tempCodePoint = (firstByte & 0xF) << 0xC | (secondByte & 0x3F) << 0x6 | (thirdByte & 0x3F)\n\t            if (tempCodePoint > 0x7FF && (tempCodePoint < 0xD800 || tempCodePoint > 0xDFFF)) {\n\t              codePoint = tempCodePoint\n\t            }\n\t          }\n\t          break\n\t        case 4:\n\t          secondByte = buf[i + 1]\n\t          thirdByte = buf[i + 2]\n\t          fourthByte = buf[i + 3]\n\t          if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80 && (fourthByte & 0xC0) === 0x80) {\n\t            tempCodePoint = (firstByte & 0xF) << 0x12 | (secondByte & 0x3F) << 0xC | (thirdByte & 0x3F) << 0x6 | (fourthByte & 0x3F)\n\t            if (tempCodePoint > 0xFFFF && tempCodePoint < 0x110000) {\n\t              codePoint = tempCodePoint\n\t            }\n\t          }\n\t      }\n\t    }\n\t\n\t    if (codePoint === null) {\n\t      // we did not generate a valid codePoint so insert a\n\t      // replacement char (U+FFFD) and advance only 1 byte\n\t      codePoint = 0xFFFD\n\t      bytesPerSequence = 1\n\t    } else if (codePoint > 0xFFFF) {\n\t      // encode to utf16 (surrogate pair dance)\n\t      codePoint -= 0x10000\n\t      res.push(codePoint >>> 10 & 0x3FF | 0xD800)\n\t      codePoint = 0xDC00 | codePoint & 0x3FF\n\t    }\n\t\n\t    res.push(codePoint)\n\t    i += bytesPerSequence\n\t  }\n\t\n\t  return decodeCodePointsArray(res)\n\t}\n\t\n\t// Based on http://stackoverflow.com/a/22747272/680742, the browser with\n\t// the lowest limit is Chrome, with 0x10000 args.\n\t// We go 1 magnitude less, for safety\n\tvar MAX_ARGUMENTS_LENGTH = 0x1000\n\t\n\tfunction decodeCodePointsArray (codePoints) {\n\t  var len = codePoints.length\n\t  if (len <= MAX_ARGUMENTS_LENGTH) {\n\t    return String.fromCharCode.apply(String, codePoints) // avoid extra slice()\n\t  }\n\t\n\t  // Decode in chunks to avoid \"call stack size exceeded\".\n\t  var res = ''\n\t  var i = 0\n\t  while (i < len) {\n\t    res += String.fromCharCode.apply(\n\t      String,\n\t      codePoints.slice(i, i += MAX_ARGUMENTS_LENGTH)\n\t    )\n\t  }\n\t  return res\n\t}\n\t\n\tfunction asciiSlice (buf, start, end) {\n\t  var ret = ''\n\t  end = Math.min(buf.length, end)\n\t\n\t  for (var i = start; i < end; ++i) {\n\t    ret += String.fromCharCode(buf[i] & 0x7F)\n\t  }\n\t  return ret\n\t}\n\t\n\tfunction latin1Slice (buf, start, end) {\n\t  var ret = ''\n\t  end = Math.min(buf.length, end)\n\t\n\t  for (var i = start; i < end; ++i) {\n\t    ret += String.fromCharCode(buf[i])\n\t  }\n\t  return ret\n\t}\n\t\n\tfunction hexSlice (buf, start, end) {\n\t  var len = buf.length\n\t\n\t  if (!start || start < 0) start = 0\n\t  if (!end || end < 0 || end > len) end = len\n\t\n\t  var out = ''\n\t  for (var i = start; i < end; ++i) {\n\t    out += toHex(buf[i])\n\t  }\n\t  return out\n\t}\n\t\n\tfunction utf16leSlice (buf, start, end) {\n\t  var bytes = buf.slice(start, end)\n\t  var res = ''\n\t  for (var i = 0; i < bytes.length; i += 2) {\n\t    res += String.fromCharCode(bytes[i] + bytes[i + 1] * 256)\n\t  }\n\t  return res\n\t}\n\t\n\tBuffer.prototype.slice = function slice (start, end) {\n\t  var len = this.length\n\t  start = ~~start\n\t  end = end === undefined ? len : ~~end\n\t\n\t  if (start < 0) {\n\t    start += len\n\t    if (start < 0) start = 0\n\t  } else if (start > len) {\n\t    start = len\n\t  }\n\t\n\t  if (end < 0) {\n\t    end += len\n\t    if (end < 0) end = 0\n\t  } else if (end > len) {\n\t    end = len\n\t  }\n\t\n\t  if (end < start) end = start\n\t\n\t  var newBuf\n\t  if (Buffer.TYPED_ARRAY_SUPPORT) {\n\t    newBuf = this.subarray(start, end)\n\t    newBuf.__proto__ = Buffer.prototype\n\t  } else {\n\t    var sliceLen = end - start\n\t    newBuf = new Buffer(sliceLen, undefined)\n\t    for (var i = 0; i < sliceLen; ++i) {\n\t      newBuf[i] = this[i + start]\n\t    }\n\t  }\n\t\n\t  return newBuf\n\t}\n\t\n\t/*\n\t * Need to make sure that buffer isn't trying to write out of bounds.\n\t */\n\tfunction checkOffset (offset, ext, length) {\n\t  if ((offset % 1) !== 0 || offset < 0) throw new RangeError('offset is not uint')\n\t  if (offset + ext > length) throw new RangeError('Trying to access beyond buffer length')\n\t}\n\t\n\tBuffer.prototype.readUIntLE = function readUIntLE (offset, byteLength, noAssert) {\n\t  offset = offset | 0\n\t  byteLength = byteLength | 0\n\t  if (!noAssert) checkOffset(offset, byteLength, this.length)\n\t\n\t  var val = this[offset]\n\t  var mul = 1\n\t  var i = 0\n\t  while (++i < byteLength && (mul *= 0x100)) {\n\t    val += this[offset + i] * mul\n\t  }\n\t\n\t  return val\n\t}\n\t\n\tBuffer.prototype.readUIntBE = function readUIntBE (offset, byteLength, noAssert) {\n\t  offset = offset | 0\n\t  byteLength = byteLength | 0\n\t  if (!noAssert) {\n\t    checkOffset(offset, byteLength, this.length)\n\t  }\n\t\n\t  var val = this[offset + --byteLength]\n\t  var mul = 1\n\t  while (byteLength > 0 && (mul *= 0x100)) {\n\t    val += this[offset + --byteLength] * mul\n\t  }\n\t\n\t  return val\n\t}\n\t\n\tBuffer.prototype.readUInt8 = function readUInt8 (offset, noAssert) {\n\t  if (!noAssert) checkOffset(offset, 1, this.length)\n\t  return this[offset]\n\t}\n\t\n\tBuffer.prototype.readUInt16LE = function readUInt16LE (offset, noAssert) {\n\t  if (!noAssert) checkOffset(offset, 2, this.length)\n\t  return this[offset] | (this[offset + 1] << 8)\n\t}\n\t\n\tBuffer.prototype.readUInt16BE = function readUInt16BE (offset, noAssert) {\n\t  if (!noAssert) checkOffset(offset, 2, this.length)\n\t  return (this[offset] << 8) | this[offset + 1]\n\t}\n\t\n\tBuffer.prototype.readUInt32LE = function readUInt32LE (offset, noAssert) {\n\t  if (!noAssert) checkOffset(offset, 4, this.length)\n\t\n\t  return ((this[offset]) |\n\t      (this[offset + 1] << 8) |\n\t      (this[offset + 2] << 16)) +\n\t      (this[offset + 3] * 0x1000000)\n\t}\n\t\n\tBuffer.prototype.readUInt32BE = function readUInt32BE (offset, noAssert) {\n\t  if (!noAssert) checkOffset(offset, 4, this.length)\n\t\n\t  return (this[offset] * 0x1000000) +\n\t    ((this[offset + 1] << 16) |\n\t    (this[offset + 2] << 8) |\n\t    this[offset + 3])\n\t}\n\t\n\tBuffer.prototype.readIntLE = function readIntLE (offset, byteLength, noAssert) {\n\t  offset = offset | 0\n\t  byteLength = byteLength | 0\n\t  if (!noAssert) checkOffset(offset, byteLength, this.length)\n\t\n\t  var val = this[offset]\n\t  var mul = 1\n\t  var i = 0\n\t  while (++i < byteLength && (mul *= 0x100)) {\n\t    val += this[offset + i] * mul\n\t  }\n\t  mul *= 0x80\n\t\n\t  if (val >= mul) val -= Math.pow(2, 8 * byteLength)\n\t\n\t  return val\n\t}\n\t\n\tBuffer.prototype.readIntBE = function readIntBE (offset, byteLength, noAssert) {\n\t  offset = offset | 0\n\t  byteLength = byteLength | 0\n\t  if (!noAssert) checkOffset(offset, byteLength, this.length)\n\t\n\t  var i = byteLength\n\t  var mul = 1\n\t  var val = this[offset + --i]\n\t  while (i > 0 && (mul *= 0x100)) {\n\t    val += this[offset + --i] * mul\n\t  }\n\t  mul *= 0x80\n\t\n\t  if (val >= mul) val -= Math.pow(2, 8 * byteLength)\n\t\n\t  return val\n\t}\n\t\n\tBuffer.prototype.readInt8 = function readInt8 (offset, noAssert) {\n\t  if (!noAssert) checkOffset(offset, 1, this.length)\n\t  if (!(this[offset] & 0x80)) return (this[offset])\n\t  return ((0xff - this[offset] + 1) * -1)\n\t}\n\t\n\tBuffer.prototype.readInt16LE = function readInt16LE (offset, noAssert) {\n\t  if (!noAssert) checkOffset(offset, 2, this.length)\n\t  var val = this[offset] | (this[offset + 1] << 8)\n\t  return (val & 0x8000) ? val | 0xFFFF0000 : val\n\t}\n\t\n\tBuffer.prototype.readInt16BE = function readInt16BE (offset, noAssert) {\n\t  if (!noAssert) checkOffset(offset, 2, this.length)\n\t  var val = this[offset + 1] | (this[offset] << 8)\n\t  return (val & 0x8000) ? val | 0xFFFF0000 : val\n\t}\n\t\n\tBuffer.prototype.readInt32LE = function readInt32LE (offset, noAssert) {\n\t  if (!noAssert) checkOffset(offset, 4, this.length)\n\t\n\t  return (this[offset]) |\n\t    (this[offset + 1] << 8) |\n\t    (this[offset + 2] << 16) |\n\t    (this[offset + 3] << 24)\n\t}\n\t\n\tBuffer.prototype.readInt32BE = function readInt32BE (offset, noAssert) {\n\t  if (!noAssert) checkOffset(offset, 4, this.length)\n\t\n\t  return (this[offset] << 24) |\n\t    (this[offset + 1] << 16) |\n\t    (this[offset + 2] << 8) |\n\t    (this[offset + 3])\n\t}\n\t\n\tBuffer.prototype.readFloatLE = function readFloatLE (offset, noAssert) {\n\t  if (!noAssert) checkOffset(offset, 4, this.length)\n\t  return ieee754.read(this, offset, true, 23, 4)\n\t}\n\t\n\tBuffer.prototype.readFloatBE = function readFloatBE (offset, noAssert) {\n\t  if (!noAssert) checkOffset(offset, 4, this.length)\n\t  return ieee754.read(this, offset, false, 23, 4)\n\t}\n\t\n\tBuffer.prototype.readDoubleLE = function readDoubleLE (offset, noAssert) {\n\t  if (!noAssert) checkOffset(offset, 8, this.length)\n\t  return ieee754.read(this, offset, true, 52, 8)\n\t}\n\t\n\tBuffer.prototype.readDoubleBE = function readDoubleBE (offset, noAssert) {\n\t  if (!noAssert) checkOffset(offset, 8, this.length)\n\t  return ieee754.read(this, offset, false, 52, 8)\n\t}\n\t\n\tfunction checkInt (buf, value, offset, ext, max, min) {\n\t  if (!Buffer.isBuffer(buf)) throw new TypeError('\"buffer\" argument must be a Buffer instance')\n\t  if (value > max || value < min) throw new RangeError('\"value\" argument is out of bounds')\n\t  if (offset + ext > buf.length) throw new RangeError('Index out of range')\n\t}\n\t\n\tBuffer.prototype.writeUIntLE = function writeUIntLE (value, offset, byteLength, noAssert) {\n\t  value = +value\n\t  offset = offset | 0\n\t  byteLength = byteLength | 0\n\t  if (!noAssert) {\n\t    var maxBytes = Math.pow(2, 8 * byteLength) - 1\n\t    checkInt(this, value, offset, byteLength, maxBytes, 0)\n\t  }\n\t\n\t  var mul = 1\n\t  var i = 0\n\t  this[offset] = value & 0xFF\n\t  while (++i < byteLength && (mul *= 0x100)) {\n\t    this[offset + i] = (value / mul) & 0xFF\n\t  }\n\t\n\t  return offset + byteLength\n\t}\n\t\n\tBuffer.prototype.writeUIntBE = function writeUIntBE (value, offset, byteLength, noAssert) {\n\t  value = +value\n\t  offset = offset | 0\n\t  byteLength = byteLength | 0\n\t  if (!noAssert) {\n\t    var maxBytes = Math.pow(2, 8 * byteLength) - 1\n\t    checkInt(this, value, offset, byteLength, maxBytes, 0)\n\t  }\n\t\n\t  var i = byteLength - 1\n\t  var mul = 1\n\t  this[offset + i] = value & 0xFF\n\t  while (--i >= 0 && (mul *= 0x100)) {\n\t    this[offset + i] = (value / mul) & 0xFF\n\t  }\n\t\n\t  return offset + byteLength\n\t}\n\t\n\tBuffer.prototype.writeUInt8 = function writeUInt8 (value, offset, noAssert) {\n\t  value = +value\n\t  offset = offset | 0\n\t  if (!noAssert) checkInt(this, value, offset, 1, 0xff, 0)\n\t  if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value)\n\t  this[offset] = (value & 0xff)\n\t  return offset + 1\n\t}\n\t\n\tfunction objectWriteUInt16 (buf, value, offset, littleEndian) {\n\t  if (value < 0) value = 0xffff + value + 1\n\t  for (var i = 0, j = Math.min(buf.length - offset, 2); i < j; ++i) {\n\t    buf[offset + i] = (value & (0xff << (8 * (littleEndian ? i : 1 - i)))) >>>\n\t      (littleEndian ? i : 1 - i) * 8\n\t  }\n\t}\n\t\n\tBuffer.prototype.writeUInt16LE = function writeUInt16LE (value, offset, noAssert) {\n\t  value = +value\n\t  offset = offset | 0\n\t  if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)\n\t  if (Buffer.TYPED_ARRAY_SUPPORT) {\n\t    this[offset] = (value & 0xff)\n\t    this[offset + 1] = (value >>> 8)\n\t  } else {\n\t    objectWriteUInt16(this, value, offset, true)\n\t  }\n\t  return offset + 2\n\t}\n\t\n\tBuffer.prototype.writeUInt16BE = function writeUInt16BE (value, offset, noAssert) {\n\t  value = +value\n\t  offset = offset | 0\n\t  if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)\n\t  if (Buffer.TYPED_ARRAY_SUPPORT) {\n\t    this[offset] = (value >>> 8)\n\t    this[offset + 1] = (value & 0xff)\n\t  } else {\n\t    objectWriteUInt16(this, value, offset, false)\n\t  }\n\t  return offset + 2\n\t}\n\t\n\tfunction objectWriteUInt32 (buf, value, offset, littleEndian) {\n\t  if (value < 0) value = 0xffffffff + value + 1\n\t  for (var i = 0, j = Math.min(buf.length - offset, 4); i < j; ++i) {\n\t    buf[offset + i] = (value >>> (littleEndian ? i : 3 - i) * 8) & 0xff\n\t  }\n\t}\n\t\n\tBuffer.prototype.writeUInt32LE = function writeUInt32LE (value, offset, noAssert) {\n\t  value = +value\n\t  offset = offset | 0\n\t  if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)\n\t  if (Buffer.TYPED_ARRAY_SUPPORT) {\n\t    this[offset + 3] = (value >>> 24)\n\t    this[offset + 2] = (value >>> 16)\n\t    this[offset + 1] = (value >>> 8)\n\t    this[offset] = (value & 0xff)\n\t  } else {\n\t    objectWriteUInt32(this, value, offset, true)\n\t  }\n\t  return offset + 4\n\t}\n\t\n\tBuffer.prototype.writeUInt32BE = function writeUInt32BE (value, offset, noAssert) {\n\t  value = +value\n\t  offset = offset | 0\n\t  if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)\n\t  if (Buffer.TYPED_ARRAY_SUPPORT) {\n\t    this[offset] = (value >>> 24)\n\t    this[offset + 1] = (value >>> 16)\n\t    this[offset + 2] = (value >>> 8)\n\t    this[offset + 3] = (value & 0xff)\n\t  } else {\n\t    objectWriteUInt32(this, value, offset, false)\n\t  }\n\t  return offset + 4\n\t}\n\t\n\tBuffer.prototype.writeIntLE = function writeIntLE (value, offset, byteLength, noAssert) {\n\t  value = +value\n\t  offset = offset | 0\n\t  if (!noAssert) {\n\t    var limit = Math.pow(2, 8 * byteLength - 1)\n\t\n\t    checkInt(this, value, offset, byteLength, limit - 1, -limit)\n\t  }\n\t\n\t  var i = 0\n\t  var mul = 1\n\t  var sub = 0\n\t  this[offset] = value & 0xFF\n\t  while (++i < byteLength && (mul *= 0x100)) {\n\t    if (value < 0 && sub === 0 && this[offset + i - 1] !== 0) {\n\t      sub = 1\n\t    }\n\t    this[offset + i] = ((value / mul) >> 0) - sub & 0xFF\n\t  }\n\t\n\t  return offset + byteLength\n\t}\n\t\n\tBuffer.prototype.writeIntBE = function writeIntBE (value, offset, byteLength, noAssert) {\n\t  value = +value\n\t  offset = offset | 0\n\t  if (!noAssert) {\n\t    var limit = Math.pow(2, 8 * byteLength - 1)\n\t\n\t    checkInt(this, value, offset, byteLength, limit - 1, -limit)\n\t  }\n\t\n\t  var i = byteLength - 1\n\t  var mul = 1\n\t  var sub = 0\n\t  this[offset + i] = value & 0xFF\n\t  while (--i >= 0 && (mul *= 0x100)) {\n\t    if (value < 0 && sub === 0 && this[offset + i + 1] !== 0) {\n\t      sub = 1\n\t    }\n\t    this[offset + i] = ((value / mul) >> 0) - sub & 0xFF\n\t  }\n\t\n\t  return offset + byteLength\n\t}\n\t\n\tBuffer.prototype.writeInt8 = function writeInt8 (value, offset, noAssert) {\n\t  value = +value\n\t  offset = offset | 0\n\t  if (!noAssert) checkInt(this, value, offset, 1, 0x7f, -0x80)\n\t  if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value)\n\t  if (value < 0) value = 0xff + value + 1\n\t  this[offset] = (value & 0xff)\n\t  return offset + 1\n\t}\n\t\n\tBuffer.prototype.writeInt16LE = function writeInt16LE (value, offset, noAssert) {\n\t  value = +value\n\t  offset = offset | 0\n\t  if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)\n\t  if (Buffer.TYPED_ARRAY_SUPPORT) {\n\t    this[offset] = (value & 0xff)\n\t    this[offset + 1] = (value >>> 8)\n\t  } else {\n\t    objectWriteUInt16(this, value, offset, true)\n\t  }\n\t  return offset + 2\n\t}\n\t\n\tBuffer.prototype.writeInt16BE = function writeInt16BE (value, offset, noAssert) {\n\t  value = +value\n\t  offset = offset | 0\n\t  if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)\n\t  if (Buffer.TYPED_ARRAY_SUPPORT) {\n\t    this[offset] = (value >>> 8)\n\t    this[offset + 1] = (value & 0xff)\n\t  } else {\n\t    objectWriteUInt16(this, value, offset, false)\n\t  }\n\t  return offset + 2\n\t}\n\t\n\tBuffer.prototype.writeInt32LE = function writeInt32LE (value, offset, noAssert) {\n\t  value = +value\n\t  offset = offset | 0\n\t  if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)\n\t  if (Buffer.TYPED_ARRAY_SUPPORT) {\n\t    this[offset] = (value & 0xff)\n\t    this[offset + 1] = (value >>> 8)\n\t    this[offset + 2] = (value >>> 16)\n\t    this[offset + 3] = (value >>> 24)\n\t  } else {\n\t    objectWriteUInt32(this, value, offset, true)\n\t  }\n\t  return offset + 4\n\t}\n\t\n\tBuffer.prototype.writeInt32BE = function writeInt32BE (value, offset, noAssert) {\n\t  value = +value\n\t  offset = offset | 0\n\t  if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)\n\t  if (value < 0) value = 0xffffffff + value + 1\n\t  if (Buffer.TYPED_ARRAY_SUPPORT) {\n\t    this[offset] = (value >>> 24)\n\t    this[offset + 1] = (value >>> 16)\n\t    this[offset + 2] = (value >>> 8)\n\t    this[offset + 3] = (value & 0xff)\n\t  } else {\n\t    objectWriteUInt32(this, value, offset, false)\n\t  }\n\t  return offset + 4\n\t}\n\t\n\tfunction checkIEEE754 (buf, value, offset, ext, max, min) {\n\t  if (offset + ext > buf.length) throw new RangeError('Index out of range')\n\t  if (offset < 0) throw new RangeError('Index out of range')\n\t}\n\t\n\tfunction writeFloat (buf, value, offset, littleEndian, noAssert) {\n\t  if (!noAssert) {\n\t    checkIEEE754(buf, value, offset, 4, 3.4028234663852886e+38, -3.4028234663852886e+38)\n\t  }\n\t  ieee754.write(buf, value, offset, littleEndian, 23, 4)\n\t  return offset + 4\n\t}\n\t\n\tBuffer.prototype.writeFloatLE = function writeFloatLE (value, offset, noAssert) {\n\t  return writeFloat(this, value, offset, true, noAssert)\n\t}\n\t\n\tBuffer.prototype.writeFloatBE = function writeFloatBE (value, offset, noAssert) {\n\t  return writeFloat(this, value, offset, false, noAssert)\n\t}\n\t\n\tfunction writeDouble (buf, value, offset, littleEndian, noAssert) {\n\t  if (!noAssert) {\n\t    checkIEEE754(buf, value, offset, 8, 1.7976931348623157E+308, -1.7976931348623157E+308)\n\t  }\n\t  ieee754.write(buf, value, offset, littleEndian, 52, 8)\n\t  return offset + 8\n\t}\n\t\n\tBuffer.prototype.writeDoubleLE = function writeDoubleLE (value, offset, noAssert) {\n\t  return writeDouble(this, value, offset, true, noAssert)\n\t}\n\t\n\tBuffer.prototype.writeDoubleBE = function writeDoubleBE (value, offset, noAssert) {\n\t  return writeDouble(this, value, offset, false, noAssert)\n\t}\n\t\n\t// copy(targetBuffer, targetStart=0, sourceStart=0, sourceEnd=buffer.length)\n\tBuffer.prototype.copy = function copy (target, targetStart, start, end) {\n\t  if (!start) start = 0\n\t  if (!end && end !== 0) end = this.length\n\t  if (targetStart >= target.length) targetStart = target.length\n\t  if (!targetStart) targetStart = 0\n\t  if (end > 0 && end < start) end = start\n\t\n\t  // Copy 0 bytes; we're done\n\t  if (end === start) return 0\n\t  if (target.length === 0 || this.length === 0) return 0\n\t\n\t  // Fatal error conditions\n\t  if (targetStart < 0) {\n\t    throw new RangeError('targetStart out of bounds')\n\t  }\n\t  if (start < 0 || start >= this.length) throw new RangeError('sourceStart out of bounds')\n\t  if (end < 0) throw new RangeError('sourceEnd out of bounds')\n\t\n\t  // Are we oob?\n\t  if (end > this.length) end = this.length\n\t  if (target.length - targetStart < end - start) {\n\t    end = target.length - targetStart + start\n\t  }\n\t\n\t  var len = end - start\n\t  var i\n\t\n\t  if (this === target && start < targetStart && targetStart < end) {\n\t    // descending copy from end\n\t    for (i = len - 1; i >= 0; --i) {\n\t      target[i + targetStart] = this[i + start]\n\t    }\n\t  } else if (len < 1000 || !Buffer.TYPED_ARRAY_SUPPORT) {\n\t    // ascending copy from start\n\t    for (i = 0; i < len; ++i) {\n\t      target[i + targetStart] = this[i + start]\n\t    }\n\t  } else {\n\t    Uint8Array.prototype.set.call(\n\t      target,\n\t      this.subarray(start, start + len),\n\t      targetStart\n\t    )\n\t  }\n\t\n\t  return len\n\t}\n\t\n\t// Usage:\n\t//    buffer.fill(number[, offset[, end]])\n\t//    buffer.fill(buffer[, offset[, end]])\n\t//    buffer.fill(string[, offset[, end]][, encoding])\n\tBuffer.prototype.fill = function fill (val, start, end, encoding) {\n\t  // Handle string cases:\n\t  if (typeof val === 'string') {\n\t    if (typeof start === 'string') {\n\t      encoding = start\n\t      start = 0\n\t      end = this.length\n\t    } else if (typeof end === 'string') {\n\t      encoding = end\n\t      end = this.length\n\t    }\n\t    if (val.length === 1) {\n\t      var code = val.charCodeAt(0)\n\t      if (code < 256) {\n\t        val = code\n\t      }\n\t    }\n\t    if (encoding !== undefined && typeof encoding !== 'string') {\n\t      throw new TypeError('encoding must be a string')\n\t    }\n\t    if (typeof encoding === 'string' && !Buffer.isEncoding(encoding)) {\n\t      throw new TypeError('Unknown encoding: ' + encoding)\n\t    }\n\t  } else if (typeof val === 'number') {\n\t    val = val & 255\n\t  }\n\t\n\t  // Invalid ranges are not set to a default, so can range check early.\n\t  if (start < 0 || this.length < start || this.length < end) {\n\t    throw new RangeError('Out of range index')\n\t  }\n\t\n\t  if (end <= start) {\n\t    return this\n\t  }\n\t\n\t  start = start >>> 0\n\t  end = end === undefined ? this.length : end >>> 0\n\t\n\t  if (!val) val = 0\n\t\n\t  var i\n\t  if (typeof val === 'number') {\n\t    for (i = start; i < end; ++i) {\n\t      this[i] = val\n\t    }\n\t  } else {\n\t    var bytes = Buffer.isBuffer(val)\n\t      ? val\n\t      : utf8ToBytes(new Buffer(val, encoding).toString())\n\t    var len = bytes.length\n\t    for (i = 0; i < end - start; ++i) {\n\t      this[i + start] = bytes[i % len]\n\t    }\n\t  }\n\t\n\t  return this\n\t}\n\t\n\t// HELPER FUNCTIONS\n\t// ================\n\t\n\tvar INVALID_BASE64_RE = /[^+\\/0-9A-Za-z-_]/g\n\t\n\tfunction base64clean (str) {\n\t  // Node strips out invalid characters like \\n and \\t from the string, base64-js does not\n\t  str = stringtrim(str).replace(INVALID_BASE64_RE, '')\n\t  // Node converts strings with length < 2 to ''\n\t  if (str.length < 2) return ''\n\t  // Node allows for non-padded base64 strings (missing trailing ===), base64-js does not\n\t  while (str.length % 4 !== 0) {\n\t    str = str + '='\n\t  }\n\t  return str\n\t}\n\t\n\tfunction stringtrim (str) {\n\t  if (str.trim) return str.trim()\n\t  return str.replace(/^\\s+|\\s+$/g, '')\n\t}\n\t\n\tfunction toHex (n) {\n\t  if (n < 16) return '0' + n.toString(16)\n\t  return n.toString(16)\n\t}\n\t\n\tfunction utf8ToBytes (string, units) {\n\t  units = units || Infinity\n\t  var codePoint\n\t  var length = string.length\n\t  var leadSurrogate = null\n\t  var bytes = []\n\t\n\t  for (var i = 0; i < length; ++i) {\n\t    codePoint = string.charCodeAt(i)\n\t\n\t    // is surrogate component\n\t    if (codePoint > 0xD7FF && codePoint < 0xE000) {\n\t      // last char was a lead\n\t      if (!leadSurrogate) {\n\t        // no lead yet\n\t        if (codePoint > 0xDBFF) {\n\t          // unexpected trail\n\t          if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n\t          continue\n\t        } else if (i + 1 === length) {\n\t          // unpaired lead\n\t          if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n\t          continue\n\t        }\n\t\n\t        // valid lead\n\t        leadSurrogate = codePoint\n\t\n\t        continue\n\t      }\n\t\n\t      // 2 leads in a row\n\t      if (codePoint < 0xDC00) {\n\t        if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n\t        leadSurrogate = codePoint\n\t        continue\n\t      }\n\t\n\t      // valid surrogate pair\n\t      codePoint = (leadSurrogate - 0xD800 << 10 | codePoint - 0xDC00) + 0x10000\n\t    } else if (leadSurrogate) {\n\t      // valid bmp char, but last char was a lead\n\t      if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n\t    }\n\t\n\t    leadSurrogate = null\n\t\n\t    // encode utf8\n\t    if (codePoint < 0x80) {\n\t      if ((units -= 1) < 0) break\n\t      bytes.push(codePoint)\n\t    } else if (codePoint < 0x800) {\n\t      if ((units -= 2) < 0) break\n\t      bytes.push(\n\t        codePoint >> 0x6 | 0xC0,\n\t        codePoint & 0x3F | 0x80\n\t      )\n\t    } else if (codePoint < 0x10000) {\n\t      if ((units -= 3) < 0) break\n\t      bytes.push(\n\t        codePoint >> 0xC | 0xE0,\n\t        codePoint >> 0x6 & 0x3F | 0x80,\n\t        codePoint & 0x3F | 0x80\n\t      )\n\t    } else if (codePoint < 0x110000) {\n\t      if ((units -= 4) < 0) break\n\t      bytes.push(\n\t        codePoint >> 0x12 | 0xF0,\n\t        codePoint >> 0xC & 0x3F | 0x80,\n\t        codePoint >> 0x6 & 0x3F | 0x80,\n\t        codePoint & 0x3F | 0x80\n\t      )\n\t    } else {\n\t      throw new Error('Invalid code point')\n\t    }\n\t  }\n\t\n\t  return bytes\n\t}\n\t\n\tfunction asciiToBytes (str) {\n\t  var byteArray = []\n\t  for (var i = 0; i < str.length; ++i) {\n\t    // Node's code seems to be doing this and not & 0x7F..\n\t    byteArray.push(str.charCodeAt(i) & 0xFF)\n\t  }\n\t  return byteArray\n\t}\n\t\n\tfunction utf16leToBytes (str, units) {\n\t  var c, hi, lo\n\t  var byteArray = []\n\t  for (var i = 0; i < str.length; ++i) {\n\t    if ((units -= 2) < 0) break\n\t\n\t    c = str.charCodeAt(i)\n\t    hi = c >> 8\n\t    lo = c % 256\n\t    byteArray.push(lo)\n\t    byteArray.push(hi)\n\t  }\n\t\n\t  return byteArray\n\t}\n\t\n\tfunction base64ToBytes (str) {\n\t  return base64.toByteArray(base64clean(str))\n\t}\n\t\n\tfunction blitBuffer (src, dst, offset, length) {\n\t  for (var i = 0; i < length; ++i) {\n\t    if ((i + offset >= dst.length) || (i >= src.length)) break\n\t    dst[i + offset] = src[i]\n\t  }\n\t  return i\n\t}\n\t\n\tfunction isnan (val) {\n\t  return val !== val // eslint-disable-line no-self-compare\n\t}\n\t\n\t/* WEBPACK VAR INJECTION */}.call(exports, (function() { return this; }())))\n\n/***/ }),\n/* 2 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\tvar Buffer = __webpack_require__(1).Buffer;\n\tvar intSize = 4;\n\tvar zeroBuffer = new Buffer(intSize); zeroBuffer.fill(0);\n\tvar chrsz = 8;\n\t\n\tfunction toArray(buf, bigEndian) {\n\t  if ((buf.length % intSize) !== 0) {\n\t    var len = buf.length + (intSize - (buf.length % intSize));\n\t    buf = Buffer.concat([buf, zeroBuffer], len);\n\t  }\n\t\n\t  var arr = [];\n\t  var fn = bigEndian ? buf.readInt32BE : buf.readInt32LE;\n\t  for (var i = 0; i < buf.length; i += intSize) {\n\t    arr.push(fn.call(buf, i));\n\t  }\n\t  return arr;\n\t}\n\t\n\tfunction toBuffer(arr, size, bigEndian) {\n\t  var buf = new Buffer(size);\n\t  var fn = bigEndian ? buf.writeInt32BE : buf.writeInt32LE;\n\t  for (var i = 0; i < arr.length; i++) {\n\t    fn.call(buf, arr[i], i * 4, true);\n\t  }\n\t  return buf;\n\t}\n\t\n\tfunction hash(buf, fn, hashSize, bigEndian) {\n\t  if (!Buffer.isBuffer(buf)) buf = new Buffer(buf);\n\t  var arr = fn(toArray(buf, bigEndian), buf.length * chrsz);\n\t  return toBuffer(arr, hashSize, bigEndian);\n\t}\n\t\n\tmodule.exports = { hash: hash };\n\n\n/***/ }),\n/* 3 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\t'use strict';\n\t\n\texports.__esModule = true;\n\t\n\tvar _buffer = __webpack_require__(1);\n\t\n\tvar _cryptoBrowserify = __webpack_require__(14);\n\t\n\tvar crypto = _interopRequireWildcard(_cryptoBrowserify);\n\t\n\tvar _BigInteger = __webpack_require__(4);\n\t\n\tvar _BigInteger2 = _interopRequireDefault(_BigInteger);\n\t\n\tfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\t\n\tfunction _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }\n\t\n\tfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } } /*!\n\t                                                                                                                                                           * Copyright 2016 Amazon.com,\n\t                                                                                                                                                           * Inc. or its affiliates. All Rights Reserved.\n\t                                                                                                                                                           *\n\t                                                                                                                                                           * Licensed under the Amazon Software License (the \"License\").\n\t                                                                                                                                                           * You may not use this file except in compliance with the\n\t                                                                                                                                                           * License. A copy of the License is located at\n\t                                                                                                                                                           *\n\t                                                                                                                                                           *     http://aws.amazon.com/asl/\n\t                                                                                                                                                           *\n\t                                                                                                                                                           * or in the \"license\" file accompanying this file. This file is\n\t                                                                                                                                                           * distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR\n\t                                                                                                                                                           * CONDITIONS OF ANY KIND, express or implied. See the License\n\t                                                                                                                                                           * for the specific language governing permissions and\n\t                                                                                                                                                           * limitations under the License.\n\t                                                                                                                                                           */\n\t\n\tvar createHash = crypto.createHash;\n\tvar createHmac = crypto.createHmac;\n\tvar randomBytes = crypto.randomBytes;\n\t\n\tvar initN = 'FFFFFFFFFFFFFFFFC90FDAA22168C234C4C6628B80DC1CD1' + '29024E088A67CC74020BBEA63B139B22514A08798E3404DD' + 'EF9519B3CD3A431B302B0A6DF25F14374FE1356D6D51C245' + 'E485B576625E7EC6F44C42E9A637ED6B0BFF5CB6F406B7ED' + 'EE386BFB5A899FA5AE9F24117C4B1FE649286651ECE45B3D' + 'C2007CB8A163BF0598DA48361C55D39A69163FA8FD24CF5F' + '83655D23DCA3AD961C62F356208552BB9ED529077096966D' + '670C354E4ABC9804F1746C08CA18217C32905E462E36CE3B' + 'E39E772C180E86039B2783A2EC07A28FB5C55DF06F4C52C9' + 'DE2BCBF6955817183995497CEA956AE515D2261898FA0510' + '15728E5A8AAAC42DAD33170D04507A33A85521ABDF1CBA64' + 'ECFB850458DBEF0A8AEA71575D060C7DB3970F85A6E1E4C7' + 'ABF5AE8CDB0933D71E8C94E04A25619DCEE3D2261AD2EE6B' + 'F12FFA06D98A0864D87602733EC86A64521F2B18177B200C' + 'BBE117577A615D6C770988C0BAD946E208E24FA074E5AB31' + '43DB5BFCE0FD108E4B82D120A93AD2CAFFFFFFFFFFFFFFFF';\n\t\n\tvar newPasswordRequiredChallengeUserAttributePrefix = 'userAttributes.';\n\t\n\t/** @class */\n\t\n\tvar AuthenticationHelper = function () {\n\t  /**\n\t   * Constructs a new AuthenticationHelper object\n\t   * @param {string} PoolName Cognito user pool name.\n\t   */\n\t  function AuthenticationHelper(PoolName) {\n\t    _classCallCheck(this, AuthenticationHelper);\n\t\n\t    this.N = new _BigInteger2.default(initN, 16);\n\t    this.g = new _BigInteger2.default('2', 16);\n\t    this.k = new _BigInteger2.default(this.hexHash('00' + this.N.toString(16) + '0' + this.g.toString(16)), 16);\n\t\n\t    this.smallAValue = this.generateRandomSmallA();\n\t    this.getLargeAValue(function () {});\n\t\n\t    this.infoBits = _buffer.Buffer.from('Caldera Derived Key', 'utf8');\n\t\n\t    this.poolName = PoolName;\n\t  }\n\t\n\t  /**\n\t   * @returns {BigInteger} small A, a random number\n\t   */\n\t\n\t\n\t  AuthenticationHelper.prototype.getSmallAValue = function getSmallAValue() {\n\t    return this.smallAValue;\n\t  };\n\t\n\t  /**\n\t   * @param {nodeCallback<BigInteger>} callback Called with (err, largeAValue)\n\t   * @returns {void}\n\t   */\n\t\n\t\n\t  AuthenticationHelper.prototype.getLargeAValue = function getLargeAValue(callback) {\n\t    var _this = this;\n\t\n\t    if (this.largeAValue) {\n\t      callback(null, this.largeAValue);\n\t    } else {\n\t      this.calculateA(this.smallAValue, function (err, largeAValue) {\n\t        if (err) {\n\t          callback(err, null);\n\t        }\n\t\n\t        _this.largeAValue = largeAValue;\n\t        callback(null, _this.largeAValue);\n\t      });\n\t    }\n\t  };\n\t\n\t  /**\n\t   * helper function to generate a random big integer\n\t   * @returns {BigInteger} a random value.\n\t   * @private\n\t   */\n\t\n\t\n\t  AuthenticationHelper.prototype.generateRandomSmallA = function generateRandomSmallA() {\n\t    var hexRandom = randomBytes(128).toString('hex');\n\t\n\t    var randomBigInt = new _BigInteger2.default(hexRandom, 16);\n\t    var smallABigInt = randomBigInt.mod(this.N);\n\t\n\t    return smallABigInt;\n\t  };\n\t\n\t  /**\n\t   * helper function to generate a random string\n\t   * @returns {string} a random value.\n\t   * @private\n\t   */\n\t\n\t\n\t  AuthenticationHelper.prototype.generateRandomString = function generateRandomString() {\n\t    return randomBytes(40).toString('base64');\n\t  };\n\t\n\t  /**\n\t   * @returns {string} Generated random value included in password hash.\n\t   */\n\t\n\t\n\t  AuthenticationHelper.prototype.getRandomPassword = function getRandomPassword() {\n\t    return this.randomPassword;\n\t  };\n\t\n\t  /**\n\t   * @returns {string} Generated random value included in devices hash.\n\t   */\n\t\n\t\n\t  AuthenticationHelper.prototype.getSaltDevices = function getSaltDevices() {\n\t    return this.SaltToHashDevices;\n\t  };\n\t\n\t  /**\n\t   * @returns {string} Value used to verify devices.\n\t   */\n\t\n\t\n\t  AuthenticationHelper.prototype.getVerifierDevices = function getVerifierDevices() {\n\t    return this.verifierDevices;\n\t  };\n\t\n\t  /**\n\t   * Generate salts and compute verifier.\n\t   * @param {string} deviceGroupKey Devices to generate verifier for.\n\t   * @param {string} username User to generate verifier for.\n\t   * @param {nodeCallback<null>} callback Called with (err, null)\n\t   * @returns {void}\n\t   */\n\t\n\t\n\t  AuthenticationHelper.prototype.generateHashDevice = function generateHashDevice(deviceGroupKey, username, callback) {\n\t    var _this2 = this;\n\t\n\t    this.randomPassword = this.generateRandomString();\n\t    var combinedString = '' + deviceGroupKey + username + ':' + this.randomPassword;\n\t    var hashedString = this.hash(combinedString);\n\t\n\t    var hexRandom = randomBytes(16).toString('hex');\n\t    this.SaltToHashDevices = this.padHex(new _BigInteger2.default(hexRandom, 16));\n\t\n\t    this.g.modPow(new _BigInteger2.default(this.hexHash(this.SaltToHashDevices + hashedString), 16), this.N, function (err, verifierDevicesNotPadded) {\n\t      if (err) {\n\t        callback(err, null);\n\t      }\n\t\n\t      _this2.verifierDevices = _this2.padHex(verifierDevicesNotPadded);\n\t      callback(null, null);\n\t    });\n\t  };\n\t\n\t  /**\n\t   * Calculate the client's public value A = g^a%N\n\t   * with the generated random number a\n\t   * @param {BigInteger} a Randomly generated small A.\n\t   * @param {nodeCallback<BigInteger>} callback Called with (err, largeAValue)\n\t   * @returns {void}\n\t   * @private\n\t   */\n\t\n\t\n\t  AuthenticationHelper.prototype.calculateA = function calculateA(a, callback) {\n\t    var _this3 = this;\n\t\n\t    this.g.modPow(a, this.N, function (err, A) {\n\t      if (err) {\n\t        callback(err, null);\n\t      }\n\t\n\t      if (A.mod(_this3.N).equals(_BigInteger2.default.ZERO)) {\n\t        callback(new Error('Illegal paramater. A mod N cannot be 0.'), null);\n\t      }\n\t\n\t      callback(null, A);\n\t    });\n\t  };\n\t\n\t  /**\n\t   * Calculate the client's value U which is the hash of A and B\n\t   * @param {BigInteger} A Large A value.\n\t   * @param {BigInteger} B Server B value.\n\t   * @returns {BigInteger} Computed U value.\n\t   * @private\n\t   */\n\t\n\t\n\t  AuthenticationHelper.prototype.calculateU = function calculateU(A, B) {\n\t    this.UHexHash = this.hexHash(this.padHex(A) + this.padHex(B));\n\t    var finalU = new _BigInteger2.default(this.UHexHash, 16);\n\t\n\t    return finalU;\n\t  };\n\t\n\t  /**\n\t   * Calculate a hash from a bitArray\n\t   * @param {Buffer} buf Value to hash.\n\t   * @returns {String} Hex-encoded hash.\n\t   * @private\n\t   */\n\t\n\t\n\t  AuthenticationHelper.prototype.hash = function hash(buf) {\n\t    var hashHex = createHash('sha256').update(buf).digest('hex');\n\t    return new Array(64 - hashHex.length).join('0') + hashHex;\n\t  };\n\t\n\t  /**\n\t   * Calculate a hash from a hex string\n\t   * @param {String} hexStr Value to hash.\n\t   * @returns {String} Hex-encoded hash.\n\t   * @private\n\t   */\n\t\n\t\n\t  AuthenticationHelper.prototype.hexHash = function hexHash(hexStr) {\n\t    return this.hash(_buffer.Buffer.from(hexStr, 'hex'));\n\t  };\n\t\n\t  /**\n\t   * Standard hkdf algorithm\n\t   * @param {Buffer} ikm Input key material.\n\t   * @param {Buffer} salt Salt value.\n\t   * @returns {Buffer} Strong key material.\n\t   * @private\n\t   */\n\t\n\t\n\t  AuthenticationHelper.prototype.computehkdf = function computehkdf(ikm, salt) {\n\t    var prk = createHmac('sha256', salt).update(ikm).digest();\n\t    var infoBitsUpdate = _buffer.Buffer.concat([this.infoBits, _buffer.Buffer.from(String.fromCharCode(1), 'utf8')]);\n\t    var hmac = createHmac('sha256', prk).update(infoBitsUpdate).digest();\n\t    return hmac.slice(0, 16);\n\t  };\n\t\n\t  /**\n\t   * Calculates the final hkdf based on computed S value, and computed U value and the key\n\t   * @param {String} username Username.\n\t   * @param {String} password Password.\n\t   * @param {BigInteger} serverBValue Server B value.\n\t   * @param {BigInteger} salt Generated salt.\n\t   * @param {nodeCallback<Buffer>} callback Called with (err, hkdfValue)\n\t   * @returns {void}\n\t   */\n\t\n\t\n\t  AuthenticationHelper.prototype.getPasswordAuthenticationKey = function getPasswordAuthenticationKey(username, password, serverBValue, salt, callback) {\n\t    var _this4 = this;\n\t\n\t    if (serverBValue.mod(this.N).equals(_BigInteger2.default.ZERO)) {\n\t      throw new Error('B cannot be zero.');\n\t    }\n\t\n\t    this.UValue = this.calculateU(this.largeAValue, serverBValue);\n\t\n\t    if (this.UValue.equals(_BigInteger2.default.ZERO)) {\n\t      throw new Error('U cannot be zero.');\n\t    }\n\t\n\t    var usernamePassword = '' + this.poolName + username + ':' + password;\n\t    var usernamePasswordHash = this.hash(usernamePassword);\n\t\n\t    var xValue = new _BigInteger2.default(this.hexHash(this.padHex(salt) + usernamePasswordHash), 16);\n\t    this.calculateS(xValue, serverBValue, function (err, sValue) {\n\t      if (err) {\n\t        callback(err, null);\n\t      }\n\t\n\t      var hkdf = _this4.computehkdf(_buffer.Buffer.from(_this4.padHex(sValue), 'hex'), _buffer.Buffer.from(_this4.padHex(_this4.UValue.toString(16)), 'hex'));\n\t\n\t      callback(null, hkdf);\n\t    });\n\t  };\n\t\n\t  /**\n\t   * Calculates the S value used in getPasswordAuthenticationKey\n\t   * @param {BigInteger} xValue Salted password hash value.\n\t   * @param {BigInteger} serverBValue Server B value.\n\t   * @param {nodeCallback<string>} callback Called on success or error.\n\t   * @returns {void}\n\t   */\n\t\n\t\n\t  AuthenticationHelper.prototype.calculateS = function calculateS(xValue, serverBValue, callback) {\n\t    var _this5 = this;\n\t\n\t    this.g.modPow(xValue, this.N, function (err, gModPowXN) {\n\t      if (err) {\n\t        callback(err, null);\n\t      }\n\t\n\t      var intValue2 = serverBValue.subtract(_this5.k.multiply(gModPowXN));\n\t      intValue2.modPow(_this5.smallAValue.add(_this5.UValue.multiply(xValue)), _this5.N, function (err2, result) {\n\t        if (err2) {\n\t          callback(err2, null);\n\t        }\n\t\n\t        callback(null, result.mod(_this5.N));\n\t      });\n\t    });\n\t  };\n\t\n\t  /**\n\t  * Return constant newPasswordRequiredChallengeUserAttributePrefix\n\t  * @return {newPasswordRequiredChallengeUserAttributePrefix} constant prefix value\n\t  */\n\t\n\t\n\t  AuthenticationHelper.prototype.getNewPasswordRequiredChallengeUserAttributePrefix = function getNewPasswordRequiredChallengeUserAttributePrefix() {\n\t    return newPasswordRequiredChallengeUserAttributePrefix;\n\t  };\n\t\n\t  /**\n\t   * Converts a BigInteger (or hex string) to hex format padded with zeroes for hashing\n\t   * @param {BigInteger|String} bigInt Number or string to pad.\n\t   * @returns {String} Padded hex string.\n\t   */\n\t\n\t\n\t  AuthenticationHelper.prototype.padHex = function padHex(bigInt) {\n\t    var hashStr = bigInt.toString(16);\n\t    if (hashStr.length % 2 === 1) {\n\t      hashStr = '0' + hashStr;\n\t    } else if ('89ABCDEFabcdef'.indexOf(hashStr[0]) !== -1) {\n\t      hashStr = '00' + hashStr;\n\t    }\n\t    return hashStr;\n\t  };\n\t\n\t  return AuthenticationHelper;\n\t}();\n\t\n\texports.default = AuthenticationHelper;\n\n/***/ }),\n/* 4 */\n/***/ (function(module, exports) {\n\n\t\"use strict\";\n\t\n\texports.__esModule = true;\n\t// A small implementation of BigInteger based on http://www-cs-students.stanford.edu/~tjw/jsbn/\n\t//\n\t// All public methods have been removed except the following:\n\t//   new BigInteger(a, b) (only radix 2, 4, 8, 16 and 32 supported)\n\t//   toString (only radix 2, 4, 8, 16 and 32 supported)\n\t//   negate\n\t//   abs\n\t//   compareTo\n\t//   bitLength\n\t//   mod\n\t//   equals\n\t//   add\n\t//   subtract\n\t//   multiply\n\t//   divide\n\t//   modPow\n\t\n\texports.default = BigInteger;\n\t\n\t/*\n\t * Copyright (c) 2003-2005  Tom Wu\n\t * All Rights Reserved.\n\t *\n\t * Permission is hereby granted, free of charge, to any person obtaining\n\t * a copy of this software and associated documentation files (the\n\t * \"Software\"), to deal in the Software without restriction, including\n\t * without limitation the rights to use, copy, modify, merge, publish,\n\t * distribute, sublicense, and/or sell copies of the Software, and to\n\t * permit persons to whom the Software is furnished to do so, subject to\n\t * the following conditions:\n\t *\n\t * The above copyright notice and this permission notice shall be\n\t * included in all copies or substantial portions of the Software.\n\t *\n\t * THE SOFTWARE IS PROVIDED \"AS-IS\" AND WITHOUT WARRANTY OF ANY KIND,\n\t * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY\n\t * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.\n\t *\n\t * IN NO EVENT SHALL TOM WU BE LIABLE FOR ANY SPECIAL, INCIDENTAL,\n\t * INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND, OR ANY DAMAGES WHATSOEVER\n\t * RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER OR NOT ADVISED OF\n\t * THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF LIABILITY, ARISING OUT\n\t * OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.\n\t *\n\t * In addition, the following condition applies:\n\t *\n\t * All redistributions must retain an intact copy of this copyright notice\n\t * and disclaimer.\n\t */\n\t\n\t// (public) Constructor\n\t\n\tfunction BigInteger(a, b) {\n\t  if (a != null) this.fromString(a, b);\n\t}\n\t\n\t// return new, unset BigInteger\n\tfunction nbi() {\n\t  return new BigInteger(null);\n\t}\n\t\n\t// Bits per digit\n\tvar dbits;\n\t\n\t// JavaScript engine analysis\n\tvar canary = 0xdeadbeefcafe;\n\tvar j_lm = (canary & 0xffffff) == 0xefcafe;\n\t\n\t// am: Compute w_j += (x*this_i), propagate carries,\n\t// c is initial carry, returns final carry.\n\t// c < 3*dvalue, x < 2*dvalue, this_i < dvalue\n\t// We need to select the fastest one that works in this environment.\n\t\n\t// am1: use a single mult and divide to get the high bits,\n\t// max digit bits should be 26 because\n\t// max internal value = 2*dvalue^2-2*dvalue (< 2^53)\n\tfunction am1(i, x, w, j, c, n) {\n\t  while (--n >= 0) {\n\t    var v = x * this[i++] + w[j] + c;\n\t    c = Math.floor(v / 0x4000000);\n\t    w[j++] = v & 0x3ffffff;\n\t  }\n\t  return c;\n\t}\n\t// am2 avoids a big mult-and-extract completely.\n\t// Max digit bits should be <= 30 because we do bitwise ops\n\t// on values up to 2*hdvalue^2-hdvalue-1 (< 2^31)\n\tfunction am2(i, x, w, j, c, n) {\n\t  var xl = x & 0x7fff,\n\t      xh = x >> 15;\n\t  while (--n >= 0) {\n\t    var l = this[i] & 0x7fff;\n\t    var h = this[i++] >> 15;\n\t    var m = xh * l + h * xl;\n\t    l = xl * l + ((m & 0x7fff) << 15) + w[j] + (c & 0x3fffffff);\n\t    c = (l >>> 30) + (m >>> 15) + xh * h + (c >>> 30);\n\t    w[j++] = l & 0x3fffffff;\n\t  }\n\t  return c;\n\t}\n\t// Alternately, set max digit bits to 28 since some\n\t// browsers slow down when dealing with 32-bit numbers.\n\tfunction am3(i, x, w, j, c, n) {\n\t  var xl = x & 0x3fff,\n\t      xh = x >> 14;\n\t  while (--n >= 0) {\n\t    var l = this[i] & 0x3fff;\n\t    var h = this[i++] >> 14;\n\t    var m = xh * l + h * xl;\n\t    l = xl * l + ((m & 0x3fff) << 14) + w[j] + c;\n\t    c = (l >> 28) + (m >> 14) + xh * h;\n\t    w[j++] = l & 0xfffffff;\n\t  }\n\t  return c;\n\t}\n\tvar inBrowser = typeof navigator !== \"undefined\";\n\tif (inBrowser && j_lm && navigator.appName == \"Microsoft Internet Explorer\") {\n\t  BigInteger.prototype.am = am2;\n\t  dbits = 30;\n\t} else if (inBrowser && j_lm && navigator.appName != \"Netscape\") {\n\t  BigInteger.prototype.am = am1;\n\t  dbits = 26;\n\t} else {\n\t  // Mozilla/Netscape seems to prefer am3\n\t  BigInteger.prototype.am = am3;\n\t  dbits = 28;\n\t}\n\t\n\tBigInteger.prototype.DB = dbits;\n\tBigInteger.prototype.DM = (1 << dbits) - 1;\n\tBigInteger.prototype.DV = 1 << dbits;\n\t\n\tvar BI_FP = 52;\n\tBigInteger.prototype.FV = Math.pow(2, BI_FP);\n\tBigInteger.prototype.F1 = BI_FP - dbits;\n\tBigInteger.prototype.F2 = 2 * dbits - BI_FP;\n\t\n\t// Digit conversions\n\tvar BI_RM = \"0123456789abcdefghijklmnopqrstuvwxyz\";\n\tvar BI_RC = new Array();\n\tvar rr, vv;\n\trr = \"0\".charCodeAt(0);\n\tfor (vv = 0; vv <= 9; ++vv) {\n\t  BI_RC[rr++] = vv;\n\t}rr = \"a\".charCodeAt(0);\n\tfor (vv = 10; vv < 36; ++vv) {\n\t  BI_RC[rr++] = vv;\n\t}rr = \"A\".charCodeAt(0);\n\tfor (vv = 10; vv < 36; ++vv) {\n\t  BI_RC[rr++] = vv;\n\t}function int2char(n) {\n\t  return BI_RM.charAt(n);\n\t}\n\tfunction intAt(s, i) {\n\t  var c = BI_RC[s.charCodeAt(i)];\n\t  return c == null ? -1 : c;\n\t}\n\t\n\t// (protected) copy this to r\n\tfunction bnpCopyTo(r) {\n\t  for (var i = this.t - 1; i >= 0; --i) {\n\t    r[i] = this[i];\n\t  }r.t = this.t;\n\t  r.s = this.s;\n\t}\n\t\n\t// (protected) set from integer value x, -DV <= x < DV\n\tfunction bnpFromInt(x) {\n\t  this.t = 1;\n\t  this.s = x < 0 ? -1 : 0;\n\t  if (x > 0) this[0] = x;else if (x < -1) this[0] = x + this.DV;else this.t = 0;\n\t}\n\t\n\t// return bigint initialized to value\n\tfunction nbv(i) {\n\t  var r = nbi();\n\t\n\t  r.fromInt(i);\n\t\n\t  return r;\n\t}\n\t\n\t// (protected) set from string and radix\n\tfunction bnpFromString(s, b) {\n\t  var k;\n\t  if (b == 16) k = 4;else if (b == 8) k = 3;else if (b == 2) k = 1;else if (b == 32) k = 5;else if (b == 4) k = 2;else throw new Error(\"Only radix 2, 4, 8, 16, 32 are supported\");\n\t  this.t = 0;\n\t  this.s = 0;\n\t  var i = s.length,\n\t      mi = false,\n\t      sh = 0;\n\t  while (--i >= 0) {\n\t    var x = intAt(s, i);\n\t    if (x < 0) {\n\t      if (s.charAt(i) == \"-\") mi = true;\n\t      continue;\n\t    }\n\t    mi = false;\n\t    if (sh == 0) this[this.t++] = x;else if (sh + k > this.DB) {\n\t      this[this.t - 1] |= (x & (1 << this.DB - sh) - 1) << sh;\n\t      this[this.t++] = x >> this.DB - sh;\n\t    } else this[this.t - 1] |= x << sh;\n\t    sh += k;\n\t    if (sh >= this.DB) sh -= this.DB;\n\t  }\n\t  this.clamp();\n\t  if (mi) BigInteger.ZERO.subTo(this, this);\n\t}\n\t\n\t// (protected) clamp off excess high words\n\tfunction bnpClamp() {\n\t  var c = this.s & this.DM;\n\t  while (this.t > 0 && this[this.t - 1] == c) {\n\t    --this.t;\n\t  }\n\t}\n\t\n\t// (public) return string representation in given radix\n\tfunction bnToString(b) {\n\t  if (this.s < 0) return \"-\" + this.negate().toString();\n\t  var k;\n\t  if (b == 16) k = 4;else if (b == 8) k = 3;else if (b == 2) k = 1;else if (b == 32) k = 5;else if (b == 4) k = 2;else throw new Error(\"Only radix 2, 4, 8, 16, 32 are supported\");\n\t  var km = (1 << k) - 1,\n\t      d,\n\t      m = false,\n\t      r = \"\",\n\t      i = this.t;\n\t  var p = this.DB - i * this.DB % k;\n\t  if (i-- > 0) {\n\t    if (p < this.DB && (d = this[i] >> p) > 0) {\n\t      m = true;\n\t      r = int2char(d);\n\t    }\n\t    while (i >= 0) {\n\t      if (p < k) {\n\t        d = (this[i] & (1 << p) - 1) << k - p;\n\t        d |= this[--i] >> (p += this.DB - k);\n\t      } else {\n\t        d = this[i] >> (p -= k) & km;\n\t        if (p <= 0) {\n\t          p += this.DB;\n\t          --i;\n\t        }\n\t      }\n\t      if (d > 0) m = true;\n\t      if (m) r += int2char(d);\n\t    }\n\t  }\n\t  return m ? r : \"0\";\n\t}\n\t\n\t// (public) -this\n\tfunction bnNegate() {\n\t  var r = nbi();\n\t\n\t  BigInteger.ZERO.subTo(this, r);\n\t\n\t  return r;\n\t}\n\t\n\t// (public) |this|\n\tfunction bnAbs() {\n\t  return this.s < 0 ? this.negate() : this;\n\t}\n\t\n\t// (public) return + if this > a, - if this < a, 0 if equal\n\tfunction bnCompareTo(a) {\n\t  var r = this.s - a.s;\n\t  if (r != 0) return r;\n\t  var i = this.t;\n\t  r = i - a.t;\n\t  if (r != 0) return this.s < 0 ? -r : r;\n\t  while (--i >= 0) {\n\t    if ((r = this[i] - a[i]) != 0) return r;\n\t  }return 0;\n\t}\n\t\n\t// returns bit length of the integer x\n\tfunction nbits(x) {\n\t  var r = 1,\n\t      t;\n\t  if ((t = x >>> 16) != 0) {\n\t    x = t;\n\t    r += 16;\n\t  }\n\t  if ((t = x >> 8) != 0) {\n\t    x = t;\n\t    r += 8;\n\t  }\n\t  if ((t = x >> 4) != 0) {\n\t    x = t;\n\t    r += 4;\n\t  }\n\t  if ((t = x >> 2) != 0) {\n\t    x = t;\n\t    r += 2;\n\t  }\n\t  if ((t = x >> 1) != 0) {\n\t    x = t;\n\t    r += 1;\n\t  }\n\t  return r;\n\t}\n\t\n\t// (public) return the number of bits in \"this\"\n\tfunction bnBitLength() {\n\t  if (this.t <= 0) return 0;\n\t  return this.DB * (this.t - 1) + nbits(this[this.t - 1] ^ this.s & this.DM);\n\t}\n\t\n\t// (protected) r = this << n*DB\n\tfunction bnpDLShiftTo(n, r) {\n\t  var i;\n\t  for (i = this.t - 1; i >= 0; --i) {\n\t    r[i + n] = this[i];\n\t  }for (i = n - 1; i >= 0; --i) {\n\t    r[i] = 0;\n\t  }r.t = this.t + n;\n\t  r.s = this.s;\n\t}\n\t\n\t// (protected) r = this >> n*DB\n\tfunction bnpDRShiftTo(n, r) {\n\t  for (var i = n; i < this.t; ++i) {\n\t    r[i - n] = this[i];\n\t  }r.t = Math.max(this.t - n, 0);\n\t  r.s = this.s;\n\t}\n\t\n\t// (protected) r = this << n\n\tfunction bnpLShiftTo(n, r) {\n\t  var bs = n % this.DB;\n\t  var cbs = this.DB - bs;\n\t  var bm = (1 << cbs) - 1;\n\t  var ds = Math.floor(n / this.DB),\n\t      c = this.s << bs & this.DM,\n\t      i;\n\t  for (i = this.t - 1; i >= 0; --i) {\n\t    r[i + ds + 1] = this[i] >> cbs | c;\n\t    c = (this[i] & bm) << bs;\n\t  }\n\t  for (i = ds - 1; i >= 0; --i) {\n\t    r[i] = 0;\n\t  }r[ds] = c;\n\t  r.t = this.t + ds + 1;\n\t  r.s = this.s;\n\t  r.clamp();\n\t}\n\t\n\t// (protected) r = this >> n\n\tfunction bnpRShiftTo(n, r) {\n\t  r.s = this.s;\n\t  var ds = Math.floor(n / this.DB);\n\t  if (ds >= this.t) {\n\t    r.t = 0;\n\t    return;\n\t  }\n\t  var bs = n % this.DB;\n\t  var cbs = this.DB - bs;\n\t  var bm = (1 << bs) - 1;\n\t  r[0] = this[ds] >> bs;\n\t  for (var i = ds + 1; i < this.t; ++i) {\n\t    r[i - ds - 1] |= (this[i] & bm) << cbs;\n\t    r[i - ds] = this[i] >> bs;\n\t  }\n\t  if (bs > 0) r[this.t - ds - 1] |= (this.s & bm) << cbs;\n\t  r.t = this.t - ds;\n\t  r.clamp();\n\t}\n\t\n\t// (protected) r = this - a\n\tfunction bnpSubTo(a, r) {\n\t  var i = 0,\n\t      c = 0,\n\t      m = Math.min(a.t, this.t);\n\t  while (i < m) {\n\t    c += this[i] - a[i];\n\t    r[i++] = c & this.DM;\n\t    c >>= this.DB;\n\t  }\n\t  if (a.t < this.t) {\n\t    c -= a.s;\n\t    while (i < this.t) {\n\t      c += this[i];\n\t      r[i++] = c & this.DM;\n\t      c >>= this.DB;\n\t    }\n\t    c += this.s;\n\t  } else {\n\t    c += this.s;\n\t    while (i < a.t) {\n\t      c -= a[i];\n\t      r[i++] = c & this.DM;\n\t      c >>= this.DB;\n\t    }\n\t    c -= a.s;\n\t  }\n\t  r.s = c < 0 ? -1 : 0;\n\t  if (c < -1) r[i++] = this.DV + c;else if (c > 0) r[i++] = c;\n\t  r.t = i;\n\t  r.clamp();\n\t}\n\t\n\t// (protected) r = this * a, r != this,a (HAC 14.12)\n\t// \"this\" should be the larger one if appropriate.\n\tfunction bnpMultiplyTo(a, r) {\n\t  var x = this.abs(),\n\t      y = a.abs();\n\t  var i = x.t;\n\t  r.t = i + y.t;\n\t  while (--i >= 0) {\n\t    r[i] = 0;\n\t  }for (i = 0; i < y.t; ++i) {\n\t    r[i + x.t] = x.am(0, y[i], r, i, 0, x.t);\n\t  }r.s = 0;\n\t  r.clamp();\n\t  if (this.s != a.s) BigInteger.ZERO.subTo(r, r);\n\t}\n\t\n\t// (protected) r = this^2, r != this (HAC 14.16)\n\tfunction bnpSquareTo(r) {\n\t  var x = this.abs();\n\t  var i = r.t = 2 * x.t;\n\t  while (--i >= 0) {\n\t    r[i] = 0;\n\t  }for (i = 0; i < x.t - 1; ++i) {\n\t    var c = x.am(i, x[i], r, 2 * i, 0, 1);\n\t    if ((r[i + x.t] += x.am(i + 1, 2 * x[i], r, 2 * i + 1, c, x.t - i - 1)) >= x.DV) {\n\t      r[i + x.t] -= x.DV;\n\t      r[i + x.t + 1] = 1;\n\t    }\n\t  }\n\t  if (r.t > 0) r[r.t - 1] += x.am(i, x[i], r, 2 * i, 0, 1);\n\t  r.s = 0;\n\t  r.clamp();\n\t}\n\t\n\t// (protected) divide this by m, quotient and remainder to q, r (HAC 14.20)\n\t// r != q, this != m.  q or r may be null.\n\tfunction bnpDivRemTo(m, q, r) {\n\t  var pm = m.abs();\n\t  if (pm.t <= 0) return;\n\t  var pt = this.abs();\n\t  if (pt.t < pm.t) {\n\t    if (q != null) q.fromInt(0);\n\t    if (r != null) this.copyTo(r);\n\t    return;\n\t  }\n\t  if (r == null) r = nbi();\n\t  var y = nbi(),\n\t      ts = this.s,\n\t      ms = m.s;\n\t  var nsh = this.DB - nbits(pm[pm.t - 1]);\n\t  // normalize modulus\n\t  if (nsh > 0) {\n\t    pm.lShiftTo(nsh, y);\n\t    pt.lShiftTo(nsh, r);\n\t  } else {\n\t    pm.copyTo(y);\n\t    pt.copyTo(r);\n\t  }\n\t  var ys = y.t;\n\t  var y0 = y[ys - 1];\n\t  if (y0 == 0) return;\n\t  var yt = y0 * (1 << this.F1) + (ys > 1 ? y[ys - 2] >> this.F2 : 0);\n\t  var d1 = this.FV / yt,\n\t      d2 = (1 << this.F1) / yt,\n\t      e = 1 << this.F2;\n\t  var i = r.t,\n\t      j = i - ys,\n\t      t = q == null ? nbi() : q;\n\t  y.dlShiftTo(j, t);\n\t  if (r.compareTo(t) >= 0) {\n\t    r[r.t++] = 1;\n\t    r.subTo(t, r);\n\t  }\n\t  BigInteger.ONE.dlShiftTo(ys, t);\n\t  t.subTo(y, y);\n\t  // \"negative\" y so we can replace sub with am later\n\t  while (y.t < ys) {\n\t    y[y.t++] = 0;\n\t  }while (--j >= 0) {\n\t    // Estimate quotient digit\n\t    var qd = r[--i] == y0 ? this.DM : Math.floor(r[i] * d1 + (r[i - 1] + e) * d2);\n\t    if ((r[i] += y.am(0, qd, r, j, 0, ys)) < qd) {\n\t      // Try it out\n\t      y.dlShiftTo(j, t);\n\t      r.subTo(t, r);\n\t      while (r[i] < --qd) {\n\t        r.subTo(t, r);\n\t      }\n\t    }\n\t  }\n\t  if (q != null) {\n\t    r.drShiftTo(ys, q);\n\t    if (ts != ms) BigInteger.ZERO.subTo(q, q);\n\t  }\n\t  r.t = ys;\n\t  r.clamp();\n\t  if (nsh > 0) r.rShiftTo(nsh, r);\n\t  // Denormalize remainder\n\t  if (ts < 0) BigInteger.ZERO.subTo(r, r);\n\t}\n\t\n\t// (public) this mod a\n\tfunction bnMod(a) {\n\t  var r = nbi();\n\t  this.abs().divRemTo(a, null, r);\n\t  if (this.s < 0 && r.compareTo(BigInteger.ZERO) > 0) a.subTo(r, r);\n\t  return r;\n\t}\n\t\n\t// (protected) return \"-1/this % 2^DB\"; useful for Mont. reduction\n\t// justification:\n\t//         xy == 1 (mod m)\n\t//         xy =  1+km\n\t//   xy(2-xy) = (1+km)(1-km)\n\t// x[y(2-xy)] = 1-k^2m^2\n\t// x[y(2-xy)] == 1 (mod m^2)\n\t// if y is 1/x mod m, then y(2-xy) is 1/x mod m^2\n\t// should reduce x and y(2-xy) by m^2 at each step to keep size bounded.\n\t// JS multiply \"overflows\" differently from C/C++, so care is needed here.\n\tfunction bnpInvDigit() {\n\t  if (this.t < 1) return 0;\n\t  var x = this[0];\n\t  if ((x & 1) == 0) return 0;\n\t  var y = x & 3;\n\t  // y == 1/x mod 2^2\n\t  y = y * (2 - (x & 0xf) * y) & 0xf;\n\t  // y == 1/x mod 2^4\n\t  y = y * (2 - (x & 0xff) * y) & 0xff;\n\t  // y == 1/x mod 2^8\n\t  y = y * (2 - ((x & 0xffff) * y & 0xffff)) & 0xffff;\n\t  // y == 1/x mod 2^16\n\t  // last step - calculate inverse mod DV directly;\n\t  // assumes 16 < DB <= 32 and assumes ability to handle 48-bit ints\n\t  y = y * (2 - x * y % this.DV) % this.DV;\n\t  // y == 1/x mod 2^dbits\n\t  // we really want the negative inverse, and -DV < y < DV\n\t  return y > 0 ? this.DV - y : -y;\n\t}\n\t\n\tfunction bnEquals(a) {\n\t  return this.compareTo(a) == 0;\n\t}\n\t\n\t// (protected) r = this + a\n\tfunction bnpAddTo(a, r) {\n\t  var i = 0,\n\t      c = 0,\n\t      m = Math.min(a.t, this.t);\n\t  while (i < m) {\n\t    c += this[i] + a[i];\n\t    r[i++] = c & this.DM;\n\t    c >>= this.DB;\n\t  }\n\t  if (a.t < this.t) {\n\t    c += a.s;\n\t    while (i < this.t) {\n\t      c += this[i];\n\t      r[i++] = c & this.DM;\n\t      c >>= this.DB;\n\t    }\n\t    c += this.s;\n\t  } else {\n\t    c += this.s;\n\t    while (i < a.t) {\n\t      c += a[i];\n\t      r[i++] = c & this.DM;\n\t      c >>= this.DB;\n\t    }\n\t    c += a.s;\n\t  }\n\t  r.s = c < 0 ? -1 : 0;\n\t  if (c > 0) r[i++] = c;else if (c < -1) r[i++] = this.DV + c;\n\t  r.t = i;\n\t  r.clamp();\n\t}\n\t\n\t// (public) this + a\n\tfunction bnAdd(a) {\n\t  var r = nbi();\n\t\n\t  this.addTo(a, r);\n\t\n\t  return r;\n\t}\n\t\n\t// (public) this - a\n\tfunction bnSubtract(a) {\n\t  var r = nbi();\n\t\n\t  this.subTo(a, r);\n\t\n\t  return r;\n\t}\n\t\n\t// (public) this * a\n\tfunction bnMultiply(a) {\n\t  var r = nbi();\n\t\n\t  this.multiplyTo(a, r);\n\t\n\t  return r;\n\t}\n\t\n\t// (public) this / a\n\tfunction bnDivide(a) {\n\t  var r = nbi();\n\t\n\t  this.divRemTo(a, r, null);\n\t\n\t  return r;\n\t}\n\t\n\t// Montgomery reduction\n\tfunction Montgomery(m) {\n\t  this.m = m;\n\t  this.mp = m.invDigit();\n\t  this.mpl = this.mp & 0x7fff;\n\t  this.mph = this.mp >> 15;\n\t  this.um = (1 << m.DB - 15) - 1;\n\t  this.mt2 = 2 * m.t;\n\t}\n\t\n\t// xR mod m\n\tfunction montConvert(x) {\n\t  var r = nbi();\n\t  x.abs().dlShiftTo(this.m.t, r);\n\t  r.divRemTo(this.m, null, r);\n\t  if (x.s < 0 && r.compareTo(BigInteger.ZERO) > 0) this.m.subTo(r, r);\n\t  return r;\n\t}\n\t\n\t// x/R mod m\n\tfunction montRevert(x) {\n\t  var r = nbi();\n\t  x.copyTo(r);\n\t  this.reduce(r);\n\t  return r;\n\t}\n\t\n\t// x = x/R mod m (HAC 14.32)\n\tfunction montReduce(x) {\n\t  while (x.t <= this.mt2) {\n\t    // pad x so am has enough room later\n\t    x[x.t++] = 0;\n\t  }for (var i = 0; i < this.m.t; ++i) {\n\t    // faster way of calculating u0 = x[i]*mp mod DV\n\t    var j = x[i] & 0x7fff;\n\t    var u0 = j * this.mpl + ((j * this.mph + (x[i] >> 15) * this.mpl & this.um) << 15) & x.DM;\n\t    // use am to combine the multiply-shift-add into one call\n\t    j = i + this.m.t;\n\t    x[j] += this.m.am(0, u0, x, i, 0, this.m.t);\n\t    // propagate carry\n\t    while (x[j] >= x.DV) {\n\t      x[j] -= x.DV;\n\t      x[++j]++;\n\t    }\n\t  }\n\t  x.clamp();\n\t  x.drShiftTo(this.m.t, x);\n\t  if (x.compareTo(this.m) >= 0) x.subTo(this.m, x);\n\t}\n\t\n\t// r = \"x^2/R mod m\"; x != r\n\tfunction montSqrTo(x, r) {\n\t  x.squareTo(r);\n\t\n\t  this.reduce(r);\n\t}\n\t\n\t// r = \"xy/R mod m\"; x,y != r\n\tfunction montMulTo(x, y, r) {\n\t  x.multiplyTo(y, r);\n\t\n\t  this.reduce(r);\n\t}\n\t\n\tMontgomery.prototype.convert = montConvert;\n\tMontgomery.prototype.revert = montRevert;\n\tMontgomery.prototype.reduce = montReduce;\n\tMontgomery.prototype.mulTo = montMulTo;\n\tMontgomery.prototype.sqrTo = montSqrTo;\n\t\n\t// (public) this^e % m (HAC 14.85)\n\tfunction bnModPow(e, m, callback) {\n\t  var i = e.bitLength(),\n\t      k,\n\t      r = nbv(1),\n\t      z = new Montgomery(m);\n\t  if (i <= 0) return r;else if (i < 18) k = 1;else if (i < 48) k = 3;else if (i < 144) k = 4;else if (i < 768) k = 5;else k = 6;\n\t\n\t  // precomputation\n\t  var g = new Array(),\n\t      n = 3,\n\t      k1 = k - 1,\n\t      km = (1 << k) - 1;\n\t  g[1] = z.convert(this);\n\t  if (k > 1) {\n\t    var g2 = nbi();\n\t    z.sqrTo(g[1], g2);\n\t    while (n <= km) {\n\t      g[n] = nbi();\n\t      z.mulTo(g2, g[n - 2], g[n]);\n\t      n += 2;\n\t    }\n\t  }\n\t\n\t  var j = e.t - 1,\n\t      w,\n\t      is1 = true,\n\t      r2 = nbi(),\n\t      t;\n\t  i = nbits(e[j]) - 1;\n\t  while (j >= 0) {\n\t    if (i >= k1) w = e[j] >> i - k1 & km;else {\n\t      w = (e[j] & (1 << i + 1) - 1) << k1 - i;\n\t      if (j > 0) w |= e[j - 1] >> this.DB + i - k1;\n\t    }\n\t\n\t    n = k;\n\t    while ((w & 1) == 0) {\n\t      w >>= 1;\n\t      --n;\n\t    }\n\t    if ((i -= n) < 0) {\n\t      i += this.DB;\n\t      --j;\n\t    }\n\t    if (is1) {\n\t      // ret == 1, don't bother squaring or multiplying it\n\t      g[w].copyTo(r);\n\t      is1 = false;\n\t    } else {\n\t      while (n > 1) {\n\t        z.sqrTo(r, r2);\n\t        z.sqrTo(r2, r);\n\t        n -= 2;\n\t      }\n\t      if (n > 0) z.sqrTo(r, r2);else {\n\t        t = r;\n\t        r = r2;\n\t        r2 = t;\n\t      }\n\t      z.mulTo(r2, g[w], r);\n\t    }\n\t\n\t    while (j >= 0 && (e[j] & 1 << i) == 0) {\n\t      z.sqrTo(r, r2);\n\t      t = r;\n\t      r = r2;\n\t      r2 = t;\n\t      if (--i < 0) {\n\t        i = this.DB - 1;\n\t        --j;\n\t      }\n\t    }\n\t  }\n\t  var result = z.revert(r);\n\t  callback(null, result);\n\t  return result;\n\t}\n\t\n\t// protected\n\tBigInteger.prototype.copyTo = bnpCopyTo;\n\tBigInteger.prototype.fromInt = bnpFromInt;\n\tBigInteger.prototype.fromString = bnpFromString;\n\tBigInteger.prototype.clamp = bnpClamp;\n\tBigInteger.prototype.dlShiftTo = bnpDLShiftTo;\n\tBigInteger.prototype.drShiftTo = bnpDRShiftTo;\n\tBigInteger.prototype.lShiftTo = bnpLShiftTo;\n\tBigInteger.prototype.rShiftTo = bnpRShiftTo;\n\tBigInteger.prototype.subTo = bnpSubTo;\n\tBigInteger.prototype.multiplyTo = bnpMultiplyTo;\n\tBigInteger.prototype.squareTo = bnpSquareTo;\n\tBigInteger.prototype.divRemTo = bnpDivRemTo;\n\tBigInteger.prototype.invDigit = bnpInvDigit;\n\tBigInteger.prototype.addTo = bnpAddTo;\n\t\n\t// public\n\tBigInteger.prototype.toString = bnToString;\n\tBigInteger.prototype.negate = bnNegate;\n\tBigInteger.prototype.abs = bnAbs;\n\tBigInteger.prototype.compareTo = bnCompareTo;\n\tBigInteger.prototype.bitLength = bnBitLength;\n\tBigInteger.prototype.mod = bnMod;\n\tBigInteger.prototype.equals = bnEquals;\n\tBigInteger.prototype.add = bnAdd;\n\tBigInteger.prototype.subtract = bnSubtract;\n\tBigInteger.prototype.multiply = bnMultiply;\n\tBigInteger.prototype.divide = bnDivide;\n\tBigInteger.prototype.modPow = bnModPow;\n\t\n\t// \"constants\"\n\tBigInteger.ZERO = nbv(0);\n\tBigInteger.ONE = nbv(1);\n\n/***/ }),\n/* 5 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\t'use strict';\n\t\n\texports.__esModule = true;\n\t\n\tvar _CognitoJwtToken2 = __webpack_require__(7);\n\t\n\tvar _CognitoJwtToken3 = _interopRequireDefault(_CognitoJwtToken2);\n\t\n\tfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\t\n\tfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\t\n\tfunction _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\"); } return call && (typeof call === \"object\" || typeof call === \"function\") ? call : self; }\n\t\n\tfunction _inherits(subClass, superClass) { if (typeof superClass !== \"function\" && superClass !== null) { throw new TypeError(\"Super expression must either be null or a function, not \" + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } /*\n\t                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                * Copyright 2016 Amazon.com,\n\t                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                * Inc. or its affiliates. All Rights Reserved.\n\t                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                *\n\t                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                * Licensed under the Amazon Software License (the \"License\").\n\t                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                * You may not use this file except in compliance with the\n\t                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                * License. A copy of the License is located at\n\t                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                *\n\t                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                *     http://aws.amazon.com/asl/\n\t                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                *\n\t                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                * or in the \"license\" file accompanying this file. This file is\n\t                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                * distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR\n\t                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                * CONDITIONS OF ANY KIND, express or implied. See the License\n\t                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                * for the specific language governing permissions and\n\t                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                * limitations under the License.\n\t                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                */\n\t\n\t/** @class */\n\tvar CognitoAccessToken = function (_CognitoJwtToken) {\n\t  _inherits(CognitoAccessToken, _CognitoJwtToken);\n\t\n\t  /**\n\t   * Constructs a new CognitoAccessToken object\n\t   * @param {string=} AccessToken The JWT access token.\n\t   */\n\t  function CognitoAccessToken() {\n\t    var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},\n\t        AccessToken = _ref.AccessToken;\n\t\n\t    _classCallCheck(this, CognitoAccessToken);\n\t\n\t    return _possibleConstructorReturn(this, _CognitoJwtToken.call(this, AccessToken || ''));\n\t  }\n\t\n\t  return CognitoAccessToken;\n\t}(_CognitoJwtToken3.default);\n\t\n\texports.default = CognitoAccessToken;\n\n/***/ }),\n/* 6 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\t'use strict';\n\t\n\texports.__esModule = true;\n\t\n\tvar _CognitoJwtToken2 = __webpack_require__(7);\n\t\n\tvar _CognitoJwtToken3 = _interopRequireDefault(_CognitoJwtToken2);\n\t\n\tfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\t\n\tfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\t\n\tfunction _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\"); } return call && (typeof call === \"object\" || typeof call === \"function\") ? call : self; }\n\t\n\tfunction _inherits(subClass, superClass) { if (typeof superClass !== \"function\" && superClass !== null) { throw new TypeError(\"Super expression must either be null or a function, not \" + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } /*!\n\t                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                * Copyright 2016 Amazon.com,\n\t                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                * Inc. or its affiliates. All Rights Reserved.\n\t                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                *\n\t                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                * Licensed under the Amazon Software License (the \"License\").\n\t                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                * You may not use this file except in compliance with the\n\t                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                * License. A copy of the License is located at\n\t                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                *\n\t                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                *     http://aws.amazon.com/asl/\n\t                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                *\n\t                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                * or in the \"license\" file accompanying this file. This file is\n\t                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                * distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR\n\t                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                * CONDITIONS OF ANY KIND, express or implied. See the License\n\t                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                * for the specific language governing permissions and\n\t                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                * limitations under the License.\n\t                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                */\n\t\n\t/** @class */\n\tvar CognitoIdToken = function (_CognitoJwtToken) {\n\t  _inherits(CognitoIdToken, _CognitoJwtToken);\n\t\n\t  /**\n\t   * Constructs a new CognitoIdToken object\n\t   * @param {string=} IdToken The JWT Id token\n\t   */\n\t  function CognitoIdToken() {\n\t    var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},\n\t        IdToken = _ref.IdToken;\n\t\n\t    _classCallCheck(this, CognitoIdToken);\n\t\n\t    return _possibleConstructorReturn(this, _CognitoJwtToken.call(this, IdToken || ''));\n\t  }\n\t\n\t  return CognitoIdToken;\n\t}(_CognitoJwtToken3.default);\n\t\n\texports.default = CognitoIdToken;\n\n/***/ }),\n/* 7 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\t'use strict';\n\t\n\texports.__esModule = true;\n\t\n\tvar _buffer = __webpack_require__(1);\n\t\n\tfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } } /*!\n\t                                                                                                                                                           * Copyright 2016 Amazon.com,\n\t                                                                                                                                                           * Inc. or its affiliates. All Rights Reserved.\n\t                                                                                                                                                           *\n\t                                                                                                                                                           * Licensed under the Amazon Software License (the \"License\").\n\t                                                                                                                                                           * You may not use this file except in compliance with the\n\t                                                                                                                                                           * License. A copy of the License is located at\n\t                                                                                                                                                           *\n\t                                                                                                                                                           *     http://aws.amazon.com/asl/\n\t                                                                                                                                                           *\n\t                                                                                                                                                           * or in the \"license\" file accompanying this file. This file is\n\t                                                                                                                                                           * distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR\n\t                                                                                                                                                           * CONDITIONS OF ANY KIND, express or implied. See the License\n\t                                                                                                                                                           * for the specific language governing permissions and\n\t                                                                                                                                                           * limitations under the License.\n\t                                                                                                                                                           */\n\t\n\t/** @class */\n\tvar CognitoJwtToken = function () {\n\t  /**\n\t   * Constructs a new CognitoJwtToken object\n\t   * @param {string=} token The JWT token.\n\t   */\n\t  function CognitoJwtToken(token) {\n\t    _classCallCheck(this, CognitoJwtToken);\n\t\n\t    // Assign object\n\t    this.jwtToken = token || '';\n\t    this.payload = this.decodePayload();\n\t  }\n\t\n\t  /**\n\t   * @returns {string} the record's token.\n\t   */\n\t\n\t\n\t  CognitoJwtToken.prototype.getJwtToken = function getJwtToken() {\n\t    return this.jwtToken;\n\t  };\n\t\n\t  /**\n\t   * @returns {int} the token's expiration (exp member).\n\t   */\n\t\n\t\n\t  CognitoJwtToken.prototype.getExpiration = function getExpiration() {\n\t    return this.payload.exp;\n\t  };\n\t\n\t  /**\n\t   * @returns {int} the token's \"issued at\" (iat member).\n\t   */\n\t\n\t\n\t  CognitoJwtToken.prototype.getIssuedAt = function getIssuedAt() {\n\t    return this.payload.iat;\n\t  };\n\t\n\t  /**\n\t   * @returns {object} the token's payload.\n\t   */\n\t\n\t\n\t  CognitoJwtToken.prototype.decodePayload = function decodePayload() {\n\t    var payload = this.jwtToken.split('.')[1];\n\t    try {\n\t      return JSON.parse(_buffer.Buffer.from(payload, 'base64').toString('utf8'));\n\t    } catch (err) {\n\t      return {};\n\t    }\n\t  };\n\t\n\t  return CognitoJwtToken;\n\t}();\n\t\n\texports.default = CognitoJwtToken;\n\n/***/ }),\n/* 8 */\n/***/ (function(module, exports) {\n\n\t'use strict';\n\t\n\texports.__esModule = true;\n\t\n\tfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\t\n\t/*!\n\t * Copyright 2016 Amazon.com,\n\t * Inc. or its affiliates. All Rights Reserved.\n\t *\n\t * Licensed under the Amazon Software License (the \"License\").\n\t * You may not use this file except in compliance with the\n\t * License. A copy of the License is located at\n\t *\n\t *     http://aws.amazon.com/asl/\n\t *\n\t * or in the \"license\" file accompanying this file. This file is\n\t * distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR\n\t * CONDITIONS OF ANY KIND, express or implied. See the License\n\t * for the specific language governing permissions and\n\t * limitations under the License.\n\t */\n\t\n\t/** @class */\n\tvar CognitoRefreshToken = function () {\n\t  /**\n\t   * Constructs a new CognitoRefreshToken object\n\t   * @param {string=} RefreshToken The JWT refresh token.\n\t   */\n\t  function CognitoRefreshToken() {\n\t    var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},\n\t        RefreshToken = _ref.RefreshToken;\n\t\n\t    _classCallCheck(this, CognitoRefreshToken);\n\t\n\t    // Assign object\n\t    this.token = RefreshToken || '';\n\t  }\n\t\n\t  /**\n\t   * @returns {string} the record's token.\n\t   */\n\t\n\t\n\t  CognitoRefreshToken.prototype.getToken = function getToken() {\n\t    return this.token;\n\t  };\n\t\n\t  return CognitoRefreshToken;\n\t}();\n\t\n\texports.default = CognitoRefreshToken;\n\n/***/ }),\n/* 9 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\t'use strict';\n\t\n\texports.__esModule = true;\n\t\n\tvar _buffer = __webpack_require__(1);\n\t\n\tvar _cryptoBrowserify = __webpack_require__(14);\n\t\n\tvar crypto = _interopRequireWildcard(_cryptoBrowserify);\n\t\n\tvar _BigInteger = __webpack_require__(4);\n\t\n\tvar _BigInteger2 = _interopRequireDefault(_BigInteger);\n\t\n\tvar _AuthenticationHelper = __webpack_require__(3);\n\t\n\tvar _AuthenticationHelper2 = _interopRequireDefault(_AuthenticationHelper);\n\t\n\tvar _CognitoAccessToken = __webpack_require__(5);\n\t\n\tvar _CognitoAccessToken2 = _interopRequireDefault(_CognitoAccessToken);\n\t\n\tvar _CognitoIdToken = __webpack_require__(6);\n\t\n\tvar _CognitoIdToken2 = _interopRequireDefault(_CognitoIdToken);\n\t\n\tvar _CognitoRefreshToken = __webpack_require__(8);\n\t\n\tvar _CognitoRefreshToken2 = _interopRequireDefault(_CognitoRefreshToken);\n\t\n\tvar _CognitoUserSession = __webpack_require__(11);\n\t\n\tvar _CognitoUserSession2 = _interopRequireDefault(_CognitoUserSession);\n\t\n\tvar _DateHelper = __webpack_require__(12);\n\t\n\tvar _DateHelper2 = _interopRequireDefault(_DateHelper);\n\t\n\tvar _CognitoUserAttribute = __webpack_require__(10);\n\t\n\tvar _CognitoUserAttribute2 = _interopRequireDefault(_CognitoUserAttribute);\n\t\n\tvar _StorageHelper = __webpack_require__(13);\n\t\n\tvar _StorageHelper2 = _interopRequireDefault(_StorageHelper);\n\t\n\tfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\t\n\tfunction _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }\n\t\n\tfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } } /*!\n\t                                                                                                                                                           * Copyright 2016 Amazon.com,\n\t                                                                                                                                                           * Inc. or its affiliates. All Rights Reserved.\n\t                                                                                                                                                           *\n\t                                                                                                                                                           * Licensed under the Amazon Software License (the \"License\").\n\t                                                                                                                                                           * You may not use this file except in compliance with the\n\t                                                                                                                                                           * License. A copy of the License is located at\n\t                                                                                                                                                           *\n\t                                                                                                                                                           *     http://aws.amazon.com/asl/\n\t                                                                                                                                                           *\n\t                                                                                                                                                           * or in the \"license\" file accompanying this file. This file is\n\t                                                                                                                                                           * distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR\n\t                                                                                                                                                           * CONDITIONS OF ANY KIND, express or implied. See the License\n\t                                                                                                                                                           * for the specific language governing permissions and\n\t                                                                                                                                                           * limitations under the License.\n\t                                                                                                                                                           */\n\t\n\t//import createHmac from 'create-hmac';\n\t\n\t\n\tvar createHmac = crypto.createHmac;\n\t\n\t/**\n\t * @callback nodeCallback\n\t * @template T result\n\t * @param {*} err The operation failure reason, or null.\n\t * @param {T} result The operation result.\n\t */\n\t\n\t/**\n\t * @callback onFailure\n\t * @param {*} err Failure reason.\n\t */\n\t\n\t/**\n\t * @callback onSuccess\n\t * @template T result\n\t * @param {T} result The operation result.\n\t */\n\t\n\t/**\n\t * @callback mfaRequired\n\t * @param {*} details MFA challenge details.\n\t */\n\t\n\t/**\n\t * @callback customChallenge\n\t * @param {*} details Custom challenge details.\n\t */\n\t\n\t/**\n\t * @callback inputVerificationCode\n\t * @param {*} data Server response.\n\t */\n\t\n\t/**\n\t * @callback authSuccess\n\t * @param {CognitoUserSession} session The new session.\n\t * @param {bool=} userConfirmationNecessary User must be confirmed.\n\t */\n\t\n\t/** @class */\n\tvar CognitoUser = function () {\n\t  /**\n\t   * Constructs a new CognitoUser object\n\t   * @param {object} data Creation options\n\t   * @param {string} data.Username The user's username.\n\t   * @param {CognitoUserPool} data.Pool Pool containing the user.\n\t   * @param {object} data.Storage Optional storage object.\n\t   */\n\t  function CognitoUser(data) {\n\t    _classCallCheck(this, CognitoUser);\n\t\n\t    if (data == null || data.Username == null || data.Pool == null) {\n\t      throw new Error('Username and pool information are required.');\n\t    }\n\t\n\t    this.username = data.Username || '';\n\t    this.pool = data.Pool;\n\t    this.Session = null;\n\t\n\t    this.client = data.Pool.client;\n\t\n\t    this.signInUserSession = null;\n\t    this.authenticationFlowType = 'USER_SRP_AUTH';\n\t\n\t    this.storage = data.Storage || new _StorageHelper2.default().getStorage();\n\t  }\n\t\n\t  /**\n\t   * Sets the session for this user\n\t   * @param {CognitoUserSession} signInUserSession the session\n\t   * @returns {void}\n\t   */\n\t\n\t\n\t  CognitoUser.prototype.setSignInUserSession = function setSignInUserSession(signInUserSession) {\n\t    this.clearCachedTokens();\n\t    this.signInUserSession = signInUserSession;\n\t    this.cacheTokens();\n\t  };\n\t\n\t  /**\n\t   * @returns {CognitoUserSession} the current session for this user\n\t   */\n\t\n\t\n\t  CognitoUser.prototype.getSignInUserSession = function getSignInUserSession() {\n\t    return this.signInUserSession;\n\t  };\n\t\n\t  /**\n\t   * @returns {string} the user's username\n\t   */\n\t\n\t\n\t  CognitoUser.prototype.getUsername = function getUsername() {\n\t    return this.username;\n\t  };\n\t\n\t  /**\n\t   * @returns {String} the authentication flow type\n\t   */\n\t\n\t\n\t  CognitoUser.prototype.getAuthenticationFlowType = function getAuthenticationFlowType() {\n\t    return this.authenticationFlowType;\n\t  };\n\t\n\t  /**\n\t   * sets authentication flow type\n\t   * @param {string} authenticationFlowType New value.\n\t   * @returns {void}\n\t   */\n\t\n\t\n\t  CognitoUser.prototype.setAuthenticationFlowType = function setAuthenticationFlowType(authenticationFlowType) {\n\t    this.authenticationFlowType = authenticationFlowType;\n\t  };\n\t\n\t  /**\n\t   * This is used for authenticating the user through the custom authentication flow.\n\t   * @param {AuthenticationDetails} authDetails Contains the authentication data\n\t   * @param {object} callback Result callback map.\n\t   * @param {onFailure} callback.onFailure Called on any error.\n\t   * @param {customChallenge} callback.customChallenge Custom challenge\n\t   *        response required to continue.\n\t   * @param {authSuccess} callback.onSuccess Called on success with the new session.\n\t   * @returns {void}\n\t   */\n\t\n\t\n\t  CognitoUser.prototype.initiateAuth = function initiateAuth(authDetails, callback) {\n\t    var _this = this;\n\t\n\t    var authParameters = authDetails.getAuthParameters();\n\t    authParameters.USERNAME = this.username;\n\t\n\t    var jsonReq = {\n\t      AuthFlow: 'CUSTOM_AUTH',\n\t      ClientId: this.pool.getClientId(),\n\t      AuthParameters: authParameters,\n\t      ClientMetadata: authDetails.getValidationData()\n\t    };\n\t    if (this.getUserContextData()) {\n\t      jsonReq.UserContextData = this.getUserContextData();\n\t    }\n\t\n\t    this.client.request('InitiateAuth', jsonReq, function (err, data) {\n\t      if (err) {\n\t        return callback.onFailure(err);\n\t      }\n\t      var challengeName = data.ChallengeName;\n\t      var challengeParameters = data.ChallengeParameters;\n\t\n\t      if (challengeName === 'CUSTOM_CHALLENGE') {\n\t        _this.Session = data.Session;\n\t        return callback.customChallenge(challengeParameters);\n\t      }\n\t      _this.signInUserSession = _this.getCognitoUserSession(data.AuthenticationResult);\n\t      _this.cacheTokens();\n\t      return callback.onSuccess(_this.signInUserSession);\n\t    });\n\t  };\n\t\n\t  /**\n\t   * This is used for authenticating the user.\n\t   * stuff\n\t   * @param {AuthenticationDetails} authDetails Contains the authentication data\n\t   * @param {object} callback Result callback map.\n\t   * @param {onFailure} callback.onFailure Called on any error.\n\t   * @param {newPasswordRequired} callback.newPasswordRequired new\n\t   *        password and any required attributes are required to continue\n\t   * @param {mfaRequired} callback.mfaRequired MFA code\n\t   *        required to continue.\n\t   * @param {customChallenge} callback.customChallenge Custom challenge\n\t   *        response required to continue.\n\t   * @param {authSuccess} callback.onSuccess Called on success with the new session.\n\t   * @returns {void}\n\t   */\n\t\n\t\n\t  CognitoUser.prototype.authenticateUser = function authenticateUser(authDetails, callback) {\n\t    if (this.authenticationFlowType === 'USER_PASSWORD_AUTH') {\n\t      return this.authenticateUserPlainUsernamePassword(authDetails, callback);\n\t    } else if (this.authenticationFlowType === 'USER_SRP_AUTH') {\n\t      return this.authenticateUserDefaultAuth(authDetails, callback);\n\t    }\n\t    return callback.onFailure(new Error('Authentication flow type is invalid.'));\n\t  };\n\t\n\t  /**\n\t   * PRIVATE ONLY: This is an internal only method and should not\n\t   * be directly called by the consumers.\n\t   * It calls the AuthenticationHelper for SRP related\n\t   * stuff\n\t   * @param {AuthenticationDetails} authDetails Contains the authentication data\n\t   * @param {object} callback Result callback map.\n\t   * @param {onFailure} callback.onFailure Called on any error.\n\t   * @param {newPasswordRequired} callback.newPasswordRequired new\n\t   *        password and any required attributes are required to continue\n\t   * @param {mfaRequired} callback.mfaRequired MFA code\n\t   *        required to continue.\n\t   * @param {customChallenge} callback.customChallenge Custom challenge\n\t   *        response required to continue.\n\t   * @param {authSuccess} callback.onSuccess Called on success with the new session.\n\t   * @returns {void}\n\t   */\n\t\n\t\n\t  CognitoUser.prototype.authenticateUserDefaultAuth = function authenticateUserDefaultAuth(authDetails, callback) {\n\t    var _this2 = this;\n\t\n\t    var authenticationHelper = new _AuthenticationHelper2.default(this.pool.getUserPoolId().split('_')[1]);\n\t    var dateHelper = new _DateHelper2.default();\n\t\n\t    var serverBValue = void 0;\n\t    var salt = void 0;\n\t    var authParameters = {};\n\t\n\t    if (this.deviceKey != null) {\n\t      authParameters.DEVICE_KEY = this.deviceKey;\n\t    }\n\t\n\t    authParameters.USERNAME = this.username;\n\t    authenticationHelper.getLargeAValue(function (errOnAValue, aValue) {\n\t      // getLargeAValue callback start\n\t      if (errOnAValue) {\n\t        callback.onFailure(errOnAValue);\n\t      }\n\t\n\t      authParameters.SRP_A = aValue.toString(16);\n\t\n\t      if (_this2.authenticationFlowType === 'CUSTOM_AUTH') {\n\t        authParameters.CHALLENGE_NAME = 'SRP_A';\n\t      }\n\t\n\t      var jsonReq = {\n\t        AuthFlow: _this2.authenticationFlowType,\n\t        ClientId: _this2.pool.getClientId(),\n\t        AuthParameters: authParameters,\n\t        ClientMetadata: authDetails.getValidationData()\n\t      };\n\t      if (_this2.getUserContextData(_this2.username)) {\n\t        jsonReq.UserContextData = _this2.getUserContextData(_this2.username);\n\t      }\n\t\n\t      _this2.client.request('InitiateAuth', jsonReq, function (err, data) {\n\t        if (err) {\n\t          return callback.onFailure(err);\n\t        }\n\t\n\t        var challengeParameters = data.ChallengeParameters;\n\t\n\t        _this2.username = challengeParameters.USER_ID_FOR_SRP;\n\t        serverBValue = new _BigInteger2.default(challengeParameters.SRP_B, 16);\n\t        salt = new _BigInteger2.default(challengeParameters.SALT, 16);\n\t        _this2.getCachedDeviceKeyAndPassword();\n\t\n\t        authenticationHelper.getPasswordAuthenticationKey(_this2.username, authDetails.getPassword(), serverBValue, salt, function (errOnHkdf, hkdf) {\n\t          // getPasswordAuthenticationKey callback start\n\t          if (errOnHkdf) {\n\t            callback.onFailure(errOnHkdf);\n\t          }\n\t\n\t          var dateNow = dateHelper.getNowString();\n\t\n\t          var signatureString = createHmac('sha256', hkdf).update(_buffer.Buffer.concat([_buffer.Buffer.from(_this2.pool.getUserPoolId().split('_')[1], 'utf8'), _buffer.Buffer.from(_this2.username, 'utf8'), _buffer.Buffer.from(challengeParameters.SECRET_BLOCK, 'base64'), _buffer.Buffer.from(dateNow, 'utf8')])).digest('base64');\n\t\n\t          var challengeResponses = {};\n\t\n\t          challengeResponses.USERNAME = _this2.username;\n\t          challengeResponses.PASSWORD_CLAIM_SECRET_BLOCK = challengeParameters.SECRET_BLOCK;\n\t          challengeResponses.TIMESTAMP = dateNow;\n\t          challengeResponses.PASSWORD_CLAIM_SIGNATURE = signatureString;\n\t\n\t          if (_this2.deviceKey != null) {\n\t            challengeResponses.DEVICE_KEY = _this2.deviceKey;\n\t          }\n\t\n\t          var respondToAuthChallenge = function respondToAuthChallenge(challenge, challengeCallback) {\n\t            return _this2.client.request('RespondToAuthChallenge', challenge, function (errChallenge, dataChallenge) {\n\t              if (errChallenge && errChallenge.code === 'ResourceNotFoundException' && errChallenge.message.toLowerCase().indexOf('device') !== -1) {\n\t                challengeResponses.DEVICE_KEY = null;\n\t                _this2.deviceKey = null;\n\t                _this2.randomPassword = null;\n\t                _this2.deviceGroupKey = null;\n\t                _this2.clearCachedDeviceKeyAndPassword();\n\t                return respondToAuthChallenge(challenge, challengeCallback);\n\t              }\n\t              return challengeCallback(errChallenge, dataChallenge);\n\t            });\n\t          };\n\t\n\t          var jsonReqResp = {\n\t            ChallengeName: 'PASSWORD_VERIFIER',\n\t            ClientId: _this2.pool.getClientId(),\n\t            ChallengeResponses: challengeResponses,\n\t            Session: data.Session\n\t          };\n\t          if (_this2.getUserContextData()) {\n\t            jsonReqResp.UserContextData = _this2.getUserContextData();\n\t          }\n\t          respondToAuthChallenge(jsonReqResp, function (errAuthenticate, dataAuthenticate) {\n\t            if (errAuthenticate) {\n\t              return callback.onFailure(errAuthenticate);\n\t            }\n\t\n\t            var challengeName = dataAuthenticate.ChallengeName;\n\t            if (challengeName === 'NEW_PASSWORD_REQUIRED') {\n\t              _this2.Session = dataAuthenticate.Session;\n\t              var userAttributes = null;\n\t              var rawRequiredAttributes = null;\n\t              var requiredAttributes = [];\n\t              var userAttributesPrefix = authenticationHelper.getNewPasswordRequiredChallengeUserAttributePrefix();\n\t\n\t              if (dataAuthenticate.ChallengeParameters) {\n\t                userAttributes = JSON.parse(dataAuthenticate.ChallengeParameters.userAttributes);\n\t                rawRequiredAttributes = JSON.parse(dataAuthenticate.ChallengeParameters.requiredAttributes);\n\t              }\n\t\n\t              if (rawRequiredAttributes) {\n\t                for (var i = 0; i < rawRequiredAttributes.length; i++) {\n\t                  requiredAttributes[i] = rawRequiredAttributes[i].substr(userAttributesPrefix.length);\n\t                }\n\t              }\n\t              return callback.newPasswordRequired(userAttributes, requiredAttributes);\n\t            }\n\t            return _this2.authenticateUserInternal(dataAuthenticate, authenticationHelper, callback);\n\t          });\n\t          return undefined;\n\t          // getPasswordAuthenticationKey callback end\n\t        });\n\t        return undefined;\n\t      });\n\t      // getLargeAValue callback end\n\t    });\n\t  };\n\t\n\t  /**\n\t   * PRIVATE ONLY: This is an internal only method and should not\n\t   * be directly called by the consumers.\n\t   * @param {AuthenticationDetails} authDetails Contains the authentication data.\n\t   * @param {object} callback Result callback map.\n\t   * @param {onFailure} callback.onFailure Called on any error.\n\t   * @param {mfaRequired} callback.mfaRequired MFA code\n\t   *        required to continue.\n\t   * @param {authSuccess} callback.onSuccess Called on success with the new session.\n\t   * @returns {void}\n\t   */\n\t\n\t\n\t  CognitoUser.prototype.authenticateUserPlainUsernamePassword = function authenticateUserPlainUsernamePassword(authDetails, callback) {\n\t    var _this3 = this;\n\t\n\t    var authParameters = {};\n\t    authParameters.USERNAME = this.username;\n\t    authParameters.PASSWORD = authDetails.getPassword();\n\t    if (!authParameters.PASSWORD) {\n\t      callback.onFailure(new Error('PASSWORD parameter is required'));\n\t      return;\n\t    }\n\t    var authenticationHelper = new _AuthenticationHelper2.default(this.pool.getUserPoolId().split('_')[1]);\n\t    this.getCachedDeviceKeyAndPassword();\n\t    if (this.deviceKey != null) {\n\t      authParameters.DEVICE_KEY = this.deviceKey;\n\t    }\n\t\n\t    var jsonReq = {\n\t      AuthFlow: 'USER_PASSWORD_AUTH',\n\t      ClientId: this.pool.getClientId(),\n\t      AuthParameters: authParameters,\n\t      ClientMetadata: authDetails.getValidationData()\n\t    };\n\t    if (this.getUserContextData(this.username)) {\n\t      jsonReq.UserContextData = this.getUserContextData(this.username);\n\t    }\n\t    // USER_PASSWORD_AUTH happens in a single round-trip: client sends userName and password,\n\t    // Cognito UserPools verifies password and returns tokens.\n\t    this.client.request('InitiateAuth', jsonReq, function (err, authResult) {\n\t      if (err) {\n\t        return callback.onFailure(err);\n\t      }\n\t      return _this3.authenticateUserInternal(authResult, authenticationHelper, callback);\n\t    });\n\t  };\n\t\n\t  /**\n\t  * PRIVATE ONLY: This is an internal only method and should not\n\t  * be directly called by the consumers.\n\t  * @param {object} dataAuthenticate authentication data\n\t  * @param {object} authenticationHelper helper created\n\t  * @param {callback} callback passed on from caller\n\t  * @returns {void}\n\t  */\n\t\n\t\n\t  CognitoUser.prototype.authenticateUserInternal = function authenticateUserInternal(dataAuthenticate, authenticationHelper, callback) {\n\t    var _this4 = this;\n\t\n\t    var challengeName = dataAuthenticate.ChallengeName;\n\t    var challengeParameters = dataAuthenticate.ChallengeParameters;\n\t\n\t    if (challengeName === 'SMS_MFA') {\n\t      this.Session = dataAuthenticate.Session;\n\t      return callback.mfaRequired(challengeName, challengeParameters);\n\t    }\n\t\n\t    if (challengeName === 'SELECT_MFA_TYPE') {\n\t      this.Session = dataAuthenticate.Session;\n\t      return callback.selectMFAType(challengeName, challengeParameters);\n\t    }\n\t\n\t    if (challengeName === 'MFA_SETUP') {\n\t      this.Session = dataAuthenticate.Session;\n\t      return callback.mfaSetup(challengeName, challengeParameters);\n\t    }\n\t\n\t    if (challengeName === 'SOFTWARE_TOKEN_MFA') {\n\t      this.Session = dataAuthenticate.Session;\n\t      return callback.totpRequired(challengeName, challengeParameters);\n\t    }\n\t\n\t    if (challengeName === 'CUSTOM_CHALLENGE') {\n\t      this.Session = dataAuthenticate.Session;\n\t      return callback.customChallenge(challengeParameters);\n\t    }\n\t\n\t    if (challengeName === 'DEVICE_SRP_AUTH') {\n\t      this.getDeviceResponse(callback);\n\t      return undefined;\n\t    }\n\t\n\t    this.signInUserSession = this.getCognitoUserSession(dataAuthenticate.AuthenticationResult);\n\t    this.cacheTokens();\n\t\n\t    var newDeviceMetadata = dataAuthenticate.AuthenticationResult.NewDeviceMetadata;\n\t    if (newDeviceMetadata == null) {\n\t      return callback.onSuccess(this.signInUserSession);\n\t    }\n\t\n\t    authenticationHelper.generateHashDevice(dataAuthenticate.AuthenticationResult.NewDeviceMetadata.DeviceGroupKey, dataAuthenticate.AuthenticationResult.NewDeviceMetadata.DeviceKey, function (errGenHash) {\n\t      if (errGenHash) {\n\t        return callback.onFailure(errGenHash);\n\t      }\n\t\n\t      var deviceSecretVerifierConfig = {\n\t        Salt: _buffer.Buffer.from(authenticationHelper.getSaltDevices(), 'hex').toString('base64'),\n\t        PasswordVerifier: _buffer.Buffer.from(authenticationHelper.getVerifierDevices(), 'hex').toString('base64')\n\t      };\n\t\n\t      _this4.verifierDevices = deviceSecretVerifierConfig.PasswordVerifier;\n\t      _this4.deviceGroupKey = newDeviceMetadata.DeviceGroupKey;\n\t      _this4.randomPassword = authenticationHelper.getRandomPassword();\n\t\n\t      _this4.client.request('ConfirmDevice', {\n\t        DeviceKey: newDeviceMetadata.DeviceKey,\n\t        AccessToken: _this4.signInUserSession.getAccessToken().getJwtToken(),\n\t        DeviceSecretVerifierConfig: deviceSecretVerifierConfig,\n\t        DeviceName: navigator.userAgent\n\t      }, function (errConfirm, dataConfirm) {\n\t        if (errConfirm) {\n\t          return callback.onFailure(errConfirm);\n\t        }\n\t\n\t        _this4.deviceKey = dataAuthenticate.AuthenticationResult.NewDeviceMetadata.DeviceKey;\n\t        _this4.cacheDeviceKeyAndPassword();\n\t        if (dataConfirm.UserConfirmationNecessary === true) {\n\t          return callback.onSuccess(_this4.signInUserSession, dataConfirm.UserConfirmationNecessary);\n\t        }\n\t        return callback.onSuccess(_this4.signInUserSession);\n\t      });\n\t      return undefined;\n\t    });\n\t    return undefined;\n\t  };\n\t\n\t  /**\n\t  * This method is user to complete the NEW_PASSWORD_REQUIRED challenge.\n\t  * Pass the new password with any new user attributes to be updated.\n\t  * User attribute keys must be of format userAttributes.<attribute_name>.\n\t  * @param {string} newPassword new password for this user\n\t  * @param {object} requiredAttributeData map with values for all required attributes\n\t  * @param {object} callback Result callback map.\n\t  * @param {onFailure} callback.onFailure Called on any error.\n\t  * @param {mfaRequired} callback.mfaRequired MFA code required to continue.\n\t  * @param {customChallenge} callback.customChallenge Custom challenge\n\t  *         response required to continue.\n\t  * @param {authSuccess} callback.onSuccess Called on success with the new session.\n\t  * @returns {void}\n\t  */\n\t\n\t\n\t  CognitoUser.prototype.completeNewPasswordChallenge = function completeNewPasswordChallenge(newPassword, requiredAttributeData, callback) {\n\t    var _this5 = this;\n\t\n\t    if (!newPassword) {\n\t      return callback.onFailure(new Error('New password is required.'));\n\t    }\n\t    var authenticationHelper = new _AuthenticationHelper2.default(this.pool.getUserPoolId().split('_')[1]);\n\t    var userAttributesPrefix = authenticationHelper.getNewPasswordRequiredChallengeUserAttributePrefix();\n\t\n\t    var finalUserAttributes = {};\n\t    if (requiredAttributeData) {\n\t      Object.keys(requiredAttributeData).forEach(function (key) {\n\t        finalUserAttributes[userAttributesPrefix + key] = requiredAttributeData[key];\n\t      });\n\t    }\n\t\n\t    finalUserAttributes.NEW_PASSWORD = newPassword;\n\t    finalUserAttributes.USERNAME = this.username;\n\t    var jsonReq = {\n\t      ChallengeName: 'NEW_PASSWORD_REQUIRED',\n\t      ClientId: this.pool.getClientId(),\n\t      ChallengeResponses: finalUserAttributes,\n\t      Session: this.Session\n\t    };\n\t    if (this.getUserContextData()) {\n\t      jsonReq.UserContextData = this.getUserContextData();\n\t    }\n\t\n\t    this.client.request('RespondToAuthChallenge', jsonReq, function (errAuthenticate, dataAuthenticate) {\n\t      if (errAuthenticate) {\n\t        return callback.onFailure(errAuthenticate);\n\t      }\n\t      return _this5.authenticateUserInternal(dataAuthenticate, authenticationHelper, callback);\n\t    });\n\t    return undefined;\n\t  };\n\t\n\t  /**\n\t   * This is used to get a session using device authentication. It is called at the end of user\n\t   * authentication\n\t   *\n\t   * @param {object} callback Result callback map.\n\t   * @param {onFailure} callback.onFailure Called on any error.\n\t   * @param {authSuccess} callback.onSuccess Called on success with the new session.\n\t   * @returns {void}\n\t   * @private\n\t   */\n\t\n\t\n\t  CognitoUser.prototype.getDeviceResponse = function getDeviceResponse(callback) {\n\t    var _this6 = this;\n\t\n\t    var authenticationHelper = new _AuthenticationHelper2.default(this.deviceGroupKey);\n\t    var dateHelper = new _DateHelper2.default();\n\t\n\t    var authParameters = {};\n\t\n\t    authParameters.USERNAME = this.username;\n\t    authParameters.DEVICE_KEY = this.deviceKey;\n\t    authenticationHelper.getLargeAValue(function (errAValue, aValue) {\n\t      // getLargeAValue callback start\n\t      if (errAValue) {\n\t        callback.onFailure(errAValue);\n\t      }\n\t\n\t      authParameters.SRP_A = aValue.toString(16);\n\t\n\t      var jsonReq = {\n\t        ChallengeName: 'DEVICE_SRP_AUTH',\n\t        ClientId: _this6.pool.getClientId(),\n\t        ChallengeResponses: authParameters\n\t      };\n\t      if (_this6.getUserContextData()) {\n\t        jsonReq.UserContextData = _this6.getUserContextData();\n\t      }\n\t      _this6.client.request('RespondToAuthChallenge', jsonReq, function (err, data) {\n\t        if (err) {\n\t          return callback.onFailure(err);\n\t        }\n\t\n\t        var challengeParameters = data.ChallengeParameters;\n\t\n\t        var serverBValue = new _BigInteger2.default(challengeParameters.SRP_B, 16);\n\t        var salt = new _BigInteger2.default(challengeParameters.SALT, 16);\n\t\n\t        authenticationHelper.getPasswordAuthenticationKey(_this6.deviceKey, _this6.randomPassword, serverBValue, salt, function (errHkdf, hkdf) {\n\t          // getPasswordAuthenticationKey callback start\n\t          if (errHkdf) {\n\t            return callback.onFailure(errHkdf);\n\t          }\n\t\n\t          var dateNow = dateHelper.getNowString();\n\t\n\t          var signatureString = createHmac('sha256', hkdf).update(_buffer.Buffer.concat([_buffer.Buffer.from(_this6.deviceGroupKey, 'utf8'), _buffer.Buffer.from(_this6.deviceKey, 'utf8'), _buffer.Buffer.from(challengeParameters.SECRET_BLOCK, 'base64'), _buffer.Buffer.from(dateNow, 'utf8')])).digest('base64');\n\t\n\t          var challengeResponses = {};\n\t\n\t          challengeResponses.USERNAME = _this6.username;\n\t          challengeResponses.PASSWORD_CLAIM_SECRET_BLOCK = challengeParameters.SECRET_BLOCK;\n\t          challengeResponses.TIMESTAMP = dateNow;\n\t          challengeResponses.PASSWORD_CLAIM_SIGNATURE = signatureString;\n\t          challengeResponses.DEVICE_KEY = _this6.deviceKey;\n\t\n\t          var jsonReqResp = {\n\t            ChallengeName: 'DEVICE_PASSWORD_VERIFIER',\n\t            ClientId: _this6.pool.getClientId(),\n\t            ChallengeResponses: challengeResponses,\n\t            Session: data.Session\n\t          };\n\t          if (_this6.getUserContextData()) {\n\t            jsonReqResp.UserContextData = _this6.getUserContextData();\n\t          }\n\t\n\t          _this6.client.request('RespondToAuthChallenge', jsonReqResp, function (errAuthenticate, dataAuthenticate) {\n\t            if (errAuthenticate) {\n\t              return callback.onFailure(errAuthenticate);\n\t            }\n\t\n\t            _this6.signInUserSession = _this6.getCognitoUserSession(dataAuthenticate.AuthenticationResult);\n\t            _this6.cacheTokens();\n\t\n\t            return callback.onSuccess(_this6.signInUserSession);\n\t          });\n\t          return undefined;\n\t          // getPasswordAuthenticationKey callback end\n\t        });\n\t        return undefined;\n\t      });\n\t      // getLargeAValue callback end\n\t    });\n\t  };\n\t\n\t  /**\n\t   * This is used for a certain user to confirm the registration by using a confirmation code\n\t   * @param {string} confirmationCode Code entered by user.\n\t   * @param {bool} forceAliasCreation Allow migrating from an existing email / phone number.\n\t   * @param {nodeCallback<string>} callback Called on success or error.\n\t   * @returns {void}\n\t   */\n\t\n\t\n\t  CognitoUser.prototype.confirmRegistration = function confirmRegistration(confirmationCode, forceAliasCreation, callback) {\n\t    var jsonReq = {\n\t      ClientId: this.pool.getClientId(),\n\t      ConfirmationCode: confirmationCode,\n\t      Username: this.username,\n\t      ForceAliasCreation: forceAliasCreation\n\t    };\n\t    if (this.getUserContextData()) {\n\t      jsonReq.UserContextData = this.getUserContextData();\n\t    }\n\t    this.client.request('ConfirmSignUp', jsonReq, function (err) {\n\t      if (err) {\n\t        return callback(err, null);\n\t      }\n\t      return callback(null, 'SUCCESS');\n\t    });\n\t  };\n\t\n\t  /**\n\t   * This is used by the user once he has the responses to a custom challenge\n\t   * @param {string} answerChallenge The custom challange answer.\n\t   * @param {object} callback Result callback map.\n\t   * @param {onFailure} callback.onFailure Called on any error.\n\t   * @param {customChallenge} callback.customChallenge\n\t   *    Custom challenge response required to continue.\n\t   * @param {authSuccess} callback.onSuccess Called on success with the new session.\n\t   * @returns {void}\n\t   */\n\t\n\t\n\t  CognitoUser.prototype.sendCustomChallengeAnswer = function sendCustomChallengeAnswer(answerChallenge, callback) {\n\t    var _this7 = this;\n\t\n\t    var challengeResponses = {};\n\t    challengeResponses.USERNAME = this.username;\n\t    challengeResponses.ANSWER = answerChallenge;\n\t\n\t    var authenticationHelper = new _AuthenticationHelper2.default(this.pool.getUserPoolId().split('_')[1]);\n\t    this.getCachedDeviceKeyAndPassword();\n\t    if (this.deviceKey != null) {\n\t      challengeResponses.DEVICE_KEY = this.deviceKey;\n\t    }\n\t\n\t    var jsonReq = {\n\t      ChallengeName: 'CUSTOM_CHALLENGE',\n\t      ChallengeResponses: challengeResponses,\n\t      ClientId: this.pool.getClientId(),\n\t      Session: this.Session\n\t    };\n\t    if (this.getUserContextData()) {\n\t      jsonReq.UserContextData = this.getUserContextData();\n\t    }\n\t    this.client.request('RespondToAuthChallenge', jsonReq, function (err, data) {\n\t      if (err) {\n\t        return callback.onFailure(err);\n\t      }\n\t\n\t      return _this7.authenticateUserInternal(data, authenticationHelper, callback);\n\t    });\n\t  };\n\t\n\t  /**\n\t   * This is used by the user once he has an MFA code\n\t   * @param {string} confirmationCode The MFA code entered by the user.\n\t   * @param {object} callback Result callback map.\n\t   * @param {string} mfaType The mfa we are replying to.\n\t   * @param {onFailure} callback.onFailure Called on any error.\n\t   * @param {authSuccess} callback.onSuccess Called on success with the new session.\n\t   * @returns {void}\n\t   */\n\t\n\t\n\t  CognitoUser.prototype.sendMFACode = function sendMFACode(confirmationCode, callback, mfaType) {\n\t    var _this8 = this;\n\t\n\t    var challengeResponses = {};\n\t    challengeResponses.USERNAME = this.username;\n\t    challengeResponses.SMS_MFA_CODE = confirmationCode;\n\t    var mfaTypeSelection = mfaType || 'SMS_MFA';\n\t    if (mfaTypeSelection === 'SOFTWARE_TOKEN_MFA') {\n\t      challengeResponses.SOFTWARE_TOKEN_MFA_CODE = confirmationCode;\n\t    }\n\t\n\t    if (this.deviceKey != null) {\n\t      challengeResponses.DEVICE_KEY = this.deviceKey;\n\t    }\n\t\n\t    var jsonReq = {\n\t      ChallengeName: mfaTypeSelection,\n\t      ChallengeResponses: challengeResponses,\n\t      ClientId: this.pool.getClientId(),\n\t      Session: this.Session\n\t    };\n\t    if (this.getUserContextData()) {\n\t      jsonReq.UserContextData = this.getUserContextData();\n\t    }\n\t\n\t    this.client.request('RespondToAuthChallenge', jsonReq, function (err, dataAuthenticate) {\n\t      if (err) {\n\t        return callback.onFailure(err);\n\t      }\n\t\n\t      var challengeName = dataAuthenticate.ChallengeName;\n\t\n\t      if (challengeName === 'DEVICE_SRP_AUTH') {\n\t        _this8.getDeviceResponse(callback);\n\t        return undefined;\n\t      }\n\t\n\t      _this8.signInUserSession = _this8.getCognitoUserSession(dataAuthenticate.AuthenticationResult);\n\t      _this8.cacheTokens();\n\t\n\t      if (dataAuthenticate.AuthenticationResult.NewDeviceMetadata == null) {\n\t        return callback.onSuccess(_this8.signInUserSession);\n\t      }\n\t\n\t      var authenticationHelper = new _AuthenticationHelper2.default(_this8.pool.getUserPoolId().split('_')[1]);\n\t      authenticationHelper.generateHashDevice(dataAuthenticate.AuthenticationResult.NewDeviceMetadata.DeviceGroupKey, dataAuthenticate.AuthenticationResult.NewDeviceMetadata.DeviceKey, function (errGenHash) {\n\t        if (errGenHash) {\n\t          return callback.onFailure(errGenHash);\n\t        }\n\t\n\t        var deviceSecretVerifierConfig = {\n\t          Salt: _buffer.Buffer.from(authenticationHelper.getSaltDevices(), 'hex').toString('base64'),\n\t          PasswordVerifier: _buffer.Buffer.from(authenticationHelper.getVerifierDevices(), 'hex').toString('base64')\n\t        };\n\t\n\t        _this8.verifierDevices = deviceSecretVerifierConfig.PasswordVerifier;\n\t        _this8.deviceGroupKey = dataAuthenticate.AuthenticationResult.NewDeviceMetadata.DeviceGroupKey;\n\t        _this8.randomPassword = authenticationHelper.getRandomPassword();\n\t\n\t        _this8.client.request('ConfirmDevice', {\n\t          DeviceKey: dataAuthenticate.AuthenticationResult.NewDeviceMetadata.DeviceKey,\n\t          AccessToken: _this8.signInUserSession.getAccessToken().getJwtToken(),\n\t          DeviceSecretVerifierConfig: deviceSecretVerifierConfig,\n\t          DeviceName: navigator.userAgent\n\t        }, function (errConfirm, dataConfirm) {\n\t          if (errConfirm) {\n\t            return callback.onFailure(errConfirm);\n\t          }\n\t\n\t          _this8.deviceKey = dataAuthenticate.AuthenticationResult.NewDeviceMetadata.DeviceKey;\n\t          _this8.cacheDeviceKeyAndPassword();\n\t          if (dataConfirm.UserConfirmationNecessary === true) {\n\t            return callback.onSuccess(_this8.signInUserSession, dataConfirm.UserConfirmationNecessary);\n\t          }\n\t          return callback.onSuccess(_this8.signInUserSession);\n\t        });\n\t        return undefined;\n\t      });\n\t      return undefined;\n\t    });\n\t  };\n\t\n\t  /**\n\t   * This is used by an authenticated user to change the current password\n\t   * @param {string} oldUserPassword The current password.\n\t   * @param {string} newUserPassword The requested new password.\n\t   * @param {nodeCallback<string>} callback Called on success or error.\n\t   * @returns {void}\n\t   */\n\t\n\t\n\t  CognitoUser.prototype.changePassword = function changePassword(oldUserPassword, newUserPassword, callback) {\n\t    if (!(this.signInUserSession != null && this.signInUserSession.isValid())) {\n\t      return callback(new Error('User is not authenticated'), null);\n\t    }\n\t\n\t    this.client.request('ChangePassword', {\n\t      PreviousPassword: oldUserPassword,\n\t      ProposedPassword: newUserPassword,\n\t      AccessToken: this.signInUserSession.getAccessToken().getJwtToken()\n\t    }, function (err) {\n\t      if (err) {\n\t        return callback(err, null);\n\t      }\n\t      return callback(null, 'SUCCESS');\n\t    });\n\t    return undefined;\n\t  };\n\t\n\t  /**\n\t   * This is used by an authenticated user to enable MFA for himself\n\t   * @param {nodeCallback<string>} callback Called on success or error.\n\t   * @returns {void}\n\t   */\n\t\n\t\n\t  CognitoUser.prototype.enableMFA = function enableMFA(callback) {\n\t    if (this.signInUserSession == null || !this.signInUserSession.isValid()) {\n\t      return callback(new Error('User is not authenticated'), null);\n\t    }\n\t\n\t    var mfaOptions = [];\n\t    var mfaEnabled = {\n\t      DeliveryMedium: 'SMS',\n\t      AttributeName: 'phone_number'\n\t    };\n\t    mfaOptions.push(mfaEnabled);\n\t\n\t    this.client.request('SetUserSettings', {\n\t      MFAOptions: mfaOptions,\n\t      AccessToken: this.signInUserSession.getAccessToken().getJwtToken()\n\t    }, function (err) {\n\t      if (err) {\n\t        return callback(err, null);\n\t      }\n\t      return callback(null, 'SUCCESS');\n\t    });\n\t    return undefined;\n\t  };\n\t\n\t  /**\n\t   * This is used by an authenticated user to enable MFA for himself\n\t   * @param {string[]} smsMfaSettings the sms mfa settings\n\t   * @param {string[]} softwareTokenMfaSettings the software token mfa settings\n\t   * @param {nodeCallback<string>} callback Called on success or error.\n\t   * @returns {void}\n\t   */\n\t\n\t\n\t  CognitoUser.prototype.setUserMfaPreference = function setUserMfaPreference(smsMfaSettings, softwareTokenMfaSettings, callback) {\n\t    if (this.signInUserSession == null || !this.signInUserSession.isValid()) {\n\t      return callback(new Error('User is not authenticated'), null);\n\t    }\n\t\n\t    this.client.request('SetUserMFAPreference', {\n\t      SMSMfaSettings: smsMfaSettings,\n\t      SoftwareTokenMfaSettings: softwareTokenMfaSettings,\n\t      AccessToken: this.signInUserSession.getAccessToken().getJwtToken()\n\t    }, function (err) {\n\t      if (err) {\n\t        return callback(err, null);\n\t      }\n\t      return callback(null, 'SUCCESS');\n\t    });\n\t    return undefined;\n\t  };\n\t\n\t  /**\n\t   * This is used by an authenticated user to disable MFA for himself\n\t   * @param {nodeCallback<string>} callback Called on success or error.\n\t   * @returns {void}\n\t   */\n\t\n\t\n\t  CognitoUser.prototype.disableMFA = function disableMFA(callback) {\n\t    if (this.signInUserSession == null || !this.signInUserSession.isValid()) {\n\t      return callback(new Error('User is not authenticated'), null);\n\t    }\n\t\n\t    var mfaOptions = [];\n\t\n\t    this.client.request('SetUserSettings', {\n\t      MFAOptions: mfaOptions,\n\t      AccessToken: this.signInUserSession.getAccessToken().getJwtToken()\n\t    }, function (err) {\n\t      if (err) {\n\t        return callback(err, null);\n\t      }\n\t      return callback(null, 'SUCCESS');\n\t    });\n\t    return undefined;\n\t  };\n\t\n\t  /**\n\t   * This is used by an authenticated user to delete himself\n\t   * @param {nodeCallback<string>} callback Called on success or error.\n\t   * @returns {void}\n\t   */\n\t\n\t\n\t  CognitoUser.prototype.deleteUser = function deleteUser(callback) {\n\t    var _this9 = this;\n\t\n\t    if (this.signInUserSession == null || !this.signInUserSession.isValid()) {\n\t      return callback(new Error('User is not authenticated'), null);\n\t    }\n\t\n\t    this.client.request('DeleteUser', {\n\t      AccessToken: this.signInUserSession.getAccessToken().getJwtToken()\n\t    }, function (err) {\n\t      if (err) {\n\t        return callback(err, null);\n\t      }\n\t      _this9.clearCachedTokens();\n\t      return callback(null, 'SUCCESS');\n\t    });\n\t    return undefined;\n\t  };\n\t\n\t  /**\n\t   * @typedef {CognitoUserAttribute | { Name:string, Value:string }} AttributeArg\n\t   */\n\t  /**\n\t   * This is used by an authenticated user to change a list of attributes\n\t   * @param {AttributeArg[]} attributes A list of the new user attributes.\n\t   * @param {nodeCallback<string>} callback Called on success or error.\n\t   * @returns {void}\n\t   */\n\t\n\t\n\t  CognitoUser.prototype.updateAttributes = function updateAttributes(attributes, callback) {\n\t    if (this.signInUserSession == null || !this.signInUserSession.isValid()) {\n\t      return callback(new Error('User is not authenticated'), null);\n\t    }\n\t\n\t    this.client.request('UpdateUserAttributes', {\n\t      AccessToken: this.signInUserSession.getAccessToken().getJwtToken(),\n\t      UserAttributes: attributes\n\t    }, function (err) {\n\t      if (err) {\n\t        return callback(err, null);\n\t      }\n\t      return callback(null, 'SUCCESS');\n\t    });\n\t    return undefined;\n\t  };\n\t\n\t  /**\n\t   * This is used by an authenticated user to get a list of attributes\n\t   * @param {nodeCallback<CognitoUserAttribute[]>} callback Called on success or error.\n\t   * @returns {void}\n\t   */\n\t\n\t\n\t  CognitoUser.prototype.getUserAttributes = function getUserAttributes(callback) {\n\t    if (!(this.signInUserSession != null && this.signInUserSession.isValid())) {\n\t      return callback(new Error('User is not authenticated'), null);\n\t    }\n\t\n\t    this.client.request('GetUser', {\n\t      AccessToken: this.signInUserSession.getAccessToken().getJwtToken()\n\t    }, function (err, userData) {\n\t      if (err) {\n\t        return callback(err, null);\n\t      }\n\t\n\t      var attributeList = [];\n\t\n\t      for (var i = 0; i < userData.UserAttributes.length; i++) {\n\t        var attribute = {\n\t          Name: userData.UserAttributes[i].Name,\n\t          Value: userData.UserAttributes[i].Value\n\t        };\n\t        var userAttribute = new _CognitoUserAttribute2.default(attribute);\n\t        attributeList.push(userAttribute);\n\t      }\n\t\n\t      return callback(null, attributeList);\n\t    });\n\t    return undefined;\n\t  };\n\t\n\t  /**\n\t   * This is used by an authenticated user to get the MFAOptions\n\t   * @param {nodeCallback<MFAOptions>} callback Called on success or error.\n\t   * @returns {void}\n\t   */\n\t\n\t\n\t  CognitoUser.prototype.getMFAOptions = function getMFAOptions(callback) {\n\t    if (!(this.signInUserSession != null && this.signInUserSession.isValid())) {\n\t      return callback(new Error('User is not authenticated'), null);\n\t    }\n\t\n\t    this.client.request('GetUser', {\n\t      AccessToken: this.signInUserSession.getAccessToken().getJwtToken()\n\t    }, function (err, userData) {\n\t      if (err) {\n\t        return callback(err, null);\n\t      }\n\t\n\t      return callback(null, userData.MFAOptions);\n\t    });\n\t    return undefined;\n\t  };\n\t\n\t  /**\n\t   * This is used by an authenticated users to get the userData\n\t   * @param {nodeCallback<UserData>} callback Called on success or error.\n\t   * @returns {void}\n\t   */\n\t\n\t\n\t  CognitoUser.prototype.getUserData = function getUserData(callback) {\n\t    if (!(this.signInUserSession != null && this.signInUserSession.isValid())) {\n\t      return callback(new Error('User is not authenticated'), null);\n\t    }\n\t\n\t    this.client.request('GetUser', {\n\t      AccessToken: this.signInUserSession.getAccessToken().getJwtToken()\n\t    }, function (err, userData) {\n\t      if (err) {\n\t        return callback(err, null);\n\t      }\n\t\n\t      return callback(null, userData);\n\t    });\n\t    return undefined;\n\t  };\n\t\n\t  /**\n\t   * This is used by an authenticated user to delete a list of attributes\n\t   * @param {string[]} attributeList Names of the attributes to delete.\n\t   * @param {nodeCallback<string>} callback Called on success or error.\n\t   * @returns {void}\n\t   */\n\t\n\t\n\t  CognitoUser.prototype.deleteAttributes = function deleteAttributes(attributeList, callback) {\n\t    if (!(this.signInUserSession != null && this.signInUserSession.isValid())) {\n\t      return callback(new Error('User is not authenticated'), null);\n\t    }\n\t\n\t    this.client.request('DeleteUserAttributes', {\n\t      UserAttributeNames: attributeList,\n\t      AccessToken: this.signInUserSession.getAccessToken().getJwtToken()\n\t    }, function (err) {\n\t      if (err) {\n\t        return callback(err, null);\n\t      }\n\t      return callback(null, 'SUCCESS');\n\t    });\n\t    return undefined;\n\t  };\n\t\n\t  /**\n\t   * This is used by a user to resend a confirmation code\n\t   * @param {nodeCallback<string>} callback Called on success or error.\n\t   * @returns {void}\n\t   */\n\t\n\t\n\t  CognitoUser.prototype.resendConfirmationCode = function resendConfirmationCode(callback) {\n\t    var jsonReq = {\n\t      ClientId: this.pool.getClientId(),\n\t      Username: this.username\n\t    };\n\t\n\t    this.client.request('ResendConfirmationCode', jsonReq, function (err, result) {\n\t      if (err) {\n\t        return callback(err, null);\n\t      }\n\t      return callback(null, result);\n\t    });\n\t  };\n\t\n\t  /**\n\t   * This is used to get a session, either from the session object\n\t   * or from  the local storage, or by using a refresh token\n\t   *\n\t   * @param {nodeCallback<CognitoUserSession>} callback Called on success or error.\n\t   * @returns {void}\n\t   */\n\t\n\t\n\t  CognitoUser.prototype.getSession = function getSession(callback) {\n\t    if (this.username == null) {\n\t      return callback(new Error('Username is null. Cannot retrieve a new session'), null);\n\t    }\n\t\n\t    if (this.signInUserSession != null && this.signInUserSession.isValid()) {\n\t      return callback(null, this.signInUserSession);\n\t    }\n\t\n\t    var keyPrefix = 'CognitoIdentityServiceProvider.' + this.pool.getClientId() + '.' + this.username;\n\t    var idTokenKey = keyPrefix + '.idToken';\n\t    var accessTokenKey = keyPrefix + '.accessToken';\n\t    var refreshTokenKey = keyPrefix + '.refreshToken';\n\t    var clockDriftKey = keyPrefix + '.clockDrift';\n\t\n\t    if (this.storage.getItem(idTokenKey)) {\n\t      var idToken = new _CognitoIdToken2.default({\n\t        IdToken: this.storage.getItem(idTokenKey)\n\t      });\n\t      var accessToken = new _CognitoAccessToken2.default({\n\t        AccessToken: this.storage.getItem(accessTokenKey)\n\t      });\n\t      var refreshToken = new _CognitoRefreshToken2.default({\n\t        RefreshToken: this.storage.getItem(refreshTokenKey)\n\t      });\n\t      var clockDrift = parseInt(this.storage.getItem(clockDriftKey), 0) || 0;\n\t\n\t      var sessionData = {\n\t        IdToken: idToken,\n\t        AccessToken: accessToken,\n\t        RefreshToken: refreshToken,\n\t        ClockDrift: clockDrift\n\t      };\n\t      var cachedSession = new _CognitoUserSession2.default(sessionData);\n\t      if (cachedSession.isValid()) {\n\t        this.signInUserSession = cachedSession;\n\t        return callback(null, this.signInUserSession);\n\t      }\n\t\n\t      if (refreshToken.getToken() == null) {\n\t        return callback(new Error('Cannot retrieve a new session. Please authenticate.'), null);\n\t      }\n\t\n\t      this.refreshSession(refreshToken, callback);\n\t    } else {\n\t      callback(new Error('Local storage is missing an ID Token, Please authenticate'), null);\n\t    }\n\t\n\t    return undefined;\n\t  };\n\t\n\t  /**\n\t   * This uses the refreshToken to retrieve a new session\n\t   * @param {CognitoRefreshToken} refreshToken A previous session's refresh token.\n\t   * @param {nodeCallback<CognitoUserSession>} callback Called on success or error.\n\t   * @returns {void}\n\t   */\n\t\n\t\n\t  CognitoUser.prototype.refreshSession = function refreshSession(refreshToken, callback) {\n\t    var _this10 = this;\n\t\n\t    var authParameters = {};\n\t    authParameters.REFRESH_TOKEN = refreshToken.getToken();\n\t    var keyPrefix = 'CognitoIdentityServiceProvider.' + this.pool.getClientId();\n\t    var lastUserKey = keyPrefix + '.LastAuthUser';\n\t\n\t    if (this.storage.getItem(lastUserKey)) {\n\t      this.username = this.storage.getItem(lastUserKey);\n\t      var deviceKeyKey = keyPrefix + '.' + this.username + '.deviceKey';\n\t      this.deviceKey = this.storage.getItem(deviceKeyKey);\n\t      authParameters.DEVICE_KEY = this.deviceKey;\n\t    }\n\t\n\t    var jsonReq = {\n\t      ClientId: this.pool.getClientId(),\n\t      AuthFlow: 'REFRESH_TOKEN_AUTH',\n\t      AuthParameters: authParameters\n\t    };\n\t    if (this.getUserContextData()) {\n\t      jsonReq.UserContextData = this.getUserContextData();\n\t    }\n\t    this.client.request('InitiateAuth', jsonReq, function (err, authResult) {\n\t      if (err) {\n\t        if (err.code === 'NotAuthorizedException') {\n\t          _this10.clearCachedTokens();\n\t        }\n\t        return callback(err, null);\n\t      }\n\t      if (authResult) {\n\t        var authenticationResult = authResult.AuthenticationResult;\n\t        if (!Object.prototype.hasOwnProperty.call(authenticationResult, 'RefreshToken')) {\n\t          authenticationResult.RefreshToken = refreshToken.getToken();\n\t        }\n\t        _this10.signInUserSession = _this10.getCognitoUserSession(authenticationResult);\n\t        _this10.cacheTokens();\n\t        return callback(null, _this10.signInUserSession);\n\t      }\n\t      return undefined;\n\t    });\n\t  };\n\t\n\t  /**\n\t   * This is used to save the session tokens to local storage\n\t   * @returns {void}\n\t   */\n\t\n\t\n\t  CognitoUser.prototype.cacheTokens = function cacheTokens() {\n\t    var keyPrefix = 'CognitoIdentityServiceProvider.' + this.pool.getClientId();\n\t    var idTokenKey = keyPrefix + '.' + this.username + '.idToken';\n\t    var accessTokenKey = keyPrefix + '.' + this.username + '.accessToken';\n\t    var refreshTokenKey = keyPrefix + '.' + this.username + '.refreshToken';\n\t    var clockDriftKey = keyPrefix + '.' + this.username + '.clockDrift';\n\t    var lastUserKey = keyPrefix + '.LastAuthUser';\n\t\n\t    this.storage.setItem(idTokenKey, this.signInUserSession.getIdToken().getJwtToken());\n\t    this.storage.setItem(accessTokenKey, this.signInUserSession.getAccessToken().getJwtToken());\n\t    this.storage.setItem(refreshTokenKey, this.signInUserSession.getRefreshToken().getToken());\n\t    this.storage.setItem(clockDriftKey, '' + this.signInUserSession.getClockDrift());\n\t    this.storage.setItem(lastUserKey, this.username);\n\t  };\n\t\n\t  /**\n\t   * This is used to cache the device key and device group and device password\n\t   * @returns {void}\n\t   */\n\t\n\t\n\t  CognitoUser.prototype.cacheDeviceKeyAndPassword = function cacheDeviceKeyAndPassword() {\n\t    var keyPrefix = 'CognitoIdentityServiceProvider.' + this.pool.getClientId() + '.' + this.username;\n\t    var deviceKeyKey = keyPrefix + '.deviceKey';\n\t    var randomPasswordKey = keyPrefix + '.randomPasswordKey';\n\t    var deviceGroupKeyKey = keyPrefix + '.deviceGroupKey';\n\t\n\t    this.storage.setItem(deviceKeyKey, this.deviceKey);\n\t    this.storage.setItem(randomPasswordKey, this.randomPassword);\n\t    this.storage.setItem(deviceGroupKeyKey, this.deviceGroupKey);\n\t  };\n\t\n\t  /**\n\t   * This is used to get current device key and device group and device password\n\t   * @returns {void}\n\t   */\n\t\n\t\n\t  CognitoUser.prototype.getCachedDeviceKeyAndPassword = function getCachedDeviceKeyAndPassword() {\n\t    var keyPrefix = 'CognitoIdentityServiceProvider.' + this.pool.getClientId() + '.' + this.username;\n\t    var deviceKeyKey = keyPrefix + '.deviceKey';\n\t    var randomPasswordKey = keyPrefix + '.randomPasswordKey';\n\t    var deviceGroupKeyKey = keyPrefix + '.deviceGroupKey';\n\t\n\t    if (this.storage.getItem(deviceKeyKey)) {\n\t      this.deviceKey = this.storage.getItem(deviceKeyKey);\n\t      this.randomPassword = this.storage.getItem(randomPasswordKey);\n\t      this.deviceGroupKey = this.storage.getItem(deviceGroupKeyKey);\n\t    }\n\t  };\n\t\n\t  /**\n\t   * This is used to clear the device key info from local storage\n\t   * @returns {void}\n\t   */\n\t\n\t\n\t  CognitoUser.prototype.clearCachedDeviceKeyAndPassword = function clearCachedDeviceKeyAndPassword() {\n\t    var keyPrefix = 'CognitoIdentityServiceProvider.' + this.pool.getClientId() + '.' + this.username;\n\t    var deviceKeyKey = keyPrefix + '.deviceKey';\n\t    var randomPasswordKey = keyPrefix + '.randomPasswordKey';\n\t    var deviceGroupKeyKey = keyPrefix + '.deviceGroupKey';\n\t\n\t    this.storage.removeItem(deviceKeyKey);\n\t    this.storage.removeItem(randomPasswordKey);\n\t    this.storage.removeItem(deviceGroupKeyKey);\n\t  };\n\t\n\t  /**\n\t   * This is used to clear the session tokens from local storage\n\t   * @returns {void}\n\t   */\n\t\n\t\n\t  CognitoUser.prototype.clearCachedTokens = function clearCachedTokens() {\n\t    var keyPrefix = 'CognitoIdentityServiceProvider.' + this.pool.getClientId();\n\t    var idTokenKey = keyPrefix + '.' + this.username + '.idToken';\n\t    var accessTokenKey = keyPrefix + '.' + this.username + '.accessToken';\n\t    var refreshTokenKey = keyPrefix + '.' + this.username + '.refreshToken';\n\t    var lastUserKey = keyPrefix + '.LastAuthUser';\n\t\n\t    this.storage.removeItem(idTokenKey);\n\t    this.storage.removeItem(accessTokenKey);\n\t    this.storage.removeItem(refreshTokenKey);\n\t    this.storage.removeItem(lastUserKey);\n\t  };\n\t\n\t  /**\n\t   * This is used to build a user session from tokens retrieved in the authentication result\n\t   * @param {object} authResult Successful auth response from server.\n\t   * @returns {CognitoUserSession} The new user session.\n\t   * @private\n\t   */\n\t\n\t\n\t  CognitoUser.prototype.getCognitoUserSession = function getCognitoUserSession(authResult) {\n\t    var idToken = new _CognitoIdToken2.default(authResult);\n\t    var accessToken = new _CognitoAccessToken2.default(authResult);\n\t    var refreshToken = new _CognitoRefreshToken2.default(authResult);\n\t\n\t    var sessionData = {\n\t      IdToken: idToken,\n\t      AccessToken: accessToken,\n\t      RefreshToken: refreshToken\n\t    };\n\t\n\t    return new _CognitoUserSession2.default(sessionData);\n\t  };\n\t\n\t  /**\n\t   * This is used to initiate a forgot password request\n\t   * @param {object} callback Result callback map.\n\t   * @param {onFailure} callback.onFailure Called on any error.\n\t   * @param {inputVerificationCode?} callback.inputVerificationCode\n\t   *    Optional callback raised instead of onSuccess with response data.\n\t   * @param {onSuccess} callback.onSuccess Called on success.\n\t   * @returns {void}\n\t   */\n\t\n\t\n\t  CognitoUser.prototype.forgotPassword = function forgotPassword(callback) {\n\t    var jsonReq = {\n\t      ClientId: this.pool.getClientId(),\n\t      Username: this.username\n\t    };\n\t    if (this.getUserContextData()) {\n\t      jsonReq.UserContextData = this.getUserContextData();\n\t    }\n\t    this.client.request('ForgotPassword', jsonReq, function (err, data) {\n\t      if (err) {\n\t        return callback.onFailure(err);\n\t      }\n\t      if (typeof callback.inputVerificationCode === 'function') {\n\t        return callback.inputVerificationCode(data);\n\t      }\n\t      return callback.onSuccess(data);\n\t    });\n\t  };\n\t\n\t  /**\n\t   * This is used to confirm a new password using a confirmationCode\n\t   * @param {string} confirmationCode Code entered by user.\n\t   * @param {string} newPassword Confirm new password.\n\t   * @param {object} callback Result callback map.\n\t   * @param {onFailure} callback.onFailure Called on any error.\n\t   * @param {onSuccess<void>} callback.onSuccess Called on success.\n\t   * @returns {void}\n\t   */\n\t\n\t\n\t  CognitoUser.prototype.confirmPassword = function confirmPassword(confirmationCode, newPassword, callback) {\n\t    var jsonReq = {\n\t      ClientId: this.pool.getClientId(),\n\t      Username: this.username,\n\t      ConfirmationCode: confirmationCode,\n\t      Password: newPassword\n\t    };\n\t    if (this.getUserContextData()) {\n\t      jsonReq.UserContextData = this.getUserContextData();\n\t    }\n\t    this.client.request('ConfirmForgotPassword', jsonReq, function (err) {\n\t      if (err) {\n\t        return callback.onFailure(err);\n\t      }\n\t      return callback.onSuccess();\n\t    });\n\t  };\n\t\n\t  /**\n\t   * This is used to initiate an attribute confirmation request\n\t   * @param {string} attributeName User attribute that needs confirmation.\n\t   * @param {object} callback Result callback map.\n\t   * @param {onFailure} callback.onFailure Called on any error.\n\t   * @param {inputVerificationCode} callback.inputVerificationCode Called on success.\n\t   * @returns {void}\n\t   */\n\t\n\t\n\t  CognitoUser.prototype.getAttributeVerificationCode = function getAttributeVerificationCode(attributeName, callback) {\n\t    if (this.signInUserSession == null || !this.signInUserSession.isValid()) {\n\t      return callback.onFailure(new Error('User is not authenticated'));\n\t    }\n\t\n\t    this.client.request('GetUserAttributeVerificationCode', {\n\t      AttributeName: attributeName,\n\t      AccessToken: this.signInUserSession.getAccessToken().getJwtToken()\n\t    }, function (err, data) {\n\t      if (err) {\n\t        return callback.onFailure(err);\n\t      }\n\t      if (typeof callback.inputVerificationCode === 'function') {\n\t        return callback.inputVerificationCode(data);\n\t      }\n\t      return callback.onSuccess();\n\t    });\n\t    return undefined;\n\t  };\n\t\n\t  /**\n\t   * This is used to confirm an attribute using a confirmation code\n\t   * @param {string} attributeName Attribute being confirmed.\n\t   * @param {string} confirmationCode Code entered by user.\n\t   * @param {object} callback Result callback map.\n\t   * @param {onFailure} callback.onFailure Called on any error.\n\t   * @param {onSuccess<string>} callback.onSuccess Called on success.\n\t   * @returns {void}\n\t   */\n\t\n\t\n\t  CognitoUser.prototype.verifyAttribute = function verifyAttribute(attributeName, confirmationCode, callback) {\n\t    if (this.signInUserSession == null || !this.signInUserSession.isValid()) {\n\t      return callback.onFailure(new Error('User is not authenticated'));\n\t    }\n\t\n\t    this.client.request('VerifyUserAttribute', {\n\t      AttributeName: attributeName,\n\t      Code: confirmationCode,\n\t      AccessToken: this.signInUserSession.getAccessToken().getJwtToken()\n\t    }, function (err) {\n\t      if (err) {\n\t        return callback.onFailure(err);\n\t      }\n\t      return callback.onSuccess('SUCCESS');\n\t    });\n\t    return undefined;\n\t  };\n\t\n\t  /**\n\t   * This is used to get the device information using the current device key\n\t   * @param {object} callback Result callback map.\n\t   * @param {onFailure} callback.onFailure Called on any error.\n\t   * @param {onSuccess<*>} callback.onSuccess Called on success with device data.\n\t   * @returns {void}\n\t   */\n\t\n\t\n\t  CognitoUser.prototype.getDevice = function getDevice(callback) {\n\t    if (this.signInUserSession == null || !this.signInUserSession.isValid()) {\n\t      return callback.onFailure(new Error('User is not authenticated'));\n\t    }\n\t\n\t    this.client.request('GetDevice', {\n\t      AccessToken: this.signInUserSession.getAccessToken().getJwtToken(),\n\t      DeviceKey: this.deviceKey\n\t    }, function (err, data) {\n\t      if (err) {\n\t        return callback.onFailure(err);\n\t      }\n\t      return callback.onSuccess(data);\n\t    });\n\t    return undefined;\n\t  };\n\t\n\t  /**\n\t   * This is used to forget a specific device\n\t   * @param {string} deviceKey Device key.\n\t   * @param {object} callback Result callback map.\n\t   * @param {onFailure} callback.onFailure Called on any error.\n\t   * @param {onSuccess<string>} callback.onSuccess Called on success.\n\t   * @returns {void}\n\t   */\n\t\n\t\n\t  CognitoUser.prototype.forgetSpecificDevice = function forgetSpecificDevice(deviceKey, callback) {\n\t    if (this.signInUserSession == null || !this.signInUserSession.isValid()) {\n\t      return callback.onFailure(new Error('User is not authenticated'));\n\t    }\n\t\n\t    this.client.request('ForgetDevice', {\n\t      AccessToken: this.signInUserSession.getAccessToken().getJwtToken(),\n\t      DeviceKey: deviceKey\n\t    }, function (err) {\n\t      if (err) {\n\t        return callback.onFailure(err);\n\t      }\n\t      return callback.onSuccess('SUCCESS');\n\t    });\n\t    return undefined;\n\t  };\n\t\n\t  /**\n\t   * This is used to forget the current device\n\t   * @param {object} callback Result callback map.\n\t   * @param {onFailure} callback.onFailure Called on any error.\n\t   * @param {onSuccess<string>} callback.onSuccess Called on success.\n\t   * @returns {void}\n\t   */\n\t\n\t\n\t  CognitoUser.prototype.forgetDevice = function forgetDevice(callback) {\n\t    var _this11 = this;\n\t\n\t    this.forgetSpecificDevice(this.deviceKey, {\n\t      onFailure: callback.onFailure,\n\t      onSuccess: function onSuccess(result) {\n\t        _this11.deviceKey = null;\n\t        _this11.deviceGroupKey = null;\n\t        _this11.randomPassword = null;\n\t        _this11.clearCachedDeviceKeyAndPassword();\n\t        return callback.onSuccess(result);\n\t      }\n\t    });\n\t  };\n\t\n\t  /**\n\t   * This is used to set the device status as remembered\n\t   * @param {object} callback Result callback map.\n\t   * @param {onFailure} callback.onFailure Called on any error.\n\t   * @param {onSuccess<string>} callback.onSuccess Called on success.\n\t   * @returns {void}\n\t   */\n\t\n\t\n\t  CognitoUser.prototype.setDeviceStatusRemembered = function setDeviceStatusRemembered(callback) {\n\t    if (this.signInUserSession == null || !this.signInUserSession.isValid()) {\n\t      return callback.onFailure(new Error('User is not authenticated'));\n\t    }\n\t\n\t    this.client.request('UpdateDeviceStatus', {\n\t      AccessToken: this.signInUserSession.getAccessToken().getJwtToken(),\n\t      DeviceKey: this.deviceKey,\n\t      DeviceRememberedStatus: 'remembered'\n\t    }, function (err) {\n\t      if (err) {\n\t        return callback.onFailure(err);\n\t      }\n\t      return callback.onSuccess('SUCCESS');\n\t    });\n\t    return undefined;\n\t  };\n\t\n\t  /**\n\t   * This is used to set the device status as not remembered\n\t   * @param {object} callback Result callback map.\n\t   * @param {onFailure} callback.onFailure Called on any error.\n\t   * @param {onSuccess<string>} callback.onSuccess Called on success.\n\t   * @returns {void}\n\t   */\n\t\n\t\n\t  CognitoUser.prototype.setDeviceStatusNotRemembered = function setDeviceStatusNotRemembered(callback) {\n\t    if (this.signInUserSession == null || !this.signInUserSession.isValid()) {\n\t      return callback.onFailure(new Error('User is not authenticated'));\n\t    }\n\t\n\t    this.client.request('UpdateDeviceStatus', {\n\t      AccessToken: this.signInUserSession.getAccessToken().getJwtToken(),\n\t      DeviceKey: this.deviceKey,\n\t      DeviceRememberedStatus: 'not_remembered'\n\t    }, function (err) {\n\t      if (err) {\n\t        return callback.onFailure(err);\n\t      }\n\t      return callback.onSuccess('SUCCESS');\n\t    });\n\t    return undefined;\n\t  };\n\t\n\t  /**\n\t   * This is used to list all devices for a user\n\t   *\n\t   * @param {int} limit the number of devices returned in a call\n\t   * @param {string} paginationToken the pagination token in case any was returned before\n\t   * @param {object} callback Result callback map.\n\t   * @param {onFailure} callback.onFailure Called on any error.\n\t   * @param {onSuccess<*>} callback.onSuccess Called on success with device list.\n\t   * @returns {void}\n\t   */\n\t\n\t\n\t  CognitoUser.prototype.listDevices = function listDevices(limit, paginationToken, callback) {\n\t    if (this.signInUserSession == null || !this.signInUserSession.isValid()) {\n\t      return callback.onFailure(new Error('User is not authenticated'));\n\t    }\n\t\n\t    this.client.request('ListDevices', {\n\t      AccessToken: this.signInUserSession.getAccessToken().getJwtToken(),\n\t      Limit: limit,\n\t      PaginationToken: paginationToken\n\t    }, function (err, data) {\n\t      if (err) {\n\t        return callback.onFailure(err);\n\t      }\n\t      return callback.onSuccess(data);\n\t    });\n\t    return undefined;\n\t  };\n\t\n\t  /**\n\t   * This is used to globally revoke all tokens issued to a user\n\t   * @param {object} callback Result callback map.\n\t   * @param {onFailure} callback.onFailure Called on any error.\n\t   * @param {onSuccess<string>} callback.onSuccess Called on success.\n\t   * @returns {void}\n\t   */\n\t\n\t\n\t  CognitoUser.prototype.globalSignOut = function globalSignOut(callback) {\n\t    var _this12 = this;\n\t\n\t    if (this.signInUserSession == null || !this.signInUserSession.isValid()) {\n\t      return callback.onFailure(new Error('User is not authenticated'));\n\t    }\n\t\n\t    this.client.request('GlobalSignOut', {\n\t      AccessToken: this.signInUserSession.getAccessToken().getJwtToken()\n\t    }, function (err) {\n\t      if (err) {\n\t        return callback.onFailure(err);\n\t      }\n\t      _this12.clearCachedTokens();\n\t      return callback.onSuccess('SUCCESS');\n\t    });\n\t    return undefined;\n\t  };\n\t\n\t  /**\n\t   * This is used for the user to signOut of the application and clear the cached tokens.\n\t   * @returns {void}\n\t   */\n\t\n\t\n\t  CognitoUser.prototype.signOut = function signOut() {\n\t    this.signInUserSession = null;\n\t    this.clearCachedTokens();\n\t  };\n\t\n\t  /**\n\t   * This is used by a user trying to select a given MFA\n\t   * @param {string} answerChallenge the mfa the user wants\n\t   * @param {nodeCallback<string>} callback Called on success or error.\n\t   * @returns {void}\n\t   */\n\t\n\t\n\t  CognitoUser.prototype.sendMFASelectionAnswer = function sendMFASelectionAnswer(answerChallenge, callback) {\n\t    var _this13 = this;\n\t\n\t    var challengeResponses = {};\n\t    challengeResponses.USERNAME = this.username;\n\t    challengeResponses.ANSWER = answerChallenge;\n\t\n\t    var jsonReq = {\n\t      ChallengeName: 'SELECT_MFA_TYPE',\n\t      ChallengeResponses: challengeResponses,\n\t      ClientId: this.pool.getClientId(),\n\t      Session: this.Session\n\t    };\n\t    if (this.getUserContextData()) {\n\t      jsonReq.UserContextData = this.getUserContextData();\n\t    }\n\t    this.client.request('RespondToAuthChallenge', jsonReq, function (err, data) {\n\t      if (err) {\n\t        return callback.onFailure(err);\n\t      }\n\t      _this13.Session = data.Session;\n\t      if (answerChallenge === 'SMS_MFA') {\n\t        return callback.mfaRequired(data.challengeName, data.challengeParameters);\n\t      }\n\t      if (answerChallenge === 'SOFTWARE_TOKEN_MFA') {\n\t        return callback.totpRequired(data.challengeName, data.challengeParameters);\n\t      }\n\t      return undefined;\n\t    });\n\t  };\n\t\n\t  /**\n\t   * This returns the user context data for advanced security feature.\n\t   * @returns {void}\n\t   */\n\t\n\t\n\t  CognitoUser.prototype.getUserContextData = function getUserContextData() {\n\t    var pool = this.pool;\n\t    return pool.getUserContextData(this.username);\n\t  };\n\t\n\t  /**\n\t   * This is used by an authenticated or a user trying to authenticate to associate a TOTP MFA\n\t   * @param {nodeCallback<string>} callback Called on success or error.\n\t   * @returns {void}\n\t   */\n\t\n\t\n\t  CognitoUser.prototype.associateSoftwareToken = function associateSoftwareToken(callback) {\n\t    var _this14 = this;\n\t\n\t    if (!(this.signInUserSession != null && this.signInUserSession.isValid())) {\n\t      this.client.request('AssociateSoftwareToken', {\n\t        Session: this.Session\n\t      }, function (err, data) {\n\t        if (err) {\n\t          return callback.onFailure(err);\n\t        }\n\t        _this14.Session = data.Session;\n\t        return callback.associateSecretCode(data.SecretCode);\n\t      });\n\t    } else {\n\t      this.client.request('AssociateSoftwareToken', {\n\t        AccessToken: this.signInUserSession.getAccessToken().getJwtToken()\n\t      }, function (err, data) {\n\t        if (err) {\n\t          return callback.onFailure(err);\n\t        }\n\t        return callback.associateSecretCode(data.SecretCode);\n\t      });\n\t    }\n\t  };\n\t\n\t  /**\n\t   * This is used by an authenticated or a user trying to authenticate to verify a TOTP MFA\n\t   * @param {string} totpCode The MFA code entered by the user.\n\t   * @param {string} friendlyDeviceName The device name we are assigning to the device.\n\t   * @param {nodeCallback<string>} callback Called on success or error.\n\t   * @returns {void}\n\t   */\n\t\n\t\n\t  CognitoUser.prototype.verifySoftwareToken = function verifySoftwareToken(totpCode, friendlyDeviceName, callback) {\n\t    var _this15 = this;\n\t\n\t    if (!(this.signInUserSession != null && this.signInUserSession.isValid())) {\n\t      this.client.request('VerifySoftwareToken', {\n\t        Session: this.Session,\n\t        UserCode: totpCode,\n\t        FriendlyDeviceName: friendlyDeviceName\n\t      }, function (err, data) {\n\t        if (err) {\n\t          return callback.onFailure(err);\n\t        }\n\t        _this15.Session = data.Session;\n\t        var challengeResponses = {};\n\t        challengeResponses.USERNAME = _this15.username;\n\t        var jsonReq = {\n\t          ChallengeName: 'MFA_SETUP',\n\t          ClientId: _this15.pool.getClientId(),\n\t          ChallengeResponses: challengeResponses,\n\t          Session: _this15.Session\n\t        };\n\t        if (_this15.getUserContextData()) {\n\t          jsonReq.UserContextData = _this15.getUserContextData();\n\t        }\n\t        _this15.client.request('RespondToAuthChallenge', jsonReq, function (errRespond, dataRespond) {\n\t          if (errRespond) {\n\t            return callback.onFailure(errRespond);\n\t          }\n\t          _this15.signInUserSession = _this15.getCognitoUserSession(dataRespond.AuthenticationResult);\n\t          _this15.cacheTokens();\n\t          return callback.onSuccess(_this15.signInUserSession);\n\t        });\n\t        return undefined;\n\t      });\n\t    } else {\n\t      this.client.request('VerifySoftwareToken', {\n\t        AccessToken: this.signInUserSession.getAccessToken().getJwtToken(),\n\t        UserCode: totpCode,\n\t        FriendlyDeviceName: friendlyDeviceName\n\t      }, function (err, data) {\n\t        if (err) {\n\t          return callback.onFailure(err);\n\t        }\n\t        return callback.onSuccess(data);\n\t      });\n\t    }\n\t  };\n\t\n\t  return CognitoUser;\n\t}();\n\t\n\texports.default = CognitoUser;\n\n/***/ }),\n/* 10 */\n/***/ (function(module, exports) {\n\n\t'use strict';\n\t\n\texports.__esModule = true;\n\t\n\tfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\t\n\t/*!\n\t * Copyright 2016 Amazon.com,\n\t * Inc. or its affiliates. All Rights Reserved.\n\t *\n\t * Licensed under the Amazon Software License (the \"License\").\n\t * You may not use this file except in compliance with the\n\t * License. A copy of the License is located at\n\t *\n\t *     http://aws.amazon.com/asl/\n\t *\n\t * or in the \"license\" file accompanying this file. This file is\n\t * distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR\n\t * CONDITIONS OF ANY KIND, express or implied. See the License\n\t * for the specific language governing permissions and\n\t * limitations under the License.\n\t */\n\t\n\t/** @class */\n\tvar CognitoUserAttribute = function () {\n\t  /**\n\t   * Constructs a new CognitoUserAttribute object\n\t   * @param {string=} Name The record's name\n\t   * @param {string=} Value The record's value\n\t   */\n\t  function CognitoUserAttribute() {\n\t    var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},\n\t        Name = _ref.Name,\n\t        Value = _ref.Value;\n\t\n\t    _classCallCheck(this, CognitoUserAttribute);\n\t\n\t    this.Name = Name || '';\n\t    this.Value = Value || '';\n\t  }\n\t\n\t  /**\n\t   * @returns {string} the record's value.\n\t   */\n\t\n\t\n\t  CognitoUserAttribute.prototype.getValue = function getValue() {\n\t    return this.Value;\n\t  };\n\t\n\t  /**\n\t   * Sets the record's value.\n\t   * @param {string} value The new value.\n\t   * @returns {CognitoUserAttribute} The record for method chaining.\n\t   */\n\t\n\t\n\t  CognitoUserAttribute.prototype.setValue = function setValue(value) {\n\t    this.Value = value;\n\t    return this;\n\t  };\n\t\n\t  /**\n\t   * @returns {string} the record's name.\n\t   */\n\t\n\t\n\t  CognitoUserAttribute.prototype.getName = function getName() {\n\t    return this.Name;\n\t  };\n\t\n\t  /**\n\t   * Sets the record's name\n\t   * @param {string} name The new name.\n\t   * @returns {CognitoUserAttribute} The record for method chaining.\n\t   */\n\t\n\t\n\t  CognitoUserAttribute.prototype.setName = function setName(name) {\n\t    this.Name = name;\n\t    return this;\n\t  };\n\t\n\t  /**\n\t   * @returns {string} a string representation of the record.\n\t   */\n\t\n\t\n\t  CognitoUserAttribute.prototype.toString = function toString() {\n\t    return JSON.stringify(this);\n\t  };\n\t\n\t  /**\n\t   * @returns {object} a flat object representing the record.\n\t   */\n\t\n\t\n\t  CognitoUserAttribute.prototype.toJSON = function toJSON() {\n\t    return {\n\t      Name: this.Name,\n\t      Value: this.Value\n\t    };\n\t  };\n\t\n\t  return CognitoUserAttribute;\n\t}();\n\t\n\texports.default = CognitoUserAttribute;\n\n/***/ }),\n/* 11 */\n/***/ (function(module, exports) {\n\n\t'use strict';\n\t\n\texports.__esModule = true;\n\t\n\tfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\t\n\t/*!\n\t * Copyright 2016 Amazon.com,\n\t * Inc. or its affiliates. All Rights Reserved.\n\t *\n\t * Licensed under the Amazon Software License (the \"License\").\n\t * You may not use this file except in compliance with the\n\t * License. A copy of the License is located at\n\t *\n\t *     http://aws.amazon.com/asl/\n\t *\n\t * or in the \"license\" file accompanying this file. This file is\n\t * distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR\n\t * CONDITIONS OF ANY KIND, express or implied. See the License\n\t * for the specific language governing permissions and\n\t * limitations under the License.\n\t */\n\t\n\t/** @class */\n\tvar CognitoUserSession = function () {\n\t  /**\n\t   * Constructs a new CognitoUserSession object\n\t   * @param {CognitoIdToken} IdToken The session's Id token.\n\t   * @param {CognitoRefreshToken=} RefreshToken The session's refresh token.\n\t   * @param {CognitoAccessToken} AccessToken The session's access token.\n\t   * @param {int} ClockDrift The saved computer's clock drift or undefined to force calculation.\n\t   */\n\t  function CognitoUserSession() {\n\t    var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},\n\t        IdToken = _ref.IdToken,\n\t        RefreshToken = _ref.RefreshToken,\n\t        AccessToken = _ref.AccessToken,\n\t        ClockDrift = _ref.ClockDrift;\n\t\n\t    _classCallCheck(this, CognitoUserSession);\n\t\n\t    if (AccessToken == null || IdToken == null) {\n\t      throw new Error('Id token and Access Token must be present.');\n\t    }\n\t\n\t    this.idToken = IdToken;\n\t    this.refreshToken = RefreshToken;\n\t    this.accessToken = AccessToken;\n\t    this.clockDrift = ClockDrift === undefined ? this.calculateClockDrift() : ClockDrift;\n\t  }\n\t\n\t  /**\n\t   * @returns {CognitoIdToken} the session's Id token\n\t   */\n\t\n\t\n\t  CognitoUserSession.prototype.getIdToken = function getIdToken() {\n\t    return this.idToken;\n\t  };\n\t\n\t  /**\n\t   * @returns {CognitoRefreshToken} the session's refresh token\n\t   */\n\t\n\t\n\t  CognitoUserSession.prototype.getRefreshToken = function getRefreshToken() {\n\t    return this.refreshToken;\n\t  };\n\t\n\t  /**\n\t   * @returns {CognitoAccessToken} the session's access token\n\t   */\n\t\n\t\n\t  CognitoUserSession.prototype.getAccessToken = function getAccessToken() {\n\t    return this.accessToken;\n\t  };\n\t\n\t  /**\n\t   * @returns {int} the session's clock drift\n\t   */\n\t\n\t\n\t  CognitoUserSession.prototype.getClockDrift = function getClockDrift() {\n\t    return this.clockDrift;\n\t  };\n\t\n\t  /**\n\t   * @returns {int} the computer's clock drift\n\t   */\n\t\n\t\n\t  CognitoUserSession.prototype.calculateClockDrift = function calculateClockDrift() {\n\t    var now = Math.floor(new Date() / 1000);\n\t    var iat = Math.min(this.accessToken.getIssuedAt(), this.idToken.getIssuedAt());\n\t\n\t    return now - iat;\n\t  };\n\t\n\t  /**\n\t   * Checks to see if the session is still valid based on session expiry information found\n\t   * in tokens and the current time (adjusted with clock drift)\n\t   * @returns {boolean} if the session is still valid\n\t   */\n\t\n\t\n\t  CognitoUserSession.prototype.isValid = function isValid() {\n\t    var now = Math.floor(new Date() / 1000);\n\t    var adjusted = now - this.clockDrift;\n\t\n\t    return adjusted < this.accessToken.getExpiration() && adjusted < this.idToken.getExpiration();\n\t  };\n\t\n\t  return CognitoUserSession;\n\t}();\n\t\n\texports.default = CognitoUserSession;\n\n/***/ }),\n/* 12 */\n/***/ (function(module, exports) {\n\n\t'use strict';\n\t\n\texports.__esModule = true;\n\t\n\tfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\t\n\t/*!\n\t * Copyright 2016 Amazon.com,\n\t * Inc. or its affiliates. All Rights Reserved.\n\t *\n\t * Licensed under the Amazon Software License (the \"License\").\n\t * You may not use this file except in compliance with the\n\t * License. A copy of the License is located at\n\t *\n\t *     http://aws.amazon.com/asl/\n\t *\n\t * or in the \"license\" file accompanying this file. This file is\n\t * distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR\n\t * CONDITIONS OF ANY KIND, express or implied. See the License\n\t * for the specific language governing permissions and\n\t * limitations under the License.\n\t */\n\t\n\tvar monthNames = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];\n\tvar weekNames = ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'];\n\t\n\t/** @class */\n\t\n\tvar DateHelper = function () {\n\t  function DateHelper() {\n\t    _classCallCheck(this, DateHelper);\n\t  }\n\t\n\t  /**\n\t   * @returns {string} The current time in \"ddd MMM D HH:mm:ss UTC YYYY\" format.\n\t   */\n\t  DateHelper.prototype.getNowString = function getNowString() {\n\t    var now = new Date();\n\t\n\t    var weekDay = weekNames[now.getUTCDay()];\n\t    var month = monthNames[now.getUTCMonth()];\n\t    var day = now.getUTCDate();\n\t\n\t    var hours = now.getUTCHours();\n\t    if (hours < 10) {\n\t      hours = '0' + hours;\n\t    }\n\t\n\t    var minutes = now.getUTCMinutes();\n\t    if (minutes < 10) {\n\t      minutes = '0' + minutes;\n\t    }\n\t\n\t    var seconds = now.getUTCSeconds();\n\t    if (seconds < 10) {\n\t      seconds = '0' + seconds;\n\t    }\n\t\n\t    var year = now.getUTCFullYear();\n\t\n\t    // ddd MMM D HH:mm:ss UTC YYYY\n\t    var dateNow = weekDay + ' ' + month + ' ' + day + ' ' + hours + ':' + minutes + ':' + seconds + ' UTC ' + year;\n\t\n\t    return dateNow;\n\t  };\n\t\n\t  return DateHelper;\n\t}();\n\t\n\texports.default = DateHelper;\n\n/***/ }),\n/* 13 */\n/***/ (function(module, exports) {\n\n\t'use strict';\n\t\n\texports.__esModule = true;\n\t\n\tfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\t\n\t/*!\n\t * Copyright 2016 Amazon.com,\n\t * Inc. or its affiliates. All Rights Reserved.\n\t *\n\t * Licensed under the Amazon Software License (the \"License\").\n\t * You may not use this file except in compliance with the\n\t * License. A copy of the License is located at\n\t *\n\t *     http://aws.amazon.com/asl/\n\t *\n\t * or in the \"license\" file accompanying this file. This file is\n\t * distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR\n\t * CONDITIONS OF ANY KIND, express or implied. See the License\n\t * for the specific language governing permissions and\n\t * limitations under the License.\n\t */\n\t\n\tvar dataMemory = {};\n\t\n\t/** @class */\n\t\n\tvar MemoryStorage = function () {\n\t  function MemoryStorage() {\n\t    _classCallCheck(this, MemoryStorage);\n\t  }\n\t\n\t  /**\n\t   * This is used to set a specific item in storage\n\t   * @param {string} key - the key for the item\n\t   * @param {object} value - the value\n\t   * @returns {string} value that was set\n\t   */\n\t  MemoryStorage.setItem = function setItem(key, value) {\n\t    dataMemory[key] = value;\n\t    return dataMemory[key];\n\t  };\n\t\n\t  /**\n\t   * This is used to get a specific key from storage\n\t   * @param {string} key - the key for the item\n\t   * This is used to clear the storage\n\t   * @returns {string} the data item\n\t   */\n\t\n\t\n\t  MemoryStorage.getItem = function getItem(key) {\n\t    return Object.prototype.hasOwnProperty.call(dataMemory, key) ? dataMemory[key] : undefined;\n\t  };\n\t\n\t  /**\n\t   * This is used to remove an item from storage\n\t   * @param {string} key - the key being set\n\t   * @returns {string} value - value that was deleted\n\t   */\n\t\n\t\n\t  MemoryStorage.removeItem = function removeItem(key) {\n\t    return delete dataMemory[key];\n\t  };\n\t\n\t  /**\n\t   * This is used to clear the storage\n\t   * @returns {string} nothing\n\t   */\n\t\n\t\n\t  MemoryStorage.clear = function clear() {\n\t    dataMemory = {};\n\t    return dataMemory;\n\t  };\n\t\n\t  return MemoryStorage;\n\t}();\n\t\n\t/** @class */\n\t\n\t\n\tvar StorageHelper = function () {\n\t\n\t  /**\n\t   * This is used to get a storage object\n\t   * @returns {object} the storage\n\t   */\n\t  function StorageHelper() {\n\t    _classCallCheck(this, StorageHelper);\n\t\n\t    try {\n\t      this.storageWindow = window.localStorage;\n\t      this.storageWindow.setItem('aws.cognito.test-ls', 1);\n\t      this.storageWindow.removeItem('aws.cognito.test-ls');\n\t    } catch (exception) {\n\t      this.storageWindow = MemoryStorage;\n\t    }\n\t  }\n\t\n\t  /**\n\t   * This is used to return the storage\n\t   * @returns {object} the storage\n\t   */\n\t\n\t\n\t  StorageHelper.prototype.getStorage = function getStorage() {\n\t    return this.storageWindow;\n\t  };\n\t\n\t  return StorageHelper;\n\t}();\n\t\n\texports.default = StorageHelper;\n\n/***/ }),\n/* 14 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\tvar Buffer = __webpack_require__(1).Buffer\n\tvar sha = __webpack_require__(26)\n\tvar sha256 = __webpack_require__(27)\n\tvar rng = __webpack_require__(25)\n\tvar md5 = __webpack_require__(24)\n\t\n\tvar algorithms = {\n\t  sha1: sha,\n\t  sha256: sha256,\n\t  md5: md5\n\t}\n\t\n\tvar blocksize = 64\n\tvar zeroBuffer = new Buffer(blocksize); zeroBuffer.fill(0)\n\tfunction hmac(fn, key, data) {\n\t  if(!Buffer.isBuffer(key)) key = new Buffer(key)\n\t  if(!Buffer.isBuffer(data)) data = new Buffer(data)\n\t\n\t  if(key.length > blocksize) {\n\t    key = fn(key)\n\t  } else if(key.length < blocksize) {\n\t    key = Buffer.concat([key, zeroBuffer], blocksize)\n\t  }\n\t\n\t  var ipad = new Buffer(blocksize), opad = new Buffer(blocksize)\n\t  for(var i = 0; i < blocksize; i++) {\n\t    ipad[i] = key[i] ^ 0x36\n\t    opad[i] = key[i] ^ 0x5C\n\t  }\n\t\n\t  var hash = fn(Buffer.concat([ipad, data]))\n\t  return fn(Buffer.concat([opad, hash]))\n\t}\n\t\n\tfunction hash(alg, key) {\n\t  alg = alg || 'sha1'\n\t  var fn = algorithms[alg]\n\t  var bufs = []\n\t  var length = 0\n\t  if(!fn) error('algorithm:', alg, 'is not yet supported')\n\t  return {\n\t    update: function (data) {\n\t      if(!Buffer.isBuffer(data)) data = new Buffer(data)\n\t        \n\t      bufs.push(data)\n\t      length += data.length\n\t      return this\n\t    },\n\t    digest: function (enc) {\n\t      var buf = Buffer.concat(bufs)\n\t      var r = key ? hmac(fn, key, buf) : fn(buf)\n\t      bufs = null\n\t      return enc ? r.toString(enc) : r\n\t    }\n\t  }\n\t}\n\t\n\tfunction error () {\n\t  var m = [].slice.call(arguments).join(' ')\n\t  throw new Error([\n\t    m,\n\t    'we accept pull requests',\n\t    'http://github.com/dominictarr/crypto-browserify'\n\t    ].join('\\n'))\n\t}\n\t\n\texports.createHash = function (alg) { return hash(alg) }\n\texports.createHmac = function (alg, key) { return hash(alg, key) }\n\texports.randomBytes = function(size, callback) {\n\t  if (callback && callback.call) {\n\t    try {\n\t      callback.call(this, undefined, new Buffer(rng(size)))\n\t    } catch (err) { callback(err) }\n\t  } else {\n\t    return new Buffer(rng(size))\n\t  }\n\t}\n\t\n\tfunction each(a, f) {\n\t  for(var i in a)\n\t    f(a[i], i)\n\t}\n\t\n\t// the least I can do is make error messages for the rest of the node.js/crypto api.\n\teach(['createCredentials'\n\t, 'createCipher'\n\t, 'createCipheriv'\n\t, 'createDecipher'\n\t, 'createDecipheriv'\n\t, 'createSign'\n\t, 'createVerify'\n\t, 'createDiffieHellman'\n\t, 'pbkdf2'], function (name) {\n\t  exports[name] = function () {\n\t    error('sorry,', name, 'is not implemented yet')\n\t  }\n\t})\n\n\n/***/ }),\n/* 15 */\n/***/ (function(module, exports) {\n\n\t'use strict'\n\t\n\texports.byteLength = byteLength\n\texports.toByteArray = toByteArray\n\texports.fromByteArray = fromByteArray\n\t\n\tvar lookup = []\n\tvar revLookup = []\n\tvar Arr = typeof Uint8Array !== 'undefined' ? Uint8Array : Array\n\t\n\tvar code = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'\n\tfor (var i = 0, len = code.length; i < len; ++i) {\n\t  lookup[i] = code[i]\n\t  revLookup[code.charCodeAt(i)] = i\n\t}\n\t\n\t// Support decoding URL-safe base64 strings, as Node.js does.\n\t// See: https://en.wikipedia.org/wiki/Base64#URL_applications\n\trevLookup['-'.charCodeAt(0)] = 62\n\trevLookup['_'.charCodeAt(0)] = 63\n\t\n\tfunction getLens (b64) {\n\t  var len = b64.length\n\t\n\t  if (len % 4 > 0) {\n\t    throw new Error('Invalid string. Length must be a multiple of 4')\n\t  }\n\t\n\t  // Trim off extra bytes after placeholder bytes are found\n\t  // See: https://github.com/beatgammit/base64-js/issues/42\n\t  var validLen = b64.indexOf('=')\n\t  if (validLen === -1) validLen = len\n\t\n\t  var placeHoldersLen = validLen === len\n\t    ? 0\n\t    : 4 - (validLen % 4)\n\t\n\t  return [validLen, placeHoldersLen]\n\t}\n\t\n\t// base64 is 4/3 + up to two characters of the original data\n\tfunction byteLength (b64) {\n\t  var lens = getLens(b64)\n\t  var validLen = lens[0]\n\t  var placeHoldersLen = lens[1]\n\t  return ((validLen + placeHoldersLen) * 3 / 4) - placeHoldersLen\n\t}\n\t\n\tfunction _byteLength (b64, validLen, placeHoldersLen) {\n\t  return ((validLen + placeHoldersLen) * 3 / 4) - placeHoldersLen\n\t}\n\t\n\tfunction toByteArray (b64) {\n\t  var tmp\n\t  var lens = getLens(b64)\n\t  var validLen = lens[0]\n\t  var placeHoldersLen = lens[1]\n\t\n\t  var arr = new Arr(_byteLength(b64, validLen, placeHoldersLen))\n\t\n\t  var curByte = 0\n\t\n\t  // if there are placeholders, only get up to the last complete 4 chars\n\t  var len = placeHoldersLen > 0\n\t    ? validLen - 4\n\t    : validLen\n\t\n\t  for (var i = 0; i < len; i += 4) {\n\t    tmp =\n\t      (revLookup[b64.charCodeAt(i)] << 18) |\n\t      (revLookup[b64.charCodeAt(i + 1)] << 12) |\n\t      (revLookup[b64.charCodeAt(i + 2)] << 6) |\n\t      revLookup[b64.charCodeAt(i + 3)]\n\t    arr[curByte++] = (tmp >> 16) & 0xFF\n\t    arr[curByte++] = (tmp >> 8) & 0xFF\n\t    arr[curByte++] = tmp & 0xFF\n\t  }\n\t\n\t  if (placeHoldersLen === 2) {\n\t    tmp =\n\t      (revLookup[b64.charCodeAt(i)] << 2) |\n\t      (revLookup[b64.charCodeAt(i + 1)] >> 4)\n\t    arr[curByte++] = tmp & 0xFF\n\t  }\n\t\n\t  if (placeHoldersLen === 1) {\n\t    tmp =\n\t      (revLookup[b64.charCodeAt(i)] << 10) |\n\t      (revLookup[b64.charCodeAt(i + 1)] << 4) |\n\t      (revLookup[b64.charCodeAt(i + 2)] >> 2)\n\t    arr[curByte++] = (tmp >> 8) & 0xFF\n\t    arr[curByte++] = tmp & 0xFF\n\t  }\n\t\n\t  return arr\n\t}\n\t\n\tfunction tripletToBase64 (num) {\n\t  return lookup[num >> 18 & 0x3F] +\n\t    lookup[num >> 12 & 0x3F] +\n\t    lookup[num >> 6 & 0x3F] +\n\t    lookup[num & 0x3F]\n\t}\n\t\n\tfunction encodeChunk (uint8, start, end) {\n\t  var tmp\n\t  var output = []\n\t  for (var i = start; i < end; i += 3) {\n\t    tmp =\n\t      ((uint8[i] << 16) & 0xFF0000) +\n\t      ((uint8[i + 1] << 8) & 0xFF00) +\n\t      (uint8[i + 2] & 0xFF)\n\t    output.push(tripletToBase64(tmp))\n\t  }\n\t  return output.join('')\n\t}\n\t\n\tfunction fromByteArray (uint8) {\n\t  var tmp\n\t  var len = uint8.length\n\t  var extraBytes = len % 3 // if we have 1 byte left, pad 2 bytes\n\t  var parts = []\n\t  var maxChunkLength = 16383 // must be multiple of 3\n\t\n\t  // go through the array every three bytes, we'll deal with trailing stuff later\n\t  for (var i = 0, len2 = len - extraBytes; i < len2; i += maxChunkLength) {\n\t    parts.push(encodeChunk(\n\t      uint8, i, (i + maxChunkLength) > len2 ? len2 : (i + maxChunkLength)\n\t    ))\n\t  }\n\t\n\t  // pad the end with zeros, but make sure to not forget the extra bytes\n\t  if (extraBytes === 1) {\n\t    tmp = uint8[len - 1]\n\t    parts.push(\n\t      lookup[tmp >> 2] +\n\t      lookup[(tmp << 4) & 0x3F] +\n\t      '=='\n\t    )\n\t  } else if (extraBytes === 2) {\n\t    tmp = (uint8[len - 2] << 8) + uint8[len - 1]\n\t    parts.push(\n\t      lookup[tmp >> 10] +\n\t      lookup[(tmp >> 4) & 0x3F] +\n\t      lookup[(tmp << 2) & 0x3F] +\n\t      '='\n\t    )\n\t  }\n\t\n\t  return parts.join('')\n\t}\n\n\n/***/ }),\n/* 16 */\n/***/ (function(module, exports) {\n\n\texports.read = function (buffer, offset, isLE, mLen, nBytes) {\n\t  var e, m\n\t  var eLen = (nBytes * 8) - mLen - 1\n\t  var eMax = (1 << eLen) - 1\n\t  var eBias = eMax >> 1\n\t  var nBits = -7\n\t  var i = isLE ? (nBytes - 1) : 0\n\t  var d = isLE ? -1 : 1\n\t  var s = buffer[offset + i]\n\t\n\t  i += d\n\t\n\t  e = s & ((1 << (-nBits)) - 1)\n\t  s >>= (-nBits)\n\t  nBits += eLen\n\t  for (; nBits > 0; e = (e * 256) + buffer[offset + i], i += d, nBits -= 8) {}\n\t\n\t  m = e & ((1 << (-nBits)) - 1)\n\t  e >>= (-nBits)\n\t  nBits += mLen\n\t  for (; nBits > 0; m = (m * 256) + buffer[offset + i], i += d, nBits -= 8) {}\n\t\n\t  if (e === 0) {\n\t    e = 1 - eBias\n\t  } else if (e === eMax) {\n\t    return m ? NaN : ((s ? -1 : 1) * Infinity)\n\t  } else {\n\t    m = m + Math.pow(2, mLen)\n\t    e = e - eBias\n\t  }\n\t  return (s ? -1 : 1) * m * Math.pow(2, e - mLen)\n\t}\n\t\n\texports.write = function (buffer, value, offset, isLE, mLen, nBytes) {\n\t  var e, m, c\n\t  var eLen = (nBytes * 8) - mLen - 1\n\t  var eMax = (1 << eLen) - 1\n\t  var eBias = eMax >> 1\n\t  var rt = (mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0)\n\t  var i = isLE ? 0 : (nBytes - 1)\n\t  var d = isLE ? 1 : -1\n\t  var s = value < 0 || (value === 0 && 1 / value < 0) ? 1 : 0\n\t\n\t  value = Math.abs(value)\n\t\n\t  if (isNaN(value) || value === Infinity) {\n\t    m = isNaN(value) ? 1 : 0\n\t    e = eMax\n\t  } else {\n\t    e = Math.floor(Math.log(value) / Math.LN2)\n\t    if (value * (c = Math.pow(2, -e)) < 1) {\n\t      e--\n\t      c *= 2\n\t    }\n\t    if (e + eBias >= 1) {\n\t      value += rt / c\n\t    } else {\n\t      value += rt * Math.pow(2, 1 - eBias)\n\t    }\n\t    if (value * c >= 2) {\n\t      e++\n\t      c /= 2\n\t    }\n\t\n\t    if (e + eBias >= eMax) {\n\t      m = 0\n\t      e = eMax\n\t    } else if (e + eBias >= 1) {\n\t      m = ((value * c) - 1) * Math.pow(2, mLen)\n\t      e = e + eBias\n\t    } else {\n\t      m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen)\n\t      e = 0\n\t    }\n\t  }\n\t\n\t  for (; mLen >= 8; buffer[offset + i] = m & 0xff, i += d, m /= 256, mLen -= 8) {}\n\t\n\t  e = (e << mLen) | m\n\t  eLen += mLen\n\t  for (; eLen > 0; buffer[offset + i] = e & 0xff, i += d, e /= 256, eLen -= 8) {}\n\t\n\t  buffer[offset + i - d] |= s * 128\n\t}\n\n\n/***/ }),\n/* 17 */\n/***/ (function(module, exports) {\n\n\tvar toString = {}.toString;\n\t\n\tmodule.exports = Array.isArray || function (arr) {\n\t  return toString.call(arr) == '[object Array]';\n\t};\n\n\n/***/ }),\n/* 18 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\tvar __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_RESULT__;/*!\n\t * JavaScript Cookie v2.2.0\n\t * https://github.com/js-cookie/js-cookie\n\t *\n\t * Copyright 2006, 2015 Klaus Hartl & Fagner Brack\n\t * Released under the MIT license\n\t */\n\t;(function (factory) {\n\t\tvar registeredInModuleLoader = false;\n\t\tif (true) {\n\t\t\t!(__WEBPACK_AMD_DEFINE_FACTORY__ = (factory), __WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ? (__WEBPACK_AMD_DEFINE_FACTORY__.call(exports, __webpack_require__, exports, module)) : __WEBPACK_AMD_DEFINE_FACTORY__), __WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));\n\t\t\tregisteredInModuleLoader = true;\n\t\t}\n\t\tif (true) {\n\t\t\tmodule.exports = factory();\n\t\t\tregisteredInModuleLoader = true;\n\t\t}\n\t\tif (!registeredInModuleLoader) {\n\t\t\tvar OldCookies = window.Cookies;\n\t\t\tvar api = window.Cookies = factory();\n\t\t\tapi.noConflict = function () {\n\t\t\t\twindow.Cookies = OldCookies;\n\t\t\t\treturn api;\n\t\t\t};\n\t\t}\n\t}(function () {\n\t\tfunction extend () {\n\t\t\tvar i = 0;\n\t\t\tvar result = {};\n\t\t\tfor (; i < arguments.length; i++) {\n\t\t\t\tvar attributes = arguments[ i ];\n\t\t\t\tfor (var key in attributes) {\n\t\t\t\t\tresult[key] = attributes[key];\n\t\t\t\t}\n\t\t\t}\n\t\t\treturn result;\n\t\t}\n\t\n\t\tfunction init (converter) {\n\t\t\tfunction api (key, value, attributes) {\n\t\t\t\tvar result;\n\t\t\t\tif (typeof document === 'undefined') {\n\t\t\t\t\treturn;\n\t\t\t\t}\n\t\n\t\t\t\t// Write\n\t\n\t\t\t\tif (arguments.length > 1) {\n\t\t\t\t\tattributes = extend({\n\t\t\t\t\t\tpath: '/'\n\t\t\t\t\t}, api.defaults, attributes);\n\t\n\t\t\t\t\tif (typeof attributes.expires === 'number') {\n\t\t\t\t\t\tvar expires = new Date();\n\t\t\t\t\t\texpires.setMilliseconds(expires.getMilliseconds() + attributes.expires * 864e+5);\n\t\t\t\t\t\tattributes.expires = expires;\n\t\t\t\t\t}\n\t\n\t\t\t\t\t// We're using \"expires\" because \"max-age\" is not supported by IE\n\t\t\t\t\tattributes.expires = attributes.expires ? attributes.expires.toUTCString() : '';\n\t\n\t\t\t\t\ttry {\n\t\t\t\t\t\tresult = JSON.stringify(value);\n\t\t\t\t\t\tif (/^[\\{\\[]/.test(result)) {\n\t\t\t\t\t\t\tvalue = result;\n\t\t\t\t\t\t}\n\t\t\t\t\t} catch (e) {}\n\t\n\t\t\t\t\tif (!converter.write) {\n\t\t\t\t\t\tvalue = encodeURIComponent(String(value))\n\t\t\t\t\t\t\t.replace(/%(23|24|26|2B|3A|3C|3E|3D|2F|3F|40|5B|5D|5E|60|7B|7D|7C)/g, decodeURIComponent);\n\t\t\t\t\t} else {\n\t\t\t\t\t\tvalue = converter.write(value, key);\n\t\t\t\t\t}\n\t\n\t\t\t\t\tkey = encodeURIComponent(String(key));\n\t\t\t\t\tkey = key.replace(/%(23|24|26|2B|5E|60|7C)/g, decodeURIComponent);\n\t\t\t\t\tkey = key.replace(/[\\(\\)]/g, escape);\n\t\n\t\t\t\t\tvar stringifiedAttributes = '';\n\t\n\t\t\t\t\tfor (var attributeName in attributes) {\n\t\t\t\t\t\tif (!attributes[attributeName]) {\n\t\t\t\t\t\t\tcontinue;\n\t\t\t\t\t\t}\n\t\t\t\t\t\tstringifiedAttributes += '; ' + attributeName;\n\t\t\t\t\t\tif (attributes[attributeName] === true) {\n\t\t\t\t\t\t\tcontinue;\n\t\t\t\t\t\t}\n\t\t\t\t\t\tstringifiedAttributes += '=' + attributes[attributeName];\n\t\t\t\t\t}\n\t\t\t\t\treturn (document.cookie = key + '=' + value + stringifiedAttributes);\n\t\t\t\t}\n\t\n\t\t\t\t// Read\n\t\n\t\t\t\tif (!key) {\n\t\t\t\t\tresult = {};\n\t\t\t\t}\n\t\n\t\t\t\t// To prevent the for loop in the first place assign an empty array\n\t\t\t\t// in case there are no cookies at all. Also prevents odd result when\n\t\t\t\t// calling \"get()\"\n\t\t\t\tvar cookies = document.cookie ? document.cookie.split('; ') : [];\n\t\t\t\tvar rdecode = /(%[0-9A-Z]{2})+/g;\n\t\t\t\tvar i = 0;\n\t\n\t\t\t\tfor (; i < cookies.length; i++) {\n\t\t\t\t\tvar parts = cookies[i].split('=');\n\t\t\t\t\tvar cookie = parts.slice(1).join('=');\n\t\n\t\t\t\t\tif (!this.json && cookie.charAt(0) === '\"') {\n\t\t\t\t\t\tcookie = cookie.slice(1, -1);\n\t\t\t\t\t}\n\t\n\t\t\t\t\ttry {\n\t\t\t\t\t\tvar name = parts[0].replace(rdecode, decodeURIComponent);\n\t\t\t\t\t\tcookie = converter.read ?\n\t\t\t\t\t\t\tconverter.read(cookie, name) : converter(cookie, name) ||\n\t\t\t\t\t\t\tcookie.replace(rdecode, decodeURIComponent);\n\t\n\t\t\t\t\t\tif (this.json) {\n\t\t\t\t\t\t\ttry {\n\t\t\t\t\t\t\t\tcookie = JSON.parse(cookie);\n\t\t\t\t\t\t\t} catch (e) {}\n\t\t\t\t\t\t}\n\t\n\t\t\t\t\t\tif (key === name) {\n\t\t\t\t\t\t\tresult = cookie;\n\t\t\t\t\t\t\tbreak;\n\t\t\t\t\t\t}\n\t\n\t\t\t\t\t\tif (!key) {\n\t\t\t\t\t\t\tresult[name] = cookie;\n\t\t\t\t\t\t}\n\t\t\t\t\t} catch (e) {}\n\t\t\t\t}\n\t\n\t\t\t\treturn result;\n\t\t\t}\n\t\n\t\t\tapi.set = api;\n\t\t\tapi.get = function (key) {\n\t\t\t\treturn api.call(api, key);\n\t\t\t};\n\t\t\tapi.getJSON = function () {\n\t\t\t\treturn api.apply({\n\t\t\t\t\tjson: true\n\t\t\t\t}, [].slice.call(arguments));\n\t\t\t};\n\t\t\tapi.defaults = {};\n\t\n\t\t\tapi.remove = function (key, attributes) {\n\t\t\t\tapi(key, '', extend(attributes, {\n\t\t\t\t\texpires: -1\n\t\t\t\t}));\n\t\t\t};\n\t\n\t\t\tapi.withConverter = init;\n\t\n\t\t\treturn api;\n\t\t}\n\t\n\t\treturn init(function () {});\n\t}));\n\n\n/***/ }),\n/* 19 */\n/***/ (function(module, exports) {\n\n\t\"use strict\";\n\t\n\texports.__esModule = true;\n\t\n\tfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\t\n\t/*!\n\t * Copyright 2016 Amazon.com,\n\t * Inc. or its affiliates. All Rights Reserved.\n\t *\n\t * Licensed under the Amazon Software License (the \"License\").\n\t * You may not use this file except in compliance with the\n\t * License. A copy of the License is located at\n\t *\n\t *     http://aws.amazon.com/asl/\n\t *\n\t * or in the \"license\" file accompanying this file. This file is\n\t * distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR\n\t * CONDITIONS OF ANY KIND, express or implied. See the License\n\t * for the specific language governing permissions and\n\t * limitations under the License.\n\t */\n\t\n\t/** @class */\n\tvar AuthenticationDetails = function () {\n\t  /**\n\t   * Constructs a new AuthenticationDetails object\n\t   * @param {object=} data Creation options.\n\t   * @param {string} data.Username User being authenticated.\n\t   * @param {string} data.Password Plain-text password to authenticate with.\n\t   * @param {(AttributeArg[])?} data.ValidationData Application extra metadata.\n\t   * @param {(AttributeArg[])?} data.AuthParamaters Authentication paramaters for custom auth.\n\t   */\n\t  function AuthenticationDetails(data) {\n\t    _classCallCheck(this, AuthenticationDetails);\n\t\n\t    var _ref = data || {},\n\t        ValidationData = _ref.ValidationData,\n\t        Username = _ref.Username,\n\t        Password = _ref.Password,\n\t        AuthParameters = _ref.AuthParameters;\n\t\n\t    this.validationData = ValidationData || {};\n\t    this.authParameters = AuthParameters || {};\n\t    this.username = Username;\n\t    this.password = Password;\n\t  }\n\t\n\t  /**\n\t   * @returns {string} the record's username\n\t   */\n\t\n\t\n\t  AuthenticationDetails.prototype.getUsername = function getUsername() {\n\t    return this.username;\n\t  };\n\t\n\t  /**\n\t   * @returns {string} the record's password\n\t   */\n\t\n\t\n\t  AuthenticationDetails.prototype.getPassword = function getPassword() {\n\t    return this.password;\n\t  };\n\t\n\t  /**\n\t   * @returns {Array} the record's validationData\n\t   */\n\t\n\t\n\t  AuthenticationDetails.prototype.getValidationData = function getValidationData() {\n\t    return this.validationData;\n\t  };\n\t\n\t  /**\n\t   * @returns {Array} the record's authParameters\n\t   */\n\t\n\t\n\t  AuthenticationDetails.prototype.getAuthParameters = function getAuthParameters() {\n\t    return this.authParameters;\n\t  };\n\t\n\t  return AuthenticationDetails;\n\t}();\n\t\n\texports.default = AuthenticationDetails;\n\n/***/ }),\n/* 20 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\t'use strict';\n\t\n\texports.__esModule = true;\n\t\n\tvar _UserAgent = __webpack_require__(23);\n\t\n\tvar _UserAgent2 = _interopRequireDefault(_UserAgent);\n\t\n\tfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\t\n\tfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\t\n\t/** @class */\n\tvar Client = function () {\n\t  /**\n\t   * Constructs a new AWS Cognito Identity Provider client object\n\t   * @param {string} region AWS region\n\t   * @param {string} endpoint endpoint\n\t   */\n\t  function Client(region, endpoint) {\n\t    _classCallCheck(this, Client);\n\t\n\t    this.endpoint = endpoint || 'https://cognito-idp.' + region + '.amazonaws.com/';\n\t    this.userAgent = _UserAgent2.default.prototype.userAgent || 'aws-amplify/0.1.x js';\n\t  }\n\t\n\t  /**\n\t   * Makes an unauthenticated request on AWS Cognito Identity Provider API\n\t   * using fetch\n\t   * @param {string} operation API operation\n\t   * @param {object} params Input parameters\n\t   * @param {function} callback Callback called when a response is returned\n\t   * @returns {void}\n\t  */\n\t\n\t\n\t  Client.prototype.request = function request(operation, params, callback) {\n\t    var headers = {\n\t      'Content-Type': 'application/x-amz-json-1.1',\n\t      'X-Amz-Target': 'AWSCognitoIdentityProviderService.' + operation,\n\t      'X-Amz-User-Agent': this.userAgent\n\t    };\n\t\n\t    var options = {\n\t      headers: headers,\n\t      method: 'POST',\n\t      mode: 'cors',\n\t      cache: 'no-cache',\n\t      body: JSON.stringify(params)\n\t    };\n\t\n\t    var response = void 0;\n\t\n\t    fetch(this.endpoint, options).then(function (resp) {\n\t      response = resp;\n\t      return resp;\n\t    }, function (err) {\n\t      // If error happens here, the request failed\n\t      // if it is TypeError throw network error\n\t      if (err instanceof TypeError) {\n\t        throw new Error('Network error');\n\t      }\n\t      throw err;\n\t    }).then(function (resp) {\n\t      return resp.json().catch(function () {\n\t        return {};\n\t      });\n\t    }).then(function (data) {\n\t      if (response.ok) return callback(null, data);\n\t\n\t      // Taken from aws-sdk-js/lib/protocol/json.js\n\t      // eslint-disable-next-line no-underscore-dangle\n\t      var code = (data.__type || data.code).split('#').pop();\n\t      var error = {\n\t        code: code,\n\t        name: code,\n\t        message: data.message || data.Message || null\n\t      };\n\t      return callback(error);\n\t    }).catch(function (err) {\n\t      // default to return 'UnknownError'\n\t      var error = { code: 'UnknownError', message: 'Unkown error' };\n\t\n\t      // first check if we have a service error\n\t      if (response && response.headers && response.headers.get('x-amzn-errortype')) {\n\t        try {\n\t          var code = response.headers.get('x-amzn-errortype').split(':')[0];\n\t          error = {\n\t            code: code,\n\t            name: code,\n\t            statusCode: response.status,\n\t            message: response.status ? response.status.toString() : null\n\t          };\n\t        } catch (ex) {\n\t          // pass through so it doesn't get swallowed if we can't parse it\n\t          error = {\n\t            code: 'UnknownError',\n\t            message: response.headers.get('x-amzn-errortype')\n\t          };\n\t          return callback(error);\n\t        }\n\t        // otherwise check if error is Network error\n\t      } else if (err instanceof Error && err.message === 'Network error') {\n\t        error = {\n\t          code: 'NetworkError',\n\t          name: err.name,\n\t          message: err.message\n\t        };\n\t      }\n\t      return callback(error);\n\t    });\n\t  };\n\t\n\t  return Client;\n\t}();\n\t\n\texports.default = Client;\n\n/***/ }),\n/* 21 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\t'use strict';\n\t\n\texports.__esModule = true;\n\t\n\tvar _Client = __webpack_require__(20);\n\t\n\tvar _Client2 = _interopRequireDefault(_Client);\n\t\n\tvar _CognitoUser = __webpack_require__(9);\n\t\n\tvar _CognitoUser2 = _interopRequireDefault(_CognitoUser);\n\t\n\tvar _StorageHelper = __webpack_require__(13);\n\t\n\tvar _StorageHelper2 = _interopRequireDefault(_StorageHelper);\n\t\n\tfunction _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }\n\t\n\tfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } } /*!\n\t                                                                                                                                                           * Copyright 2016 Amazon.com,\n\t                                                                                                                                                           * Inc. or its affiliates. All Rights Reserved.\n\t                                                                                                                                                           *\n\t                                                                                                                                                           * Licensed under the Amazon Software License (the \"License\").\n\t                                                                                                                                                           * You may not use this file except in compliance with the\n\t                                                                                                                                                           * License. A copy of the License is located at\n\t                                                                                                                                                           *\n\t                                                                                                                                                           *     http://aws.amazon.com/asl/\n\t                                                                                                                                                           *\n\t                                                                                                                                                           * or in the \"license\" file accompanying this file. This file is\n\t                                                                                                                                                           * distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR\n\t                                                                                                                                                           * CONDITIONS OF ANY KIND, express or implied. See the License\n\t                                                                                                                                                           * for the specific language governing permissions and\n\t                                                                                                                                                           * limitations under the License.\n\t                                                                                                                                                           */\n\t\n\t/** @class */\n\tvar CognitoUserPool = function () {\n\t  /**\n\t   * Constructs a new CognitoUserPool object\n\t   * @param {object} data Creation options.\n\t   * @param {string} data.UserPoolId Cognito user pool id.\n\t   * @param {string} data.ClientId User pool application client id.\n\t   * @param {object} data.Storage Optional storage object.\n\t   * @param {boolean} data.AdvancedSecurityDataCollectionFlag Optional:\n\t   *        boolean flag indicating if the data collection is enabled\n\t   *        to support cognito advanced security features. By default, this\n\t   *        flag is set to true.\n\t   */\n\t  function CognitoUserPool(data) {\n\t    _classCallCheck(this, CognitoUserPool);\n\t\n\t    var _ref = data || {},\n\t        UserPoolId = _ref.UserPoolId,\n\t        ClientId = _ref.ClientId,\n\t        endpoint = _ref.endpoint,\n\t        AdvancedSecurityDataCollectionFlag = _ref.AdvancedSecurityDataCollectionFlag;\n\t\n\t    if (!UserPoolId || !ClientId) {\n\t      throw new Error('Both UserPoolId and ClientId are required.');\n\t    }\n\t    if (!/^[\\w-]+_.+$/.test(UserPoolId)) {\n\t      throw new Error('Invalid UserPoolId format.');\n\t    }\n\t    var region = UserPoolId.split('_')[0];\n\t\n\t    this.userPoolId = UserPoolId;\n\t    this.clientId = ClientId;\n\t\n\t    this.client = new _Client2.default(region, endpoint);\n\t\n\t    /**\n\t     * By default, AdvancedSecurityDataCollectionFlag is set to true,\n\t     * if no input value is provided.\n\t     */\n\t    this.advancedSecurityDataCollectionFlag = AdvancedSecurityDataCollectionFlag !== false;\n\t\n\t    this.storage = data.Storage || new _StorageHelper2.default().getStorage();\n\t  }\n\t\n\t  /**\n\t   * @returns {string} the user pool id\n\t   */\n\t\n\t\n\t  CognitoUserPool.prototype.getUserPoolId = function getUserPoolId() {\n\t    return this.userPoolId;\n\t  };\n\t\n\t  /**\n\t   * @returns {string} the client id\n\t   */\n\t\n\t\n\t  CognitoUserPool.prototype.getClientId = function getClientId() {\n\t    return this.clientId;\n\t  };\n\t\n\t  /**\n\t   * @typedef {object} SignUpResult\n\t   * @property {CognitoUser} user New user.\n\t   * @property {bool} userConfirmed If the user is already confirmed.\n\t   */\n\t  /**\n\t   * method for signing up a user\n\t   * @param {string} username User's username.\n\t   * @param {string} password Plain-text initial password entered by user.\n\t   * @param {(AttributeArg[])=} userAttributes New user attributes.\n\t   * @param {(AttributeArg[])=} validationData Application metadata.\n\t   * @param {nodeCallback<SignUpResult>} callback Called on error or with the new user.\n\t   * @returns {void}\n\t   */\n\t\n\t\n\t  CognitoUserPool.prototype.signUp = function signUp(username, password, userAttributes, validationData, callback) {\n\t    var _this = this;\n\t\n\t    var jsonReq = {\n\t      ClientId: this.clientId,\n\t      Username: username,\n\t      Password: password,\n\t      UserAttributes: userAttributes,\n\t      ValidationData: validationData\n\t    };\n\t    if (this.getUserContextData(username)) {\n\t      jsonReq.UserContextData = this.getUserContextData(username);\n\t    }\n\t    this.client.request('SignUp', jsonReq, function (err, data) {\n\t      if (err) {\n\t        return callback(err, null);\n\t      }\n\t\n\t      var cognitoUser = {\n\t        Username: username,\n\t        Pool: _this,\n\t        Storage: _this.storage\n\t      };\n\t\n\t      var returnData = {\n\t        user: new _CognitoUser2.default(cognitoUser),\n\t        userConfirmed: data.UserConfirmed,\n\t        userSub: data.UserSub\n\t      };\n\t\n\t      return callback(null, returnData);\n\t    });\n\t  };\n\t\n\t  /**\n\t   * method for getting the current user of the application from the local storage\n\t   *\n\t   * @returns {CognitoUser} the user retrieved from storage\n\t   */\n\t\n\t\n\t  CognitoUserPool.prototype.getCurrentUser = function getCurrentUser() {\n\t    var lastUserKey = 'CognitoIdentityServiceProvider.' + this.clientId + '.LastAuthUser';\n\t\n\t    var lastAuthUser = this.storage.getItem(lastUserKey);\n\t    if (lastAuthUser) {\n\t      var cognitoUser = {\n\t        Username: lastAuthUser,\n\t        Pool: this,\n\t        Storage: this.storage\n\t      };\n\t\n\t      return new _CognitoUser2.default(cognitoUser);\n\t    }\n\t\n\t    return null;\n\t  };\n\t\n\t  /**\n\t   * This method returns the encoded data string used for cognito advanced security feature.\n\t   * This would be generated only when developer has included the JS used for collecting the\n\t   * data on their client. Please refer to documentation to know more about using AdvancedSecurity\n\t   * features\n\t   * @param {string} username the username for the context data\n\t   * @returns {string} the user context data\n\t   **/\n\t\n\t\n\t  CognitoUserPool.prototype.getUserContextData = function getUserContextData(username) {\n\t    if (typeof AmazonCognitoAdvancedSecurityData === 'undefined') {\n\t      return undefined;\n\t    }\n\t    /* eslint-disable */\n\t    var amazonCognitoAdvancedSecurityDataConst = AmazonCognitoAdvancedSecurityData;\n\t    /* eslint-enable */\n\t\n\t    if (this.advancedSecurityDataCollectionFlag) {\n\t      var advancedSecurityData = amazonCognitoAdvancedSecurityDataConst.getData(username, this.userPoolId, this.clientId);\n\t      if (advancedSecurityData) {\n\t        var userContextData = {\n\t          EncodedData: advancedSecurityData\n\t        };\n\t        return userContextData;\n\t      }\n\t    }\n\t    return {};\n\t  };\n\t\n\t  return CognitoUserPool;\n\t}();\n\t\n\texports.default = CognitoUserPool;\n\n/***/ }),\n/* 22 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\t'use strict';\n\t\n\texports.__esModule = true;\n\t\n\tvar _jsCookie = __webpack_require__(18);\n\t\n\tvar Cookies = _interopRequireWildcard(_jsCookie);\n\t\n\tfunction _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }\n\t\n\tfunction _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError(\"Cannot call a class as a function\"); } }\n\t\n\t/** @class */\n\tvar CookieStorage = function () {\n\t\n\t  /**\n\t   * Constructs a new CookieStorage object\n\t   * @param {object} data Creation options.\n\t   * @param {string} data.domain Cookies domain (mandatory).\n\t   * @param {string} data.path Cookies path (default: '/')\n\t   * @param {integer} data.expires Cookie expiration (in days, default: 365)\n\t   * @param {boolean} data.secure Cookie secure flag (default: true)\n\t   */\n\t  function CookieStorage(data) {\n\t    _classCallCheck(this, CookieStorage);\n\t\n\t    this.domain = data.domain;\n\t    if (data.path) {\n\t      this.path = data.path;\n\t    } else {\n\t      this.path = '/';\n\t    }\n\t    if (Object.prototype.hasOwnProperty.call(data, 'expires')) {\n\t      this.expires = data.expires;\n\t    } else {\n\t      this.expires = 365;\n\t    }\n\t    if (Object.prototype.hasOwnProperty.call(data, 'secure')) {\n\t      this.secure = data.secure;\n\t    } else {\n\t      this.secure = true;\n\t    }\n\t  }\n\t\n\t  /**\n\t   * This is used to set a specific item in storage\n\t   * @param {string} key - the key for the item\n\t   * @param {object} value - the value\n\t   * @returns {string} value that was set\n\t   */\n\t\n\t\n\t  CookieStorage.prototype.setItem = function setItem(key, value) {\n\t    Cookies.set(key, value, {\n\t      path: this.path,\n\t      expires: this.expires,\n\t      domain: this.domain,\n\t      secure: this.secure\n\t    });\n\t    return Cookies.get(key);\n\t  };\n\t\n\t  /**\n\t   * This is used to get a specific key from storage\n\t   * @param {string} key - the key for the item\n\t   * This is used to clear the storage\n\t   * @returns {string} the data item\n\t   */\n\t\n\t\n\t  CookieStorage.prototype.getItem = function getItem(key) {\n\t    return Cookies.get(key);\n\t  };\n\t\n\t  /**\n\t   * This is used to remove an item from storage\n\t   * @param {string} key - the key being set\n\t   * @returns {string} value - value that was deleted\n\t   */\n\t\n\t\n\t  CookieStorage.prototype.removeItem = function removeItem(key) {\n\t    return Cookies.remove(key, {\n\t      path: this.path,\n\t      domain: this.domain,\n\t      secure: this.secure\n\t    });\n\t  };\n\t\n\t  /**\n\t   * This is used to clear the storage\n\t   * @returns {string} nothing\n\t   */\n\t\n\t\n\t  CookieStorage.prototype.clear = function clear() {\n\t    var cookies = Cookies.get();\n\t    var index = void 0;\n\t    for (index = 0; index < cookies.length; ++index) {\n\t      Cookies.remove(cookies[index]);\n\t    }\n\t    return {};\n\t  };\n\t\n\t  return CookieStorage;\n\t}();\n\t\n\texports.default = CookieStorage;\n\n/***/ }),\n/* 23 */\n/***/ (function(module, exports) {\n\n\t'use strict';\n\t\n\texports.__esModule = true;\n\t// class for defining the amzn user-agent\n\texports.default = UserAgent;\n\t// constructor\n\t\n\tfunction UserAgent() {}\n\t// public\n\tUserAgent.prototype.userAgent = 'aws-amplify/0.1.x js';\n\n/***/ }),\n/* 24 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\t/*\r\n\t * A JavaScript implementation of the RSA Data Security, Inc. MD5 Message\r\n\t * Digest Algorithm, as defined in RFC 1321.\r\n\t * Version 2.1 Copyright (C) Paul Johnston 1999 - 2002.\r\n\t * Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet\r\n\t * Distributed under the BSD License\r\n\t * See http://pajhome.org.uk/crypt/md5 for more info.\r\n\t */\r\n\t\r\n\tvar helpers = __webpack_require__(2);\r\n\t\r\n\t/*\r\n\t * Perform a simple self-test to see if the VM is working\r\n\t */\r\n\tfunction md5_vm_test()\r\n\t{\r\n\t  return hex_md5(\"abc\") == \"900150983cd24fb0d6963f7d28e17f72\";\r\n\t}\r\n\t\r\n\t/*\r\n\t * Calculate the MD5 of an array of little-endian words, and a bit length\r\n\t */\r\n\tfunction core_md5(x, len)\r\n\t{\r\n\t  /* append padding */\r\n\t  x[len >> 5] |= 0x80 << ((len) % 32);\r\n\t  x[(((len + 64) >>> 9) << 4) + 14] = len;\r\n\t\r\n\t  var a =  1732584193;\r\n\t  var b = -271733879;\r\n\t  var c = -1732584194;\r\n\t  var d =  271733878;\r\n\t\r\n\t  for(var i = 0; i < x.length; i += 16)\r\n\t  {\r\n\t    var olda = a;\r\n\t    var oldb = b;\r\n\t    var oldc = c;\r\n\t    var oldd = d;\r\n\t\r\n\t    a = md5_ff(a, b, c, d, x[i+ 0], 7 , -680876936);\r\n\t    d = md5_ff(d, a, b, c, x[i+ 1], 12, -389564586);\r\n\t    c = md5_ff(c, d, a, b, x[i+ 2], 17,  606105819);\r\n\t    b = md5_ff(b, c, d, a, x[i+ 3], 22, -1044525330);\r\n\t    a = md5_ff(a, b, c, d, x[i+ 4], 7 , -176418897);\r\n\t    d = md5_ff(d, a, b, c, x[i+ 5], 12,  1200080426);\r\n\t    c = md5_ff(c, d, a, b, x[i+ 6], 17, -1473231341);\r\n\t    b = md5_ff(b, c, d, a, x[i+ 7], 22, -45705983);\r\n\t    a = md5_ff(a, b, c, d, x[i+ 8], 7 ,  1770035416);\r\n\t    d = md5_ff(d, a, b, c, x[i+ 9], 12, -1958414417);\r\n\t    c = md5_ff(c, d, a, b, x[i+10], 17, -42063);\r\n\t    b = md5_ff(b, c, d, a, x[i+11], 22, -1990404162);\r\n\t    a = md5_ff(a, b, c, d, x[i+12], 7 ,  1804603682);\r\n\t    d = md5_ff(d, a, b, c, x[i+13], 12, -40341101);\r\n\t    c = md5_ff(c, d, a, b, x[i+14], 17, -1502002290);\r\n\t    b = md5_ff(b, c, d, a, x[i+15], 22,  1236535329);\r\n\t\r\n\t    a = md5_gg(a, b, c, d, x[i+ 1], 5 , -165796510);\r\n\t    d = md5_gg(d, a, b, c, x[i+ 6], 9 , -1069501632);\r\n\t    c = md5_gg(c, d, a, b, x[i+11], 14,  643717713);\r\n\t    b = md5_gg(b, c, d, a, x[i+ 0], 20, -373897302);\r\n\t    a = md5_gg(a, b, c, d, x[i+ 5], 5 , -701558691);\r\n\t    d = md5_gg(d, a, b, c, x[i+10], 9 ,  38016083);\r\n\t    c = md5_gg(c, d, a, b, x[i+15], 14, -660478335);\r\n\t    b = md5_gg(b, c, d, a, x[i+ 4], 20, -405537848);\r\n\t    a = md5_gg(a, b, c, d, x[i+ 9], 5 ,  568446438);\r\n\t    d = md5_gg(d, a, b, c, x[i+14], 9 , -1019803690);\r\n\t    c = md5_gg(c, d, a, b, x[i+ 3], 14, -187363961);\r\n\t    b = md5_gg(b, c, d, a, x[i+ 8], 20,  1163531501);\r\n\t    a = md5_gg(a, b, c, d, x[i+13], 5 , -1444681467);\r\n\t    d = md5_gg(d, a, b, c, x[i+ 2], 9 , -51403784);\r\n\t    c = md5_gg(c, d, a, b, x[i+ 7], 14,  1735328473);\r\n\t    b = md5_gg(b, c, d, a, x[i+12], 20, -1926607734);\r\n\t\r\n\t    a = md5_hh(a, b, c, d, x[i+ 5], 4 , -378558);\r\n\t    d = md5_hh(d, a, b, c, x[i+ 8], 11, -2022574463);\r\n\t    c = md5_hh(c, d, a, b, x[i+11], 16,  1839030562);\r\n\t    b = md5_hh(b, c, d, a, x[i+14], 23, -35309556);\r\n\t    a = md5_hh(a, b, c, d, x[i+ 1], 4 , -1530992060);\r\n\t    d = md5_hh(d, a, b, c, x[i+ 4], 11,  1272893353);\r\n\t    c = md5_hh(c, d, a, b, x[i+ 7], 16, -155497632);\r\n\t    b = md5_hh(b, c, d, a, x[i+10], 23, -1094730640);\r\n\t    a = md5_hh(a, b, c, d, x[i+13], 4 ,  681279174);\r\n\t    d = md5_hh(d, a, b, c, x[i+ 0], 11, -358537222);\r\n\t    c = md5_hh(c, d, a, b, x[i+ 3], 16, -722521979);\r\n\t    b = md5_hh(b, c, d, a, x[i+ 6], 23,  76029189);\r\n\t    a = md5_hh(a, b, c, d, x[i+ 9], 4 , -640364487);\r\n\t    d = md5_hh(d, a, b, c, x[i+12], 11, -421815835);\r\n\t    c = md5_hh(c, d, a, b, x[i+15], 16,  530742520);\r\n\t    b = md5_hh(b, c, d, a, x[i+ 2], 23, -995338651);\r\n\t\r\n\t    a = md5_ii(a, b, c, d, x[i+ 0], 6 , -198630844);\r\n\t    d = md5_ii(d, a, b, c, x[i+ 7], 10,  1126891415);\r\n\t    c = md5_ii(c, d, a, b, x[i+14], 15, -1416354905);\r\n\t    b = md5_ii(b, c, d, a, x[i+ 5], 21, -57434055);\r\n\t    a = md5_ii(a, b, c, d, x[i+12], 6 ,  1700485571);\r\n\t    d = md5_ii(d, a, b, c, x[i+ 3], 10, -1894986606);\r\n\t    c = md5_ii(c, d, a, b, x[i+10], 15, -1051523);\r\n\t    b = md5_ii(b, c, d, a, x[i+ 1], 21, -2054922799);\r\n\t    a = md5_ii(a, b, c, d, x[i+ 8], 6 ,  1873313359);\r\n\t    d = md5_ii(d, a, b, c, x[i+15], 10, -30611744);\r\n\t    c = md5_ii(c, d, a, b, x[i+ 6], 15, -1560198380);\r\n\t    b = md5_ii(b, c, d, a, x[i+13], 21,  1309151649);\r\n\t    a = md5_ii(a, b, c, d, x[i+ 4], 6 , -145523070);\r\n\t    d = md5_ii(d, a, b, c, x[i+11], 10, -1120210379);\r\n\t    c = md5_ii(c, d, a, b, x[i+ 2], 15,  718787259);\r\n\t    b = md5_ii(b, c, d, a, x[i+ 9], 21, -343485551);\r\n\t\r\n\t    a = safe_add(a, olda);\r\n\t    b = safe_add(b, oldb);\r\n\t    c = safe_add(c, oldc);\r\n\t    d = safe_add(d, oldd);\r\n\t  }\r\n\t  return Array(a, b, c, d);\r\n\t\r\n\t}\r\n\t\r\n\t/*\r\n\t * These functions implement the four basic operations the algorithm uses.\r\n\t */\r\n\tfunction md5_cmn(q, a, b, x, s, t)\r\n\t{\r\n\t  return safe_add(bit_rol(safe_add(safe_add(a, q), safe_add(x, t)), s),b);\r\n\t}\r\n\tfunction md5_ff(a, b, c, d, x, s, t)\r\n\t{\r\n\t  return md5_cmn((b & c) | ((~b) & d), a, b, x, s, t);\r\n\t}\r\n\tfunction md5_gg(a, b, c, d, x, s, t)\r\n\t{\r\n\t  return md5_cmn((b & d) | (c & (~d)), a, b, x, s, t);\r\n\t}\r\n\tfunction md5_hh(a, b, c, d, x, s, t)\r\n\t{\r\n\t  return md5_cmn(b ^ c ^ d, a, b, x, s, t);\r\n\t}\r\n\tfunction md5_ii(a, b, c, d, x, s, t)\r\n\t{\r\n\t  return md5_cmn(c ^ (b | (~d)), a, b, x, s, t);\r\n\t}\r\n\t\r\n\t/*\r\n\t * Add integers, wrapping at 2^32. This uses 16-bit operations internally\r\n\t * to work around bugs in some JS interpreters.\r\n\t */\r\n\tfunction safe_add(x, y)\r\n\t{\r\n\t  var lsw = (x & 0xFFFF) + (y & 0xFFFF);\r\n\t  var msw = (x >> 16) + (y >> 16) + (lsw >> 16);\r\n\t  return (msw << 16) | (lsw & 0xFFFF);\r\n\t}\r\n\t\r\n\t/*\r\n\t * Bitwise rotate a 32-bit number to the left.\r\n\t */\r\n\tfunction bit_rol(num, cnt)\r\n\t{\r\n\t  return (num << cnt) | (num >>> (32 - cnt));\r\n\t}\r\n\t\r\n\tmodule.exports = function md5(buf) {\r\n\t  return helpers.hash(buf, core_md5, 16);\r\n\t};\r\n\n\n/***/ }),\n/* 25 */\n/***/ (function(module, exports) {\n\n\t// Original code adapted from Robert Kieffer.\n\t// details at https://github.com/broofa/node-uuid\n\t(function() {\n\t  var _global = this;\n\t\n\t  var mathRNG, whatwgRNG;\n\t\n\t  // NOTE: Math.random() does not guarantee \"cryptographic quality\"\n\t  mathRNG = function(size) {\n\t    var bytes = new Array(size);\n\t    var r;\n\t\n\t    for (var i = 0, r; i < size; i++) {\n\t      if ((i & 0x03) == 0) r = Math.random() * 0x100000000;\n\t      bytes[i] = r >>> ((i & 0x03) << 3) & 0xff;\n\t    }\n\t\n\t    return bytes;\n\t  }\n\t\n\t  if (_global.crypto && crypto.getRandomValues) {\n\t    whatwgRNG = function(size) {\n\t      var bytes = new Uint8Array(size);\n\t      crypto.getRandomValues(bytes);\n\t      return bytes;\n\t    }\n\t  }\n\t\n\t  module.exports = whatwgRNG || mathRNG;\n\t\n\t}())\n\n\n/***/ }),\n/* 26 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\t/*\n\t * A JavaScript implementation of the Secure Hash Algorithm, SHA-1, as defined\n\t * in FIPS PUB 180-1\n\t * Version 2.1a Copyright Paul Johnston 2000 - 2002.\n\t * Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet\n\t * Distributed under the BSD License\n\t * See http://pajhome.org.uk/crypt/md5 for details.\n\t */\n\t\n\tvar helpers = __webpack_require__(2);\n\t\n\t/*\n\t * Calculate the SHA-1 of an array of big-endian words, and a bit length\n\t */\n\tfunction core_sha1(x, len)\n\t{\n\t  /* append padding */\n\t  x[len >> 5] |= 0x80 << (24 - len % 32);\n\t  x[((len + 64 >> 9) << 4) + 15] = len;\n\t\n\t  var w = Array(80);\n\t  var a =  1732584193;\n\t  var b = -271733879;\n\t  var c = -1732584194;\n\t  var d =  271733878;\n\t  var e = -1009589776;\n\t\n\t  for(var i = 0; i < x.length; i += 16)\n\t  {\n\t    var olda = a;\n\t    var oldb = b;\n\t    var oldc = c;\n\t    var oldd = d;\n\t    var olde = e;\n\t\n\t    for(var j = 0; j < 80; j++)\n\t    {\n\t      if(j < 16) w[j] = x[i + j];\n\t      else w[j] = rol(w[j-3] ^ w[j-8] ^ w[j-14] ^ w[j-16], 1);\n\t      var t = safe_add(safe_add(rol(a, 5), sha1_ft(j, b, c, d)),\n\t                       safe_add(safe_add(e, w[j]), sha1_kt(j)));\n\t      e = d;\n\t      d = c;\n\t      c = rol(b, 30);\n\t      b = a;\n\t      a = t;\n\t    }\n\t\n\t    a = safe_add(a, olda);\n\t    b = safe_add(b, oldb);\n\t    c = safe_add(c, oldc);\n\t    d = safe_add(d, oldd);\n\t    e = safe_add(e, olde);\n\t  }\n\t  return Array(a, b, c, d, e);\n\t\n\t}\n\t\n\t/*\n\t * Perform the appropriate triplet combination function for the current\n\t * iteration\n\t */\n\tfunction sha1_ft(t, b, c, d)\n\t{\n\t  if(t < 20) return (b & c) | ((~b) & d);\n\t  if(t < 40) return b ^ c ^ d;\n\t  if(t < 60) return (b & c) | (b & d) | (c & d);\n\t  return b ^ c ^ d;\n\t}\n\t\n\t/*\n\t * Determine the appropriate additive constant for the current iteration\n\t */\n\tfunction sha1_kt(t)\n\t{\n\t  return (t < 20) ?  1518500249 : (t < 40) ?  1859775393 :\n\t         (t < 60) ? -1894007588 : -899497514;\n\t}\n\t\n\t/*\n\t * Add integers, wrapping at 2^32. This uses 16-bit operations internally\n\t * to work around bugs in some JS interpreters.\n\t */\n\tfunction safe_add(x, y)\n\t{\n\t  var lsw = (x & 0xFFFF) + (y & 0xFFFF);\n\t  var msw = (x >> 16) + (y >> 16) + (lsw >> 16);\n\t  return (msw << 16) | (lsw & 0xFFFF);\n\t}\n\t\n\t/*\n\t * Bitwise rotate a 32-bit number to the left.\n\t */\n\tfunction rol(num, cnt)\n\t{\n\t  return (num << cnt) | (num >>> (32 - cnt));\n\t}\n\t\n\tmodule.exports = function sha1(buf) {\n\t  return helpers.hash(buf, core_sha1, 20, true);\n\t};\n\n\n/***/ }),\n/* 27 */\n/***/ (function(module, exports, __webpack_require__) {\n\n\t\n\t/**\n\t * A JavaScript implementation of the Secure Hash Algorithm, SHA-256, as defined\n\t * in FIPS 180-2\n\t * Version 2.2-beta Copyright Angel Marin, Paul Johnston 2000 - 2009.\n\t * Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet\n\t *\n\t */\n\t\n\tvar helpers = __webpack_require__(2);\n\t\n\tvar safe_add = function(x, y) {\n\t  var lsw = (x & 0xFFFF) + (y & 0xFFFF);\n\t  var msw = (x >> 16) + (y >> 16) + (lsw >> 16);\n\t  return (msw << 16) | (lsw & 0xFFFF);\n\t};\n\t\n\tvar S = function(X, n) {\n\t  return (X >>> n) | (X << (32 - n));\n\t};\n\t\n\tvar R = function(X, n) {\n\t  return (X >>> n);\n\t};\n\t\n\tvar Ch = function(x, y, z) {\n\t  return ((x & y) ^ ((~x) & z));\n\t};\n\t\n\tvar Maj = function(x, y, z) {\n\t  return ((x & y) ^ (x & z) ^ (y & z));\n\t};\n\t\n\tvar Sigma0256 = function(x) {\n\t  return (S(x, 2) ^ S(x, 13) ^ S(x, 22));\n\t};\n\t\n\tvar Sigma1256 = function(x) {\n\t  return (S(x, 6) ^ S(x, 11) ^ S(x, 25));\n\t};\n\t\n\tvar Gamma0256 = function(x) {\n\t  return (S(x, 7) ^ S(x, 18) ^ R(x, 3));\n\t};\n\t\n\tvar Gamma1256 = function(x) {\n\t  return (S(x, 17) ^ S(x, 19) ^ R(x, 10));\n\t};\n\t\n\tvar core_sha256 = function(m, l) {\n\t  var K = new Array(0x428A2F98,0x71374491,0xB5C0FBCF,0xE9B5DBA5,0x3956C25B,0x59F111F1,0x923F82A4,0xAB1C5ED5,0xD807AA98,0x12835B01,0x243185BE,0x550C7DC3,0x72BE5D74,0x80DEB1FE,0x9BDC06A7,0xC19BF174,0xE49B69C1,0xEFBE4786,0xFC19DC6,0x240CA1CC,0x2DE92C6F,0x4A7484AA,0x5CB0A9DC,0x76F988DA,0x983E5152,0xA831C66D,0xB00327C8,0xBF597FC7,0xC6E00BF3,0xD5A79147,0x6CA6351,0x14292967,0x27B70A85,0x2E1B2138,0x4D2C6DFC,0x53380D13,0x650A7354,0x766A0ABB,0x81C2C92E,0x92722C85,0xA2BFE8A1,0xA81A664B,0xC24B8B70,0xC76C51A3,0xD192E819,0xD6990624,0xF40E3585,0x106AA070,0x19A4C116,0x1E376C08,0x2748774C,0x34B0BCB5,0x391C0CB3,0x4ED8AA4A,0x5B9CCA4F,0x682E6FF3,0x748F82EE,0x78A5636F,0x84C87814,0x8CC70208,0x90BEFFFA,0xA4506CEB,0xBEF9A3F7,0xC67178F2);\n\t  var HASH = new Array(0x6A09E667, 0xBB67AE85, 0x3C6EF372, 0xA54FF53A, 0x510E527F, 0x9B05688C, 0x1F83D9AB, 0x5BE0CD19);\n\t    var W = new Array(64);\n\t    var a, b, c, d, e, f, g, h, i, j;\n\t    var T1, T2;\n\t  /* append padding */\n\t  m[l >> 5] |= 0x80 << (24 - l % 32);\n\t  m[((l + 64 >> 9) << 4) + 15] = l;\n\t  for (var i = 0; i < m.length; i += 16) {\n\t    a = HASH[0]; b = HASH[1]; c = HASH[2]; d = HASH[3]; e = HASH[4]; f = HASH[5]; g = HASH[6]; h = HASH[7];\n\t    for (var j = 0; j < 64; j++) {\n\t      if (j < 16) {\n\t        W[j] = m[j + i];\n\t      } else {\n\t        W[j] = safe_add(safe_add(safe_add(Gamma1256(W[j - 2]), W[j - 7]), Gamma0256(W[j - 15])), W[j - 16]);\n\t      }\n\t      T1 = safe_add(safe_add(safe_add(safe_add(h, Sigma1256(e)), Ch(e, f, g)), K[j]), W[j]);\n\t      T2 = safe_add(Sigma0256(a), Maj(a, b, c));\n\t      h = g; g = f; f = e; e = safe_add(d, T1); d = c; c = b; b = a; a = safe_add(T1, T2);\n\t    }\n\t    HASH[0] = safe_add(a, HASH[0]); HASH[1] = safe_add(b, HASH[1]); HASH[2] = safe_add(c, HASH[2]); HASH[3] = safe_add(d, HASH[3]);\n\t    HASH[4] = safe_add(e, HASH[4]); HASH[5] = safe_add(f, HASH[5]); HASH[6] = safe_add(g, HASH[6]); HASH[7] = safe_add(h, HASH[7]);\n\t  }\n\t  return HASH;\n\t};\n\t\n\tmodule.exports = function sha256(buf) {\n\t  return helpers.hash(buf, core_sha256, 32, true);\n\t};\n\n\n/***/ })\n/******/ ])\n});\n;\n\n\n// WEBPACK FOOTER //\n// amazon-cognito-identity.min.js"," \t// The module cache\n \tvar installedModules = {};\n\n \t// The require function\n \tfunction __webpack_require__(moduleId) {\n\n \t\t// Check if module is in cache\n \t\tif(installedModules[moduleId])\n \t\t\treturn installedModules[moduleId].exports;\n\n \t\t// Create a new module (and put it into the cache)\n \t\tvar module = installedModules[moduleId] = {\n \t\t\texports: {},\n \t\t\tid: moduleId,\n \t\t\tloaded: false\n \t\t};\n\n \t\t// Execute the module function\n \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n \t\t// Flag the module as loaded\n \t\tmodule.loaded = true;\n\n \t\t// Return the exports of the module\n \t\treturn module.exports;\n \t}\n\n\n \t// expose the modules object (__webpack_modules__)\n \t__webpack_require__.m = modules;\n\n \t// expose the module cache\n \t__webpack_require__.c = installedModules;\n\n \t// __webpack_public_path__\n \t__webpack_require__.p = \"\";\n\n \t// Load entry module and return exports\n \treturn __webpack_require__(0);\n\n\n\n// WEBPACK FOOTER //\n// webpack/bootstrap 491cfc370b425e28b040","/*!\n * Copyright 2016 Amazon.com,\n * Inc. or its affiliates. All Rights Reserved.\n *\n * Licensed under the Amazon Software License (the \"License\").\n * You may not use this file except in compliance with the\n * License. A copy of the License is located at\n *\n *     http://aws.amazon.com/asl/\n *\n * or in the \"license\" file accompanying this file. This file is\n * distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR\n * CONDITIONS OF ANY KIND, express or implied. See the License\n * for the specific language governing permissions and\n * limitations under the License.\n */\n\nexport { default as AuthenticationDetails } from './AuthenticationDetails';\nexport { default as AuthenticationHelper } from './AuthenticationHelper';\nexport { default as CognitoAccessToken } from './CognitoAccessToken';\nexport { default as CognitoIdToken } from './CognitoIdToken';\nexport { default as CognitoRefreshToken } from './CognitoRefreshToken';\nexport { default as CognitoUser } from './CognitoUser';\nexport { default as CognitoUserAttribute } from './CognitoUserAttribute';\nexport { default as CognitoUserPool } from './CognitoUserPool';\nexport { default as CognitoUserSession } from './CognitoUserSession';\nexport { default as CookieStorage } from './CookieStorage';\nexport { default as DateHelper } from './DateHelper';\n\n\n\n// WEBPACK FOOTER //\n// ./src/index.js","/*!\n * The buffer module from node.js, for the browser.\n *\n * @author   Feross Aboukhadijeh <feross@feross.org> <http://feross.org>\n * @license  MIT\n */\n/* eslint-disable no-proto */\n\n'use strict'\n\nvar base64 = require('base64-js')\nvar ieee754 = require('ieee754')\nvar isArray = require('isarray')\n\nexports.Buffer = Buffer\nexports.SlowBuffer = SlowBuffer\nexports.INSPECT_MAX_BYTES = 50\n\n/**\n * If `Buffer.TYPED_ARRAY_SUPPORT`:\n *   === true    Use Uint8Array implementation (fastest)\n *   === false   Use Object implementation (most compatible, even IE6)\n *\n * Browsers that support typed arrays are IE 10+, Firefox 4+, Chrome 7+, Safari 5.1+,\n * Opera 11.6+, iOS 4.2+.\n *\n * Due to various browser bugs, sometimes the Object implementation will be used even\n * when the browser supports typed arrays.\n *\n * Note:\n *\n *   - Firefox 4-29 lacks support for adding new properties to `Uint8Array` instances,\n *     See: https://bugzilla.mozilla.org/show_bug.cgi?id=695438.\n *\n *   - Chrome 9-10 is missing the `TypedArray.prototype.subarray` function.\n *\n *   - IE10 has a broken `TypedArray.prototype.subarray` function which returns arrays of\n *     incorrect length in some situations.\n\n * We detect these buggy browsers and set `Buffer.TYPED_ARRAY_SUPPORT` to `false` so they\n * get the Object implementation, which is slower but behaves correctly.\n */\nBuffer.TYPED_ARRAY_SUPPORT = global.TYPED_ARRAY_SUPPORT !== undefined\n  ? global.TYPED_ARRAY_SUPPORT\n  : typedArraySupport()\n\n/*\n * Export kMaxLength after typed array support is determined.\n */\nexports.kMaxLength = kMaxLength()\n\nfunction typedArraySupport () {\n  try {\n    var arr = new Uint8Array(1)\n    arr.__proto__ = {__proto__: Uint8Array.prototype, foo: function () { return 42 }}\n    return arr.foo() === 42 && // typed array instances can be augmented\n        typeof arr.subarray === 'function' && // chrome 9-10 lack `subarray`\n        arr.subarray(1, 1).byteLength === 0 // ie10 has broken `subarray`\n  } catch (e) {\n    return false\n  }\n}\n\nfunction kMaxLength () {\n  return Buffer.TYPED_ARRAY_SUPPORT\n    ? 0x7fffffff\n    : 0x3fffffff\n}\n\nfunction createBuffer (that, length) {\n  if (kMaxLength() < length) {\n    throw new RangeError('Invalid typed array length')\n  }\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    // Return an augmented `Uint8Array` instance, for best performance\n    that = new Uint8Array(length)\n    that.__proto__ = Buffer.prototype\n  } else {\n    // Fallback: Return an object instance of the Buffer class\n    if (that === null) {\n      that = new Buffer(length)\n    }\n    that.length = length\n  }\n\n  return that\n}\n\n/**\n * The Buffer constructor returns instances of `Uint8Array` that have their\n * prototype changed to `Buffer.prototype`. Furthermore, `Buffer` is a subclass of\n * `Uint8Array`, so the returned instances will have all the node `Buffer` methods\n * and the `Uint8Array` methods. Square bracket notation works as expected -- it\n * returns a single octet.\n *\n * The `Uint8Array` prototype remains unmodified.\n */\n\nfunction Buffer (arg, encodingOrOffset, length) {\n  if (!Buffer.TYPED_ARRAY_SUPPORT && !(this instanceof Buffer)) {\n    return new Buffer(arg, encodingOrOffset, length)\n  }\n\n  // Common case.\n  if (typeof arg === 'number') {\n    if (typeof encodingOrOffset === 'string') {\n      throw new Error(\n        'If encoding is specified then the first argument must be a string'\n      )\n    }\n    return allocUnsafe(this, arg)\n  }\n  return from(this, arg, encodingOrOffset, length)\n}\n\nBuffer.poolSize = 8192 // not used by this implementation\n\n// TODO: Legacy, not needed anymore. Remove in next major version.\nBuffer._augment = function (arr) {\n  arr.__proto__ = Buffer.prototype\n  return arr\n}\n\nfunction from (that, value, encodingOrOffset, length) {\n  if (typeof value === 'number') {\n    throw new TypeError('\"value\" argument must not be a number')\n  }\n\n  if (typeof ArrayBuffer !== 'undefined' && value instanceof ArrayBuffer) {\n    return fromArrayBuffer(that, value, encodingOrOffset, length)\n  }\n\n  if (typeof value === 'string') {\n    return fromString(that, value, encodingOrOffset)\n  }\n\n  return fromObject(that, value)\n}\n\n/**\n * Functionally equivalent to Buffer(arg, encoding) but throws a TypeError\n * if value is a number.\n * Buffer.from(str[, encoding])\n * Buffer.from(array)\n * Buffer.from(buffer)\n * Buffer.from(arrayBuffer[, byteOffset[, length]])\n **/\nBuffer.from = function (value, encodingOrOffset, length) {\n  return from(null, value, encodingOrOffset, length)\n}\n\nif (Buffer.TYPED_ARRAY_SUPPORT) {\n  Buffer.prototype.__proto__ = Uint8Array.prototype\n  Buffer.__proto__ = Uint8Array\n  if (typeof Symbol !== 'undefined' && Symbol.species &&\n      Buffer[Symbol.species] === Buffer) {\n    // Fix subarray() in ES2016. See: https://github.com/feross/buffer/pull/97\n    Object.defineProperty(Buffer, Symbol.species, {\n      value: null,\n      configurable: true\n    })\n  }\n}\n\nfunction assertSize (size) {\n  if (typeof size !== 'number') {\n    throw new TypeError('\"size\" argument must be a number')\n  } else if (size < 0) {\n    throw new RangeError('\"size\" argument must not be negative')\n  }\n}\n\nfunction alloc (that, size, fill, encoding) {\n  assertSize(size)\n  if (size <= 0) {\n    return createBuffer(that, size)\n  }\n  if (fill !== undefined) {\n    // Only pay attention to encoding if it's a string. This\n    // prevents accidentally sending in a number that would\n    // be interpretted as a start offset.\n    return typeof encoding === 'string'\n      ? createBuffer(that, size).fill(fill, encoding)\n      : createBuffer(that, size).fill(fill)\n  }\n  return createBuffer(that, size)\n}\n\n/**\n * Creates a new filled Buffer instance.\n * alloc(size[, fill[, encoding]])\n **/\nBuffer.alloc = function (size, fill, encoding) {\n  return alloc(null, size, fill, encoding)\n}\n\nfunction allocUnsafe (that, size) {\n  assertSize(size)\n  that = createBuffer(that, size < 0 ? 0 : checked(size) | 0)\n  if (!Buffer.TYPED_ARRAY_SUPPORT) {\n    for (var i = 0; i < size; ++i) {\n      that[i] = 0\n    }\n  }\n  return that\n}\n\n/**\n * Equivalent to Buffer(num), by default creates a non-zero-filled Buffer instance.\n * */\nBuffer.allocUnsafe = function (size) {\n  return allocUnsafe(null, size)\n}\n/**\n * Equivalent to SlowBuffer(num), by default creates a non-zero-filled Buffer instance.\n */\nBuffer.allocUnsafeSlow = function (size) {\n  return allocUnsafe(null, size)\n}\n\nfunction fromString (that, string, encoding) {\n  if (typeof encoding !== 'string' || encoding === '') {\n    encoding = 'utf8'\n  }\n\n  if (!Buffer.isEncoding(encoding)) {\n    throw new TypeError('\"encoding\" must be a valid string encoding')\n  }\n\n  var length = byteLength(string, encoding) | 0\n  that = createBuffer(that, length)\n\n  var actual = that.write(string, encoding)\n\n  if (actual !== length) {\n    // Writing a hex string, for example, that contains invalid characters will\n    // cause everything after the first invalid character to be ignored. (e.g.\n    // 'abxxcd' will be treated as 'ab')\n    that = that.slice(0, actual)\n  }\n\n  return that\n}\n\nfunction fromArrayLike (that, array) {\n  var length = array.length < 0 ? 0 : checked(array.length) | 0\n  that = createBuffer(that, length)\n  for (var i = 0; i < length; i += 1) {\n    that[i] = array[i] & 255\n  }\n  return that\n}\n\nfunction fromArrayBuffer (that, array, byteOffset, length) {\n  array.byteLength // this throws if `array` is not a valid ArrayBuffer\n\n  if (byteOffset < 0 || array.byteLength < byteOffset) {\n    throw new RangeError('\\'offset\\' is out of bounds')\n  }\n\n  if (array.byteLength < byteOffset + (length || 0)) {\n    throw new RangeError('\\'length\\' is out of bounds')\n  }\n\n  if (byteOffset === undefined && length === undefined) {\n    array = new Uint8Array(array)\n  } else if (length === undefined) {\n    array = new Uint8Array(array, byteOffset)\n  } else {\n    array = new Uint8Array(array, byteOffset, length)\n  }\n\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    // Return an augmented `Uint8Array` instance, for best performance\n    that = array\n    that.__proto__ = Buffer.prototype\n  } else {\n    // Fallback: Return an object instance of the Buffer class\n    that = fromArrayLike(that, array)\n  }\n  return that\n}\n\nfunction fromObject (that, obj) {\n  if (Buffer.isBuffer(obj)) {\n    var len = checked(obj.length) | 0\n    that = createBuffer(that, len)\n\n    if (that.length === 0) {\n      return that\n    }\n\n    obj.copy(that, 0, 0, len)\n    return that\n  }\n\n  if (obj) {\n    if ((typeof ArrayBuffer !== 'undefined' &&\n        obj.buffer instanceof ArrayBuffer) || 'length' in obj) {\n      if (typeof obj.length !== 'number' || isnan(obj.length)) {\n        return createBuffer(that, 0)\n      }\n      return fromArrayLike(that, obj)\n    }\n\n    if (obj.type === 'Buffer' && isArray(obj.data)) {\n      return fromArrayLike(that, obj.data)\n    }\n  }\n\n  throw new TypeError('First argument must be a string, Buffer, ArrayBuffer, Array, or array-like object.')\n}\n\nfunction checked (length) {\n  // Note: cannot use `length < kMaxLength()` here because that fails when\n  // length is NaN (which is otherwise coerced to zero.)\n  if (length >= kMaxLength()) {\n    throw new RangeError('Attempt to allocate Buffer larger than maximum ' +\n                         'size: 0x' + kMaxLength().toString(16) + ' bytes')\n  }\n  return length | 0\n}\n\nfunction SlowBuffer (length) {\n  if (+length != length) { // eslint-disable-line eqeqeq\n    length = 0\n  }\n  return Buffer.alloc(+length)\n}\n\nBuffer.isBuffer = function isBuffer (b) {\n  return !!(b != null && b._isBuffer)\n}\n\nBuffer.compare = function compare (a, b) {\n  if (!Buffer.isBuffer(a) || !Buffer.isBuffer(b)) {\n    throw new TypeError('Arguments must be Buffers')\n  }\n\n  if (a === b) return 0\n\n  var x = a.length\n  var y = b.length\n\n  for (var i = 0, len = Math.min(x, y); i < len; ++i) {\n    if (a[i] !== b[i]) {\n      x = a[i]\n      y = b[i]\n      break\n    }\n  }\n\n  if (x < y) return -1\n  if (y < x) return 1\n  return 0\n}\n\nBuffer.isEncoding = function isEncoding (encoding) {\n  switch (String(encoding).toLowerCase()) {\n    case 'hex':\n    case 'utf8':\n    case 'utf-8':\n    case 'ascii':\n    case 'latin1':\n    case 'binary':\n    case 'base64':\n    case 'ucs2':\n    case 'ucs-2':\n    case 'utf16le':\n    case 'utf-16le':\n      return true\n    default:\n      return false\n  }\n}\n\nBuffer.concat = function concat (list, length) {\n  if (!isArray(list)) {\n    throw new TypeError('\"list\" argument must be an Array of Buffers')\n  }\n\n  if (list.length === 0) {\n    return Buffer.alloc(0)\n  }\n\n  var i\n  if (length === undefined) {\n    length = 0\n    for (i = 0; i < list.length; ++i) {\n      length += list[i].length\n    }\n  }\n\n  var buffer = Buffer.allocUnsafe(length)\n  var pos = 0\n  for (i = 0; i < list.length; ++i) {\n    var buf = list[i]\n    if (!Buffer.isBuffer(buf)) {\n      throw new TypeError('\"list\" argument must be an Array of Buffers')\n    }\n    buf.copy(buffer, pos)\n    pos += buf.length\n  }\n  return buffer\n}\n\nfunction byteLength (string, encoding) {\n  if (Buffer.isBuffer(string)) {\n    return string.length\n  }\n  if (typeof ArrayBuffer !== 'undefined' && typeof ArrayBuffer.isView === 'function' &&\n      (ArrayBuffer.isView(string) || string instanceof ArrayBuffer)) {\n    return string.byteLength\n  }\n  if (typeof string !== 'string') {\n    string = '' + string\n  }\n\n  var len = string.length\n  if (len === 0) return 0\n\n  // Use a for loop to avoid recursion\n  var loweredCase = false\n  for (;;) {\n    switch (encoding) {\n      case 'ascii':\n      case 'latin1':\n      case 'binary':\n        return len\n      case 'utf8':\n      case 'utf-8':\n      case undefined:\n        return utf8ToBytes(string).length\n      case 'ucs2':\n      case 'ucs-2':\n      case 'utf16le':\n      case 'utf-16le':\n        return len * 2\n      case 'hex':\n        return len >>> 1\n      case 'base64':\n        return base64ToBytes(string).length\n      default:\n        if (loweredCase) return utf8ToBytes(string).length // assume utf8\n        encoding = ('' + encoding).toLowerCase()\n        loweredCase = true\n    }\n  }\n}\nBuffer.byteLength = byteLength\n\nfunction slowToString (encoding, start, end) {\n  var loweredCase = false\n\n  // No need to verify that \"this.length <= MAX_UINT32\" since it's a read-only\n  // property of a typed array.\n\n  // This behaves neither like String nor Uint8Array in that we set start/end\n  // to their upper/lower bounds if the value passed is out of range.\n  // undefined is handled specially as per ECMA-262 6th Edition,\n  // Section 13.3.3.7 Runtime Semantics: KeyedBindingInitialization.\n  if (start === undefined || start < 0) {\n    start = 0\n  }\n  // Return early if start > this.length. Done here to prevent potential uint32\n  // coercion fail below.\n  if (start > this.length) {\n    return ''\n  }\n\n  if (end === undefined || end > this.length) {\n    end = this.length\n  }\n\n  if (end <= 0) {\n    return ''\n  }\n\n  // Force coersion to uint32. This will also coerce falsey/NaN values to 0.\n  end >>>= 0\n  start >>>= 0\n\n  if (end <= start) {\n    return ''\n  }\n\n  if (!encoding) encoding = 'utf8'\n\n  while (true) {\n    switch (encoding) {\n      case 'hex':\n        return hexSlice(this, start, end)\n\n      case 'utf8':\n      case 'utf-8':\n        return utf8Slice(this, start, end)\n\n      case 'ascii':\n        return asciiSlice(this, start, end)\n\n      case 'latin1':\n      case 'binary':\n        return latin1Slice(this, start, end)\n\n      case 'base64':\n        return base64Slice(this, start, end)\n\n      case 'ucs2':\n      case 'ucs-2':\n      case 'utf16le':\n      case 'utf-16le':\n        return utf16leSlice(this, start, end)\n\n      default:\n        if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)\n        encoding = (encoding + '').toLowerCase()\n        loweredCase = true\n    }\n  }\n}\n\n// The property is used by `Buffer.isBuffer` and `is-buffer` (in Safari 5-7) to detect\n// Buffer instances.\nBuffer.prototype._isBuffer = true\n\nfunction swap (b, n, m) {\n  var i = b[n]\n  b[n] = b[m]\n  b[m] = i\n}\n\nBuffer.prototype.swap16 = function swap16 () {\n  var len = this.length\n  if (len % 2 !== 0) {\n    throw new RangeError('Buffer size must be a multiple of 16-bits')\n  }\n  for (var i = 0; i < len; i += 2) {\n    swap(this, i, i + 1)\n  }\n  return this\n}\n\nBuffer.prototype.swap32 = function swap32 () {\n  var len = this.length\n  if (len % 4 !== 0) {\n    throw new RangeError('Buffer size must be a multiple of 32-bits')\n  }\n  for (var i = 0; i < len; i += 4) {\n    swap(this, i, i + 3)\n    swap(this, i + 1, i + 2)\n  }\n  return this\n}\n\nBuffer.prototype.swap64 = function swap64 () {\n  var len = this.length\n  if (len % 8 !== 0) {\n    throw new RangeError('Buffer size must be a multiple of 64-bits')\n  }\n  for (var i = 0; i < len; i += 8) {\n    swap(this, i, i + 7)\n    swap(this, i + 1, i + 6)\n    swap(this, i + 2, i + 5)\n    swap(this, i + 3, i + 4)\n  }\n  return this\n}\n\nBuffer.prototype.toString = function toString () {\n  var length = this.length | 0\n  if (length === 0) return ''\n  if (arguments.length === 0) return utf8Slice(this, 0, length)\n  return slowToString.apply(this, arguments)\n}\n\nBuffer.prototype.equals = function equals (b) {\n  if (!Buffer.isBuffer(b)) throw new TypeError('Argument must be a Buffer')\n  if (this === b) return true\n  return Buffer.compare(this, b) === 0\n}\n\nBuffer.prototype.inspect = function inspect () {\n  var str = ''\n  var max = exports.INSPECT_MAX_BYTES\n  if (this.length > 0) {\n    str = this.toString('hex', 0, max).match(/.{2}/g).join(' ')\n    if (this.length > max) str += ' ... '\n  }\n  return '<Buffer ' + str + '>'\n}\n\nBuffer.prototype.compare = function compare (target, start, end, thisStart, thisEnd) {\n  if (!Buffer.isBuffer(target)) {\n    throw new TypeError('Argument must be a Buffer')\n  }\n\n  if (start === undefined) {\n    start = 0\n  }\n  if (end === undefined) {\n    end = target ? target.length : 0\n  }\n  if (thisStart === undefined) {\n    thisStart = 0\n  }\n  if (thisEnd === undefined) {\n    thisEnd = this.length\n  }\n\n  if (start < 0 || end > target.length || thisStart < 0 || thisEnd > this.length) {\n    throw new RangeError('out of range index')\n  }\n\n  if (thisStart >= thisEnd && start >= end) {\n    return 0\n  }\n  if (thisStart >= thisEnd) {\n    return -1\n  }\n  if (start >= end) {\n    return 1\n  }\n\n  start >>>= 0\n  end >>>= 0\n  thisStart >>>= 0\n  thisEnd >>>= 0\n\n  if (this === target) return 0\n\n  var x = thisEnd - thisStart\n  var y = end - start\n  var len = Math.min(x, y)\n\n  var thisCopy = this.slice(thisStart, thisEnd)\n  var targetCopy = target.slice(start, end)\n\n  for (var i = 0; i < len; ++i) {\n    if (thisCopy[i] !== targetCopy[i]) {\n      x = thisCopy[i]\n      y = targetCopy[i]\n      break\n    }\n  }\n\n  if (x < y) return -1\n  if (y < x) return 1\n  return 0\n}\n\n// Finds either the first index of `val` in `buffer` at offset >= `byteOffset`,\n// OR the last index of `val` in `buffer` at offset <= `byteOffset`.\n//\n// Arguments:\n// - buffer - a Buffer to search\n// - val - a string, Buffer, or number\n// - byteOffset - an index into `buffer`; will be clamped to an int32\n// - encoding - an optional encoding, relevant is val is a string\n// - dir - true for indexOf, false for lastIndexOf\nfunction bidirectionalIndexOf (buffer, val, byteOffset, encoding, dir) {\n  // Empty buffer means no match\n  if (buffer.length === 0) return -1\n\n  // Normalize byteOffset\n  if (typeof byteOffset === 'string') {\n    encoding = byteOffset\n    byteOffset = 0\n  } else if (byteOffset > 0x7fffffff) {\n    byteOffset = 0x7fffffff\n  } else if (byteOffset < -0x80000000) {\n    byteOffset = -0x80000000\n  }\n  byteOffset = +byteOffset  // Coerce to Number.\n  if (isNaN(byteOffset)) {\n    // byteOffset: it it's undefined, null, NaN, \"foo\", etc, search whole buffer\n    byteOffset = dir ? 0 : (buffer.length - 1)\n  }\n\n  // Normalize byteOffset: negative offsets start from the end of the buffer\n  if (byteOffset < 0) byteOffset = buffer.length + byteOffset\n  if (byteOffset >= buffer.length) {\n    if (dir) return -1\n    else byteOffset = buffer.length - 1\n  } else if (byteOffset < 0) {\n    if (dir) byteOffset = 0\n    else return -1\n  }\n\n  // Normalize val\n  if (typeof val === 'string') {\n    val = Buffer.from(val, encoding)\n  }\n\n  // Finally, search either indexOf (if dir is true) or lastIndexOf\n  if (Buffer.isBuffer(val)) {\n    // Special case: looking for empty string/buffer always fails\n    if (val.length === 0) {\n      return -1\n    }\n    return arrayIndexOf(buffer, val, byteOffset, encoding, dir)\n  } else if (typeof val === 'number') {\n    val = val & 0xFF // Search for a byte value [0-255]\n    if (Buffer.TYPED_ARRAY_SUPPORT &&\n        typeof Uint8Array.prototype.indexOf === 'function') {\n      if (dir) {\n        return Uint8Array.prototype.indexOf.call(buffer, val, byteOffset)\n      } else {\n        return Uint8Array.prototype.lastIndexOf.call(buffer, val, byteOffset)\n      }\n    }\n    return arrayIndexOf(buffer, [ val ], byteOffset, encoding, dir)\n  }\n\n  throw new TypeError('val must be string, number or Buffer')\n}\n\nfunction arrayIndexOf (arr, val, byteOffset, encoding, dir) {\n  var indexSize = 1\n  var arrLength = arr.length\n  var valLength = val.length\n\n  if (encoding !== undefined) {\n    encoding = String(encoding).toLowerCase()\n    if (encoding === 'ucs2' || encoding === 'ucs-2' ||\n        encoding === 'utf16le' || encoding === 'utf-16le') {\n      if (arr.length < 2 || val.length < 2) {\n        return -1\n      }\n      indexSize = 2\n      arrLength /= 2\n      valLength /= 2\n      byteOffset /= 2\n    }\n  }\n\n  function read (buf, i) {\n    if (indexSize === 1) {\n      return buf[i]\n    } else {\n      return buf.readUInt16BE(i * indexSize)\n    }\n  }\n\n  var i\n  if (dir) {\n    var foundIndex = -1\n    for (i = byteOffset; i < arrLength; i++) {\n      if (read(arr, i) === read(val, foundIndex === -1 ? 0 : i - foundIndex)) {\n        if (foundIndex === -1) foundIndex = i\n        if (i - foundIndex + 1 === valLength) return foundIndex * indexSize\n      } else {\n        if (foundIndex !== -1) i -= i - foundIndex\n        foundIndex = -1\n      }\n    }\n  } else {\n    if (byteOffset + valLength > arrLength) byteOffset = arrLength - valLength\n    for (i = byteOffset; i >= 0; i--) {\n      var found = true\n      for (var j = 0; j < valLength; j++) {\n        if (read(arr, i + j) !== read(val, j)) {\n          found = false\n          break\n        }\n      }\n      if (found) return i\n    }\n  }\n\n  return -1\n}\n\nBuffer.prototype.includes = function includes (val, byteOffset, encoding) {\n  return this.indexOf(val, byteOffset, encoding) !== -1\n}\n\nBuffer.prototype.indexOf = function indexOf (val, byteOffset, encoding) {\n  return bidirectionalIndexOf(this, val, byteOffset, encoding, true)\n}\n\nBuffer.prototype.lastIndexOf = function lastIndexOf (val, byteOffset, encoding) {\n  return bidirectionalIndexOf(this, val, byteOffset, encoding, false)\n}\n\nfunction hexWrite (buf, string, offset, length) {\n  offset = Number(offset) || 0\n  var remaining = buf.length - offset\n  if (!length) {\n    length = remaining\n  } else {\n    length = Number(length)\n    if (length > remaining) {\n      length = remaining\n    }\n  }\n\n  // must be an even number of digits\n  var strLen = string.length\n  if (strLen % 2 !== 0) throw new TypeError('Invalid hex string')\n\n  if (length > strLen / 2) {\n    length = strLen / 2\n  }\n  for (var i = 0; i < length; ++i) {\n    var parsed = parseInt(string.substr(i * 2, 2), 16)\n    if (isNaN(parsed)) return i\n    buf[offset + i] = parsed\n  }\n  return i\n}\n\nfunction utf8Write (buf, string, offset, length) {\n  return blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length)\n}\n\nfunction asciiWrite (buf, string, offset, length) {\n  return blitBuffer(asciiToBytes(string), buf, offset, length)\n}\n\nfunction latin1Write (buf, string, offset, length) {\n  return asciiWrite(buf, string, offset, length)\n}\n\nfunction base64Write (buf, string, offset, length) {\n  return blitBuffer(base64ToBytes(string), buf, offset, length)\n}\n\nfunction ucs2Write (buf, string, offset, length) {\n  return blitBuffer(utf16leToBytes(string, buf.length - offset), buf, offset, length)\n}\n\nBuffer.prototype.write = function write (string, offset, length, encoding) {\n  // Buffer#write(string)\n  if (offset === undefined) {\n    encoding = 'utf8'\n    length = this.length\n    offset = 0\n  // Buffer#write(string, encoding)\n  } else if (length === undefined && typeof offset === 'string') {\n    encoding = offset\n    length = this.length\n    offset = 0\n  // Buffer#write(string, offset[, length][, encoding])\n  } else if (isFinite(offset)) {\n    offset = offset | 0\n    if (isFinite(length)) {\n      length = length | 0\n      if (encoding === undefined) encoding = 'utf8'\n    } else {\n      encoding = length\n      length = undefined\n    }\n  // legacy write(string, encoding, offset, length) - remove in v0.13\n  } else {\n    throw new Error(\n      'Buffer.write(string, encoding, offset[, length]) is no longer supported'\n    )\n  }\n\n  var remaining = this.length - offset\n  if (length === undefined || length > remaining) length = remaining\n\n  if ((string.length > 0 && (length < 0 || offset < 0)) || offset > this.length) {\n    throw new RangeError('Attempt to write outside buffer bounds')\n  }\n\n  if (!encoding) encoding = 'utf8'\n\n  var loweredCase = false\n  for (;;) {\n    switch (encoding) {\n      case 'hex':\n        return hexWrite(this, string, offset, length)\n\n      case 'utf8':\n      case 'utf-8':\n        return utf8Write(this, string, offset, length)\n\n      case 'ascii':\n        return asciiWrite(this, string, offset, length)\n\n      case 'latin1':\n      case 'binary':\n        return latin1Write(this, string, offset, length)\n\n      case 'base64':\n        // Warning: maxLength not taken into account in base64Write\n        return base64Write(this, string, offset, length)\n\n      case 'ucs2':\n      case 'ucs-2':\n      case 'utf16le':\n      case 'utf-16le':\n        return ucs2Write(this, string, offset, length)\n\n      default:\n        if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)\n        encoding = ('' + encoding).toLowerCase()\n        loweredCase = true\n    }\n  }\n}\n\nBuffer.prototype.toJSON = function toJSON () {\n  return {\n    type: 'Buffer',\n    data: Array.prototype.slice.call(this._arr || this, 0)\n  }\n}\n\nfunction base64Slice (buf, start, end) {\n  if (start === 0 && end === buf.length) {\n    return base64.fromByteArray(buf)\n  } else {\n    return base64.fromByteArray(buf.slice(start, end))\n  }\n}\n\nfunction utf8Slice (buf, start, end) {\n  end = Math.min(buf.length, end)\n  var res = []\n\n  var i = start\n  while (i < end) {\n    var firstByte = buf[i]\n    var codePoint = null\n    var bytesPerSequence = (firstByte > 0xEF) ? 4\n      : (firstByte > 0xDF) ? 3\n      : (firstByte > 0xBF) ? 2\n      : 1\n\n    if (i + bytesPerSequence <= end) {\n      var secondByte, thirdByte, fourthByte, tempCodePoint\n\n      switch (bytesPerSequence) {\n        case 1:\n          if (firstByte < 0x80) {\n            codePoint = firstByte\n          }\n          break\n        case 2:\n          secondByte = buf[i + 1]\n          if ((secondByte & 0xC0) === 0x80) {\n            tempCodePoint = (firstByte & 0x1F) << 0x6 | (secondByte & 0x3F)\n            if (tempCodePoint > 0x7F) {\n              codePoint = tempCodePoint\n            }\n          }\n          break\n        case 3:\n          secondByte = buf[i + 1]\n          thirdByte = buf[i + 2]\n          if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80) {\n            tempCodePoint = (firstByte & 0xF) << 0xC | (secondByte & 0x3F) << 0x6 | (thirdByte & 0x3F)\n            if (tempCodePoint > 0x7FF && (tempCodePoint < 0xD800 || tempCodePoint > 0xDFFF)) {\n              codePoint = tempCodePoint\n            }\n          }\n          break\n        case 4:\n          secondByte = buf[i + 1]\n          thirdByte = buf[i + 2]\n          fourthByte = buf[i + 3]\n          if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80 && (fourthByte & 0xC0) === 0x80) {\n            tempCodePoint = (firstByte & 0xF) << 0x12 | (secondByte & 0x3F) << 0xC | (thirdByte & 0x3F) << 0x6 | (fourthByte & 0x3F)\n            if (tempCodePoint > 0xFFFF && tempCodePoint < 0x110000) {\n              codePoint = tempCodePoint\n            }\n          }\n      }\n    }\n\n    if (codePoint === null) {\n      // we did not generate a valid codePoint so insert a\n      // replacement char (U+FFFD) and advance only 1 byte\n      codePoint = 0xFFFD\n      bytesPerSequence = 1\n    } else if (codePoint > 0xFFFF) {\n      // encode to utf16 (surrogate pair dance)\n      codePoint -= 0x10000\n      res.push(codePoint >>> 10 & 0x3FF | 0xD800)\n      codePoint = 0xDC00 | codePoint & 0x3FF\n    }\n\n    res.push(codePoint)\n    i += bytesPerSequence\n  }\n\n  return decodeCodePointsArray(res)\n}\n\n// Based on http://stackoverflow.com/a/22747272/680742, the browser with\n// the lowest limit is Chrome, with 0x10000 args.\n// We go 1 magnitude less, for safety\nvar MAX_ARGUMENTS_LENGTH = 0x1000\n\nfunction decodeCodePointsArray (codePoints) {\n  var len = codePoints.length\n  if (len <= MAX_ARGUMENTS_LENGTH) {\n    return String.fromCharCode.apply(String, codePoints) // avoid extra slice()\n  }\n\n  // Decode in chunks to avoid \"call stack size exceeded\".\n  var res = ''\n  var i = 0\n  while (i < len) {\n    res += String.fromCharCode.apply(\n      String,\n      codePoints.slice(i, i += MAX_ARGUMENTS_LENGTH)\n    )\n  }\n  return res\n}\n\nfunction asciiSlice (buf, start, end) {\n  var ret = ''\n  end = Math.min(buf.length, end)\n\n  for (var i = start; i < end; ++i) {\n    ret += String.fromCharCode(buf[i] & 0x7F)\n  }\n  return ret\n}\n\nfunction latin1Slice (buf, start, end) {\n  var ret = ''\n  end = Math.min(buf.length, end)\n\n  for (var i = start; i < end; ++i) {\n    ret += String.fromCharCode(buf[i])\n  }\n  return ret\n}\n\nfunction hexSlice (buf, start, end) {\n  var len = buf.length\n\n  if (!start || start < 0) start = 0\n  if (!end || end < 0 || end > len) end = len\n\n  var out = ''\n  for (var i = start; i < end; ++i) {\n    out += toHex(buf[i])\n  }\n  return out\n}\n\nfunction utf16leSlice (buf, start, end) {\n  var bytes = buf.slice(start, end)\n  var res = ''\n  for (var i = 0; i < bytes.length; i += 2) {\n    res += String.fromCharCode(bytes[i] + bytes[i + 1] * 256)\n  }\n  return res\n}\n\nBuffer.prototype.slice = function slice (start, end) {\n  var len = this.length\n  start = ~~start\n  end = end === undefined ? len : ~~end\n\n  if (start < 0) {\n    start += len\n    if (start < 0) start = 0\n  } else if (start > len) {\n    start = len\n  }\n\n  if (end < 0) {\n    end += len\n    if (end < 0) end = 0\n  } else if (end > len) {\n    end = len\n  }\n\n  if (end < start) end = start\n\n  var newBuf\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    newBuf = this.subarray(start, end)\n    newBuf.__proto__ = Buffer.prototype\n  } else {\n    var sliceLen = end - start\n    newBuf = new Buffer(sliceLen, undefined)\n    for (var i = 0; i < sliceLen; ++i) {\n      newBuf[i] = this[i + start]\n    }\n  }\n\n  return newBuf\n}\n\n/*\n * Need to make sure that buffer isn't trying to write out of bounds.\n */\nfunction checkOffset (offset, ext, length) {\n  if ((offset % 1) !== 0 || offset < 0) throw new RangeError('offset is not uint')\n  if (offset + ext > length) throw new RangeError('Trying to access beyond buffer length')\n}\n\nBuffer.prototype.readUIntLE = function readUIntLE (offset, byteLength, noAssert) {\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) checkOffset(offset, byteLength, this.length)\n\n  var val = this[offset]\n  var mul = 1\n  var i = 0\n  while (++i < byteLength && (mul *= 0x100)) {\n    val += this[offset + i] * mul\n  }\n\n  return val\n}\n\nBuffer.prototype.readUIntBE = function readUIntBE (offset, byteLength, noAssert) {\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) {\n    checkOffset(offset, byteLength, this.length)\n  }\n\n  var val = this[offset + --byteLength]\n  var mul = 1\n  while (byteLength > 0 && (mul *= 0x100)) {\n    val += this[offset + --byteLength] * mul\n  }\n\n  return val\n}\n\nBuffer.prototype.readUInt8 = function readUInt8 (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 1, this.length)\n  return this[offset]\n}\n\nBuffer.prototype.readUInt16LE = function readUInt16LE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 2, this.length)\n  return this[offset] | (this[offset + 1] << 8)\n}\n\nBuffer.prototype.readUInt16BE = function readUInt16BE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 2, this.length)\n  return (this[offset] << 8) | this[offset + 1]\n}\n\nBuffer.prototype.readUInt32LE = function readUInt32LE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n\n  return ((this[offset]) |\n      (this[offset + 1] << 8) |\n      (this[offset + 2] << 16)) +\n      (this[offset + 3] * 0x1000000)\n}\n\nBuffer.prototype.readUInt32BE = function readUInt32BE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n\n  return (this[offset] * 0x1000000) +\n    ((this[offset + 1] << 16) |\n    (this[offset + 2] << 8) |\n    this[offset + 3])\n}\n\nBuffer.prototype.readIntLE = function readIntLE (offset, byteLength, noAssert) {\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) checkOffset(offset, byteLength, this.length)\n\n  var val = this[offset]\n  var mul = 1\n  var i = 0\n  while (++i < byteLength && (mul *= 0x100)) {\n    val += this[offset + i] * mul\n  }\n  mul *= 0x80\n\n  if (val >= mul) val -= Math.pow(2, 8 * byteLength)\n\n  return val\n}\n\nBuffer.prototype.readIntBE = function readIntBE (offset, byteLength, noAssert) {\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) checkOffset(offset, byteLength, this.length)\n\n  var i = byteLength\n  var mul = 1\n  var val = this[offset + --i]\n  while (i > 0 && (mul *= 0x100)) {\n    val += this[offset + --i] * mul\n  }\n  mul *= 0x80\n\n  if (val >= mul) val -= Math.pow(2, 8 * byteLength)\n\n  return val\n}\n\nBuffer.prototype.readInt8 = function readInt8 (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 1, this.length)\n  if (!(this[offset] & 0x80)) return (this[offset])\n  return ((0xff - this[offset] + 1) * -1)\n}\n\nBuffer.prototype.readInt16LE = function readInt16LE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 2, this.length)\n  var val = this[offset] | (this[offset + 1] << 8)\n  return (val & 0x8000) ? val | 0xFFFF0000 : val\n}\n\nBuffer.prototype.readInt16BE = function readInt16BE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 2, this.length)\n  var val = this[offset + 1] | (this[offset] << 8)\n  return (val & 0x8000) ? val | 0xFFFF0000 : val\n}\n\nBuffer.prototype.readInt32LE = function readInt32LE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n\n  return (this[offset]) |\n    (this[offset + 1] << 8) |\n    (this[offset + 2] << 16) |\n    (this[offset + 3] << 24)\n}\n\nBuffer.prototype.readInt32BE = function readInt32BE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n\n  return (this[offset] << 24) |\n    (this[offset + 1] << 16) |\n    (this[offset + 2] << 8) |\n    (this[offset + 3])\n}\n\nBuffer.prototype.readFloatLE = function readFloatLE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n  return ieee754.read(this, offset, true, 23, 4)\n}\n\nBuffer.prototype.readFloatBE = function readFloatBE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 4, this.length)\n  return ieee754.read(this, offset, false, 23, 4)\n}\n\nBuffer.prototype.readDoubleLE = function readDoubleLE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 8, this.length)\n  return ieee754.read(this, offset, true, 52, 8)\n}\n\nBuffer.prototype.readDoubleBE = function readDoubleBE (offset, noAssert) {\n  if (!noAssert) checkOffset(offset, 8, this.length)\n  return ieee754.read(this, offset, false, 52, 8)\n}\n\nfunction checkInt (buf, value, offset, ext, max, min) {\n  if (!Buffer.isBuffer(buf)) throw new TypeError('\"buffer\" argument must be a Buffer instance')\n  if (value > max || value < min) throw new RangeError('\"value\" argument is out of bounds')\n  if (offset + ext > buf.length) throw new RangeError('Index out of range')\n}\n\nBuffer.prototype.writeUIntLE = function writeUIntLE (value, offset, byteLength, noAssert) {\n  value = +value\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) {\n    var maxBytes = Math.pow(2, 8 * byteLength) - 1\n    checkInt(this, value, offset, byteLength, maxBytes, 0)\n  }\n\n  var mul = 1\n  var i = 0\n  this[offset] = value & 0xFF\n  while (++i < byteLength && (mul *= 0x100)) {\n    this[offset + i] = (value / mul) & 0xFF\n  }\n\n  return offset + byteLength\n}\n\nBuffer.prototype.writeUIntBE = function writeUIntBE (value, offset, byteLength, noAssert) {\n  value = +value\n  offset = offset | 0\n  byteLength = byteLength | 0\n  if (!noAssert) {\n    var maxBytes = Math.pow(2, 8 * byteLength) - 1\n    checkInt(this, value, offset, byteLength, maxBytes, 0)\n  }\n\n  var i = byteLength - 1\n  var mul = 1\n  this[offset + i] = value & 0xFF\n  while (--i >= 0 && (mul *= 0x100)) {\n    this[offset + i] = (value / mul) & 0xFF\n  }\n\n  return offset + byteLength\n}\n\nBuffer.prototype.writeUInt8 = function writeUInt8 (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 1, 0xff, 0)\n  if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value)\n  this[offset] = (value & 0xff)\n  return offset + 1\n}\n\nfunction objectWriteUInt16 (buf, value, offset, littleEndian) {\n  if (value < 0) value = 0xffff + value + 1\n  for (var i = 0, j = Math.min(buf.length - offset, 2); i < j; ++i) {\n    buf[offset + i] = (value & (0xff << (8 * (littleEndian ? i : 1 - i)))) >>>\n      (littleEndian ? i : 1 - i) * 8\n  }\n}\n\nBuffer.prototype.writeUInt16LE = function writeUInt16LE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value & 0xff)\n    this[offset + 1] = (value >>> 8)\n  } else {\n    objectWriteUInt16(this, value, offset, true)\n  }\n  return offset + 2\n}\n\nBuffer.prototype.writeUInt16BE = function writeUInt16BE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value >>> 8)\n    this[offset + 1] = (value & 0xff)\n  } else {\n    objectWriteUInt16(this, value, offset, false)\n  }\n  return offset + 2\n}\n\nfunction objectWriteUInt32 (buf, value, offset, littleEndian) {\n  if (value < 0) value = 0xffffffff + value + 1\n  for (var i = 0, j = Math.min(buf.length - offset, 4); i < j; ++i) {\n    buf[offset + i] = (value >>> (littleEndian ? i : 3 - i) * 8) & 0xff\n  }\n}\n\nBuffer.prototype.writeUInt32LE = function writeUInt32LE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset + 3] = (value >>> 24)\n    this[offset + 2] = (value >>> 16)\n    this[offset + 1] = (value >>> 8)\n    this[offset] = (value & 0xff)\n  } else {\n    objectWriteUInt32(this, value, offset, true)\n  }\n  return offset + 4\n}\n\nBuffer.prototype.writeUInt32BE = function writeUInt32BE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value >>> 24)\n    this[offset + 1] = (value >>> 16)\n    this[offset + 2] = (value >>> 8)\n    this[offset + 3] = (value & 0xff)\n  } else {\n    objectWriteUInt32(this, value, offset, false)\n  }\n  return offset + 4\n}\n\nBuffer.prototype.writeIntLE = function writeIntLE (value, offset, byteLength, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) {\n    var limit = Math.pow(2, 8 * byteLength - 1)\n\n    checkInt(this, value, offset, byteLength, limit - 1, -limit)\n  }\n\n  var i = 0\n  var mul = 1\n  var sub = 0\n  this[offset] = value & 0xFF\n  while (++i < byteLength && (mul *= 0x100)) {\n    if (value < 0 && sub === 0 && this[offset + i - 1] !== 0) {\n      sub = 1\n    }\n    this[offset + i] = ((value / mul) >> 0) - sub & 0xFF\n  }\n\n  return offset + byteLength\n}\n\nBuffer.prototype.writeIntBE = function writeIntBE (value, offset, byteLength, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) {\n    var limit = Math.pow(2, 8 * byteLength - 1)\n\n    checkInt(this, value, offset, byteLength, limit - 1, -limit)\n  }\n\n  var i = byteLength - 1\n  var mul = 1\n  var sub = 0\n  this[offset + i] = value & 0xFF\n  while (--i >= 0 && (mul *= 0x100)) {\n    if (value < 0 && sub === 0 && this[offset + i + 1] !== 0) {\n      sub = 1\n    }\n    this[offset + i] = ((value / mul) >> 0) - sub & 0xFF\n  }\n\n  return offset + byteLength\n}\n\nBuffer.prototype.writeInt8 = function writeInt8 (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 1, 0x7f, -0x80)\n  if (!Buffer.TYPED_ARRAY_SUPPORT) value = Math.floor(value)\n  if (value < 0) value = 0xff + value + 1\n  this[offset] = (value & 0xff)\n  return offset + 1\n}\n\nBuffer.prototype.writeInt16LE = function writeInt16LE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value & 0xff)\n    this[offset + 1] = (value >>> 8)\n  } else {\n    objectWriteUInt16(this, value, offset, true)\n  }\n  return offset + 2\n}\n\nBuffer.prototype.writeInt16BE = function writeInt16BE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value >>> 8)\n    this[offset + 1] = (value & 0xff)\n  } else {\n    objectWriteUInt16(this, value, offset, false)\n  }\n  return offset + 2\n}\n\nBuffer.prototype.writeInt32LE = function writeInt32LE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value & 0xff)\n    this[offset + 1] = (value >>> 8)\n    this[offset + 2] = (value >>> 16)\n    this[offset + 3] = (value >>> 24)\n  } else {\n    objectWriteUInt32(this, value, offset, true)\n  }\n  return offset + 4\n}\n\nBuffer.prototype.writeInt32BE = function writeInt32BE (value, offset, noAssert) {\n  value = +value\n  offset = offset | 0\n  if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)\n  if (value < 0) value = 0xffffffff + value + 1\n  if (Buffer.TYPED_ARRAY_SUPPORT) {\n    this[offset] = (value >>> 24)\n    this[offset + 1] = (value >>> 16)\n    this[offset + 2] = (value >>> 8)\n    this[offset + 3] = (value & 0xff)\n  } else {\n    objectWriteUInt32(this, value, offset, false)\n  }\n  return offset + 4\n}\n\nfunction checkIEEE754 (buf, value, offset, ext, max, min) {\n  if (offset + ext > buf.length) throw new RangeError('Index out of range')\n  if (offset < 0) throw new RangeError('Index out of range')\n}\n\nfunction writeFloat (buf, value, offset, littleEndian, noAssert) {\n  if (!noAssert) {\n    checkIEEE754(buf, value, offset, 4, 3.4028234663852886e+38, -3.4028234663852886e+38)\n  }\n  ieee754.write(buf, value, offset, littleEndian, 23, 4)\n  return offset + 4\n}\n\nBuffer.prototype.writeFloatLE = function writeFloatLE (value, offset, noAssert) {\n  return writeFloat(this, value, offset, true, noAssert)\n}\n\nBuffer.prototype.writeFloatBE = function writeFloatBE (value, offset, noAssert) {\n  return writeFloat(this, value, offset, false, noAssert)\n}\n\nfunction writeDouble (buf, value, offset, littleEndian, noAssert) {\n  if (!noAssert) {\n    checkIEEE754(buf, value, offset, 8, 1.7976931348623157E+308, -1.7976931348623157E+308)\n  }\n  ieee754.write(buf, value, offset, littleEndian, 52, 8)\n  return offset + 8\n}\n\nBuffer.prototype.writeDoubleLE = function writeDoubleLE (value, offset, noAssert) {\n  return writeDouble(this, value, offset, true, noAssert)\n}\n\nBuffer.prototype.writeDoubleBE = function writeDoubleBE (value, offset, noAssert) {\n  return writeDouble(this, value, offset, false, noAssert)\n}\n\n// copy(targetBuffer, targetStart=0, sourceStart=0, sourceEnd=buffer.length)\nBuffer.prototype.copy = function copy (target, targetStart, start, end) {\n  if (!start) start = 0\n  if (!end && end !== 0) end = this.length\n  if (targetStart >= target.length) targetStart = target.length\n  if (!targetStart) targetStart = 0\n  if (end > 0 && end < start) end = start\n\n  // Copy 0 bytes; we're done\n  if (end === start) return 0\n  if (target.length === 0 || this.length === 0) return 0\n\n  // Fatal error conditions\n  if (targetStart < 0) {\n    throw new RangeError('targetStart out of bounds')\n  }\n  if (start < 0 || start >= this.length) throw new RangeError('sourceStart out of bounds')\n  if (end < 0) throw new RangeError('sourceEnd out of bounds')\n\n  // Are we oob?\n  if (end > this.length) end = this.length\n  if (target.length - targetStart < end - start) {\n    end = target.length - targetStart + start\n  }\n\n  var len = end - start\n  var i\n\n  if (this === target && start < targetStart && targetStart < end) {\n    // descending copy from end\n    for (i = len - 1; i >= 0; --i) {\n      target[i + targetStart] = this[i + start]\n    }\n  } else if (len < 1000 || !Buffer.TYPED_ARRAY_SUPPORT) {\n    // ascending copy from start\n    for (i = 0; i < len; ++i) {\n      target[i + targetStart] = this[i + start]\n    }\n  } else {\n    Uint8Array.prototype.set.call(\n      target,\n      this.subarray(start, start + len),\n      targetStart\n    )\n  }\n\n  return len\n}\n\n// Usage:\n//    buffer.fill(number[, offset[, end]])\n//    buffer.fill(buffer[, offset[, end]])\n//    buffer.fill(string[, offset[, end]][, encoding])\nBuffer.prototype.fill = function fill (val, start, end, encoding) {\n  // Handle string cases:\n  if (typeof val === 'string') {\n    if (typeof start === 'string') {\n      encoding = start\n      start = 0\n      end = this.length\n    } else if (typeof end === 'string') {\n      encoding = end\n      end = this.length\n    }\n    if (val.length === 1) {\n      var code = val.charCodeAt(0)\n      if (code < 256) {\n        val = code\n      }\n    }\n    if (encoding !== undefined && typeof encoding !== 'string') {\n      throw new TypeError('encoding must be a string')\n    }\n    if (typeof encoding === 'string' && !Buffer.isEncoding(encoding)) {\n      throw new TypeError('Unknown encoding: ' + encoding)\n    }\n  } else if (typeof val === 'number') {\n    val = val & 255\n  }\n\n  // Invalid ranges are not set to a default, so can range check early.\n  if (start < 0 || this.length < start || this.length < end) {\n    throw new RangeError('Out of range index')\n  }\n\n  if (end <= start) {\n    return this\n  }\n\n  start = start >>> 0\n  end = end === undefined ? this.length : end >>> 0\n\n  if (!val) val = 0\n\n  var i\n  if (typeof val === 'number') {\n    for (i = start; i < end; ++i) {\n      this[i] = val\n    }\n  } else {\n    var bytes = Buffer.isBuffer(val)\n      ? val\n      : utf8ToBytes(new Buffer(val, encoding).toString())\n    var len = bytes.length\n    for (i = 0; i < end - start; ++i) {\n      this[i + start] = bytes[i % len]\n    }\n  }\n\n  return this\n}\n\n// HELPER FUNCTIONS\n// ================\n\nvar INVALID_BASE64_RE = /[^+\\/0-9A-Za-z-_]/g\n\nfunction base64clean (str) {\n  // Node strips out invalid characters like \\n and \\t from the string, base64-js does not\n  str = stringtrim(str).replace(INVALID_BASE64_RE, '')\n  // Node converts strings with length < 2 to ''\n  if (str.length < 2) return ''\n  // Node allows for non-padded base64 strings (missing trailing ===), base64-js does not\n  while (str.length % 4 !== 0) {\n    str = str + '='\n  }\n  return str\n}\n\nfunction stringtrim (str) {\n  if (str.trim) return str.trim()\n  return str.replace(/^\\s+|\\s+$/g, '')\n}\n\nfunction toHex (n) {\n  if (n < 16) return '0' + n.toString(16)\n  return n.toString(16)\n}\n\nfunction utf8ToBytes (string, units) {\n  units = units || Infinity\n  var codePoint\n  var length = string.length\n  var leadSurrogate = null\n  var bytes = []\n\n  for (var i = 0; i < length; ++i) {\n    codePoint = string.charCodeAt(i)\n\n    // is surrogate component\n    if (codePoint > 0xD7FF && codePoint < 0xE000) {\n      // last char was a lead\n      if (!leadSurrogate) {\n        // no lead yet\n        if (codePoint > 0xDBFF) {\n          // unexpected trail\n          if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n          continue\n        } else if (i + 1 === length) {\n          // unpaired lead\n          if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n          continue\n        }\n\n        // valid lead\n        leadSurrogate = codePoint\n\n        continue\n      }\n\n      // 2 leads in a row\n      if (codePoint < 0xDC00) {\n        if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n        leadSurrogate = codePoint\n        continue\n      }\n\n      // valid surrogate pair\n      codePoint = (leadSurrogate - 0xD800 << 10 | codePoint - 0xDC00) + 0x10000\n    } else if (leadSurrogate) {\n      // valid bmp char, but last char was a lead\n      if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)\n    }\n\n    leadSurrogate = null\n\n    // encode utf8\n    if (codePoint < 0x80) {\n      if ((units -= 1) < 0) break\n      bytes.push(codePoint)\n    } else if (codePoint < 0x800) {\n      if ((units -= 2) < 0) break\n      bytes.push(\n        codePoint >> 0x6 | 0xC0,\n        codePoint & 0x3F | 0x80\n      )\n    } else if (codePoint < 0x10000) {\n      if ((units -= 3) < 0) break\n      bytes.push(\n        codePoint >> 0xC | 0xE0,\n        codePoint >> 0x6 & 0x3F | 0x80,\n        codePoint & 0x3F | 0x80\n      )\n    } else if (codePoint < 0x110000) {\n      if ((units -= 4) < 0) break\n      bytes.push(\n        codePoint >> 0x12 | 0xF0,\n        codePoint >> 0xC & 0x3F | 0x80,\n        codePoint >> 0x6 & 0x3F | 0x80,\n        codePoint & 0x3F | 0x80\n      )\n    } else {\n      throw new Error('Invalid code point')\n    }\n  }\n\n  return bytes\n}\n\nfunction asciiToBytes (str) {\n  var byteArray = []\n  for (var i = 0; i < str.length; ++i) {\n    // Node's code seems to be doing this and not & 0x7F..\n    byteArray.push(str.charCodeAt(i) & 0xFF)\n  }\n  return byteArray\n}\n\nfunction utf16leToBytes (str, units) {\n  var c, hi, lo\n  var byteArray = []\n  for (var i = 0; i < str.length; ++i) {\n    if ((units -= 2) < 0) break\n\n    c = str.charCodeAt(i)\n    hi = c >> 8\n    lo = c % 256\n    byteArray.push(lo)\n    byteArray.push(hi)\n  }\n\n  return byteArray\n}\n\nfunction base64ToBytes (str) {\n  return base64.toByteArray(base64clean(str))\n}\n\nfunction blitBuffer (src, dst, offset, length) {\n  for (var i = 0; i < length; ++i) {\n    if ((i + offset >= dst.length) || (i >= src.length)) break\n    dst[i + offset] = src[i]\n  }\n  return i\n}\n\nfunction isnan (val) {\n  return val !== val // eslint-disable-line no-self-compare\n}\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// /Users/dnnoyes/release-repo/~/buffer/index.js\n// module id = 1\n// module chunks = 0","var Buffer = require('buffer').Buffer;\nvar intSize = 4;\nvar zeroBuffer = new Buffer(intSize); zeroBuffer.fill(0);\nvar chrsz = 8;\n\nfunction toArray(buf, bigEndian) {\n  if ((buf.length % intSize) !== 0) {\n    var len = buf.length + (intSize - (buf.length % intSize));\n    buf = Buffer.concat([buf, zeroBuffer], len);\n  }\n\n  var arr = [];\n  var fn = bigEndian ? buf.readInt32BE : buf.readInt32LE;\n  for (var i = 0; i < buf.length; i += intSize) {\n    arr.push(fn.call(buf, i));\n  }\n  return arr;\n}\n\nfunction toBuffer(arr, size, bigEndian) {\n  var buf = new Buffer(size);\n  var fn = bigEndian ? buf.writeInt32BE : buf.writeInt32LE;\n  for (var i = 0; i < arr.length; i++) {\n    fn.call(buf, arr[i], i * 4, true);\n  }\n  return buf;\n}\n\nfunction hash(buf, fn, hashSize, bigEndian) {\n  if (!Buffer.isBuffer(buf)) buf = new Buffer(buf);\n  var arr = fn(toArray(buf, bigEndian), buf.length * chrsz);\n  return toBuffer(arr, hashSize, bigEndian);\n}\n\nmodule.exports = { hash: hash };\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/crypto-browserify/helpers.js\n// module id = 2\n// module chunks = 0","/*!\n * Copyright 2016 Amazon.com,\n * Inc. or its affiliates. All Rights Reserved.\n *\n * Licensed under the Amazon Software License (the \"License\").\n * You may not use this file except in compliance with the\n * License. A copy of the License is located at\n *\n *     http://aws.amazon.com/asl/\n *\n * or in the \"license\" file accompanying this file. This file is\n * distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR\n * CONDITIONS OF ANY KIND, express or implied. See the License\n * for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { Buffer } from 'buffer/';\nimport * as crypto from 'crypto-browserify';\nconst createHash = crypto.createHash;\nconst createHmac = crypto.createHmac;\nconst randomBytes = crypto.randomBytes;\n\nimport BigInteger from './BigInteger';\n\nconst initN = 'FFFFFFFFFFFFFFFFC90FDAA22168C234C4C6628B80DC1CD1'\n  + '29024E088A67CC74020BBEA63B139B22514A08798E3404DD'\n  + 'EF9519B3CD3A431B302B0A6DF25F14374FE1356D6D51C245'\n  + 'E485B576625E7EC6F44C42E9A637ED6B0BFF5CB6F406B7ED'\n  + 'EE386BFB5A899FA5AE9F24117C4B1FE649286651ECE45B3D'\n  + 'C2007CB8A163BF0598DA48361C55D39A69163FA8FD24CF5F'\n  + '83655D23DCA3AD961C62F356208552BB9ED529077096966D'\n  + '670C354E4ABC9804F1746C08CA18217C32905E462E36CE3B'\n  + 'E39E772C180E86039B2783A2EC07A28FB5C55DF06F4C52C9'\n  + 'DE2BCBF6955817183995497CEA956AE515D2261898FA0510'\n  + '15728E5A8AAAC42DAD33170D04507A33A85521ABDF1CBA64'\n  + 'ECFB850458DBEF0A8AEA71575D060C7DB3970F85A6E1E4C7'\n  + 'ABF5AE8CDB0933D71E8C94E04A25619DCEE3D2261AD2EE6B'\n  + 'F12FFA06D98A0864D87602733EC86A64521F2B18177B200C'\n  + 'BBE117577A615D6C770988C0BAD946E208E24FA074E5AB31'\n  + '43DB5BFCE0FD108E4B82D120A93AD2CAFFFFFFFFFFFFFFFF';\n\nconst newPasswordRequiredChallengeUserAttributePrefix = 'userAttributes.';\n\n/** @class */\nexport default class AuthenticationHelper {\n  /**\n   * Constructs a new AuthenticationHelper object\n   * @param {string} PoolName Cognito user pool name.\n   */\n  constructor(PoolName) {\n    this.N = new BigInteger(initN, 16);\n    this.g = new BigInteger('2', 16);\n    this.k = new BigInteger(this.hexHash(`00${this.N.toString(16)}0${this.g.toString(16)}`), 16);\n\n    this.smallAValue = this.generateRandomSmallA();\n    this.getLargeAValue(() => {});\n\n    this.infoBits = Buffer.from('Caldera Derived Key', 'utf8');\n\n    this.poolName = PoolName;\n  }\n\n  /**\n   * @returns {BigInteger} small A, a random number\n   */\n  getSmallAValue() {\n    return this.smallAValue;\n  }\n\n  /**\n   * @param {nodeCallback<BigInteger>} callback Called with (err, largeAValue)\n   * @returns {void}\n   */\n  getLargeAValue(callback) {\n    if (this.largeAValue) {\n      callback(null, this.largeAValue);\n    } else {\n      this.calculateA(this.smallAValue, (err, largeAValue) => {\n        if (err) {\n          callback(err, null);\n        }\n\n        this.largeAValue = largeAValue;\n        callback(null, this.largeAValue);\n      });\n    }\n  }\n\n  /**\n   * helper function to generate a random big integer\n   * @returns {BigInteger} a random value.\n   * @private\n   */\n  generateRandomSmallA() {\n    const hexRandom = randomBytes(128).toString('hex');\n\n    const randomBigInt = new BigInteger(hexRandom, 16);\n    const smallABigInt = randomBigInt.mod(this.N);\n\n    return smallABigInt;\n  }\n\n  /**\n   * helper function to generate a random string\n   * @returns {string} a random value.\n   * @private\n   */\n  generateRandomString() {\n    return randomBytes(40).toString('base64');\n  }\n\n  /**\n   * @returns {string} Generated random value included in password hash.\n   */\n  getRandomPassword() {\n    return this.randomPassword;\n  }\n\n  /**\n   * @returns {string} Generated random value included in devices hash.\n   */\n  getSaltDevices() {\n    return this.SaltToHashDevices;\n  }\n\n  /**\n   * @returns {string} Value used to verify devices.\n   */\n  getVerifierDevices() {\n    return this.verifierDevices;\n  }\n\n  /**\n   * Generate salts and compute verifier.\n   * @param {string} deviceGroupKey Devices to generate verifier for.\n   * @param {string} username User to generate verifier for.\n   * @param {nodeCallback<null>} callback Called with (err, null)\n   * @returns {void}\n   */\n  generateHashDevice(deviceGroupKey, username, callback) {\n    this.randomPassword = this.generateRandomString();\n    const combinedString = `${deviceGroupKey}${username}:${this.randomPassword}`;\n    const hashedString = this.hash(combinedString);\n\n    const hexRandom = randomBytes(16).toString('hex');\n    this.SaltToHashDevices = this.padHex(new BigInteger(hexRandom, 16));\n\n    this.g.modPow(\n      new BigInteger(this.hexHash(this.SaltToHashDevices + hashedString), 16),\n      this.N,\n      (err, verifierDevicesNotPadded) => {\n        if (err) {\n          callback(err, null);\n        }\n\n        this.verifierDevices = this.padHex(verifierDevicesNotPadded);\n        callback(null, null);\n      });\n  }\n\n  /**\n   * Calculate the client's public value A = g^a%N\n   * with the generated random number a\n   * @param {BigInteger} a Randomly generated small A.\n   * @param {nodeCallback<BigInteger>} callback Called with (err, largeAValue)\n   * @returns {void}\n   * @private\n   */\n  calculateA(a, callback) {\n    this.g.modPow(a, this.N, (err, A) => {\n      if (err) {\n        callback(err, null);\n      }\n\n      if (A.mod(this.N).equals(BigInteger.ZERO)) {\n        callback(new Error('Illegal paramater. A mod N cannot be 0.'), null);\n      }\n\n      callback(null, A);\n    });\n  }\n\n  /**\n   * Calculate the client's value U which is the hash of A and B\n   * @param {BigInteger} A Large A value.\n   * @param {BigInteger} B Server B value.\n   * @returns {BigInteger} Computed U value.\n   * @private\n   */\n  calculateU(A, B) {\n    this.UHexHash = this.hexHash(this.padHex(A) + this.padHex(B));\n    const finalU = new BigInteger(this.UHexHash, 16);\n\n    return finalU;\n  }\n\n  /**\n   * Calculate a hash from a bitArray\n   * @param {Buffer} buf Value to hash.\n   * @returns {String} Hex-encoded hash.\n   * @private\n   */\n  hash(buf) {\n    const hashHex = createHash('sha256').update(buf).digest('hex');\n    return (new Array(64 - hashHex.length).join('0')) + hashHex;\n  }\n\n  /**\n   * Calculate a hash from a hex string\n   * @param {String} hexStr Value to hash.\n   * @returns {String} Hex-encoded hash.\n   * @private\n   */\n  hexHash(hexStr) {\n    return this.hash(Buffer.from(hexStr, 'hex'));\n  }\n\n  /**\n   * Standard hkdf algorithm\n   * @param {Buffer} ikm Input key material.\n   * @param {Buffer} salt Salt value.\n   * @returns {Buffer} Strong key material.\n   * @private\n   */\n  computehkdf(ikm, salt) {\n    const prk = createHmac('sha256', salt).update(ikm).digest();\n    const infoBitsUpdate = Buffer.concat([\n      this.infoBits,\n      Buffer.from(String.fromCharCode(1), 'utf8'),\n    ]);\n    const hmac = createHmac('sha256', prk).update(infoBitsUpdate).digest();\n    return hmac.slice(0, 16);\n  }\n\n  /**\n   * Calculates the final hkdf based on computed S value, and computed U value and the key\n   * @param {String} username Username.\n   * @param {String} password Password.\n   * @param {BigInteger} serverBValue Server B value.\n   * @param {BigInteger} salt Generated salt.\n   * @param {nodeCallback<Buffer>} callback Called with (err, hkdfValue)\n   * @returns {void}\n   */\n  getPasswordAuthenticationKey(username, password, serverBValue, salt, callback) {\n    if (serverBValue.mod(this.N).equals(BigInteger.ZERO)) {\n      throw new Error('B cannot be zero.');\n    }\n\n    this.UValue = this.calculateU(this.largeAValue, serverBValue);\n\n    if (this.UValue.equals(BigInteger.ZERO)) {\n      throw new Error('U cannot be zero.');\n    }\n\n    const usernamePassword = `${this.poolName}${username}:${password}`;\n    const usernamePasswordHash = this.hash(usernamePassword);\n\n    const xValue = new BigInteger(this.hexHash(this.padHex(salt) + usernamePasswordHash), 16);\n    this.calculateS(xValue, serverBValue, (err, sValue) => {\n      if (err) {\n        callback(err, null);\n      }\n\n      const hkdf = this.computehkdf(\n        Buffer.from(this.padHex(sValue), 'hex'),\n        Buffer.from(this.padHex(this.UValue.toString(16)), 'hex'));\n\n      callback(null, hkdf);\n    });\n  }\n\n  /**\n   * Calculates the S value used in getPasswordAuthenticationKey\n   * @param {BigInteger} xValue Salted password hash value.\n   * @param {BigInteger} serverBValue Server B value.\n   * @param {nodeCallback<string>} callback Called on success or error.\n   * @returns {void}\n   */\n  calculateS(xValue, serverBValue, callback) {\n    this.g.modPow(xValue, this.N, (err, gModPowXN) => {\n      if (err) {\n        callback(err, null);\n      }\n\n      const intValue2 = serverBValue.subtract(this.k.multiply(gModPowXN));\n      intValue2.modPow(\n        this.smallAValue.add(this.UValue.multiply(xValue)),\n        this.N,\n        (err2, result) => {\n          if (err2) {\n            callback(err2, null);\n          }\n\n          callback(null, result.mod(this.N));\n        }\n      );\n    });\n  }\n\n  /**\n  * Return constant newPasswordRequiredChallengeUserAttributePrefix\n  * @return {newPasswordRequiredChallengeUserAttributePrefix} constant prefix value\n  */\n  getNewPasswordRequiredChallengeUserAttributePrefix() {\n    return newPasswordRequiredChallengeUserAttributePrefix;\n  }\n\n  /**\n   * Converts a BigInteger (or hex string) to hex format padded with zeroes for hashing\n   * @param {BigInteger|String} bigInt Number or string to pad.\n   * @returns {String} Padded hex string.\n   */\n  padHex(bigInt) {\n    let hashStr = bigInt.toString(16);\n    if (hashStr.length % 2 === 1) {\n      hashStr = `0${hashStr}`;\n    } else if ('89ABCDEFabcdef'.indexOf(hashStr[0]) !== -1) {\n      hashStr = `00${hashStr}`;\n    }\n    return hashStr;\n  }\n}\n\n\n\n// WEBPACK FOOTER //\n// ./src/AuthenticationHelper.js","// A small implementation of BigInteger based on http://www-cs-students.stanford.edu/~tjw/jsbn/\n//\n// All public methods have been removed except the following:\n//   new BigInteger(a, b) (only radix 2, 4, 8, 16 and 32 supported)\n//   toString (only radix 2, 4, 8, 16 and 32 supported)\n//   negate\n//   abs\n//   compareTo\n//   bitLength\n//   mod\n//   equals\n//   add\n//   subtract\n//   multiply\n//   divide\n//   modPow\n\nexport default BigInteger;\n\n/*\n * Copyright (c) 2003-2005  Tom Wu\n * All Rights Reserved.\n *\n * Permission is hereby granted, free of charge, to any person obtaining\n * a copy of this software and associated documentation files (the\n * \"Software\"), to deal in the Software without restriction, including\n * without limitation the rights to use, copy, modify, merge, publish,\n * distribute, sublicense, and/or sell copies of the Software, and to\n * permit persons to whom the Software is furnished to do so, subject to\n * the following conditions:\n *\n * The above copyright notice and this permission notice shall be\n * included in all copies or substantial portions of the Software.\n *\n * THE SOFTWARE IS PROVIDED \"AS-IS\" AND WITHOUT WARRANTY OF ANY KIND,\n * EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY\n * WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.\n *\n * IN NO EVENT SHALL TOM WU BE LIABLE FOR ANY SPECIAL, INCIDENTAL,\n * INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND, OR ANY DAMAGES WHATSOEVER\n * RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER OR NOT ADVISED OF\n * THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF LIABILITY, ARISING OUT\n * OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.\n *\n * In addition, the following condition applies:\n *\n * All redistributions must retain an intact copy of this copyright notice\n * and disclaimer.\n */\n\n// (public) Constructor\nfunction BigInteger(a, b) {\n  if (a != null) this.fromString(a, b);\n}\n\n// return new, unset BigInteger\nfunction nbi() {\n  return new BigInteger(null);\n}\n\n// Bits per digit\nvar dbits;\n\n// JavaScript engine analysis\nvar canary = 0xdeadbeefcafe;\nvar j_lm = ((canary&0xffffff)==0xefcafe);\n\n// am: Compute w_j += (x*this_i), propagate carries,\n// c is initial carry, returns final carry.\n// c < 3*dvalue, x < 2*dvalue, this_i < dvalue\n// We need to select the fastest one that works in this environment.\n\n// am1: use a single mult and divide to get the high bits,\n// max digit bits should be 26 because\n// max internal value = 2*dvalue^2-2*dvalue (< 2^53)\nfunction am1(i,x,w,j,c,n) {\n  while(--n >= 0) {\n    var v = x*this[i++]+w[j]+c;\n    c = Math.floor(v/0x4000000);\n    w[j++] = v&0x3ffffff;\n  }\n  return c;\n}\n// am2 avoids a big mult-and-extract completely.\n// Max digit bits should be <= 30 because we do bitwise ops\n// on values up to 2*hdvalue^2-hdvalue-1 (< 2^31)\nfunction am2(i,x,w,j,c,n) {\n  var xl = x&0x7fff, xh = x>>15;\n  while(--n >= 0) {\n    var l = this[i]&0x7fff;\n    var h = this[i++]>>15;\n    var m = xh*l+h*xl;\n    l = xl*l+((m&0x7fff)<<15)+w[j]+(c&0x3fffffff);\n    c = (l>>>30)+(m>>>15)+xh*h+(c>>>30);\n    w[j++] = l&0x3fffffff;\n  }\n  return c;\n}\n// Alternately, set max digit bits to 28 since some\n// browsers slow down when dealing with 32-bit numbers.\nfunction am3(i,x,w,j,c,n) {\n  var xl = x&0x3fff, xh = x>>14;\n  while(--n >= 0) {\n    var l = this[i]&0x3fff;\n    var h = this[i++]>>14;\n    var m = xh*l+h*xl;\n    l = xl*l+((m&0x3fff)<<14)+w[j]+c;\n    c = (l>>28)+(m>>14)+xh*h;\n    w[j++] = l&0xfffffff;\n  }\n  return c;\n}\nvar inBrowser = typeof navigator !== \"undefined\";\nif(inBrowser && j_lm && (navigator.appName == \"Microsoft Internet Explorer\")) {\n  BigInteger.prototype.am = am2;\n  dbits = 30;\n}\nelse if(inBrowser && j_lm && (navigator.appName != \"Netscape\")) {\n  BigInteger.prototype.am = am1;\n  dbits = 26;\n}\nelse { // Mozilla/Netscape seems to prefer am3\n  BigInteger.prototype.am = am3;\n  dbits = 28;\n}\n\nBigInteger.prototype.DB = dbits;\nBigInteger.prototype.DM = (1 << dbits) - 1;\nBigInteger.prototype.DV = 1 << dbits;\n\nvar BI_FP = 52;\nBigInteger.prototype.FV = Math.pow(2, BI_FP);\nBigInteger.prototype.F1 = BI_FP - dbits;\nBigInteger.prototype.F2 = 2 * dbits - BI_FP;\n\n// Digit conversions\nvar BI_RM = \"0123456789abcdefghijklmnopqrstuvwxyz\";\nvar BI_RC = new Array();\nvar rr, vv;\nrr = \"0\".charCodeAt(0);\nfor (vv = 0; vv <= 9; ++vv)\n  BI_RC[rr++] = vv;\nrr = \"a\".charCodeAt(0);\nfor (vv = 10; vv < 36; ++vv)\n  BI_RC[rr++] = vv;\nrr = \"A\".charCodeAt(0);\nfor (vv = 10; vv < 36; ++vv)\n  BI_RC[rr++] = vv;\n\nfunction int2char(n) {\n  return BI_RM.charAt(n);\n}\nfunction intAt(s, i) {\n  var c = BI_RC[s.charCodeAt(i)];\n  return c == null ? -1 : c;\n}\n\n// (protected) copy this to r\nfunction bnpCopyTo(r) {\n  for (var i = this.t - 1; i >= 0; --i)\n    r[i] = this[i];\n  r.t = this.t;\n  r.s = this.s;\n}\n\n// (protected) set from integer value x, -DV <= x < DV\nfunction bnpFromInt(x) {\n  this.t = 1;\n  this.s = x < 0 ? -1 : 0;\n  if (x > 0) this[0] = x;\n  else if (x < -1) this[0] = x + this.DV;\n  else this.t = 0;\n}\n\n// return bigint initialized to value\nfunction nbv(i) {\n  var r = nbi();\n\n  r.fromInt(i);\n\n  return r;\n}\n\n// (protected) set from string and radix\nfunction bnpFromString(s, b) {\n  var k;\n  if (b == 16) k = 4;\n  else if (b == 8) k = 3;\n  else if (b == 2) k = 1;\n  else if (b == 32) k = 5;\n  else if (b == 4) k = 2;\n  else throw new Error(\"Only radix 2, 4, 8, 16, 32 are supported\");\n  this.t = 0;\n  this.s = 0;\n  var i = s.length, mi = false, sh = 0;\n  while (--i >= 0) {\n    var x = intAt(s, i);\n    if (x < 0) {\n      if (s.charAt(i) == \"-\") mi = true;\n      continue;\n    }\n    mi = false;\n    if (sh == 0) this[this.t++] = x;\n    else if (sh + k > this.DB) {\n      this[this.t - 1] |= (x & (1 << this.DB - sh) - 1) << sh;\n      this[this.t++] = x >> this.DB - sh;\n    } else this[this.t - 1] |= x << sh;\n    sh += k;\n    if (sh >= this.DB) sh -= this.DB;\n  }\n  this.clamp();\n  if (mi) BigInteger.ZERO.subTo(this, this);\n}\n\n// (protected) clamp off excess high words\nfunction bnpClamp() {\n  var c = this.s & this.DM;\n  while (this.t > 0 && this[this.t - 1] == c)\n    --this.t;\n}\n\n// (public) return string representation in given radix\nfunction bnToString(b) {\n  if (this.s < 0) return \"-\" + this.negate().toString();\n  var k;\n  if (b == 16) k = 4;\n  else if (b == 8) k = 3;\n  else if (b == 2) k = 1;\n  else if (b == 32) k = 5;\n  else if (b == 4) k = 2;\n  else throw new Error(\"Only radix 2, 4, 8, 16, 32 are supported\");\n  var km = (1 << k) - 1, d, m = false, r = \"\", i = this.t;\n  var p = this.DB - i * this.DB % k;\n  if (i-- > 0) {\n    if (p < this.DB && (d = this[i] >> p) > 0) {\n      m = true;\n      r = int2char(d);\n    }\n    while (i >= 0) {\n      if (p < k) {\n        d = (this[i] & (1 << p) - 1) << k - p;\n        d |= this[--i] >> (p += this.DB - k);\n      } else {\n        d = this[i] >> (p -= k) & km;\n        if (p <= 0) {\n          p += this.DB;\n          --i;\n        }\n      }\n      if (d > 0) m = true;\n      if (m) r += int2char(d);\n    }\n  }\n  return m ? r : \"0\";\n}\n\n// (public) -this\nfunction bnNegate() {\n  var r = nbi();\n\n  BigInteger.ZERO.subTo(this, r);\n\n  return r;\n}\n\n// (public) |this|\nfunction bnAbs() {\n  return this.s < 0 ? this.negate() : this;\n}\n\n// (public) return + if this > a, - if this < a, 0 if equal\nfunction bnCompareTo(a) {\n  var r = this.s - a.s;\n  if (r != 0) return r;\n  var i = this.t;\n  r = i - a.t;\n  if (r != 0) return this.s < 0 ? -r : r;\n  while (--i >= 0)\n    if ((r = this[i] - a[i]) != 0) return r;\n  return 0;\n}\n\n// returns bit length of the integer x\nfunction nbits(x) {\n  var r = 1, t;\n  if ((t = x >>> 16) != 0) {\n    x = t;\n    r += 16;\n  }\n  if ((t = x >> 8) != 0) {\n    x = t;\n    r += 8;\n  }\n  if ((t = x >> 4) != 0) {\n    x = t;\n    r += 4;\n  }\n  if ((t = x >> 2) != 0) {\n    x = t;\n    r += 2;\n  }\n  if ((t = x >> 1) != 0) {\n    x = t;\n    r += 1;\n  }\n  return r;\n}\n\n// (public) return the number of bits in \"this\"\nfunction bnBitLength() {\n  if (this.t <= 0) return 0;\n  return this.DB * (this.t - 1) + nbits(this[this.t - 1] ^ this.s & this.DM);\n}\n\n// (protected) r = this << n*DB\nfunction bnpDLShiftTo(n, r) {\n  var i;\n  for (i = this.t - 1; i >= 0; --i)\n    r[i + n] = this[i];\n  for (i = n - 1; i >= 0; --i)\n    r[i] = 0;\n  r.t = this.t + n;\n  r.s = this.s;\n}\n\n// (protected) r = this >> n*DB\nfunction bnpDRShiftTo(n, r) {\n  for (var i = n; i < this.t; ++i)\n    r[i - n] = this[i];\n  r.t = Math.max(this.t - n, 0);\n  r.s = this.s;\n}\n\n// (protected) r = this << n\nfunction bnpLShiftTo(n, r) {\n  var bs = n % this.DB;\n  var cbs = this.DB - bs;\n  var bm = (1 << cbs) - 1;\n  var ds = Math.floor(n / this.DB), c = this.s << bs & this.DM, i;\n  for (i = this.t - 1; i >= 0; --i) {\n    r[i + ds + 1] = this[i] >> cbs | c;\n    c = (this[i] & bm) << bs;\n  }\n  for (i = ds - 1; i >= 0; --i)\n    r[i] = 0;\n  r[ds] = c;\n  r.t = this.t + ds + 1;\n  r.s = this.s;\n  r.clamp();\n}\n\n// (protected) r = this >> n\nfunction bnpRShiftTo(n, r) {\n  r.s = this.s;\n  var ds = Math.floor(n / this.DB);\n  if (ds >= this.t) {\n    r.t = 0;\n    return;\n  }\n  var bs = n % this.DB;\n  var cbs = this.DB - bs;\n  var bm = (1 << bs) - 1;\n  r[0] = this[ds] >> bs;\n  for (var i = ds + 1; i < this.t; ++i) {\n    r[i - ds - 1] |= (this[i] & bm) << cbs;\n    r[i - ds] = this[i] >> bs;\n  }\n  if (bs > 0) r[this.t - ds - 1] |= (this.s & bm) << cbs;\n  r.t = this.t - ds;\n  r.clamp();\n}\n\n// (protected) r = this - a\nfunction bnpSubTo(a, r) {\n  var i = 0, c = 0, m = Math.min(a.t, this.t);\n  while (i < m) {\n    c += this[i] - a[i];\n    r[i++] = c & this.DM;\n    c >>= this.DB;\n  }\n  if (a.t < this.t) {\n    c -= a.s;\n    while (i < this.t) {\n      c += this[i];\n      r[i++] = c & this.DM;\n      c >>= this.DB;\n    }\n    c += this.s;\n  } else {\n    c += this.s;\n    while (i < a.t) {\n      c -= a[i];\n      r[i++] = c & this.DM;\n      c >>= this.DB;\n    }\n    c -= a.s;\n  }\n  r.s = c < 0 ? -1 : 0;\n  if (c < -1) r[i++] = this.DV + c;\n  else if (c > 0) r[i++] = c;\n  r.t = i;\n  r.clamp();\n}\n\n// (protected) r = this * a, r != this,a (HAC 14.12)\n// \"this\" should be the larger one if appropriate.\nfunction bnpMultiplyTo(a, r) {\n  var x = this.abs(), y = a.abs();\n  var i = x.t;\n  r.t = i + y.t;\n  while (--i >= 0)\n    r[i] = 0;\n  for (i = 0; i < y.t; ++i)\n    r[i + x.t] = x.am(0, y[i], r, i, 0, x.t);\n  r.s = 0;\n  r.clamp();\n  if (this.s != a.s) BigInteger.ZERO.subTo(r, r);\n}\n\n// (protected) r = this^2, r != this (HAC 14.16)\nfunction bnpSquareTo(r) {\n  var x = this.abs();\n  var i = r.t = 2 * x.t;\n  while (--i >= 0)\n    r[i] = 0;\n  for (i = 0; i < x.t - 1; ++i) {\n    var c = x.am(i, x[i], r, 2 * i, 0, 1);\n    if (\n      (r[i + x.t] += x.am(i + 1, 2 * x[i], r, 2 * i + 1, c, x.t - i - 1)) >=\n        x.DV\n    ) {\n      r[i + x.t] -= x.DV;\n      r[i + x.t + 1] = 1;\n    }\n  }\n  if (r.t > 0) r[r.t - 1] += x.am(i, x[i], r, 2 * i, 0, 1);\n  r.s = 0;\n  r.clamp();\n}\n\n// (protected) divide this by m, quotient and remainder to q, r (HAC 14.20)\n// r != q, this != m.  q or r may be null.\nfunction bnpDivRemTo(m, q, r) {\n  var pm = m.abs();\n  if (pm.t <= 0) return;\n  var pt = this.abs();\n  if (pt.t < pm.t) {\n    if (q != null) q.fromInt(0);\n    if (r != null) this.copyTo(r);\n    return;\n  }\n  if (r == null) r = nbi();\n  var y = nbi(), ts = this.s, ms = m.s;\n  var nsh = this.DB - nbits(pm[pm.t - 1]);\n  // normalize modulus\n  if (nsh > 0) {\n    pm.lShiftTo(nsh, y);\n    pt.lShiftTo(nsh, r);\n  } else {\n    pm.copyTo(y);\n    pt.copyTo(r);\n  }\n  var ys = y.t;\n  var y0 = y[ys - 1];\n  if (y0 == 0) return;\n  var yt = y0 * (1 << this.F1) + (ys > 1 ? y[ys - 2] >> this.F2 : 0);\n  var d1 = this.FV / yt, d2 = (1 << this.F1) / yt, e = 1 << this.F2;\n  var i = r.t, j = i - ys, t = q == null ? nbi() : q;\n  y.dlShiftTo(j, t);\n  if (r.compareTo(t) >= 0) {\n    r[r.t++] = 1;\n    r.subTo(t, r);\n  }\n  BigInteger.ONE.dlShiftTo(ys, t);\n  t.subTo(y, y);\n  // \"negative\" y so we can replace sub with am later\n  while (y.t < ys)\n    y[y.t++] = 0;\n  while (--j >= 0) {\n    // Estimate quotient digit\n    var qd = r[--i] == y0\n      ? this.DM\n      : Math.floor(r[i] * d1 + (r[i - 1] + e) * d2);\n    if ((r[i] += y.am(0, qd, r, j, 0, ys)) < qd) {\n      // Try it out\n      y.dlShiftTo(j, t);\n      r.subTo(t, r);\n      while (r[i] < --qd) r.subTo(t, r);\n    }\n  }\n  if (q != null) {\n    r.drShiftTo(ys, q);\n    if (ts != ms) BigInteger.ZERO.subTo(q, q);\n  }\n  r.t = ys;\n  r.clamp();\n  if (nsh > 0) r.rShiftTo(nsh, r);\n  // Denormalize remainder\n  if (ts < 0) BigInteger.ZERO.subTo(r, r);\n}\n\n// (public) this mod a\nfunction bnMod(a) {\n  var r = nbi();\n  this.abs().divRemTo(a, null, r);\n  if (this.s < 0 && r.compareTo(BigInteger.ZERO) > 0) a.subTo(r, r);\n  return r;\n}\n\n// (protected) return \"-1/this % 2^DB\"; useful for Mont. reduction\n// justification:\n//         xy == 1 (mod m)\n//         xy =  1+km\n//   xy(2-xy) = (1+km)(1-km)\n// x[y(2-xy)] = 1-k^2m^2\n// x[y(2-xy)] == 1 (mod m^2)\n// if y is 1/x mod m, then y(2-xy) is 1/x mod m^2\n// should reduce x and y(2-xy) by m^2 at each step to keep size bounded.\n// JS multiply \"overflows\" differently from C/C++, so care is needed here.\nfunction bnpInvDigit() {\n  if (this.t < 1) return 0;\n  var x = this[0];\n  if ((x & 1) == 0) return 0;\n  var y = x & 3;\n  // y == 1/x mod 2^2\n  y = y * (2 - (x & 0xf) * y) & 0xf;\n  // y == 1/x mod 2^4\n  y = y * (2 - (x & 0xff) * y) & 0xff;\n  // y == 1/x mod 2^8\n  y = y * (2 - ((x & 0xffff) * y & 0xffff)) & 0xffff;\n  // y == 1/x mod 2^16\n  // last step - calculate inverse mod DV directly;\n  // assumes 16 < DB <= 32 and assumes ability to handle 48-bit ints\n  y = y * (2 - x * y % this.DV) % this.DV;\n  // y == 1/x mod 2^dbits\n  // we really want the negative inverse, and -DV < y < DV\n  return y > 0 ? this.DV - y : -y;\n}\n\nfunction bnEquals(a) {\n  return this.compareTo(a) == 0;\n}\n\n// (protected) r = this + a\nfunction bnpAddTo(a, r) {\n  var i = 0, c = 0, m = Math.min(a.t, this.t);\n  while (i < m) {\n    c += this[i] + a[i];\n    r[i++] = c & this.DM;\n    c >>= this.DB;\n  }\n  if (a.t < this.t) {\n    c += a.s;\n    while (i < this.t) {\n      c += this[i];\n      r[i++] = c & this.DM;\n      c >>= this.DB;\n    }\n    c += this.s;\n  } else {\n    c += this.s;\n    while (i < a.t) {\n      c += a[i];\n      r[i++] = c & this.DM;\n      c >>= this.DB;\n    }\n    c += a.s;\n  }\n  r.s = c < 0 ? -1 : 0;\n  if (c > 0) r[i++] = c;\n  else if (c < -1) r[i++] = this.DV + c;\n  r.t = i;\n  r.clamp();\n}\n\n// (public) this + a\nfunction bnAdd(a) {\n  var r = nbi();\n\n  this.addTo(a, r);\n\n  return r;\n}\n\n// (public) this - a\nfunction bnSubtract(a) {\n  var r = nbi();\n\n  this.subTo(a, r);\n\n  return r;\n}\n\n// (public) this * a\nfunction bnMultiply(a) {\n  var r = nbi();\n\n  this.multiplyTo(a, r);\n\n  return r;\n}\n\n// (public) this / a\nfunction bnDivide(a) {\n  var r = nbi();\n\n  this.divRemTo(a, r, null);\n\n  return r;\n}\n\n// Montgomery reduction\nfunction Montgomery(m) {\n  this.m = m;\n  this.mp = m.invDigit();\n  this.mpl = this.mp & 0x7fff;\n  this.mph = this.mp >> 15;\n  this.um = (1 << m.DB - 15) - 1;\n  this.mt2 = 2 * m.t;\n}\n\n// xR mod m\nfunction montConvert(x) {\n  var r = nbi();\n  x.abs().dlShiftTo(this.m.t, r);\n  r.divRemTo(this.m, null, r);\n  if (x.s < 0 && r.compareTo(BigInteger.ZERO) > 0) this.m.subTo(r, r);\n  return r;\n}\n\n// x/R mod m\nfunction montRevert(x) {\n  var r = nbi();\n  x.copyTo(r);\n  this.reduce(r);\n  return r;\n}\n\n// x = x/R mod m (HAC 14.32)\nfunction montReduce(x) {\n  while (x.t <= this.mt2)\n    // pad x so am has enough room later\n    x[x.t++] = 0;\n  for (var i = 0; i < this.m.t; ++i) {\n    // faster way of calculating u0 = x[i]*mp mod DV\n    var j = x[i] & 0x7fff;\n    var u0 = j * this.mpl +\n      ((j * this.mph + (x[i] >> 15) * this.mpl & this.um) << 15) &\n      x.DM;\n    // use am to combine the multiply-shift-add into one call\n    j = i + this.m.t;\n    x[j] += this.m.am(0, u0, x, i, 0, this.m.t);\n    // propagate carry\n    while (x[j] >= x.DV) {\n      x[j] -= x.DV;\n      x[++j]++;\n    }\n  }\n  x.clamp();\n  x.drShiftTo(this.m.t, x);\n  if (x.compareTo(this.m) >= 0) x.subTo(this.m, x);\n}\n\n// r = \"x^2/R mod m\"; x != r\nfunction montSqrTo(x, r) {\n  x.squareTo(r);\n\n  this.reduce(r);\n}\n\n// r = \"xy/R mod m\"; x,y != r\nfunction montMulTo(x, y, r) {\n  x.multiplyTo(y, r);\n\n  this.reduce(r);\n}\n\nMontgomery.prototype.convert = montConvert;\nMontgomery.prototype.revert = montRevert;\nMontgomery.prototype.reduce = montReduce;\nMontgomery.prototype.mulTo = montMulTo;\nMontgomery.prototype.sqrTo = montSqrTo;\n\n// (public) this^e % m (HAC 14.85)\nfunction bnModPow(e, m, callback) {\n  var i = e.bitLength(), k, r = nbv(1), z = new Montgomery(m);\n  if (i <= 0) return r;\n  else if (i < 18) k = 1;\n  else if (i < 48) k = 3;\n  else if (i < 144) k = 4;\n  else if (i < 768) k = 5;\n  else k = 6;\n\n  // precomputation\n  var g = new Array(), n = 3, k1 = k - 1, km = (1 << k) - 1;\n  g[1] = z.convert(this);\n  if (k > 1) {\n    var g2 = nbi();\n    z.sqrTo(g[1], g2);\n    while (n <= km) {\n      g[n] = nbi();\n      z.mulTo(g2, g[n - 2], g[n]);\n      n += 2;\n    }\n  }\n\n  var j = e.t - 1, w, is1 = true, r2 = nbi(), t;\n  i = nbits(e[j]) - 1;\n  while (j >= 0) {\n    if (i >= k1) w = e[j] >> i - k1 & km;\n    else {\n      w = (e[j] & (1 << i + 1) - 1) << k1 - i;\n      if (j > 0) w |= e[j - 1] >> this.DB + i - k1;\n    }\n\n    n = k;\n    while ((w & 1) == 0) {\n      w >>= 1;\n      --n;\n    }\n    if ((i -= n) < 0) {\n      i += this.DB;\n      --j;\n    }\n    if (is1) {\n      // ret == 1, don't bother squaring or multiplying it\n      g[w].copyTo(r);\n      is1 = false;\n    } else {\n      while (n > 1) {\n        z.sqrTo(r, r2);\n        z.sqrTo(r2, r);\n        n -= 2;\n      }\n      if (n > 0) z.sqrTo(r, r2);\n      else {\n        t = r;\n        r = r2;\n        r2 = t;\n      }\n      z.mulTo(r2, g[w], r);\n    }\n\n    while (j >= 0 && (e[j] & 1 << i) == 0) {\n      z.sqrTo(r, r2);\n      t = r;\n      r = r2;\n      r2 = t;\n      if (--i < 0) {\n        i = this.DB - 1;\n        --j;\n      }\n    }\n  }\n  var result = z.revert(r);\n  callback(null, result);\n  return result;\n}\n\n// protected\nBigInteger.prototype.copyTo = bnpCopyTo;\nBigInteger.prototype.fromInt = bnpFromInt;\nBigInteger.prototype.fromString = bnpFromString;\nBigInteger.prototype.clamp = bnpClamp;\nBigInteger.prototype.dlShiftTo = bnpDLShiftTo;\nBigInteger.prototype.drShiftTo = bnpDRShiftTo;\nBigInteger.prototype.lShiftTo = bnpLShiftTo;\nBigInteger.prototype.rShiftTo = bnpRShiftTo;\nBigInteger.prototype.subTo = bnpSubTo;\nBigInteger.prototype.multiplyTo = bnpMultiplyTo;\nBigInteger.prototype.squareTo = bnpSquareTo;\nBigInteger.prototype.divRemTo = bnpDivRemTo;\nBigInteger.prototype.invDigit = bnpInvDigit;\nBigInteger.prototype.addTo = bnpAddTo;\n\n// public\nBigInteger.prototype.toString = bnToString;\nBigInteger.prototype.negate = bnNegate;\nBigInteger.prototype.abs = bnAbs;\nBigInteger.prototype.compareTo = bnCompareTo;\nBigInteger.prototype.bitLength = bnBitLength;\nBigInteger.prototype.mod = bnMod;\nBigInteger.prototype.equals = bnEquals;\nBigInteger.prototype.add = bnAdd;\nBigInteger.prototype.subtract = bnSubtract;\nBigInteger.prototype.multiply = bnMultiply;\nBigInteger.prototype.divide = bnDivide;\nBigInteger.prototype.modPow = bnModPow;\n\n// \"constants\"\nBigInteger.ZERO = nbv(0);\nBigInteger.ONE = nbv(1);\n\n\n\n\n// WEBPACK FOOTER //\n// ./src/BigInteger.js","/*\n * Copyright 2016 Amazon.com,\n * Inc. or its affiliates. All Rights Reserved.\n *\n * Licensed under the Amazon Software License (the \"License\").\n * You may not use this file except in compliance with the\n * License. A copy of the License is located at\n *\n *     http://aws.amazon.com/asl/\n *\n * or in the \"license\" file accompanying this file. This file is\n * distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR\n * CONDITIONS OF ANY KIND, express or implied. See the License\n * for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport CognitoJwtToken from './CognitoJwtToken';\n\n/** @class */\nexport default class CognitoAccessToken extends CognitoJwtToken {\n  /**\n   * Constructs a new CognitoAccessToken object\n   * @param {string=} AccessToken The JWT access token.\n   */\n  constructor({ AccessToken } = {}) {\n    super(AccessToken || '');\n  }\n}\n\n\n\n// WEBPACK FOOTER //\n// ./src/CognitoAccessToken.js","/*!\n * Copyright 2016 Amazon.com,\n * Inc. or its affiliates. All Rights Reserved.\n *\n * Licensed under the Amazon Software License (the \"License\").\n * You may not use this file except in compliance with the\n * License. A copy of the License is located at\n *\n *     http://aws.amazon.com/asl/\n *\n * or in the \"license\" file accompanying this file. This file is\n * distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR\n * CONDITIONS OF ANY KIND, express or implied. See the License\n * for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport CognitoJwtToken from './CognitoJwtToken';\n\n/** @class */\nexport default class CognitoIdToken extends CognitoJwtToken {\n  /**\n   * Constructs a new CognitoIdToken object\n   * @param {string=} IdToken The JWT Id token\n   */\n  constructor({ IdToken } = {}) {\n    super(IdToken || '');\n  }\n}\n\n\n\n// WEBPACK FOOTER //\n// ./src/CognitoIdToken.js","/*!\n * Copyright 2016 Amazon.com,\n * Inc. or its affiliates. All Rights Reserved.\n *\n * Licensed under the Amazon Software License (the \"License\").\n * You may not use this file except in compliance with the\n * License. A copy of the License is located at\n *\n *     http://aws.amazon.com/asl/\n *\n * or in the \"license\" file accompanying this file. This file is\n * distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR\n * CONDITIONS OF ANY KIND, express or implied. See the License\n * for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { Buffer } from 'buffer/';\n\n/** @class */\nexport default class CognitoJwtToken {\n  /**\n   * Constructs a new CognitoJwtToken object\n   * @param {string=} token The JWT token.\n   */\n  constructor(token) {\n    // Assign object\n    this.jwtToken = token || '';\n    this.payload = this.decodePayload();\n  }\n\n  /**\n   * @returns {string} the record's token.\n   */\n  getJwtToken() {\n    return this.jwtToken;\n  }\n\n  /**\n   * @returns {int} the token's expiration (exp member).\n   */\n  getExpiration() {\n    return this.payload.exp;\n  }\n\n  /**\n   * @returns {int} the token's \"issued at\" (iat member).\n   */\n  getIssuedAt() {\n    return this.payload.iat;\n  }\n\n  /**\n   * @returns {object} the token's payload.\n   */\n  decodePayload() {\n    const payload = this.jwtToken.split('.')[1];\n    try {\n      return JSON.parse(Buffer.from(payload, 'base64').toString('utf8'));\n    } catch (err) {\n      return {};\n    }\n  }\n}\n\n\n\n// WEBPACK FOOTER //\n// ./src/CognitoJwtToken.js","/*!\n * Copyright 2016 Amazon.com,\n * Inc. or its affiliates. All Rights Reserved.\n *\n * Licensed under the Amazon Software License (the \"License\").\n * You may not use this file except in compliance with the\n * License. A copy of the License is located at\n *\n *     http://aws.amazon.com/asl/\n *\n * or in the \"license\" file accompanying this file. This file is\n * distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR\n * CONDITIONS OF ANY KIND, express or implied. See the License\n * for the specific language governing permissions and\n * limitations under the License.\n */\n\n/** @class */\nexport default class CognitoRefreshToken {\n  /**\n   * Constructs a new CognitoRefreshToken object\n   * @param {string=} RefreshToken The JWT refresh token.\n   */\n  constructor({ RefreshToken } = {}) {\n    // Assign object\n    this.token = RefreshToken || '';\n  }\n\n  /**\n   * @returns {string} the record's token.\n   */\n  getToken() {\n    return this.token;\n  }\n}\n\n\n\n// WEBPACK FOOTER //\n// ./src/CognitoRefreshToken.js","/*!\n * Copyright 2016 Amazon.com,\n * Inc. or its affiliates. All Rights Reserved.\n *\n * Licensed under the Amazon Software License (the \"License\").\n * You may not use this file except in compliance with the\n * License. A copy of the License is located at\n *\n *     http://aws.amazon.com/asl/\n *\n * or in the \"license\" file accompanying this file. This file is\n * distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR\n * CONDITIONS OF ANY KIND, express or implied. See the License\n * for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { Buffer } from 'buffer/';\n//import createHmac from 'create-hmac';\nimport * as crypto from 'crypto-browserify';\nconst createHmac = crypto.createHmac;\n\nimport BigInteger from './BigInteger';\nimport AuthenticationHelper from './AuthenticationHelper';\nimport CognitoAccessToken from './CognitoAccessToken';\nimport CognitoIdToken from './CognitoIdToken';\nimport CognitoRefreshToken from './CognitoRefreshToken';\nimport CognitoUserSession from './CognitoUserSession';\nimport DateHelper from './DateHelper';\nimport CognitoUserAttribute from './CognitoUserAttribute';\nimport StorageHelper from './StorageHelper';\n\n/**\n * @callback nodeCallback\n * @template T result\n * @param {*} err The operation failure reason, or null.\n * @param {T} result The operation result.\n */\n\n/**\n * @callback onFailure\n * @param {*} err Failure reason.\n */\n\n/**\n * @callback onSuccess\n * @template T result\n * @param {T} result The operation result.\n */\n\n/**\n * @callback mfaRequired\n * @param {*} details MFA challenge details.\n */\n\n/**\n * @callback customChallenge\n * @param {*} details Custom challenge details.\n */\n\n/**\n * @callback inputVerificationCode\n * @param {*} data Server response.\n */\n\n/**\n * @callback authSuccess\n * @param {CognitoUserSession} session The new session.\n * @param {bool=} userConfirmationNecessary User must be confirmed.\n */\n\n\n/** @class */\nexport default class CognitoUser {\n  /**\n   * Constructs a new CognitoUser object\n   * @param {object} data Creation options\n   * @param {string} data.Username The user's username.\n   * @param {CognitoUserPool} data.Pool Pool containing the user.\n   * @param {object} data.Storage Optional storage object.\n   */\n  constructor(data) {\n    if (data == null || data.Username == null || data.Pool == null) {\n      throw new Error('Username and pool information are required.');\n    }\n\n    this.username = data.Username || '';\n    this.pool = data.Pool;\n    this.Session = null;\n\n    this.client = data.Pool.client;\n\n    this.signInUserSession = null;\n    this.authenticationFlowType = 'USER_SRP_AUTH';\n\n    this.storage = data.Storage || new StorageHelper().getStorage();\n  }\n\n  /**\n   * Sets the session for this user\n   * @param {CognitoUserSession} signInUserSession the session\n   * @returns {void}\n   */\n  setSignInUserSession(signInUserSession) {\n    this.clearCachedTokens();\n    this.signInUserSession = signInUserSession;\n    this.cacheTokens();\n  }\n\n  /**\n   * @returns {CognitoUserSession} the current session for this user\n   */\n  getSignInUserSession() {\n    return this.signInUserSession;\n  }\n\n  /**\n   * @returns {string} the user's username\n   */\n  getUsername() {\n    return this.username;\n  }\n\n  /**\n   * @returns {String} the authentication flow type\n   */\n  getAuthenticationFlowType() {\n    return this.authenticationFlowType;\n  }\n\n  /**\n   * sets authentication flow type\n   * @param {string} authenticationFlowType New value.\n   * @returns {void}\n   */\n  setAuthenticationFlowType(authenticationFlowType) {\n    this.authenticationFlowType = authenticationFlowType;\n  }\n\n\n  /**\n   * This is used for authenticating the user through the custom authentication flow.\n   * @param {AuthenticationDetails} authDetails Contains the authentication data\n   * @param {object} callback Result callback map.\n   * @param {onFailure} callback.onFailure Called on any error.\n   * @param {customChallenge} callback.customChallenge Custom challenge\n   *        response required to continue.\n   * @param {authSuccess} callback.onSuccess Called on success with the new session.\n   * @returns {void}\n   */\n  initiateAuth(authDetails, callback) {\n    const authParameters = authDetails.getAuthParameters();\n    authParameters.USERNAME = this.username;\n\n    const jsonReq = {\n      AuthFlow: 'CUSTOM_AUTH',\n      ClientId: this.pool.getClientId(),\n      AuthParameters: authParameters,\n      ClientMetadata: authDetails.getValidationData(),\n    };\n    if (this.getUserContextData()) {\n      jsonReq.UserContextData = this.getUserContextData();\n    }\n\n    this.client.request('InitiateAuth', jsonReq, (err, data) => {\n      if (err) {\n        return callback.onFailure(err);\n      }\n      const challengeName = data.ChallengeName;\n      const challengeParameters = data.ChallengeParameters;\n\n      if (challengeName === 'CUSTOM_CHALLENGE') {\n        this.Session = data.Session;\n        return callback.customChallenge(challengeParameters);\n      }\n      this.signInUserSession = this.getCognitoUserSession(data.AuthenticationResult);\n      this.cacheTokens();\n      return callback.onSuccess(this.signInUserSession);\n    });\n  }\n\n  /**\n   * This is used for authenticating the user.\n   * stuff\n   * @param {AuthenticationDetails} authDetails Contains the authentication data\n   * @param {object} callback Result callback map.\n   * @param {onFailure} callback.onFailure Called on any error.\n   * @param {newPasswordRequired} callback.newPasswordRequired new\n   *        password and any required attributes are required to continue\n   * @param {mfaRequired} callback.mfaRequired MFA code\n   *        required to continue.\n   * @param {customChallenge} callback.customChallenge Custom challenge\n   *        response required to continue.\n   * @param {authSuccess} callback.onSuccess Called on success with the new session.\n   * @returns {void}\n   */\n  authenticateUser(authDetails, callback) {\n    if (this.authenticationFlowType === 'USER_PASSWORD_AUTH') {\n      return this.authenticateUserPlainUsernamePassword(authDetails, callback);\n    } else if (this.authenticationFlowType === 'USER_SRP_AUTH') {\n      return this.authenticateUserDefaultAuth(authDetails, callback);\n    }\n    return callback.onFailure(new Error('Authentication flow type is invalid.'));\n  }\n\n  /**\n   * PRIVATE ONLY: This is an internal only method and should not\n   * be directly called by the consumers.\n   * It calls the AuthenticationHelper for SRP related\n   * stuff\n   * @param {AuthenticationDetails} authDetails Contains the authentication data\n   * @param {object} callback Result callback map.\n   * @param {onFailure} callback.onFailure Called on any error.\n   * @param {newPasswordRequired} callback.newPasswordRequired new\n   *        password and any required attributes are required to continue\n   * @param {mfaRequired} callback.mfaRequired MFA code\n   *        required to continue.\n   * @param {customChallenge} callback.customChallenge Custom challenge\n   *        response required to continue.\n   * @param {authSuccess} callback.onSuccess Called on success with the new session.\n   * @returns {void}\n   */\n  authenticateUserDefaultAuth(authDetails, callback) {\n    const authenticationHelper = new AuthenticationHelper(\n      this.pool.getUserPoolId().split('_')[1]);\n    const dateHelper = new DateHelper();\n\n    let serverBValue;\n    let salt;\n    const authParameters = {};\n\n    if (this.deviceKey != null) {\n      authParameters.DEVICE_KEY = this.deviceKey;\n    }\n\n    authParameters.USERNAME = this.username;\n    authenticationHelper.getLargeAValue((errOnAValue, aValue) => {\n      // getLargeAValue callback start\n      if (errOnAValue) {\n        callback.onFailure(errOnAValue);\n      }\n\n      authParameters.SRP_A = aValue.toString(16);\n\n      if (this.authenticationFlowType === 'CUSTOM_AUTH') {\n        authParameters.CHALLENGE_NAME = 'SRP_A';\n      }\n\n      const jsonReq = {\n        AuthFlow: this.authenticationFlowType,\n        ClientId: this.pool.getClientId(),\n        AuthParameters: authParameters,\n        ClientMetadata: authDetails.getValidationData(),\n      };\n      if (this.getUserContextData(this.username)) {\n        jsonReq.UserContextData = this.getUserContextData(this.username);\n      }\n\n      this.client.request('InitiateAuth', jsonReq, (err, data) => {\n        if (err) {\n          return callback.onFailure(err);\n        }\n\n        const challengeParameters = data.ChallengeParameters;\n\n        this.username = challengeParameters.USER_ID_FOR_SRP;\n        serverBValue = new BigInteger(challengeParameters.SRP_B, 16);\n        salt = new BigInteger(challengeParameters.SALT, 16);\n        this.getCachedDeviceKeyAndPassword();\n\n        authenticationHelper.getPasswordAuthenticationKey(\n          this.username,\n          authDetails.getPassword(),\n          serverBValue,\n          salt,\n          (errOnHkdf, hkdf) => {\n            // getPasswordAuthenticationKey callback start\n            if (errOnHkdf) {\n              callback.onFailure(errOnHkdf);\n            }\n\n            const dateNow = dateHelper.getNowString();\n\n            const signatureString = createHmac('sha256', hkdf)\n              .update(Buffer.concat([\n                Buffer.from(this.pool.getUserPoolId().split('_')[1], 'utf8'),\n                Buffer.from(this.username, 'utf8'),\n                Buffer.from(challengeParameters.SECRET_BLOCK, 'base64'),\n                Buffer.from(dateNow, 'utf8'),\n              ]))\n              .digest('base64');\n\n            const challengeResponses = {};\n\n            challengeResponses.USERNAME = this.username;\n            challengeResponses.PASSWORD_CLAIM_SECRET_BLOCK = challengeParameters.SECRET_BLOCK;\n            challengeResponses.TIMESTAMP = dateNow;\n            challengeResponses.PASSWORD_CLAIM_SIGNATURE = signatureString;\n\n            if (this.deviceKey != null) {\n              challengeResponses.DEVICE_KEY = this.deviceKey;\n            }\n\n            const respondToAuthChallenge = (challenge, challengeCallback) =>\n              this.client.request('RespondToAuthChallenge', challenge,\n                (errChallenge, dataChallenge) => {\n                  if (errChallenge && errChallenge.code === 'ResourceNotFoundException' &&\n                      errChallenge.message.toLowerCase().indexOf('device') !== -1) {\n                    challengeResponses.DEVICE_KEY = null;\n                    this.deviceKey = null;\n                    this.randomPassword = null;\n                    this.deviceGroupKey = null;\n                    this.clearCachedDeviceKeyAndPassword();\n                    return respondToAuthChallenge(challenge, challengeCallback);\n                  }\n                  return challengeCallback(errChallenge, dataChallenge);\n                });\n\n            const jsonReqResp = {\n              ChallengeName: 'PASSWORD_VERIFIER',\n              ClientId: this.pool.getClientId(),\n              ChallengeResponses: challengeResponses,\n              Session: data.Session,\n            };\n            if (this.getUserContextData()) {\n              jsonReqResp.UserContextData = this.getUserContextData();\n            }\n            respondToAuthChallenge(jsonReqResp, (errAuthenticate, dataAuthenticate) => {\n              if (errAuthenticate) {\n                return callback.onFailure(errAuthenticate);\n              }\n\n              const challengeName = dataAuthenticate.ChallengeName;\n              if (challengeName === 'NEW_PASSWORD_REQUIRED') {\n                this.Session = dataAuthenticate.Session;\n                let userAttributes = null;\n                let rawRequiredAttributes = null;\n                const requiredAttributes = [];\n                const userAttributesPrefix = authenticationHelper\n                  .getNewPasswordRequiredChallengeUserAttributePrefix();\n\n                if (dataAuthenticate.ChallengeParameters) {\n                  userAttributes = JSON.parse(\n                    dataAuthenticate.ChallengeParameters.userAttributes);\n                  rawRequiredAttributes = JSON.parse(\n                    dataAuthenticate.ChallengeParameters.requiredAttributes);\n                }\n\n                if (rawRequiredAttributes) {\n                  for (let i = 0; i < rawRequiredAttributes.length; i++) {\n                    requiredAttributes[i] = rawRequiredAttributes[i].substr(\n                      userAttributesPrefix.length\n                    );\n                  }\n                }\n                return callback.newPasswordRequired(userAttributes, requiredAttributes);\n              }\n              return this.authenticateUserInternal(\n                dataAuthenticate,\n                authenticationHelper,\n                callback\n              );\n            });\n            return undefined;\n          // getPasswordAuthenticationKey callback end\n          });\n        return undefined;\n      });\n      // getLargeAValue callback end\n    });\n  }\n\n  /**\n   * PRIVATE ONLY: This is an internal only method and should not\n   * be directly called by the consumers.\n   * @param {AuthenticationDetails} authDetails Contains the authentication data.\n   * @param {object} callback Result callback map.\n   * @param {onFailure} callback.onFailure Called on any error.\n   * @param {mfaRequired} callback.mfaRequired MFA code\n   *        required to continue.\n   * @param {authSuccess} callback.onSuccess Called on success with the new session.\n   * @returns {void}\n   */\n  authenticateUserPlainUsernamePassword(authDetails, callback) {\n    const authParameters = {};\n    authParameters.USERNAME = this.username;\n    authParameters.PASSWORD = authDetails.getPassword();\n    if (!authParameters.PASSWORD) {\n      callback.onFailure(new Error('PASSWORD parameter is required'));\n      return;\n    }\n    const authenticationHelper = new AuthenticationHelper(\n      this.pool.getUserPoolId().split('_')[1]);\n    this.getCachedDeviceKeyAndPassword();\n    if (this.deviceKey != null) {\n      authParameters.DEVICE_KEY = this.deviceKey;\n    }\n\n    const jsonReq = {\n      AuthFlow: 'USER_PASSWORD_AUTH',\n      ClientId: this.pool.getClientId(),\n      AuthParameters: authParameters,\n      ClientMetadata: authDetails.getValidationData(),\n    };\n    if (this.getUserContextData(this.username)) {\n      jsonReq.UserContextData = this.getUserContextData(this.username);\n    }\n    // USER_PASSWORD_AUTH happens in a single round-trip: client sends userName and password,\n    // Cognito UserPools verifies password and returns tokens.\n    this.client.request('InitiateAuth', jsonReq, (err, authResult) => {\n      if (err) {\n        return callback.onFailure(err);\n      }\n      return this.authenticateUserInternal(authResult, authenticationHelper, callback);\n    });\n  }\n\n  /**\n  * PRIVATE ONLY: This is an internal only method and should not\n  * be directly called by the consumers.\n  * @param {object} dataAuthenticate authentication data\n  * @param {object} authenticationHelper helper created\n  * @param {callback} callback passed on from caller\n  * @returns {void}\n  */\n  authenticateUserInternal(dataAuthenticate, authenticationHelper, callback) {\n    const challengeName = dataAuthenticate.ChallengeName;\n    const challengeParameters = dataAuthenticate.ChallengeParameters;\n\n    if (challengeName === 'SMS_MFA') {\n      this.Session = dataAuthenticate.Session;\n      return callback.mfaRequired(challengeName, challengeParameters);\n    }\n\n    if (challengeName === 'SELECT_MFA_TYPE') {\n      this.Session = dataAuthenticate.Session;\n      return callback.selectMFAType(challengeName, challengeParameters);\n    }\n\n    if (challengeName === 'MFA_SETUP') {\n      this.Session = dataAuthenticate.Session;\n      return callback.mfaSetup(challengeName, challengeParameters);\n    }\n\n    if (challengeName === 'SOFTWARE_TOKEN_MFA') {\n      this.Session = dataAuthenticate.Session;\n      return callback.totpRequired(challengeName, challengeParameters);\n    }\n\n    if (challengeName === 'CUSTOM_CHALLENGE') {\n      this.Session = dataAuthenticate.Session;\n      return callback.customChallenge(challengeParameters);\n    }\n\n    if (challengeName === 'DEVICE_SRP_AUTH') {\n      this.getDeviceResponse(callback);\n      return undefined;\n    }\n\n    this.signInUserSession = this.getCognitoUserSession(dataAuthenticate.AuthenticationResult);\n    this.cacheTokens();\n\n    const newDeviceMetadata = dataAuthenticate.AuthenticationResult.NewDeviceMetadata;\n    if (newDeviceMetadata == null) {\n      return callback.onSuccess(this.signInUserSession);\n    }\n\n    authenticationHelper.generateHashDevice(\n      dataAuthenticate.AuthenticationResult.NewDeviceMetadata.DeviceGroupKey,\n      dataAuthenticate.AuthenticationResult.NewDeviceMetadata.DeviceKey,\n    (errGenHash) => {\n      if (errGenHash) {\n        return callback.onFailure(errGenHash);\n      }\n\n      const deviceSecretVerifierConfig = {\n        Salt: Buffer.from(\n          authenticationHelper.getSaltDevices(), 'hex'\n        ).toString('base64'),\n        PasswordVerifier: Buffer.from(\n          authenticationHelper.getVerifierDevices(), 'hex'\n        ).toString('base64'),\n      };\n\n      this.verifierDevices = deviceSecretVerifierConfig.PasswordVerifier;\n      this.deviceGroupKey = newDeviceMetadata.DeviceGroupKey;\n      this.randomPassword = authenticationHelper.getRandomPassword();\n\n      this.client.request('ConfirmDevice', {\n        DeviceKey: newDeviceMetadata.DeviceKey,\n        AccessToken: this.signInUserSession.getAccessToken().getJwtToken(),\n        DeviceSecretVerifierConfig: deviceSecretVerifierConfig,\n        DeviceName: navigator.userAgent,\n      }, (errConfirm, dataConfirm) => {\n        if (errConfirm) {\n          return callback.onFailure(errConfirm);\n        }\n\n        this.deviceKey = dataAuthenticate.AuthenticationResult.NewDeviceMetadata.DeviceKey;\n        this.cacheDeviceKeyAndPassword();\n        if (dataConfirm.UserConfirmationNecessary === true) {\n          return callback.onSuccess(\n            this.signInUserSession, dataConfirm.UserConfirmationNecessary);\n        }\n        return callback.onSuccess(this.signInUserSession);\n      });\n      return undefined;\n    });\n    return undefined;\n  }\n\n  /**\n  * This method is user to complete the NEW_PASSWORD_REQUIRED challenge.\n  * Pass the new password with any new user attributes to be updated.\n  * User attribute keys must be of format userAttributes.<attribute_name>.\n  * @param {string} newPassword new password for this user\n  * @param {object} requiredAttributeData map with values for all required attributes\n  * @param {object} callback Result callback map.\n  * @param {onFailure} callback.onFailure Called on any error.\n  * @param {mfaRequired} callback.mfaRequired MFA code required to continue.\n  * @param {customChallenge} callback.customChallenge Custom challenge\n  *         response required to continue.\n  * @param {authSuccess} callback.onSuccess Called on success with the new session.\n  * @returns {void}\n  */\n  completeNewPasswordChallenge(newPassword, requiredAttributeData, callback) {\n    if (!newPassword) {\n      return callback.onFailure(new Error('New password is required.'));\n    }\n    const authenticationHelper = new AuthenticationHelper(\n      this.pool.getUserPoolId().split('_')[1]);\n    const userAttributesPrefix = authenticationHelper\n      .getNewPasswordRequiredChallengeUserAttributePrefix();\n\n    const finalUserAttributes = {};\n    if (requiredAttributeData) {\n      Object.keys(requiredAttributeData).forEach((key) => {\n        finalUserAttributes[userAttributesPrefix + key] = requiredAttributeData[key];\n      });\n    }\n\n    finalUserAttributes.NEW_PASSWORD = newPassword;\n    finalUserAttributes.USERNAME = this.username;\n    const jsonReq = {\n      ChallengeName: 'NEW_PASSWORD_REQUIRED',\n      ClientId: this.pool.getClientId(),\n      ChallengeResponses: finalUserAttributes,\n      Session: this.Session,\n    };\n    if (this.getUserContextData()) {\n      jsonReq.UserContextData = this.getUserContextData();\n    }\n\n    this.client.request('RespondToAuthChallenge',\n        jsonReq, (errAuthenticate, dataAuthenticate) => {\n          if (errAuthenticate) {\n            return callback.onFailure(errAuthenticate);\n          }\n          return this.authenticateUserInternal(dataAuthenticate, authenticationHelper, callback);\n        });\n    return undefined;\n  }\n\n  /**\n   * This is used to get a session using device authentication. It is called at the end of user\n   * authentication\n   *\n   * @param {object} callback Result callback map.\n   * @param {onFailure} callback.onFailure Called on any error.\n   * @param {authSuccess} callback.onSuccess Called on success with the new session.\n   * @returns {void}\n   * @private\n   */\n  getDeviceResponse(callback) {\n    const authenticationHelper = new AuthenticationHelper(\n      this.deviceGroupKey);\n    const dateHelper = new DateHelper();\n\n    const authParameters = {};\n\n    authParameters.USERNAME = this.username;\n    authParameters.DEVICE_KEY = this.deviceKey;\n    authenticationHelper.getLargeAValue((errAValue, aValue) => {\n      // getLargeAValue callback start\n      if (errAValue) {\n        callback.onFailure(errAValue);\n      }\n\n      authParameters.SRP_A = aValue.toString(16);\n\n      const jsonReq = {\n        ChallengeName: 'DEVICE_SRP_AUTH',\n        ClientId: this.pool.getClientId(),\n        ChallengeResponses: authParameters,\n      };\n      if (this.getUserContextData()) {\n        jsonReq.UserContextData = this.getUserContextData();\n      }\n      this.client.request('RespondToAuthChallenge', jsonReq, (err, data) => {\n        if (err) {\n          return callback.onFailure(err);\n        }\n\n        const challengeParameters = data.ChallengeParameters;\n\n        const serverBValue = new BigInteger(challengeParameters.SRP_B, 16);\n        const salt = new BigInteger(challengeParameters.SALT, 16);\n\n        authenticationHelper.getPasswordAuthenticationKey(\n          this.deviceKey,\n          this.randomPassword,\n          serverBValue,\n          salt,\n          (errHkdf, hkdf) => {\n            // getPasswordAuthenticationKey callback start\n            if (errHkdf) {\n              return callback.onFailure(errHkdf);\n            }\n\n            const dateNow = dateHelper.getNowString();\n\n            const signatureString = createHmac('sha256', hkdf)\n            .update(Buffer.concat([\n              Buffer.from(this.deviceGroupKey, 'utf8'),\n              Buffer.from(this.deviceKey, 'utf8'),\n              Buffer.from(challengeParameters.SECRET_BLOCK, 'base64'),\n              Buffer.from(dateNow, 'utf8'),\n            ]))\n            .digest('base64');\n\n            const challengeResponses = {};\n\n            challengeResponses.USERNAME = this.username;\n            challengeResponses.PASSWORD_CLAIM_SECRET_BLOCK = challengeParameters.SECRET_BLOCK;\n            challengeResponses.TIMESTAMP = dateNow;\n            challengeResponses.PASSWORD_CLAIM_SIGNATURE = signatureString;\n            challengeResponses.DEVICE_KEY = this.deviceKey;\n\n            const jsonReqResp = {\n              ChallengeName: 'DEVICE_PASSWORD_VERIFIER',\n              ClientId: this.pool.getClientId(),\n              ChallengeResponses: challengeResponses,\n              Session: data.Session,\n            };\n            if (this.getUserContextData()) {\n              jsonReqResp.UserContextData = this.getUserContextData();\n            }\n\n            this.client.request('RespondToAuthChallenge',\n                jsonReqResp, (errAuthenticate, dataAuthenticate) => {\n                  if (errAuthenticate) {\n                    return callback.onFailure(errAuthenticate);\n                  }\n\n                  this.signInUserSession = this.getCognitoUserSession(\n                      dataAuthenticate.AuthenticationResult\n                  );\n                  this.cacheTokens();\n\n                  return callback.onSuccess(this.signInUserSession);\n                });\n            return undefined;\n            // getPasswordAuthenticationKey callback end\n          });\n        return undefined;\n      });\n      // getLargeAValue callback end\n    });\n  }\n\n  /**\n   * This is used for a certain user to confirm the registration by using a confirmation code\n   * @param {string} confirmationCode Code entered by user.\n   * @param {bool} forceAliasCreation Allow migrating from an existing email / phone number.\n   * @param {nodeCallback<string>} callback Called on success or error.\n   * @returns {void}\n   */\n  confirmRegistration(confirmationCode, forceAliasCreation, callback) {\n    const jsonReq = {\n      ClientId: this.pool.getClientId(),\n      ConfirmationCode: confirmationCode,\n      Username: this.username,\n      ForceAliasCreation: forceAliasCreation,\n    };\n    if (this.getUserContextData()) {\n      jsonReq.UserContextData = this.getUserContextData();\n    }\n    this.client.request('ConfirmSignUp', jsonReq, err => {\n      if (err) {\n        return callback(err, null);\n      }\n      return callback(null, 'SUCCESS');\n    });\n  }\n\n  /**\n   * This is used by the user once he has the responses to a custom challenge\n   * @param {string} answerChallenge The custom challange answer.\n   * @param {object} callback Result callback map.\n   * @param {onFailure} callback.onFailure Called on any error.\n   * @param {customChallenge} callback.customChallenge\n   *    Custom challenge response required to continue.\n   * @param {authSuccess} callback.onSuccess Called on success with the new session.\n   * @returns {void}\n   */\n  sendCustomChallengeAnswer(answerChallenge, callback) {\n    const challengeResponses = {};\n    challengeResponses.USERNAME = this.username;\n    challengeResponses.ANSWER = answerChallenge;\n\n    const authenticationHelper = new AuthenticationHelper(\n      this.pool.getUserPoolId().split('_')[1]\n    );\n    this.getCachedDeviceKeyAndPassword();\n    if (this.deviceKey != null) {\n      challengeResponses.DEVICE_KEY = this.deviceKey;\n    }\n\n    const jsonReq = {\n      ChallengeName: 'CUSTOM_CHALLENGE',\n      ChallengeResponses: challengeResponses,\n      ClientId: this.pool.getClientId(),\n      Session: this.Session,\n    };\n    if (this.getUserContextData()) {\n      jsonReq.UserContextData = this.getUserContextData();\n    }\n    this.client.request('RespondToAuthChallenge', jsonReq, (err, data) => {\n      if (err) {\n        return callback.onFailure(err);\n      }\n\n      return this.authenticateUserInternal(data, authenticationHelper, callback);\n    });\n  }\n\n  /**\n   * This is used by the user once he has an MFA code\n   * @param {string} confirmationCode The MFA code entered by the user.\n   * @param {object} callback Result callback map.\n   * @param {string} mfaType The mfa we are replying to.\n   * @param {onFailure} callback.onFailure Called on any error.\n   * @param {authSuccess} callback.onSuccess Called on success with the new session.\n   * @returns {void}\n   */\n  sendMFACode(confirmationCode, callback, mfaType) {\n    const challengeResponses = {};\n    challengeResponses.USERNAME = this.username;\n    challengeResponses.SMS_MFA_CODE = confirmationCode;\n    const mfaTypeSelection = mfaType || 'SMS_MFA';\n    if (mfaTypeSelection === 'SOFTWARE_TOKEN_MFA') {\n      challengeResponses.SOFTWARE_TOKEN_MFA_CODE = confirmationCode;\n    }\n\n    if (this.deviceKey != null) {\n      challengeResponses.DEVICE_KEY = this.deviceKey;\n    }\n\n    const jsonReq = {\n      ChallengeName: mfaTypeSelection,\n      ChallengeResponses: challengeResponses,\n      ClientId: this.pool.getClientId(),\n      Session: this.Session,\n    };\n    if (this.getUserContextData()) {\n      jsonReq.UserContextData = this.getUserContextData();\n    }\n\n    this.client.request('RespondToAuthChallenge',\n        jsonReq, (err, dataAuthenticate) => {\n          if (err) {\n            return callback.onFailure(err);\n          }\n\n          const challengeName = dataAuthenticate.ChallengeName;\n\n          if (challengeName === 'DEVICE_SRP_AUTH') {\n            this.getDeviceResponse(callback);\n            return undefined;\n          }\n\n          this.signInUserSession =\n            this.getCognitoUserSession(dataAuthenticate.AuthenticationResult);\n          this.cacheTokens();\n\n          if (dataAuthenticate.AuthenticationResult.NewDeviceMetadata == null) {\n            return callback.onSuccess(this.signInUserSession);\n          }\n\n          const authenticationHelper = new AuthenticationHelper(\n          this.pool.getUserPoolId().split('_')[1]);\n          authenticationHelper.generateHashDevice(\n            dataAuthenticate.AuthenticationResult.NewDeviceMetadata.DeviceGroupKey,\n            dataAuthenticate.AuthenticationResult.NewDeviceMetadata.DeviceKey,\n            (errGenHash) => {\n              if (errGenHash) {\n                return callback.onFailure(errGenHash);\n              }\n\n              const deviceSecretVerifierConfig = {\n                Salt: Buffer.from(\n                  authenticationHelper.getSaltDevices(), 'hex'\n                ).toString('base64'),\n                PasswordVerifier: Buffer.from(\n                  authenticationHelper.getVerifierDevices(), 'hex'\n                ).toString('base64'),\n              };\n\n              this.verifierDevices = deviceSecretVerifierConfig.PasswordVerifier;\n              this.deviceGroupKey = dataAuthenticate.AuthenticationResult\n                .NewDeviceMetadata.DeviceGroupKey;\n              this.randomPassword = authenticationHelper.getRandomPassword();\n\n              this.client.request('ConfirmDevice', {\n                DeviceKey: dataAuthenticate.AuthenticationResult.NewDeviceMetadata.DeviceKey,\n                AccessToken: this.signInUserSession.getAccessToken().getJwtToken(),\n                DeviceSecretVerifierConfig: deviceSecretVerifierConfig,\n                DeviceName: navigator.userAgent,\n              }, (errConfirm, dataConfirm) => {\n                if (errConfirm) {\n                  return callback.onFailure(errConfirm);\n                }\n\n                this.deviceKey = dataAuthenticate.AuthenticationResult.NewDeviceMetadata.DeviceKey;\n                this.cacheDeviceKeyAndPassword();\n                if (dataConfirm.UserConfirmationNecessary === true) {\n                  return callback.onSuccess(\n                    this.signInUserSession,\n                    dataConfirm.UserConfirmationNecessary);\n                }\n                return callback.onSuccess(this.signInUserSession);\n              });\n              return undefined;\n            });\n          return undefined;\n        });\n  }\n\n  /**\n   * This is used by an authenticated user to change the current password\n   * @param {string} oldUserPassword The current password.\n   * @param {string} newUserPassword The requested new password.\n   * @param {nodeCallback<string>} callback Called on success or error.\n   * @returns {void}\n   */\n  changePassword(oldUserPassword, newUserPassword, callback) {\n    if (!(this.signInUserSession != null && this.signInUserSession.isValid())) {\n      return callback(new Error('User is not authenticated'), null);\n    }\n\n    this.client.request('ChangePassword', {\n      PreviousPassword: oldUserPassword,\n      ProposedPassword: newUserPassword,\n      AccessToken: this.signInUserSession.getAccessToken().getJwtToken(),\n    }, err => {\n      if (err) {\n        return callback(err, null);\n      }\n      return callback(null, 'SUCCESS');\n    });\n    return undefined;\n  }\n\n  /**\n   * This is used by an authenticated user to enable MFA for himself\n   * @param {nodeCallback<string>} callback Called on success or error.\n   * @returns {void}\n   */\n  enableMFA(callback) {\n    if (this.signInUserSession == null || !this.signInUserSession.isValid()) {\n      return callback(new Error('User is not authenticated'), null);\n    }\n\n    const mfaOptions = [];\n    const mfaEnabled = {\n      DeliveryMedium: 'SMS',\n      AttributeName: 'phone_number',\n    };\n    mfaOptions.push(mfaEnabled);\n\n    this.client.request('SetUserSettings', {\n      MFAOptions: mfaOptions,\n      AccessToken: this.signInUserSession.getAccessToken().getJwtToken(),\n    }, err => {\n      if (err) {\n        return callback(err, null);\n      }\n      return callback(null, 'SUCCESS');\n    });\n    return undefined;\n  }\n\n  /**\n   * This is used by an authenticated user to enable MFA for himself\n   * @param {string[]} smsMfaSettings the sms mfa settings\n   * @param {string[]} softwareTokenMfaSettings the software token mfa settings\n   * @param {nodeCallback<string>} callback Called on success or error.\n   * @returns {void}\n   */\n  setUserMfaPreference(smsMfaSettings, softwareTokenMfaSettings, callback) {\n    if (this.signInUserSession == null || !this.signInUserSession.isValid()) {\n      return callback(new Error('User is not authenticated'), null);\n    }\n\n    this.client.request('SetUserMFAPreference', {\n      SMSMfaSettings: smsMfaSettings,\n      SoftwareTokenMfaSettings: softwareTokenMfaSettings,\n      AccessToken: this.signInUserSession.getAccessToken().getJwtToken(),\n    }, err => {\n      if (err) {\n        return callback(err, null);\n      }\n      return callback(null, 'SUCCESS');\n    });\n    return undefined;\n  }\n\n  /**\n   * This is used by an authenticated user to disable MFA for himself\n   * @param {nodeCallback<string>} callback Called on success or error.\n   * @returns {void}\n   */\n  disableMFA(callback) {\n    if (this.signInUserSession == null || !this.signInUserSession.isValid()) {\n      return callback(new Error('User is not authenticated'), null);\n    }\n\n    const mfaOptions = [];\n\n    this.client.request('SetUserSettings', {\n      MFAOptions: mfaOptions,\n      AccessToken: this.signInUserSession.getAccessToken().getJwtToken(),\n    }, err => {\n      if (err) {\n        return callback(err, null);\n      }\n      return callback(null, 'SUCCESS');\n    });\n    return undefined;\n  }\n\n\n  /**\n   * This is used by an authenticated user to delete himself\n   * @param {nodeCallback<string>} callback Called on success or error.\n   * @returns {void}\n   */\n  deleteUser(callback) {\n    if (this.signInUserSession == null || !this.signInUserSession.isValid()) {\n      return callback(new Error('User is not authenticated'), null);\n    }\n\n    this.client.request('DeleteUser', {\n      AccessToken: this.signInUserSession.getAccessToken().getJwtToken(),\n    }, err => {\n      if (err) {\n        return callback(err, null);\n      }\n      this.clearCachedTokens();\n      return callback(null, 'SUCCESS');\n    });\n    return undefined;\n  }\n\n  /**\n   * @typedef {CognitoUserAttribute | { Name:string, Value:string }} AttributeArg\n   */\n  /**\n   * This is used by an authenticated user to change a list of attributes\n   * @param {AttributeArg[]} attributes A list of the new user attributes.\n   * @param {nodeCallback<string>} callback Called on success or error.\n   * @returns {void}\n   */\n  updateAttributes(attributes, callback) {\n    if (this.signInUserSession == null || !this.signInUserSession.isValid()) {\n      return callback(new Error('User is not authenticated'), null);\n    }\n\n    this.client.request('UpdateUserAttributes', {\n      AccessToken: this.signInUserSession.getAccessToken().getJwtToken(),\n      UserAttributes: attributes,\n    }, err => {\n      if (err) {\n        return callback(err, null);\n      }\n      return callback(null, 'SUCCESS');\n    });\n    return undefined;\n  }\n\n  /**\n   * This is used by an authenticated user to get a list of attributes\n   * @param {nodeCallback<CognitoUserAttribute[]>} callback Called on success or error.\n   * @returns {void}\n   */\n  getUserAttributes(callback) {\n    if (!(this.signInUserSession != null && this.signInUserSession.isValid())) {\n      return callback(new Error('User is not authenticated'), null);\n    }\n\n    this.client.request('GetUser', {\n      AccessToken: this.signInUserSession.getAccessToken().getJwtToken(),\n    }, (err, userData) => {\n      if (err) {\n        return callback(err, null);\n      }\n\n      const attributeList = [];\n\n      for (let i = 0; i < userData.UserAttributes.length; i++) {\n        const attribute = {\n          Name: userData.UserAttributes[i].Name,\n          Value: userData.UserAttributes[i].Value,\n        };\n        const userAttribute = new CognitoUserAttribute(attribute);\n        attributeList.push(userAttribute);\n      }\n\n      return callback(null, attributeList);\n    });\n    return undefined;\n  }\n\n  /**\n   * This is used by an authenticated user to get the MFAOptions\n   * @param {nodeCallback<MFAOptions>} callback Called on success or error.\n   * @returns {void}\n   */\n  getMFAOptions(callback) {\n    if (!(this.signInUserSession != null && this.signInUserSession.isValid())) {\n      return callback(new Error('User is not authenticated'), null);\n    }\n\n    this.client.request('GetUser', {\n      AccessToken: this.signInUserSession.getAccessToken().getJwtToken(),\n    }, (err, userData) => {\n      if (err) {\n        return callback(err, null);\n      }\n\n      return callback(null, userData.MFAOptions);\n    });\n    return undefined;\n  }\n\n  /**\n   * This is used by an authenticated users to get the userData\n   * @param {nodeCallback<UserData>} callback Called on success or error.\n   * @returns {void}\n   */\n  getUserData(callback) {\n    if (!(this.signInUserSession != null && this.signInUserSession.isValid())) {\n      return callback(new Error('User is not authenticated'), null);\n    }\n\n    this.client.request('GetUser', {\n      AccessToken: this.signInUserSession.getAccessToken().getJwtToken(),\n    }, (err, userData) => {\n      if (err) {\n        return callback(err, null);\n      }\n\n      return callback(null, userData);\n    });\n    return undefined;\n  }\n\n  /**\n   * This is used by an authenticated user to delete a list of attributes\n   * @param {string[]} attributeList Names of the attributes to delete.\n   * @param {nodeCallback<string>} callback Called on success or error.\n   * @returns {void}\n   */\n  deleteAttributes(attributeList, callback) {\n    if (!(this.signInUserSession != null && this.signInUserSession.isValid())) {\n      return callback(new Error('User is not authenticated'), null);\n    }\n\n    this.client.request('DeleteUserAttributes', {\n      UserAttributeNames: attributeList,\n      AccessToken: this.signInUserSession.getAccessToken().getJwtToken(),\n    }, err => {\n      if (err) {\n        return callback(err, null);\n      }\n      return callback(null, 'SUCCESS');\n    });\n    return undefined;\n  }\n\n  /**\n   * This is used by a user to resend a confirmation code\n   * @param {nodeCallback<string>} callback Called on success or error.\n   * @returns {void}\n   */\n  resendConfirmationCode(callback) {\n    const jsonReq = {\n      ClientId: this.pool.getClientId(),\n      Username: this.username,\n    };\n\n    this.client.request('ResendConfirmationCode', jsonReq, (err, result) => {\n      if (err) {\n        return callback(err, null);\n      }\n      return callback(null, result);\n    });\n  }\n\n  /**\n   * This is used to get a session, either from the session object\n   * or from  the local storage, or by using a refresh token\n   *\n   * @param {nodeCallback<CognitoUserSession>} callback Called on success or error.\n   * @returns {void}\n   */\n  getSession(callback) {\n    if (this.username == null) {\n      return callback(new Error('Username is null. Cannot retrieve a new session'), null);\n    }\n\n    if (this.signInUserSession != null && this.signInUserSession.isValid()) {\n      return callback(null, this.signInUserSession);\n    }\n\n    const keyPrefix = `CognitoIdentityServiceProvider.${this.pool.getClientId()}.${this.username}`;\n    const idTokenKey = `${keyPrefix}.idToken`;\n    const accessTokenKey = `${keyPrefix}.accessToken`;\n    const refreshTokenKey = `${keyPrefix}.refreshToken`;\n    const clockDriftKey = `${keyPrefix}.clockDrift`;\n\n    if (this.storage.getItem(idTokenKey)) {\n      const idToken = new CognitoIdToken({\n        IdToken: this.storage.getItem(idTokenKey),\n      });\n      const accessToken = new CognitoAccessToken({\n        AccessToken: this.storage.getItem(accessTokenKey),\n      });\n      const refreshToken = new CognitoRefreshToken({\n        RefreshToken: this.storage.getItem(refreshTokenKey),\n      });\n      const clockDrift = parseInt(this.storage.getItem(clockDriftKey), 0) || 0;\n\n      const sessionData = {\n        IdToken: idToken,\n        AccessToken: accessToken,\n        RefreshToken: refreshToken,\n        ClockDrift: clockDrift,\n      };\n      const cachedSession = new CognitoUserSession(sessionData);\n      if (cachedSession.isValid()) {\n        this.signInUserSession = cachedSession;\n        return callback(null, this.signInUserSession);\n      }\n\n      if (refreshToken.getToken() == null) {\n        return callback(new Error('Cannot retrieve a new session. Please authenticate.'), null);\n      }\n\n      this.refreshSession(refreshToken, callback);\n    } else {\n      callback(new Error('Local storage is missing an ID Token, Please authenticate'), null);\n    }\n\n    return undefined;\n  }\n\n\n  /**\n   * This uses the refreshToken to retrieve a new session\n   * @param {CognitoRefreshToken} refreshToken A previous session's refresh token.\n   * @param {nodeCallback<CognitoUserSession>} callback Called on success or error.\n   * @returns {void}\n   */\n  refreshSession(refreshToken, callback) {\n    const authParameters = {};\n    authParameters.REFRESH_TOKEN = refreshToken.getToken();\n    const keyPrefix = `CognitoIdentityServiceProvider.${this.pool.getClientId()}`;\n    const lastUserKey = `${keyPrefix}.LastAuthUser`;\n\n    if (this.storage.getItem(lastUserKey)) {\n      this.username = this.storage.getItem(lastUserKey);\n      const deviceKeyKey = `${keyPrefix}.${this.username}.deviceKey`;\n      this.deviceKey = this.storage.getItem(deviceKeyKey);\n      authParameters.DEVICE_KEY = this.deviceKey;\n    }\n\n    const jsonReq = {\n      ClientId: this.pool.getClientId(),\n      AuthFlow: 'REFRESH_TOKEN_AUTH',\n      AuthParameters: authParameters,\n    };\n    if (this.getUserContextData()) {\n      jsonReq.UserContextData = this.getUserContextData();\n    }\n    this.client.request('InitiateAuth', jsonReq, (err, authResult) => {\n      if (err) {\n        if (err.code === 'NotAuthorizedException') {\n          this.clearCachedTokens();\n        }\n        return callback(err, null);\n      }\n      if (authResult) {\n        const authenticationResult = authResult.AuthenticationResult;\n        if (!Object.prototype.hasOwnProperty.call(authenticationResult, 'RefreshToken')) {\n          authenticationResult.RefreshToken = refreshToken.getToken();\n        }\n        this.signInUserSession = this.getCognitoUserSession(authenticationResult);\n        this.cacheTokens();\n        return callback(null, this.signInUserSession);\n      }\n      return undefined;\n    });\n  }\n\n  /**\n   * This is used to save the session tokens to local storage\n   * @returns {void}\n   */\n  cacheTokens() {\n    const keyPrefix = `CognitoIdentityServiceProvider.${this.pool.getClientId()}`;\n    const idTokenKey = `${keyPrefix}.${this.username}.idToken`;\n    const accessTokenKey = `${keyPrefix}.${this.username}.accessToken`;\n    const refreshTokenKey = `${keyPrefix}.${this.username}.refreshToken`;\n    const clockDriftKey = `${keyPrefix}.${this.username}.clockDrift`;\n    const lastUserKey = `${keyPrefix}.LastAuthUser`;\n\n    this.storage.setItem(idTokenKey, this.signInUserSession.getIdToken().getJwtToken());\n    this.storage.setItem(accessTokenKey, this.signInUserSession.getAccessToken().getJwtToken());\n    this.storage.setItem(refreshTokenKey, this.signInUserSession.getRefreshToken().getToken());\n    this.storage.setItem(clockDriftKey, `${this.signInUserSession.getClockDrift()}`);\n    this.storage.setItem(lastUserKey, this.username);\n  }\n\n  /**\n   * This is used to cache the device key and device group and device password\n   * @returns {void}\n   */\n  cacheDeviceKeyAndPassword() {\n    const keyPrefix = `CognitoIdentityServiceProvider.${this.pool.getClientId()}.${this.username}`;\n    const deviceKeyKey = `${keyPrefix}.deviceKey`;\n    const randomPasswordKey = `${keyPrefix}.randomPasswordKey`;\n    const deviceGroupKeyKey = `${keyPrefix}.deviceGroupKey`;\n\n    this.storage.setItem(deviceKeyKey, this.deviceKey);\n    this.storage.setItem(randomPasswordKey, this.randomPassword);\n    this.storage.setItem(deviceGroupKeyKey, this.deviceGroupKey);\n  }\n\n  /**\n   * This is used to get current device key and device group and device password\n   * @returns {void}\n   */\n  getCachedDeviceKeyAndPassword() {\n    const keyPrefix = `CognitoIdentityServiceProvider.${this.pool.getClientId()}.${this.username}`;\n    const deviceKeyKey = `${keyPrefix}.deviceKey`;\n    const randomPasswordKey = `${keyPrefix}.randomPasswordKey`;\n    const deviceGroupKeyKey = `${keyPrefix}.deviceGroupKey`;\n\n    if (this.storage.getItem(deviceKeyKey)) {\n      this.deviceKey = this.storage.getItem(deviceKeyKey);\n      this.randomPassword = this.storage.getItem(randomPasswordKey);\n      this.deviceGroupKey = this.storage.getItem(deviceGroupKeyKey);\n    }\n  }\n\n  /**\n   * This is used to clear the device key info from local storage\n   * @returns {void}\n   */\n  clearCachedDeviceKeyAndPassword() {\n    const keyPrefix = `CognitoIdentityServiceProvider.${this.pool.getClientId()}.${this.username}`;\n    const deviceKeyKey = `${keyPrefix}.deviceKey`;\n    const randomPasswordKey = `${keyPrefix}.randomPasswordKey`;\n    const deviceGroupKeyKey = `${keyPrefix}.deviceGroupKey`;\n\n    this.storage.removeItem(deviceKeyKey);\n    this.storage.removeItem(randomPasswordKey);\n    this.storage.removeItem(deviceGroupKeyKey);\n  }\n\n  /**\n   * This is used to clear the session tokens from local storage\n   * @returns {void}\n   */\n  clearCachedTokens() {\n    const keyPrefix = `CognitoIdentityServiceProvider.${this.pool.getClientId()}`;\n    const idTokenKey = `${keyPrefix}.${this.username}.idToken`;\n    const accessTokenKey = `${keyPrefix}.${this.username}.accessToken`;\n    const refreshTokenKey = `${keyPrefix}.${this.username}.refreshToken`;\n    const lastUserKey = `${keyPrefix}.LastAuthUser`;\n\n    this.storage.removeItem(idTokenKey);\n    this.storage.removeItem(accessTokenKey);\n    this.storage.removeItem(refreshTokenKey);\n    this.storage.removeItem(lastUserKey);\n  }\n\n  /**\n   * This is used to build a user session from tokens retrieved in the authentication result\n   * @param {object} authResult Successful auth response from server.\n   * @returns {CognitoUserSession} The new user session.\n   * @private\n   */\n  getCognitoUserSession(authResult) {\n    const idToken = new CognitoIdToken(authResult);\n    const accessToken = new CognitoAccessToken(authResult);\n    const refreshToken = new CognitoRefreshToken(authResult);\n\n    const sessionData = {\n      IdToken: idToken,\n      AccessToken: accessToken,\n      RefreshToken: refreshToken,\n    };\n\n    return new CognitoUserSession(sessionData);\n  }\n\n  /**\n   * This is used to initiate a forgot password request\n   * @param {object} callback Result callback map.\n   * @param {onFailure} callback.onFailure Called on any error.\n   * @param {inputVerificationCode?} callback.inputVerificationCode\n   *    Optional callback raised instead of onSuccess with response data.\n   * @param {onSuccess} callback.onSuccess Called on success.\n   * @returns {void}\n   */\n  forgotPassword(callback) {\n    const jsonReq = {\n      ClientId: this.pool.getClientId(),\n      Username: this.username,\n    };\n    if (this.getUserContextData()) {\n      jsonReq.UserContextData = this.getUserContextData();\n    }\n    this.client.request('ForgotPassword', jsonReq, (err, data) => {\n      if (err) {\n        return callback.onFailure(err);\n      }\n      if (typeof callback.inputVerificationCode === 'function') {\n        return callback.inputVerificationCode(data);\n      }\n      return callback.onSuccess(data);\n    });\n  }\n\n  /**\n   * This is used to confirm a new password using a confirmationCode\n   * @param {string} confirmationCode Code entered by user.\n   * @param {string} newPassword Confirm new password.\n   * @param {object} callback Result callback map.\n   * @param {onFailure} callback.onFailure Called on any error.\n   * @param {onSuccess<void>} callback.onSuccess Called on success.\n   * @returns {void}\n   */\n  confirmPassword(confirmationCode, newPassword, callback) {\n    const jsonReq = {\n      ClientId: this.pool.getClientId(),\n      Username: this.username,\n      ConfirmationCode: confirmationCode,\n      Password: newPassword,\n    };\n    if (this.getUserContextData()) {\n      jsonReq.UserContextData = this.getUserContextData();\n    }\n    this.client.request('ConfirmForgotPassword', jsonReq, err => {\n      if (err) {\n        return callback.onFailure(err);\n      }\n      return callback.onSuccess();\n    });\n  }\n\n  /**\n   * This is used to initiate an attribute confirmation request\n   * @param {string} attributeName User attribute that needs confirmation.\n   * @param {object} callback Result callback map.\n   * @param {onFailure} callback.onFailure Called on any error.\n   * @param {inputVerificationCode} callback.inputVerificationCode Called on success.\n   * @returns {void}\n   */\n  getAttributeVerificationCode(attributeName, callback) {\n    if (this.signInUserSession == null || !this.signInUserSession.isValid()) {\n      return callback.onFailure(new Error('User is not authenticated'));\n    }\n\n    this.client.request('GetUserAttributeVerificationCode', {\n      AttributeName: attributeName,\n      AccessToken: this.signInUserSession.getAccessToken().getJwtToken(),\n    }, (err, data) => {\n      if (err) {\n        return callback.onFailure(err);\n      }\n      if (typeof callback.inputVerificationCode === 'function') {\n        return callback.inputVerificationCode(data);\n      }\n      return callback.onSuccess();\n    });\n    return undefined;\n  }\n\n  /**\n   * This is used to confirm an attribute using a confirmation code\n   * @param {string} attributeName Attribute being confirmed.\n   * @param {string} confirmationCode Code entered by user.\n   * @param {object} callback Result callback map.\n   * @param {onFailure} callback.onFailure Called on any error.\n   * @param {onSuccess<string>} callback.onSuccess Called on success.\n   * @returns {void}\n   */\n  verifyAttribute(attributeName, confirmationCode, callback) {\n    if (this.signInUserSession == null || !this.signInUserSession.isValid()) {\n      return callback.onFailure(new Error('User is not authenticated'));\n    }\n\n    this.client.request('VerifyUserAttribute', {\n      AttributeName: attributeName,\n      Code: confirmationCode,\n      AccessToken: this.signInUserSession.getAccessToken().getJwtToken(),\n    }, err => {\n      if (err) {\n        return callback.onFailure(err);\n      }\n      return callback.onSuccess('SUCCESS');\n    });\n    return undefined;\n  }\n\n  /**\n   * This is used to get the device information using the current device key\n   * @param {object} callback Result callback map.\n   * @param {onFailure} callback.onFailure Called on any error.\n   * @param {onSuccess<*>} callback.onSuccess Called on success with device data.\n   * @returns {void}\n   */\n  getDevice(callback) {\n    if (this.signInUserSession == null || !this.signInUserSession.isValid()) {\n      return callback.onFailure(new Error('User is not authenticated'));\n    }\n\n    this.client.request('GetDevice', {\n      AccessToken: this.signInUserSession.getAccessToken().getJwtToken(),\n      DeviceKey: this.deviceKey,\n    }, (err, data) => {\n      if (err) {\n        return callback.onFailure(err);\n      }\n      return callback.onSuccess(data);\n    });\n    return undefined;\n  }\n\n  /**\n   * This is used to forget a specific device\n   * @param {string} deviceKey Device key.\n   * @param {object} callback Result callback map.\n   * @param {onFailure} callback.onFailure Called on any error.\n   * @param {onSuccess<string>} callback.onSuccess Called on success.\n   * @returns {void}\n   */\n  forgetSpecificDevice(deviceKey, callback) {\n    if (this.signInUserSession == null || !this.signInUserSession.isValid()) {\n      return callback.onFailure(new Error('User is not authenticated'));\n    }\n\n    this.client.request('ForgetDevice', {\n      AccessToken: this.signInUserSession.getAccessToken().getJwtToken(),\n      DeviceKey: deviceKey,\n    }, err => {\n      if (err) {\n        return callback.onFailure(err);\n      }\n      return callback.onSuccess('SUCCESS');\n    });\n    return undefined;\n  }\n\n  /**\n   * This is used to forget the current device\n   * @param {object} callback Result callback map.\n   * @param {onFailure} callback.onFailure Called on any error.\n   * @param {onSuccess<string>} callback.onSuccess Called on success.\n   * @returns {void}\n   */\n  forgetDevice(callback) {\n    this.forgetSpecificDevice(this.deviceKey, {\n      onFailure: callback.onFailure,\n      onSuccess: result => {\n        this.deviceKey = null;\n        this.deviceGroupKey = null;\n        this.randomPassword = null;\n        this.clearCachedDeviceKeyAndPassword();\n        return callback.onSuccess(result);\n      },\n    });\n  }\n\n  /**\n   * This is used to set the device status as remembered\n   * @param {object} callback Result callback map.\n   * @param {onFailure} callback.onFailure Called on any error.\n   * @param {onSuccess<string>} callback.onSuccess Called on success.\n   * @returns {void}\n   */\n  setDeviceStatusRemembered(callback) {\n    if (this.signInUserSession == null || !this.signInUserSession.isValid()) {\n      return callback.onFailure(new Error('User is not authenticated'));\n    }\n\n    this.client.request('UpdateDeviceStatus', {\n      AccessToken: this.signInUserSession.getAccessToken().getJwtToken(),\n      DeviceKey: this.deviceKey,\n      DeviceRememberedStatus: 'remembered',\n    }, err => {\n      if (err) {\n        return callback.onFailure(err);\n      }\n      return callback.onSuccess('SUCCESS');\n    });\n    return undefined;\n  }\n\n  /**\n   * This is used to set the device status as not remembered\n   * @param {object} callback Result callback map.\n   * @param {onFailure} callback.onFailure Called on any error.\n   * @param {onSuccess<string>} callback.onSuccess Called on success.\n   * @returns {void}\n   */\n  setDeviceStatusNotRemembered(callback) {\n    if (this.signInUserSession == null || !this.signInUserSession.isValid()) {\n      return callback.onFailure(new Error('User is not authenticated'));\n    }\n\n    this.client.request('UpdateDeviceStatus', {\n      AccessToken: this.signInUserSession.getAccessToken().getJwtToken(),\n      DeviceKey: this.deviceKey,\n      DeviceRememberedStatus: 'not_remembered',\n    }, err => {\n      if (err) {\n        return callback.onFailure(err);\n      }\n      return callback.onSuccess('SUCCESS');\n    });\n    return undefined;\n  }\n\n  /**\n   * This is used to list all devices for a user\n   *\n   * @param {int} limit the number of devices returned in a call\n   * @param {string} paginationToken the pagination token in case any was returned before\n   * @param {object} callback Result callback map.\n   * @param {onFailure} callback.onFailure Called on any error.\n   * @param {onSuccess<*>} callback.onSuccess Called on success with device list.\n   * @returns {void}\n   */\n  listDevices(limit, paginationToken, callback) {\n    if (this.signInUserSession == null || !this.signInUserSession.isValid()) {\n      return callback.onFailure(new Error('User is not authenticated'));\n    }\n\n    this.client.request('ListDevices', {\n      AccessToken: this.signInUserSession.getAccessToken().getJwtToken(),\n      Limit: limit,\n      PaginationToken: paginationToken,\n    }, (err, data) => {\n      if (err) {\n        return callback.onFailure(err);\n      }\n      return callback.onSuccess(data);\n    });\n    return undefined;\n  }\n\n  /**\n   * This is used to globally revoke all tokens issued to a user\n   * @param {object} callback Result callback map.\n   * @param {onFailure} callback.onFailure Called on any error.\n   * @param {onSuccess<string>} callback.onSuccess Called on success.\n   * @returns {void}\n   */\n  globalSignOut(callback) {\n    if (this.signInUserSession == null || !this.signInUserSession.isValid()) {\n      return callback.onFailure(new Error('User is not authenticated'));\n    }\n\n    this.client.request('GlobalSignOut', {\n      AccessToken: this.signInUserSession.getAccessToken().getJwtToken(),\n    }, err => {\n      if (err) {\n        return callback.onFailure(err);\n      }\n      this.clearCachedTokens();\n      return callback.onSuccess('SUCCESS');\n    });\n    return undefined;\n  }\n\n  /**\n   * This is used for the user to signOut of the application and clear the cached tokens.\n   * @returns {void}\n   */\n  signOut() {\n    this.signInUserSession = null;\n    this.clearCachedTokens();\n  }\n\n  /**\n   * This is used by a user trying to select a given MFA\n   * @param {string} answerChallenge the mfa the user wants\n   * @param {nodeCallback<string>} callback Called on success or error.\n   * @returns {void}\n   */\n  sendMFASelectionAnswer(answerChallenge, callback) {\n    const challengeResponses = {};\n    challengeResponses.USERNAME = this.username;\n    challengeResponses.ANSWER = answerChallenge;\n\n    const jsonReq = {\n      ChallengeName: 'SELECT_MFA_TYPE',\n      ChallengeResponses: challengeResponses,\n      ClientId: this.pool.getClientId(),\n      Session: this.Session,\n    };\n    if (this.getUserContextData()) {\n      jsonReq.UserContextData = this.getUserContextData();\n    }\n    this.client.request('RespondToAuthChallenge', jsonReq, (err, data) => {\n      if (err) {\n        return callback.onFailure(err);\n      }\n      this.Session = data.Session;\n      if (answerChallenge === 'SMS_MFA') {\n        return callback.mfaRequired(data.challengeName, data.challengeParameters);\n      }\n      if (answerChallenge === 'SOFTWARE_TOKEN_MFA') {\n        return callback.totpRequired(data.challengeName, data.challengeParameters);\n      }\n      return undefined;\n    });\n  }\n\n  /**\n   * This returns the user context data for advanced security feature.\n   * @returns {void}\n   */\n  getUserContextData() {\n    const pool = this.pool;\n    return pool.getUserContextData(this.username);\n  }\n\n  /**\n   * This is used by an authenticated or a user trying to authenticate to associate a TOTP MFA\n   * @param {nodeCallback<string>} callback Called on success or error.\n   * @returns {void}\n   */\n  associateSoftwareToken(callback) {\n    if (!(this.signInUserSession != null && this.signInUserSession.isValid())) {\n      this.client.request('AssociateSoftwareToken', {\n        Session: this.Session,\n      }, (err, data) => {\n        if (err) {\n          return callback.onFailure(err);\n        }\n        this.Session = data.Session;\n        return callback.associateSecretCode(data.SecretCode);\n      });\n    } else {\n      this.client.request('AssociateSoftwareToken', {\n        AccessToken: this.signInUserSession.getAccessToken().getJwtToken(),\n      }, (err, data) => {\n        if (err) {\n          return callback.onFailure(err);\n        }\n        return callback.associateSecretCode(data.SecretCode);\n      });\n    }\n  }\n\n  /**\n   * This is used by an authenticated or a user trying to authenticate to verify a TOTP MFA\n   * @param {string} totpCode The MFA code entered by the user.\n   * @param {string} friendlyDeviceName The device name we are assigning to the device.\n   * @param {nodeCallback<string>} callback Called on success or error.\n   * @returns {void}\n   */\n  verifySoftwareToken(totpCode, friendlyDeviceName, callback) {\n    if (!(this.signInUserSession != null && this.signInUserSession.isValid())) {\n      this.client.request('VerifySoftwareToken', {\n        Session: this.Session,\n        UserCode: totpCode,\n        FriendlyDeviceName: friendlyDeviceName,\n      }, (err, data) => {\n        if (err) {\n          return callback.onFailure(err);\n        }\n        this.Session = data.Session;\n        const challengeResponses = {};\n        challengeResponses.USERNAME = this.username;\n        const jsonReq = {\n          ChallengeName: 'MFA_SETUP',\n          ClientId: this.pool.getClientId(),\n          ChallengeResponses: challengeResponses,\n          Session: this.Session,\n        };\n        if (this.getUserContextData()) {\n          jsonReq.UserContextData = this.getUserContextData();\n        }\n        this.client.request('RespondToAuthChallenge',\n            jsonReq, (errRespond, dataRespond) => {\n              if (errRespond) {\n                return callback.onFailure(errRespond);\n              }\n              this.signInUserSession = this.getCognitoUserSession(dataRespond.AuthenticationResult);\n              this.cacheTokens();\n              return callback.onSuccess(this.signInUserSession);\n            });\n        return undefined;\n      });\n    } else {\n      this.client.request('VerifySoftwareToken', {\n        AccessToken: this.signInUserSession.getAccessToken().getJwtToken(),\n        UserCode: totpCode,\n        FriendlyDeviceName: friendlyDeviceName,\n      }, (err, data) => {\n        if (err) {\n          return callback.onFailure(err);\n        }\n        return callback.onSuccess(data);\n      });\n    }\n  }\n}\n\n\n\n// WEBPACK FOOTER //\n// ./src/CognitoUser.js","/*!\n * Copyright 2016 Amazon.com,\n * Inc. or its affiliates. All Rights Reserved.\n *\n * Licensed under the Amazon Software License (the \"License\").\n * You may not use this file except in compliance with the\n * License. A copy of the License is located at\n *\n *     http://aws.amazon.com/asl/\n *\n * or in the \"license\" file accompanying this file. This file is\n * distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR\n * CONDITIONS OF ANY KIND, express or implied. See the License\n * for the specific language governing permissions and\n * limitations under the License.\n */\n\n/** @class */\nexport default class CognitoUserAttribute {\n  /**\n   * Constructs a new CognitoUserAttribute object\n   * @param {string=} Name The record's name\n   * @param {string=} Value The record's value\n   */\n  constructor({ Name, Value } = {}) {\n    this.Name = Name || '';\n    this.Value = Value || '';\n  }\n\n  /**\n   * @returns {string} the record's value.\n   */\n  getValue() {\n    return this.Value;\n  }\n\n  /**\n   * Sets the record's value.\n   * @param {string} value The new value.\n   * @returns {CognitoUserAttribute} The record for method chaining.\n   */\n  setValue(value) {\n    this.Value = value;\n    return this;\n  }\n\n  /**\n   * @returns {string} the record's name.\n   */\n  getName() {\n    return this.Name;\n  }\n\n  /**\n   * Sets the record's name\n   * @param {string} name The new name.\n   * @returns {CognitoUserAttribute} The record for method chaining.\n   */\n  setName(name) {\n    this.Name = name;\n    return this;\n  }\n\n  /**\n   * @returns {string} a string representation of the record.\n   */\n  toString() {\n    return JSON.stringify(this);\n  }\n\n  /**\n   * @returns {object} a flat object representing the record.\n   */\n  toJSON() {\n    return {\n      Name: this.Name,\n      Value: this.Value,\n    };\n  }\n}\n\n\n\n// WEBPACK FOOTER //\n// ./src/CognitoUserAttribute.js","/*!\n * Copyright 2016 Amazon.com,\n * Inc. or its affiliates. All Rights Reserved.\n *\n * Licensed under the Amazon Software License (the \"License\").\n * You may not use this file except in compliance with the\n * License. A copy of the License is located at\n *\n *     http://aws.amazon.com/asl/\n *\n * or in the \"license\" file accompanying this file. This file is\n * distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR\n * CONDITIONS OF ANY KIND, express or implied. See the License\n * for the specific language governing permissions and\n * limitations under the License.\n */\n\n/** @class */\nexport default class CognitoUserSession {\n  /**\n   * Constructs a new CognitoUserSession object\n   * @param {CognitoIdToken} IdToken The session's Id token.\n   * @param {CognitoRefreshToken=} RefreshToken The session's refresh token.\n   * @param {CognitoAccessToken} AccessToken The session's access token.\n   * @param {int} ClockDrift The saved computer's clock drift or undefined to force calculation.\n   */\n  constructor({ IdToken, RefreshToken, AccessToken, ClockDrift } = {}) {\n    if (AccessToken == null || IdToken == null) {\n      throw new Error('Id token and Access Token must be present.');\n    }\n\n    this.idToken = IdToken;\n    this.refreshToken = RefreshToken;\n    this.accessToken = AccessToken;\n    this.clockDrift = ClockDrift === undefined ? this.calculateClockDrift() : ClockDrift;\n  }\n\n  /**\n   * @returns {CognitoIdToken} the session's Id token\n   */\n  getIdToken() {\n    return this.idToken;\n  }\n\n  /**\n   * @returns {CognitoRefreshToken} the session's refresh token\n   */\n  getRefreshToken() {\n    return this.refreshToken;\n  }\n\n  /**\n   * @returns {CognitoAccessToken} the session's access token\n   */\n  getAccessToken() {\n    return this.accessToken;\n  }\n\n  /**\n   * @returns {int} the session's clock drift\n   */\n  getClockDrift() {\n    return this.clockDrift;\n  }\n\n  /**\n   * @returns {int} the computer's clock drift\n   */\n  calculateClockDrift() {\n    const now = Math.floor(new Date() / 1000);\n    const iat = Math.min(this.accessToken.getIssuedAt(), this.idToken.getIssuedAt());\n\n    return now - iat;\n  }\n\n  /**\n   * Checks to see if the session is still valid based on session expiry information found\n   * in tokens and the current time (adjusted with clock drift)\n   * @returns {boolean} if the session is still valid\n   */\n  isValid() {\n    const now = Math.floor(new Date() / 1000);\n    const adjusted = now - this.clockDrift;\n\n    return adjusted < this.accessToken.getExpiration() && adjusted < this.idToken.getExpiration();\n  }\n}\n\n\n\n// WEBPACK FOOTER //\n// ./src/CognitoUserSession.js","/*!\n * Copyright 2016 Amazon.com,\n * Inc. or its affiliates. All Rights Reserved.\n *\n * Licensed under the Amazon Software License (the \"License\").\n * You may not use this file except in compliance with the\n * License. A copy of the License is located at\n *\n *     http://aws.amazon.com/asl/\n *\n * or in the \"license\" file accompanying this file. This file is\n * distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR\n * CONDITIONS OF ANY KIND, express or implied. See the License\n * for the specific language governing permissions and\n * limitations under the License.\n */\n\nconst monthNames =\n  ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];\nconst weekNames = ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'];\n\n/** @class */\nexport default class DateHelper {\n  /**\n   * @returns {string} The current time in \"ddd MMM D HH:mm:ss UTC YYYY\" format.\n   */\n  getNowString() {\n    const now = new Date();\n\n    const weekDay = weekNames[now.getUTCDay()];\n    const month = monthNames[now.getUTCMonth()];\n    const day = now.getUTCDate();\n\n    let hours = now.getUTCHours();\n    if (hours < 10) {\n      hours = `0${hours}`;\n    }\n\n    let minutes = now.getUTCMinutes();\n    if (minutes < 10) {\n      minutes = `0${minutes}`;\n    }\n\n    let seconds = now.getUTCSeconds();\n    if (seconds < 10) {\n      seconds = `0${seconds}`;\n    }\n\n    const year = now.getUTCFullYear();\n\n    // ddd MMM D HH:mm:ss UTC YYYY\n    const dateNow = `${weekDay} ${month} ${day} ${hours}:${minutes}:${seconds} UTC ${year}`;\n\n    return dateNow;\n  }\n}\n\n\n\n// WEBPACK FOOTER //\n// ./src/DateHelper.js","/*!\n * Copyright 2016 Amazon.com,\n * Inc. or its affiliates. All Rights Reserved.\n *\n * Licensed under the Amazon Software License (the \"License\").\n * You may not use this file except in compliance with the\n * License. A copy of the License is located at\n *\n *     http://aws.amazon.com/asl/\n *\n * or in the \"license\" file accompanying this file. This file is\n * distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR\n * CONDITIONS OF ANY KIND, express or implied. See the License\n * for the specific language governing permissions and\n * limitations under the License.\n */\n\nlet dataMemory = {};\n\n/** @class */\nclass MemoryStorage {\n\n  /**\n   * This is used to set a specific item in storage\n   * @param {string} key - the key for the item\n   * @param {object} value - the value\n   * @returns {string} value that was set\n   */\n  static setItem(key, value) {\n    dataMemory[key] = value;\n    return dataMemory[key];\n  }\n\n  /**\n   * This is used to get a specific key from storage\n   * @param {string} key - the key for the item\n   * This is used to clear the storage\n   * @returns {string} the data item\n   */\n  static getItem(key) {\n    return Object.prototype.hasOwnProperty.call(dataMemory, key) ? dataMemory[key] : undefined;\n  }\n\n  /**\n   * This is used to remove an item from storage\n   * @param {string} key - the key being set\n   * @returns {string} value - value that was deleted\n   */\n  static removeItem(key) {\n    return delete dataMemory[key];\n  }\n\n  /**\n   * This is used to clear the storage\n   * @returns {string} nothing\n   */\n  static clear() {\n    dataMemory = {};\n    return dataMemory;\n  }\n}\n\n/** @class */\nexport default class StorageHelper {\n\n  /**\n   * This is used to get a storage object\n   * @returns {object} the storage\n   */\n  constructor() {\n    try {\n      this.storageWindow = window.localStorage;\n      this.storageWindow.setItem('aws.cognito.test-ls', 1);\n      this.storageWindow.removeItem('aws.cognito.test-ls');\n    } catch (exception) {\n      this.storageWindow = MemoryStorage;\n    }\n  }\n\n  /**\n   * This is used to return the storage\n   * @returns {object} the storage\n   */\n  getStorage() {\n    return this.storageWindow;\n  }\n}\n\n\n\n// WEBPACK FOOTER //\n// ./src/StorageHelper.js","var Buffer = require('buffer').Buffer\nvar sha = require('./sha')\nvar sha256 = require('./sha256')\nvar rng = require('./rng')\nvar md5 = require('./md5')\n\nvar algorithms = {\n  sha1: sha,\n  sha256: sha256,\n  md5: md5\n}\n\nvar blocksize = 64\nvar zeroBuffer = new Buffer(blocksize); zeroBuffer.fill(0)\nfunction hmac(fn, key, data) {\n  if(!Buffer.isBuffer(key)) key = new Buffer(key)\n  if(!Buffer.isBuffer(data)) data = new Buffer(data)\n\n  if(key.length > blocksize) {\n    key = fn(key)\n  } else if(key.length < blocksize) {\n    key = Buffer.concat([key, zeroBuffer], blocksize)\n  }\n\n  var ipad = new Buffer(blocksize), opad = new Buffer(blocksize)\n  for(var i = 0; i < blocksize; i++) {\n    ipad[i] = key[i] ^ 0x36\n    opad[i] = key[i] ^ 0x5C\n  }\n\n  var hash = fn(Buffer.concat([ipad, data]))\n  return fn(Buffer.concat([opad, hash]))\n}\n\nfunction hash(alg, key) {\n  alg = alg || 'sha1'\n  var fn = algorithms[alg]\n  var bufs = []\n  var length = 0\n  if(!fn) error('algorithm:', alg, 'is not yet supported')\n  return {\n    update: function (data) {\n      if(!Buffer.isBuffer(data)) data = new Buffer(data)\n        \n      bufs.push(data)\n      length += data.length\n      return this\n    },\n    digest: function (enc) {\n      var buf = Buffer.concat(bufs)\n      var r = key ? hmac(fn, key, buf) : fn(buf)\n      bufs = null\n      return enc ? r.toString(enc) : r\n    }\n  }\n}\n\nfunction error () {\n  var m = [].slice.call(arguments).join(' ')\n  throw new Error([\n    m,\n    'we accept pull requests',\n    'http://github.com/dominictarr/crypto-browserify'\n    ].join('\\n'))\n}\n\nexports.createHash = function (alg) { return hash(alg) }\nexports.createHmac = function (alg, key) { return hash(alg, key) }\nexports.randomBytes = function(size, callback) {\n  if (callback && callback.call) {\n    try {\n      callback.call(this, undefined, new Buffer(rng(size)))\n    } catch (err) { callback(err) }\n  } else {\n    return new Buffer(rng(size))\n  }\n}\n\nfunction each(a, f) {\n  for(var i in a)\n    f(a[i], i)\n}\n\n// the least I can do is make error messages for the rest of the node.js/crypto api.\neach(['createCredentials'\n, 'createCipher'\n, 'createCipheriv'\n, 'createDecipher'\n, 'createDecipheriv'\n, 'createSign'\n, 'createVerify'\n, 'createDiffieHellman'\n, 'pbkdf2'], function (name) {\n  exports[name] = function () {\n    error('sorry,', name, 'is not implemented yet')\n  }\n})\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/crypto-browserify/index.js\n// module id = 14\n// module chunks = 0","'use strict'\n\nexports.byteLength = byteLength\nexports.toByteArray = toByteArray\nexports.fromByteArray = fromByteArray\n\nvar lookup = []\nvar revLookup = []\nvar Arr = typeof Uint8Array !== 'undefined' ? Uint8Array : Array\n\nvar code = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'\nfor (var i = 0, len = code.length; i < len; ++i) {\n  lookup[i] = code[i]\n  revLookup[code.charCodeAt(i)] = i\n}\n\n// Support decoding URL-safe base64 strings, as Node.js does.\n// See: https://en.wikipedia.org/wiki/Base64#URL_applications\nrevLookup['-'.charCodeAt(0)] = 62\nrevLookup['_'.charCodeAt(0)] = 63\n\nfunction getLens (b64) {\n  var len = b64.length\n\n  if (len % 4 > 0) {\n    throw new Error('Invalid string. Length must be a multiple of 4')\n  }\n\n  // Trim off extra bytes after placeholder bytes are found\n  // See: https://github.com/beatgammit/base64-js/issues/42\n  var validLen = b64.indexOf('=')\n  if (validLen === -1) validLen = len\n\n  var placeHoldersLen = validLen === len\n    ? 0\n    : 4 - (validLen % 4)\n\n  return [validLen, placeHoldersLen]\n}\n\n// base64 is 4/3 + up to two characters of the original data\nfunction byteLength (b64) {\n  var lens = getLens(b64)\n  var validLen = lens[0]\n  var placeHoldersLen = lens[1]\n  return ((validLen + placeHoldersLen) * 3 / 4) - placeHoldersLen\n}\n\nfunction _byteLength (b64, validLen, placeHoldersLen) {\n  return ((validLen + placeHoldersLen) * 3 / 4) - placeHoldersLen\n}\n\nfunction toByteArray (b64) {\n  var tmp\n  var lens = getLens(b64)\n  var validLen = lens[0]\n  var placeHoldersLen = lens[1]\n\n  var arr = new Arr(_byteLength(b64, validLen, placeHoldersLen))\n\n  var curByte = 0\n\n  // if there are placeholders, only get up to the last complete 4 chars\n  var len = placeHoldersLen > 0\n    ? validLen - 4\n    : validLen\n\n  for (var i = 0; i < len; i += 4) {\n    tmp =\n      (revLookup[b64.charCodeAt(i)] << 18) |\n      (revLookup[b64.charCodeAt(i + 1)] << 12) |\n      (revLookup[b64.charCodeAt(i + 2)] << 6) |\n      revLookup[b64.charCodeAt(i + 3)]\n    arr[curByte++] = (tmp >> 16) & 0xFF\n    arr[curByte++] = (tmp >> 8) & 0xFF\n    arr[curByte++] = tmp & 0xFF\n  }\n\n  if (placeHoldersLen === 2) {\n    tmp =\n      (revLookup[b64.charCodeAt(i)] << 2) |\n      (revLookup[b64.charCodeAt(i + 1)] >> 4)\n    arr[curByte++] = tmp & 0xFF\n  }\n\n  if (placeHoldersLen === 1) {\n    tmp =\n      (revLookup[b64.charCodeAt(i)] << 10) |\n      (revLookup[b64.charCodeAt(i + 1)] << 4) |\n      (revLookup[b64.charCodeAt(i + 2)] >> 2)\n    arr[curByte++] = (tmp >> 8) & 0xFF\n    arr[curByte++] = tmp & 0xFF\n  }\n\n  return arr\n}\n\nfunction tripletToBase64 (num) {\n  return lookup[num >> 18 & 0x3F] +\n    lookup[num >> 12 & 0x3F] +\n    lookup[num >> 6 & 0x3F] +\n    lookup[num & 0x3F]\n}\n\nfunction encodeChunk (uint8, start, end) {\n  var tmp\n  var output = []\n  for (var i = start; i < end; i += 3) {\n    tmp =\n      ((uint8[i] << 16) & 0xFF0000) +\n      ((uint8[i + 1] << 8) & 0xFF00) +\n      (uint8[i + 2] & 0xFF)\n    output.push(tripletToBase64(tmp))\n  }\n  return output.join('')\n}\n\nfunction fromByteArray (uint8) {\n  var tmp\n  var len = uint8.length\n  var extraBytes = len % 3 // if we have 1 byte left, pad 2 bytes\n  var parts = []\n  var maxChunkLength = 16383 // must be multiple of 3\n\n  // go through the array every three bytes, we'll deal with trailing stuff later\n  for (var i = 0, len2 = len - extraBytes; i < len2; i += maxChunkLength) {\n    parts.push(encodeChunk(\n      uint8, i, (i + maxChunkLength) > len2 ? len2 : (i + maxChunkLength)\n    ))\n  }\n\n  // pad the end with zeros, but make sure to not forget the extra bytes\n  if (extraBytes === 1) {\n    tmp = uint8[len - 1]\n    parts.push(\n      lookup[tmp >> 2] +\n      lookup[(tmp << 4) & 0x3F] +\n      '=='\n    )\n  } else if (extraBytes === 2) {\n    tmp = (uint8[len - 2] << 8) + uint8[len - 1]\n    parts.push(\n      lookup[tmp >> 10] +\n      lookup[(tmp >> 4) & 0x3F] +\n      lookup[(tmp << 2) & 0x3F] +\n      '='\n    )\n  }\n\n  return parts.join('')\n}\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// /Users/dnnoyes/release-repo/~/base64-js/index.js\n// module id = 15\n// module chunks = 0","exports.read = function (buffer, offset, isLE, mLen, nBytes) {\n  var e, m\n  var eLen = (nBytes * 8) - mLen - 1\n  var eMax = (1 << eLen) - 1\n  var eBias = eMax >> 1\n  var nBits = -7\n  var i = isLE ? (nBytes - 1) : 0\n  var d = isLE ? -1 : 1\n  var s = buffer[offset + i]\n\n  i += d\n\n  e = s & ((1 << (-nBits)) - 1)\n  s >>= (-nBits)\n  nBits += eLen\n  for (; nBits > 0; e = (e * 256) + buffer[offset + i], i += d, nBits -= 8) {}\n\n  m = e & ((1 << (-nBits)) - 1)\n  e >>= (-nBits)\n  nBits += mLen\n  for (; nBits > 0; m = (m * 256) + buffer[offset + i], i += d, nBits -= 8) {}\n\n  if (e === 0) {\n    e = 1 - eBias\n  } else if (e === eMax) {\n    return m ? NaN : ((s ? -1 : 1) * Infinity)\n  } else {\n    m = m + Math.pow(2, mLen)\n    e = e - eBias\n  }\n  return (s ? -1 : 1) * m * Math.pow(2, e - mLen)\n}\n\nexports.write = function (buffer, value, offset, isLE, mLen, nBytes) {\n  var e, m, c\n  var eLen = (nBytes * 8) - mLen - 1\n  var eMax = (1 << eLen) - 1\n  var eBias = eMax >> 1\n  var rt = (mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0)\n  var i = isLE ? 0 : (nBytes - 1)\n  var d = isLE ? 1 : -1\n  var s = value < 0 || (value === 0 && 1 / value < 0) ? 1 : 0\n\n  value = Math.abs(value)\n\n  if (isNaN(value) || value === Infinity) {\n    m = isNaN(value) ? 1 : 0\n    e = eMax\n  } else {\n    e = Math.floor(Math.log(value) / Math.LN2)\n    if (value * (c = Math.pow(2, -e)) < 1) {\n      e--\n      c *= 2\n    }\n    if (e + eBias >= 1) {\n      value += rt / c\n    } else {\n      value += rt * Math.pow(2, 1 - eBias)\n    }\n    if (value * c >= 2) {\n      e++\n      c /= 2\n    }\n\n    if (e + eBias >= eMax) {\n      m = 0\n      e = eMax\n    } else if (e + eBias >= 1) {\n      m = ((value * c) - 1) * Math.pow(2, mLen)\n      e = e + eBias\n    } else {\n      m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen)\n      e = 0\n    }\n  }\n\n  for (; mLen >= 8; buffer[offset + i] = m & 0xff, i += d, m /= 256, mLen -= 8) {}\n\n  e = (e << mLen) | m\n  eLen += mLen\n  for (; eLen > 0; buffer[offset + i] = e & 0xff, i += d, e /= 256, eLen -= 8) {}\n\n  buffer[offset + i - d] |= s * 128\n}\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// /Users/dnnoyes/release-repo/~/ieee754/index.js\n// module id = 16\n// module chunks = 0","var toString = {}.toString;\n\nmodule.exports = Array.isArray || function (arr) {\n  return toString.call(arr) == '[object Array]';\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// /Users/dnnoyes/release-repo/~/isarray/index.js\n// module id = 17\n// module chunks = 0","/*!\n * JavaScript Cookie v2.2.0\n * https://github.com/js-cookie/js-cookie\n *\n * Copyright 2006, 2015 Klaus Hartl & Fagner Brack\n * Released under the MIT license\n */\n;(function (factory) {\n\tvar registeredInModuleLoader = false;\n\tif (typeof define === 'function' && define.amd) {\n\t\tdefine(factory);\n\t\tregisteredInModuleLoader = true;\n\t}\n\tif (typeof exports === 'object') {\n\t\tmodule.exports = factory();\n\t\tregisteredInModuleLoader = true;\n\t}\n\tif (!registeredInModuleLoader) {\n\t\tvar OldCookies = window.Cookies;\n\t\tvar api = window.Cookies = factory();\n\t\tapi.noConflict = function () {\n\t\t\twindow.Cookies = OldCookies;\n\t\t\treturn api;\n\t\t};\n\t}\n}(function () {\n\tfunction extend () {\n\t\tvar i = 0;\n\t\tvar result = {};\n\t\tfor (; i < arguments.length; i++) {\n\t\t\tvar attributes = arguments[ i ];\n\t\t\tfor (var key in attributes) {\n\t\t\t\tresult[key] = attributes[key];\n\t\t\t}\n\t\t}\n\t\treturn result;\n\t}\n\n\tfunction init (converter) {\n\t\tfunction api (key, value, attributes) {\n\t\t\tvar result;\n\t\t\tif (typeof document === 'undefined') {\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t\t// Write\n\n\t\t\tif (arguments.length > 1) {\n\t\t\t\tattributes = extend({\n\t\t\t\t\tpath: '/'\n\t\t\t\t}, api.defaults, attributes);\n\n\t\t\t\tif (typeof attributes.expires === 'number') {\n\t\t\t\t\tvar expires = new Date();\n\t\t\t\t\texpires.setMilliseconds(expires.getMilliseconds() + attributes.expires * 864e+5);\n\t\t\t\t\tattributes.expires = expires;\n\t\t\t\t}\n\n\t\t\t\t// We're using \"expires\" because \"max-age\" is not supported by IE\n\t\t\t\tattributes.expires = attributes.expires ? attributes.expires.toUTCString() : '';\n\n\t\t\t\ttry {\n\t\t\t\t\tresult = JSON.stringify(value);\n\t\t\t\t\tif (/^[\\{\\[]/.test(result)) {\n\t\t\t\t\t\tvalue = result;\n\t\t\t\t\t}\n\t\t\t\t} catch (e) {}\n\n\t\t\t\tif (!converter.write) {\n\t\t\t\t\tvalue = encodeURIComponent(String(value))\n\t\t\t\t\t\t.replace(/%(23|24|26|2B|3A|3C|3E|3D|2F|3F|40|5B|5D|5E|60|7B|7D|7C)/g, decodeURIComponent);\n\t\t\t\t} else {\n\t\t\t\t\tvalue = converter.write(value, key);\n\t\t\t\t}\n\n\t\t\t\tkey = encodeURIComponent(String(key));\n\t\t\t\tkey = key.replace(/%(23|24|26|2B|5E|60|7C)/g, decodeURIComponent);\n\t\t\t\tkey = key.replace(/[\\(\\)]/g, escape);\n\n\t\t\t\tvar stringifiedAttributes = '';\n\n\t\t\t\tfor (var attributeName in attributes) {\n\t\t\t\t\tif (!attributes[attributeName]) {\n\t\t\t\t\t\tcontinue;\n\t\t\t\t\t}\n\t\t\t\t\tstringifiedAttributes += '; ' + attributeName;\n\t\t\t\t\tif (attributes[attributeName] === true) {\n\t\t\t\t\t\tcontinue;\n\t\t\t\t\t}\n\t\t\t\t\tstringifiedAttributes += '=' + attributes[attributeName];\n\t\t\t\t}\n\t\t\t\treturn (document.cookie = key + '=' + value + stringifiedAttributes);\n\t\t\t}\n\n\t\t\t// Read\n\n\t\t\tif (!key) {\n\t\t\t\tresult = {};\n\t\t\t}\n\n\t\t\t// To prevent the for loop in the first place assign an empty array\n\t\t\t// in case there are no cookies at all. Also prevents odd result when\n\t\t\t// calling \"get()\"\n\t\t\tvar cookies = document.cookie ? document.cookie.split('; ') : [];\n\t\t\tvar rdecode = /(%[0-9A-Z]{2})+/g;\n\t\t\tvar i = 0;\n\n\t\t\tfor (; i < cookies.length; i++) {\n\t\t\t\tvar parts = cookies[i].split('=');\n\t\t\t\tvar cookie = parts.slice(1).join('=');\n\n\t\t\t\tif (!this.json && cookie.charAt(0) === '\"') {\n\t\t\t\t\tcookie = cookie.slice(1, -1);\n\t\t\t\t}\n\n\t\t\t\ttry {\n\t\t\t\t\tvar name = parts[0].replace(rdecode, decodeURIComponent);\n\t\t\t\t\tcookie = converter.read ?\n\t\t\t\t\t\tconverter.read(cookie, name) : converter(cookie, name) ||\n\t\t\t\t\t\tcookie.replace(rdecode, decodeURIComponent);\n\n\t\t\t\t\tif (this.json) {\n\t\t\t\t\t\ttry {\n\t\t\t\t\t\t\tcookie = JSON.parse(cookie);\n\t\t\t\t\t\t} catch (e) {}\n\t\t\t\t\t}\n\n\t\t\t\t\tif (key === name) {\n\t\t\t\t\t\tresult = cookie;\n\t\t\t\t\t\tbreak;\n\t\t\t\t\t}\n\n\t\t\t\t\tif (!key) {\n\t\t\t\t\t\tresult[name] = cookie;\n\t\t\t\t\t}\n\t\t\t\t} catch (e) {}\n\t\t\t}\n\n\t\t\treturn result;\n\t\t}\n\n\t\tapi.set = api;\n\t\tapi.get = function (key) {\n\t\t\treturn api.call(api, key);\n\t\t};\n\t\tapi.getJSON = function () {\n\t\t\treturn api.apply({\n\t\t\t\tjson: true\n\t\t\t}, [].slice.call(arguments));\n\t\t};\n\t\tapi.defaults = {};\n\n\t\tapi.remove = function (key, attributes) {\n\t\t\tapi(key, '', extend(attributes, {\n\t\t\t\texpires: -1\n\t\t\t}));\n\t\t};\n\n\t\tapi.withConverter = init;\n\n\t\treturn api;\n\t}\n\n\treturn init(function () {});\n}));\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// /Users/dnnoyes/release-repo/~/js-cookie/src/js.cookie.js\n// module id = 18\n// module chunks = 0","/*!\n * Copyright 2016 Amazon.com,\n * Inc. or its affiliates. All Rights Reserved.\n *\n * Licensed under the Amazon Software License (the \"License\").\n * You may not use this file except in compliance with the\n * License. A copy of the License is located at\n *\n *     http://aws.amazon.com/asl/\n *\n * or in the \"license\" file accompanying this file. This file is\n * distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR\n * CONDITIONS OF ANY KIND, express or implied. See the License\n * for the specific language governing permissions and\n * limitations under the License.\n */\n\n/** @class */\nexport default class AuthenticationDetails {\n  /**\n   * Constructs a new AuthenticationDetails object\n   * @param {object=} data Creation options.\n   * @param {string} data.Username User being authenticated.\n   * @param {string} data.Password Plain-text password to authenticate with.\n   * @param {(AttributeArg[])?} data.ValidationData Application extra metadata.\n   * @param {(AttributeArg[])?} data.AuthParamaters Authentication paramaters for custom auth.\n   */\n  constructor(data) {\n    const { ValidationData, Username, Password, AuthParameters } = data || {};\n    this.validationData = ValidationData || {};\n    this.authParameters = AuthParameters || {};\n    this.username = Username;\n    this.password = Password;\n  }\n\n  /**\n   * @returns {string} the record's username\n   */\n  getUsername() {\n    return this.username;\n  }\n\n  /**\n   * @returns {string} the record's password\n   */\n  getPassword() {\n    return this.password;\n  }\n\n  /**\n   * @returns {Array} the record's validationData\n   */\n  getValidationData() {\n    return this.validationData;\n  }\n\n  /**\n   * @returns {Array} the record's authParameters\n   */\n  getAuthParameters() {\n    return this.authParameters;\n  }\n}\n\n\n\n// WEBPACK FOOTER //\n// ./src/AuthenticationDetails.js","import UserAgent from './UserAgent';\n/** @class */\nexport default class Client {\n  /**\n   * Constructs a new AWS Cognito Identity Provider client object\n   * @param {string} region AWS region\n   * @param {string} endpoint endpoint\n   */\n  constructor(region, endpoint) {\n    this.endpoint = endpoint || `https://cognito-idp.${region}.amazonaws.com/`;\n    this.userAgent = UserAgent.prototype.userAgent || 'aws-amplify/0.1.x js';\n  }\n\n  /**\n   * Makes an unauthenticated request on AWS Cognito Identity Provider API\n   * using fetch\n   * @param {string} operation API operation\n   * @param {object} params Input parameters\n   * @param {function} callback Callback called when a response is returned\n   * @returns {void}\n  */\n  request(operation, params, callback) {\n    const headers = {\n      'Content-Type': 'application/x-amz-json-1.1',\n      'X-Amz-Target': `AWSCognitoIdentityProviderService.${operation}`,\n      'X-Amz-User-Agent': this.userAgent,\n    };\n\n    const options = {\n      headers,\n      method: 'POST',\n      mode: 'cors',\n      cache: 'no-cache',\n      body: JSON.stringify(params),\n    };\n\n    let response;\n\n    fetch(this.endpoint, options)\n      .then(resp => {\n        response = resp;\n        return resp;\n      }, err => {\n        // If error happens here, the request failed\n        // if it is TypeError throw network error\n        if (err instanceof TypeError) {\n          throw new Error('Network error');\n        }\n        throw err;\n      })\n      .then(resp => resp.json().catch(() => ({})))\n      .then(data => {\n        if (response.ok) return callback(null, data);\n\n        // Taken from aws-sdk-js/lib/protocol/json.js\n        // eslint-disable-next-line no-underscore-dangle\n        const code = (data.__type || data.code).split('#').pop();\n        const error = {\n          code,\n          name: code,\n          message: (data.message || data.Message || null),\n        };\n        return callback(error);\n      })\n      .catch(err => {\n        // default to return 'UnknownError'\n        let error = { code: 'UnknownError', message: 'Unkown error' };\n\n        // first check if we have a service error\n        if (response && response.headers && response.headers.get('x-amzn-errortype')) {\n          try {\n            const code = (response.headers.get('x-amzn-errortype')).split(':')[0];\n            error = {\n              code,\n              name: code,\n              statusCode: response.status,\n              message: (response.status) ? response.status.toString() : null,\n            };\n          } catch (ex) {\n              // pass through so it doesn't get swallowed if we can't parse it\n              error = {\n                code: 'UnknownError',\n                message: response.headers.get('x-amzn-errortype'),\n              }\n              return callback(error);\n          }\n        // otherwise check if error is Network error\n        } else if (err instanceof Error && err.message === 'Network error') {\n          error = {\n            code: 'NetworkError',\n            name: err.name,\n            message: err.message,\n          };\n        }\n        return callback(error);\n      });\n  }\n}\n\n\n\n// WEBPACK FOOTER //\n// ./src/Client.js","/*!\n * Copyright 2016 Amazon.com,\n * Inc. or its affiliates. All Rights Reserved.\n *\n * Licensed under the Amazon Software License (the \"License\").\n * You may not use this file except in compliance with the\n * License. A copy of the License is located at\n *\n *     http://aws.amazon.com/asl/\n *\n * or in the \"license\" file accompanying this file. This file is\n * distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR\n * CONDITIONS OF ANY KIND, express or implied. See the License\n * for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport Client from './Client';\nimport CognitoUser from './CognitoUser';\nimport StorageHelper from './StorageHelper';\n\n/** @class */\nexport default class CognitoUserPool {\n  /**\n   * Constructs a new CognitoUserPool object\n   * @param {object} data Creation options.\n   * @param {string} data.UserPoolId Cognito user pool id.\n   * @param {string} data.ClientId User pool application client id.\n   * @param {object} data.Storage Optional storage object.\n   * @param {boolean} data.AdvancedSecurityDataCollectionFlag Optional:\n   *        boolean flag indicating if the data collection is enabled\n   *        to support cognito advanced security features. By default, this\n   *        flag is set to true.\n   */\n  constructor(data) {\n    const { UserPoolId, ClientId, endpoint, AdvancedSecurityDataCollectionFlag } = data || {};\n    if (!UserPoolId || !ClientId) {\n      throw new Error('Both UserPoolId and ClientId are required.');\n    }\n    if (!/^[\\w-]+_.+$/.test(UserPoolId)) {\n      throw new Error('Invalid UserPoolId format.');\n    }\n    const region = UserPoolId.split('_')[0];\n\n    this.userPoolId = UserPoolId;\n    this.clientId = ClientId;\n\n    this.client = new Client(region, endpoint);\n\n    /**\n     * By default, AdvancedSecurityDataCollectionFlag is set to true,\n     * if no input value is provided.\n     */\n    this.advancedSecurityDataCollectionFlag = AdvancedSecurityDataCollectionFlag !== false;\n\n    this.storage = data.Storage || new StorageHelper().getStorage();\n  }\n\n  /**\n   * @returns {string} the user pool id\n   */\n  getUserPoolId() {\n    return this.userPoolId;\n  }\n\n  /**\n   * @returns {string} the client id\n   */\n  getClientId() {\n    return this.clientId;\n  }\n\n  /**\n   * @typedef {object} SignUpResult\n   * @property {CognitoUser} user New user.\n   * @property {bool} userConfirmed If the user is already confirmed.\n   */\n  /**\n   * method for signing up a user\n   * @param {string} username User's username.\n   * @param {string} password Plain-text initial password entered by user.\n   * @param {(AttributeArg[])=} userAttributes New user attributes.\n   * @param {(AttributeArg[])=} validationData Application metadata.\n   * @param {nodeCallback<SignUpResult>} callback Called on error or with the new user.\n   * @returns {void}\n   */\n  signUp(username, password, userAttributes, validationData, callback) {\n    const jsonReq = {\n      ClientId: this.clientId,\n      Username: username,\n      Password: password,\n      UserAttributes: userAttributes,\n      ValidationData: validationData,\n    };\n    if (this.getUserContextData(username)) {\n      jsonReq.UserContextData = this.getUserContextData(username);\n    }\n    this.client.request('SignUp', jsonReq, (err, data) => {\n      if (err) {\n        return callback(err, null);\n      }\n\n      const cognitoUser = {\n        Username: username,\n        Pool: this,\n        Storage: this.storage,\n      };\n\n      const returnData = {\n        user: new CognitoUser(cognitoUser),\n        userConfirmed: data.UserConfirmed,\n        userSub: data.UserSub,\n      };\n\n      return callback(null, returnData);\n    });\n  }\n\n\n  /**\n   * method for getting the current user of the application from the local storage\n   *\n   * @returns {CognitoUser} the user retrieved from storage\n   */\n  getCurrentUser() {\n    const lastUserKey = `CognitoIdentityServiceProvider.${this.clientId}.LastAuthUser`;\n\n    const lastAuthUser = this.storage.getItem(lastUserKey);\n    if (lastAuthUser) {\n      const cognitoUser = {\n        Username: lastAuthUser,\n        Pool: this,\n        Storage: this.storage,\n      };\n\n      return new CognitoUser(cognitoUser);\n    }\n\n    return null;\n  }\n\n  /**\n   * This method returns the encoded data string used for cognito advanced security feature.\n   * This would be generated only when developer has included the JS used for collecting the\n   * data on their client. Please refer to documentation to know more about using AdvancedSecurity\n   * features\n   * @param {string} username the username for the context data\n   * @returns {string} the user context data\n   **/\n  getUserContextData(username) {\n    if (typeof AmazonCognitoAdvancedSecurityData === 'undefined') {\n      return undefined;\n    }\n    /* eslint-disable */\n    const amazonCognitoAdvancedSecurityDataConst = AmazonCognitoAdvancedSecurityData;\n    /* eslint-enable */\n\n    if (this.advancedSecurityDataCollectionFlag) {\n      const advancedSecurityData = amazonCognitoAdvancedSecurityDataConst.getData(username,\n          this.userPoolId, this.clientId);\n      if (advancedSecurityData) {\n        const userContextData = {\n          EncodedData: advancedSecurityData,\n        };\n        return userContextData;\n      }\n    }\n    return {};\n  }\n}\n\n\n\n// WEBPACK FOOTER //\n// ./src/CognitoUserPool.js","\nimport * as Cookies from 'js-cookie';\n\n/** @class */\nexport default class CookieStorage {\n\n  /**\n   * Constructs a new CookieStorage object\n   * @param {object} data Creation options.\n   * @param {string} data.domain Cookies domain (mandatory).\n   * @param {string} data.path Cookies path (default: '/')\n   * @param {integer} data.expires Cookie expiration (in days, default: 365)\n   * @param {boolean} data.secure Cookie secure flag (default: true)\n   */\n  constructor(data) {\n    this.domain = data.domain;\n    if (data.path) {\n      this.path = data.path;\n    } else {\n      this.path = '/';\n    }\n    if (Object.prototype.hasOwnProperty.call(data, 'expires')) {\n      this.expires = data.expires;\n    } else {\n      this.expires = 365;\n    }\n    if (Object.prototype.hasOwnProperty.call(data, 'secure')) {\n      this.secure = data.secure;\n    } else {\n      this.secure = true;\n    }\n  }\n\n  /**\n   * This is used to set a specific item in storage\n   * @param {string} key - the key for the item\n   * @param {object} value - the value\n   * @returns {string} value that was set\n   */\n  setItem(key, value) {\n    Cookies.set(key, value, {\n      path: this.path,\n      expires: this.expires,\n      domain: this.domain,\n      secure: this.secure,\n    }\n    );\n    return Cookies.get(key);\n  }\n\n  /**\n   * This is used to get a specific key from storage\n   * @param {string} key - the key for the item\n   * This is used to clear the storage\n   * @returns {string} the data item\n   */\n  getItem(key) {\n    return Cookies.get(key);\n  }\n\n  /**\n   * This is used to remove an item from storage\n   * @param {string} key - the key being set\n   * @returns {string} value - value that was deleted\n   */\n  removeItem(key) {\n    return Cookies.remove(key, {\n      path: this.path,\n      domain: this.domain,\n      secure: this.secure,\n    }\n    );\n  }\n\n  /**\n   * This is used to clear the storage\n   * @returns {string} nothing\n   */\n  clear() {\n    const cookies = Cookies.get();\n    let index;\n    for (index = 0; index < cookies.length; ++index) {\n      Cookies.remove(cookies[index]);\n    }\n    return {};\n  }\n}\n\n\n\n// WEBPACK FOOTER //\n// ./src/CookieStorage.js","// class for defining the amzn user-agent\nexport default UserAgent;\n// constructor\nfunction UserAgent() {}\n// public\nUserAgent.prototype.userAgent = 'aws-amplify/0.1.x js';\n\n\n// WEBPACK FOOTER //\n// ./src/UserAgent.js","/*\r\n * A JavaScript implementation of the RSA Data Security, Inc. MD5 Message\r\n * Digest Algorithm, as defined in RFC 1321.\r\n * Version 2.1 Copyright (C) Paul Johnston 1999 - 2002.\r\n * Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet\r\n * Distributed under the BSD License\r\n * See http://pajhome.org.uk/crypt/md5 for more info.\r\n */\r\n\r\nvar helpers = require('./helpers');\r\n\r\n/*\r\n * Perform a simple self-test to see if the VM is working\r\n */\r\nfunction md5_vm_test()\r\n{\r\n  return hex_md5(\"abc\") == \"900150983cd24fb0d6963f7d28e17f72\";\r\n}\r\n\r\n/*\r\n * Calculate the MD5 of an array of little-endian words, and a bit length\r\n */\r\nfunction core_md5(x, len)\r\n{\r\n  /* append padding */\r\n  x[len >> 5] |= 0x80 << ((len) % 32);\r\n  x[(((len + 64) >>> 9) << 4) + 14] = len;\r\n\r\n  var a =  1732584193;\r\n  var b = -271733879;\r\n  var c = -1732584194;\r\n  var d =  271733878;\r\n\r\n  for(var i = 0; i < x.length; i += 16)\r\n  {\r\n    var olda = a;\r\n    var oldb = b;\r\n    var oldc = c;\r\n    var oldd = d;\r\n\r\n    a = md5_ff(a, b, c, d, x[i+ 0], 7 , -680876936);\r\n    d = md5_ff(d, a, b, c, x[i+ 1], 12, -389564586);\r\n    c = md5_ff(c, d, a, b, x[i+ 2], 17,  606105819);\r\n    b = md5_ff(b, c, d, a, x[i+ 3], 22, -1044525330);\r\n    a = md5_ff(a, b, c, d, x[i+ 4], 7 , -176418897);\r\n    d = md5_ff(d, a, b, c, x[i+ 5], 12,  1200080426);\r\n    c = md5_ff(c, d, a, b, x[i+ 6], 17, -1473231341);\r\n    b = md5_ff(b, c, d, a, x[i+ 7], 22, -45705983);\r\n    a = md5_ff(a, b, c, d, x[i+ 8], 7 ,  1770035416);\r\n    d = md5_ff(d, a, b, c, x[i+ 9], 12, -1958414417);\r\n    c = md5_ff(c, d, a, b, x[i+10], 17, -42063);\r\n    b = md5_ff(b, c, d, a, x[i+11], 22, -1990404162);\r\n    a = md5_ff(a, b, c, d, x[i+12], 7 ,  1804603682);\r\n    d = md5_ff(d, a, b, c, x[i+13], 12, -40341101);\r\n    c = md5_ff(c, d, a, b, x[i+14], 17, -1502002290);\r\n    b = md5_ff(b, c, d, a, x[i+15], 22,  1236535329);\r\n\r\n    a = md5_gg(a, b, c, d, x[i+ 1], 5 , -165796510);\r\n    d = md5_gg(d, a, b, c, x[i+ 6], 9 , -1069501632);\r\n    c = md5_gg(c, d, a, b, x[i+11], 14,  643717713);\r\n    b = md5_gg(b, c, d, a, x[i+ 0], 20, -373897302);\r\n    a = md5_gg(a, b, c, d, x[i+ 5], 5 , -701558691);\r\n    d = md5_gg(d, a, b, c, x[i+10], 9 ,  38016083);\r\n    c = md5_gg(c, d, a, b, x[i+15], 14, -660478335);\r\n    b = md5_gg(b, c, d, a, x[i+ 4], 20, -405537848);\r\n    a = md5_gg(a, b, c, d, x[i+ 9], 5 ,  568446438);\r\n    d = md5_gg(d, a, b, c, x[i+14], 9 , -1019803690);\r\n    c = md5_gg(c, d, a, b, x[i+ 3], 14, -187363961);\r\n    b = md5_gg(b, c, d, a, x[i+ 8], 20,  1163531501);\r\n    a = md5_gg(a, b, c, d, x[i+13], 5 , -1444681467);\r\n    d = md5_gg(d, a, b, c, x[i+ 2], 9 , -51403784);\r\n    c = md5_gg(c, d, a, b, x[i+ 7], 14,  1735328473);\r\n    b = md5_gg(b, c, d, a, x[i+12], 20, -1926607734);\r\n\r\n    a = md5_hh(a, b, c, d, x[i+ 5], 4 , -378558);\r\n    d = md5_hh(d, a, b, c, x[i+ 8], 11, -2022574463);\r\n    c = md5_hh(c, d, a, b, x[i+11], 16,  1839030562);\r\n    b = md5_hh(b, c, d, a, x[i+14], 23, -35309556);\r\n    a = md5_hh(a, b, c, d, x[i+ 1], 4 , -1530992060);\r\n    d = md5_hh(d, a, b, c, x[i+ 4], 11,  1272893353);\r\n    c = md5_hh(c, d, a, b, x[i+ 7], 16, -155497632);\r\n    b = md5_hh(b, c, d, a, x[i+10], 23, -1094730640);\r\n    a = md5_hh(a, b, c, d, x[i+13], 4 ,  681279174);\r\n    d = md5_hh(d, a, b, c, x[i+ 0], 11, -358537222);\r\n    c = md5_hh(c, d, a, b, x[i+ 3], 16, -722521979);\r\n    b = md5_hh(b, c, d, a, x[i+ 6], 23,  76029189);\r\n    a = md5_hh(a, b, c, d, x[i+ 9], 4 , -640364487);\r\n    d = md5_hh(d, a, b, c, x[i+12], 11, -421815835);\r\n    c = md5_hh(c, d, a, b, x[i+15], 16,  530742520);\r\n    b = md5_hh(b, c, d, a, x[i+ 2], 23, -995338651);\r\n\r\n    a = md5_ii(a, b, c, d, x[i+ 0], 6 , -198630844);\r\n    d = md5_ii(d, a, b, c, x[i+ 7], 10,  1126891415);\r\n    c = md5_ii(c, d, a, b, x[i+14], 15, -1416354905);\r\n    b = md5_ii(b, c, d, a, x[i+ 5], 21, -57434055);\r\n    a = md5_ii(a, b, c, d, x[i+12], 6 ,  1700485571);\r\n    d = md5_ii(d, a, b, c, x[i+ 3], 10, -1894986606);\r\n    c = md5_ii(c, d, a, b, x[i+10], 15, -1051523);\r\n    b = md5_ii(b, c, d, a, x[i+ 1], 21, -2054922799);\r\n    a = md5_ii(a, b, c, d, x[i+ 8], 6 ,  1873313359);\r\n    d = md5_ii(d, a, b, c, x[i+15], 10, -30611744);\r\n    c = md5_ii(c, d, a, b, x[i+ 6], 15, -1560198380);\r\n    b = md5_ii(b, c, d, a, x[i+13], 21,  1309151649);\r\n    a = md5_ii(a, b, c, d, x[i+ 4], 6 , -145523070);\r\n    d = md5_ii(d, a, b, c, x[i+11], 10, -1120210379);\r\n    c = md5_ii(c, d, a, b, x[i+ 2], 15,  718787259);\r\n    b = md5_ii(b, c, d, a, x[i+ 9], 21, -343485551);\r\n\r\n    a = safe_add(a, olda);\r\n    b = safe_add(b, oldb);\r\n    c = safe_add(c, oldc);\r\n    d = safe_add(d, oldd);\r\n  }\r\n  return Array(a, b, c, d);\r\n\r\n}\r\n\r\n/*\r\n * These functions implement the four basic operations the algorithm uses.\r\n */\r\nfunction md5_cmn(q, a, b, x, s, t)\r\n{\r\n  return safe_add(bit_rol(safe_add(safe_add(a, q), safe_add(x, t)), s),b);\r\n}\r\nfunction md5_ff(a, b, c, d, x, s, t)\r\n{\r\n  return md5_cmn((b & c) | ((~b) & d), a, b, x, s, t);\r\n}\r\nfunction md5_gg(a, b, c, d, x, s, t)\r\n{\r\n  return md5_cmn((b & d) | (c & (~d)), a, b, x, s, t);\r\n}\r\nfunction md5_hh(a, b, c, d, x, s, t)\r\n{\r\n  return md5_cmn(b ^ c ^ d, a, b, x, s, t);\r\n}\r\nfunction md5_ii(a, b, c, d, x, s, t)\r\n{\r\n  return md5_cmn(c ^ (b | (~d)), a, b, x, s, t);\r\n}\r\n\r\n/*\r\n * Add integers, wrapping at 2^32. This uses 16-bit operations internally\r\n * to work around bugs in some JS interpreters.\r\n */\r\nfunction safe_add(x, y)\r\n{\r\n  var lsw = (x & 0xFFFF) + (y & 0xFFFF);\r\n  var msw = (x >> 16) + (y >> 16) + (lsw >> 16);\r\n  return (msw << 16) | (lsw & 0xFFFF);\r\n}\r\n\r\n/*\r\n * Bitwise rotate a 32-bit number to the left.\r\n */\r\nfunction bit_rol(num, cnt)\r\n{\r\n  return (num << cnt) | (num >>> (32 - cnt));\r\n}\r\n\r\nmodule.exports = function md5(buf) {\r\n  return helpers.hash(buf, core_md5, 16);\r\n};\r\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/crypto-browserify/md5.js\n// module id = 24\n// module chunks = 0","// Original code adapted from Robert Kieffer.\n// details at https://github.com/broofa/node-uuid\n(function() {\n  var _global = this;\n\n  var mathRNG, whatwgRNG;\n\n  // NOTE: Math.random() does not guarantee \"cryptographic quality\"\n  mathRNG = function(size) {\n    var bytes = new Array(size);\n    var r;\n\n    for (var i = 0, r; i < size; i++) {\n      if ((i & 0x03) == 0) r = Math.random() * 0x100000000;\n      bytes[i] = r >>> ((i & 0x03) << 3) & 0xff;\n    }\n\n    return bytes;\n  }\n\n  if (_global.crypto && crypto.getRandomValues) {\n    whatwgRNG = function(size) {\n      var bytes = new Uint8Array(size);\n      crypto.getRandomValues(bytes);\n      return bytes;\n    }\n  }\n\n  module.exports = whatwgRNG || mathRNG;\n\n}())\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/crypto-browserify/rng.js\n// module id = 25\n// module chunks = 0","/*\n * A JavaScript implementation of the Secure Hash Algorithm, SHA-1, as defined\n * in FIPS PUB 180-1\n * Version 2.1a Copyright Paul Johnston 2000 - 2002.\n * Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet\n * Distributed under the BSD License\n * See http://pajhome.org.uk/crypt/md5 for details.\n */\n\nvar helpers = require('./helpers');\n\n/*\n * Calculate the SHA-1 of an array of big-endian words, and a bit length\n */\nfunction core_sha1(x, len)\n{\n  /* append padding */\n  x[len >> 5] |= 0x80 << (24 - len % 32);\n  x[((len + 64 >> 9) << 4) + 15] = len;\n\n  var w = Array(80);\n  var a =  1732584193;\n  var b = -271733879;\n  var c = -1732584194;\n  var d =  271733878;\n  var e = -1009589776;\n\n  for(var i = 0; i < x.length; i += 16)\n  {\n    var olda = a;\n    var oldb = b;\n    var oldc = c;\n    var oldd = d;\n    var olde = e;\n\n    for(var j = 0; j < 80; j++)\n    {\n      if(j < 16) w[j] = x[i + j];\n      else w[j] = rol(w[j-3] ^ w[j-8] ^ w[j-14] ^ w[j-16], 1);\n      var t = safe_add(safe_add(rol(a, 5), sha1_ft(j, b, c, d)),\n                       safe_add(safe_add(e, w[j]), sha1_kt(j)));\n      e = d;\n      d = c;\n      c = rol(b, 30);\n      b = a;\n      a = t;\n    }\n\n    a = safe_add(a, olda);\n    b = safe_add(b, oldb);\n    c = safe_add(c, oldc);\n    d = safe_add(d, oldd);\n    e = safe_add(e, olde);\n  }\n  return Array(a, b, c, d, e);\n\n}\n\n/*\n * Perform the appropriate triplet combination function for the current\n * iteration\n */\nfunction sha1_ft(t, b, c, d)\n{\n  if(t < 20) return (b & c) | ((~b) & d);\n  if(t < 40) return b ^ c ^ d;\n  if(t < 60) return (b & c) | (b & d) | (c & d);\n  return b ^ c ^ d;\n}\n\n/*\n * Determine the appropriate additive constant for the current iteration\n */\nfunction sha1_kt(t)\n{\n  return (t < 20) ?  1518500249 : (t < 40) ?  1859775393 :\n         (t < 60) ? -1894007588 : -899497514;\n}\n\n/*\n * Add integers, wrapping at 2^32. This uses 16-bit operations internally\n * to work around bugs in some JS interpreters.\n */\nfunction safe_add(x, y)\n{\n  var lsw = (x & 0xFFFF) + (y & 0xFFFF);\n  var msw = (x >> 16) + (y >> 16) + (lsw >> 16);\n  return (msw << 16) | (lsw & 0xFFFF);\n}\n\n/*\n * Bitwise rotate a 32-bit number to the left.\n */\nfunction rol(num, cnt)\n{\n  return (num << cnt) | (num >>> (32 - cnt));\n}\n\nmodule.exports = function sha1(buf) {\n  return helpers.hash(buf, core_sha1, 20, true);\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/crypto-browserify/sha.js\n// module id = 26\n// module chunks = 0","\n/**\n * A JavaScript implementation of the Secure Hash Algorithm, SHA-256, as defined\n * in FIPS 180-2\n * Version 2.2-beta Copyright Angel Marin, Paul Johnston 2000 - 2009.\n * Other contributors: Greg Holt, Andrew Kepert, Ydnar, Lostinet\n *\n */\n\nvar helpers = require('./helpers');\n\nvar safe_add = function(x, y) {\n  var lsw = (x & 0xFFFF) + (y & 0xFFFF);\n  var msw = (x >> 16) + (y >> 16) + (lsw >> 16);\n  return (msw << 16) | (lsw & 0xFFFF);\n};\n\nvar S = function(X, n) {\n  return (X >>> n) | (X << (32 - n));\n};\n\nvar R = function(X, n) {\n  return (X >>> n);\n};\n\nvar Ch = function(x, y, z) {\n  return ((x & y) ^ ((~x) & z));\n};\n\nvar Maj = function(x, y, z) {\n  return ((x & y) ^ (x & z) ^ (y & z));\n};\n\nvar Sigma0256 = function(x) {\n  return (S(x, 2) ^ S(x, 13) ^ S(x, 22));\n};\n\nvar Sigma1256 = function(x) {\n  return (S(x, 6) ^ S(x, 11) ^ S(x, 25));\n};\n\nvar Gamma0256 = function(x) {\n  return (S(x, 7) ^ S(x, 18) ^ R(x, 3));\n};\n\nvar Gamma1256 = function(x) {\n  return (S(x, 17) ^ S(x, 19) ^ R(x, 10));\n};\n\nvar core_sha256 = function(m, l) {\n  var K = new Array(0x428A2F98,0x71374491,0xB5C0FBCF,0xE9B5DBA5,0x3956C25B,0x59F111F1,0x923F82A4,0xAB1C5ED5,0xD807AA98,0x12835B01,0x243185BE,0x550C7DC3,0x72BE5D74,0x80DEB1FE,0x9BDC06A7,0xC19BF174,0xE49B69C1,0xEFBE4786,0xFC19DC6,0x240CA1CC,0x2DE92C6F,0x4A7484AA,0x5CB0A9DC,0x76F988DA,0x983E5152,0xA831C66D,0xB00327C8,0xBF597FC7,0xC6E00BF3,0xD5A79147,0x6CA6351,0x14292967,0x27B70A85,0x2E1B2138,0x4D2C6DFC,0x53380D13,0x650A7354,0x766A0ABB,0x81C2C92E,0x92722C85,0xA2BFE8A1,0xA81A664B,0xC24B8B70,0xC76C51A3,0xD192E819,0xD6990624,0xF40E3585,0x106AA070,0x19A4C116,0x1E376C08,0x2748774C,0x34B0BCB5,0x391C0CB3,0x4ED8AA4A,0x5B9CCA4F,0x682E6FF3,0x748F82EE,0x78A5636F,0x84C87814,0x8CC70208,0x90BEFFFA,0xA4506CEB,0xBEF9A3F7,0xC67178F2);\n  var HASH = new Array(0x6A09E667, 0xBB67AE85, 0x3C6EF372, 0xA54FF53A, 0x510E527F, 0x9B05688C, 0x1F83D9AB, 0x5BE0CD19);\n    var W = new Array(64);\n    var a, b, c, d, e, f, g, h, i, j;\n    var T1, T2;\n  /* append padding */\n  m[l >> 5] |= 0x80 << (24 - l % 32);\n  m[((l + 64 >> 9) << 4) + 15] = l;\n  for (var i = 0; i < m.length; i += 16) {\n    a = HASH[0]; b = HASH[1]; c = HASH[2]; d = HASH[3]; e = HASH[4]; f = HASH[5]; g = HASH[6]; h = HASH[7];\n    for (var j = 0; j < 64; j++) {\n      if (j < 16) {\n        W[j] = m[j + i];\n      } else {\n        W[j] = safe_add(safe_add(safe_add(Gamma1256(W[j - 2]), W[j - 7]), Gamma0256(W[j - 15])), W[j - 16]);\n      }\n      T1 = safe_add(safe_add(safe_add(safe_add(h, Sigma1256(e)), Ch(e, f, g)), K[j]), W[j]);\n      T2 = safe_add(Sigma0256(a), Maj(a, b, c));\n      h = g; g = f; f = e; e = safe_add(d, T1); d = c; c = b; b = a; a = safe_add(T1, T2);\n    }\n    HASH[0] = safe_add(a, HASH[0]); HASH[1] = safe_add(b, HASH[1]); HASH[2] = safe_add(c, HASH[2]); HASH[3] = safe_add(d, HASH[3]);\n    HASH[4] = safe_add(e, HASH[4]); HASH[5] = safe_add(f, HASH[5]); HASH[6] = safe_add(g, HASH[6]); HASH[7] = safe_add(h, HASH[7]);\n  }\n  return HASH;\n};\n\nmodule.exports = function sha256(buf) {\n  return helpers.hash(buf, core_sha256, 32, true);\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./~/crypto-browserify/sha256.js\n// module id = 27\n// module chunks = 0"],"sourceRoot":""}