{"version":3,"sources":["webpack:///webpack/universalModuleDefinition","webpack:///webpack/bootstrap a4cce2a914ed64be9512","webpack:///okta-auth-js.min.js","webpack:///./lib/util.js","webpack:///./lib/errors/AuthSdkError.js","webpack:///./lib/constants.js","webpack:///./lib/http.js","webpack:///./lib/browser/browserStorage.js","webpack:///./node_modules/q/q.js","webpack:///./lib/storageBuilder.js","webpack:///./lib/tx.js","webpack:////root/okta/okta-auth-js/node_modules/process/browser.js","webpack:///(webpack)/buildin/global.js","webpack:///./lib/oauthUtil.js","webpack:///./lib/browser/browserIndex.js","webpack:///./fetch/fetchRequest.js","webpack:////root/okta/okta-auth-js/node_modules/cross-fetch/dist/browser-ponyfill.js","webpack:////root/okta/okta-auth-js/node_modules/js-cookie/src/js.cookie.js","webpack:///./lib/browser/browser.js","webpack:///./lib/vendor/polyfills.js","webpack:////root/okta/okta-auth-js/node_modules/Base64/base64.js","webpack:////root/okta/okta-auth-js/node_modules/tiny-emitter/index.js","webpack:///./lib/builderUtil.js","webpack:////root/okta/okta-auth-js/node_modules/timers-browserify/main.js","webpack:////root/okta/okta-auth-js/node_modules/setimmediate/setImmediate.js","webpack:///./lib/errors/AuthApiError.js","webpack:///./lib/errors/AuthPollStopError.js","webpack:///./lib/session.js","webpack:///./lib/token.js","webpack:///./lib/crypto.js","webpack:///./lib/errors/OAuthError.js","webpack:///./lib/pkce.js","webpack:///./lib/TokenManager.js","webpack:///./lib/clock.js"],"names":["root","factory","exports","module","define","amd","self","this","__webpack_require__","moduleId","installedModules","i","l","modules","call","m","c","d","name","getter","o","Object","defineProperty","configurable","enumerable","get","n","__esModule","object","property","prototype","hasOwnProperty","p","s","util","stringToBase64Url","str","b64","btoa","base64ToBase64Url","replace","base64UrlToBase64","b64u","base64UrlToString","length","utf8","atob","decodeURIComponent","escape","e","stringToBuffer","buffer","Uint8Array","charCodeAt","base64UrlDecode","bind","fn","ctx","additionalArgs","Array","slice","arguments","args","concat","apply","isAbsoluteUrl","url","test","isString","obj","toString","isObject","isNumber","isArray","isoToUTCString","parts","match","isoTime","Date","UTC","toUTCString","toQueryParams","key","undefined","push","encodeURIComponent","join","genRandomString","randomCharset","random","cl","Math","floor","extend","obj1","forEach","prop","removeNils","cleaned","value","clone","JSON","stringify","parse","omit","props","newobj","indexOf","find","collection","searchParams","item","found","getLink","linkName","altName","_links","link","getNativeConsole","window","console","getConsole","nativeConsole","log","warn","text","deprecate","deprecateWrap","removeTrailingSlash","path","trimmed","isIE11OrLess","document","documentMode","isFunction","AuthSdkError","msg","xhr","message","errorCode","errorSummary","errorLink","errorId","errorCauses","Error","httpRequest","sdk","options","method","saveAuthnState","accessToken","withCredentials","storageUtil","storage","httpCache","getHttpCache","cacheResponse","cacheContents","getStorage","cachedResponse","now","expiresAt","Q","resolve","response","headers","userAgent","err","res","ajaxOptions","data","httpRequestClient","then","resp","responseText","stateToken","delete","constants","STATE_TOKEN_KEY_NAME","set","updateStorage","DEFAULT_CACHE_DURATION","fail","serverErr","status","transformErrorXHR","AuthApiError","getOptions","post","postOptions","Cookies","storageBuilder","browserHasLocalStorage","getLocalStorage","testStorage","browserHasSessionStorage","getSessionStorage","getPKCEStorage","PKCE_STORAGE_NAME","getCookieStorage","secure","location","protocol","CACHE_STORAGE_NAME","localStorage","sessionStorage","sameSite","getItem","setItem","getInMemoryStorage","store","removeItem","cookieOptions","expires","remove","definition","bootstrap","uncurryThis","f","isStopIteration","exception","object_toString","QReturnValue","makeStackTraceLong","error","promise","hasStacks","stack","STACK_JUMP_SEPARATOR","stacks","source","unshift","concatedStacks","filterStackString","stackString","lines","split","desiredLines","line","isInternalFrame","isNodeFrame","stackLine","getFileNameAndLineNumber","attempt1","exec","Number","attempt2","attempt3","fileNameAndLineNumber","fileName","lineNumber","qFileName","qStartingLine","qEndingLine","captureLine","firstLine","Promise","isPromiseAlike","coerce","fulfill","defer","become","newPromise","resolvedPromise","array_reduce","messages","nextTick","promiseDispatch","progressListeners","deferred","object_create","op","operands","array_slice","valueOf","nearerValue","nearer","isPromise","inspect","state","longStackSupport","substring","reject","reason","notify","progress","progressListener","resolver","TypeError","race","answerPs","len","descriptor","fallback","result","inspected","when","fulfilled","rejected","progressed","isPending","isFulfilled","isRejected","resetUnhandledRejections","unhandledReasons","unhandledRejections","trackUnhandledRejections","trackRejection","process","emit","runAfter","array_indexOf","reportedUnhandledRejections","untrackRejection","at","atReport","splice","rejection","rhs","thisp","object_keys","master","dispatch","spread","async","makeGenerator","continuer","verb","arg","StopIteration","generator","done","callback","errback","spawn","_return","promised","all","promises","pendingCount","index","snapshot","any","prev","current","onFulfilled","onRejected","onProgress","allResolved","array_map","noop","allSettled","nodeify","nodeback","flush","task","domain","head","next","enter","runSingle","laterQueue","pop","flushing","isNodeJS","exit","setTimeout","tail","requestTick","setImmediate","MessageChannel","channel","port1","onmessage","requestPortTick","port2","postMessage","Function","reduce","basis","map","collect","create","Type","object_hasOwnProperty","keys","ReturnValue","env","Q_DEBUG","makeNodeResolver","passByCopy","x","y","that","makePromise","_fulfilled","_rejected","newException","_progressed","newValue","threw","onerror","tap","fcall","thenResolve","thenReject","getUnhandledReasons","stopUnhandledRejectionTracking","array","del","mapply","send","mcall","invoke","fapply","fbind","alternative","regardless","fin","onUnhandledError","timeout","ms","timeoutId","code","clearTimeout","delay","nfapply","nodeArgs","nfcall","nfbind","denodeify","baseArgs","nbind","bound","nmapply","npost","nsend","nmcall","ninvoke","noConflict","webstorage","storageName","storageString","setStorage","clearStorage","addStateToken","builtArgs","getStateToken","transactionStatus","http","resumeTransaction","tx","exists","_get","AuthTransaction","introspect","transactionStep","transactionExists","postToTransaction","getPollFn","ref","pollFn","opts","autoPush","rememberDevice","href","pollLink","transactionCallBack","DEFAULT_POLLING_DELAY","isPolling","retryCount","recursivePoll","pollRes","factorResult","AuthPollStopError","delayLength","pow","link2fn","lk","hints","allow","factorType","provider","params","profile","updatePhone","links2fns","fns","type","poll","flattenEmbedded","objArr","ol","embedded","_embedded","cancel","defaultSetTimout","defaultClearTimeout","runTimeout","fun","cachedSetTimeout","runClearTimeout","marker","cachedClearTimeout","cleanUpNextTick","draining","currentQueue","queue","queueIndex","drainQueue","run","Item","title","browser","argv","version","versions","on","addListener","once","off","removeListener","removeAllListeners","prependListener","prependOnceListener","listeners","binding","cwd","chdir","dir","umask","g","eval","generateState","generateNonce","isToken","idToken","scopes","eventTarget","addEventListener","attachEvent","removeEventListener","detachEvent","loadFrame","src","iframe","createElement","style","display","body","appendChild","loadPopup","popupTitle","appearance","winEl","open","getWellKnown","issuer","authServerUri","getKey","kid","wellKnown","jwksUri","cachedKey","validateClaims","claims","validationParams","aud","clientId","iss","nonce","iat","exp","maxClockSkew","getOAuthUrls","oauthParams","authorizeUrl","userinfoUrl","tokenUrl","logoutUrl","revokeUrl","responseType","baseUrl","RegExp","endsWith","urlParamsToObject","hashOrSearch","param","plus2space","paramSplit","fragment","fetchRequest","fetch","credentials","ok","respHandler","toLowerCase","json","__self__","F","DOMException","isDataView","DataView","isPrototypeOf","normalizeName","String","normalizeValue","iteratorFor","items","iterator","shift","support","iterable","Symbol","Headers","append","header","getOwnPropertyNames","consumed","bodyUsed","fileReaderReady","reader","onload","readBlobAsArrayBuffer","blob","FileReader","readAsArrayBuffer","readBlobAsText","readAsText","readArrayBufferAsText","buf","view","chars","fromCharCode","bufferClone","byteLength","Body","_initBody","_bodyInit","_bodyText","Blob","_bodyBlob","formData","FormData","_bodyFormData","URLSearchParams","arrayBuffer","_bodyArrayBuffer","ArrayBuffer","isArrayBufferView","decode","normalizeMethod","upcased","toUpperCase","methods","Request","input","mode","signal","referrer","form","trim","bytes","parseHeaders","rawHeaders","Response","bodyInit","statusText","init","abortXhr","abort","request","aborted","XMLHttpRequest","getAllResponseHeaders","responseURL","ontimeout","onabort","setRequestHeader","onreadystatechange","readyState","viewClasses","isView","oldValue","has","thisArg","values","entries","redirectStatuses","redirect","RangeError","constructor","polyfill","default","registeredInModuleLoader","OldCookies","api","attributes","converter","defaults","setMilliseconds","getMilliseconds","write","stringifiedAttributes","attributeName","cookie","cookies","rdecode","charAt","read","getJSON","withConverter","OktaAuthBuilder","builderUtil","getValidUrl","usePKCE","pkce","grantType","redirectUri","postLogoutRedirectUri","responseMode","onSessionExpired","features","isPKCESupported","errorMessage","isHTTPS","hasTextEncoder","DEFAULT_MAX_CLOCK_SKEW","ignoreSignature","session","close","closeSession","sessionExists","getSession","refresh","refreshSession","setCookieAndRedirect","resume","authorize","_getLocationHref","token","getWithoutPrompt","getWithPopup","getWithRedirect","parseFromUrl","decodeToken","revoke","revokeToken","renew","renewToken","getUserInfo","verify","verifyToken","_setLocation","_getHistory","history","_getLocation","_getDocument","fingerprint","_getUserAgent","navigator","isWindowsPhone","isFingerprintSupported","agent","emitter","Emitter","tokenManager","TokenManager","_onTokenManagerError","oauthUtil","proto","isPopupPostMessageSupported","isIE8or9","isTokenVerifySupported","crypto","subtle","TextEncoder","signIn","sendFingerprint","signOut","catch","revokeAccessToken","tokens","clear","assign","idTokenHint","logoutUri","addSharedPrototypes","webfinger","listener","origin","contains","parentElement","removeChild","buildOktaAuth","searchElement","fromIndex","k","abs","Infinity","max","InvalidCharacterError","block","charCode","idx","output","bs","bc","E","_","evtArr","evts","liveEvents","isUrlRegex","forgotPassword","unlockAccount","verifyRecoveryToken","OktaAuth","ajaxRequest","Timeout","id","clearFn","_id","_clearFn","scope","setInterval","clearInterval","unref","enroll","msecs","_idleTimeoutId","_idleTimeout","unenroll","_unrefActive","active","_onTimeout","global","clearImmediate","tasksByHandle","nextHandle","registerImmediate","handle","runIfPresent","currentlyRunningATask","doc","attachTo","getPrototypeOf","importScripts","postMessageIsAsynchronous","oldOnMessage","messagePrefix","onGlobalMessage","event","html","documentElement","script","user","sessionToken","redirectUrl","checkAccountSetupComplete","token_type_hint","creds","decodedToken","jwt","payload","signature","validationOptions","sdkCrypto","valid","addPostMessageListener","responseHandler","addFragmentListener","windowEl","hashChangeHandler","hash","hashToObject","closed","exchangeCodeForToken","authorizationCode","urls","meta","PKCE","loadMeta","getTokenParams","codeVerifier","getToken","validateResponse","clearMeta","OAuthError","handleOAuthResponse","tokenDict","tokenType","filter","getDefaultOAuthParams","convertOAuthParamsToQueryParams","oauthQueryParams","codeChallenge","codeChallengeMethod","idp","idpScope","loginHint","maxAge","prompt","mayBeArray","buildAuthorizeParams","oauthOptions","prepareOauthParams","getOrigin","hasClosed","win","popupDeferred","sessionTokenOverrides","idpOverrides","requestUrl","endpoint","iframePromise","iframeEl","popupPromise","windowOptions","windowOrigin","redirectUriOrigin","closePoller","DEFAULT_CODE_CHALLENGE_METHOD","generateVerifier","saveMeta","computeChallenge","clonedParams","includes","isSecure","cookieSettings","REDIRECT_OAUTH_PARAMS_COOKIE_NAME","REDIRECT_NONCE_COOKIE_NAME","REDIRECT_STATE_COOKIE_NAME","removeHash","nativeHistory","nativeDoc","nativeLoc","replaceState","pathname","search","removeSearch","paramStr","oauthParamsCookie","accessTokenObject","authenticateHeader","getResponseHeader","errorMatches","errorDescriptionMatches","errorDescription","algo","usages","use","importKey","cryptoKey","b64Signature","summary","dec2hex","dec","substr","getRandomString","a","ceil","getRandomValues","from","prefix","verifier","MIN_VERIFIER_LENGTH","MAX_VERIFIER_LENGTH","encode","digest","validateOptions","getPostData","getExpireTime","tokenMgmtRef","expireEarlySeconds","hasExpired","clock","emitExpired","emitError","clearExpireEventTimeout","expireTimeouts","renewPromise","clearExpireEventTimeoutAll","setExpireEventTimeout","expireTime","expireEventWait","expireEventTimeout","setExpireEventTimeoutAll","tokenStorage","add","getAsync","autoRenew","existingPromise","freshTokens","freshToken","oldToken","tokenKey","finally","DEFAULT_OPTIONS","storageProvider","storageKey","TOKEN_STORAGE_NAME","SdkClock","localOffset","parseInt"],"mappings":"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","file":"okta-auth-js.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[\"OktaAuth\"] = factory();\n\telse\n\t\troot[\"OktaAuth\"] = factory();\n})(typeof self !== 'undefined' ? self : this, function() {\nreturn \n\n\n// WEBPACK FOOTER //\n// webpack/universalModuleDefinition"," \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 \t\t}\n \t\t// Create a new module (and put it into the cache)\n \t\tvar module = installedModules[moduleId] = {\n \t\t\ti: moduleId,\n \t\t\tl: false,\n \t\t\texports: {}\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.l = 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// define getter function for harmony exports\n \t__webpack_require__.d = function(exports, name, getter) {\n \t\tif(!__webpack_require__.o(exports, name)) {\n \t\t\tObject.defineProperty(exports, name, {\n \t\t\t\tconfigurable: false,\n \t\t\t\tenumerable: true,\n \t\t\t\tget: getter\n \t\t\t});\n \t\t}\n \t};\n\n \t// getDefaultExport function for compatibility with non-harmony modules\n \t__webpack_require__.n = function(module) {\n \t\tvar getter = module && module.__esModule ?\n \t\t\tfunction getDefault() { return module['default']; } :\n \t\t\tfunction getModuleExports() { return module; };\n \t\t__webpack_require__.d(getter, 'a', getter);\n \t\treturn getter;\n \t};\n\n \t// Object.prototype.hasOwnProperty.call\n \t__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };\n\n \t// __webpack_public_path__\n \t__webpack_require__.p = \"\";\n\n \t// Load entry module and return exports\n \treturn __webpack_require__(__webpack_require__.s = 11);\n\n\n\n// WEBPACK FOOTER //\n// webpack/bootstrap a4cce2a914ed64be9512","(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[\"OktaAuth\"] = factory();\n\telse\n\t\troot[\"OktaAuth\"] = factory();\n})(typeof self !== 'undefined' ? self : 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/******/ \t\t}\n/******/ \t\t// Create a new module (and put it into the cache)\n/******/ \t\tvar module = installedModules[moduleId] = {\n/******/ \t\t\ti: moduleId,\n/******/ \t\t\tl: false,\n/******/ \t\t\texports: {}\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.l = 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// define getter function for harmony exports\n/******/ \t__webpack_require__.d = function(exports, name, getter) {\n/******/ \t\tif(!__webpack_require__.o(exports, name)) {\n/******/ \t\t\tObject.defineProperty(exports, name, {\n/******/ \t\t\t\tconfigurable: false,\n/******/ \t\t\t\tenumerable: true,\n/******/ \t\t\t\tget: getter\n/******/ \t\t\t});\n/******/ \t\t}\n/******/ \t};\n/******/\n/******/ \t// getDefaultExport function for compatibility with non-harmony modules\n/******/ \t__webpack_require__.n = function(module) {\n/******/ \t\tvar getter = module && module.__esModule ?\n/******/ \t\t\tfunction getDefault() { return module['default']; } :\n/******/ \t\t\tfunction getModuleExports() { return module; };\n/******/ \t\t__webpack_require__.d(getter, 'a', getter);\n/******/ \t\treturn getter;\n/******/ \t};\n/******/\n/******/ \t// Object.prototype.hasOwnProperty.call\n/******/ \t__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };\n/******/\n/******/ \t// __webpack_public_path__\n/******/ \t__webpack_require__.p = \"\";\n/******/\n/******/ \t// Load entry module and return exports\n/******/ \treturn __webpack_require__(__webpack_require__.s = 11);\n/******/ })\n/************************************************************************/\n/******/ ([\n/* 0 */\n/***/ (function(module, exports) {\n\n/*!\n * Copyright (c) 2015-present, Okta, Inc. and/or its affiliates. All rights reserved.\n * The Okta software accompanied by this notice is provided pursuant to the Apache License, Version 2.0 (the \"License.\")\n *\n * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0.\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS, WITHOUT\n * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n *\n * See the License for the specific language governing permissions and limitations under the License.\n */\n/* eslint-env es6 */\nvar util = module.exports;\n\n// converts a string to base64 (url/filename safe variant)\nutil.stringToBase64Url = function(str) {\n  var b64 = btoa(str);\n  return util.base64ToBase64Url(b64);\n};\n\n// converts a standard base64-encoded string to a \"url/filename safe\" variant\nutil.base64ToBase64Url = function(b64) {\n  return b64.replace(/\\+/g, '-').replace(/\\//g, '_').replace(/=+$/, '');\n};\n\n// converts a \"url/filename safe\" base64 string to a \"standard\" base64 string\nutil.base64UrlToBase64 = function(b64u) {\n  return b64u.replace(/-/g, '+').replace(/_/g, '/');\n};\n\nutil.base64UrlToString = function(b64u) {\n  var b64 = util.base64UrlToBase64(b64u);\n  switch (b64.length % 4) {\n    case 0:\n      break;\n    case 2:\n      b64 += '==';\n      break;\n    case 3:\n      b64 += '=';\n      break;\n    default:\n      throw 'Not a valid Base64Url';\n  }\n  var utf8 = atob(b64);\n  try {\n    return decodeURIComponent(escape(utf8));\n  } catch (e) {\n    return utf8;\n  }\n};\n\nutil.stringToBuffer = function(str) {\n  var buffer = new Uint8Array(str.length);\n  for (var i = 0; i < str.length; i++) {\n    buffer[i] = str.charCodeAt(i);\n  }\n  return buffer;\n};\n\nutil.base64UrlDecode = function(str) {\n  return atob(util.base64UrlToBase64(str));\n};\n\nutil.bind = function(fn, ctx) {\n  var additionalArgs = Array.prototype.slice.call(arguments, 2);\n  return function() {\n    var args = Array.prototype.slice.call(arguments);\n    args = additionalArgs.concat(args);\n    return fn.apply(ctx, args);\n  };\n};\n\nutil.isAbsoluteUrl = function(url) {\n  return /^(?:[a-z]+:)?\\/\\//i.test(url);\n};\n\nutil.isString = function(obj) {\n  return Object.prototype.toString.call(obj) === '[object String]';\n};\n\nutil.isObject = function(obj) {\n  return Object.prototype.toString.call(obj) === '[object Object]';\n};\n\nutil.isNumber = function(obj) {\n  return Object.prototype.toString.call(obj) === '[object Number]';\n};\n\nutil.isArray = function(obj) {\n  return Object.prototype.toString.call(obj) === '[object Array]';\n};\n\nutil.isoToUTCString = function(str) {\n  var parts = str.match(/\\d+/g),\n      isoTime = Date.UTC(parts[0], parts[1] - 1, parts[2], parts[3], parts[4], parts[5]),\n      isoDate = new Date(isoTime);\n\n  return isoDate.toUTCString();\n};\n\nutil.toQueryParams = function(obj) {\n  var str = [];\n  if (obj !== null) {\n    for (var key in obj) {\n      if (obj.hasOwnProperty(key) &&\n          obj[key] !== undefined &&\n          obj[key] !== null) {\n        str.push(key + '=' + encodeURIComponent(obj[key]));\n      }\n    }\n  }\n  if (str.length) {\n    return '?' + str.join('&');\n  } else {\n    return '';\n  }\n};\n\nutil.genRandomString = function(length) {\n  var randomCharset = 'abcdefghijklnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789';\n  var random = '';\n  for (var c = 0, cl = randomCharset.length; c < length; ++c) {\n    random += randomCharset[Math.floor(Math.random() * cl)];\n  }\n  return random;\n};\n\nutil.extend = function() {\n  // First object will be modified!\n  var obj1 = arguments[0];\n  // Properties from other objects will be copied over\n  var objArray = [].slice.call(arguments, 1);\n  objArray.forEach(function(obj) {\n    for (var prop in obj) {\n      // copy over all properties with defined values\n      if (obj.hasOwnProperty(prop) && obj[prop] !== undefined) {\n        obj1[prop] = obj[prop];\n      }\n    }\n  });\n  return obj1; // return the modified object\n};\n\nutil.removeNils = function(obj) {\n  var cleaned = {};\n  for (var prop in obj) {\n    if (obj.hasOwnProperty(prop)) {\n      var value = obj[prop];\n      if (value !== null && value !== undefined) {\n        cleaned[prop] = value;\n      }\n    }\n  }\n  return cleaned;\n};\n\nutil.clone = function(obj) {\n  if (obj) {\n    var str = JSON.stringify(obj);\n    if (str) {\n      return JSON.parse(str);\n    }\n  }\n  return obj;\n};\n\n// Analogous to _.omit\nutil.omit = function(obj) {\n  var props = Array.prototype.slice.call(arguments, 1);\n  var newobj = {};\n  for (var p in obj) {\n    if (obj.hasOwnProperty(p) && props.indexOf(p) == -1) {\n      newobj[p] = obj[p];\n    }\n  }\n  return util.clone(newobj);\n};\n\nutil.find = function(collection, searchParams) {\n  var c = collection.length;\n  while (c--) {\n    var item = collection[c];\n    var found = true;\n    for (var prop in searchParams) {\n      if (!searchParams.hasOwnProperty(prop)) {\n        continue;\n      }\n      if (item[prop] !== searchParams[prop]) {\n        found = false;\n        break;\n      }\n    }\n    if (found) {\n      return item;\n    }\n  }\n};\n\nutil.getLink = function(obj, linkName, altName) {\n  if (!obj || !obj._links) {\n    return;\n  }\n\n  var link = util.clone(obj._links[linkName]);\n\n  // If a link has a name and we have an altName, return if they match\n  if (link && link.name && altName) {\n    if (link.name === altName) {\n      return link;\n    }\n  } else {\n    return link;\n  }\n};\n\nutil.getNativeConsole = function() {\n  if (typeof window !== 'undefined') {\n    return window.console;\n  } else if (typeof console !== 'undefined') {\n    return console;\n  } else {\n    return undefined;\n  }\n};\n\nutil.getConsole = function() {\n  var nativeConsole = util.getNativeConsole();\n  if (nativeConsole && nativeConsole.log) {\n    return nativeConsole;\n  }\n  return {\n    log: function() {}\n  };\n};\n\nutil.warn = function(text) {\n  /* eslint-disable no-console */\n  util.getConsole().log('[okta-auth-sdk] WARN: ' + text);\n  /* eslint-enable */\n};\n\nutil.deprecate = function(text) {\n  /* eslint-disable no-console */\n  util.getConsole().log('[okta-auth-sdk] DEPRECATION: ' + text);\n  /* eslint-enable */\n};\n\nutil.deprecateWrap = function(text, fn) {\n  return function() {\n    util.deprecate(text);\n    return fn.apply(null, arguments);\n  };\n};\n\nutil.removeTrailingSlash = function(path) {\n  if (!path) {\n    return;\n  }\n  // Remove any whitespace before or after string\n  var trimmed = path.replace(/^\\s+|\\s+$/gm,'');\n  // Remove trailing slash(es)\n  trimmed = trimmed.replace(/\\/+$/, '');\n\n  return trimmed;\n};\n\nutil.isIE11OrLess = function() {\n  return !!document.documentMode && document.documentMode <= 11;\n};\n\nutil.isFunction = function(fn) {\n  return !!fn && {}.toString.call(fn) === '[object Function]';\n};\n\n\n/***/ }),\n/* 1 */\n/***/ (function(module, exports) {\n\n/*!\n * Copyright (c) 2015-present, Okta, Inc. and/or its affiliates. All rights reserved.\n * The Okta software accompanied by this notice is provided pursuant to the Apache License, Version 2.0 (the \"License.\")\n *\n * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0.\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS, WITHOUT\n * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n *\n * See the License for the specific language governing permissions and limitations under the License.\n */\n\nfunction AuthSdkError(msg, xhr) {\n  this.name = 'AuthSdkError';\n  this.message = msg;\n\n  this.errorCode = 'INTERNAL';\n  this.errorSummary = msg;\n  this.errorLink = 'INTERNAL';\n  this.errorId = 'INTERNAL';\n  this.errorCauses = [];\n  if (xhr) {\n    this.xhr = xhr;\n  }\n}\nAuthSdkError.prototype = new Error();\n\nmodule.exports = AuthSdkError;\n\n\n/***/ }),\n/* 2 */\n/***/ (function(module, exports) {\n\nmodule.exports = {\n  'STATE_TOKEN_KEY_NAME': 'oktaStateToken',\n  'DEFAULT_POLLING_DELAY': 500,\n  'DEFAULT_MAX_CLOCK_SKEW': 300,\n  'DEFAULT_CACHE_DURATION': 86400,\n  'REDIRECT_OAUTH_PARAMS_COOKIE_NAME': 'okta-oauth-redirect-params',\n  'REDIRECT_STATE_COOKIE_NAME': 'okta-oauth-state',\n  'REDIRECT_NONCE_COOKIE_NAME': 'okta-oauth-nonce',\n  'TOKEN_STORAGE_NAME': 'okta-token-storage',\n  'CACHE_STORAGE_NAME': 'okta-cache-storage',\n  'PKCE_STORAGE_NAME': 'okta-pkce-storage'\n};\n\n/***/ }),\n/* 3 */\n/***/ (function(module, exports, __webpack_require__) {\n\n/*!\n * Copyright (c) 2015-present, Okta, Inc. and/or its affiliates. All rights reserved.\n * The Okta software accompanied by this notice is provided pursuant to the Apache License, Version 2.0 (the \"License.\")\n *\n * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0.\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS, WITHOUT\n * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n *\n * See the License for the specific language governing permissions and limitations under the License.\n *\n */\n\n/* eslint-disable complexity */\nvar util = __webpack_require__(0);\nvar Q = __webpack_require__(5);\nvar AuthApiError = __webpack_require__(22);\nvar constants = __webpack_require__(2);\n\nfunction httpRequest(sdk, options) {\n  options = options || {};\n  var url = options.url,\n      method = options.method,\n      args = options.args,\n      saveAuthnState = options.saveAuthnState,\n      accessToken = options.accessToken,\n      withCredentials = options.withCredentials !== false, // default value is true\n      storageUtil = sdk.options.storageUtil,\n      storage = storageUtil.storage,\n      httpCache = storageUtil.getHttpCache();\n\n  if (options.cacheResponse) {\n    var cacheContents = httpCache.getStorage();\n    var cachedResponse = cacheContents[url];\n    if (cachedResponse && Date.now()/1000 < cachedResponse.expiresAt) {\n      return Q.resolve(cachedResponse.response);\n    }\n  }\n\n  var headers = {\n    'Accept': 'application/json',\n    'Content-Type': 'application/json',\n    'X-Okta-User-Agent-Extended': sdk.userAgent\n  };\n  util.extend(headers, sdk.options.headers, options.headers);\n\n  if (accessToken && util.isString(accessToken)) {\n    headers['Authorization'] = 'Bearer ' + accessToken;\n  }\n\n  var ajaxOptions = {\n    headers: headers,\n    data: args || undefined,\n    withCredentials: withCredentials\n  };\n\n  var err, res;\n  return new Q(sdk.options.httpRequestClient(method, url, ajaxOptions))\n    .then(function(resp) {\n      res = resp.responseText;\n      if (res && util.isString(res)) {\n        res = JSON.parse(res);\n      }\n\n      if (saveAuthnState) {\n        if (!res.stateToken) {\n          storage.delete(constants.STATE_TOKEN_KEY_NAME);\n        }\n      }\n\n      if (res && res.stateToken && res.expiresAt) {\n        storage.set(constants.STATE_TOKEN_KEY_NAME, res.stateToken, res.expiresAt);\n      }\n\n      if (res && options.cacheResponse) {\n        httpCache.updateStorage(url, {\n          expiresAt: Math.floor(Date.now()/1000) + constants.DEFAULT_CACHE_DURATION,\n          response: res\n        });\n      }\n\n      return res;\n    })\n    .fail(function(resp) {\n      var serverErr = resp.responseText || {};\n      if (util.isString(serverErr)) {\n        try {\n          serverErr = JSON.parse(serverErr);\n        } catch (e) {\n          serverErr = {\n            errorSummary: 'Unknown error'\n          };\n        }\n      }\n\n      if (resp.status >= 500) {\n        serverErr.errorSummary = 'Unknown error';\n      }\n\n      if (sdk.options.transformErrorXHR) {\n        resp = sdk.options.transformErrorXHR(util.clone(resp));\n      }\n\n      err = new AuthApiError(serverErr, resp);\n\n      if (err.errorCode === 'E0000011') {\n        storage.delete(constants.STATE_TOKEN_KEY_NAME);\n      }\n\n      throw err;\n    });\n}\n\nfunction get(sdk, url, options) {\n  url = util.isAbsoluteUrl(url) ? url : sdk.options.url + url;\n  var getOptions = {\n    url: url,\n    method: 'GET'\n  };\n  util.extend(getOptions, options);\n  return httpRequest(sdk, getOptions);\n}\n\nfunction post(sdk, url, args, options) {\n  url = util.isAbsoluteUrl(url) ? url : sdk.options.url + url;\n  var postOptions = {\n    url: url,\n    method: 'POST',\n    args: args,\n    saveAuthnState: true\n  };\n  util.extend(postOptions, options);\n  return httpRequest(sdk, postOptions);\n}\n\nmodule.exports = {\n  get: get,\n  post: post,\n  httpRequest: httpRequest\n};\n\n\n/***/ }),\n/* 4 */\n/***/ (function(module, exports, __webpack_require__) {\n\n/*!\n * Copyright (c) 2015-present, Okta, Inc. and/or its affiliates. All rights reserved.\n * The Okta software accompanied by this notice is provided pursuant to the Apache License, Version 2.0 (the \"License.\")\n *\n * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0.\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS, WITHOUT\n * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n *\n * See the License for the specific language governing permissions and limitations under the License.\n *\n */\n\nvar Cookies = __webpack_require__(14);\nvar storageBuilder = __webpack_require__(6);\nvar constants = __webpack_require__(2);\n\n// Building this as an object allows us to mock the functions in our tests\nvar storageUtil = {};\n\n// IE11 bug that Microsoft doesn't plan to fix\n// https://connect.microsoft.com/IE/Feedback/Details/1496040\nstorageUtil.browserHasLocalStorage = function() {\n  try {\n    var storage = storageUtil.getLocalStorage();\n    return storageUtil.testStorage(storage);\n  } catch (e) {\n    return false;\n  }\n};\n\nstorageUtil.browserHasSessionStorage = function() {\n  try {\n    var storage = storageUtil.getSessionStorage();\n    return storageUtil.testStorage(storage);\n  } catch (e) {\n    return false;\n  }\n};\n\nstorageUtil.getPKCEStorage = function() {\n  if (storageUtil.browserHasLocalStorage()) {\n    return storageBuilder(storageUtil.getLocalStorage(), constants.PKCE_STORAGE_NAME);\n  } else if (storageUtil.browserHasSessionStorage()) {\n    return storageBuilder(storageUtil.getSessionStorage(), constants.PKCE_STORAGE_NAME);\n  } else {\n    return storageBuilder(storageUtil.getCookieStorage({\n      secure: window.location.protocol === 'https:'\n    }), constants.PKCE_STORAGE_NAME);\n  }\n};\n\nstorageUtil.getHttpCache = function() {\n  if (storageUtil.browserHasLocalStorage()) {\n    return storageBuilder(storageUtil.getLocalStorage(), constants.CACHE_STORAGE_NAME);\n  } else if (storageUtil.browserHasSessionStorage()) {\n    return storageBuilder(storageUtil.getSessionStorage(), constants.CACHE_STORAGE_NAME);\n  } else {\n    return storageBuilder(storageUtil.getCookieStorage({\n      secure: window.location.protocol === 'https:'\n    }), constants.CACHE_STORAGE_NAME);\n  }\n};\n\nstorageUtil.getLocalStorage = function() {\n  return localStorage;\n};\n\nstorageUtil.getSessionStorage = function() {\n  return sessionStorage;\n};\n\n// Provides webStorage-like interface for cookies\nstorageUtil.getCookieStorage = function(options) {\n  options = options || {};\n  var secure = options.secure || false; // currently opt-in\n  var sameSite = options.sameSite || (secure ? 'none' : 'lax');\n  return {\n    getItem: storageUtil.storage.get,\n    setItem: function(key, value) {\n      // Cookie shouldn't expire\n      storageUtil.storage.set(key, value, '2200-01-01T00:00:00.000Z', {\n        secure: secure, \n        sameSite: sameSite\n      });\n    }\n  };\n};\n\n// Provides an in-memory solution\nstorageUtil.getInMemoryStorage = function() {\n  var store = {};\n  return {\n    getItem: function(key) {\n      return store[key];\n    },\n    setItem: function(key, value) {\n      store[key] = value;\n    }\n  };\n};\n\nstorageUtil.testStorage = function(storage) {\n  var key = 'okta-test-storage';\n  try {\n    storage.setItem(key, key);\n    storage.removeItem(key);\n    return true;\n  } catch (e) {\n    return false;\n  }\n};\n\nstorageUtil.storage = {\n  set: function(name, value, expiresAt, options) {\n    options = options || {};\n    var cookieOptions = {\n      path: options.path || '/',\n      secure: options.secure,\n      sameSite: options.sameSite\n    };\n\n    // eslint-disable-next-line no-extra-boolean-cast\n    if (!!(Date.parse(expiresAt))) {\n      // Expires value can be converted to a Date object.\n      //\n      // If the 'expiresAt' value is not provided, or the value cannot be\n      // parsed as a Date object, the cookie will set as a session cookie.\n      cookieOptions.expires = new Date(expiresAt);\n    }\n\n    Cookies.set(name, value, cookieOptions);\n    return storageUtil.storage.get(name);\n  },\n\n  get: function(name) {\n    return Cookies.get(name);\n  },\n\n  delete: function(name) {\n    return Cookies.remove(name, { path: '/' });\n  }\n};\n\nmodule.exports = storageUtil;\n\n\n/***/ }),\n/* 5 */\n/***/ (function(module, exports, __webpack_require__) {\n\n/* WEBPACK VAR INJECTION */(function(process, setImmediate) {// vim:ts=4:sts=4:sw=4:\n/*!\n *\n * Copyright 2009-2012 Kris Kowal under the terms of the MIT\n * license found at http://github.com/kriskowal/q/raw/master/LICENSE\n *\n * With parts by Tyler Close\n * Copyright 2007-2009 Tyler Close under the terms of the MIT X license found\n * at http://www.opensource.org/licenses/mit-license.html\n * Forked at ref_send.js version: 2009-05-11\n *\n * With parts by Mark Miller\n * Copyright (C) 2011 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n *\n */\n\n(function (definition) {\n    \"use strict\";\n\n    // This file will function properly as a <script> tag, or a module\n    // using CommonJS and NodeJS or RequireJS module formats.  In\n    // Common/Node/RequireJS, the module exports the Q API and when\n    // executed as a simple <script>, it creates a Q global instead.\n\n    // Montage Require\n    if (typeof bootstrap === \"function\") {\n        bootstrap(\"promise\", definition);\n\n    // CommonJS\n    } else if (true) {\n        module.exports = definition();\n\n    // RequireJS\n    } else if (typeof define === \"function\" && define.amd) {\n        define(definition);\n\n    // SES (Secure EcmaScript)\n    } else if (typeof ses !== \"undefined\") {\n        if (!ses.ok()) {\n            return;\n        } else {\n            ses.makeQ = definition;\n        }\n\n    // <script>\n    } else if (typeof window !== \"undefined\" || typeof self !== \"undefined\") {\n        // Prefer window over self for add-on scripts. Use self for\n        // non-windowed contexts.\n        var global = typeof window !== \"undefined\" ? window : self;\n\n        // Get the `window` object, save the previous Q global\n        // and initialize Q as a global.\n        var previousQ = global.Q;\n        global.Q = definition();\n\n        // Add a noConflict function so Q can be removed from the\n        // global namespace.\n        global.Q.noConflict = function () {\n            global.Q = previousQ;\n            return this;\n        };\n\n    } else {\n        throw new Error(\"This environment was not anticipated by Q. Please file a bug.\");\n    }\n\n})(function () {\n\"use strict\";\n\nvar hasStacks = false;\ntry {\n    throw new Error();\n} catch (e) {\n    hasStacks = !!e.stack;\n}\n\n// All code after this point will be filtered from stack traces reported\n// by Q.\nvar qStartingLine = captureLine();\nvar qFileName;\n\n// shims\n\n// used for fallback in \"allResolved\"\nvar noop = function () {};\n\n// Use the fastest possible means to execute a task in a future turn\n// of the event loop.\nvar nextTick =(function () {\n    // linked list of tasks (single, with head node)\n    var head = {task: void 0, next: null};\n    var tail = head;\n    var flushing = false;\n    var requestTick = void 0;\n    var isNodeJS = false;\n    // queue for late tasks, used by unhandled rejection tracking\n    var laterQueue = [];\n\n    function flush() {\n        /* jshint loopfunc: true */\n        var task, domain;\n\n        while (head.next) {\n            head = head.next;\n            task = head.task;\n            head.task = void 0;\n            domain = head.domain;\n\n            if (domain) {\n                head.domain = void 0;\n                domain.enter();\n            }\n            runSingle(task, domain);\n\n        }\n        while (laterQueue.length) {\n            task = laterQueue.pop();\n            runSingle(task);\n        }\n        flushing = false;\n    }\n    // runs a single function in the async queue\n    function runSingle(task, domain) {\n        try {\n            task();\n\n        } catch (e) {\n            if (isNodeJS) {\n                // In node, uncaught exceptions are considered fatal errors.\n                // Re-throw them synchronously to interrupt flushing!\n\n                // Ensure continuation if the uncaught exception is suppressed\n                // listening \"uncaughtException\" events (as domains does).\n                // Continue in next event to avoid tick recursion.\n                if (domain) {\n                    domain.exit();\n                }\n                setTimeout(flush, 0);\n                if (domain) {\n                    domain.enter();\n                }\n\n                throw e;\n\n            } else {\n                // In browsers, uncaught exceptions are not fatal.\n                // Re-throw them asynchronously to avoid slow-downs.\n                setTimeout(function () {\n                    throw e;\n                }, 0);\n            }\n        }\n\n        if (domain) {\n            domain.exit();\n        }\n    }\n\n    nextTick = function (task) {\n        tail = tail.next = {\n            task: task,\n            domain: isNodeJS && process.domain,\n            next: null\n        };\n\n        if (!flushing) {\n            flushing = true;\n            requestTick();\n        }\n    };\n\n    if (typeof process === \"object\" &&\n        process.toString() === \"[object process]\" && process.nextTick) {\n        // Ensure Q is in a real Node environment, with a `process.nextTick`.\n        // To see through fake Node environments:\n        // * Mocha test runner - exposes a `process` global without a `nextTick`\n        // * Browserify - exposes a `process.nexTick` function that uses\n        //   `setTimeout`. In this case `setImmediate` is preferred because\n        //    it is faster. Browserify's `process.toString()` yields\n        //   \"[object Object]\", while in a real Node environment\n        //   `process.nextTick()` yields \"[object process]\".\n        isNodeJS = true;\n\n        requestTick = function () {\n            process.nextTick(flush);\n        };\n\n    } else if (typeof setImmediate === \"function\") {\n        // In IE10, Node.js 0.9+, or https://github.com/NobleJS/setImmediate\n        if (typeof window !== \"undefined\") {\n            requestTick = setImmediate.bind(window, flush);\n        } else {\n            requestTick = function () {\n                setImmediate(flush);\n            };\n        }\n\n    } else if (typeof MessageChannel !== \"undefined\") {\n        // modern browsers\n        // http://www.nonblocking.io/2011/06/windownexttick.html\n        var channel = new MessageChannel();\n        // At least Safari Version 6.0.5 (8536.30.1) intermittently cannot create\n        // working message ports the first time a page loads.\n        channel.port1.onmessage = function () {\n            requestTick = requestPortTick;\n            channel.port1.onmessage = flush;\n            flush();\n        };\n        var requestPortTick = function () {\n            // Opera requires us to provide a message payload, regardless of\n            // whether we use it.\n            channel.port2.postMessage(0);\n        };\n        requestTick = function () {\n            setTimeout(flush, 0);\n            requestPortTick();\n        };\n\n    } else {\n        // old browsers\n        requestTick = function () {\n            setTimeout(flush, 0);\n        };\n    }\n    // runs a task after all other tasks have been run\n    // this is useful for unhandled rejection tracking that needs to happen\n    // after all `then`d tasks have been run.\n    nextTick.runAfter = function (task) {\n        laterQueue.push(task);\n        if (!flushing) {\n            flushing = true;\n            requestTick();\n        }\n    };\n    return nextTick;\n})();\n\n// Attempt to make generics safe in the face of downstream\n// modifications.\n// There is no situation where this is necessary.\n// If you need a security guarantee, these primordials need to be\n// deeply frozen anyway, and if you don’t need a security guarantee,\n// this is just plain paranoid.\n// However, this **might** have the nice side-effect of reducing the size of\n// the minified code by reducing x.call() to merely x()\n// See Mark Miller’s explanation of what this does.\n// http://wiki.ecmascript.org/doku.php?id=conventions:safe_meta_programming\nvar call = Function.call;\nfunction uncurryThis(f) {\n    return function () {\n        return call.apply(f, arguments);\n    };\n}\n// This is equivalent, but slower:\n// uncurryThis = Function_bind.bind(Function_bind.call);\n// http://jsperf.com/uncurrythis\n\nvar array_slice = uncurryThis(Array.prototype.slice);\n\nvar array_reduce = uncurryThis(\n    Array.prototype.reduce || function (callback, basis) {\n        var index = 0,\n            length = this.length;\n        // concerning the initial value, if one is not provided\n        if (arguments.length === 1) {\n            // seek to the first value in the array, accounting\n            // for the possibility that is is a sparse array\n            do {\n                if (index in this) {\n                    basis = this[index++];\n                    break;\n                }\n                if (++index >= length) {\n                    throw new TypeError();\n                }\n            } while (1);\n        }\n        // reduce\n        for (; index < length; index++) {\n            // account for the possibility that the array is sparse\n            if (index in this) {\n                basis = callback(basis, this[index], index);\n            }\n        }\n        return basis;\n    }\n);\n\nvar array_indexOf = uncurryThis(\n    Array.prototype.indexOf || function (value) {\n        // not a very good shim, but good enough for our one use of it\n        for (var i = 0; i < this.length; i++) {\n            if (this[i] === value) {\n                return i;\n            }\n        }\n        return -1;\n    }\n);\n\nvar array_map = uncurryThis(\n    Array.prototype.map || function (callback, thisp) {\n        var self = this;\n        var collect = [];\n        array_reduce(self, function (undefined, value, index) {\n            collect.push(callback.call(thisp, value, index, self));\n        }, void 0);\n        return collect;\n    }\n);\n\nvar object_create = Object.create || function (prototype) {\n    function Type() { }\n    Type.prototype = prototype;\n    return new Type();\n};\n\nvar object_hasOwnProperty = uncurryThis(Object.prototype.hasOwnProperty);\n\nvar object_keys = Object.keys || function (object) {\n    var keys = [];\n    for (var key in object) {\n        if (object_hasOwnProperty(object, key)) {\n            keys.push(key);\n        }\n    }\n    return keys;\n};\n\nvar object_toString = uncurryThis(Object.prototype.toString);\n\nfunction isObject(value) {\n    return value === Object(value);\n}\n\n// generator related shims\n\n// FIXME: Remove this function once ES6 generators are in SpiderMonkey.\nfunction isStopIteration(exception) {\n    return (\n        object_toString(exception) === \"[object StopIteration]\" ||\n        exception instanceof QReturnValue\n    );\n}\n\n// FIXME: Remove this helper and Q.return once ES6 generators are in\n// SpiderMonkey.\nvar QReturnValue;\nif (typeof ReturnValue !== \"undefined\") {\n    QReturnValue = ReturnValue;\n} else {\n    QReturnValue = function (value) {\n        this.value = value;\n    };\n}\n\n// long stack traces\n\nvar STACK_JUMP_SEPARATOR = \"From previous event:\";\n\nfunction makeStackTraceLong(error, promise) {\n    // If possible, transform the error stack trace by removing Node and Q\n    // cruft, then concatenating with the stack trace of `promise`. See #57.\n    if (hasStacks &&\n        promise.stack &&\n        typeof error === \"object\" &&\n        error !== null &&\n        error.stack &&\n        error.stack.indexOf(STACK_JUMP_SEPARATOR) === -1\n    ) {\n        var stacks = [];\n        for (var p = promise; !!p; p = p.source) {\n            if (p.stack) {\n                stacks.unshift(p.stack);\n            }\n        }\n        stacks.unshift(error.stack);\n\n        var concatedStacks = stacks.join(\"\\n\" + STACK_JUMP_SEPARATOR + \"\\n\");\n        error.stack = filterStackString(concatedStacks);\n    }\n}\n\nfunction filterStackString(stackString) {\n    var lines = stackString.split(\"\\n\");\n    var desiredLines = [];\n    for (var i = 0; i < lines.length; ++i) {\n        var line = lines[i];\n\n        if (!isInternalFrame(line) && !isNodeFrame(line) && line) {\n            desiredLines.push(line);\n        }\n    }\n    return desiredLines.join(\"\\n\");\n}\n\nfunction isNodeFrame(stackLine) {\n    return stackLine.indexOf(\"(module.js:\") !== -1 ||\n           stackLine.indexOf(\"(node.js:\") !== -1;\n}\n\nfunction getFileNameAndLineNumber(stackLine) {\n    // Named functions: \"at functionName (filename:lineNumber:columnNumber)\"\n    // In IE10 function name can have spaces (\"Anonymous function\") O_o\n    var attempt1 = /at .+ \\((.+):(\\d+):(?:\\d+)\\)$/.exec(stackLine);\n    if (attempt1) {\n        return [attempt1[1], Number(attempt1[2])];\n    }\n\n    // Anonymous functions: \"at filename:lineNumber:columnNumber\"\n    var attempt2 = /at ([^ ]+):(\\d+):(?:\\d+)$/.exec(stackLine);\n    if (attempt2) {\n        return [attempt2[1], Number(attempt2[2])];\n    }\n\n    // Firefox style: \"function@filename:lineNumber or @filename:lineNumber\"\n    var attempt3 = /.*@(.+):(\\d+)$/.exec(stackLine);\n    if (attempt3) {\n        return [attempt3[1], Number(attempt3[2])];\n    }\n}\n\nfunction isInternalFrame(stackLine) {\n    var fileNameAndLineNumber = getFileNameAndLineNumber(stackLine);\n\n    if (!fileNameAndLineNumber) {\n        return false;\n    }\n\n    var fileName = fileNameAndLineNumber[0];\n    var lineNumber = fileNameAndLineNumber[1];\n\n    return fileName === qFileName &&\n        lineNumber >= qStartingLine &&\n        lineNumber <= qEndingLine;\n}\n\n// discover own file name and line number range for filtering stack\n// traces\nfunction captureLine() {\n    if (!hasStacks) {\n        return;\n    }\n\n    try {\n        throw new Error();\n    } catch (e) {\n        var lines = e.stack.split(\"\\n\");\n        var firstLine = lines[0].indexOf(\"@\") > 0 ? lines[1] : lines[2];\n        var fileNameAndLineNumber = getFileNameAndLineNumber(firstLine);\n        if (!fileNameAndLineNumber) {\n            return;\n        }\n\n        qFileName = fileNameAndLineNumber[0];\n        return fileNameAndLineNumber[1];\n    }\n}\n\nfunction deprecate(callback, name, alternative) {\n    return function () {\n        if (typeof console !== \"undefined\" &&\n            typeof console.warn === \"function\") {\n            console.warn(name + \" is deprecated, use \" + alternative +\n                         \" instead.\", new Error(\"\").stack);\n        }\n        return callback.apply(callback, arguments);\n    };\n}\n\n// end of shims\n// beginning of real work\n\n/**\n * Constructs a promise for an immediate reference, passes promises through, or\n * coerces promises from different systems.\n * @param value immediate reference or promise\n */\nfunction Q(value) {\n    // If the object is already a Promise, return it directly.  This enables\n    // the resolve function to both be used to created references from objects,\n    // but to tolerably coerce non-promises to promises.\n    if (value instanceof Promise) {\n        return value;\n    }\n\n    // assimilate thenables\n    if (isPromiseAlike(value)) {\n        return coerce(value);\n    } else {\n        return fulfill(value);\n    }\n}\nQ.resolve = Q;\n\n/**\n * Performs a task in a future turn of the event loop.\n * @param {Function} task\n */\nQ.nextTick = nextTick;\n\n/**\n * Controls whether or not long stack traces will be on\n */\nQ.longStackSupport = false;\n\n// enable long stacks if Q_DEBUG is set\nif (typeof process === \"object\" && process && process.env && process.env.Q_DEBUG) {\n    Q.longStackSupport = true;\n}\n\n/**\n * Constructs a {promise, resolve, reject} object.\n *\n * `resolve` is a callback to invoke with a more resolved value for the\n * promise. To fulfill the promise, invoke `resolve` with any value that is\n * not a thenable. To reject the promise, invoke `resolve` with a rejected\n * thenable, or invoke `reject` with the reason directly. To resolve the\n * promise to another thenable, thus putting it in the same state, invoke\n * `resolve` with that other thenable.\n */\nQ.defer = defer;\nfunction defer() {\n    // if \"messages\" is an \"Array\", that indicates that the promise has not yet\n    // been resolved.  If it is \"undefined\", it has been resolved.  Each\n    // element of the messages array is itself an array of complete arguments to\n    // forward to the resolved promise.  We coerce the resolution value to a\n    // promise using the `resolve` function because it handles both fully\n    // non-thenable values and other thenables gracefully.\n    var messages = [], progressListeners = [], resolvedPromise;\n\n    var deferred = object_create(defer.prototype);\n    var promise = object_create(Promise.prototype);\n\n    promise.promiseDispatch = function (resolve, op, operands) {\n        var args = array_slice(arguments);\n        if (messages) {\n            messages.push(args);\n            if (op === \"when\" && operands[1]) { // progress operand\n                progressListeners.push(operands[1]);\n            }\n        } else {\n            Q.nextTick(function () {\n                resolvedPromise.promiseDispatch.apply(resolvedPromise, args);\n            });\n        }\n    };\n\n    // XXX deprecated\n    promise.valueOf = function () {\n        if (messages) {\n            return promise;\n        }\n        var nearerValue = nearer(resolvedPromise);\n        if (isPromise(nearerValue)) {\n            resolvedPromise = nearerValue; // shorten chain\n        }\n        return nearerValue;\n    };\n\n    promise.inspect = function () {\n        if (!resolvedPromise) {\n            return { state: \"pending\" };\n        }\n        return resolvedPromise.inspect();\n    };\n\n    if (Q.longStackSupport && hasStacks) {\n        try {\n            throw new Error();\n        } catch (e) {\n            // NOTE: don't try to use `Error.captureStackTrace` or transfer the\n            // accessor around; that causes memory leaks as per GH-111. Just\n            // reify the stack trace as a string ASAP.\n            //\n            // At the same time, cut off the first line; it's always just\n            // \"[object Promise]\\n\", as per the `toString`.\n            promise.stack = e.stack.substring(e.stack.indexOf(\"\\n\") + 1);\n        }\n    }\n\n    // NOTE: we do the checks for `resolvedPromise` in each method, instead of\n    // consolidating them into `become`, since otherwise we'd create new\n    // promises with the lines `become(whatever(value))`. See e.g. GH-252.\n\n    function become(newPromise) {\n        resolvedPromise = newPromise;\n        promise.source = newPromise;\n\n        array_reduce(messages, function (undefined, message) {\n            Q.nextTick(function () {\n                newPromise.promiseDispatch.apply(newPromise, message);\n            });\n        }, void 0);\n\n        messages = void 0;\n        progressListeners = void 0;\n    }\n\n    deferred.promise = promise;\n    deferred.resolve = function (value) {\n        if (resolvedPromise) {\n            return;\n        }\n\n        become(Q(value));\n    };\n\n    deferred.fulfill = function (value) {\n        if (resolvedPromise) {\n            return;\n        }\n\n        become(fulfill(value));\n    };\n    deferred.reject = function (reason) {\n        if (resolvedPromise) {\n            return;\n        }\n\n        become(reject(reason));\n    };\n    deferred.notify = function (progress) {\n        if (resolvedPromise) {\n            return;\n        }\n\n        array_reduce(progressListeners, function (undefined, progressListener) {\n            Q.nextTick(function () {\n                progressListener(progress);\n            });\n        }, void 0);\n    };\n\n    return deferred;\n}\n\n/**\n * Creates a Node-style callback that will resolve or reject the deferred\n * promise.\n * @returns a nodeback\n */\ndefer.prototype.makeNodeResolver = function () {\n    var self = this;\n    return function (error, value) {\n        if (error) {\n            self.reject(error);\n        } else if (arguments.length > 2) {\n            self.resolve(array_slice(arguments, 1));\n        } else {\n            self.resolve(value);\n        }\n    };\n};\n\n/**\n * @param resolver {Function} a function that returns nothing and accepts\n * the resolve, reject, and notify functions for a deferred.\n * @returns a promise that may be resolved with the given resolve and reject\n * functions, or rejected by a thrown exception in resolver\n */\nQ.Promise = promise; // ES6\nQ.promise = promise;\nfunction promise(resolver) {\n    if (typeof resolver !== \"function\") {\n        throw new TypeError(\"resolver must be a function.\");\n    }\n    var deferred = defer();\n    try {\n        resolver(deferred.resolve, deferred.reject, deferred.notify);\n    } catch (reason) {\n        deferred.reject(reason);\n    }\n    return deferred.promise;\n}\n\npromise.race = race; // ES6\npromise.all = all; // ES6\npromise.reject = reject; // ES6\npromise.resolve = Q; // ES6\n\n// XXX experimental.  This method is a way to denote that a local value is\n// serializable and should be immediately dispatched to a remote upon request,\n// instead of passing a reference.\nQ.passByCopy = function (object) {\n    //freeze(object);\n    //passByCopies.set(object, true);\n    return object;\n};\n\nPromise.prototype.passByCopy = function () {\n    //freeze(object);\n    //passByCopies.set(object, true);\n    return this;\n};\n\n/**\n * If two promises eventually fulfill to the same value, promises that value,\n * but otherwise rejects.\n * @param x {Any*}\n * @param y {Any*}\n * @returns {Any*} a promise for x and y if they are the same, but a rejection\n * otherwise.\n *\n */\nQ.join = function (x, y) {\n    return Q(x).join(y);\n};\n\nPromise.prototype.join = function (that) {\n    return Q([this, that]).spread(function (x, y) {\n        if (x === y) {\n            // TODO: \"===\" should be Object.is or equiv\n            return x;\n        } else {\n            throw new Error(\"Can't join: not the same: \" + x + \" \" + y);\n        }\n    });\n};\n\n/**\n * Returns a promise for the first of an array of promises to become settled.\n * @param answers {Array[Any*]} promises to race\n * @returns {Any*} the first promise to be settled\n */\nQ.race = race;\nfunction race(answerPs) {\n    return promise(function (resolve, reject) {\n        // Switch to this once we can assume at least ES5\n        // answerPs.forEach(function (answerP) {\n        //     Q(answerP).then(resolve, reject);\n        // });\n        // Use this in the meantime\n        for (var i = 0, len = answerPs.length; i < len; i++) {\n            Q(answerPs[i]).then(resolve, reject);\n        }\n    });\n}\n\nPromise.prototype.race = function () {\n    return this.then(Q.race);\n};\n\n/**\n * Constructs a Promise with a promise descriptor object and optional fallback\n * function.  The descriptor contains methods like when(rejected), get(name),\n * set(name, value), post(name, args), and delete(name), which all\n * return either a value, a promise for a value, or a rejection.  The fallback\n * accepts the operation name, a resolver, and any further arguments that would\n * have been forwarded to the appropriate method above had a method been\n * provided with the proper name.  The API makes no guarantees about the nature\n * of the returned object, apart from that it is usable whereever promises are\n * bought and sold.\n */\nQ.makePromise = Promise;\nfunction Promise(descriptor, fallback, inspect) {\n    if (fallback === void 0) {\n        fallback = function (op) {\n            return reject(new Error(\n                \"Promise does not support operation: \" + op\n            ));\n        };\n    }\n    if (inspect === void 0) {\n        inspect = function () {\n            return {state: \"unknown\"};\n        };\n    }\n\n    var promise = object_create(Promise.prototype);\n\n    promise.promiseDispatch = function (resolve, op, args) {\n        var result;\n        try {\n            if (descriptor[op]) {\n                result = descriptor[op].apply(promise, args);\n            } else {\n                result = fallback.call(promise, op, args);\n            }\n        } catch (exception) {\n            result = reject(exception);\n        }\n        if (resolve) {\n            resolve(result);\n        }\n    };\n\n    promise.inspect = inspect;\n\n    // XXX deprecated `valueOf` and `exception` support\n    if (inspect) {\n        var inspected = inspect();\n        if (inspected.state === \"rejected\") {\n            promise.exception = inspected.reason;\n        }\n\n        promise.valueOf = function () {\n            var inspected = inspect();\n            if (inspected.state === \"pending\" ||\n                inspected.state === \"rejected\") {\n                return promise;\n            }\n            return inspected.value;\n        };\n    }\n\n    return promise;\n}\n\nPromise.prototype.toString = function () {\n    return \"[object Promise]\";\n};\n\nPromise.prototype.then = function (fulfilled, rejected, progressed) {\n    var self = this;\n    var deferred = defer();\n    var done = false;   // ensure the untrusted promise makes at most a\n                        // single call to one of the callbacks\n\n    function _fulfilled(value) {\n        try {\n            return typeof fulfilled === \"function\" ? fulfilled(value) : value;\n        } catch (exception) {\n            return reject(exception);\n        }\n    }\n\n    function _rejected(exception) {\n        if (typeof rejected === \"function\") {\n            makeStackTraceLong(exception, self);\n            try {\n                return rejected(exception);\n            } catch (newException) {\n                return reject(newException);\n            }\n        }\n        return reject(exception);\n    }\n\n    function _progressed(value) {\n        return typeof progressed === \"function\" ? progressed(value) : value;\n    }\n\n    Q.nextTick(function () {\n        self.promiseDispatch(function (value) {\n            if (done) {\n                return;\n            }\n            done = true;\n\n            deferred.resolve(_fulfilled(value));\n        }, \"when\", [function (exception) {\n            if (done) {\n                return;\n            }\n            done = true;\n\n            deferred.resolve(_rejected(exception));\n        }]);\n    });\n\n    // Progress propagator need to be attached in the current tick.\n    self.promiseDispatch(void 0, \"when\", [void 0, function (value) {\n        var newValue;\n        var threw = false;\n        try {\n            newValue = _progressed(value);\n        } catch (e) {\n            threw = true;\n            if (Q.onerror) {\n                Q.onerror(e);\n            } else {\n                throw e;\n            }\n        }\n\n        if (!threw) {\n            deferred.notify(newValue);\n        }\n    }]);\n\n    return deferred.promise;\n};\n\nQ.tap = function (promise, callback) {\n    return Q(promise).tap(callback);\n};\n\n/**\n * Works almost like \"finally\", but not called for rejections.\n * Original resolution value is passed through callback unaffected.\n * Callback may return a promise that will be awaited for.\n * @param {Function} callback\n * @returns {Q.Promise}\n * @example\n * doSomething()\n *   .then(...)\n *   .tap(console.log)\n *   .then(...);\n */\nPromise.prototype.tap = function (callback) {\n    callback = Q(callback);\n\n    return this.then(function (value) {\n        return callback.fcall(value).thenResolve(value);\n    });\n};\n\n/**\n * Registers an observer on a promise.\n *\n * Guarantees:\n *\n * 1. that fulfilled and rejected will be called only once.\n * 2. that either the fulfilled callback or the rejected callback will be\n *    called, but not both.\n * 3. that fulfilled and rejected will not be called in this turn.\n *\n * @param value      promise or immediate reference to observe\n * @param fulfilled  function to be called with the fulfilled value\n * @param rejected   function to be called with the rejection exception\n * @param progressed function to be called on any progress notifications\n * @return promise for the return value from the invoked callback\n */\nQ.when = when;\nfunction when(value, fulfilled, rejected, progressed) {\n    return Q(value).then(fulfilled, rejected, progressed);\n}\n\nPromise.prototype.thenResolve = function (value) {\n    return this.then(function () { return value; });\n};\n\nQ.thenResolve = function (promise, value) {\n    return Q(promise).thenResolve(value);\n};\n\nPromise.prototype.thenReject = function (reason) {\n    return this.then(function () { throw reason; });\n};\n\nQ.thenReject = function (promise, reason) {\n    return Q(promise).thenReject(reason);\n};\n\n/**\n * If an object is not a promise, it is as \"near\" as possible.\n * If a promise is rejected, it is as \"near\" as possible too.\n * If it’s a fulfilled promise, the fulfillment value is nearer.\n * If it’s a deferred promise and the deferred has been resolved, the\n * resolution is \"nearer\".\n * @param object\n * @returns most resolved (nearest) form of the object\n */\n\n// XXX should we re-do this?\nQ.nearer = nearer;\nfunction nearer(value) {\n    if (isPromise(value)) {\n        var inspected = value.inspect();\n        if (inspected.state === \"fulfilled\") {\n            return inspected.value;\n        }\n    }\n    return value;\n}\n\n/**\n * @returns whether the given object is a promise.\n * Otherwise it is a fulfilled value.\n */\nQ.isPromise = isPromise;\nfunction isPromise(object) {\n    return object instanceof Promise;\n}\n\nQ.isPromiseAlike = isPromiseAlike;\nfunction isPromiseAlike(object) {\n    return isObject(object) && typeof object.then === \"function\";\n}\n\n/**\n * @returns whether the given object is a pending promise, meaning not\n * fulfilled or rejected.\n */\nQ.isPending = isPending;\nfunction isPending(object) {\n    return isPromise(object) && object.inspect().state === \"pending\";\n}\n\nPromise.prototype.isPending = function () {\n    return this.inspect().state === \"pending\";\n};\n\n/**\n * @returns whether the given object is a value or fulfilled\n * promise.\n */\nQ.isFulfilled = isFulfilled;\nfunction isFulfilled(object) {\n    return !isPromise(object) || object.inspect().state === \"fulfilled\";\n}\n\nPromise.prototype.isFulfilled = function () {\n    return this.inspect().state === \"fulfilled\";\n};\n\n/**\n * @returns whether the given object is a rejected promise.\n */\nQ.isRejected = isRejected;\nfunction isRejected(object) {\n    return isPromise(object) && object.inspect().state === \"rejected\";\n}\n\nPromise.prototype.isRejected = function () {\n    return this.inspect().state === \"rejected\";\n};\n\n//// BEGIN UNHANDLED REJECTION TRACKING\n\n// This promise library consumes exceptions thrown in handlers so they can be\n// handled by a subsequent promise.  The exceptions get added to this array when\n// they are created, and removed when they are handled.  Note that in ES6 or\n// shimmed environments, this would naturally be a `Set`.\nvar unhandledReasons = [];\nvar unhandledRejections = [];\nvar reportedUnhandledRejections = [];\nvar trackUnhandledRejections = true;\n\nfunction resetUnhandledRejections() {\n    unhandledReasons.length = 0;\n    unhandledRejections.length = 0;\n\n    if (!trackUnhandledRejections) {\n        trackUnhandledRejections = true;\n    }\n}\n\nfunction trackRejection(promise, reason) {\n    if (!trackUnhandledRejections) {\n        return;\n    }\n    if (typeof process === \"object\" && typeof process.emit === \"function\") {\n        Q.nextTick.runAfter(function () {\n            if (array_indexOf(unhandledRejections, promise) !== -1) {\n                process.emit(\"unhandledRejection\", reason, promise);\n                reportedUnhandledRejections.push(promise);\n            }\n        });\n    }\n\n    unhandledRejections.push(promise);\n    if (reason && typeof reason.stack !== \"undefined\") {\n        unhandledReasons.push(reason.stack);\n    } else {\n        unhandledReasons.push(\"(no stack) \" + reason);\n    }\n}\n\nfunction untrackRejection(promise) {\n    if (!trackUnhandledRejections) {\n        return;\n    }\n\n    var at = array_indexOf(unhandledRejections, promise);\n    if (at !== -1) {\n        if (typeof process === \"object\" && typeof process.emit === \"function\") {\n            Q.nextTick.runAfter(function () {\n                var atReport = array_indexOf(reportedUnhandledRejections, promise);\n                if (atReport !== -1) {\n                    process.emit(\"rejectionHandled\", unhandledReasons[at], promise);\n                    reportedUnhandledRejections.splice(atReport, 1);\n                }\n            });\n        }\n        unhandledRejections.splice(at, 1);\n        unhandledReasons.splice(at, 1);\n    }\n}\n\nQ.resetUnhandledRejections = resetUnhandledRejections;\n\nQ.getUnhandledReasons = function () {\n    // Make a copy so that consumers can't interfere with our internal state.\n    return unhandledReasons.slice();\n};\n\nQ.stopUnhandledRejectionTracking = function () {\n    resetUnhandledRejections();\n    trackUnhandledRejections = false;\n};\n\nresetUnhandledRejections();\n\n//// END UNHANDLED REJECTION TRACKING\n\n/**\n * Constructs a rejected promise.\n * @param reason value describing the failure\n */\nQ.reject = reject;\nfunction reject(reason) {\n    var rejection = Promise({\n        \"when\": function (rejected) {\n            // note that the error has been handled\n            if (rejected) {\n                untrackRejection(this);\n            }\n            return rejected ? rejected(reason) : this;\n        }\n    }, function fallback() {\n        return this;\n    }, function inspect() {\n        return { state: \"rejected\", reason: reason };\n    });\n\n    // Note that the reason has not been handled.\n    trackRejection(rejection, reason);\n\n    return rejection;\n}\n\n/**\n * Constructs a fulfilled promise for an immediate reference.\n * @param value immediate reference\n */\nQ.fulfill = fulfill;\nfunction fulfill(value) {\n    return Promise({\n        \"when\": function () {\n            return value;\n        },\n        \"get\": function (name) {\n            return value[name];\n        },\n        \"set\": function (name, rhs) {\n            value[name] = rhs;\n        },\n        \"delete\": function (name) {\n            delete value[name];\n        },\n        \"post\": function (name, args) {\n            // Mark Miller proposes that post with no name should apply a\n            // promised function.\n            if (name === null || name === void 0) {\n                return value.apply(void 0, args);\n            } else {\n                return value[name].apply(value, args);\n            }\n        },\n        \"apply\": function (thisp, args) {\n            return value.apply(thisp, args);\n        },\n        \"keys\": function () {\n            return object_keys(value);\n        }\n    }, void 0, function inspect() {\n        return { state: \"fulfilled\", value: value };\n    });\n}\n\n/**\n * Converts thenables to Q promises.\n * @param promise thenable promise\n * @returns a Q promise\n */\nfunction coerce(promise) {\n    var deferred = defer();\n    Q.nextTick(function () {\n        try {\n            promise.then(deferred.resolve, deferred.reject, deferred.notify);\n        } catch (exception) {\n            deferred.reject(exception);\n        }\n    });\n    return deferred.promise;\n}\n\n/**\n * Annotates an object such that it will never be\n * transferred away from this process over any promise\n * communication channel.\n * @param object\n * @returns promise a wrapping of that object that\n * additionally responds to the \"isDef\" message\n * without a rejection.\n */\nQ.master = master;\nfunction master(object) {\n    return Promise({\n        \"isDef\": function () {}\n    }, function fallback(op, args) {\n        return dispatch(object, op, args);\n    }, function () {\n        return Q(object).inspect();\n    });\n}\n\n/**\n * Spreads the values of a promised array of arguments into the\n * fulfillment callback.\n * @param fulfilled callback that receives variadic arguments from the\n * promised array\n * @param rejected callback that receives the exception if the promise\n * is rejected.\n * @returns a promise for the return value or thrown exception of\n * either callback.\n */\nQ.spread = spread;\nfunction spread(value, fulfilled, rejected) {\n    return Q(value).spread(fulfilled, rejected);\n}\n\nPromise.prototype.spread = function (fulfilled, rejected) {\n    return this.all().then(function (array) {\n        return fulfilled.apply(void 0, array);\n    }, rejected);\n};\n\n/**\n * The async function is a decorator for generator functions, turning\n * them into asynchronous generators.  Although generators are only part\n * of the newest ECMAScript 6 drafts, this code does not cause syntax\n * errors in older engines.  This code should continue to work and will\n * in fact improve over time as the language improves.\n *\n * ES6 generators are currently part of V8 version 3.19 with the\n * --harmony-generators runtime flag enabled.  SpiderMonkey has had them\n * for longer, but under an older Python-inspired form.  This function\n * works on both kinds of generators.\n *\n * Decorates a generator function such that:\n *  - it may yield promises\n *  - execution will continue when that promise is fulfilled\n *  - the value of the yield expression will be the fulfilled value\n *  - it returns a promise for the return value (when the generator\n *    stops iterating)\n *  - the decorated function returns a promise for the return value\n *    of the generator or the first rejected promise among those\n *    yielded.\n *  - if an error is thrown in the generator, it propagates through\n *    every following yield until it is caught, or until it escapes\n *    the generator function altogether, and is translated into a\n *    rejection for the promise returned by the decorated generator.\n */\nQ.async = async;\nfunction async(makeGenerator) {\n    return function () {\n        // when verb is \"send\", arg is a value\n        // when verb is \"throw\", arg is an exception\n        function continuer(verb, arg) {\n            var result;\n\n            // Until V8 3.19 / Chromium 29 is released, SpiderMonkey is the only\n            // engine that has a deployed base of browsers that support generators.\n            // However, SM's generators use the Python-inspired semantics of\n            // outdated ES6 drafts.  We would like to support ES6, but we'd also\n            // like to make it possible to use generators in deployed browsers, so\n            // we also support Python-style generators.  At some point we can remove\n            // this block.\n\n            if (typeof StopIteration === \"undefined\") {\n                // ES6 Generators\n                try {\n                    result = generator[verb](arg);\n                } catch (exception) {\n                    return reject(exception);\n                }\n                if (result.done) {\n                    return Q(result.value);\n                } else {\n                    return when(result.value, callback, errback);\n                }\n            } else {\n                // SpiderMonkey Generators\n                // FIXME: Remove this case when SM does ES6 generators.\n                try {\n                    result = generator[verb](arg);\n                } catch (exception) {\n                    if (isStopIteration(exception)) {\n                        return Q(exception.value);\n                    } else {\n                        return reject(exception);\n                    }\n                }\n                return when(result, callback, errback);\n            }\n        }\n        var generator = makeGenerator.apply(this, arguments);\n        var callback = continuer.bind(continuer, \"next\");\n        var errback = continuer.bind(continuer, \"throw\");\n        return callback();\n    };\n}\n\n/**\n * The spawn function is a small wrapper around async that immediately\n * calls the generator and also ends the promise chain, so that any\n * unhandled errors are thrown instead of forwarded to the error\n * handler. This is useful because it's extremely common to run\n * generators at the top-level to work with libraries.\n */\nQ.spawn = spawn;\nfunction spawn(makeGenerator) {\n    Q.done(Q.async(makeGenerator)());\n}\n\n// FIXME: Remove this interface once ES6 generators are in SpiderMonkey.\n/**\n * Throws a ReturnValue exception to stop an asynchronous generator.\n *\n * This interface is a stop-gap measure to support generator return\n * values in older Firefox/SpiderMonkey.  In browsers that support ES6\n * generators like Chromium 29, just use \"return\" in your generator\n * functions.\n *\n * @param value the return value for the surrounding generator\n * @throws ReturnValue exception with the value.\n * @example\n * // ES6 style\n * Q.async(function* () {\n *      var foo = yield getFooPromise();\n *      var bar = yield getBarPromise();\n *      return foo + bar;\n * })\n * // Older SpiderMonkey style\n * Q.async(function () {\n *      var foo = yield getFooPromise();\n *      var bar = yield getBarPromise();\n *      Q.return(foo + bar);\n * })\n */\nQ[\"return\"] = _return;\nfunction _return(value) {\n    throw new QReturnValue(value);\n}\n\n/**\n * The promised function decorator ensures that any promise arguments\n * are settled and passed as values (`this` is also settled and passed\n * as a value).  It will also ensure that the result of a function is\n * always a promise.\n *\n * @example\n * var add = Q.promised(function (a, b) {\n *     return a + b;\n * });\n * add(Q(a), Q(B));\n *\n * @param {function} callback The function to decorate\n * @returns {function} a function that has been decorated.\n */\nQ.promised = promised;\nfunction promised(callback) {\n    return function () {\n        return spread([this, all(arguments)], function (self, args) {\n            return callback.apply(self, args);\n        });\n    };\n}\n\n/**\n * sends a message to a value in a future turn\n * @param object* the recipient\n * @param op the name of the message operation, e.g., \"when\",\n * @param args further arguments to be forwarded to the operation\n * @returns result {Promise} a promise for the result of the operation\n */\nQ.dispatch = dispatch;\nfunction dispatch(object, op, args) {\n    return Q(object).dispatch(op, args);\n}\n\nPromise.prototype.dispatch = function (op, args) {\n    var self = this;\n    var deferred = defer();\n    Q.nextTick(function () {\n        self.promiseDispatch(deferred.resolve, op, args);\n    });\n    return deferred.promise;\n};\n\n/**\n * Gets the value of a property in a future turn.\n * @param object    promise or immediate reference for target object\n * @param name      name of property to get\n * @return promise for the property value\n */\nQ.get = function (object, key) {\n    return Q(object).dispatch(\"get\", [key]);\n};\n\nPromise.prototype.get = function (key) {\n    return this.dispatch(\"get\", [key]);\n};\n\n/**\n * Sets the value of a property in a future turn.\n * @param object    promise or immediate reference for object object\n * @param name      name of property to set\n * @param value     new value of property\n * @return promise for the return value\n */\nQ.set = function (object, key, value) {\n    return Q(object).dispatch(\"set\", [key, value]);\n};\n\nPromise.prototype.set = function (key, value) {\n    return this.dispatch(\"set\", [key, value]);\n};\n\n/**\n * Deletes a property in a future turn.\n * @param object    promise or immediate reference for target object\n * @param name      name of property to delete\n * @return promise for the return value\n */\nQ.del = // XXX legacy\nQ[\"delete\"] = function (object, key) {\n    return Q(object).dispatch(\"delete\", [key]);\n};\n\nPromise.prototype.del = // XXX legacy\nPromise.prototype[\"delete\"] = function (key) {\n    return this.dispatch(\"delete\", [key]);\n};\n\n/**\n * Invokes a method in a future turn.\n * @param object    promise or immediate reference for target object\n * @param name      name of method to invoke\n * @param value     a value to post, typically an array of\n *                  invocation arguments for promises that\n *                  are ultimately backed with `resolve` values,\n *                  as opposed to those backed with URLs\n *                  wherein the posted value can be any\n *                  JSON serializable object.\n * @return promise for the return value\n */\n// bound locally because it is used by other methods\nQ.mapply = // XXX As proposed by \"Redsandro\"\nQ.post = function (object, name, args) {\n    return Q(object).dispatch(\"post\", [name, args]);\n};\n\nPromise.prototype.mapply = // XXX As proposed by \"Redsandro\"\nPromise.prototype.post = function (name, args) {\n    return this.dispatch(\"post\", [name, args]);\n};\n\n/**\n * Invokes a method in a future turn.\n * @param object    promise or immediate reference for target object\n * @param name      name of method to invoke\n * @param ...args   array of invocation arguments\n * @return promise for the return value\n */\nQ.send = // XXX Mark Miller's proposed parlance\nQ.mcall = // XXX As proposed by \"Redsandro\"\nQ.invoke = function (object, name /*...args*/) {\n    return Q(object).dispatch(\"post\", [name, array_slice(arguments, 2)]);\n};\n\nPromise.prototype.send = // XXX Mark Miller's proposed parlance\nPromise.prototype.mcall = // XXX As proposed by \"Redsandro\"\nPromise.prototype.invoke = function (name /*...args*/) {\n    return this.dispatch(\"post\", [name, array_slice(arguments, 1)]);\n};\n\n/**\n * Applies the promised function in a future turn.\n * @param object    promise or immediate reference for target function\n * @param args      array of application arguments\n */\nQ.fapply = function (object, args) {\n    return Q(object).dispatch(\"apply\", [void 0, args]);\n};\n\nPromise.prototype.fapply = function (args) {\n    return this.dispatch(\"apply\", [void 0, args]);\n};\n\n/**\n * Calls the promised function in a future turn.\n * @param object    promise or immediate reference for target function\n * @param ...args   array of application arguments\n */\nQ[\"try\"] =\nQ.fcall = function (object /* ...args*/) {\n    return Q(object).dispatch(\"apply\", [void 0, array_slice(arguments, 1)]);\n};\n\nPromise.prototype.fcall = function (/*...args*/) {\n    return this.dispatch(\"apply\", [void 0, array_slice(arguments)]);\n};\n\n/**\n * Binds the promised function, transforming return values into a fulfilled\n * promise and thrown errors into a rejected one.\n * @param object    promise or immediate reference for target function\n * @param ...args   array of application arguments\n */\nQ.fbind = function (object /*...args*/) {\n    var promise = Q(object);\n    var args = array_slice(arguments, 1);\n    return function fbound() {\n        return promise.dispatch(\"apply\", [\n            this,\n            args.concat(array_slice(arguments))\n        ]);\n    };\n};\nPromise.prototype.fbind = function (/*...args*/) {\n    var promise = this;\n    var args = array_slice(arguments);\n    return function fbound() {\n        return promise.dispatch(\"apply\", [\n            this,\n            args.concat(array_slice(arguments))\n        ]);\n    };\n};\n\n/**\n * Requests the names of the owned properties of a promised\n * object in a future turn.\n * @param object    promise or immediate reference for target object\n * @return promise for the keys of the eventually settled object\n */\nQ.keys = function (object) {\n    return Q(object).dispatch(\"keys\", []);\n};\n\nPromise.prototype.keys = function () {\n    return this.dispatch(\"keys\", []);\n};\n\n/**\n * Turns an array of promises into a promise for an array.  If any of\n * the promises gets rejected, the whole array is rejected immediately.\n * @param {Array*} an array (or promise for an array) of values (or\n * promises for values)\n * @returns a promise for an array of the corresponding values\n */\n// By Mark Miller\n// http://wiki.ecmascript.org/doku.php?id=strawman:concurrency&rev=1308776521#allfulfilled\nQ.all = all;\nfunction all(promises) {\n    return when(promises, function (promises) {\n        var pendingCount = 0;\n        var deferred = defer();\n        array_reduce(promises, function (undefined, promise, index) {\n            var snapshot;\n            if (\n                isPromise(promise) &&\n                (snapshot = promise.inspect()).state === \"fulfilled\"\n            ) {\n                promises[index] = snapshot.value;\n            } else {\n                ++pendingCount;\n                when(\n                    promise,\n                    function (value) {\n                        promises[index] = value;\n                        if (--pendingCount === 0) {\n                            deferred.resolve(promises);\n                        }\n                    },\n                    deferred.reject,\n                    function (progress) {\n                        deferred.notify({ index: index, value: progress });\n                    }\n                );\n            }\n        }, void 0);\n        if (pendingCount === 0) {\n            deferred.resolve(promises);\n        }\n        return deferred.promise;\n    });\n}\n\nPromise.prototype.all = function () {\n    return all(this);\n};\n\n/**\n * Returns the first resolved promise of an array. Prior rejected promises are\n * ignored.  Rejects only if all promises are rejected.\n * @param {Array*} an array containing values or promises for values\n * @returns a promise fulfilled with the value of the first resolved promise,\n * or a rejected promise if all promises are rejected.\n */\nQ.any = any;\n\nfunction any(promises) {\n    if (promises.length === 0) {\n        return Q.resolve();\n    }\n\n    var deferred = Q.defer();\n    var pendingCount = 0;\n    array_reduce(promises, function (prev, current, index) {\n        var promise = promises[index];\n\n        pendingCount++;\n\n        when(promise, onFulfilled, onRejected, onProgress);\n        function onFulfilled(result) {\n            deferred.resolve(result);\n        }\n        function onRejected() {\n            pendingCount--;\n            if (pendingCount === 0) {\n                deferred.reject(new Error(\n                    \"Can't get fulfillment value from any promise, all \" +\n                    \"promises were rejected.\"\n                ));\n            }\n        }\n        function onProgress(progress) {\n            deferred.notify({\n                index: index,\n                value: progress\n            });\n        }\n    }, undefined);\n\n    return deferred.promise;\n}\n\nPromise.prototype.any = function () {\n    return any(this);\n};\n\n/**\n * Waits for all promises to be settled, either fulfilled or\n * rejected.  This is distinct from `all` since that would stop\n * waiting at the first rejection.  The promise returned by\n * `allResolved` will never be rejected.\n * @param promises a promise for an array (or an array) of promises\n * (or values)\n * @return a promise for an array of promises\n */\nQ.allResolved = deprecate(allResolved, \"allResolved\", \"allSettled\");\nfunction allResolved(promises) {\n    return when(promises, function (promises) {\n        promises = array_map(promises, Q);\n        return when(all(array_map(promises, function (promise) {\n            return when(promise, noop, noop);\n        })), function () {\n            return promises;\n        });\n    });\n}\n\nPromise.prototype.allResolved = function () {\n    return allResolved(this);\n};\n\n/**\n * @see Promise#allSettled\n */\nQ.allSettled = allSettled;\nfunction allSettled(promises) {\n    return Q(promises).allSettled();\n}\n\n/**\n * Turns an array of promises into a promise for an array of their states (as\n * returned by `inspect`) when they have all settled.\n * @param {Array[Any*]} values an array (or promise for an array) of values (or\n * promises for values)\n * @returns {Array[State]} an array of states for the respective values.\n */\nPromise.prototype.allSettled = function () {\n    return this.then(function (promises) {\n        return all(array_map(promises, function (promise) {\n            promise = Q(promise);\n            function regardless() {\n                return promise.inspect();\n            }\n            return promise.then(regardless, regardless);\n        }));\n    });\n};\n\n/**\n * Captures the failure of a promise, giving an oportunity to recover\n * with a callback.  If the given promise is fulfilled, the returned\n * promise is fulfilled.\n * @param {Any*} promise for something\n * @param {Function} callback to fulfill the returned promise if the\n * given promise is rejected\n * @returns a promise for the return value of the callback\n */\nQ.fail = // XXX legacy\nQ[\"catch\"] = function (object, rejected) {\n    return Q(object).then(void 0, rejected);\n};\n\nPromise.prototype.fail = // XXX legacy\nPromise.prototype[\"catch\"] = function (rejected) {\n    return this.then(void 0, rejected);\n};\n\n/**\n * Attaches a listener that can respond to progress notifications from a\n * promise's originating deferred. This listener receives the exact arguments\n * passed to ``deferred.notify``.\n * @param {Any*} promise for something\n * @param {Function} callback to receive any progress notifications\n * @returns the given promise, unchanged\n */\nQ.progress = progress;\nfunction progress(object, progressed) {\n    return Q(object).then(void 0, void 0, progressed);\n}\n\nPromise.prototype.progress = function (progressed) {\n    return this.then(void 0, void 0, progressed);\n};\n\n/**\n * Provides an opportunity to observe the settling of a promise,\n * regardless of whether the promise is fulfilled or rejected.  Forwards\n * the resolution to the returned promise when the callback is done.\n * The callback can return a promise to defer completion.\n * @param {Any*} promise\n * @param {Function} callback to observe the resolution of the given\n * promise, takes no arguments.\n * @returns a promise for the resolution of the given promise when\n * ``fin`` is done.\n */\nQ.fin = // XXX legacy\nQ[\"finally\"] = function (object, callback) {\n    return Q(object)[\"finally\"](callback);\n};\n\nPromise.prototype.fin = // XXX legacy\nPromise.prototype[\"finally\"] = function (callback) {\n    callback = Q(callback);\n    return this.then(function (value) {\n        return callback.fcall().then(function () {\n            return value;\n        });\n    }, function (reason) {\n        // TODO attempt to recycle the rejection with \"this\".\n        return callback.fcall().then(function () {\n            throw reason;\n        });\n    });\n};\n\n/**\n * Terminates a chain of promises, forcing rejections to be\n * thrown as exceptions.\n * @param {Any*} promise at the end of a chain of promises\n * @returns nothing\n */\nQ.done = function (object, fulfilled, rejected, progress) {\n    return Q(object).done(fulfilled, rejected, progress);\n};\n\nPromise.prototype.done = function (fulfilled, rejected, progress) {\n    var onUnhandledError = function (error) {\n        // forward to a future turn so that ``when``\n        // does not catch it and turn it into a rejection.\n        Q.nextTick(function () {\n            makeStackTraceLong(error, promise);\n            if (Q.onerror) {\n                Q.onerror(error);\n            } else {\n                throw error;\n            }\n        });\n    };\n\n    // Avoid unnecessary `nextTick`ing via an unnecessary `when`.\n    var promise = fulfilled || rejected || progress ?\n        this.then(fulfilled, rejected, progress) :\n        this;\n\n    if (typeof process === \"object\" && process && process.domain) {\n        onUnhandledError = process.domain.bind(onUnhandledError);\n    }\n\n    promise.then(void 0, onUnhandledError);\n};\n\n/**\n * Causes a promise to be rejected if it does not get fulfilled before\n * some milliseconds time out.\n * @param {Any*} promise\n * @param {Number} milliseconds timeout\n * @param {Any*} custom error message or Error object (optional)\n * @returns a promise for the resolution of the given promise if it is\n * fulfilled before the timeout, otherwise rejected.\n */\nQ.timeout = function (object, ms, error) {\n    return Q(object).timeout(ms, error);\n};\n\nPromise.prototype.timeout = function (ms, error) {\n    var deferred = defer();\n    var timeoutId = setTimeout(function () {\n        if (!error || \"string\" === typeof error) {\n            error = new Error(error || \"Timed out after \" + ms + \" ms\");\n            error.code = \"ETIMEDOUT\";\n        }\n        deferred.reject(error);\n    }, ms);\n\n    this.then(function (value) {\n        clearTimeout(timeoutId);\n        deferred.resolve(value);\n    }, function (exception) {\n        clearTimeout(timeoutId);\n        deferred.reject(exception);\n    }, deferred.notify);\n\n    return deferred.promise;\n};\n\n/**\n * Returns a promise for the given value (or promised value), some\n * milliseconds after it resolved. Passes rejections immediately.\n * @param {Any*} promise\n * @param {Number} milliseconds\n * @returns a promise for the resolution of the given promise after milliseconds\n * time has elapsed since the resolution of the given promise.\n * If the given promise rejects, that is passed immediately.\n */\nQ.delay = function (object, timeout) {\n    if (timeout === void 0) {\n        timeout = object;\n        object = void 0;\n    }\n    return Q(object).delay(timeout);\n};\n\nPromise.prototype.delay = function (timeout) {\n    return this.then(function (value) {\n        var deferred = defer();\n        setTimeout(function () {\n            deferred.resolve(value);\n        }, timeout);\n        return deferred.promise;\n    });\n};\n\n/**\n * Passes a continuation to a Node function, which is called with the given\n * arguments provided as an array, and returns a promise.\n *\n *      Q.nfapply(FS.readFile, [__filename])\n *      .then(function (content) {\n *      })\n *\n */\nQ.nfapply = function (callback, args) {\n    return Q(callback).nfapply(args);\n};\n\nPromise.prototype.nfapply = function (args) {\n    var deferred = defer();\n    var nodeArgs = array_slice(args);\n    nodeArgs.push(deferred.makeNodeResolver());\n    this.fapply(nodeArgs).fail(deferred.reject);\n    return deferred.promise;\n};\n\n/**\n * Passes a continuation to a Node function, which is called with the given\n * arguments provided individually, and returns a promise.\n * @example\n * Q.nfcall(FS.readFile, __filename)\n * .then(function (content) {\n * })\n *\n */\nQ.nfcall = function (callback /*...args*/) {\n    var args = array_slice(arguments, 1);\n    return Q(callback).nfapply(args);\n};\n\nPromise.prototype.nfcall = function (/*...args*/) {\n    var nodeArgs = array_slice(arguments);\n    var deferred = defer();\n    nodeArgs.push(deferred.makeNodeResolver());\n    this.fapply(nodeArgs).fail(deferred.reject);\n    return deferred.promise;\n};\n\n/**\n * Wraps a NodeJS continuation passing function and returns an equivalent\n * version that returns a promise.\n * @example\n * Q.nfbind(FS.readFile, __filename)(\"utf-8\")\n * .then(console.log)\n * .done()\n */\nQ.nfbind =\nQ.denodeify = function (callback /*...args*/) {\n    var baseArgs = array_slice(arguments, 1);\n    return function () {\n        var nodeArgs = baseArgs.concat(array_slice(arguments));\n        var deferred = defer();\n        nodeArgs.push(deferred.makeNodeResolver());\n        Q(callback).fapply(nodeArgs).fail(deferred.reject);\n        return deferred.promise;\n    };\n};\n\nPromise.prototype.nfbind =\nPromise.prototype.denodeify = function (/*...args*/) {\n    var args = array_slice(arguments);\n    args.unshift(this);\n    return Q.denodeify.apply(void 0, args);\n};\n\nQ.nbind = function (callback, thisp /*...args*/) {\n    var baseArgs = array_slice(arguments, 2);\n    return function () {\n        var nodeArgs = baseArgs.concat(array_slice(arguments));\n        var deferred = defer();\n        nodeArgs.push(deferred.makeNodeResolver());\n        function bound() {\n            return callback.apply(thisp, arguments);\n        }\n        Q(bound).fapply(nodeArgs).fail(deferred.reject);\n        return deferred.promise;\n    };\n};\n\nPromise.prototype.nbind = function (/*thisp, ...args*/) {\n    var args = array_slice(arguments, 0);\n    args.unshift(this);\n    return Q.nbind.apply(void 0, args);\n};\n\n/**\n * Calls a method of a Node-style object that accepts a Node-style\n * callback with a given array of arguments, plus a provided callback.\n * @param object an object that has the named method\n * @param {String} name name of the method of object\n * @param {Array} args arguments to pass to the method; the callback\n * will be provided by Q and appended to these arguments.\n * @returns a promise for the value or error\n */\nQ.nmapply = // XXX As proposed by \"Redsandro\"\nQ.npost = function (object, name, args) {\n    return Q(object).npost(name, args);\n};\n\nPromise.prototype.nmapply = // XXX As proposed by \"Redsandro\"\nPromise.prototype.npost = function (name, args) {\n    var nodeArgs = array_slice(args || []);\n    var deferred = defer();\n    nodeArgs.push(deferred.makeNodeResolver());\n    this.dispatch(\"post\", [name, nodeArgs]).fail(deferred.reject);\n    return deferred.promise;\n};\n\n/**\n * Calls a method of a Node-style object that accepts a Node-style\n * callback, forwarding the given variadic arguments, plus a provided\n * callback argument.\n * @param object an object that has the named method\n * @param {String} name name of the method of object\n * @param ...args arguments to pass to the method; the callback will\n * be provided by Q and appended to these arguments.\n * @returns a promise for the value or error\n */\nQ.nsend = // XXX Based on Mark Miller's proposed \"send\"\nQ.nmcall = // XXX Based on \"Redsandro's\" proposal\nQ.ninvoke = function (object, name /*...args*/) {\n    var nodeArgs = array_slice(arguments, 2);\n    var deferred = defer();\n    nodeArgs.push(deferred.makeNodeResolver());\n    Q(object).dispatch(\"post\", [name, nodeArgs]).fail(deferred.reject);\n    return deferred.promise;\n};\n\nPromise.prototype.nsend = // XXX Based on Mark Miller's proposed \"send\"\nPromise.prototype.nmcall = // XXX Based on \"Redsandro's\" proposal\nPromise.prototype.ninvoke = function (name /*...args*/) {\n    var nodeArgs = array_slice(arguments, 1);\n    var deferred = defer();\n    nodeArgs.push(deferred.makeNodeResolver());\n    this.dispatch(\"post\", [name, nodeArgs]).fail(deferred.reject);\n    return deferred.promise;\n};\n\n/**\n * If a function would like to support both Node continuation-passing-style and\n * promise-returning-style, it can end its internal promise chain with\n * `nodeify(nodeback)`, forwarding the optional nodeback argument.  If the user\n * elects to use a nodeback, the result will be sent there.  If they do not\n * pass a nodeback, they will receive the result promise.\n * @param object a result (or a promise for a result)\n * @param {Function} nodeback a Node.js-style callback\n * @returns either the promise or nothing\n */\nQ.nodeify = nodeify;\nfunction nodeify(object, nodeback) {\n    return Q(object).nodeify(nodeback);\n}\n\nPromise.prototype.nodeify = function (nodeback) {\n    if (nodeback) {\n        this.then(function (value) {\n            Q.nextTick(function () {\n                nodeback(null, value);\n            });\n        }, function (error) {\n            Q.nextTick(function () {\n                nodeback(error);\n            });\n        });\n    } else {\n        return this;\n    }\n};\n\nQ.noConflict = function() {\n    throw new Error(\"Q.noConflict only works when Q is used as a global\");\n};\n\n// All code before this point will be filtered from stack traces.\nvar qEndingLine = captureLine();\n\nreturn Q;\n\n});\n\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(8), __webpack_require__(20).setImmediate))\n\n/***/ }),\n/* 6 */\n/***/ (function(module, exports, __webpack_require__) {\n\n/*!\n * Copyright (c) 2015-present, Okta, Inc. and/or its affiliates. All rights reserved.\n * The Okta software accompanied by this notice is provided pursuant to the Apache License, Version 2.0 (the \"License.\")\n *\n * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0.\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS, WITHOUT\n * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n *\n * See the License for the specific language governing permissions and limitations under the License.\n *\n */\n\nvar AuthSdkError = __webpack_require__(1);\n\n// storage must have getItem and setItem\nfunction storageBuilder(webstorage, storageName) {\n  if (typeof storageName !== 'string' || !storageName.length) {\n    throw new AuthSdkError('\"storageName\" is required');\n  }\n\n  function getStorage() {\n    var storageString = webstorage.getItem(storageName);\n    storageString = storageString || '{}';\n    try {\n      return JSON.parse(storageString);\n    } catch(e) {\n      throw new AuthSdkError('Unable to parse storage string: ' + storageName);\n    }\n  }\n\n  function setStorage(storage) {\n    try {\n      var storageString = JSON.stringify(storage);\n      webstorage.setItem(storageName, storageString);\n    } catch(e) {\n      throw new AuthSdkError('Unable to set storage: ' + storageName);\n    }\n  }\n\n  function clearStorage(key) {\n    if (!key) {\n      setStorage({});\n    }\n    var storage = getStorage();\n    delete storage[key];\n    setStorage(storage);\n  }\n\n  function updateStorage(key, value) {\n    var storage = getStorage();\n    storage[key] = value;\n    setStorage(storage);\n  }\n\n  return {\n    getStorage: getStorage,\n    setStorage: setStorage,\n    clearStorage: clearStorage,\n    updateStorage: updateStorage\n  };\n}\n\nmodule.exports = storageBuilder;\n\n\n/***/ }),\n/* 7 */\n/***/ (function(module, exports, __webpack_require__) {\n\n/*!\n * Copyright (c) 2015-present, Okta, Inc. and/or its affiliates. All rights reserved.\n * The Okta software accompanied by this notice is provided pursuant to the Apache License, Version 2.0 (the \"License.\")\n *\n * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0.\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS, WITHOUT\n * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n *\n * See the License for the specific language governing permissions and limitations under the License.\n *\n */\n\n/* eslint-disable complexity, max-statements */\nvar http              = __webpack_require__(3);\nvar util              = __webpack_require__(0);\nvar Q                 = __webpack_require__(5);\nvar AuthSdkError      = __webpack_require__(1);\nvar AuthPollStopError = __webpack_require__(23);\nvar constants         = __webpack_require__(2);\n\nfunction addStateToken(res, options) {\n  var builtArgs = {};\n  util.extend(builtArgs, options);\n\n  // Add the stateToken if one isn't passed and we have one\n  if (!builtArgs.stateToken && res.stateToken) {\n    builtArgs.stateToken = res.stateToken;\n  }\n\n  return builtArgs;\n}\n\nfunction getStateToken(res) {\n  return addStateToken(res);\n}\n\nfunction transactionStatus(sdk, args) {\n  args = addStateToken(sdk, args);\n  return http.post(sdk, sdk.options.url + '/api/v1/authn', args);\n}\n\nfunction resumeTransaction(sdk, args) {\n  if (!args || !args.stateToken) {\n    var stateToken = sdk.tx.exists._get(constants.STATE_TOKEN_KEY_NAME);\n    if (stateToken) {\n      args = {\n        stateToken: stateToken\n      };\n    } else {\n      return Q.reject(new AuthSdkError('No transaction to resume'));\n    }\n  }\n  return sdk.tx.status(args)\n    .then(function(res) {\n      return new AuthTransaction(sdk, res);\n    });\n}\n\nfunction introspect (sdk, args) {\n  if (!args || !args.stateToken) {\n    var stateToken = sdk.tx.exists._get(constants.STATE_TOKEN_KEY_NAME);\n    if (stateToken) {\n      args = {\n        stateToken: stateToken\n      };\n    } else {\n      return Q.reject(new AuthSdkError('No transaction to evaluate'));\n    }\n  }\n  return transactionStep(sdk, args)\n    .then(function (res) {\n      return new AuthTransaction(sdk, res);\n    });\n}\n\nfunction transactionStep(sdk, args) {\n  args = addStateToken(sdk, args);\n  // v1 pipeline introspect API\n  return http.post(sdk, sdk.options.url + '/api/v1/authn/introspect', args);\n}\n\nfunction transactionExists(sdk) {\n  // We have a cookie state token\n  return !!sdk.tx.exists._get(constants.STATE_TOKEN_KEY_NAME);\n}\n\nfunction postToTransaction(sdk, url, args, options) {\n  return http.post(sdk, url, args, options)\n    .then(function(res) {\n      return new AuthTransaction(sdk, res);\n    });\n}\n\nfunction getPollFn(sdk, res, ref) {\n  return function (options) {\n    var delay;\n    var rememberDevice;\n    var autoPush;\n    var transactionCallBack;\n\n    if (util.isNumber(options)) {\n      delay = options;\n    } else if (util.isObject(options)) {\n      delay = options.delay;\n      rememberDevice = options.rememberDevice;\n      autoPush = options.autoPush;\n      transactionCallBack = options.transactionCallBack;\n    }\n\n    if (!delay && delay !== 0) {\n      delay = constants.DEFAULT_POLLING_DELAY;\n    }\n\n    // Get the poll function\n    var pollLink = util.getLink(res, 'next', 'poll');\n    function pollFn() {\n      var opts = {};\n      if (typeof autoPush === 'function') {\n        try {\n          opts.autoPush = !!autoPush();\n        }\n        catch (e) {\n          return Q.reject(new AuthSdkError('AutoPush resulted in an error.'));\n        }\n      }\n      else if (autoPush !== undefined && autoPush !== null) {\n        opts.autoPush = !!autoPush;\n      }\n      if (typeof rememberDevice === 'function') {\n        try {\n          opts.rememberDevice = !!rememberDevice();\n        }\n        catch (e) {\n          return Q.reject(new AuthSdkError('RememberDevice resulted in an error.'));\n        }\n      }\n      else if (rememberDevice !== undefined && rememberDevice !== null) {\n        opts.rememberDevice = !!rememberDevice;\n      }\n\n      var href = pollLink.href + util.toQueryParams(opts);\n      return http.post(sdk, href, getStateToken(res), {\n        saveAuthnState: false  \n      });\n    }\n\n    ref.isPolling = true;\n\n    var retryCount = 0;\n    var recursivePoll = function () {\n      // If the poll was manually stopped during the delay\n      if (!ref.isPolling) {\n        return Q.reject(new AuthPollStopError());\n      }\n      return pollFn()\n        .then(function (pollRes) {\n          // Reset our retry counter on success\n          retryCount = 0;\n\n          // If we're still waiting\n          if (pollRes.factorResult && pollRes.factorResult === 'WAITING') {\n\n            // If the poll was manually stopped while the pollFn was called\n            if (!ref.isPolling) {\n              throw new AuthPollStopError();\n            }\n\n            if (typeof transactionCallBack === 'function') {\n              transactionCallBack(pollRes);\n            }\n\n            // Continue poll\n            return Q.delay(delay)\n              .then(recursivePoll);\n\n          } else {\n            // Any non-waiting result, even if polling was stopped\n            // during a request, will return\n            ref.isPolling = false;\n            return new AuthTransaction(sdk, pollRes);\n          }\n        })\n        .fail(function(err) {\n          // Exponential backoff, up to 16 seconds\n          if (err.xhr &&\n              (err.xhr.status === 0 || err.xhr.status === 429) &&\n              retryCount <= 4) {\n            var delayLength = Math.pow(2, retryCount) * 1000;\n            retryCount++;\n            return Q.delay(delayLength)\n              .then(recursivePoll);\n          }\n          throw err;\n        });\n    };\n    return recursivePoll()\n      .fail(function(err) {\n        ref.isPolling = false;\n        throw err;\n      });\n  };\n}\n\nfunction link2fn(sdk, res, obj, link, ref) {\n  if (Array.isArray(link)) {\n    return function(name, opts) {\n      if (!name) {\n        throw new AuthSdkError('Must provide a link name');\n      }\n\n      var lk = util.find(link, {name: name});\n      if (!lk) {\n        throw new AuthSdkError('No link found for that name');\n      }\n\n      return link2fn(sdk, res, obj, lk, ref)(opts);\n    };\n\n  } else if (link.hints &&\n      link.hints.allow &&\n      link.hints.allow.length === 1) {\n    var method = link.hints.allow[0];\n    switch (method) {\n\n      case 'GET':\n        return function() {\n          return http.get(sdk, link.href);\n        };\n\n      case 'POST':\n        return function(opts) {\n          if (ref && ref.isPolling) {\n            ref.isPolling = false;\n          }\n\n          var data = addStateToken(res, opts);\n\n          if (res.status === 'MFA_ENROLL' || res.status === 'FACTOR_ENROLL') {\n            // Add factorType and provider\n            util.extend(data, {\n              factorType: obj.factorType,\n              provider: obj.provider\n            });\n          }\n\n          var params = {};\n          var autoPush = data.autoPush;\n          if (autoPush !== undefined) {\n            if (typeof autoPush === 'function') {\n              try {\n                params.autoPush = !!autoPush();\n              }\n              catch (e) {\n                return Q.reject(new AuthSdkError('AutoPush resulted in an error.'));\n              }\n            }\n            else if (autoPush !== null) {\n              params.autoPush = !!autoPush;\n            }\n            data = util.omit(data, 'autoPush');\n          }\n\n          var rememberDevice = data.rememberDevice;\n          if (rememberDevice !== undefined) {\n            if (typeof rememberDevice === 'function') {\n              try {\n                params.rememberDevice = !!rememberDevice();\n              }\n              catch (e) {\n                return Q.reject(new AuthSdkError('RememberDevice resulted in an error.'));\n              }\n            }\n            else if (rememberDevice !== null) {\n              params.rememberDevice = !!rememberDevice;\n            }\n            data = util.omit(data, 'rememberDevice');\n\n          } else if (data.profile &&\n                    data.profile.updatePhone !== undefined) {\n            if (data.profile.updatePhone) {\n              params.updatePhone = true;\n            }\n            data.profile = util.omit(data.profile, 'updatePhone');\n          }\n          var href = link.href + util.toQueryParams(params);\n          return postToTransaction(sdk, href, data);\n        };\n    }\n  }\n}\n\nfunction links2fns(sdk, res, obj, ref) {\n  var fns = {};\n  for (var linkName in obj._links) {\n    if (!obj._links.hasOwnProperty(linkName)) {\n      continue;\n    }\n\n    var link = obj._links[linkName];\n    \n    if (linkName === 'next') {\n      linkName = link.name;\n    }\n\n    if (link.type) {\n      fns[linkName] = link;\n      continue;\n    }\n\n    switch (linkName) {\n      // poll is only found at the transaction\n      // level, so we don't need to pass the link\n      case 'poll':\n        fns.poll = getPollFn(sdk, res, ref);\n        break;\n\n      default:\n        var fn = link2fn(sdk, res, obj, link, ref);\n        if (fn) {\n          fns[linkName] = fn;\n        }\n    }\n  }\n  return fns;\n}\n\nfunction flattenEmbedded(sdk, res, obj, ref) {\n  obj = obj || res;\n  obj = util.clone(obj);\n\n  if (Array.isArray(obj)) {\n    var objArr = [];\n    for (var o = 0, ol = obj.length; o < ol; o++) {\n      objArr.push(flattenEmbedded(sdk, res, obj[o], ref));\n    }\n    return objArr;\n  }\n\n  var embedded = obj._embedded || {};\n\n  for (var key in embedded) {\n    if (!embedded.hasOwnProperty(key)) {\n      continue;\n    }\n\n    // Flatten any nested _embedded objects\n    if (util.isObject(embedded[key]) || Array.isArray(embedded[key])) {\n      embedded[key] = flattenEmbedded(sdk, res, embedded[key], ref);\n    }\n  }\n\n  // Convert any links on the embedded object\n  var fns = links2fns(sdk, res, obj, ref);\n  util.extend(embedded, fns);\n\n  obj = util.omit(obj, '_embedded', '_links');\n  util.extend(obj, embedded);\n  return obj;\n}\n\nfunction AuthTransaction(sdk, res) {\n  if (res) {\n    this.data = res;\n    util.extend(this, flattenEmbedded(sdk, res, res, {}));\n    delete this.stateToken;\n\n    // RECOVERY_CHALLENGE has some responses without _links.\n    // Without _links, we emulate cancel to make it intuitive\n    // to return to the starting state. We may remove this\n    // when OKTA-75434 is resolved\n    if (res.status === 'RECOVERY_CHALLENGE' && !res._links) {\n      this.cancel = function() {\n        return new Q(new AuthTransaction(sdk));\n      };\n    }\n  }\n}\n\nmodule.exports = {\n  transactionStatus: transactionStatus,\n  resumeTransaction: resumeTransaction,\n  transactionExists: transactionExists,\n  postToTransaction: postToTransaction,\n  introspect: introspect,\n};\n\n\n/***/ }),\n/* 8 */\n/***/ (function(module, exports) {\n\n// shim for using process in browser\nvar process = module.exports = {};\n\n// cached from whatever global is present so that test runners that stub it\n// don't break things.  But we need to wrap it in a try catch in case it is\n// wrapped in strict mode code which doesn't define any globals.  It's inside a\n// function because try/catches deoptimize in certain engines.\n\nvar cachedSetTimeout;\nvar cachedClearTimeout;\n\nfunction defaultSetTimout() {\n    throw new Error('setTimeout has not been defined');\n}\nfunction defaultClearTimeout () {\n    throw new Error('clearTimeout has not been defined');\n}\n(function () {\n    try {\n        if (typeof setTimeout === 'function') {\n            cachedSetTimeout = setTimeout;\n        } else {\n            cachedSetTimeout = defaultSetTimout;\n        }\n    } catch (e) {\n        cachedSetTimeout = defaultSetTimout;\n    }\n    try {\n        if (typeof clearTimeout === 'function') {\n            cachedClearTimeout = clearTimeout;\n        } else {\n            cachedClearTimeout = defaultClearTimeout;\n        }\n    } catch (e) {\n        cachedClearTimeout = defaultClearTimeout;\n    }\n} ())\nfunction runTimeout(fun) {\n    if (cachedSetTimeout === setTimeout) {\n        //normal enviroments in sane situations\n        return setTimeout(fun, 0);\n    }\n    // if setTimeout wasn't available but was latter defined\n    if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {\n        cachedSetTimeout = setTimeout;\n        return setTimeout(fun, 0);\n    }\n    try {\n        // when when somebody has screwed with setTimeout but no I.E. maddness\n        return cachedSetTimeout(fun, 0);\n    } catch(e){\n        try {\n            // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally\n            return cachedSetTimeout.call(null, fun, 0);\n        } catch(e){\n            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error\n            return cachedSetTimeout.call(this, fun, 0);\n        }\n    }\n\n\n}\nfunction runClearTimeout(marker) {\n    if (cachedClearTimeout === clearTimeout) {\n        //normal enviroments in sane situations\n        return clearTimeout(marker);\n    }\n    // if clearTimeout wasn't available but was latter defined\n    if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {\n        cachedClearTimeout = clearTimeout;\n        return clearTimeout(marker);\n    }\n    try {\n        // when when somebody has screwed with setTimeout but no I.E. maddness\n        return cachedClearTimeout(marker);\n    } catch (e){\n        try {\n            // When we are in I.E. but the script has been evaled so I.E. doesn't  trust the global object when called normally\n            return cachedClearTimeout.call(null, marker);\n        } catch (e){\n            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.\n            // Some versions of I.E. have different rules for clearTimeout vs setTimeout\n            return cachedClearTimeout.call(this, marker);\n        }\n    }\n\n\n\n}\nvar queue = [];\nvar draining = false;\nvar currentQueue;\nvar queueIndex = -1;\n\nfunction cleanUpNextTick() {\n    if (!draining || !currentQueue) {\n        return;\n    }\n    draining = false;\n    if (currentQueue.length) {\n        queue = currentQueue.concat(queue);\n    } else {\n        queueIndex = -1;\n    }\n    if (queue.length) {\n        drainQueue();\n    }\n}\n\nfunction drainQueue() {\n    if (draining) {\n        return;\n    }\n    var timeout = runTimeout(cleanUpNextTick);\n    draining = true;\n\n    var len = queue.length;\n    while(len) {\n        currentQueue = queue;\n        queue = [];\n        while (++queueIndex < len) {\n            if (currentQueue) {\n                currentQueue[queueIndex].run();\n            }\n        }\n        queueIndex = -1;\n        len = queue.length;\n    }\n    currentQueue = null;\n    draining = false;\n    runClearTimeout(timeout);\n}\n\nprocess.nextTick = function (fun) {\n    var args = new Array(arguments.length - 1);\n    if (arguments.length > 1) {\n        for (var i = 1; i < arguments.length; i++) {\n            args[i - 1] = arguments[i];\n        }\n    }\n    queue.push(new Item(fun, args));\n    if (queue.length === 1 && !draining) {\n        runTimeout(drainQueue);\n    }\n};\n\n// v8 likes predictible objects\nfunction Item(fun, array) {\n    this.fun = fun;\n    this.array = array;\n}\nItem.prototype.run = function () {\n    this.fun.apply(null, this.array);\n};\nprocess.title = 'browser';\nprocess.browser = true;\nprocess.env = {};\nprocess.argv = [];\nprocess.version = ''; // empty string to avoid regexp issues\nprocess.versions = {};\n\nfunction noop() {}\n\nprocess.on = noop;\nprocess.addListener = noop;\nprocess.once = noop;\nprocess.off = noop;\nprocess.removeListener = noop;\nprocess.removeAllListeners = noop;\nprocess.emit = noop;\nprocess.prependListener = noop;\nprocess.prependOnceListener = noop;\n\nprocess.listeners = function (name) { return [] }\n\nprocess.binding = function (name) {\n    throw new Error('process.binding is not supported');\n};\n\nprocess.cwd = function () { return '/' };\nprocess.chdir = function (dir) {\n    throw new Error('process.chdir is not supported');\n};\nprocess.umask = function() { return 0; };\n\n\n/***/ }),\n/* 9 */\n/***/ (function(module, exports) {\n\nvar g;\r\n\r\n// This works in non-strict mode\r\ng = (function() {\r\n\treturn this;\r\n})();\r\n\r\ntry {\r\n\t// This works if eval is allowed (see CSP)\r\n\tg = g || Function(\"return this\")() || (1,eval)(\"this\");\r\n} catch(e) {\r\n\t// This works if the window reference is available\r\n\tif(typeof window === \"object\")\r\n\t\tg = window;\r\n}\r\n\r\n// g can still be undefined, but nothing to do about it...\r\n// We return undefined, instead of nothing here, so it's\r\n// easier to handle this case. if(!global) { ...}\r\n\r\nmodule.exports = g;\r\n\n\n/***/ }),\n/* 10 */\n/***/ (function(module, exports, __webpack_require__) {\n\n/*!\n * Copyright (c) 2015-present, Okta, Inc. and/or its affiliates. All rights reserved.\n * The Okta software accompanied by this notice is provided pursuant to the Apache License, Version 2.0 (the \"License.\")\n *\n * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0.\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS, WITHOUT\n * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n *\n * See the License for the specific language governing permissions and limitations under the License.\n *\n */\n\n/* eslint-disable complexity, max-statements */\nvar http = __webpack_require__(3);\nvar util = __webpack_require__(0);\nvar storageUtil = __webpack_require__(4);\nvar AuthSdkError = __webpack_require__(1);\n\nvar httpCache = storageUtil.getHttpCache();\n\nfunction generateState() {\n  return util.genRandomString(64);\n}\n\nfunction generateNonce() {\n  return util.genRandomString(64);\n}\n\nfunction isToken(obj) {\n  if (obj &&\n      (obj.accessToken || obj.idToken) &&\n      Array.isArray(obj.scopes)) {\n    return true;\n  }\n  return false;\n}\n\nfunction addListener(eventTarget, name, fn) {\n  if (eventTarget.addEventListener) {\n    eventTarget.addEventListener(name, fn);\n  } else {\n    eventTarget.attachEvent('on' + name, fn);\n  }\n}\n\nfunction removeListener(eventTarget, name, fn) {\n  if (eventTarget.removeEventListener) {\n    eventTarget.removeEventListener(name, fn);\n  } else {\n    eventTarget.detachEvent('on' + name, fn);\n  }\n}\n\nfunction loadFrame(src) {\n  var iframe = document.createElement('iframe');\n  iframe.style.display = 'none';\n  iframe.src = src;\n\n  return document.body.appendChild(iframe);\n}\n\nfunction loadPopup(src, options) {\n  var title = options.popupTitle || 'External Identity Provider User Authentication';\n  var appearance = 'toolbar=no, scrollbars=yes, resizable=yes, ' +\n    'top=100, left=500, width=600, height=600';\n\n  if (util.isIE11OrLess()) {\n    // IE<=11 doesn't fully support postMessage at time of writting.\n    // the following simple solution happened to solve the issue\n    // without adding another proxy layer which makes flow more complecated.\n    var winEl = window.open('/', title, appearance);\n    winEl.location.href = src;\n    return winEl;\n  } else {\n    return window.open(src, title, appearance);\n  }\n}\n\nfunction getWellKnown(sdk, issuer) {\n  var authServerUri = (issuer || sdk.options.issuer || sdk.options.url);\n  return http.get(sdk, authServerUri + '/.well-known/openid-configuration', {\n    cacheResponse: true\n  });\n}\n\nfunction getKey(sdk, issuer, kid) {\n  return getWellKnown(sdk, issuer)\n  .then(function(wellKnown) {\n    var jwksUri = wellKnown['jwks_uri'];\n\n    // Check our kid against the cached version (if it exists and isn't expired)\n    var cacheContents = httpCache.getStorage();\n    var cachedResponse = cacheContents[jwksUri];\n    if (cachedResponse && Date.now()/1000 < cachedResponse.expiresAt) {\n      var cachedKey = util.find(cachedResponse.response.keys, {\n        kid: kid\n      });\n\n      if (cachedKey) {\n        return cachedKey;\n      }\n    }\n\n    // Remove cache for the key\n    httpCache.clearStorage(jwksUri);\n\n    // Pull the latest keys if the key wasn't in the cache\n    return http.get(sdk, jwksUri, {\n      cacheResponse: true\n    })\n    .then(function(res) {\n      var key = util.find(res.keys, {\n        kid: kid\n      });\n\n      if (key) {\n        return key;\n      }\n\n      throw new AuthSdkError('The key id, ' + kid + ', was not found in the server\\'s keys');\n    });\n  });\n}\n\nfunction validateClaims(sdk, claims, validationParams) {\n  var aud = validationParams.clientId;\n  var iss = validationParams.issuer;\n  var nonce = validationParams.nonce;\n\n  if (!claims || !iss || !aud) {\n    throw new AuthSdkError('The jwt, iss, and aud arguments are all required');\n  }\n\n  if (nonce && claims.nonce !== nonce) {\n    throw new AuthSdkError('OAuth flow response nonce doesn\\'t match request nonce');\n  }\n\n  var now = Math.floor(Date.now()/1000);\n\n  if (claims.iss !== iss) {\n    throw new AuthSdkError('The issuer [' + claims.iss + '] ' +\n      'does not match [' + iss + ']');\n  }\n\n  if (claims.aud !== aud) {\n    throw new AuthSdkError('The audience [' + claims.aud + '] ' +\n      'does not match [' + aud + ']');\n  }\n\n  if (claims.iat > claims.exp) {\n    throw new AuthSdkError('The JWT expired before it was issued');\n  }\n\n  if ((now - sdk.options.maxClockSkew) > claims.exp) {\n    throw new AuthSdkError('The JWT expired and is no longer valid');\n  }\n\n  if (claims.iat > (now + sdk.options.maxClockSkew)) {\n    throw new AuthSdkError('The JWT was issued in the future');\n  }\n}\n\nfunction getOAuthUrls(sdk, oauthParams, options) {\n  options = options || {};\n\n  // Get user-supplied arguments\n  var authorizeUrl = util.removeTrailingSlash(options.authorizeUrl) || sdk.options.authorizeUrl;\n  var issuer = util.removeTrailingSlash(options.issuer) || sdk.options.issuer;\n  var userinfoUrl = util.removeTrailingSlash(options.userinfoUrl) || sdk.options.userinfoUrl;\n  var tokenUrl = util.removeTrailingSlash(options.tokenUrl) || sdk.options.tokenUrl;\n  var logoutUrl = util.removeTrailingSlash(options.logoutUrl) || sdk.options.logoutUrl;\n  var revokeUrl = util.removeTrailingSlash(options.revokeUrl) || sdk.options.revokeUrl;\n\n  // If an issuer exists but it's not a url, assume it's an authServerId\n  if (issuer && !(/^https?:/.test(issuer))) {\n    // Make it a url\n    issuer = sdk.options.url + '/oauth2/' + issuer;\n  }\n\n  // If an authorizeUrl is supplied without an issuer, and an id_token is requested\n  if (!issuer && authorizeUrl &&\n      oauthParams.responseType.indexOf('id_token') !== -1) {\n    // The issuer is ambiguous, so we won't be able to validate the id_token jwt\n    throw new AuthSdkError('Cannot request idToken with an authorizeUrl without an issuer');\n  }\n\n  // If a token is requested without an issuer\n  if (!issuer && oauthParams && oauthParams.responseType.indexOf('token') !== -1) {\n    // If an authorizeUrl is supplied without a userinfoUrl\n    if (authorizeUrl && !userinfoUrl) {\n      // The userinfoUrl is ambiguous, so we won't be able to call getUserInfo\n      throw new AuthSdkError('Cannot request accessToken with an authorizeUrl without an issuer or userinfoUrl');\n    }\n\n    // If a userinfoUrl is supplied without a authorizeUrl\n    if (userinfoUrl && !authorizeUrl) {\n      // The authorizeUrl is ambiguous, so we won't be able to call the authorize endpoint\n      throw new AuthSdkError('Cannot request token with an userinfoUrl without an issuer or authorizeUrl');\n    }\n  }\n\n  // Default the issuer to our baseUrl\n  issuer = issuer || sdk.options.url;\n\n  // Trim trailing slashes\n  issuer = util.removeTrailingSlash(issuer);\n\n  var baseUrl = issuer;\n  // A custom auth server issuer looks like:\n  // https://example.okta.com/oauth2/aus8aus76q8iphupD0h7\n  // \n  // Most orgs have a \"default\" custom authorization server:\n  // https://example.okta.com/oauth2/default\n  var customAuthServerRegex = new RegExp('^https?://.*?/oauth2/.+');\n  if (!customAuthServerRegex.test(baseUrl)) {\n    // Append '/oauth2' if necessary\n    if (!baseUrl.endsWith('/oauth2')) {\n      baseUrl += '/oauth2';\n    }\n  }\n\n  authorizeUrl = authorizeUrl || baseUrl + '/v1/authorize';\n  userinfoUrl = userinfoUrl || baseUrl + '/v1/userinfo';\n  tokenUrl = tokenUrl || baseUrl + '/v1/token';\n  revokeUrl = revokeUrl || baseUrl + '/v1/revoke';\n  logoutUrl = logoutUrl || baseUrl + '/v1/logout';\n\n  return {\n    issuer: issuer,\n    authorizeUrl: authorizeUrl,\n    userinfoUrl: userinfoUrl,\n    tokenUrl: tokenUrl,\n    revokeUrl: revokeUrl,\n    logoutUrl: logoutUrl\n  };\n}\n\nfunction urlParamsToObject(hashOrSearch) {\n  // Predefine regexs for parsing hash\n  var plus2space = /\\+/g;\n  var paramSplit = /([^&=]+)=?([^&]*)/g;\n\n  // Remove the leading # or ?\n  var fragment = hashOrSearch.substring(1);\n\n  var obj = {};\n\n  // Loop until we have no more params\n  var param;\n  while (true) { // eslint-disable-line no-constant-condition\n    param = paramSplit.exec(fragment);\n    if (!param) { break; }\n\n    var key = param[1];\n    var value = param[2];\n\n    // id_token should remain base64url encoded\n    if (key === 'id_token' || key === 'access_token' || key === 'code') {\n      obj[key] = value;\n    } else {\n      obj[key] = decodeURIComponent(value.replace(plus2space, ' '));\n    }\n  }\n  return obj;\n}\n\nmodule.exports = {\n  generateState: generateState,\n  generateNonce: generateNonce,\n  getWellKnown: getWellKnown,\n  getKey: getKey,\n  validateClaims: validateClaims,\n  getOAuthUrls: getOAuthUrls,\n  loadFrame: loadFrame,\n  loadPopup: loadPopup,\n  urlParamsToObject: urlParamsToObject,\n  isToken: isToken,\n  addListener: addListener,\n  removeListener: removeListener\n};\n\n\n/***/ }),\n/* 11 */\n/***/ (function(module, exports, __webpack_require__) {\n\n/*!\n * Copyright (c) 2015-present, Okta, Inc. and/or its affiliates. All rights reserved.\n * The Okta software accompanied by this notice is provided pursuant to the Apache License, Version 2.0 (the \"License.\")\n *\n * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0.\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS, WITHOUT\n * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n *\n * See the License for the specific language governing permissions and limitations under the License.\n *\n */\n\nvar fetchRequest = __webpack_require__(12);\nvar storageUtil = __webpack_require__(4);\n\nmodule.exports = __webpack_require__(15)(storageUtil, fetchRequest);\n\n\n/***/ }),\n/* 12 */\n/***/ (function(module, exports, __webpack_require__) {\n\n/*!\n * Copyright (c) 2018-present, Okta, Inc. and/or its affiliates. All rights reserved.\n * The Okta software accompanied by this notice is provided pursuant to the Apache License, Version 2.0 (the \"License.\")\n *\n * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0.\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS, WITHOUT\n * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n *\n * See the License for the specific language governing permissions and limitations under the License.\n */\n\nvar fetch = __webpack_require__(13);\n\n/* eslint-disable complexity */\nfunction fetchRequest(method, url, args) {\n  var body = args.data;\n  var headers = args.headers || {};\n  var contentType = (headers['Content-Type'] || headers['content-type'] || '');\n\n  // JSON encode body (if appropriate)\n  if (contentType === 'application/json' && body && typeof body !== 'string') {\n    body = JSON.stringify(body);\n  }\n\n  var fetchPromise = fetch(url, {\n    method: method,\n    headers: args.headers,\n    body: body,\n    credentials: args.withCredentials === false ? 'omit' : 'include'\n  })\n  .then(function(response) {\n    var error = !response.ok;\n    var status = response.status;\n    var respHandler = function(resp) {\n      var result = {\n        responseText: resp,\n        status: status\n      };\n      if (error) {\n        // Throwing response object since error handling is done in http.js\n        throw result;\n      }\n      return result;\n    };\n    if (response.headers.get('Content-Type') &&\n        response.headers.get('Content-Type').toLowerCase().indexOf('application/json') >= 0) {\n      return response.json().then(respHandler);\n    } else {\n      return response.text().then(respHandler);\n    }\n  });\n  return fetchPromise;\n}\n\nmodule.exports = fetchRequest;\n\n\n/***/ }),\n/* 13 */\n/***/ (function(module, exports) {\n\nvar __self__ = (function (root) {\nfunction F() {\nthis.fetch = false;\nthis.DOMException = root.DOMException\n}\nF.prototype = root;\nreturn new F();\n})(typeof self !== 'undefined' ? self : this);\n(function(self) {\n\nvar irrelevant = (function (exports) {\n  var support = {\n    searchParams: 'URLSearchParams' in self,\n    iterable: 'Symbol' in self && 'iterator' in Symbol,\n    blob:\n      'FileReader' in self &&\n      'Blob' in self &&\n      (function() {\n        try {\n          new Blob();\n          return true\n        } catch (e) {\n          return false\n        }\n      })(),\n    formData: 'FormData' in self,\n    arrayBuffer: 'ArrayBuffer' in self\n  };\n\n  function isDataView(obj) {\n    return obj && DataView.prototype.isPrototypeOf(obj)\n  }\n\n  if (support.arrayBuffer) {\n    var viewClasses = [\n      '[object Int8Array]',\n      '[object Uint8Array]',\n      '[object Uint8ClampedArray]',\n      '[object Int16Array]',\n      '[object Uint16Array]',\n      '[object Int32Array]',\n      '[object Uint32Array]',\n      '[object Float32Array]',\n      '[object Float64Array]'\n    ];\n\n    var isArrayBufferView =\n      ArrayBuffer.isView ||\n      function(obj) {\n        return obj && viewClasses.indexOf(Object.prototype.toString.call(obj)) > -1\n      };\n  }\n\n  function normalizeName(name) {\n    if (typeof name !== 'string') {\n      name = String(name);\n    }\n    if (/[^a-z0-9\\-#$%&'*+.^_`|~]/i.test(name)) {\n      throw new TypeError('Invalid character in header field name')\n    }\n    return name.toLowerCase()\n  }\n\n  function normalizeValue(value) {\n    if (typeof value !== 'string') {\n      value = String(value);\n    }\n    return value\n  }\n\n  // Build a destructive iterator for the value list\n  function iteratorFor(items) {\n    var iterator = {\n      next: function() {\n        var value = items.shift();\n        return {done: value === undefined, value: value}\n      }\n    };\n\n    if (support.iterable) {\n      iterator[Symbol.iterator] = function() {\n        return iterator\n      };\n    }\n\n    return iterator\n  }\n\n  function Headers(headers) {\n    this.map = {};\n\n    if (headers instanceof Headers) {\n      headers.forEach(function(value, name) {\n        this.append(name, value);\n      }, this);\n    } else if (Array.isArray(headers)) {\n      headers.forEach(function(header) {\n        this.append(header[0], header[1]);\n      }, this);\n    } else if (headers) {\n      Object.getOwnPropertyNames(headers).forEach(function(name) {\n        this.append(name, headers[name]);\n      }, this);\n    }\n  }\n\n  Headers.prototype.append = function(name, value) {\n    name = normalizeName(name);\n    value = normalizeValue(value);\n    var oldValue = this.map[name];\n    this.map[name] = oldValue ? oldValue + ', ' + value : value;\n  };\n\n  Headers.prototype['delete'] = function(name) {\n    delete this.map[normalizeName(name)];\n  };\n\n  Headers.prototype.get = function(name) {\n    name = normalizeName(name);\n    return this.has(name) ? this.map[name] : null\n  };\n\n  Headers.prototype.has = function(name) {\n    return this.map.hasOwnProperty(normalizeName(name))\n  };\n\n  Headers.prototype.set = function(name, value) {\n    this.map[normalizeName(name)] = normalizeValue(value);\n  };\n\n  Headers.prototype.forEach = function(callback, thisArg) {\n    for (var name in this.map) {\n      if (this.map.hasOwnProperty(name)) {\n        callback.call(thisArg, this.map[name], name, this);\n      }\n    }\n  };\n\n  Headers.prototype.keys = function() {\n    var items = [];\n    this.forEach(function(value, name) {\n      items.push(name);\n    });\n    return iteratorFor(items)\n  };\n\n  Headers.prototype.values = function() {\n    var items = [];\n    this.forEach(function(value) {\n      items.push(value);\n    });\n    return iteratorFor(items)\n  };\n\n  Headers.prototype.entries = function() {\n    var items = [];\n    this.forEach(function(value, name) {\n      items.push([name, value]);\n    });\n    return iteratorFor(items)\n  };\n\n  if (support.iterable) {\n    Headers.prototype[Symbol.iterator] = Headers.prototype.entries;\n  }\n\n  function consumed(body) {\n    if (body.bodyUsed) {\n      return Promise.reject(new TypeError('Already read'))\n    }\n    body.bodyUsed = true;\n  }\n\n  function fileReaderReady(reader) {\n    return new Promise(function(resolve, reject) {\n      reader.onload = function() {\n        resolve(reader.result);\n      };\n      reader.onerror = function() {\n        reject(reader.error);\n      };\n    })\n  }\n\n  function readBlobAsArrayBuffer(blob) {\n    var reader = new FileReader();\n    var promise = fileReaderReady(reader);\n    reader.readAsArrayBuffer(blob);\n    return promise\n  }\n\n  function readBlobAsText(blob) {\n    var reader = new FileReader();\n    var promise = fileReaderReady(reader);\n    reader.readAsText(blob);\n    return promise\n  }\n\n  function readArrayBufferAsText(buf) {\n    var view = new Uint8Array(buf);\n    var chars = new Array(view.length);\n\n    for (var i = 0; i < view.length; i++) {\n      chars[i] = String.fromCharCode(view[i]);\n    }\n    return chars.join('')\n  }\n\n  function bufferClone(buf) {\n    if (buf.slice) {\n      return buf.slice(0)\n    } else {\n      var view = new Uint8Array(buf.byteLength);\n      view.set(new Uint8Array(buf));\n      return view.buffer\n    }\n  }\n\n  function Body() {\n    this.bodyUsed = false;\n\n    this._initBody = function(body) {\n      this._bodyInit = body;\n      if (!body) {\n        this._bodyText = '';\n      } else if (typeof body === 'string') {\n        this._bodyText = body;\n      } else if (support.blob && Blob.prototype.isPrototypeOf(body)) {\n        this._bodyBlob = body;\n      } else if (support.formData && FormData.prototype.isPrototypeOf(body)) {\n        this._bodyFormData = body;\n      } else if (support.searchParams && URLSearchParams.prototype.isPrototypeOf(body)) {\n        this._bodyText = body.toString();\n      } else if (support.arrayBuffer && support.blob && isDataView(body)) {\n        this._bodyArrayBuffer = bufferClone(body.buffer);\n        // IE 10-11 can't handle a DataView body.\n        this._bodyInit = new Blob([this._bodyArrayBuffer]);\n      } else if (support.arrayBuffer && (ArrayBuffer.prototype.isPrototypeOf(body) || isArrayBufferView(body))) {\n        this._bodyArrayBuffer = bufferClone(body);\n      } else {\n        this._bodyText = body = Object.prototype.toString.call(body);\n      }\n\n      if (!this.headers.get('content-type')) {\n        if (typeof body === 'string') {\n          this.headers.set('content-type', 'text/plain;charset=UTF-8');\n        } else if (this._bodyBlob && this._bodyBlob.type) {\n          this.headers.set('content-type', this._bodyBlob.type);\n        } else if (support.searchParams && URLSearchParams.prototype.isPrototypeOf(body)) {\n          this.headers.set('content-type', 'application/x-www-form-urlencoded;charset=UTF-8');\n        }\n      }\n    };\n\n    if (support.blob) {\n      this.blob = function() {\n        var rejected = consumed(this);\n        if (rejected) {\n          return rejected\n        }\n\n        if (this._bodyBlob) {\n          return Promise.resolve(this._bodyBlob)\n        } else if (this._bodyArrayBuffer) {\n          return Promise.resolve(new Blob([this._bodyArrayBuffer]))\n        } else if (this._bodyFormData) {\n          throw new Error('could not read FormData body as blob')\n        } else {\n          return Promise.resolve(new Blob([this._bodyText]))\n        }\n      };\n\n      this.arrayBuffer = function() {\n        if (this._bodyArrayBuffer) {\n          return consumed(this) || Promise.resolve(this._bodyArrayBuffer)\n        } else {\n          return this.blob().then(readBlobAsArrayBuffer)\n        }\n      };\n    }\n\n    this.text = function() {\n      var rejected = consumed(this);\n      if (rejected) {\n        return rejected\n      }\n\n      if (this._bodyBlob) {\n        return readBlobAsText(this._bodyBlob)\n      } else if (this._bodyArrayBuffer) {\n        return Promise.resolve(readArrayBufferAsText(this._bodyArrayBuffer))\n      } else if (this._bodyFormData) {\n        throw new Error('could not read FormData body as text')\n      } else {\n        return Promise.resolve(this._bodyText)\n      }\n    };\n\n    if (support.formData) {\n      this.formData = function() {\n        return this.text().then(decode)\n      };\n    }\n\n    this.json = function() {\n      return this.text().then(JSON.parse)\n    };\n\n    return this\n  }\n\n  // HTTP methods whose capitalization should be normalized\n  var methods = ['DELETE', 'GET', 'HEAD', 'OPTIONS', 'POST', 'PUT'];\n\n  function normalizeMethod(method) {\n    var upcased = method.toUpperCase();\n    return methods.indexOf(upcased) > -1 ? upcased : method\n  }\n\n  function Request(input, options) {\n    options = options || {};\n    var body = options.body;\n\n    if (input instanceof Request) {\n      if (input.bodyUsed) {\n        throw new TypeError('Already read')\n      }\n      this.url = input.url;\n      this.credentials = input.credentials;\n      if (!options.headers) {\n        this.headers = new Headers(input.headers);\n      }\n      this.method = input.method;\n      this.mode = input.mode;\n      this.signal = input.signal;\n      if (!body && input._bodyInit != null) {\n        body = input._bodyInit;\n        input.bodyUsed = true;\n      }\n    } else {\n      this.url = String(input);\n    }\n\n    this.credentials = options.credentials || this.credentials || 'same-origin';\n    if (options.headers || !this.headers) {\n      this.headers = new Headers(options.headers);\n    }\n    this.method = normalizeMethod(options.method || this.method || 'GET');\n    this.mode = options.mode || this.mode || null;\n    this.signal = options.signal || this.signal;\n    this.referrer = null;\n\n    if ((this.method === 'GET' || this.method === 'HEAD') && body) {\n      throw new TypeError('Body not allowed for GET or HEAD requests')\n    }\n    this._initBody(body);\n  }\n\n  Request.prototype.clone = function() {\n    return new Request(this, {body: this._bodyInit})\n  };\n\n  function decode(body) {\n    var form = new FormData();\n    body\n      .trim()\n      .split('&')\n      .forEach(function(bytes) {\n        if (bytes) {\n          var split = bytes.split('=');\n          var name = split.shift().replace(/\\+/g, ' ');\n          var value = split.join('=').replace(/\\+/g, ' ');\n          form.append(decodeURIComponent(name), decodeURIComponent(value));\n        }\n      });\n    return form\n  }\n\n  function parseHeaders(rawHeaders) {\n    var headers = new Headers();\n    // Replace instances of \\r\\n and \\n followed by at least one space or horizontal tab with a space\n    // https://tools.ietf.org/html/rfc7230#section-3.2\n    var preProcessedHeaders = rawHeaders.replace(/\\r?\\n[\\t ]+/g, ' ');\n    preProcessedHeaders.split(/\\r?\\n/).forEach(function(line) {\n      var parts = line.split(':');\n      var key = parts.shift().trim();\n      if (key) {\n        var value = parts.join(':').trim();\n        headers.append(key, value);\n      }\n    });\n    return headers\n  }\n\n  Body.call(Request.prototype);\n\n  function Response(bodyInit, options) {\n    if (!options) {\n      options = {};\n    }\n\n    this.type = 'default';\n    this.status = options.status === undefined ? 200 : options.status;\n    this.ok = this.status >= 200 && this.status < 300;\n    this.statusText = 'statusText' in options ? options.statusText : 'OK';\n    this.headers = new Headers(options.headers);\n    this.url = options.url || '';\n    this._initBody(bodyInit);\n  }\n\n  Body.call(Response.prototype);\n\n  Response.prototype.clone = function() {\n    return new Response(this._bodyInit, {\n      status: this.status,\n      statusText: this.statusText,\n      headers: new Headers(this.headers),\n      url: this.url\n    })\n  };\n\n  Response.error = function() {\n    var response = new Response(null, {status: 0, statusText: ''});\n    response.type = 'error';\n    return response\n  };\n\n  var redirectStatuses = [301, 302, 303, 307, 308];\n\n  Response.redirect = function(url, status) {\n    if (redirectStatuses.indexOf(status) === -1) {\n      throw new RangeError('Invalid status code')\n    }\n\n    return new Response(null, {status: status, headers: {location: url}})\n  };\n\n  exports.DOMException = self.DOMException;\n  try {\n    new exports.DOMException();\n  } catch (err) {\n    exports.DOMException = function(message, name) {\n      this.message = message;\n      this.name = name;\n      var error = Error(message);\n      this.stack = error.stack;\n    };\n    exports.DOMException.prototype = Object.create(Error.prototype);\n    exports.DOMException.prototype.constructor = exports.DOMException;\n  }\n\n  function fetch(input, init) {\n    return new Promise(function(resolve, reject) {\n      var request = new Request(input, init);\n\n      if (request.signal && request.signal.aborted) {\n        return reject(new exports.DOMException('Aborted', 'AbortError'))\n      }\n\n      var xhr = new XMLHttpRequest();\n\n      function abortXhr() {\n        xhr.abort();\n      }\n\n      xhr.onload = function() {\n        var options = {\n          status: xhr.status,\n          statusText: xhr.statusText,\n          headers: parseHeaders(xhr.getAllResponseHeaders() || '')\n        };\n        options.url = 'responseURL' in xhr ? xhr.responseURL : options.headers.get('X-Request-URL');\n        var body = 'response' in xhr ? xhr.response : xhr.responseText;\n        resolve(new Response(body, options));\n      };\n\n      xhr.onerror = function() {\n        reject(new TypeError('Network request failed'));\n      };\n\n      xhr.ontimeout = function() {\n        reject(new TypeError('Network request failed'));\n      };\n\n      xhr.onabort = function() {\n        reject(new exports.DOMException('Aborted', 'AbortError'));\n      };\n\n      xhr.open(request.method, request.url, true);\n\n      if (request.credentials === 'include') {\n        xhr.withCredentials = true;\n      } else if (request.credentials === 'omit') {\n        xhr.withCredentials = false;\n      }\n\n      if ('responseType' in xhr && support.blob) {\n        xhr.responseType = 'blob';\n      }\n\n      request.headers.forEach(function(value, name) {\n        xhr.setRequestHeader(name, value);\n      });\n\n      if (request.signal) {\n        request.signal.addEventListener('abort', abortXhr);\n\n        xhr.onreadystatechange = function() {\n          // DONE (success or failure)\n          if (xhr.readyState === 4) {\n            request.signal.removeEventListener('abort', abortXhr);\n          }\n        };\n      }\n\n      xhr.send(typeof request._bodyInit === 'undefined' ? null : request._bodyInit);\n    })\n  }\n\n  fetch.polyfill = true;\n\n  if (!self.fetch) {\n    self.fetch = fetch;\n    self.Headers = Headers;\n    self.Request = Request;\n    self.Response = Response;\n  }\n\n  exports.Headers = Headers;\n  exports.Request = Request;\n  exports.Response = Response;\n  exports.fetch = fetch;\n\n  return exports;\n\n}({}));\n})(__self__);\ndelete __self__.fetch.polyfill\nexports = __self__.fetch // To enable: import fetch from 'cross-fetch'\nexports.default = __self__.fetch // For TypeScript consumers without esModuleInterop.\nexports.fetch = __self__.fetch // To enable: import {fetch} from 'cross-fetch'\nexports.Headers = __self__.Headers\nexports.Request = __self__.Request\nexports.Response = __self__.Response\nmodule.exports = exports\n\n\n/***/ }),\n/* 14 */\n/***/ (function(module, exports, __webpack_require__) {\n\nvar __WEBPACK_AMD_DEFINE_FACTORY__, __WEBPACK_AMD_DEFINE_RESULT__;/*!\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 (true) {\n\t\t!(__WEBPACK_AMD_DEFINE_FACTORY__ = (factory),\n\t\t\t\t__WEBPACK_AMD_DEFINE_RESULT__ = (typeof __WEBPACK_AMD_DEFINE_FACTORY__ === 'function' ?\n\t\t\t\t(__WEBPACK_AMD_DEFINE_FACTORY__.call(exports, __webpack_require__, exports, module)) :\n\t\t\t\t__WEBPACK_AMD_DEFINE_FACTORY__),\n\t\t\t\t__WEBPACK_AMD_DEFINE_RESULT__ !== undefined && (module.exports = __WEBPACK_AMD_DEFINE_RESULT__));\n\t\tregisteredInModuleLoader = true;\n\t}\n\tif (true) {\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/* 15 */\n/***/ (function(module, exports, __webpack_require__) {\n\n/*!\n * Copyright (c) 2015-present, Okta, Inc. and/or its affiliates. All rights reserved.\n * The Okta software accompanied by this notice is provided pursuant to the Apache License, Version 2.0 (the \"License.\")\n *\n * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0.\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS, WITHOUT\n * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n *\n * See the License for the specific language governing permissions and limitations under the License.\n */\n/* eslint-disable complexity */\n/* eslint-disable max-statements */\n/* SDK_VERSION is defined in webpack config */ \n/* global SDK_VERSION */\n\n__webpack_require__(16);\n\nvar Emitter           = __webpack_require__(18);\nvar AuthSdkError      = __webpack_require__(1);\nvar builderUtil       = __webpack_require__(19);\nvar constants         = __webpack_require__(2);\nvar cookies           = __webpack_require__(4).storage;\nvar http              = __webpack_require__(3);\nvar oauthUtil         = __webpack_require__(10);\nvar Q                 = __webpack_require__(5);\nvar session           = __webpack_require__(24);\nvar token             = __webpack_require__(25);\nvar TokenManager      = __webpack_require__(29);\nvar tx                = __webpack_require__(7);\nvar util              = __webpack_require__(0);\n\nfunction OktaAuthBuilder(args) {\n  var sdk = this;\n\n  var url = builderUtil.getValidUrl(args);\n  // OKTA-242989: support for grantType will be removed in 3.0 \n  var usePKCE = args.pkce || args.grantType === 'authorization_code';\n  this.options = {\n    url: util.removeTrailingSlash(url),\n    clientId: args.clientId,\n    issuer: util.removeTrailingSlash(args.issuer),\n    authorizeUrl: util.removeTrailingSlash(args.authorizeUrl),\n    userinfoUrl: util.removeTrailingSlash(args.userinfoUrl),\n    tokenUrl: util.removeTrailingSlash(args.tokenUrl),\n    revokeUrl: util.removeTrailingSlash(args.revokeUrl),\n    logoutUrl: util.removeTrailingSlash(args.logoutUrl),\n    pkce: usePKCE,\n    redirectUri: args.redirectUri,\n    postLogoutRedirectUri: args.postLogoutRedirectUri,\n    responseMode: args.responseMode,\n    httpRequestClient: args.httpRequestClient,\n    storageUtil: args.storageUtil,\n    transformErrorXHR: args.transformErrorXHR,\n    headers: args.headers,\n    onSessionExpired: args.onSessionExpired,\n  };\n\n  if (this.options.pkce && !sdk.features.isPKCESupported()) {\n    var errorMessage = 'PKCE requires a modern browser with encryption support running in a secure context.';\n    if (!sdk.features.isHTTPS()) {\n      errorMessage += '\\nThe current page is not being served with HTTPS protocol. Try using HTTPS.';\n    }\n    if (!sdk.features.hasTextEncoder()) {\n      errorMessage += '\\n\"TextEncoder\" is not defined. You may need a polyfill/shim for this browser.';\n    }\n    throw new AuthSdkError(errorMessage);\n  }\n\n  this.userAgent = 'okta-auth-js-' + \"2.13.2\";\n\n  // Digital clocks will drift over time, so the server\n  // can misalign with the time reported by the browser.\n  // The maxClockSkew allows relaxing the time-based\n  // validation of tokens (in seconds, not milliseconds).\n  // It currently defaults to 300, because 5 min is the\n  // default maximum tolerance allowed by Kerberos.\n  // (https://technet.microsoft.com/en-us/library/cc976357.aspx)\n  if (!args.maxClockSkew && args.maxClockSkew !== 0) {\n    this.options.maxClockSkew = constants.DEFAULT_MAX_CLOCK_SKEW;\n  } else {\n    this.options.maxClockSkew = args.maxClockSkew;\n  }\n\n  // Give the developer the ability to disable token signature\n  // validation.\n  this.options.ignoreSignature = !!args.ignoreSignature;\n\n  sdk.session = {\n    close: util.bind(session.closeSession, null, sdk),\n    exists: util.bind(session.sessionExists, null, sdk),\n    get: util.bind(session.getSession, null, sdk),\n    refresh: util.bind(session.refreshSession, null, sdk),\n    setCookieAndRedirect: util.bind(session.setCookieAndRedirect, null, sdk)\n  };\n\n  sdk.tx = {\n    status: util.bind(tx.transactionStatus, null, sdk),\n    resume: util.bind(tx.resumeTransaction, null, sdk),\n    exists: util.bind(tx.transactionExists, null, sdk),\n    introspect: util.bind(tx.introspect, null, sdk)\n  };\n\n  // This is exposed so we can mock document.cookie in our tests\n  sdk.tx.exists._get = function(name) {\n    return cookies.get(name);\n  };\n\n  // This is exposed so we can mock window.location.href in our tests\n  sdk.idToken = {\n    authorize: {\n      _getLocationHref: function() {\n        return window.location.href;\n      }\n    }\n  };\n\n  sdk.token = {\n    getWithoutPrompt: util.bind(token.getWithoutPrompt, null, sdk),\n    getWithPopup: util.bind(token.getWithPopup, null, sdk),\n    getWithRedirect: util.bind(token.getWithRedirect, null, sdk),\n    parseFromUrl: util.bind(token.parseFromUrl, null, sdk),\n    decode: token.decodeToken,\n    revoke: util.bind(token.revokeToken, null, sdk),\n    renew: util.bind(token.renewToken, null, sdk),\n    getUserInfo: util.bind(token.getUserInfo, null, sdk),\n    verify: util.bind(token.verifyToken, null, sdk)\n  };\n\n  // This is exposed so we can set window.location in our tests\n  sdk.token.getWithRedirect._setLocation = function(url) {\n    window.location = url;\n  };\n\n  // This is exposed so we can mock getting window.history in our tests\n  sdk.token.parseFromUrl._getHistory = function() {\n    return window.history;\n  };\n\n  // This is exposed so we can mock getting window.location in our tests\n  sdk.token.parseFromUrl._getLocation = function() {\n    return window.location;\n  };\n\n  // This is exposed so we can mock getting window.document in our tests\n  sdk.token.parseFromUrl._getDocument = function() {\n    return window.document;\n  };\n\n  sdk.fingerprint._getUserAgent = function() {\n    return navigator.userAgent;\n  };\n\n  var isWindowsPhone = /windows phone|iemobile|wpdesktop/i;\n  sdk.features.isFingerprintSupported = function() {\n    var agent = sdk.fingerprint._getUserAgent();\n    return agent && !isWindowsPhone.test(agent);\n  };\n\n  sdk.emitter = new Emitter();\n  sdk.tokenManager = new TokenManager(sdk, args.tokenManager);\n  sdk.tokenManager.on('error', this._onTokenManagerError, this);\n}\n\nvar proto = OktaAuthBuilder.prototype;\nproto._onTokenManagerError = function(error) {\n  var code = error.errorCode;\n  if (code === 'login_required' && error.accessToken) {\n    if (this.options.onSessionExpired) {\n      this.options.onSessionExpired();\n    } else {\n      // eslint-disable-next-line no-console\n      console.error('Session has expired or was closed outside the application.');\n    }\n  }\n};\n\nproto.features = {};\n\nproto.features.isPopupPostMessageSupported = function() {\n  var isIE8or9 = document.documentMode && document.documentMode < 10;\n  if (window.postMessage && !isIE8or9) {\n    return true;\n  }\n  return false;\n};\n\nproto.features.isTokenVerifySupported = function() {\n  return typeof crypto !== 'undefined' && crypto.subtle && typeof Uint8Array !== 'undefined';\n};\n\nproto.features.hasTextEncoder = function() {\n  return typeof TextEncoder !== 'undefined';\n};\n\nproto.features.isPKCESupported = function() {\n  return proto.features.isTokenVerifySupported() && proto.features.hasTextEncoder();\n};\n\nproto.features.isHTTPS = function() {\n  return window.location.protocol === 'https:';\n};\n\n// { username, password, (relayState), (context) }\nproto.signIn = function (opts) {\n  var sdk = this;\n  opts = util.clone(opts || {});\n  function postToTransaction(options) {\n    delete opts.sendFingerprint;\n    return tx.postToTransaction(sdk, '/api/v1/authn', opts, options);\n  }\n  if (!opts.sendFingerprint) {\n    return postToTransaction();\n  }\n  return sdk.fingerprint()\n  .then(function(fingerprint) {\n    return postToTransaction({\n      headers: {\n        'X-Device-Fingerprint': fingerprint\n      }\n    });\n  });\n};\n\n// Ends the current application session, clearing all local tokens\n// Optionally revokes the access token\n// Ends the user's Okta session using the API or redirect method\nproto.signOut = function (options) {\n  options = util.extend({}, options);\n\n  // postLogoutRedirectUri must be whitelisted in Okta Admin UI\n  var postLogoutRedirectUri = options.postLogoutRedirectUri || this.options.postLogoutRedirectUri;\n\n  var accessToken = options.accessToken;\n  var revokeAccessToken = options.revokeAccessToken;\n  var idToken = options.idToken;\n\n  var sdk = this;\n  var logoutUrl = oauthUtil.getOAuthUrls(sdk).logoutUrl;\n\n  function getAccessToken() {\n    return new Q()\n    .then(function() {\n      if (revokeAccessToken && typeof accessToken === 'undefined') {\n        return sdk.tokenManager.get('token');\n      }\n      return accessToken;\n    });\n  }\n\n  function getIdToken() {\n    return new Q()\n    .then(function() {\n      if (postLogoutRedirectUri && typeof idToken === 'undefined') {\n        return sdk.tokenManager.get('idToken');\n      }\n      return idToken;\n    });\n  }\n\n  function closeSession() {\n    return sdk.session.close() // DELETE /api/v1/sessions/me\n    .catch(function(e) {\n      if (e.name === 'AuthApiError') {\n        // Most likely cause is session does not exist or has already been closed\n        // Could also be a network error. Nothing we can do here.\n        return;\n      }\n      throw e;\n    });\n  }\n\n  return Q.allSettled([getAccessToken(), getIdToken()])\n    .then(function(tokens) {\n      accessToken = tokens[0].value;\n      idToken = tokens[1].value;\n\n      // Clear all local tokens\n      sdk.tokenManager.clear();\n\n      if (revokeAccessToken && accessToken) {\n        return sdk.token.revoke(accessToken)\n        .catch(function(e) {\n          if (e.name === 'AuthApiError') {\n            // Capture and ignore network errors\n            return;\n          }\n          throw e;\n        });\n      }\n    })\n    .then(function() {\n      // XHR signOut method\n      if (!postLogoutRedirectUri) {\n        return closeSession();\n      }\n\n      // No idToken? This can happen if the storage was cleared.\n      // Fallback to XHR signOut, then redirect to the post logout uri\n      if (!idToken) {\n        return closeSession()\n        .catch(function(err) {\n          // eslint-disable-next-line no-console\n          console.log('Unhandled exception while closing session', err);\n        })\n        .then(function() {\n          window.location.assign(postLogoutRedirectUri);\n        });\n      }\n\n      // logout redirect using the idToken.\n      var state = options.state;\n      var idTokenHint = idToken.idToken; // a string\n      var logoutUri = logoutUrl + '?id_token_hint=' + encodeURIComponent(idTokenHint) +\n        '&post_logout_redirect_uri=' + encodeURIComponent(postLogoutRedirectUri);\n    \n      // State allows option parameters to be passed to logout redirect uri\n      if (state) {\n        logoutUri += '&state=' + encodeURIComponent(state);\n      }\n      \n      window.location.assign(logoutUri);\n    });\n};\n\nbuilderUtil.addSharedPrototypes(proto);\n\n// { resource, (rel), (requestContext)}\nproto.webfinger = function (opts) {\n  var url = '/.well-known/webfinger' + util.toQueryParams(opts);\n  var options = {\n    headers: {\n      'Accept': 'application/jrd+json'\n    }\n  };\n  return http.get(this, url, options);\n};\n\nproto.fingerprint = function(options) {\n  options = options || {};\n  var sdk = this;\n  if (!sdk.features.isFingerprintSupported()) {\n    return Q.reject(new AuthSdkError('Fingerprinting is not supported on this device'));\n  }\n\n  var deferred = Q.defer();\n\n  var iframe = document.createElement('iframe');\n  iframe.style.display = 'none';\n\n  function listener(e) {\n    if (!e || !e.data || e.origin !== sdk.options.url) {\n      return;\n    }\n\n    try {\n      var msg = JSON.parse(e.data);\n    } catch (err) {\n      return deferred.reject(new AuthSdkError('Unable to parse iframe response'));\n    }\n\n    if (!msg) { return; }\n    if (msg.type === 'FingerprintAvailable') {\n      return deferred.resolve(msg.fingerprint);\n    }\n    if (msg.type === 'FingerprintServiceReady') {\n      e.source.postMessage(JSON.stringify({\n        type: 'GetFingerprint'\n      }), e.origin);\n    }\n  }\n  oauthUtil.addListener(window, 'message', listener);\n\n  iframe.src = sdk.options.url + '/auth/services/devicefingerprint';\n  document.body.appendChild(iframe);\n\n  var timeout = setTimeout(function() {\n    deferred.reject(new AuthSdkError('Fingerprinting timed out'));\n  }, options.timeout || 15000);\n\n  return deferred.promise.fin(function() {\n    clearTimeout(timeout);\n    oauthUtil.removeListener(window, 'message', listener);\n    if (document.body.contains(iframe)) {\n      iframe.parentElement.removeChild(iframe);\n    }\n  });\n};\n\nmodule.exports = builderUtil.buildOktaAuth(OktaAuthBuilder);\n\n\n/***/ }),\n/* 16 */\n/***/ (function(module, exports, __webpack_require__) {\n\n/*!\n * Copyright (c) 2015-2016, Okta, Inc. and/or its affiliates. All rights reserved.\n * The Okta software accompanied by this notice is provided pursuant to the Apache License, Version 2.0 (the \"License.\")\n *\n * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0.\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS, WITHOUT\n * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n *\n * See the License for the specific language governing permissions and limitations under the License.\n */\n\n__webpack_require__(17);\n\n// Production steps of ECMA-262, Edition 5, 15.4.4.14\n// Reference: http://es5.github.io/#x15.4.4.14\n// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/indexOf#Polyfill\nif (!Array.prototype.indexOf) {\n  Array.prototype.indexOf = function(searchElement, fromIndex) {\n\n    var k;\n\n    // 1. Let o be the result of calling ToObject passing\n    //    the this value as the argument.\n    if (this == null) {\n      throw new TypeError('\"this\" is null or not defined');\n    }\n\n    var o = Object(this);\n\n    // 2. Let lenValue be the result of calling the Get\n    //    internal method of o with the argument \"length\".\n    // 3. Let len be ToUint32(lenValue).\n    var len = o.length >>> 0;\n\n    // 4. If len is 0, return -1.\n    if (len === 0) {\n      return -1;\n    }\n\n    // 5. If argument fromIndex was passed let n be\n    //    ToInteger(fromIndex); else let n be 0.\n    var n = +fromIndex || 0;\n\n    if (Math.abs(n) === Infinity) {\n      n = 0;\n    }\n\n    // 6. If n >= len, return -1.\n    if (n >= len) {\n      return -1;\n    }\n\n    // 7. If n >= 0, then Let k be n.\n    // 8. Else, n<0, Let k be len - abs(n).\n    //    If k is less than 0, then let k be 0.\n    k = Math.max(n >= 0 ? n : len - Math.abs(n), 0);\n\n    // 9. Repeat, while k < len\n    while (k < len) {\n      // a. Let Pk be ToString(k).\n      //   This is implicit for LHS operands of the in operator\n      // b. Let kPresent be the result of calling the\n      //    HasProperty internal method of o with argument Pk.\n      //   This step can be combined with c\n      // c. If kPresent is true, then\n      //    i.  Let elementK be the result of calling the Get\n      //        internal method of o with the argument ToString(k).\n      //   ii.  Let same be the result of applying the\n      //        Strict Equality Comparison Algorithm to\n      //        searchElement and elementK.\n      //  iii.  If same is true, return k.\n      if (k in o && o[k] === searchElement) {\n        return k;\n      }\n      k++;\n    }\n    return -1;\n  };\n}\n\nif (!Array.isArray) {\n  Array.isArray = function(obj) {\n    return Object.prototype.toString.call(obj) === '[object Array]';\n  };\n}\n\n\n/***/ }),\n/* 17 */\n/***/ (function(module, exports, __webpack_require__) {\n\n;(function () {\n\n  var object =  true ? exports : this; // #8: web workers\n  var chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=';\n\n  function InvalidCharacterError(message) {\n    this.message = message;\n  }\n  InvalidCharacterError.prototype = new Error;\n  InvalidCharacterError.prototype.name = 'InvalidCharacterError';\n\n  // encoder\n  // [https://gist.github.com/999166] by [https://github.com/nignag]\n  object.btoa || (\n  object.btoa = function (input) {\n    var str = String(input);\n    for (\n      // initialize result and counter\n      var block, charCode, idx = 0, map = chars, output = '';\n      // if the next str index does not exist:\n      //   change the mapping table to \"=\"\n      //   check if d has no fractional digits\n      str.charAt(idx | 0) || (map = '=', idx % 1);\n      // \"8 - idx % 1 * 8\" generates the sequence 2, 4, 6, 8\n      output += map.charAt(63 & block >> 8 - idx % 1 * 8)\n    ) {\n      charCode = str.charCodeAt(idx += 3/4);\n      if (charCode > 0xFF) {\n        throw new InvalidCharacterError(\"'btoa' failed: The string to be encoded contains characters outside of the Latin1 range.\");\n      }\n      block = block << 8 | charCode;\n    }\n    return output;\n  });\n\n  // decoder\n  // [https://gist.github.com/1020396] by [https://github.com/atk]\n  object.atob || (\n  object.atob = function (input) {\n    var str = String(input).replace(/=+$/, '');\n    if (str.length % 4 == 1) {\n      throw new InvalidCharacterError(\"'atob' failed: The string to be decoded is not correctly encoded.\");\n    }\n    for (\n      // initialize result and counters\n      var bc = 0, bs, buffer, idx = 0, output = '';\n      // get next character\n      buffer = str.charAt(idx++);\n      // character found in table? initialize bit storage and add its ascii value;\n      ~buffer && (bs = bc % 4 ? bs * 64 + buffer : buffer,\n        // and if not first of each 4 characters,\n        // convert the first 8 bits to one ascii character\n        bc++ % 4) ? output += String.fromCharCode(255 & bs >> (-2 * bc & 6)) : 0\n    ) {\n      // try to find character in table (0-63, not found => -1)\n      buffer = chars.indexOf(buffer);\n    }\n    return output;\n  });\n\n}());\n\n\n/***/ }),\n/* 18 */\n/***/ (function(module, exports) {\n\nfunction E () {\n  // Keep this empty so it's easier to inherit from\n  // (via https://github.com/lipsmack from https://github.com/scottcorgan/tiny-emitter/issues/3)\n}\n\nE.prototype = {\n  on: function (name, callback, ctx) {\n    var e = this.e || (this.e = {});\n\n    (e[name] || (e[name] = [])).push({\n      fn: callback,\n      ctx: ctx\n    });\n\n    return this;\n  },\n\n  once: function (name, callback, ctx) {\n    var self = this;\n    function listener () {\n      self.off(name, listener);\n      callback.apply(ctx, arguments);\n    };\n\n    listener._ = callback\n    return this.on(name, listener, ctx);\n  },\n\n  emit: function (name) {\n    var data = [].slice.call(arguments, 1);\n    var evtArr = ((this.e || (this.e = {}))[name] || []).slice();\n    var i = 0;\n    var len = evtArr.length;\n\n    for (i; i < len; i++) {\n      evtArr[i].fn.apply(evtArr[i].ctx, data);\n    }\n\n    return this;\n  },\n\n  off: function (name, callback) {\n    var e = this.e || (this.e = {});\n    var evts = e[name];\n    var liveEvents = [];\n\n    if (evts && callback) {\n      for (var i = 0, len = evts.length; i < len; i++) {\n        if (evts[i].fn !== callback && evts[i].fn._ !== callback)\n          liveEvents.push(evts[i]);\n      }\n    }\n\n    // Remove event from queue to prevent memory leak\n    // Suggested by https://github.com/lazd\n    // Ref: https://github.com/scottcorgan/tiny-emitter/commit/c6ebfaa9bc973b33d110a84a307742b7cf94c953#commitcomment-5024910\n\n    (liveEvents.length)\n      ? e[name] = liveEvents\n      : delete e[name];\n\n    return this;\n  }\n};\n\nmodule.exports = E;\n\n\n/***/ }),\n/* 19 */\n/***/ (function(module, exports, __webpack_require__) {\n\n/*!\n * Copyright (c) 2018-present, Okta, Inc. and/or its affiliates. All rights reserved.\n * The Okta software accompanied by this notice is provided pursuant to the Apache License, Version 2.0 (the \"License.\")\n *\n * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0.\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS, WITHOUT\n * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n *\n * See the License for the specific language governing permissions and limitations under the License.\n */\n\nvar AuthSdkError = __webpack_require__(1);\nvar tx = __webpack_require__(7);\nvar util = __webpack_require__(0);\n\nfunction getValidUrl(args) {\n  if (!args) {\n    throw new AuthSdkError('No arguments passed to constructor. ' +\n      'Required usage: new OktaAuth(args)');\n  }\n\n  var url = args.url;\n  if (!url) {\n    var isUrlRegex = new RegExp('^http?s?://.+');\n    if (args.issuer && isUrlRegex.test(args.issuer)) {\n      // Infer the URL from the issuer URL, omitting the /oauth2/{authServerId}\n      url = args.issuer.split('/oauth2/')[0];\n    } else {\n      throw new AuthSdkError('No url passed to constructor. ' +\n      'Required usage: new OktaAuth({url: \"https://{yourOktaDomain}.com\"})');\n    }\n  }\n\n  if (url.indexOf('-admin.') !== -1) {\n    throw new AuthSdkError('URL passed to constructor contains \"-admin\" in subdomain. ' +\n      'Required usage: new OktaAuth({url: \"https://{yourOktaDomain}.com})');\n  }\n\n  return url;\n}\n\nfunction addSharedPrototypes(proto) {\n  // { username, (relayState) }\n  proto.forgotPassword = function (opts) {\n    return tx.postToTransaction(this, '/api/v1/authn/recovery/password', opts);\n  };\n\n  // { username, (relayState) }\n  proto.unlockAccount = function (opts) {\n    return tx.postToTransaction(this, '/api/v1/authn/recovery/unlock', opts);\n  };\n\n  // { recoveryToken }\n  proto.verifyRecoveryToken = function (opts) {\n    return tx.postToTransaction(this, '/api/v1/authn/recovery/token', opts);\n  };\n}\n\nfunction buildOktaAuth(OktaAuthBuilder) {\n  return function(storageUtil, httpRequestClient) {\n    function OktaAuth(args) {\n      if (!(this instanceof OktaAuth)) {\n        return new OktaAuth(args);\n      }\n\n      if (args) {\n        args.storageUtil = storageUtil;\n\n        if (args.ajaxRequest) {\n          util.deprecate('ajaxRequest is being deprecated, use httpRequestClient attribute instead.');\n          args.httpRequestClient = args.ajaxRequest;\n        } else if (!args.httpRequestClient) {\n          args.httpRequestClient = httpRequestClient;\n        }\n      }\n\n      util.bind(OktaAuthBuilder, this)(args);\n    }\n    OktaAuth.prototype = OktaAuthBuilder.prototype;\n    OktaAuth.prototype.constructor = OktaAuth;\n\n    // Hoist feature detection functions to static type\n    OktaAuth.features = OktaAuthBuilder.prototype.features;\n\n    return OktaAuth;\n  };\n}\n\nmodule.exports = {\n  addSharedPrototypes: addSharedPrototypes,\n  buildOktaAuth: buildOktaAuth,\n  getValidUrl: getValidUrl\n};\n\n\n/***/ }),\n/* 20 */\n/***/ (function(module, exports, __webpack_require__) {\n\n/* WEBPACK VAR INJECTION */(function(global) {var scope = (typeof global !== \"undefined\" && global) ||\n            (typeof self !== \"undefined\" && self) ||\n            window;\nvar apply = Function.prototype.apply;\n\n// DOM APIs, for completeness\n\nexports.setTimeout = function() {\n  return new Timeout(apply.call(setTimeout, scope, arguments), clearTimeout);\n};\nexports.setInterval = function() {\n  return new Timeout(apply.call(setInterval, scope, arguments), clearInterval);\n};\nexports.clearTimeout =\nexports.clearInterval = function(timeout) {\n  if (timeout) {\n    timeout.close();\n  }\n};\n\nfunction Timeout(id, clearFn) {\n  this._id = id;\n  this._clearFn = clearFn;\n}\nTimeout.prototype.unref = Timeout.prototype.ref = function() {};\nTimeout.prototype.close = function() {\n  this._clearFn.call(scope, this._id);\n};\n\n// Does not start the time, just sets up the members needed.\nexports.enroll = function(item, msecs) {\n  clearTimeout(item._idleTimeoutId);\n  item._idleTimeout = msecs;\n};\n\nexports.unenroll = function(item) {\n  clearTimeout(item._idleTimeoutId);\n  item._idleTimeout = -1;\n};\n\nexports._unrefActive = exports.active = function(item) {\n  clearTimeout(item._idleTimeoutId);\n\n  var msecs = item._idleTimeout;\n  if (msecs >= 0) {\n    item._idleTimeoutId = setTimeout(function onTimeout() {\n      if (item._onTimeout)\n        item._onTimeout();\n    }, msecs);\n  }\n};\n\n// setimmediate attaches itself to the global object\n__webpack_require__(21);\n// On some exotic environments, it's not clear which object `setimmediate` was\n// able to install onto.  Search each possibility in the same order as the\n// `setimmediate` library.\nexports.setImmediate = (typeof self !== \"undefined\" && self.setImmediate) ||\n                       (typeof global !== \"undefined\" && global.setImmediate) ||\n                       (this && this.setImmediate);\nexports.clearImmediate = (typeof self !== \"undefined\" && self.clearImmediate) ||\n                         (typeof global !== \"undefined\" && global.clearImmediate) ||\n                         (this && this.clearImmediate);\n\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(9)))\n\n/***/ }),\n/* 21 */\n/***/ (function(module, exports, __webpack_require__) {\n\n/* WEBPACK VAR INJECTION */(function(global, process) {(function (global, undefined) {\n    \"use strict\";\n\n    if (global.setImmediate) {\n        return;\n    }\n\n    var nextHandle = 1; // Spec says greater than zero\n    var tasksByHandle = {};\n    var currentlyRunningATask = false;\n    var doc = global.document;\n    var registerImmediate;\n\n    function setImmediate(callback) {\n      // Callback can either be a function or a string\n      if (typeof callback !== \"function\") {\n        callback = new Function(\"\" + callback);\n      }\n      // Copy function arguments\n      var args = new Array(arguments.length - 1);\n      for (var i = 0; i < args.length; i++) {\n          args[i] = arguments[i + 1];\n      }\n      // Store and register the task\n      var task = { callback: callback, args: args };\n      tasksByHandle[nextHandle] = task;\n      registerImmediate(nextHandle);\n      return nextHandle++;\n    }\n\n    function clearImmediate(handle) {\n        delete tasksByHandle[handle];\n    }\n\n    function run(task) {\n        var callback = task.callback;\n        var args = task.args;\n        switch (args.length) {\n        case 0:\n            callback();\n            break;\n        case 1:\n            callback(args[0]);\n            break;\n        case 2:\n            callback(args[0], args[1]);\n            break;\n        case 3:\n            callback(args[0], args[1], args[2]);\n            break;\n        default:\n            callback.apply(undefined, args);\n            break;\n        }\n    }\n\n    function runIfPresent(handle) {\n        // From the spec: \"Wait until any invocations of this algorithm started before this one have completed.\"\n        // So if we're currently running a task, we'll need to delay this invocation.\n        if (currentlyRunningATask) {\n            // Delay by doing a setTimeout. setImmediate was tried instead, but in Firefox 7 it generated a\n            // \"too much recursion\" error.\n            setTimeout(runIfPresent, 0, handle);\n        } else {\n            var task = tasksByHandle[handle];\n            if (task) {\n                currentlyRunningATask = true;\n                try {\n                    run(task);\n                } finally {\n                    clearImmediate(handle);\n                    currentlyRunningATask = false;\n                }\n            }\n        }\n    }\n\n    function installNextTickImplementation() {\n        registerImmediate = function(handle) {\n            process.nextTick(function () { runIfPresent(handle); });\n        };\n    }\n\n    function canUsePostMessage() {\n        // The test against `importScripts` prevents this implementation from being installed inside a web worker,\n        // where `global.postMessage` means something completely different and can't be used for this purpose.\n        if (global.postMessage && !global.importScripts) {\n            var postMessageIsAsynchronous = true;\n            var oldOnMessage = global.onmessage;\n            global.onmessage = function() {\n                postMessageIsAsynchronous = false;\n            };\n            global.postMessage(\"\", \"*\");\n            global.onmessage = oldOnMessage;\n            return postMessageIsAsynchronous;\n        }\n    }\n\n    function installPostMessageImplementation() {\n        // Installs an event handler on `global` for the `message` event: see\n        // * https://developer.mozilla.org/en/DOM/window.postMessage\n        // * http://www.whatwg.org/specs/web-apps/current-work/multipage/comms.html#crossDocumentMessages\n\n        var messagePrefix = \"setImmediate$\" + Math.random() + \"$\";\n        var onGlobalMessage = function(event) {\n            if (event.source === global &&\n                typeof event.data === \"string\" &&\n                event.data.indexOf(messagePrefix) === 0) {\n                runIfPresent(+event.data.slice(messagePrefix.length));\n            }\n        };\n\n        if (global.addEventListener) {\n            global.addEventListener(\"message\", onGlobalMessage, false);\n        } else {\n            global.attachEvent(\"onmessage\", onGlobalMessage);\n        }\n\n        registerImmediate = function(handle) {\n            global.postMessage(messagePrefix + handle, \"*\");\n        };\n    }\n\n    function installMessageChannelImplementation() {\n        var channel = new MessageChannel();\n        channel.port1.onmessage = function(event) {\n            var handle = event.data;\n            runIfPresent(handle);\n        };\n\n        registerImmediate = function(handle) {\n            channel.port2.postMessage(handle);\n        };\n    }\n\n    function installReadyStateChangeImplementation() {\n        var html = doc.documentElement;\n        registerImmediate = function(handle) {\n            // Create a <script> element; its readystatechange event will be fired asynchronously once it is inserted\n            // into the document. Do so, thus queuing up the task. Remember to clean up once it's been called.\n            var script = doc.createElement(\"script\");\n            script.onreadystatechange = function () {\n                runIfPresent(handle);\n                script.onreadystatechange = null;\n                html.removeChild(script);\n                script = null;\n            };\n            html.appendChild(script);\n        };\n    }\n\n    function installSetTimeoutImplementation() {\n        registerImmediate = function(handle) {\n            setTimeout(runIfPresent, 0, handle);\n        };\n    }\n\n    // If supported, we should attach to the prototype of global, since that is where setTimeout et al. live.\n    var attachTo = Object.getPrototypeOf && Object.getPrototypeOf(global);\n    attachTo = attachTo && attachTo.setTimeout ? attachTo : global;\n\n    // Don't get fooled by e.g. browserify environments.\n    if ({}.toString.call(global.process) === \"[object process]\") {\n        // For Node.js before 0.9\n        installNextTickImplementation();\n\n    } else if (canUsePostMessage()) {\n        // For non-IE10 modern browsers\n        installPostMessageImplementation();\n\n    } else if (global.MessageChannel) {\n        // For web workers, where supported\n        installMessageChannelImplementation();\n\n    } else if (doc && \"onreadystatechange\" in doc.createElement(\"script\")) {\n        // For IE 6–8\n        installReadyStateChangeImplementation();\n\n    } else {\n        // For older browsers\n        installSetTimeoutImplementation();\n    }\n\n    attachTo.setImmediate = setImmediate;\n    attachTo.clearImmediate = clearImmediate;\n}(typeof self === \"undefined\" ? typeof global === \"undefined\" ? this : global : self));\n\n/* WEBPACK VAR INJECTION */}.call(exports, __webpack_require__(9), __webpack_require__(8)))\n\n/***/ }),\n/* 22 */\n/***/ (function(module, exports) {\n\n/*!\n * Copyright (c) 2015-present, Okta, Inc. and/or its affiliates. All rights reserved.\n * The Okta software accompanied by this notice is provided pursuant to the Apache License, Version 2.0 (the \"License.\")\n *\n * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0.\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS, WITHOUT\n * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n *\n * See the License for the specific language governing permissions and limitations under the License.\n */\n\nfunction AuthApiError(err, xhr) {\n  this.name = 'AuthApiError';\n  this.message = err.errorSummary;\n  this.errorSummary = err.errorSummary;\n  this.errorCode = err.errorCode;\n  this.errorLink = err.errorLink;\n  this.errorId = err.errorId;\n  this.errorCauses = err.errorCauses;\n\n  if (xhr) {\n    this.xhr = xhr;\n  }\n}\nAuthApiError.prototype = new Error();\n\nmodule.exports = AuthApiError;\n\n\n/***/ }),\n/* 23 */\n/***/ (function(module, exports) {\n\n/*!\n * Copyright (c) 2015-present, Okta, Inc. and/or its affiliates. All rights reserved.\n * The Okta software accompanied by this notice is provided pursuant to the Apache License, Version 2.0 (the \"License.\")\n *\n * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0.\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS, WITHOUT\n * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n *\n * See the License for the specific language governing permissions and limitations under the License.\n */\n\nfunction AuthPollStopError() {\n  this.name = 'AuthPollStopError';\n  this.message = 'The poll was stopped by the sdk';\n}\nAuthPollStopError.prototype = new Error();\n\nmodule.exports = AuthPollStopError;\n\n\n/***/ }),\n/* 24 */\n/***/ (function(module, exports, __webpack_require__) {\n\n/*!\n * Copyright (c) 2015-present, Okta, Inc. and/or its affiliates. All rights reserved.\n * The Okta software accompanied by this notice is provided pursuant to the Apache License, Version 2.0 (the \"License.\")\n *\n * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0.\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS, WITHOUT\n * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n *\n * See the License for the specific language governing permissions and limitations under the License.\n *\n */\n\nvar util = __webpack_require__(0);\nvar http = __webpack_require__(3);\n\nfunction sessionExists(sdk) {\n  return sdk.session.get()\n    .then(function(res) {\n      if (res.status === 'ACTIVE') {\n        return true;\n      }\n      return false;\n    })\n    .fail(function() {\n      return false;\n    });\n}\n\nfunction getSession(sdk) { \n  return http.get(sdk, '/api/v1/sessions/me')\n  .then(function(session) {\n    var res = util.omit(session, '_links');\n\n    res.refresh = function() {\n      return http.post(sdk, util.getLink(session, 'refresh').href);\n    };\n\n    res.user = function() {\n      return http.get(sdk, util.getLink(session, 'user').href);\n    };\n\n    return res;\n  })\n  .fail(function() {\n    // Return INACTIVE status on failure\n    return {status: 'INACTIVE'};\n  });\n}\n\nfunction closeSession(sdk) {\n  return http.httpRequest(sdk, {\n    url: sdk.options.url + '/api/v1/sessions/me',\n    method: 'DELETE'\n  });\n}\n\nfunction refreshSession(sdk) {\n  return http.post(sdk, '/api/v1/sessions/me/lifecycle/refresh');\n}\n\nfunction setCookieAndRedirect(sdk, sessionToken, redirectUrl) {\n  redirectUrl = redirectUrl || window.location.href;\n  window.location = sdk.options.url + '/login/sessionCookieRedirect' +\n    util.toQueryParams({\n      checkAccountSetupComplete: true,\n      token: sessionToken,\n      redirectUrl: redirectUrl\n    });\n}\n\nmodule.exports = {\n  sessionExists: sessionExists,\n  getSession: getSession,\n  closeSession: closeSession,\n  refreshSession: refreshSession,\n  setCookieAndRedirect: setCookieAndRedirect\n};\n\n\n/***/ }),\n/* 25 */\n/***/ (function(module, exports, __webpack_require__) {\n\n/*!\n * Copyright (c) 2015-present, Okta, Inc. and/or its affiliates. All rights reserved.\n * The Okta software accompanied by this notice is provided pursuant to the Apache License, Version 2.0 (the \"License.\")\n *\n * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0.\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS, WITHOUT\n * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n *\n * See the License for the specific language governing permissions and limitations under the License.\n *\n */\n\n/* eslint-disable complexity, max-statements */\nvar http          = __webpack_require__(3);\nvar util          = __webpack_require__(0);\nvar oauthUtil     = __webpack_require__(10);\nvar Q             = __webpack_require__(5);\nvar sdkCrypto     = __webpack_require__(26);\nvar AuthSdkError  = __webpack_require__(1);\nvar OAuthError    = __webpack_require__(27);\nvar constants     = __webpack_require__(2);\nvar cookies       = __webpack_require__(4).storage;\nvar PKCE          = __webpack_require__(28);\n\n// Only the access token can be revoked in SPA applications\nfunction revokeToken(sdk, token) {\n  return new Q()\n  .then(function() {\n    if (!token || !token.accessToken) {\n      throw new AuthSdkError('A valid access token object is required');\n    }\n    var clientId = sdk.options.clientId;\n    if (!clientId) {\n      throw new AuthSdkError('A clientId must be specified in the OktaAuth constructor to revoke a token');\n    }\n    var revokeUrl = oauthUtil.getOAuthUrls(sdk).revokeUrl;\n    var accessToken = token.accessToken;\n    var args = util.toQueryParams({\n      // eslint-disable-next-line camelcase\n      token_type_hint: 'access_token',\n      token: accessToken\n    }).slice(1);\n    var creds = btoa(clientId);\n    return http.post(sdk, revokeUrl, args, {\n      headers: {\n        'Content-Type': 'application/x-www-form-urlencoded',\n        'Authorization': 'Basic ' + creds\n      }\n    });\n  });\n}\n\nfunction decodeToken(token) {\n  var jwt = token.split('.');\n  var decodedToken;\n\n  try {\n    decodedToken = {\n      header: JSON.parse(util.base64UrlToString(jwt[0])),\n      payload: JSON.parse(util.base64UrlToString(jwt[1])),\n      signature: jwt[2]\n    };\n  } catch(e) {\n    throw new AuthSdkError('Malformed token');\n  }\n\n  return decodedToken;\n}\n\n// Verify the id token\nfunction verifyToken(sdk, token, validationParams) {\n  return new Q()\n  .then(function() {\n    if (!token || !token.idToken) {\n      throw new AuthSdkError('Only idTokens may be verified');\n    }\n\n    var jwt = decodeToken(token.idToken);\n\n    var validationOptions = {\n      clientId: sdk.options.clientId,\n      issuer: sdk.options.issuer || sdk.options.url,\n      ignoreSignature: sdk.options.ignoreSignature\n    };\n\n    util.extend(validationOptions, validationParams);\n\n    // Standard claim validation\n    oauthUtil.validateClaims(sdk, jwt.payload, validationOptions);\n\n    // If the browser doesn't support native crypto or we choose not\n    // to verify the signature, bail early\n    if (validationOptions.ignoreSignature == true || !sdk.features.isTokenVerifySupported()) {\n      return token;\n    }\n\n    return oauthUtil.getKey(sdk, token.issuer, jwt.header.kid)\n    .then(function(key) {\n      return sdkCrypto.verifyToken(token.idToken, key);\n    })\n    .then(function(valid) {\n      if (!valid) {\n        throw new AuthSdkError('The token signature is not valid');\n      }\n      return token;\n    });\n  });\n}\n\nfunction addPostMessageListener(sdk, timeout, state) {\n  var deferred = Q.defer();\n\n  function responseHandler(e) {\n    if (!e.data || e.data.state !== state) {\n      // A message not meant for us\n      return;\n    }\n\n    // Configuration mismatch between saved token and current app instance\n    // This may happen if apps with different issuers are running on the same host url\n    // If they share the same storage key, they may read and write tokens in the same location.\n    // Common when developing against http://localhost\n    if (e.origin !== sdk.options.url) {\n      return deferred.reject(new AuthSdkError('The request does not match client configuration'));\n    }\n\n    deferred.resolve(e.data);\n  }\n\n  oauthUtil.addListener(window, 'message', responseHandler);\n\n  return deferred.promise.timeout(timeout || 120000, new AuthSdkError('OAuth flow timed out'))\n    .fin(function() {\n      oauthUtil.removeListener(window, 'message', responseHandler);\n    });\n}\n\nfunction addFragmentListener(sdk, windowEl, timeout) {\n  var deferred = Q.defer();\n\n  function hashChangeHandler() {\n    /*\n      We are only able to access window.location.hash on a window\n      that has the same domain. A try/catch is necessary because\n      there's no other way to determine that the popup is in\n      another domain. When we try to access a window on another\n      domain, an error is thrown.\n    */\n    try {\n      if (windowEl &&\n          windowEl.location &&\n          windowEl.location.hash) {\n        deferred.resolve(oauthUtil.hashToObject(windowEl.location.hash));\n      } else if (windowEl && !windowEl.closed) {\n        setTimeout(hashChangeHandler, 500);\n      }\n    } catch (err) {\n      setTimeout(hashChangeHandler, 500);\n    }\n  }\n\n  hashChangeHandler();\n\n  return deferred.promise.timeout(timeout || 120000, new AuthSdkError('OAuth flow timed out'));\n}\n\nfunction exchangeCodeForToken(sdk, oauthParams, authorizationCode, urls) {\n  // PKCE authorization_code flow\n  // Retrieve saved values and build oauthParams for call to /token\n  var meta = PKCE.loadMeta(sdk);\n  var getTokenParams = {\n    clientId: oauthParams.clientId,\n    authorizationCode: authorizationCode,\n    codeVerifier: meta.codeVerifier,\n    redirectUri: meta.redirectUri\n  };\n  return PKCE.getToken(sdk, getTokenParams, urls)\n  .then(function(res) {\n    validateResponse(res, getTokenParams);\n    return res;\n  })\n  .fin(function() {\n    PKCE.clearMeta(sdk);\n  });\n}\n\nfunction validateResponse(res, oauthParams) {\n  if (res['error'] || res['error_description']) {\n    throw new OAuthError(res['error'], res['error_description']);\n  }\n\n  if (res.state !== oauthParams.state) {\n    throw new AuthSdkError('OAuth flow response state doesn\\'t match request state');\n  }\n}\n\nfunction handleOAuthResponse(sdk, oauthParams, res, urls) {\n  urls = urls || {};\n\n  var responseType = oauthParams.responseType;\n  var scopes = util.clone(oauthParams.scopes);\n  var clientId = oauthParams.clientId || sdk.options.clientId;\n\n  return new Q()\n  .then(function() {\n    validateResponse(res, oauthParams);\n\n    // We do not support \"hybrid\" scenarios where the response includes both a code and a token.\n    // If the response contains a code it is used immediately to obtain new tokens.\n    if (res['code']) {\n      responseType = ['token', 'id_token']; // what we expect the code to provide us\n      return exchangeCodeForToken(sdk, oauthParams, res['code'], urls);\n    }\n    return res;\n  }).then(function(res) {\n    var tokenDict = {};\n\n    if (res['access_token']) {\n      tokenDict['token'] = {\n        accessToken: res['access_token'],\n        expiresAt: Number(res['expires_in']) + Math.floor(Date.now()/1000),\n        tokenType: res['token_type'],\n        scopes: scopes,\n        authorizeUrl: urls.authorizeUrl,\n        userinfoUrl: urls.userinfoUrl\n      };\n    }\n\n    if (res['id_token']) {\n      var jwt = sdk.token.decode(res['id_token']);\n\n      var idToken = {\n        idToken: res['id_token'],\n        claims: jwt.payload,\n        expiresAt: jwt.payload.exp,\n        scopes: scopes,\n        authorizeUrl: urls.authorizeUrl,\n        issuer: urls.issuer,\n        clientId: clientId\n      };\n\n      var validationParams = {\n        clientId: clientId,\n        issuer: urls.issuer,\n        nonce: oauthParams.nonce\n      };\n\n      if (oauthParams.ignoreSignature !== undefined) {\n        validationParams.ignoreSignature = oauthParams.ignoreSignature;\n      }\n\n      return verifyToken(sdk, idToken, validationParams)\n      .then(function() {\n        tokenDict['id_token'] = idToken;\n        return tokenDict;\n      });\n    }\n\n    return tokenDict;\n  })\n  .then(function(tokenDict) {\n    if (!Array.isArray(responseType)) {\n      return tokenDict[responseType];\n    }\n\n    // Validate response against tokenTypes\n    var validateTokenTypes =  ['token', 'id_token'];\n    validateTokenTypes.filter(function(key) {\n      return (responseType.indexOf(key) !== -1);\n    }).forEach(function(key) {\n      if (!tokenDict[key]) {\n        throw new AuthSdkError('Unable to parse OAuth flow response: ' + key + ' was not returned.');\n      }     \n    });\n\n    // Create token array in the order of the responseType array\n    return responseType.map(function(item) {\n      return tokenDict[item];\n    });\n  });\n}\n\nfunction getDefaultOAuthParams(sdk) {\n  return {\n    pkce: sdk.options.pkce || false,\n    clientId: sdk.options.clientId,\n    redirectUri: sdk.options.redirectUri || window.location.href,\n    responseType: 'id_token',\n    responseMode: 'okta_post_message',\n    state: oauthUtil.generateState(),\n    nonce: oauthUtil.generateNonce(),\n    scopes: ['openid', 'email'],\n    ignoreSignature: sdk.options.ignoreSignature\n  };\n}\n\nfunction convertOAuthParamsToQueryParams(oauthParams) {\n  // Quick validation\n  if (!oauthParams.clientId) {\n    throw new AuthSdkError('A clientId must be specified in the OktaAuth constructor to get a token');\n  }\n\n  if (util.isString(oauthParams.responseType) && oauthParams.responseType.indexOf(' ') !== -1) {\n    throw new AuthSdkError('Multiple OAuth responseTypes must be defined as an array');\n  }\n\n  // Convert our params to their actual OAuth equivalents\n  var oauthQueryParams = util.removeNils({\n    'client_id': oauthParams.clientId,\n    'code_challenge': oauthParams.codeChallenge,\n    'code_challenge_method': oauthParams.codeChallengeMethod,\n    'display': oauthParams.display,\n    'idp': oauthParams.idp,\n    'idp_scope': oauthParams.idpScope,\n    'login_hint': oauthParams.loginHint,\n    'max_age': oauthParams.maxAge,\n    'nonce': oauthParams.nonce,\n    'prompt': oauthParams.prompt,\n    'redirect_uri': oauthParams.redirectUri,\n    'response_mode': oauthParams.responseMode,\n    'response_type': oauthParams.responseType,\n    'sessionToken': oauthParams.sessionToken,\n    'state': oauthParams.state,\n  });\n\n  ['idp_scope', 'response_type'].forEach( function( mayBeArray ) { \n    if (Array.isArray(oauthQueryParams[mayBeArray])) {\n      oauthQueryParams[mayBeArray] = oauthQueryParams[mayBeArray].join(' ');\n    }\n  });\n\n  if (oauthParams.responseType.indexOf('id_token') !== -1 &&\n      oauthParams.scopes.indexOf('openid') === -1) {\n    throw new AuthSdkError('openid scope must be specified in the scopes argument when requesting an id_token');\n  } else {\n    oauthQueryParams.scope = oauthParams.scopes.join(' ');\n  }\n\n  return oauthQueryParams;\n}\n\nfunction buildAuthorizeParams(oauthParams) {\n  var oauthQueryParams = convertOAuthParamsToQueryParams(oauthParams);\n  return util.toQueryParams(oauthQueryParams);\n}\n\n/*\n * Retrieve an idToken from an Okta or a third party idp\n *\n * Two main flows:\n *\n *  1) Exchange a sessionToken for a token\n *\n *    Required:\n *      clientId: passed via the OktaAuth constructor or into getToken\n *      sessionToken: 'yourtoken'\n *\n *    Optional:\n *      redirectUri: defaults to window.location.href\n *      scopes: defaults to ['openid', 'email']\n *\n *    Forced:\n *      prompt: 'none'\n *      responseMode: 'okta_post_message'\n *      display: undefined\n *\n *  2) Get a token from an idp\n *\n *    Required:\n *      clientId: passed via the OktaAuth constructor or into getToken\n *\n *    Optional:\n *      redirectUri: defaults to window.location.href\n *      scopes: defaults to ['openid', 'email']\n *      idp: defaults to Okta as an idp\n *      prompt: no default. Pass 'none' to throw an error if user is not signed in\n *\n *    Forced:\n *      display: 'popup'\n *\n *  Only common optional params shown. Any OAuth parameters not explicitly forced are available to override\n *\n * @param {Object} oauthOptions\n * @param {String} [oauthOptions.clientId] ID of this client\n * @param {String} [oauthOptions.redirectUri] URI that the iframe or popup will go to once authenticated\n * @param {String[]} [oauthOptions.scopes] OAuth 2.0 scopes to request (openid must be specified)\n * @param {String} [oauthOptions.idp] ID of an external IdP to use for user authentication\n * @param {String} [oauthOptions.sessionToken] Bootstrap Session Token returned by the Okta Authentication API\n * @param {String} [oauthOptions.prompt] Determines whether the Okta login will be displayed on failure.\n *                                       Use 'none' to prevent this behavior\n *\n * @param {Object} options\n * @param {Integer} [options.timeout] Time in ms before the flow is automatically terminated. Defaults to 120000\n * @param {String} [options.popupTitle] Title dispayed in the popup.\n *                                      Defaults to 'External Identity Provider User Authentication'\n */\nfunction getToken(sdk, oauthOptions, options) {\n  oauthOptions = oauthOptions || {};\n  options = options || {};\n\n  return prepareOauthParams(sdk, oauthOptions)\n  .then(function(oauthParams) {\n\n    // Start overriding any options that don't make sense\n    var sessionTokenOverrides = {\n      prompt: 'none',\n      responseMode: 'okta_post_message',\n      display: null\n    };\n\n    var idpOverrides = {\n      display: 'popup'\n    };\n\n    if (oauthOptions.sessionToken) {\n      util.extend(oauthParams, sessionTokenOverrides);\n    } else if (oauthOptions.idp) {\n      util.extend(oauthParams, idpOverrides);\n    }\n\n    // Use the query params to build the authorize url\n    var requestUrl,\n        endpoint,\n        urls;\n    try {\n      // Get authorizeUrl and issuer\n      urls = oauthUtil.getOAuthUrls(sdk, oauthParams, options);\n      endpoint = oauthOptions.codeVerifier ? urls.tokenUrl : urls.authorizeUrl;\n      requestUrl = endpoint + buildAuthorizeParams(oauthParams);\n    } catch (e) {\n      return Q.reject(e);\n    }\n\n    // Determine the flow type\n    var flowType;\n    if (oauthParams.sessionToken || oauthParams.display === null) {\n      flowType = 'IFRAME';\n    } else if (oauthParams.display === 'popup') {\n      flowType = 'POPUP';\n    } else {\n      flowType = 'IMPLICIT';\n    }\n\n    function getOrigin(url) {\n      /* eslint-disable-next-line no-useless-escape */\n      var originRegex = /^(https?\\:\\/\\/)?([^:\\/?#]*(?:\\:[0-9]+)?)/;\n      return originRegex.exec(url)[0];\n    }\n\n    // Execute the flow type\n    switch (flowType) {\n      case 'IFRAME':\n        var iframePromise = addPostMessageListener(sdk, options.timeout, oauthParams.state);\n        var iframeEl = oauthUtil.loadFrame(requestUrl);\n        return iframePromise\n          .then(function(res) {\n            return handleOAuthResponse(sdk, oauthParams, res, urls);\n          })\n          .fin(function() {\n            if (document.body.contains(iframeEl)) {\n              iframeEl.parentElement.removeChild(iframeEl);\n            }\n          });\n\n      case 'POPUP': // eslint-disable-line no-case-declarations\n        var popupPromise;\n\n        // Add listener on postMessage before window creation, so\n        // postMessage isn't triggered before we're listening\n        if (oauthParams.responseMode === 'okta_post_message') {\n          if (!sdk.features.isPopupPostMessageSupported()) {\n            return Q.reject(new AuthSdkError('This browser doesn\\'t have full postMessage support'));\n          }\n          popupPromise = addPostMessageListener(sdk, options.timeout, oauthParams.state);\n        }\n\n        // Create the window\n        var windowOptions = {\n          popupTitle: options.popupTitle\n        };\n        var windowEl = oauthUtil.loadPopup(requestUrl, windowOptions);\n\n        // Poll until we get a valid hash fragment\n        if (oauthParams.responseMode === 'fragment') {\n          var windowOrigin = getOrigin(sdk.idToken.authorize._getLocationHref());\n          var redirectUriOrigin = getOrigin(oauthParams.redirectUri);\n          if (windowOrigin !== redirectUriOrigin) {\n            return Q.reject(new AuthSdkError('Using fragment, the redirectUri origin (' + redirectUriOrigin +\n              ') must match the origin of this page (' + windowOrigin + ')'));\n          }\n          popupPromise = addFragmentListener(sdk, windowEl, options.timeout);\n        }\n\n        // Both postMessage and fragment require a poll to see if the popup closed\n        var popupDeferred = Q.defer();\n        /* eslint-disable-next-line no-case-declarations, no-inner-declarations */\n        function hasClosed(win) {\n          if (!win || win.closed) {\n            popupDeferred.reject(new AuthSdkError('Unable to parse OAuth flow response'));\n            return true;\n          }\n        }\n        var closePoller = setInterval(function() {\n          if (hasClosed(windowEl)) {\n            clearInterval(closePoller);\n          }\n        }, 500);\n\n        // Proxy the promise results into the deferred\n        popupPromise\n        .then(function(res) {\n          popupDeferred.resolve(res);\n        })\n        .fail(function(err) {\n          popupDeferred.reject(err);\n        });\n\n        return popupDeferred.promise\n          .then(function(res) {\n            return handleOAuthResponse(sdk, oauthParams, res, urls);\n          })\n          .fin(function() {\n            clearInterval(closePoller);\n            if (windowEl && !windowEl.closed) {\n              windowEl.close();\n            }\n          });\n\n      default:\n        return Q.reject(new AuthSdkError('The full page redirect flow is not supported'));\n    }\n  });\n}\n\nfunction getWithoutPrompt(sdk, oauthOptions, options) {\n  var oauthParams = util.clone(oauthOptions) || {};\n  util.extend(oauthParams, {\n    prompt: 'none',\n    responseMode: 'okta_post_message',\n    display: null\n  });\n  return getToken(sdk, oauthParams, options);\n}\n\nfunction getWithPopup(sdk, oauthOptions, options) {\n  var oauthParams = util.clone(oauthOptions) || {};\n  util.extend(oauthParams, {\n    display: 'popup',\n    responseMode: 'okta_post_message'\n  });\n  return getToken(sdk, oauthParams, options);\n}\n\nfunction prepareOauthParams(sdk, oauthOptions) {\n  // clone and prepare options\n  oauthOptions = util.clone(oauthOptions) || {};\n\n  // OKTA-242989: support for grantType will be removed in 3.0 \n  if (oauthOptions.grantType === 'authorization_code') {\n    oauthOptions.pkce = true;\n  }\n\n  // build params using defaults + options\n  var oauthParams = getDefaultOAuthParams(sdk);\n  util.extend(oauthParams, oauthOptions);\n\n  if (oauthParams.pkce !== true) {\n    return Q.resolve(oauthParams);\n  }\n\n  // PKCE flow\n  if (!sdk.features.isPKCESupported()) {\n    return Q.reject(new AuthSdkError('This browser doesn\\'t support PKCE'));\n  }\n\n  // set default code challenge method, if none provided\n  if (!oauthParams.codeChallengeMethod) {\n    oauthParams.codeChallengeMethod = PKCE.DEFAULT_CODE_CHALLENGE_METHOD;\n  }\n\n  // responseType is forced\n  oauthParams.responseType = 'code';\n\n  return oauthUtil.getWellKnown(sdk, null)\n    .then(function(res) {\n      var methods = res['code_challenge_methods_supported'] || [];\n      if (methods.indexOf(oauthParams.codeChallengeMethod) === -1) {\n        throw new AuthSdkError('Invalid code_challenge_method');\n      }\n    })\n    .then(function() {\n      // PKCE authorization_code flow\n      var codeVerifier = PKCE.generateVerifier(oauthParams.codeVerifier);\n\n      // We will need these values after redirect when we call /token\n      var meta = {\n        codeVerifier: codeVerifier,\n        redirectUri: oauthParams.redirectUri\n      };\n      PKCE.saveMeta(sdk, meta);\n\n      return PKCE.computeChallenge(codeVerifier);\n    })\n    .then(function(codeChallenge) {\n\n      // Clone/copy the params. Set codeChallenge\n      var clonedParams = util.clone(oauthParams) || {};\n      util.extend(clonedParams, oauthParams, {\n        codeChallenge: codeChallenge,\n      });\n      return clonedParams;\n    });\n}\n\nfunction getWithRedirect(sdk, oauthOptions, options) {\n  oauthOptions = util.clone(oauthOptions) || {};\n\n  return prepareOauthParams(sdk, oauthOptions)\n    .then(function(oauthParams) {\n\n      // Dynamically set the responseMode unless the user has provided one\n      // Server-side flow requires query. Client-side apps usually prefer fragment.\n      if (!oauthOptions.responseMode) {\n        if (oauthParams.responseType.includes('code') && !oauthParams.pkce) {\n          // server-side flows using authorization_code\n          oauthParams.responseMode = 'query';\n        } else {\n          // Client-side flow can use fragment or query. This can be configured on the SDK instance.\n          oauthParams.responseMode = sdk.options.responseMode || 'fragment';\n        }\n      }\n\n      var urls = oauthUtil.getOAuthUrls(sdk, oauthParams, options);\n      var requestUrl = urls.authorizeUrl + buildAuthorizeParams(oauthParams);\n\n      // Chrome >= 80 will block cookies with SameSite=None unless they are also Secure\n      // If the application is running on HTTPS, we can relax 3rd party cookie settings.\n      // This will allow embedding the app in an iframe (only if it is running on HTTPS protocol)\n      var isSecure = window.location.protocol === 'https:';\n      var cookieSettings = {\n        secure: isSecure,\n        sameSite: isSecure ? 'none' : 'lax'\n      };\n\n      // Set session cookie to store the oauthParams\n      cookies.set(constants.REDIRECT_OAUTH_PARAMS_COOKIE_NAME, JSON.stringify({\n        responseType: oauthParams.responseType,\n        state: oauthParams.state,\n        nonce: oauthParams.nonce,\n        scopes: oauthParams.scopes,\n        clientId: oauthParams.clientId,\n        urls: urls,\n        ignoreSignature: oauthParams.ignoreSignature\n      }), null, cookieSettings);\n\n      // Set nonce cookie for servers to validate nonce in id_token\n      cookies.set(constants.REDIRECT_NONCE_COOKIE_NAME, oauthParams.nonce, null, cookieSettings);\n\n      // Set state cookie for servers to validate state\n      cookies.set(constants.REDIRECT_STATE_COOKIE_NAME, oauthParams.state, null, cookieSettings);\n\n      sdk.token.getWithRedirect._setLocation(requestUrl);\n    });\n}\n\nfunction renewToken(sdk, token) {\n  if (!oauthUtil.isToken(token)) {\n    return Q.reject(new AuthSdkError('Renew must be passed a token with ' +\n      'an array of scopes and an accessToken or idToken'));\n  }\n\n  var responseType;\n  if (sdk.options.pkce) {\n    responseType = 'code';\n  } else if (token.accessToken) {\n    responseType = 'token';\n  } else {\n    responseType = 'id_token';\n  }\n\n  return sdk.token.getWithoutPrompt({\n    responseType: responseType,\n    scopes: token.scopes\n  }, {\n    authorizeUrl: token.authorizeUrl,\n    userinfoUrl: token.userinfoUrl,\n    issuer: token.issuer\n  });\n}\n\nfunction removeHash(sdk) {\n  var nativeHistory = sdk.token.parseFromUrl._getHistory();\n  var nativeDoc = sdk.token.parseFromUrl._getDocument();\n  var nativeLoc = sdk.token.parseFromUrl._getLocation();\n  if (nativeHistory && nativeHistory.replaceState) {\n    nativeHistory.replaceState(null, nativeDoc.title, nativeLoc.pathname + nativeLoc.search);\n  } else {\n    nativeLoc.hash = '';\n  }\n}\n\nfunction removeSearch(sdk) {\n  var nativeHistory = sdk.token.parseFromUrl._getHistory();\n  var nativeDoc = sdk.token.parseFromUrl._getDocument();\n  var nativeLoc = sdk.token.parseFromUrl._getLocation();\n  if (nativeHistory && nativeHistory.replaceState) {\n    nativeHistory.replaceState(null, nativeDoc.title, nativeLoc.pathname + nativeLoc.hash);\n  } else {\n    nativeLoc.search = '';\n  }\n}\n\nfunction parseFromUrl(sdk, options) {\n  options = options || {};\n  if (util.isString(options)) {\n    options = { url: options };\n  }\n\n  var url = options.url;\n  var responseMode = options.responseMode || sdk.options.responseMode || 'fragment';\n  var nativeLoc = sdk.token.parseFromUrl._getLocation();\n  var paramStr;\n\n  if (responseMode === 'query') {\n    paramStr = url ? url.substring(url.indexOf('?')) : nativeLoc.search;\n  } else {\n    paramStr = url ? url.substring(url.indexOf('#')) : nativeLoc.hash;\n  }\n\n  if (!paramStr) {\n    return Q.reject(new AuthSdkError('Unable to parse a token from the url'));\n  }\n\n  var oauthParamsCookie = cookies.get(constants.REDIRECT_OAUTH_PARAMS_COOKIE_NAME);\n  if (!oauthParamsCookie) {\n    return Q.reject(new AuthSdkError('Unable to retrieve OAuth redirect params cookie'));\n  }\n\n  try {\n    var oauthParams = JSON.parse(oauthParamsCookie);\n    var urls = oauthParams.urls;\n    delete oauthParams.urls;\n    cookies.delete(constants.REDIRECT_OAUTH_PARAMS_COOKIE_NAME);\n  } catch(e) {\n    return Q.reject(new AuthSdkError('Unable to parse the ' +\n    constants.REDIRECT_OAUTH_PARAMS_COOKIE_NAME + ' cookie: ' + e.message));\n  }\n\n  return Q.resolve(oauthUtil.urlParamsToObject(paramStr))\n    .then(function(res) {\n      if (!url) {\n        // Clean hash or search from the url\n        responseMode === 'query' ? removeSearch(sdk) : removeHash(sdk);\n      }\n      return handleOAuthResponse(sdk, oauthParams, res, urls);\n    });\n}\n\nfunction getUserInfo(sdk, accessTokenObject) {\n  if (!accessTokenObject ||\n      (!oauthUtil.isToken(accessTokenObject) && !accessTokenObject.accessToken && !accessTokenObject.userinfoUrl)) {\n    return Q.reject(new AuthSdkError('getUserInfo requires an access token object'));\n  }\n  return http.httpRequest(sdk, {\n    url: accessTokenObject.userinfoUrl,\n    method: 'GET',\n    accessToken: accessTokenObject.accessToken\n  })\n  .fail(function(err) {\n    if (err.xhr && (err.xhr.status === 401 || err.xhr.status === 403)) {\n      var authenticateHeader;\n      if (err.xhr.headers && util.isFunction(err.xhr.headers.get) && err.xhr.headers.get('WWW-Authenticate')) {\n        authenticateHeader = err.xhr.headers.get('WWW-Authenticate');\n      } else if (util.isFunction(err.xhr.getResponseHeader)) {\n        authenticateHeader = err.xhr.getResponseHeader('WWW-Authenticate');\n      }\n      if (authenticateHeader) {\n        var errorMatches = authenticateHeader.match(/error=\"(.*?)\"/) || [];\n        var errorDescriptionMatches = authenticateHeader.match(/error_description=\"(.*?)\"/) || [];\n        var error = errorMatches[1];\n        var errorDescription = errorDescriptionMatches[1];\n        if (error && errorDescription) {\n          err = new OAuthError(error, errorDescription);\n        }\n      }\n    }\n    throw err;\n  });\n}\n\nmodule.exports = {\n  revokeToken: revokeToken,\n  getToken: getToken,\n  getWithoutPrompt: getWithoutPrompt,\n  getWithPopup: getWithPopup,\n  getWithRedirect: getWithRedirect,\n  parseFromUrl: parseFromUrl,\n  decodeToken: decodeToken,\n  renewToken: renewToken,\n  getUserInfo: getUserInfo,\n  verifyToken: verifyToken,\n  handleOAuthResponse: handleOAuthResponse,\n  prepareOauthParams: prepareOauthParams\n};\n\n\n/***/ }),\n/* 26 */\n/***/ (function(module, exports, __webpack_require__) {\n\n/*!\n * Copyright (c) 2015-present, Okta, Inc. and/or its affiliates. All rights reserved.\n * The Okta software accompanied by this notice is provided pursuant to the Apache License, Version 2.0 (the \"License.\")\n *\n * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0.\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS, WITHOUT\n * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n *\n * See the License for the specific language governing permissions and limitations under the License.\n */\n\nvar util = __webpack_require__(0);\n\nfunction verifyToken(idToken, key) {\n  key = util.clone(key);\n\n  var format = 'jwk';\n  var algo = {\n    name: 'RSASSA-PKCS1-v1_5',\n    hash: { name: 'SHA-256' }\n  };\n  var extractable = true;\n  var usages = ['verify'];\n\n  // https://connect.microsoft.com/IE/feedback/details/2242108/webcryptoapi-importing-jwk-with-use-field-fails\n  // This is a metadata tag that specifies the intent of how the key should be used.\n  // It's not necessary to properly verify the jwt's signature.\n  delete key.use;\n\n  return crypto.subtle.importKey(\n    format,\n    key,\n    algo,\n    extractable,\n    usages\n  )\n  .then(function(cryptoKey) {\n    var jwt = idToken.split('.');\n    var payload = util.stringToBuffer(jwt[0] + '.' + jwt[1]);\n    var b64Signature = util.base64UrlDecode(jwt[2]);\n    var signature = util.stringToBuffer(b64Signature);\n\n    return crypto.subtle.verify(\n      algo,\n      cryptoKey,\n      signature,\n      payload\n    );\n  });\n}\n\nmodule.exports = {\n  verifyToken: verifyToken\n};\n\n\n/***/ }),\n/* 27 */\n/***/ (function(module, exports) {\n\n/*!\n * Copyright (c) 2015-present, Okta, Inc. and/or its affiliates. All rights reserved.\n * The Okta software accompanied by this notice is provided pursuant to the Apache License, Version 2.0 (the \"License.\")\n *\n * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0.\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS, WITHOUT\n * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n *\n * See the License for the specific language governing permissions and limitations under the License.\n */\n\nfunction OAuthError(errorCode, summary) {\n  this.name = 'OAuthError';\n  this.message = summary;\n\n  this.errorCode = errorCode;\n  this.errorSummary = summary;\n}\nOAuthError.prototype = new Error();\n\nmodule.exports = OAuthError;\n\n\n/***/ }),\n/* 28 */\n/***/ (function(module, exports, __webpack_require__) {\n\n/*!\n * Copyright (c) 2019-present, Okta, Inc. and/or its affiliates. All rights reserved.\n * The Okta software accompanied by this notice is provided pursuant to the Apache License, Version 2.0 (the \"License.\")\n *\n * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0.\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS, WITHOUT\n * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n *\n * See the License for the specific language governing permissions and limitations under the License.\n *\n */\n\n /* eslint-disable complexity, max-statements */\nvar AuthSdkError  = __webpack_require__(1);\nvar http          = __webpack_require__(3);\nvar util          = __webpack_require__(0);\n\n// Code verifier: Random URL-safe string with a minimum length of 43 characters.\n// Code challenge: Base64 URL-encoded SHA-256 hash of the code verifier.\nvar MIN_VERIFIER_LENGTH = 43;\nvar MAX_VERIFIER_LENGTH = 128;\nvar DEFAULT_CODE_CHALLENGE_METHOD = 'S256';\n\nfunction dec2hex (dec) {\n  return ('0' + dec.toString(16)).substr(-2);\n}\n\nfunction getRandomString(length) {\n  var a = new Uint8Array(Math.ceil(length / 2));\n  crypto.getRandomValues(a);\n  var str = Array.from(a, dec2hex).join('');\n  return str.slice(0, length);\n}\n\nfunction generateVerifier(prefix) {\n  var verifier = prefix || '';\n  if (verifier.length < MIN_VERIFIER_LENGTH) {\n    verifier = verifier + getRandomString(MIN_VERIFIER_LENGTH - verifier.length);\n  }\n  return encodeURIComponent(verifier).slice(0, MAX_VERIFIER_LENGTH);\n}\n\nfunction saveMeta(sdk, meta) {\n  var storage = sdk.options.storageUtil.getPKCEStorage();\n  storage.setStorage(meta);\n}\n\nfunction loadMeta(sdk) {\n  var storage = sdk.options.storageUtil.getPKCEStorage();\n  var obj = storage.getStorage();\n  return obj;\n}\n\nfunction clearMeta(sdk) {\n  var storage = sdk.options.storageUtil.getPKCEStorage();\n  storage.clearStorage();\n}\n\n/* global Uint8Array, TextEncoder */\nfunction computeChallenge(str) {  \n  var buffer = new TextEncoder().encode(str);\n  return crypto.subtle.digest('SHA-256', buffer).then(function(arrayBuffer) {\n    var hash = String.fromCharCode.apply(null, new Uint8Array(arrayBuffer));\n    var b64u = util.stringToBase64Url(hash); // url-safe base64 variant\n    return b64u;\n  });\n}\n\n\nfunction validateOptions(oauthOptions) {\n  // Quick validation\n  if (!oauthOptions.clientId) {\n    throw new AuthSdkError('A clientId must be specified in the OktaAuth constructor to get a token');\n  }\n\n  if (!oauthOptions.redirectUri) {\n    throw new AuthSdkError('The redirectUri passed to /authorize must also be passed to /token');\n  }\n\n  if (!oauthOptions.authorizationCode) {\n    throw new AuthSdkError('An authorization code (returned from /authorize) must be passed to /token');\n  }\n\n  if (!oauthOptions.codeVerifier) {\n    throw new AuthSdkError('The \"codeVerifier\" (generated and saved by your app) must be passed to /token');\n  }\n}\n\nfunction getPostData(options) {\n  // Convert options to OAuth params\n  var params = util.removeNils({\n    'client_id': options.clientId,\n    'redirect_uri': options.redirectUri,\n    'grant_type': 'authorization_code',\n    'code': options.authorizationCode,\n    'code_verifier': options.codeVerifier\n  });\n  // Encode as URL string\n  return util.toQueryParams(params).slice(1);\n}\n\n// exchange authorization code for an access token\nfunction getToken(sdk, oauthOptions, urls) {\n  validateOptions(oauthOptions);\n  var data = getPostData(oauthOptions);\n\n  return http.httpRequest(sdk, {\n    url: urls.tokenUrl,\n    method: 'POST',\n    args: data,\n    withCredentials: false,\n    headers: {\n      'Content-Type': 'application/x-www-form-urlencoded'\n    }\n  });\n}\n\nmodule.exports = {\n  DEFAULT_CODE_CHALLENGE_METHOD: DEFAULT_CODE_CHALLENGE_METHOD,\n  generateVerifier: generateVerifier,\n  clearMeta: clearMeta,\n  saveMeta: saveMeta,\n  loadMeta: loadMeta,\n  computeChallenge: computeChallenge,\n  getToken: getToken\n};\n\n\n/***/ }),\n/* 29 */\n/***/ (function(module, exports, __webpack_require__) {\n\n/*!\n * Copyright (c) 2015-present, Okta, Inc. and/or its affiliates. All rights reserved.\n * The Okta software accompanied by this notice is provided pursuant to the Apache License, Version 2.0 (the \"License.\")\n *\n * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0.\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS, WITHOUT\n * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n *\n * See the License for the specific language governing permissions and limitations under the License.\n *\n */\n\n/* eslint complexity:[0,8] max-statements:[0,21] */\nvar util = __webpack_require__(0);\nvar AuthSdkError = __webpack_require__(1);\nvar storageUtil = __webpack_require__(4);\nvar Q = __webpack_require__(5);\nvar constants = __webpack_require__(2);\nvar storageBuilder = __webpack_require__(6);\nvar SdkClock = __webpack_require__(30);\n\nvar DEFAULT_OPTIONS = {\n  autoRenew: true,\n  storage: 'localStorage',\n  expireEarlySeconds: 30\n};\n\nfunction getExpireTime(tokenMgmtRef, token) {\n  var expireTime = token.expiresAt - tokenMgmtRef.options.expireEarlySeconds;\n  return expireTime;\n}\n\nfunction hasExpired(tokenMgmtRef, token) {\n  var expireTime = getExpireTime(tokenMgmtRef, token);\n  return expireTime <= tokenMgmtRef.clock.now();\n}\n\nfunction emitExpired(tokenMgmtRef, key, token) {\n  tokenMgmtRef.emitter.emit('expired', key, token);\n}\n\nfunction emitError(tokenMgmtRef, error) {\n  tokenMgmtRef.emitter.emit('error', error);\n}\n\nfunction clearExpireEventTimeout(tokenMgmtRef, key) {\n  clearTimeout(tokenMgmtRef.expireTimeouts[key]);\n  delete tokenMgmtRef.expireTimeouts[key];\n\n  // Remove the renew promise (if it exists)\n  delete tokenMgmtRef.renewPromise[key];\n}\n\nfunction clearExpireEventTimeoutAll(tokenMgmtRef) {\n  var expireTimeouts = tokenMgmtRef.expireTimeouts;\n  for (var key in expireTimeouts) {\n    if (!expireTimeouts.hasOwnProperty(key)) {\n      continue;\n    }\n    clearExpireEventTimeout(tokenMgmtRef, key);\n  }\n}\n\nfunction setExpireEventTimeout(sdk, tokenMgmtRef, key, token) {\n  var expireTime = getExpireTime(tokenMgmtRef, token);\n  var expireEventWait = Math.max(expireTime - tokenMgmtRef.clock.now(), 0) * 1000;\n\n  // Clear any existing timeout\n  clearExpireEventTimeout(tokenMgmtRef, key);\n\n  var expireEventTimeout = setTimeout(function() {\n    emitExpired(tokenMgmtRef, key, token);\n  }, expireEventWait);\n\n  // Add a new timeout\n  tokenMgmtRef.expireTimeouts[key] = expireEventTimeout;\n}\n\nfunction setExpireEventTimeoutAll(sdk, tokenMgmtRef, storage) {\n  try {\n    var tokenStorage = storage.getStorage();\n  } catch(e) {\n    // Any errors thrown on instantiation will not be caught,\n    // because there are no listeners yet\n    emitError(tokenMgmtRef, e);\n    return;\n  }\n\n  for(var key in tokenStorage) {\n    if (!tokenStorage.hasOwnProperty(key)) {\n      continue;\n    }\n    var token = tokenStorage[key];\n    setExpireEventTimeout(sdk, tokenMgmtRef, key, token);\n  }\n}\n\nfunction add(sdk, tokenMgmtRef, storage, key, token) {\n  var tokenStorage = storage.getStorage();\n  if (!util.isObject(token) ||\n      !token.scopes ||\n      (!token.expiresAt && token.expiresAt !== 0) ||\n      (!token.idToken && !token.accessToken)) {\n    throw new AuthSdkError('Token must be an Object with scopes, expiresAt, and an idToken or accessToken properties');\n  }\n  tokenStorage[key] = token;\n  storage.setStorage(tokenStorage);\n  setExpireEventTimeout(sdk, tokenMgmtRef, key, token);\n}\n\nfunction get(storage, key) {\n  var tokenStorage = storage.getStorage();\n  return tokenStorage[key];\n}\n\nfunction getAsync(sdk, tokenMgmtRef, storage, key) {\n  return Q.Promise(function(resolve) {\n    var token = get(storage, key);\n    if (!token || !hasExpired(tokenMgmtRef, token)) {\n      return resolve(token);\n    }\n\n    var tokenPromise = tokenMgmtRef.options.autoRenew\n      ? renew(sdk, tokenMgmtRef, storage, key)\n      : remove(tokenMgmtRef, storage, key);\n\n    return resolve(tokenPromise);\n  });\n}\n\nfunction remove(tokenMgmtRef, storage, key) {\n  // Clear any listener for this token\n  clearExpireEventTimeout(tokenMgmtRef, key);\n\n  // Remove it from storage\n  var tokenStorage = storage.getStorage();\n  delete tokenStorage[key];\n  storage.setStorage(tokenStorage);\n}\n\nfunction renew(sdk, tokenMgmtRef, storage, key) {\n  // Multiple callers may receive the same promise. They will all resolve or reject from the same request.\n  var existingPromise = tokenMgmtRef.renewPromise[key];\n  if (existingPromise) {\n    return existingPromise;\n  }\n\n  try {\n    var token = get(storage, key);\n    if (!token) {\n      throw new AuthSdkError('The tokenManager has no token for the key: ' + key);\n    }\n  } catch (e) {\n    return Q.reject(e);\n  }\n\n  // Remove existing autoRenew timeout for this key\n  clearExpireEventTimeout(tokenMgmtRef, key);\n\n  // Store the renew promise state, to avoid renewing again\n  tokenMgmtRef.renewPromise[key] = sdk.token.renew(token)\n    .then(function(freshTokens) {\n      var freshToken = freshTokens;\n      // With PKCE flow we will receive multiple tokens. Find the one we are looking for\n      if (freshTokens instanceof Array) {\n        freshToken = freshTokens.find(function(freshToken) {\n          return (freshToken.idToken && token.idToken) || (freshToken.accessToken && token.accessToken);\n        });\n      }\n\n      var oldToken = get(storage, key);\n      if (!oldToken) {\n        // It is possible to enter a state where the tokens have been cleared\n        // after a renewal request was triggered. To ensure we do not store a\n        // renewed token, we verify the promise key doesn't exist and return.\n        return;\n      }\n      add(sdk, tokenMgmtRef, storage, key, freshToken);\n      tokenMgmtRef.emitter.emit('renewed', key, freshToken, oldToken);\n      return freshToken;\n    })\n    .catch(function(err) {\n      if (err.name === 'OAuthError' || err.name === 'AuthSdkError') {\n        remove(tokenMgmtRef, storage, key);\n        err.tokenKey = key;\n        err.accessToken = !!token.accessToken;\n        emitError(tokenMgmtRef, err);\n      }\n      throw err;\n    })\n    .finally(function() {\n      // Remove existing promise key\n      delete tokenMgmtRef.renewPromise[key];\n    });\n\n  return tokenMgmtRef.renewPromise[key];\n}\n\nfunction clear(tokenMgmtRef, storage) {\n  clearExpireEventTimeoutAll(tokenMgmtRef);\n  storage.clearStorage();\n}\n\nfunction TokenManager(sdk, options) {\n  options = util.extend({}, DEFAULT_OPTIONS, util.removeNils(options));\n\n  if (options.storage === 'localStorage' && !storageUtil.browserHasLocalStorage()) {\n    util.warn('This browser doesn\\'t support localStorage. Switching to sessionStorage.');\n    options.storage = 'sessionStorage';\n  }\n\n  if (options.storage === 'sessionStorage' && !storageUtil.browserHasSessionStorage()) {\n    util.warn('This browser doesn\\'t support sessionStorage. Switching to cookie-based storage.');\n    options.storage = 'cookie';\n  }\n\n  var storageProvider;\n  if (typeof options.storage === 'object') {\n    // A custom storage provider must implement getItem(key) and setItem(key, val)\n    storageProvider = options.storage;\n  } else {\n    switch(options.storage) {\n      case 'localStorage':\n        storageProvider = localStorage;\n        break;\n      case 'sessionStorage':\n        storageProvider = sessionStorage;\n        break;\n      case 'cookie':\n        storageProvider = storageUtil.getCookieStorage(options);\n        break;\n      case 'memory':\n        storageProvider = storageUtil.getInMemoryStorage();\n        break;\n      default:\n        throw new AuthSdkError('Unrecognized storage option');\n    }\n  }\n  var storageKey = options.storageKey || constants.TOKEN_STORAGE_NAME;\n  var storage = storageBuilder(storageProvider, storageKey);\n  var clock = SdkClock.create(sdk, options);\n  var tokenMgmtRef = {\n    clock: clock,\n    options: options,\n    emitter: sdk.emitter,\n    expireTimeouts: {},\n    renewPromise: {}\n  };\n\n  this.add = util.bind(add, this, sdk, tokenMgmtRef, storage);\n  this.get = util.bind(getAsync, this, sdk, tokenMgmtRef, storage);\n  this.remove = util.bind(remove, this, tokenMgmtRef, storage);\n  this.clear = util.bind(clear, this, tokenMgmtRef, storage);\n  this.renew = util.bind(renew, this, sdk, tokenMgmtRef, storage);\n  this.on = util.bind(tokenMgmtRef.emitter.on, tokenMgmtRef.emitter);\n  this.off = util.bind(tokenMgmtRef.emitter.off, tokenMgmtRef.emitter);\n\n  setExpireEventTimeoutAll(sdk, tokenMgmtRef, storage);\n}\n\nmodule.exports = TokenManager;\n\n\n/***/ }),\n/* 30 */\n/***/ (function(module, exports, __webpack_require__) {\n\nvar util = __webpack_require__(0);\n\nfunction SdkClock(localOffset) {\n  // Calculated local clock offset from server time (in milliseconds). Can be positive or negative.\n  this.localOffset = parseInt(localOffset || 0);\n}\n\nutil.extend(SdkClock.prototype, {\n  // Return the current time (in seconds)\n  now: function() {\n    var now = (Date.now() + this.localOffset) / 1000;\n    return now;\n  }\n});\n\n// factory method. Create an instance of a clock from current context.\nSdkClock.create = function(/* sdk, options */) {\n  // TODO: calculate localOffset\n  var localOffset = 0;\n  return new SdkClock(localOffset);\n};\n\nmodule.exports = SdkClock;\n\n\n/***/ })\n/******/ ]);\n});\n\n\n// WEBPACK FOOTER //\n// okta-auth-js.min.js","/*!\n * Copyright (c) 2015-present, Okta, Inc. and/or its affiliates. All rights reserved.\n * The Okta software accompanied by this notice is provided pursuant to the Apache License, Version 2.0 (the \"License.\")\n *\n * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0.\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS, WITHOUT\n * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n *\n * See the License for the specific language governing permissions and limitations under the License.\n */\n/* eslint-env es6 */\nvar util = module.exports;\n\n// converts a string to base64 (url/filename safe variant)\nutil.stringToBase64Url = function(str) {\n  var b64 = btoa(str);\n  return util.base64ToBase64Url(b64);\n};\n\n// converts a standard base64-encoded string to a \"url/filename safe\" variant\nutil.base64ToBase64Url = function(b64) {\n  return b64.replace(/\\+/g, '-').replace(/\\//g, '_').replace(/=+$/, '');\n};\n\n// converts a \"url/filename safe\" base64 string to a \"standard\" base64 string\nutil.base64UrlToBase64 = function(b64u) {\n  return b64u.replace(/-/g, '+').replace(/_/g, '/');\n};\n\nutil.base64UrlToString = function(b64u) {\n  var b64 = util.base64UrlToBase64(b64u);\n  switch (b64.length % 4) {\n    case 0:\n      break;\n    case 2:\n      b64 += '==';\n      break;\n    case 3:\n      b64 += '=';\n      break;\n    default:\n      throw 'Not a valid Base64Url';\n  }\n  var utf8 = atob(b64);\n  try {\n    return decodeURIComponent(escape(utf8));\n  } catch (e) {\n    return utf8;\n  }\n};\n\nutil.stringToBuffer = function(str) {\n  var buffer = new Uint8Array(str.length);\n  for (var i = 0; i < str.length; i++) {\n    buffer[i] = str.charCodeAt(i);\n  }\n  return buffer;\n};\n\nutil.base64UrlDecode = function(str) {\n  return atob(util.base64UrlToBase64(str));\n};\n\nutil.bind = function(fn, ctx) {\n  var additionalArgs = Array.prototype.slice.call(arguments, 2);\n  return function() {\n    var args = Array.prototype.slice.call(arguments);\n    args = additionalArgs.concat(args);\n    return fn.apply(ctx, args);\n  };\n};\n\nutil.isAbsoluteUrl = function(url) {\n  return /^(?:[a-z]+:)?\\/\\//i.test(url);\n};\n\nutil.isString = function(obj) {\n  return Object.prototype.toString.call(obj) === '[object String]';\n};\n\nutil.isObject = function(obj) {\n  return Object.prototype.toString.call(obj) === '[object Object]';\n};\n\nutil.isNumber = function(obj) {\n  return Object.prototype.toString.call(obj) === '[object Number]';\n};\n\nutil.isArray = function(obj) {\n  return Object.prototype.toString.call(obj) === '[object Array]';\n};\n\nutil.isoToUTCString = function(str) {\n  var parts = str.match(/\\d+/g),\n      isoTime = Date.UTC(parts[0], parts[1] - 1, parts[2], parts[3], parts[4], parts[5]),\n      isoDate = new Date(isoTime);\n\n  return isoDate.toUTCString();\n};\n\nutil.toQueryParams = function(obj) {\n  var str = [];\n  if (obj !== null) {\n    for (var key in obj) {\n      if (obj.hasOwnProperty(key) &&\n          obj[key] !== undefined &&\n          obj[key] !== null) {\n        str.push(key + '=' + encodeURIComponent(obj[key]));\n      }\n    }\n  }\n  if (str.length) {\n    return '?' + str.join('&');\n  } else {\n    return '';\n  }\n};\n\nutil.genRandomString = function(length) {\n  var randomCharset = 'abcdefghijklnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789';\n  var random = '';\n  for (var c = 0, cl = randomCharset.length; c < length; ++c) {\n    random += randomCharset[Math.floor(Math.random() * cl)];\n  }\n  return random;\n};\n\nutil.extend = function() {\n  // First object will be modified!\n  var obj1 = arguments[0];\n  // Properties from other objects will be copied over\n  var objArray = [].slice.call(arguments, 1);\n  objArray.forEach(function(obj) {\n    for (var prop in obj) {\n      // copy over all properties with defined values\n      if (obj.hasOwnProperty(prop) && obj[prop] !== undefined) {\n        obj1[prop] = obj[prop];\n      }\n    }\n  });\n  return obj1; // return the modified object\n};\n\nutil.removeNils = function(obj) {\n  var cleaned = {};\n  for (var prop in obj) {\n    if (obj.hasOwnProperty(prop)) {\n      var value = obj[prop];\n      if (value !== null && value !== undefined) {\n        cleaned[prop] = value;\n      }\n    }\n  }\n  return cleaned;\n};\n\nutil.clone = function(obj) {\n  if (obj) {\n    var str = JSON.stringify(obj);\n    if (str) {\n      return JSON.parse(str);\n    }\n  }\n  return obj;\n};\n\n// Analogous to _.omit\nutil.omit = function(obj) {\n  var props = Array.prototype.slice.call(arguments, 1);\n  var newobj = {};\n  for (var p in obj) {\n    if (obj.hasOwnProperty(p) && props.indexOf(p) == -1) {\n      newobj[p] = obj[p];\n    }\n  }\n  return util.clone(newobj);\n};\n\nutil.find = function(collection, searchParams) {\n  var c = collection.length;\n  while (c--) {\n    var item = collection[c];\n    var found = true;\n    for (var prop in searchParams) {\n      if (!searchParams.hasOwnProperty(prop)) {\n        continue;\n      }\n      if (item[prop] !== searchParams[prop]) {\n        found = false;\n        break;\n      }\n    }\n    if (found) {\n      return item;\n    }\n  }\n};\n\nutil.getLink = function(obj, linkName, altName) {\n  if (!obj || !obj._links) {\n    return;\n  }\n\n  var link = util.clone(obj._links[linkName]);\n\n  // If a link has a name and we have an altName, return if they match\n  if (link && link.name && altName) {\n    if (link.name === altName) {\n      return link;\n    }\n  } else {\n    return link;\n  }\n};\n\nutil.getNativeConsole = function() {\n  if (typeof window !== 'undefined') {\n    return window.console;\n  } else if (typeof console !== 'undefined') {\n    return console;\n  } else {\n    return undefined;\n  }\n};\n\nutil.getConsole = function() {\n  var nativeConsole = util.getNativeConsole();\n  if (nativeConsole && nativeConsole.log) {\n    return nativeConsole;\n  }\n  return {\n    log: function() {}\n  };\n};\n\nutil.warn = function(text) {\n  /* eslint-disable no-console */\n  util.getConsole().log('[okta-auth-sdk] WARN: ' + text);\n  /* eslint-enable */\n};\n\nutil.deprecate = function(text) {\n  /* eslint-disable no-console */\n  util.getConsole().log('[okta-auth-sdk] DEPRECATION: ' + text);\n  /* eslint-enable */\n};\n\nutil.deprecateWrap = function(text, fn) {\n  return function() {\n    util.deprecate(text);\n    return fn.apply(null, arguments);\n  };\n};\n\nutil.removeTrailingSlash = function(path) {\n  if (!path) {\n    return;\n  }\n  // Remove any whitespace before or after string\n  var trimmed = path.replace(/^\\s+|\\s+$/gm,'');\n  // Remove trailing slash(es)\n  trimmed = trimmed.replace(/\\/+$/, '');\n\n  return trimmed;\n};\n\nutil.isIE11OrLess = function() {\n  return !!document.documentMode && document.documentMode <= 11;\n};\n\nutil.isFunction = function(fn) {\n  return !!fn && {}.toString.call(fn) === '[object Function]';\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./lib/util.js\n// module id = 0\n// module chunks = 0","/*!\n * Copyright (c) 2015-present, Okta, Inc. and/or its affiliates. All rights reserved.\n * The Okta software accompanied by this notice is provided pursuant to the Apache License, Version 2.0 (the \"License.\")\n *\n * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0.\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS, WITHOUT\n * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n *\n * See the License for the specific language governing permissions and limitations under the License.\n */\n\nfunction AuthSdkError(msg, xhr) {\n  this.name = 'AuthSdkError';\n  this.message = msg;\n\n  this.errorCode = 'INTERNAL';\n  this.errorSummary = msg;\n  this.errorLink = 'INTERNAL';\n  this.errorId = 'INTERNAL';\n  this.errorCauses = [];\n  if (xhr) {\n    this.xhr = xhr;\n  }\n}\nAuthSdkError.prototype = new Error();\n\nmodule.exports = AuthSdkError;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./lib/errors/AuthSdkError.js\n// module id = 1\n// module chunks = 0","module.exports = {\n  'STATE_TOKEN_KEY_NAME': 'oktaStateToken',\n  'DEFAULT_POLLING_DELAY': 500,\n  'DEFAULT_MAX_CLOCK_SKEW': 300,\n  'DEFAULT_CACHE_DURATION': 86400,\n  'REDIRECT_OAUTH_PARAMS_COOKIE_NAME': 'okta-oauth-redirect-params',\n  'REDIRECT_STATE_COOKIE_NAME': 'okta-oauth-state',\n  'REDIRECT_NONCE_COOKIE_NAME': 'okta-oauth-nonce',\n  'TOKEN_STORAGE_NAME': 'okta-token-storage',\n  'CACHE_STORAGE_NAME': 'okta-cache-storage',\n  'PKCE_STORAGE_NAME': 'okta-pkce-storage'\n};\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./lib/constants.js\n// module id = 2\n// module chunks = 0","/*!\n * Copyright (c) 2015-present, Okta, Inc. and/or its affiliates. All rights reserved.\n * The Okta software accompanied by this notice is provided pursuant to the Apache License, Version 2.0 (the \"License.\")\n *\n * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0.\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS, WITHOUT\n * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n *\n * See the License for the specific language governing permissions and limitations under the License.\n *\n */\n\n/* eslint-disable complexity */\nvar util = require('./util');\nvar Q = require('q');\nvar AuthApiError = require('./errors/AuthApiError');\nvar constants = require('./constants');\n\nfunction httpRequest(sdk, options) {\n  options = options || {};\n  var url = options.url,\n      method = options.method,\n      args = options.args,\n      saveAuthnState = options.saveAuthnState,\n      accessToken = options.accessToken,\n      withCredentials = options.withCredentials !== false, // default value is true\n      storageUtil = sdk.options.storageUtil,\n      storage = storageUtil.storage,\n      httpCache = storageUtil.getHttpCache();\n\n  if (options.cacheResponse) {\n    var cacheContents = httpCache.getStorage();\n    var cachedResponse = cacheContents[url];\n    if (cachedResponse && Date.now()/1000 < cachedResponse.expiresAt) {\n      return Q.resolve(cachedResponse.response);\n    }\n  }\n\n  var headers = {\n    'Accept': 'application/json',\n    'Content-Type': 'application/json',\n    'X-Okta-User-Agent-Extended': sdk.userAgent\n  };\n  util.extend(headers, sdk.options.headers, options.headers);\n\n  if (accessToken && util.isString(accessToken)) {\n    headers['Authorization'] = 'Bearer ' + accessToken;\n  }\n\n  var ajaxOptions = {\n    headers: headers,\n    data: args || undefined,\n    withCredentials: withCredentials\n  };\n\n  var err, res;\n  return new Q(sdk.options.httpRequestClient(method, url, ajaxOptions))\n    .then(function(resp) {\n      res = resp.responseText;\n      if (res && util.isString(res)) {\n        res = JSON.parse(res);\n      }\n\n      if (saveAuthnState) {\n        if (!res.stateToken) {\n          storage.delete(constants.STATE_TOKEN_KEY_NAME);\n        }\n      }\n\n      if (res && res.stateToken && res.expiresAt) {\n        storage.set(constants.STATE_TOKEN_KEY_NAME, res.stateToken, res.expiresAt);\n      }\n\n      if (res && options.cacheResponse) {\n        httpCache.updateStorage(url, {\n          expiresAt: Math.floor(Date.now()/1000) + constants.DEFAULT_CACHE_DURATION,\n          response: res\n        });\n      }\n\n      return res;\n    })\n    .fail(function(resp) {\n      var serverErr = resp.responseText || {};\n      if (util.isString(serverErr)) {\n        try {\n          serverErr = JSON.parse(serverErr);\n        } catch (e) {\n          serverErr = {\n            errorSummary: 'Unknown error'\n          };\n        }\n      }\n\n      if (resp.status >= 500) {\n        serverErr.errorSummary = 'Unknown error';\n      }\n\n      if (sdk.options.transformErrorXHR) {\n        resp = sdk.options.transformErrorXHR(util.clone(resp));\n      }\n\n      err = new AuthApiError(serverErr, resp);\n\n      if (err.errorCode === 'E0000011') {\n        storage.delete(constants.STATE_TOKEN_KEY_NAME);\n      }\n\n      throw err;\n    });\n}\n\nfunction get(sdk, url, options) {\n  url = util.isAbsoluteUrl(url) ? url : sdk.options.url + url;\n  var getOptions = {\n    url: url,\n    method: 'GET'\n  };\n  util.extend(getOptions, options);\n  return httpRequest(sdk, getOptions);\n}\n\nfunction post(sdk, url, args, options) {\n  url = util.isAbsoluteUrl(url) ? url : sdk.options.url + url;\n  var postOptions = {\n    url: url,\n    method: 'POST',\n    args: args,\n    saveAuthnState: true\n  };\n  util.extend(postOptions, options);\n  return httpRequest(sdk, postOptions);\n}\n\nmodule.exports = {\n  get: get,\n  post: post,\n  httpRequest: httpRequest\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./lib/http.js\n// module id = 3\n// module chunks = 0","/*!\n * Copyright (c) 2015-present, Okta, Inc. and/or its affiliates. All rights reserved.\n * The Okta software accompanied by this notice is provided pursuant to the Apache License, Version 2.0 (the \"License.\")\n *\n * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0.\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS, WITHOUT\n * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n *\n * See the License for the specific language governing permissions and limitations under the License.\n *\n */\n\nvar Cookies = require('js-cookie');\nvar storageBuilder = require('../storageBuilder');\nvar constants = require('../constants');\n\n// Building this as an object allows us to mock the functions in our tests\nvar storageUtil = {};\n\n// IE11 bug that Microsoft doesn't plan to fix\n// https://connect.microsoft.com/IE/Feedback/Details/1496040\nstorageUtil.browserHasLocalStorage = function() {\n  try {\n    var storage = storageUtil.getLocalStorage();\n    return storageUtil.testStorage(storage);\n  } catch (e) {\n    return false;\n  }\n};\n\nstorageUtil.browserHasSessionStorage = function() {\n  try {\n    var storage = storageUtil.getSessionStorage();\n    return storageUtil.testStorage(storage);\n  } catch (e) {\n    return false;\n  }\n};\n\nstorageUtil.getPKCEStorage = function() {\n  if (storageUtil.browserHasLocalStorage()) {\n    return storageBuilder(storageUtil.getLocalStorage(), constants.PKCE_STORAGE_NAME);\n  } else if (storageUtil.browserHasSessionStorage()) {\n    return storageBuilder(storageUtil.getSessionStorage(), constants.PKCE_STORAGE_NAME);\n  } else {\n    return storageBuilder(storageUtil.getCookieStorage({\n      secure: window.location.protocol === 'https:'\n    }), constants.PKCE_STORAGE_NAME);\n  }\n};\n\nstorageUtil.getHttpCache = function() {\n  if (storageUtil.browserHasLocalStorage()) {\n    return storageBuilder(storageUtil.getLocalStorage(), constants.CACHE_STORAGE_NAME);\n  } else if (storageUtil.browserHasSessionStorage()) {\n    return storageBuilder(storageUtil.getSessionStorage(), constants.CACHE_STORAGE_NAME);\n  } else {\n    return storageBuilder(storageUtil.getCookieStorage({\n      secure: window.location.protocol === 'https:'\n    }), constants.CACHE_STORAGE_NAME);\n  }\n};\n\nstorageUtil.getLocalStorage = function() {\n  return localStorage;\n};\n\nstorageUtil.getSessionStorage = function() {\n  return sessionStorage;\n};\n\n// Provides webStorage-like interface for cookies\nstorageUtil.getCookieStorage = function(options) {\n  options = options || {};\n  var secure = options.secure || false; // currently opt-in\n  var sameSite = options.sameSite || (secure ? 'none' : 'lax');\n  return {\n    getItem: storageUtil.storage.get,\n    setItem: function(key, value) {\n      // Cookie shouldn't expire\n      storageUtil.storage.set(key, value, '2200-01-01T00:00:00.000Z', {\n        secure: secure, \n        sameSite: sameSite\n      });\n    }\n  };\n};\n\n// Provides an in-memory solution\nstorageUtil.getInMemoryStorage = function() {\n  var store = {};\n  return {\n    getItem: function(key) {\n      return store[key];\n    },\n    setItem: function(key, value) {\n      store[key] = value;\n    }\n  };\n};\n\nstorageUtil.testStorage = function(storage) {\n  var key = 'okta-test-storage';\n  try {\n    storage.setItem(key, key);\n    storage.removeItem(key);\n    return true;\n  } catch (e) {\n    return false;\n  }\n};\n\nstorageUtil.storage = {\n  set: function(name, value, expiresAt, options) {\n    options = options || {};\n    var cookieOptions = {\n      path: options.path || '/',\n      secure: options.secure,\n      sameSite: options.sameSite\n    };\n\n    // eslint-disable-next-line no-extra-boolean-cast\n    if (!!(Date.parse(expiresAt))) {\n      // Expires value can be converted to a Date object.\n      //\n      // If the 'expiresAt' value is not provided, or the value cannot be\n      // parsed as a Date object, the cookie will set as a session cookie.\n      cookieOptions.expires = new Date(expiresAt);\n    }\n\n    Cookies.set(name, value, cookieOptions);\n    return storageUtil.storage.get(name);\n  },\n\n  get: function(name) {\n    return Cookies.get(name);\n  },\n\n  delete: function(name) {\n    return Cookies.remove(name, { path: '/' });\n  }\n};\n\nmodule.exports = storageUtil;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./lib/browser/browserStorage.js\n// module id = 4\n// module chunks = 0","// vim:ts=4:sts=4:sw=4:\n/*!\n *\n * Copyright 2009-2012 Kris Kowal under the terms of the MIT\n * license found at http://github.com/kriskowal/q/raw/master/LICENSE\n *\n * With parts by Tyler Close\n * Copyright 2007-2009 Tyler Close under the terms of the MIT X license found\n * at http://www.opensource.org/licenses/mit-license.html\n * Forked at ref_send.js version: 2009-05-11\n *\n * With parts by Mark Miller\n * Copyright (C) 2011 Google Inc.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n *\n */\n\n(function (definition) {\n    \"use strict\";\n\n    // This file will function properly as a <script> tag, or a module\n    // using CommonJS and NodeJS or RequireJS module formats.  In\n    // Common/Node/RequireJS, the module exports the Q API and when\n    // executed as a simple <script>, it creates a Q global instead.\n\n    // Montage Require\n    if (typeof bootstrap === \"function\") {\n        bootstrap(\"promise\", definition);\n\n    // CommonJS\n    } else if (typeof exports === \"object\" && typeof module === \"object\") {\n        module.exports = definition();\n\n    // RequireJS\n    } else if (typeof define === \"function\" && define.amd) {\n        define(definition);\n\n    // SES (Secure EcmaScript)\n    } else if (typeof ses !== \"undefined\") {\n        if (!ses.ok()) {\n            return;\n        } else {\n            ses.makeQ = definition;\n        }\n\n    // <script>\n    } else if (typeof window !== \"undefined\" || typeof self !== \"undefined\") {\n        // Prefer window over self for add-on scripts. Use self for\n        // non-windowed contexts.\n        var global = typeof window !== \"undefined\" ? window : self;\n\n        // Get the `window` object, save the previous Q global\n        // and initialize Q as a global.\n        var previousQ = global.Q;\n        global.Q = definition();\n\n        // Add a noConflict function so Q can be removed from the\n        // global namespace.\n        global.Q.noConflict = function () {\n            global.Q = previousQ;\n            return this;\n        };\n\n    } else {\n        throw new Error(\"This environment was not anticipated by Q. Please file a bug.\");\n    }\n\n})(function () {\n\"use strict\";\n\nvar hasStacks = false;\ntry {\n    throw new Error();\n} catch (e) {\n    hasStacks = !!e.stack;\n}\n\n// All code after this point will be filtered from stack traces reported\n// by Q.\nvar qStartingLine = captureLine();\nvar qFileName;\n\n// shims\n\n// used for fallback in \"allResolved\"\nvar noop = function () {};\n\n// Use the fastest possible means to execute a task in a future turn\n// of the event loop.\nvar nextTick =(function () {\n    // linked list of tasks (single, with head node)\n    var head = {task: void 0, next: null};\n    var tail = head;\n    var flushing = false;\n    var requestTick = void 0;\n    var isNodeJS = false;\n    // queue for late tasks, used by unhandled rejection tracking\n    var laterQueue = [];\n\n    function flush() {\n        /* jshint loopfunc: true */\n        var task, domain;\n\n        while (head.next) {\n            head = head.next;\n            task = head.task;\n            head.task = void 0;\n            domain = head.domain;\n\n            if (domain) {\n                head.domain = void 0;\n                domain.enter();\n            }\n            runSingle(task, domain);\n\n        }\n        while (laterQueue.length) {\n            task = laterQueue.pop();\n            runSingle(task);\n        }\n        flushing = false;\n    }\n    // runs a single function in the async queue\n    function runSingle(task, domain) {\n        try {\n            task();\n\n        } catch (e) {\n            if (isNodeJS) {\n                // In node, uncaught exceptions are considered fatal errors.\n                // Re-throw them synchronously to interrupt flushing!\n\n                // Ensure continuation if the uncaught exception is suppressed\n                // listening \"uncaughtException\" events (as domains does).\n                // Continue in next event to avoid tick recursion.\n                if (domain) {\n                    domain.exit();\n                }\n                setTimeout(flush, 0);\n                if (domain) {\n                    domain.enter();\n                }\n\n                throw e;\n\n            } else {\n                // In browsers, uncaught exceptions are not fatal.\n                // Re-throw them asynchronously to avoid slow-downs.\n                setTimeout(function () {\n                    throw e;\n                }, 0);\n            }\n        }\n\n        if (domain) {\n            domain.exit();\n        }\n    }\n\n    nextTick = function (task) {\n        tail = tail.next = {\n            task: task,\n            domain: isNodeJS && process.domain,\n            next: null\n        };\n\n        if (!flushing) {\n            flushing = true;\n            requestTick();\n        }\n    };\n\n    if (typeof process === \"object\" &&\n        process.toString() === \"[object process]\" && process.nextTick) {\n        // Ensure Q is in a real Node environment, with a `process.nextTick`.\n        // To see through fake Node environments:\n        // * Mocha test runner - exposes a `process` global without a `nextTick`\n        // * Browserify - exposes a `process.nexTick` function that uses\n        //   `setTimeout`. In this case `setImmediate` is preferred because\n        //    it is faster. Browserify's `process.toString()` yields\n        //   \"[object Object]\", while in a real Node environment\n        //   `process.nextTick()` yields \"[object process]\".\n        isNodeJS = true;\n\n        requestTick = function () {\n            process.nextTick(flush);\n        };\n\n    } else if (typeof setImmediate === \"function\") {\n        // In IE10, Node.js 0.9+, or https://github.com/NobleJS/setImmediate\n        if (typeof window !== \"undefined\") {\n            requestTick = setImmediate.bind(window, flush);\n        } else {\n            requestTick = function () {\n                setImmediate(flush);\n            };\n        }\n\n    } else if (typeof MessageChannel !== \"undefined\") {\n        // modern browsers\n        // http://www.nonblocking.io/2011/06/windownexttick.html\n        var channel = new MessageChannel();\n        // At least Safari Version 6.0.5 (8536.30.1) intermittently cannot create\n        // working message ports the first time a page loads.\n        channel.port1.onmessage = function () {\n            requestTick = requestPortTick;\n            channel.port1.onmessage = flush;\n            flush();\n        };\n        var requestPortTick = function () {\n            // Opera requires us to provide a message payload, regardless of\n            // whether we use it.\n            channel.port2.postMessage(0);\n        };\n        requestTick = function () {\n            setTimeout(flush, 0);\n            requestPortTick();\n        };\n\n    } else {\n        // old browsers\n        requestTick = function () {\n            setTimeout(flush, 0);\n        };\n    }\n    // runs a task after all other tasks have been run\n    // this is useful for unhandled rejection tracking that needs to happen\n    // after all `then`d tasks have been run.\n    nextTick.runAfter = function (task) {\n        laterQueue.push(task);\n        if (!flushing) {\n            flushing = true;\n            requestTick();\n        }\n    };\n    return nextTick;\n})();\n\n// Attempt to make generics safe in the face of downstream\n// modifications.\n// There is no situation where this is necessary.\n// If you need a security guarantee, these primordials need to be\n// deeply frozen anyway, and if you don’t need a security guarantee,\n// this is just plain paranoid.\n// However, this **might** have the nice side-effect of reducing the size of\n// the minified code by reducing x.call() to merely x()\n// See Mark Miller’s explanation of what this does.\n// http://wiki.ecmascript.org/doku.php?id=conventions:safe_meta_programming\nvar call = Function.call;\nfunction uncurryThis(f) {\n    return function () {\n        return call.apply(f, arguments);\n    };\n}\n// This is equivalent, but slower:\n// uncurryThis = Function_bind.bind(Function_bind.call);\n// http://jsperf.com/uncurrythis\n\nvar array_slice = uncurryThis(Array.prototype.slice);\n\nvar array_reduce = uncurryThis(\n    Array.prototype.reduce || function (callback, basis) {\n        var index = 0,\n            length = this.length;\n        // concerning the initial value, if one is not provided\n        if (arguments.length === 1) {\n            // seek to the first value in the array, accounting\n            // for the possibility that is is a sparse array\n            do {\n                if (index in this) {\n                    basis = this[index++];\n                    break;\n                }\n                if (++index >= length) {\n                    throw new TypeError();\n                }\n            } while (1);\n        }\n        // reduce\n        for (; index < length; index++) {\n            // account for the possibility that the array is sparse\n            if (index in this) {\n                basis = callback(basis, this[index], index);\n            }\n        }\n        return basis;\n    }\n);\n\nvar array_indexOf = uncurryThis(\n    Array.prototype.indexOf || function (value) {\n        // not a very good shim, but good enough for our one use of it\n        for (var i = 0; i < this.length; i++) {\n            if (this[i] === value) {\n                return i;\n            }\n        }\n        return -1;\n    }\n);\n\nvar array_map = uncurryThis(\n    Array.prototype.map || function (callback, thisp) {\n        var self = this;\n        var collect = [];\n        array_reduce(self, function (undefined, value, index) {\n            collect.push(callback.call(thisp, value, index, self));\n        }, void 0);\n        return collect;\n    }\n);\n\nvar object_create = Object.create || function (prototype) {\n    function Type() { }\n    Type.prototype = prototype;\n    return new Type();\n};\n\nvar object_hasOwnProperty = uncurryThis(Object.prototype.hasOwnProperty);\n\nvar object_keys = Object.keys || function (object) {\n    var keys = [];\n    for (var key in object) {\n        if (object_hasOwnProperty(object, key)) {\n            keys.push(key);\n        }\n    }\n    return keys;\n};\n\nvar object_toString = uncurryThis(Object.prototype.toString);\n\nfunction isObject(value) {\n    return value === Object(value);\n}\n\n// generator related shims\n\n// FIXME: Remove this function once ES6 generators are in SpiderMonkey.\nfunction isStopIteration(exception) {\n    return (\n        object_toString(exception) === \"[object StopIteration]\" ||\n        exception instanceof QReturnValue\n    );\n}\n\n// FIXME: Remove this helper and Q.return once ES6 generators are in\n// SpiderMonkey.\nvar QReturnValue;\nif (typeof ReturnValue !== \"undefined\") {\n    QReturnValue = ReturnValue;\n} else {\n    QReturnValue = function (value) {\n        this.value = value;\n    };\n}\n\n// long stack traces\n\nvar STACK_JUMP_SEPARATOR = \"From previous event:\";\n\nfunction makeStackTraceLong(error, promise) {\n    // If possible, transform the error stack trace by removing Node and Q\n    // cruft, then concatenating with the stack trace of `promise`. See #57.\n    if (hasStacks &&\n        promise.stack &&\n        typeof error === \"object\" &&\n        error !== null &&\n        error.stack &&\n        error.stack.indexOf(STACK_JUMP_SEPARATOR) === -1\n    ) {\n        var stacks = [];\n        for (var p = promise; !!p; p = p.source) {\n            if (p.stack) {\n                stacks.unshift(p.stack);\n            }\n        }\n        stacks.unshift(error.stack);\n\n        var concatedStacks = stacks.join(\"\\n\" + STACK_JUMP_SEPARATOR + \"\\n\");\n        error.stack = filterStackString(concatedStacks);\n    }\n}\n\nfunction filterStackString(stackString) {\n    var lines = stackString.split(\"\\n\");\n    var desiredLines = [];\n    for (var i = 0; i < lines.length; ++i) {\n        var line = lines[i];\n\n        if (!isInternalFrame(line) && !isNodeFrame(line) && line) {\n            desiredLines.push(line);\n        }\n    }\n    return desiredLines.join(\"\\n\");\n}\n\nfunction isNodeFrame(stackLine) {\n    return stackLine.indexOf(\"(module.js:\") !== -1 ||\n           stackLine.indexOf(\"(node.js:\") !== -1;\n}\n\nfunction getFileNameAndLineNumber(stackLine) {\n    // Named functions: \"at functionName (filename:lineNumber:columnNumber)\"\n    // In IE10 function name can have spaces (\"Anonymous function\") O_o\n    var attempt1 = /at .+ \\((.+):(\\d+):(?:\\d+)\\)$/.exec(stackLine);\n    if (attempt1) {\n        return [attempt1[1], Number(attempt1[2])];\n    }\n\n    // Anonymous functions: \"at filename:lineNumber:columnNumber\"\n    var attempt2 = /at ([^ ]+):(\\d+):(?:\\d+)$/.exec(stackLine);\n    if (attempt2) {\n        return [attempt2[1], Number(attempt2[2])];\n    }\n\n    // Firefox style: \"function@filename:lineNumber or @filename:lineNumber\"\n    var attempt3 = /.*@(.+):(\\d+)$/.exec(stackLine);\n    if (attempt3) {\n        return [attempt3[1], Number(attempt3[2])];\n    }\n}\n\nfunction isInternalFrame(stackLine) {\n    var fileNameAndLineNumber = getFileNameAndLineNumber(stackLine);\n\n    if (!fileNameAndLineNumber) {\n        return false;\n    }\n\n    var fileName = fileNameAndLineNumber[0];\n    var lineNumber = fileNameAndLineNumber[1];\n\n    return fileName === qFileName &&\n        lineNumber >= qStartingLine &&\n        lineNumber <= qEndingLine;\n}\n\n// discover own file name and line number range for filtering stack\n// traces\nfunction captureLine() {\n    if (!hasStacks) {\n        return;\n    }\n\n    try {\n        throw new Error();\n    } catch (e) {\n        var lines = e.stack.split(\"\\n\");\n        var firstLine = lines[0].indexOf(\"@\") > 0 ? lines[1] : lines[2];\n        var fileNameAndLineNumber = getFileNameAndLineNumber(firstLine);\n        if (!fileNameAndLineNumber) {\n            return;\n        }\n\n        qFileName = fileNameAndLineNumber[0];\n        return fileNameAndLineNumber[1];\n    }\n}\n\nfunction deprecate(callback, name, alternative) {\n    return function () {\n        if (typeof console !== \"undefined\" &&\n            typeof console.warn === \"function\") {\n            console.warn(name + \" is deprecated, use \" + alternative +\n                         \" instead.\", new Error(\"\").stack);\n        }\n        return callback.apply(callback, arguments);\n    };\n}\n\n// end of shims\n// beginning of real work\n\n/**\n * Constructs a promise for an immediate reference, passes promises through, or\n * coerces promises from different systems.\n * @param value immediate reference or promise\n */\nfunction Q(value) {\n    // If the object is already a Promise, return it directly.  This enables\n    // the resolve function to both be used to created references from objects,\n    // but to tolerably coerce non-promises to promises.\n    if (value instanceof Promise) {\n        return value;\n    }\n\n    // assimilate thenables\n    if (isPromiseAlike(value)) {\n        return coerce(value);\n    } else {\n        return fulfill(value);\n    }\n}\nQ.resolve = Q;\n\n/**\n * Performs a task in a future turn of the event loop.\n * @param {Function} task\n */\nQ.nextTick = nextTick;\n\n/**\n * Controls whether or not long stack traces will be on\n */\nQ.longStackSupport = false;\n\n// enable long stacks if Q_DEBUG is set\nif (typeof process === \"object\" && process && process.env && process.env.Q_DEBUG) {\n    Q.longStackSupport = true;\n}\n\n/**\n * Constructs a {promise, resolve, reject} object.\n *\n * `resolve` is a callback to invoke with a more resolved value for the\n * promise. To fulfill the promise, invoke `resolve` with any value that is\n * not a thenable. To reject the promise, invoke `resolve` with a rejected\n * thenable, or invoke `reject` with the reason directly. To resolve the\n * promise to another thenable, thus putting it in the same state, invoke\n * `resolve` with that other thenable.\n */\nQ.defer = defer;\nfunction defer() {\n    // if \"messages\" is an \"Array\", that indicates that the promise has not yet\n    // been resolved.  If it is \"undefined\", it has been resolved.  Each\n    // element of the messages array is itself an array of complete arguments to\n    // forward to the resolved promise.  We coerce the resolution value to a\n    // promise using the `resolve` function because it handles both fully\n    // non-thenable values and other thenables gracefully.\n    var messages = [], progressListeners = [], resolvedPromise;\n\n    var deferred = object_create(defer.prototype);\n    var promise = object_create(Promise.prototype);\n\n    promise.promiseDispatch = function (resolve, op, operands) {\n        var args = array_slice(arguments);\n        if (messages) {\n            messages.push(args);\n            if (op === \"when\" && operands[1]) { // progress operand\n                progressListeners.push(operands[1]);\n            }\n        } else {\n            Q.nextTick(function () {\n                resolvedPromise.promiseDispatch.apply(resolvedPromise, args);\n            });\n        }\n    };\n\n    // XXX deprecated\n    promise.valueOf = function () {\n        if (messages) {\n            return promise;\n        }\n        var nearerValue = nearer(resolvedPromise);\n        if (isPromise(nearerValue)) {\n            resolvedPromise = nearerValue; // shorten chain\n        }\n        return nearerValue;\n    };\n\n    promise.inspect = function () {\n        if (!resolvedPromise) {\n            return { state: \"pending\" };\n        }\n        return resolvedPromise.inspect();\n    };\n\n    if (Q.longStackSupport && hasStacks) {\n        try {\n            throw new Error();\n        } catch (e) {\n            // NOTE: don't try to use `Error.captureStackTrace` or transfer the\n            // accessor around; that causes memory leaks as per GH-111. Just\n            // reify the stack trace as a string ASAP.\n            //\n            // At the same time, cut off the first line; it's always just\n            // \"[object Promise]\\n\", as per the `toString`.\n            promise.stack = e.stack.substring(e.stack.indexOf(\"\\n\") + 1);\n        }\n    }\n\n    // NOTE: we do the checks for `resolvedPromise` in each method, instead of\n    // consolidating them into `become`, since otherwise we'd create new\n    // promises with the lines `become(whatever(value))`. See e.g. GH-252.\n\n    function become(newPromise) {\n        resolvedPromise = newPromise;\n        promise.source = newPromise;\n\n        array_reduce(messages, function (undefined, message) {\n            Q.nextTick(function () {\n                newPromise.promiseDispatch.apply(newPromise, message);\n            });\n        }, void 0);\n\n        messages = void 0;\n        progressListeners = void 0;\n    }\n\n    deferred.promise = promise;\n    deferred.resolve = function (value) {\n        if (resolvedPromise) {\n            return;\n        }\n\n        become(Q(value));\n    };\n\n    deferred.fulfill = function (value) {\n        if (resolvedPromise) {\n            return;\n        }\n\n        become(fulfill(value));\n    };\n    deferred.reject = function (reason) {\n        if (resolvedPromise) {\n            return;\n        }\n\n        become(reject(reason));\n    };\n    deferred.notify = function (progress) {\n        if (resolvedPromise) {\n            return;\n        }\n\n        array_reduce(progressListeners, function (undefined, progressListener) {\n            Q.nextTick(function () {\n                progressListener(progress);\n            });\n        }, void 0);\n    };\n\n    return deferred;\n}\n\n/**\n * Creates a Node-style callback that will resolve or reject the deferred\n * promise.\n * @returns a nodeback\n */\ndefer.prototype.makeNodeResolver = function () {\n    var self = this;\n    return function (error, value) {\n        if (error) {\n            self.reject(error);\n        } else if (arguments.length > 2) {\n            self.resolve(array_slice(arguments, 1));\n        } else {\n            self.resolve(value);\n        }\n    };\n};\n\n/**\n * @param resolver {Function} a function that returns nothing and accepts\n * the resolve, reject, and notify functions for a deferred.\n * @returns a promise that may be resolved with the given resolve and reject\n * functions, or rejected by a thrown exception in resolver\n */\nQ.Promise = promise; // ES6\nQ.promise = promise;\nfunction promise(resolver) {\n    if (typeof resolver !== \"function\") {\n        throw new TypeError(\"resolver must be a function.\");\n    }\n    var deferred = defer();\n    try {\n        resolver(deferred.resolve, deferred.reject, deferred.notify);\n    } catch (reason) {\n        deferred.reject(reason);\n    }\n    return deferred.promise;\n}\n\npromise.race = race; // ES6\npromise.all = all; // ES6\npromise.reject = reject; // ES6\npromise.resolve = Q; // ES6\n\n// XXX experimental.  This method is a way to denote that a local value is\n// serializable and should be immediately dispatched to a remote upon request,\n// instead of passing a reference.\nQ.passByCopy = function (object) {\n    //freeze(object);\n    //passByCopies.set(object, true);\n    return object;\n};\n\nPromise.prototype.passByCopy = function () {\n    //freeze(object);\n    //passByCopies.set(object, true);\n    return this;\n};\n\n/**\n * If two promises eventually fulfill to the same value, promises that value,\n * but otherwise rejects.\n * @param x {Any*}\n * @param y {Any*}\n * @returns {Any*} a promise for x and y if they are the same, but a rejection\n * otherwise.\n *\n */\nQ.join = function (x, y) {\n    return Q(x).join(y);\n};\n\nPromise.prototype.join = function (that) {\n    return Q([this, that]).spread(function (x, y) {\n        if (x === y) {\n            // TODO: \"===\" should be Object.is or equiv\n            return x;\n        } else {\n            throw new Error(\"Can't join: not the same: \" + x + \" \" + y);\n        }\n    });\n};\n\n/**\n * Returns a promise for the first of an array of promises to become settled.\n * @param answers {Array[Any*]} promises to race\n * @returns {Any*} the first promise to be settled\n */\nQ.race = race;\nfunction race(answerPs) {\n    return promise(function (resolve, reject) {\n        // Switch to this once we can assume at least ES5\n        // answerPs.forEach(function (answerP) {\n        //     Q(answerP).then(resolve, reject);\n        // });\n        // Use this in the meantime\n        for (var i = 0, len = answerPs.length; i < len; i++) {\n            Q(answerPs[i]).then(resolve, reject);\n        }\n    });\n}\n\nPromise.prototype.race = function () {\n    return this.then(Q.race);\n};\n\n/**\n * Constructs a Promise with a promise descriptor object and optional fallback\n * function.  The descriptor contains methods like when(rejected), get(name),\n * set(name, value), post(name, args), and delete(name), which all\n * return either a value, a promise for a value, or a rejection.  The fallback\n * accepts the operation name, a resolver, and any further arguments that would\n * have been forwarded to the appropriate method above had a method been\n * provided with the proper name.  The API makes no guarantees about the nature\n * of the returned object, apart from that it is usable whereever promises are\n * bought and sold.\n */\nQ.makePromise = Promise;\nfunction Promise(descriptor, fallback, inspect) {\n    if (fallback === void 0) {\n        fallback = function (op) {\n            return reject(new Error(\n                \"Promise does not support operation: \" + op\n            ));\n        };\n    }\n    if (inspect === void 0) {\n        inspect = function () {\n            return {state: \"unknown\"};\n        };\n    }\n\n    var promise = object_create(Promise.prototype);\n\n    promise.promiseDispatch = function (resolve, op, args) {\n        var result;\n        try {\n            if (descriptor[op]) {\n                result = descriptor[op].apply(promise, args);\n            } else {\n                result = fallback.call(promise, op, args);\n            }\n        } catch (exception) {\n            result = reject(exception);\n        }\n        if (resolve) {\n            resolve(result);\n        }\n    };\n\n    promise.inspect = inspect;\n\n    // XXX deprecated `valueOf` and `exception` support\n    if (inspect) {\n        var inspected = inspect();\n        if (inspected.state === \"rejected\") {\n            promise.exception = inspected.reason;\n        }\n\n        promise.valueOf = function () {\n            var inspected = inspect();\n            if (inspected.state === \"pending\" ||\n                inspected.state === \"rejected\") {\n                return promise;\n            }\n            return inspected.value;\n        };\n    }\n\n    return promise;\n}\n\nPromise.prototype.toString = function () {\n    return \"[object Promise]\";\n};\n\nPromise.prototype.then = function (fulfilled, rejected, progressed) {\n    var self = this;\n    var deferred = defer();\n    var done = false;   // ensure the untrusted promise makes at most a\n                        // single call to one of the callbacks\n\n    function _fulfilled(value) {\n        try {\n            return typeof fulfilled === \"function\" ? fulfilled(value) : value;\n        } catch (exception) {\n            return reject(exception);\n        }\n    }\n\n    function _rejected(exception) {\n        if (typeof rejected === \"function\") {\n            makeStackTraceLong(exception, self);\n            try {\n                return rejected(exception);\n            } catch (newException) {\n                return reject(newException);\n            }\n        }\n        return reject(exception);\n    }\n\n    function _progressed(value) {\n        return typeof progressed === \"function\" ? progressed(value) : value;\n    }\n\n    Q.nextTick(function () {\n        self.promiseDispatch(function (value) {\n            if (done) {\n                return;\n            }\n            done = true;\n\n            deferred.resolve(_fulfilled(value));\n        }, \"when\", [function (exception) {\n            if (done) {\n                return;\n            }\n            done = true;\n\n            deferred.resolve(_rejected(exception));\n        }]);\n    });\n\n    // Progress propagator need to be attached in the current tick.\n    self.promiseDispatch(void 0, \"when\", [void 0, function (value) {\n        var newValue;\n        var threw = false;\n        try {\n            newValue = _progressed(value);\n        } catch (e) {\n            threw = true;\n            if (Q.onerror) {\n                Q.onerror(e);\n            } else {\n                throw e;\n            }\n        }\n\n        if (!threw) {\n            deferred.notify(newValue);\n        }\n    }]);\n\n    return deferred.promise;\n};\n\nQ.tap = function (promise, callback) {\n    return Q(promise).tap(callback);\n};\n\n/**\n * Works almost like \"finally\", but not called for rejections.\n * Original resolution value is passed through callback unaffected.\n * Callback may return a promise that will be awaited for.\n * @param {Function} callback\n * @returns {Q.Promise}\n * @example\n * doSomething()\n *   .then(...)\n *   .tap(console.log)\n *   .then(...);\n */\nPromise.prototype.tap = function (callback) {\n    callback = Q(callback);\n\n    return this.then(function (value) {\n        return callback.fcall(value).thenResolve(value);\n    });\n};\n\n/**\n * Registers an observer on a promise.\n *\n * Guarantees:\n *\n * 1. that fulfilled and rejected will be called only once.\n * 2. that either the fulfilled callback or the rejected callback will be\n *    called, but not both.\n * 3. that fulfilled and rejected will not be called in this turn.\n *\n * @param value      promise or immediate reference to observe\n * @param fulfilled  function to be called with the fulfilled value\n * @param rejected   function to be called with the rejection exception\n * @param progressed function to be called on any progress notifications\n * @return promise for the return value from the invoked callback\n */\nQ.when = when;\nfunction when(value, fulfilled, rejected, progressed) {\n    return Q(value).then(fulfilled, rejected, progressed);\n}\n\nPromise.prototype.thenResolve = function (value) {\n    return this.then(function () { return value; });\n};\n\nQ.thenResolve = function (promise, value) {\n    return Q(promise).thenResolve(value);\n};\n\nPromise.prototype.thenReject = function (reason) {\n    return this.then(function () { throw reason; });\n};\n\nQ.thenReject = function (promise, reason) {\n    return Q(promise).thenReject(reason);\n};\n\n/**\n * If an object is not a promise, it is as \"near\" as possible.\n * If a promise is rejected, it is as \"near\" as possible too.\n * If it’s a fulfilled promise, the fulfillment value is nearer.\n * If it’s a deferred promise and the deferred has been resolved, the\n * resolution is \"nearer\".\n * @param object\n * @returns most resolved (nearest) form of the object\n */\n\n// XXX should we re-do this?\nQ.nearer = nearer;\nfunction nearer(value) {\n    if (isPromise(value)) {\n        var inspected = value.inspect();\n        if (inspected.state === \"fulfilled\") {\n            return inspected.value;\n        }\n    }\n    return value;\n}\n\n/**\n * @returns whether the given object is a promise.\n * Otherwise it is a fulfilled value.\n */\nQ.isPromise = isPromise;\nfunction isPromise(object) {\n    return object instanceof Promise;\n}\n\nQ.isPromiseAlike = isPromiseAlike;\nfunction isPromiseAlike(object) {\n    return isObject(object) && typeof object.then === \"function\";\n}\n\n/**\n * @returns whether the given object is a pending promise, meaning not\n * fulfilled or rejected.\n */\nQ.isPending = isPending;\nfunction isPending(object) {\n    return isPromise(object) && object.inspect().state === \"pending\";\n}\n\nPromise.prototype.isPending = function () {\n    return this.inspect().state === \"pending\";\n};\n\n/**\n * @returns whether the given object is a value or fulfilled\n * promise.\n */\nQ.isFulfilled = isFulfilled;\nfunction isFulfilled(object) {\n    return !isPromise(object) || object.inspect().state === \"fulfilled\";\n}\n\nPromise.prototype.isFulfilled = function () {\n    return this.inspect().state === \"fulfilled\";\n};\n\n/**\n * @returns whether the given object is a rejected promise.\n */\nQ.isRejected = isRejected;\nfunction isRejected(object) {\n    return isPromise(object) && object.inspect().state === \"rejected\";\n}\n\nPromise.prototype.isRejected = function () {\n    return this.inspect().state === \"rejected\";\n};\n\n//// BEGIN UNHANDLED REJECTION TRACKING\n\n// This promise library consumes exceptions thrown in handlers so they can be\n// handled by a subsequent promise.  The exceptions get added to this array when\n// they are created, and removed when they are handled.  Note that in ES6 or\n// shimmed environments, this would naturally be a `Set`.\nvar unhandledReasons = [];\nvar unhandledRejections = [];\nvar reportedUnhandledRejections = [];\nvar trackUnhandledRejections = true;\n\nfunction resetUnhandledRejections() {\n    unhandledReasons.length = 0;\n    unhandledRejections.length = 0;\n\n    if (!trackUnhandledRejections) {\n        trackUnhandledRejections = true;\n    }\n}\n\nfunction trackRejection(promise, reason) {\n    if (!trackUnhandledRejections) {\n        return;\n    }\n    if (typeof process === \"object\" && typeof process.emit === \"function\") {\n        Q.nextTick.runAfter(function () {\n            if (array_indexOf(unhandledRejections, promise) !== -1) {\n                process.emit(\"unhandledRejection\", reason, promise);\n                reportedUnhandledRejections.push(promise);\n            }\n        });\n    }\n\n    unhandledRejections.push(promise);\n    if (reason && typeof reason.stack !== \"undefined\") {\n        unhandledReasons.push(reason.stack);\n    } else {\n        unhandledReasons.push(\"(no stack) \" + reason);\n    }\n}\n\nfunction untrackRejection(promise) {\n    if (!trackUnhandledRejections) {\n        return;\n    }\n\n    var at = array_indexOf(unhandledRejections, promise);\n    if (at !== -1) {\n        if (typeof process === \"object\" && typeof process.emit === \"function\") {\n            Q.nextTick.runAfter(function () {\n                var atReport = array_indexOf(reportedUnhandledRejections, promise);\n                if (atReport !== -1) {\n                    process.emit(\"rejectionHandled\", unhandledReasons[at], promise);\n                    reportedUnhandledRejections.splice(atReport, 1);\n                }\n            });\n        }\n        unhandledRejections.splice(at, 1);\n        unhandledReasons.splice(at, 1);\n    }\n}\n\nQ.resetUnhandledRejections = resetUnhandledRejections;\n\nQ.getUnhandledReasons = function () {\n    // Make a copy so that consumers can't interfere with our internal state.\n    return unhandledReasons.slice();\n};\n\nQ.stopUnhandledRejectionTracking = function () {\n    resetUnhandledRejections();\n    trackUnhandledRejections = false;\n};\n\nresetUnhandledRejections();\n\n//// END UNHANDLED REJECTION TRACKING\n\n/**\n * Constructs a rejected promise.\n * @param reason value describing the failure\n */\nQ.reject = reject;\nfunction reject(reason) {\n    var rejection = Promise({\n        \"when\": function (rejected) {\n            // note that the error has been handled\n            if (rejected) {\n                untrackRejection(this);\n            }\n            return rejected ? rejected(reason) : this;\n        }\n    }, function fallback() {\n        return this;\n    }, function inspect() {\n        return { state: \"rejected\", reason: reason };\n    });\n\n    // Note that the reason has not been handled.\n    trackRejection(rejection, reason);\n\n    return rejection;\n}\n\n/**\n * Constructs a fulfilled promise for an immediate reference.\n * @param value immediate reference\n */\nQ.fulfill = fulfill;\nfunction fulfill(value) {\n    return Promise({\n        \"when\": function () {\n            return value;\n        },\n        \"get\": function (name) {\n            return value[name];\n        },\n        \"set\": function (name, rhs) {\n            value[name] = rhs;\n        },\n        \"delete\": function (name) {\n            delete value[name];\n        },\n        \"post\": function (name, args) {\n            // Mark Miller proposes that post with no name should apply a\n            // promised function.\n            if (name === null || name === void 0) {\n                return value.apply(void 0, args);\n            } else {\n                return value[name].apply(value, args);\n            }\n        },\n        \"apply\": function (thisp, args) {\n            return value.apply(thisp, args);\n        },\n        \"keys\": function () {\n            return object_keys(value);\n        }\n    }, void 0, function inspect() {\n        return { state: \"fulfilled\", value: value };\n    });\n}\n\n/**\n * Converts thenables to Q promises.\n * @param promise thenable promise\n * @returns a Q promise\n */\nfunction coerce(promise) {\n    var deferred = defer();\n    Q.nextTick(function () {\n        try {\n            promise.then(deferred.resolve, deferred.reject, deferred.notify);\n        } catch (exception) {\n            deferred.reject(exception);\n        }\n    });\n    return deferred.promise;\n}\n\n/**\n * Annotates an object such that it will never be\n * transferred away from this process over any promise\n * communication channel.\n * @param object\n * @returns promise a wrapping of that object that\n * additionally responds to the \"isDef\" message\n * without a rejection.\n */\nQ.master = master;\nfunction master(object) {\n    return Promise({\n        \"isDef\": function () {}\n    }, function fallback(op, args) {\n        return dispatch(object, op, args);\n    }, function () {\n        return Q(object).inspect();\n    });\n}\n\n/**\n * Spreads the values of a promised array of arguments into the\n * fulfillment callback.\n * @param fulfilled callback that receives variadic arguments from the\n * promised array\n * @param rejected callback that receives the exception if the promise\n * is rejected.\n * @returns a promise for the return value or thrown exception of\n * either callback.\n */\nQ.spread = spread;\nfunction spread(value, fulfilled, rejected) {\n    return Q(value).spread(fulfilled, rejected);\n}\n\nPromise.prototype.spread = function (fulfilled, rejected) {\n    return this.all().then(function (array) {\n        return fulfilled.apply(void 0, array);\n    }, rejected);\n};\n\n/**\n * The async function is a decorator for generator functions, turning\n * them into asynchronous generators.  Although generators are only part\n * of the newest ECMAScript 6 drafts, this code does not cause syntax\n * errors in older engines.  This code should continue to work and will\n * in fact improve over time as the language improves.\n *\n * ES6 generators are currently part of V8 version 3.19 with the\n * --harmony-generators runtime flag enabled.  SpiderMonkey has had them\n * for longer, but under an older Python-inspired form.  This function\n * works on both kinds of generators.\n *\n * Decorates a generator function such that:\n *  - it may yield promises\n *  - execution will continue when that promise is fulfilled\n *  - the value of the yield expression will be the fulfilled value\n *  - it returns a promise for the return value (when the generator\n *    stops iterating)\n *  - the decorated function returns a promise for the return value\n *    of the generator or the first rejected promise among those\n *    yielded.\n *  - if an error is thrown in the generator, it propagates through\n *    every following yield until it is caught, or until it escapes\n *    the generator function altogether, and is translated into a\n *    rejection for the promise returned by the decorated generator.\n */\nQ.async = async;\nfunction async(makeGenerator) {\n    return function () {\n        // when verb is \"send\", arg is a value\n        // when verb is \"throw\", arg is an exception\n        function continuer(verb, arg) {\n            var result;\n\n            // Until V8 3.19 / Chromium 29 is released, SpiderMonkey is the only\n            // engine that has a deployed base of browsers that support generators.\n            // However, SM's generators use the Python-inspired semantics of\n            // outdated ES6 drafts.  We would like to support ES6, but we'd also\n            // like to make it possible to use generators in deployed browsers, so\n            // we also support Python-style generators.  At some point we can remove\n            // this block.\n\n            if (typeof StopIteration === \"undefined\") {\n                // ES6 Generators\n                try {\n                    result = generator[verb](arg);\n                } catch (exception) {\n                    return reject(exception);\n                }\n                if (result.done) {\n                    return Q(result.value);\n                } else {\n                    return when(result.value, callback, errback);\n                }\n            } else {\n                // SpiderMonkey Generators\n                // FIXME: Remove this case when SM does ES6 generators.\n                try {\n                    result = generator[verb](arg);\n                } catch (exception) {\n                    if (isStopIteration(exception)) {\n                        return Q(exception.value);\n                    } else {\n                        return reject(exception);\n                    }\n                }\n                return when(result, callback, errback);\n            }\n        }\n        var generator = makeGenerator.apply(this, arguments);\n        var callback = continuer.bind(continuer, \"next\");\n        var errback = continuer.bind(continuer, \"throw\");\n        return callback();\n    };\n}\n\n/**\n * The spawn function is a small wrapper around async that immediately\n * calls the generator and also ends the promise chain, so that any\n * unhandled errors are thrown instead of forwarded to the error\n * handler. This is useful because it's extremely common to run\n * generators at the top-level to work with libraries.\n */\nQ.spawn = spawn;\nfunction spawn(makeGenerator) {\n    Q.done(Q.async(makeGenerator)());\n}\n\n// FIXME: Remove this interface once ES6 generators are in SpiderMonkey.\n/**\n * Throws a ReturnValue exception to stop an asynchronous generator.\n *\n * This interface is a stop-gap measure to support generator return\n * values in older Firefox/SpiderMonkey.  In browsers that support ES6\n * generators like Chromium 29, just use \"return\" in your generator\n * functions.\n *\n * @param value the return value for the surrounding generator\n * @throws ReturnValue exception with the value.\n * @example\n * // ES6 style\n * Q.async(function* () {\n *      var foo = yield getFooPromise();\n *      var bar = yield getBarPromise();\n *      return foo + bar;\n * })\n * // Older SpiderMonkey style\n * Q.async(function () {\n *      var foo = yield getFooPromise();\n *      var bar = yield getBarPromise();\n *      Q.return(foo + bar);\n * })\n */\nQ[\"return\"] = _return;\nfunction _return(value) {\n    throw new QReturnValue(value);\n}\n\n/**\n * The promised function decorator ensures that any promise arguments\n * are settled and passed as values (`this` is also settled and passed\n * as a value).  It will also ensure that the result of a function is\n * always a promise.\n *\n * @example\n * var add = Q.promised(function (a, b) {\n *     return a + b;\n * });\n * add(Q(a), Q(B));\n *\n * @param {function} callback The function to decorate\n * @returns {function} a function that has been decorated.\n */\nQ.promised = promised;\nfunction promised(callback) {\n    return function () {\n        return spread([this, all(arguments)], function (self, args) {\n            return callback.apply(self, args);\n        });\n    };\n}\n\n/**\n * sends a message to a value in a future turn\n * @param object* the recipient\n * @param op the name of the message operation, e.g., \"when\",\n * @param args further arguments to be forwarded to the operation\n * @returns result {Promise} a promise for the result of the operation\n */\nQ.dispatch = dispatch;\nfunction dispatch(object, op, args) {\n    return Q(object).dispatch(op, args);\n}\n\nPromise.prototype.dispatch = function (op, args) {\n    var self = this;\n    var deferred = defer();\n    Q.nextTick(function () {\n        self.promiseDispatch(deferred.resolve, op, args);\n    });\n    return deferred.promise;\n};\n\n/**\n * Gets the value of a property in a future turn.\n * @param object    promise or immediate reference for target object\n * @param name      name of property to get\n * @return promise for the property value\n */\nQ.get = function (object, key) {\n    return Q(object).dispatch(\"get\", [key]);\n};\n\nPromise.prototype.get = function (key) {\n    return this.dispatch(\"get\", [key]);\n};\n\n/**\n * Sets the value of a property in a future turn.\n * @param object    promise or immediate reference for object object\n * @param name      name of property to set\n * @param value     new value of property\n * @return promise for the return value\n */\nQ.set = function (object, key, value) {\n    return Q(object).dispatch(\"set\", [key, value]);\n};\n\nPromise.prototype.set = function (key, value) {\n    return this.dispatch(\"set\", [key, value]);\n};\n\n/**\n * Deletes a property in a future turn.\n * @param object    promise or immediate reference for target object\n * @param name      name of property to delete\n * @return promise for the return value\n */\nQ.del = // XXX legacy\nQ[\"delete\"] = function (object, key) {\n    return Q(object).dispatch(\"delete\", [key]);\n};\n\nPromise.prototype.del = // XXX legacy\nPromise.prototype[\"delete\"] = function (key) {\n    return this.dispatch(\"delete\", [key]);\n};\n\n/**\n * Invokes a method in a future turn.\n * @param object    promise or immediate reference for target object\n * @param name      name of method to invoke\n * @param value     a value to post, typically an array of\n *                  invocation arguments for promises that\n *                  are ultimately backed with `resolve` values,\n *                  as opposed to those backed with URLs\n *                  wherein the posted value can be any\n *                  JSON serializable object.\n * @return promise for the return value\n */\n// bound locally because it is used by other methods\nQ.mapply = // XXX As proposed by \"Redsandro\"\nQ.post = function (object, name, args) {\n    return Q(object).dispatch(\"post\", [name, args]);\n};\n\nPromise.prototype.mapply = // XXX As proposed by \"Redsandro\"\nPromise.prototype.post = function (name, args) {\n    return this.dispatch(\"post\", [name, args]);\n};\n\n/**\n * Invokes a method in a future turn.\n * @param object    promise or immediate reference for target object\n * @param name      name of method to invoke\n * @param ...args   array of invocation arguments\n * @return promise for the return value\n */\nQ.send = // XXX Mark Miller's proposed parlance\nQ.mcall = // XXX As proposed by \"Redsandro\"\nQ.invoke = function (object, name /*...args*/) {\n    return Q(object).dispatch(\"post\", [name, array_slice(arguments, 2)]);\n};\n\nPromise.prototype.send = // XXX Mark Miller's proposed parlance\nPromise.prototype.mcall = // XXX As proposed by \"Redsandro\"\nPromise.prototype.invoke = function (name /*...args*/) {\n    return this.dispatch(\"post\", [name, array_slice(arguments, 1)]);\n};\n\n/**\n * Applies the promised function in a future turn.\n * @param object    promise or immediate reference for target function\n * @param args      array of application arguments\n */\nQ.fapply = function (object, args) {\n    return Q(object).dispatch(\"apply\", [void 0, args]);\n};\n\nPromise.prototype.fapply = function (args) {\n    return this.dispatch(\"apply\", [void 0, args]);\n};\n\n/**\n * Calls the promised function in a future turn.\n * @param object    promise or immediate reference for target function\n * @param ...args   array of application arguments\n */\nQ[\"try\"] =\nQ.fcall = function (object /* ...args*/) {\n    return Q(object).dispatch(\"apply\", [void 0, array_slice(arguments, 1)]);\n};\n\nPromise.prototype.fcall = function (/*...args*/) {\n    return this.dispatch(\"apply\", [void 0, array_slice(arguments)]);\n};\n\n/**\n * Binds the promised function, transforming return values into a fulfilled\n * promise and thrown errors into a rejected one.\n * @param object    promise or immediate reference for target function\n * @param ...args   array of application arguments\n */\nQ.fbind = function (object /*...args*/) {\n    var promise = Q(object);\n    var args = array_slice(arguments, 1);\n    return function fbound() {\n        return promise.dispatch(\"apply\", [\n            this,\n            args.concat(array_slice(arguments))\n        ]);\n    };\n};\nPromise.prototype.fbind = function (/*...args*/) {\n    var promise = this;\n    var args = array_slice(arguments);\n    return function fbound() {\n        return promise.dispatch(\"apply\", [\n            this,\n            args.concat(array_slice(arguments))\n        ]);\n    };\n};\n\n/**\n * Requests the names of the owned properties of a promised\n * object in a future turn.\n * @param object    promise or immediate reference for target object\n * @return promise for the keys of the eventually settled object\n */\nQ.keys = function (object) {\n    return Q(object).dispatch(\"keys\", []);\n};\n\nPromise.prototype.keys = function () {\n    return this.dispatch(\"keys\", []);\n};\n\n/**\n * Turns an array of promises into a promise for an array.  If any of\n * the promises gets rejected, the whole array is rejected immediately.\n * @param {Array*} an array (or promise for an array) of values (or\n * promises for values)\n * @returns a promise for an array of the corresponding values\n */\n// By Mark Miller\n// http://wiki.ecmascript.org/doku.php?id=strawman:concurrency&rev=1308776521#allfulfilled\nQ.all = all;\nfunction all(promises) {\n    return when(promises, function (promises) {\n        var pendingCount = 0;\n        var deferred = defer();\n        array_reduce(promises, function (undefined, promise, index) {\n            var snapshot;\n            if (\n                isPromise(promise) &&\n                (snapshot = promise.inspect()).state === \"fulfilled\"\n            ) {\n                promises[index] = snapshot.value;\n            } else {\n                ++pendingCount;\n                when(\n                    promise,\n                    function (value) {\n                        promises[index] = value;\n                        if (--pendingCount === 0) {\n                            deferred.resolve(promises);\n                        }\n                    },\n                    deferred.reject,\n                    function (progress) {\n                        deferred.notify({ index: index, value: progress });\n                    }\n                );\n            }\n        }, void 0);\n        if (pendingCount === 0) {\n            deferred.resolve(promises);\n        }\n        return deferred.promise;\n    });\n}\n\nPromise.prototype.all = function () {\n    return all(this);\n};\n\n/**\n * Returns the first resolved promise of an array. Prior rejected promises are\n * ignored.  Rejects only if all promises are rejected.\n * @param {Array*} an array containing values or promises for values\n * @returns a promise fulfilled with the value of the first resolved promise,\n * or a rejected promise if all promises are rejected.\n */\nQ.any = any;\n\nfunction any(promises) {\n    if (promises.length === 0) {\n        return Q.resolve();\n    }\n\n    var deferred = Q.defer();\n    var pendingCount = 0;\n    array_reduce(promises, function (prev, current, index) {\n        var promise = promises[index];\n\n        pendingCount++;\n\n        when(promise, onFulfilled, onRejected, onProgress);\n        function onFulfilled(result) {\n            deferred.resolve(result);\n        }\n        function onRejected() {\n            pendingCount--;\n            if (pendingCount === 0) {\n                deferred.reject(new Error(\n                    \"Can't get fulfillment value from any promise, all \" +\n                    \"promises were rejected.\"\n                ));\n            }\n        }\n        function onProgress(progress) {\n            deferred.notify({\n                index: index,\n                value: progress\n            });\n        }\n    }, undefined);\n\n    return deferred.promise;\n}\n\nPromise.prototype.any = function () {\n    return any(this);\n};\n\n/**\n * Waits for all promises to be settled, either fulfilled or\n * rejected.  This is distinct from `all` since that would stop\n * waiting at the first rejection.  The promise returned by\n * `allResolved` will never be rejected.\n * @param promises a promise for an array (or an array) of promises\n * (or values)\n * @return a promise for an array of promises\n */\nQ.allResolved = deprecate(allResolved, \"allResolved\", \"allSettled\");\nfunction allResolved(promises) {\n    return when(promises, function (promises) {\n        promises = array_map(promises, Q);\n        return when(all(array_map(promises, function (promise) {\n            return when(promise, noop, noop);\n        })), function () {\n            return promises;\n        });\n    });\n}\n\nPromise.prototype.allResolved = function () {\n    return allResolved(this);\n};\n\n/**\n * @see Promise#allSettled\n */\nQ.allSettled = allSettled;\nfunction allSettled(promises) {\n    return Q(promises).allSettled();\n}\n\n/**\n * Turns an array of promises into a promise for an array of their states (as\n * returned by `inspect`) when they have all settled.\n * @param {Array[Any*]} values an array (or promise for an array) of values (or\n * promises for values)\n * @returns {Array[State]} an array of states for the respective values.\n */\nPromise.prototype.allSettled = function () {\n    return this.then(function (promises) {\n        return all(array_map(promises, function (promise) {\n            promise = Q(promise);\n            function regardless() {\n                return promise.inspect();\n            }\n            return promise.then(regardless, regardless);\n        }));\n    });\n};\n\n/**\n * Captures the failure of a promise, giving an oportunity to recover\n * with a callback.  If the given promise is fulfilled, the returned\n * promise is fulfilled.\n * @param {Any*} promise for something\n * @param {Function} callback to fulfill the returned promise if the\n * given promise is rejected\n * @returns a promise for the return value of the callback\n */\nQ.fail = // XXX legacy\nQ[\"catch\"] = function (object, rejected) {\n    return Q(object).then(void 0, rejected);\n};\n\nPromise.prototype.fail = // XXX legacy\nPromise.prototype[\"catch\"] = function (rejected) {\n    return this.then(void 0, rejected);\n};\n\n/**\n * Attaches a listener that can respond to progress notifications from a\n * promise's originating deferred. This listener receives the exact arguments\n * passed to ``deferred.notify``.\n * @param {Any*} promise for something\n * @param {Function} callback to receive any progress notifications\n * @returns the given promise, unchanged\n */\nQ.progress = progress;\nfunction progress(object, progressed) {\n    return Q(object).then(void 0, void 0, progressed);\n}\n\nPromise.prototype.progress = function (progressed) {\n    return this.then(void 0, void 0, progressed);\n};\n\n/**\n * Provides an opportunity to observe the settling of a promise,\n * regardless of whether the promise is fulfilled or rejected.  Forwards\n * the resolution to the returned promise when the callback is done.\n * The callback can return a promise to defer completion.\n * @param {Any*} promise\n * @param {Function} callback to observe the resolution of the given\n * promise, takes no arguments.\n * @returns a promise for the resolution of the given promise when\n * ``fin`` is done.\n */\nQ.fin = // XXX legacy\nQ[\"finally\"] = function (object, callback) {\n    return Q(object)[\"finally\"](callback);\n};\n\nPromise.prototype.fin = // XXX legacy\nPromise.prototype[\"finally\"] = function (callback) {\n    callback = Q(callback);\n    return this.then(function (value) {\n        return callback.fcall().then(function () {\n            return value;\n        });\n    }, function (reason) {\n        // TODO attempt to recycle the rejection with \"this\".\n        return callback.fcall().then(function () {\n            throw reason;\n        });\n    });\n};\n\n/**\n * Terminates a chain of promises, forcing rejections to be\n * thrown as exceptions.\n * @param {Any*} promise at the end of a chain of promises\n * @returns nothing\n */\nQ.done = function (object, fulfilled, rejected, progress) {\n    return Q(object).done(fulfilled, rejected, progress);\n};\n\nPromise.prototype.done = function (fulfilled, rejected, progress) {\n    var onUnhandledError = function (error) {\n        // forward to a future turn so that ``when``\n        // does not catch it and turn it into a rejection.\n        Q.nextTick(function () {\n            makeStackTraceLong(error, promise);\n            if (Q.onerror) {\n                Q.onerror(error);\n            } else {\n                throw error;\n            }\n        });\n    };\n\n    // Avoid unnecessary `nextTick`ing via an unnecessary `when`.\n    var promise = fulfilled || rejected || progress ?\n        this.then(fulfilled, rejected, progress) :\n        this;\n\n    if (typeof process === \"object\" && process && process.domain) {\n        onUnhandledError = process.domain.bind(onUnhandledError);\n    }\n\n    promise.then(void 0, onUnhandledError);\n};\n\n/**\n * Causes a promise to be rejected if it does not get fulfilled before\n * some milliseconds time out.\n * @param {Any*} promise\n * @param {Number} milliseconds timeout\n * @param {Any*} custom error message or Error object (optional)\n * @returns a promise for the resolution of the given promise if it is\n * fulfilled before the timeout, otherwise rejected.\n */\nQ.timeout = function (object, ms, error) {\n    return Q(object).timeout(ms, error);\n};\n\nPromise.prototype.timeout = function (ms, error) {\n    var deferred = defer();\n    var timeoutId = setTimeout(function () {\n        if (!error || \"string\" === typeof error) {\n            error = new Error(error || \"Timed out after \" + ms + \" ms\");\n            error.code = \"ETIMEDOUT\";\n        }\n        deferred.reject(error);\n    }, ms);\n\n    this.then(function (value) {\n        clearTimeout(timeoutId);\n        deferred.resolve(value);\n    }, function (exception) {\n        clearTimeout(timeoutId);\n        deferred.reject(exception);\n    }, deferred.notify);\n\n    return deferred.promise;\n};\n\n/**\n * Returns a promise for the given value (or promised value), some\n * milliseconds after it resolved. Passes rejections immediately.\n * @param {Any*} promise\n * @param {Number} milliseconds\n * @returns a promise for the resolution of the given promise after milliseconds\n * time has elapsed since the resolution of the given promise.\n * If the given promise rejects, that is passed immediately.\n */\nQ.delay = function (object, timeout) {\n    if (timeout === void 0) {\n        timeout = object;\n        object = void 0;\n    }\n    return Q(object).delay(timeout);\n};\n\nPromise.prototype.delay = function (timeout) {\n    return this.then(function (value) {\n        var deferred = defer();\n        setTimeout(function () {\n            deferred.resolve(value);\n        }, timeout);\n        return deferred.promise;\n    });\n};\n\n/**\n * Passes a continuation to a Node function, which is called with the given\n * arguments provided as an array, and returns a promise.\n *\n *      Q.nfapply(FS.readFile, [__filename])\n *      .then(function (content) {\n *      })\n *\n */\nQ.nfapply = function (callback, args) {\n    return Q(callback).nfapply(args);\n};\n\nPromise.prototype.nfapply = function (args) {\n    var deferred = defer();\n    var nodeArgs = array_slice(args);\n    nodeArgs.push(deferred.makeNodeResolver());\n    this.fapply(nodeArgs).fail(deferred.reject);\n    return deferred.promise;\n};\n\n/**\n * Passes a continuation to a Node function, which is called with the given\n * arguments provided individually, and returns a promise.\n * @example\n * Q.nfcall(FS.readFile, __filename)\n * .then(function (content) {\n * })\n *\n */\nQ.nfcall = function (callback /*...args*/) {\n    var args = array_slice(arguments, 1);\n    return Q(callback).nfapply(args);\n};\n\nPromise.prototype.nfcall = function (/*...args*/) {\n    var nodeArgs = array_slice(arguments);\n    var deferred = defer();\n    nodeArgs.push(deferred.makeNodeResolver());\n    this.fapply(nodeArgs).fail(deferred.reject);\n    return deferred.promise;\n};\n\n/**\n * Wraps a NodeJS continuation passing function and returns an equivalent\n * version that returns a promise.\n * @example\n * Q.nfbind(FS.readFile, __filename)(\"utf-8\")\n * .then(console.log)\n * .done()\n */\nQ.nfbind =\nQ.denodeify = function (callback /*...args*/) {\n    var baseArgs = array_slice(arguments, 1);\n    return function () {\n        var nodeArgs = baseArgs.concat(array_slice(arguments));\n        var deferred = defer();\n        nodeArgs.push(deferred.makeNodeResolver());\n        Q(callback).fapply(nodeArgs).fail(deferred.reject);\n        return deferred.promise;\n    };\n};\n\nPromise.prototype.nfbind =\nPromise.prototype.denodeify = function (/*...args*/) {\n    var args = array_slice(arguments);\n    args.unshift(this);\n    return Q.denodeify.apply(void 0, args);\n};\n\nQ.nbind = function (callback, thisp /*...args*/) {\n    var baseArgs = array_slice(arguments, 2);\n    return function () {\n        var nodeArgs = baseArgs.concat(array_slice(arguments));\n        var deferred = defer();\n        nodeArgs.push(deferred.makeNodeResolver());\n        function bound() {\n            return callback.apply(thisp, arguments);\n        }\n        Q(bound).fapply(nodeArgs).fail(deferred.reject);\n        return deferred.promise;\n    };\n};\n\nPromise.prototype.nbind = function (/*thisp, ...args*/) {\n    var args = array_slice(arguments, 0);\n    args.unshift(this);\n    return Q.nbind.apply(void 0, args);\n};\n\n/**\n * Calls a method of a Node-style object that accepts a Node-style\n * callback with a given array of arguments, plus a provided callback.\n * @param object an object that has the named method\n * @param {String} name name of the method of object\n * @param {Array} args arguments to pass to the method; the callback\n * will be provided by Q and appended to these arguments.\n * @returns a promise for the value or error\n */\nQ.nmapply = // XXX As proposed by \"Redsandro\"\nQ.npost = function (object, name, args) {\n    return Q(object).npost(name, args);\n};\n\nPromise.prototype.nmapply = // XXX As proposed by \"Redsandro\"\nPromise.prototype.npost = function (name, args) {\n    var nodeArgs = array_slice(args || []);\n    var deferred = defer();\n    nodeArgs.push(deferred.makeNodeResolver());\n    this.dispatch(\"post\", [name, nodeArgs]).fail(deferred.reject);\n    return deferred.promise;\n};\n\n/**\n * Calls a method of a Node-style object that accepts a Node-style\n * callback, forwarding the given variadic arguments, plus a provided\n * callback argument.\n * @param object an object that has the named method\n * @param {String} name name of the method of object\n * @param ...args arguments to pass to the method; the callback will\n * be provided by Q and appended to these arguments.\n * @returns a promise for the value or error\n */\nQ.nsend = // XXX Based on Mark Miller's proposed \"send\"\nQ.nmcall = // XXX Based on \"Redsandro's\" proposal\nQ.ninvoke = function (object, name /*...args*/) {\n    var nodeArgs = array_slice(arguments, 2);\n    var deferred = defer();\n    nodeArgs.push(deferred.makeNodeResolver());\n    Q(object).dispatch(\"post\", [name, nodeArgs]).fail(deferred.reject);\n    return deferred.promise;\n};\n\nPromise.prototype.nsend = // XXX Based on Mark Miller's proposed \"send\"\nPromise.prototype.nmcall = // XXX Based on \"Redsandro's\" proposal\nPromise.prototype.ninvoke = function (name /*...args*/) {\n    var nodeArgs = array_slice(arguments, 1);\n    var deferred = defer();\n    nodeArgs.push(deferred.makeNodeResolver());\n    this.dispatch(\"post\", [name, nodeArgs]).fail(deferred.reject);\n    return deferred.promise;\n};\n\n/**\n * If a function would like to support both Node continuation-passing-style and\n * promise-returning-style, it can end its internal promise chain with\n * `nodeify(nodeback)`, forwarding the optional nodeback argument.  If the user\n * elects to use a nodeback, the result will be sent there.  If they do not\n * pass a nodeback, they will receive the result promise.\n * @param object a result (or a promise for a result)\n * @param {Function} nodeback a Node.js-style callback\n * @returns either the promise or nothing\n */\nQ.nodeify = nodeify;\nfunction nodeify(object, nodeback) {\n    return Q(object).nodeify(nodeback);\n}\n\nPromise.prototype.nodeify = function (nodeback) {\n    if (nodeback) {\n        this.then(function (value) {\n            Q.nextTick(function () {\n                nodeback(null, value);\n            });\n        }, function (error) {\n            Q.nextTick(function () {\n                nodeback(error);\n            });\n        });\n    } else {\n        return this;\n    }\n};\n\nQ.noConflict = function() {\n    throw new Error(\"Q.noConflict only works when Q is used as a global\");\n};\n\n// All code before this point will be filtered from stack traces.\nvar qEndingLine = captureLine();\n\nreturn Q;\n\n});\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./node_modules/q/q.js\n// module id = 5\n// module chunks = 0","/*!\n * Copyright (c) 2015-present, Okta, Inc. and/or its affiliates. All rights reserved.\n * The Okta software accompanied by this notice is provided pursuant to the Apache License, Version 2.0 (the \"License.\")\n *\n * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0.\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS, WITHOUT\n * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n *\n * See the License for the specific language governing permissions and limitations under the License.\n *\n */\n\nvar AuthSdkError = require('./errors/AuthSdkError');\n\n// storage must have getItem and setItem\nfunction storageBuilder(webstorage, storageName) {\n  if (typeof storageName !== 'string' || !storageName.length) {\n    throw new AuthSdkError('\"storageName\" is required');\n  }\n\n  function getStorage() {\n    var storageString = webstorage.getItem(storageName);\n    storageString = storageString || '{}';\n    try {\n      return JSON.parse(storageString);\n    } catch(e) {\n      throw new AuthSdkError('Unable to parse storage string: ' + storageName);\n    }\n  }\n\n  function setStorage(storage) {\n    try {\n      var storageString = JSON.stringify(storage);\n      webstorage.setItem(storageName, storageString);\n    } catch(e) {\n      throw new AuthSdkError('Unable to set storage: ' + storageName);\n    }\n  }\n\n  function clearStorage(key) {\n    if (!key) {\n      setStorage({});\n    }\n    var storage = getStorage();\n    delete storage[key];\n    setStorage(storage);\n  }\n\n  function updateStorage(key, value) {\n    var storage = getStorage();\n    storage[key] = value;\n    setStorage(storage);\n  }\n\n  return {\n    getStorage: getStorage,\n    setStorage: setStorage,\n    clearStorage: clearStorage,\n    updateStorage: updateStorage\n  };\n}\n\nmodule.exports = storageBuilder;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./lib/storageBuilder.js\n// module id = 6\n// module chunks = 0","/*!\n * Copyright (c) 2015-present, Okta, Inc. and/or its affiliates. All rights reserved.\n * The Okta software accompanied by this notice is provided pursuant to the Apache License, Version 2.0 (the \"License.\")\n *\n * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0.\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS, WITHOUT\n * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n *\n * See the License for the specific language governing permissions and limitations under the License.\n *\n */\n\n/* eslint-disable complexity, max-statements */\nvar http              = require('./http');\nvar util              = require('./util');\nvar Q                 = require('q');\nvar AuthSdkError      = require('./errors/AuthSdkError');\nvar AuthPollStopError = require('./errors/AuthPollStopError');\nvar constants         = require('./constants');\n\nfunction addStateToken(res, options) {\n  var builtArgs = {};\n  util.extend(builtArgs, options);\n\n  // Add the stateToken if one isn't passed and we have one\n  if (!builtArgs.stateToken && res.stateToken) {\n    builtArgs.stateToken = res.stateToken;\n  }\n\n  return builtArgs;\n}\n\nfunction getStateToken(res) {\n  return addStateToken(res);\n}\n\nfunction transactionStatus(sdk, args) {\n  args = addStateToken(sdk, args);\n  return http.post(sdk, sdk.options.url + '/api/v1/authn', args);\n}\n\nfunction resumeTransaction(sdk, args) {\n  if (!args || !args.stateToken) {\n    var stateToken = sdk.tx.exists._get(constants.STATE_TOKEN_KEY_NAME);\n    if (stateToken) {\n      args = {\n        stateToken: stateToken\n      };\n    } else {\n      return Q.reject(new AuthSdkError('No transaction to resume'));\n    }\n  }\n  return sdk.tx.status(args)\n    .then(function(res) {\n      return new AuthTransaction(sdk, res);\n    });\n}\n\nfunction introspect (sdk, args) {\n  if (!args || !args.stateToken) {\n    var stateToken = sdk.tx.exists._get(constants.STATE_TOKEN_KEY_NAME);\n    if (stateToken) {\n      args = {\n        stateToken: stateToken\n      };\n    } else {\n      return Q.reject(new AuthSdkError('No transaction to evaluate'));\n    }\n  }\n  return transactionStep(sdk, args)\n    .then(function (res) {\n      return new AuthTransaction(sdk, res);\n    });\n}\n\nfunction transactionStep(sdk, args) {\n  args = addStateToken(sdk, args);\n  // v1 pipeline introspect API\n  return http.post(sdk, sdk.options.url + '/api/v1/authn/introspect', args);\n}\n\nfunction transactionExists(sdk) {\n  // We have a cookie state token\n  return !!sdk.tx.exists._get(constants.STATE_TOKEN_KEY_NAME);\n}\n\nfunction postToTransaction(sdk, url, args, options) {\n  return http.post(sdk, url, args, options)\n    .then(function(res) {\n      return new AuthTransaction(sdk, res);\n    });\n}\n\nfunction getPollFn(sdk, res, ref) {\n  return function (options) {\n    var delay;\n    var rememberDevice;\n    var autoPush;\n    var transactionCallBack;\n\n    if (util.isNumber(options)) {\n      delay = options;\n    } else if (util.isObject(options)) {\n      delay = options.delay;\n      rememberDevice = options.rememberDevice;\n      autoPush = options.autoPush;\n      transactionCallBack = options.transactionCallBack;\n    }\n\n    if (!delay && delay !== 0) {\n      delay = constants.DEFAULT_POLLING_DELAY;\n    }\n\n    // Get the poll function\n    var pollLink = util.getLink(res, 'next', 'poll');\n    function pollFn() {\n      var opts = {};\n      if (typeof autoPush === 'function') {\n        try {\n          opts.autoPush = !!autoPush();\n        }\n        catch (e) {\n          return Q.reject(new AuthSdkError('AutoPush resulted in an error.'));\n        }\n      }\n      else if (autoPush !== undefined && autoPush !== null) {\n        opts.autoPush = !!autoPush;\n      }\n      if (typeof rememberDevice === 'function') {\n        try {\n          opts.rememberDevice = !!rememberDevice();\n        }\n        catch (e) {\n          return Q.reject(new AuthSdkError('RememberDevice resulted in an error.'));\n        }\n      }\n      else if (rememberDevice !== undefined && rememberDevice !== null) {\n        opts.rememberDevice = !!rememberDevice;\n      }\n\n      var href = pollLink.href + util.toQueryParams(opts);\n      return http.post(sdk, href, getStateToken(res), {\n        saveAuthnState: false  \n      });\n    }\n\n    ref.isPolling = true;\n\n    var retryCount = 0;\n    var recursivePoll = function () {\n      // If the poll was manually stopped during the delay\n      if (!ref.isPolling) {\n        return Q.reject(new AuthPollStopError());\n      }\n      return pollFn()\n        .then(function (pollRes) {\n          // Reset our retry counter on success\n          retryCount = 0;\n\n          // If we're still waiting\n          if (pollRes.factorResult && pollRes.factorResult === 'WAITING') {\n\n            // If the poll was manually stopped while the pollFn was called\n            if (!ref.isPolling) {\n              throw new AuthPollStopError();\n            }\n\n            if (typeof transactionCallBack === 'function') {\n              transactionCallBack(pollRes);\n            }\n\n            // Continue poll\n            return Q.delay(delay)\n              .then(recursivePoll);\n\n          } else {\n            // Any non-waiting result, even if polling was stopped\n            // during a request, will return\n            ref.isPolling = false;\n            return new AuthTransaction(sdk, pollRes);\n          }\n        })\n        .fail(function(err) {\n          // Exponential backoff, up to 16 seconds\n          if (err.xhr &&\n              (err.xhr.status === 0 || err.xhr.status === 429) &&\n              retryCount <= 4) {\n            var delayLength = Math.pow(2, retryCount) * 1000;\n            retryCount++;\n            return Q.delay(delayLength)\n              .then(recursivePoll);\n          }\n          throw err;\n        });\n    };\n    return recursivePoll()\n      .fail(function(err) {\n        ref.isPolling = false;\n        throw err;\n      });\n  };\n}\n\nfunction link2fn(sdk, res, obj, link, ref) {\n  if (Array.isArray(link)) {\n    return function(name, opts) {\n      if (!name) {\n        throw new AuthSdkError('Must provide a link name');\n      }\n\n      var lk = util.find(link, {name: name});\n      if (!lk) {\n        throw new AuthSdkError('No link found for that name');\n      }\n\n      return link2fn(sdk, res, obj, lk, ref)(opts);\n    };\n\n  } else if (link.hints &&\n      link.hints.allow &&\n      link.hints.allow.length === 1) {\n    var method = link.hints.allow[0];\n    switch (method) {\n\n      case 'GET':\n        return function() {\n          return http.get(sdk, link.href);\n        };\n\n      case 'POST':\n        return function(opts) {\n          if (ref && ref.isPolling) {\n            ref.isPolling = false;\n          }\n\n          var data = addStateToken(res, opts);\n\n          if (res.status === 'MFA_ENROLL' || res.status === 'FACTOR_ENROLL') {\n            // Add factorType and provider\n            util.extend(data, {\n              factorType: obj.factorType,\n              provider: obj.provider\n            });\n          }\n\n          var params = {};\n          var autoPush = data.autoPush;\n          if (autoPush !== undefined) {\n            if (typeof autoPush === 'function') {\n              try {\n                params.autoPush = !!autoPush();\n              }\n              catch (e) {\n                return Q.reject(new AuthSdkError('AutoPush resulted in an error.'));\n              }\n            }\n            else if (autoPush !== null) {\n              params.autoPush = !!autoPush;\n            }\n            data = util.omit(data, 'autoPush');\n          }\n\n          var rememberDevice = data.rememberDevice;\n          if (rememberDevice !== undefined) {\n            if (typeof rememberDevice === 'function') {\n              try {\n                params.rememberDevice = !!rememberDevice();\n              }\n              catch (e) {\n                return Q.reject(new AuthSdkError('RememberDevice resulted in an error.'));\n              }\n            }\n            else if (rememberDevice !== null) {\n              params.rememberDevice = !!rememberDevice;\n            }\n            data = util.omit(data, 'rememberDevice');\n\n          } else if (data.profile &&\n                    data.profile.updatePhone !== undefined) {\n            if (data.profile.updatePhone) {\n              params.updatePhone = true;\n            }\n            data.profile = util.omit(data.profile, 'updatePhone');\n          }\n          var href = link.href + util.toQueryParams(params);\n          return postToTransaction(sdk, href, data);\n        };\n    }\n  }\n}\n\nfunction links2fns(sdk, res, obj, ref) {\n  var fns = {};\n  for (var linkName in obj._links) {\n    if (!obj._links.hasOwnProperty(linkName)) {\n      continue;\n    }\n\n    var link = obj._links[linkName];\n    \n    if (linkName === 'next') {\n      linkName = link.name;\n    }\n\n    if (link.type) {\n      fns[linkName] = link;\n      continue;\n    }\n\n    switch (linkName) {\n      // poll is only found at the transaction\n      // level, so we don't need to pass the link\n      case 'poll':\n        fns.poll = getPollFn(sdk, res, ref);\n        break;\n\n      default:\n        var fn = link2fn(sdk, res, obj, link, ref);\n        if (fn) {\n          fns[linkName] = fn;\n        }\n    }\n  }\n  return fns;\n}\n\nfunction flattenEmbedded(sdk, res, obj, ref) {\n  obj = obj || res;\n  obj = util.clone(obj);\n\n  if (Array.isArray(obj)) {\n    var objArr = [];\n    for (var o = 0, ol = obj.length; o < ol; o++) {\n      objArr.push(flattenEmbedded(sdk, res, obj[o], ref));\n    }\n    return objArr;\n  }\n\n  var embedded = obj._embedded || {};\n\n  for (var key in embedded) {\n    if (!embedded.hasOwnProperty(key)) {\n      continue;\n    }\n\n    // Flatten any nested _embedded objects\n    if (util.isObject(embedded[key]) || Array.isArray(embedded[key])) {\n      embedded[key] = flattenEmbedded(sdk, res, embedded[key], ref);\n    }\n  }\n\n  // Convert any links on the embedded object\n  var fns = links2fns(sdk, res, obj, ref);\n  util.extend(embedded, fns);\n\n  obj = util.omit(obj, '_embedded', '_links');\n  util.extend(obj, embedded);\n  return obj;\n}\n\nfunction AuthTransaction(sdk, res) {\n  if (res) {\n    this.data = res;\n    util.extend(this, flattenEmbedded(sdk, res, res, {}));\n    delete this.stateToken;\n\n    // RECOVERY_CHALLENGE has some responses without _links.\n    // Without _links, we emulate cancel to make it intuitive\n    // to return to the starting state. We may remove this\n    // when OKTA-75434 is resolved\n    if (res.status === 'RECOVERY_CHALLENGE' && !res._links) {\n      this.cancel = function() {\n        return new Q(new AuthTransaction(sdk));\n      };\n    }\n  }\n}\n\nmodule.exports = {\n  transactionStatus: transactionStatus,\n  resumeTransaction: resumeTransaction,\n  transactionExists: transactionExists,\n  postToTransaction: postToTransaction,\n  introspect: introspect,\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./lib/tx.js\n// module id = 7\n// module chunks = 0","// shim for using process in browser\nvar process = module.exports = {};\n\n// cached from whatever global is present so that test runners that stub it\n// don't break things.  But we need to wrap it in a try catch in case it is\n// wrapped in strict mode code which doesn't define any globals.  It's inside a\n// function because try/catches deoptimize in certain engines.\n\nvar cachedSetTimeout;\nvar cachedClearTimeout;\n\nfunction defaultSetTimout() {\n    throw new Error('setTimeout has not been defined');\n}\nfunction defaultClearTimeout () {\n    throw new Error('clearTimeout has not been defined');\n}\n(function () {\n    try {\n        if (typeof setTimeout === 'function') {\n            cachedSetTimeout = setTimeout;\n        } else {\n            cachedSetTimeout = defaultSetTimout;\n        }\n    } catch (e) {\n        cachedSetTimeout = defaultSetTimout;\n    }\n    try {\n        if (typeof clearTimeout === 'function') {\n            cachedClearTimeout = clearTimeout;\n        } else {\n            cachedClearTimeout = defaultClearTimeout;\n        }\n    } catch (e) {\n        cachedClearTimeout = defaultClearTimeout;\n    }\n} ())\nfunction runTimeout(fun) {\n    if (cachedSetTimeout === setTimeout) {\n        //normal enviroments in sane situations\n        return setTimeout(fun, 0);\n    }\n    // if setTimeout wasn't available but was latter defined\n    if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {\n        cachedSetTimeout = setTimeout;\n        return setTimeout(fun, 0);\n    }\n    try {\n        // when when somebody has screwed with setTimeout but no I.E. maddness\n        return cachedSetTimeout(fun, 0);\n    } catch(e){\n        try {\n            // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally\n            return cachedSetTimeout.call(null, fun, 0);\n        } catch(e){\n            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error\n            return cachedSetTimeout.call(this, fun, 0);\n        }\n    }\n\n\n}\nfunction runClearTimeout(marker) {\n    if (cachedClearTimeout === clearTimeout) {\n        //normal enviroments in sane situations\n        return clearTimeout(marker);\n    }\n    // if clearTimeout wasn't available but was latter defined\n    if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {\n        cachedClearTimeout = clearTimeout;\n        return clearTimeout(marker);\n    }\n    try {\n        // when when somebody has screwed with setTimeout but no I.E. maddness\n        return cachedClearTimeout(marker);\n    } catch (e){\n        try {\n            // When we are in I.E. but the script has been evaled so I.E. doesn't  trust the global object when called normally\n            return cachedClearTimeout.call(null, marker);\n        } catch (e){\n            // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.\n            // Some versions of I.E. have different rules for clearTimeout vs setTimeout\n            return cachedClearTimeout.call(this, marker);\n        }\n    }\n\n\n\n}\nvar queue = [];\nvar draining = false;\nvar currentQueue;\nvar queueIndex = -1;\n\nfunction cleanUpNextTick() {\n    if (!draining || !currentQueue) {\n        return;\n    }\n    draining = false;\n    if (currentQueue.length) {\n        queue = currentQueue.concat(queue);\n    } else {\n        queueIndex = -1;\n    }\n    if (queue.length) {\n        drainQueue();\n    }\n}\n\nfunction drainQueue() {\n    if (draining) {\n        return;\n    }\n    var timeout = runTimeout(cleanUpNextTick);\n    draining = true;\n\n    var len = queue.length;\n    while(len) {\n        currentQueue = queue;\n        queue = [];\n        while (++queueIndex < len) {\n            if (currentQueue) {\n                currentQueue[queueIndex].run();\n            }\n        }\n        queueIndex = -1;\n        len = queue.length;\n    }\n    currentQueue = null;\n    draining = false;\n    runClearTimeout(timeout);\n}\n\nprocess.nextTick = function (fun) {\n    var args = new Array(arguments.length - 1);\n    if (arguments.length > 1) {\n        for (var i = 1; i < arguments.length; i++) {\n            args[i - 1] = arguments[i];\n        }\n    }\n    queue.push(new Item(fun, args));\n    if (queue.length === 1 && !draining) {\n        runTimeout(drainQueue);\n    }\n};\n\n// v8 likes predictible objects\nfunction Item(fun, array) {\n    this.fun = fun;\n    this.array = array;\n}\nItem.prototype.run = function () {\n    this.fun.apply(null, this.array);\n};\nprocess.title = 'browser';\nprocess.browser = true;\nprocess.env = {};\nprocess.argv = [];\nprocess.version = ''; // empty string to avoid regexp issues\nprocess.versions = {};\n\nfunction noop() {}\n\nprocess.on = noop;\nprocess.addListener = noop;\nprocess.once = noop;\nprocess.off = noop;\nprocess.removeListener = noop;\nprocess.removeAllListeners = noop;\nprocess.emit = noop;\nprocess.prependListener = noop;\nprocess.prependOnceListener = noop;\n\nprocess.listeners = function (name) { return [] }\n\nprocess.binding = function (name) {\n    throw new Error('process.binding is not supported');\n};\n\nprocess.cwd = function () { return '/' };\nprocess.chdir = function (dir) {\n    throw new Error('process.chdir is not supported');\n};\nprocess.umask = function() { return 0; };\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// /root/okta/okta-auth-js/node_modules/process/browser.js\n// module id = 8\n// module chunks = 0","var g;\r\n\r\n// This works in non-strict mode\r\ng = (function() {\r\n\treturn this;\r\n})();\r\n\r\ntry {\r\n\t// This works if eval is allowed (see CSP)\r\n\tg = g || Function(\"return this\")() || (1,eval)(\"this\");\r\n} catch(e) {\r\n\t// This works if the window reference is available\r\n\tif(typeof window === \"object\")\r\n\t\tg = window;\r\n}\r\n\r\n// g can still be undefined, but nothing to do about it...\r\n// We return undefined, instead of nothing here, so it's\r\n// easier to handle this case. if(!global) { ...}\r\n\r\nmodule.exports = g;\r\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// (webpack)/buildin/global.js\n// module id = 9\n// module chunks = 0","/*!\n * Copyright (c) 2015-present, Okta, Inc. and/or its affiliates. All rights reserved.\n * The Okta software accompanied by this notice is provided pursuant to the Apache License, Version 2.0 (the \"License.\")\n *\n * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0.\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS, WITHOUT\n * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n *\n * See the License for the specific language governing permissions and limitations under the License.\n *\n */\n\n/* eslint-disable complexity, max-statements */\nvar http = require('./http');\nvar util = require('./util');\nvar storageUtil = require('./browser/browserStorage');\nvar AuthSdkError = require('./errors/AuthSdkError');\n\nvar httpCache = storageUtil.getHttpCache();\n\nfunction generateState() {\n  return util.genRandomString(64);\n}\n\nfunction generateNonce() {\n  return util.genRandomString(64);\n}\n\nfunction isToken(obj) {\n  if (obj &&\n      (obj.accessToken || obj.idToken) &&\n      Array.isArray(obj.scopes)) {\n    return true;\n  }\n  return false;\n}\n\nfunction addListener(eventTarget, name, fn) {\n  if (eventTarget.addEventListener) {\n    eventTarget.addEventListener(name, fn);\n  } else {\n    eventTarget.attachEvent('on' + name, fn);\n  }\n}\n\nfunction removeListener(eventTarget, name, fn) {\n  if (eventTarget.removeEventListener) {\n    eventTarget.removeEventListener(name, fn);\n  } else {\n    eventTarget.detachEvent('on' + name, fn);\n  }\n}\n\nfunction loadFrame(src) {\n  var iframe = document.createElement('iframe');\n  iframe.style.display = 'none';\n  iframe.src = src;\n\n  return document.body.appendChild(iframe);\n}\n\nfunction loadPopup(src, options) {\n  var title = options.popupTitle || 'External Identity Provider User Authentication';\n  var appearance = 'toolbar=no, scrollbars=yes, resizable=yes, ' +\n    'top=100, left=500, width=600, height=600';\n\n  if (util.isIE11OrLess()) {\n    // IE<=11 doesn't fully support postMessage at time of writting.\n    // the following simple solution happened to solve the issue\n    // without adding another proxy layer which makes flow more complecated.\n    var winEl = window.open('/', title, appearance);\n    winEl.location.href = src;\n    return winEl;\n  } else {\n    return window.open(src, title, appearance);\n  }\n}\n\nfunction getWellKnown(sdk, issuer) {\n  var authServerUri = (issuer || sdk.options.issuer || sdk.options.url);\n  return http.get(sdk, authServerUri + '/.well-known/openid-configuration', {\n    cacheResponse: true\n  });\n}\n\nfunction getKey(sdk, issuer, kid) {\n  return getWellKnown(sdk, issuer)\n  .then(function(wellKnown) {\n    var jwksUri = wellKnown['jwks_uri'];\n\n    // Check our kid against the cached version (if it exists and isn't expired)\n    var cacheContents = httpCache.getStorage();\n    var cachedResponse = cacheContents[jwksUri];\n    if (cachedResponse && Date.now()/1000 < cachedResponse.expiresAt) {\n      var cachedKey = util.find(cachedResponse.response.keys, {\n        kid: kid\n      });\n\n      if (cachedKey) {\n        return cachedKey;\n      }\n    }\n\n    // Remove cache for the key\n    httpCache.clearStorage(jwksUri);\n\n    // Pull the latest keys if the key wasn't in the cache\n    return http.get(sdk, jwksUri, {\n      cacheResponse: true\n    })\n    .then(function(res) {\n      var key = util.find(res.keys, {\n        kid: kid\n      });\n\n      if (key) {\n        return key;\n      }\n\n      throw new AuthSdkError('The key id, ' + kid + ', was not found in the server\\'s keys');\n    });\n  });\n}\n\nfunction validateClaims(sdk, claims, validationParams) {\n  var aud = validationParams.clientId;\n  var iss = validationParams.issuer;\n  var nonce = validationParams.nonce;\n\n  if (!claims || !iss || !aud) {\n    throw new AuthSdkError('The jwt, iss, and aud arguments are all required');\n  }\n\n  if (nonce && claims.nonce !== nonce) {\n    throw new AuthSdkError('OAuth flow response nonce doesn\\'t match request nonce');\n  }\n\n  var now = Math.floor(Date.now()/1000);\n\n  if (claims.iss !== iss) {\n    throw new AuthSdkError('The issuer [' + claims.iss + '] ' +\n      'does not match [' + iss + ']');\n  }\n\n  if (claims.aud !== aud) {\n    throw new AuthSdkError('The audience [' + claims.aud + '] ' +\n      'does not match [' + aud + ']');\n  }\n\n  if (claims.iat > claims.exp) {\n    throw new AuthSdkError('The JWT expired before it was issued');\n  }\n\n  if ((now - sdk.options.maxClockSkew) > claims.exp) {\n    throw new AuthSdkError('The JWT expired and is no longer valid');\n  }\n\n  if (claims.iat > (now + sdk.options.maxClockSkew)) {\n    throw new AuthSdkError('The JWT was issued in the future');\n  }\n}\n\nfunction getOAuthUrls(sdk, oauthParams, options) {\n  options = options || {};\n\n  // Get user-supplied arguments\n  var authorizeUrl = util.removeTrailingSlash(options.authorizeUrl) || sdk.options.authorizeUrl;\n  var issuer = util.removeTrailingSlash(options.issuer) || sdk.options.issuer;\n  var userinfoUrl = util.removeTrailingSlash(options.userinfoUrl) || sdk.options.userinfoUrl;\n  var tokenUrl = util.removeTrailingSlash(options.tokenUrl) || sdk.options.tokenUrl;\n  var logoutUrl = util.removeTrailingSlash(options.logoutUrl) || sdk.options.logoutUrl;\n  var revokeUrl = util.removeTrailingSlash(options.revokeUrl) || sdk.options.revokeUrl;\n\n  // If an issuer exists but it's not a url, assume it's an authServerId\n  if (issuer && !(/^https?:/.test(issuer))) {\n    // Make it a url\n    issuer = sdk.options.url + '/oauth2/' + issuer;\n  }\n\n  // If an authorizeUrl is supplied without an issuer, and an id_token is requested\n  if (!issuer && authorizeUrl &&\n      oauthParams.responseType.indexOf('id_token') !== -1) {\n    // The issuer is ambiguous, so we won't be able to validate the id_token jwt\n    throw new AuthSdkError('Cannot request idToken with an authorizeUrl without an issuer');\n  }\n\n  // If a token is requested without an issuer\n  if (!issuer && oauthParams && oauthParams.responseType.indexOf('token') !== -1) {\n    // If an authorizeUrl is supplied without a userinfoUrl\n    if (authorizeUrl && !userinfoUrl) {\n      // The userinfoUrl is ambiguous, so we won't be able to call getUserInfo\n      throw new AuthSdkError('Cannot request accessToken with an authorizeUrl without an issuer or userinfoUrl');\n    }\n\n    // If a userinfoUrl is supplied without a authorizeUrl\n    if (userinfoUrl && !authorizeUrl) {\n      // The authorizeUrl is ambiguous, so we won't be able to call the authorize endpoint\n      throw new AuthSdkError('Cannot request token with an userinfoUrl without an issuer or authorizeUrl');\n    }\n  }\n\n  // Default the issuer to our baseUrl\n  issuer = issuer || sdk.options.url;\n\n  // Trim trailing slashes\n  issuer = util.removeTrailingSlash(issuer);\n\n  var baseUrl = issuer;\n  // A custom auth server issuer looks like:\n  // https://example.okta.com/oauth2/aus8aus76q8iphupD0h7\n  // \n  // Most orgs have a \"default\" custom authorization server:\n  // https://example.okta.com/oauth2/default\n  var customAuthServerRegex = new RegExp('^https?://.*?/oauth2/.+');\n  if (!customAuthServerRegex.test(baseUrl)) {\n    // Append '/oauth2' if necessary\n    if (!baseUrl.endsWith('/oauth2')) {\n      baseUrl += '/oauth2';\n    }\n  }\n\n  authorizeUrl = authorizeUrl || baseUrl + '/v1/authorize';\n  userinfoUrl = userinfoUrl || baseUrl + '/v1/userinfo';\n  tokenUrl = tokenUrl || baseUrl + '/v1/token';\n  revokeUrl = revokeUrl || baseUrl + '/v1/revoke';\n  logoutUrl = logoutUrl || baseUrl + '/v1/logout';\n\n  return {\n    issuer: issuer,\n    authorizeUrl: authorizeUrl,\n    userinfoUrl: userinfoUrl,\n    tokenUrl: tokenUrl,\n    revokeUrl: revokeUrl,\n    logoutUrl: logoutUrl\n  };\n}\n\nfunction urlParamsToObject(hashOrSearch) {\n  // Predefine regexs for parsing hash\n  var plus2space = /\\+/g;\n  var paramSplit = /([^&=]+)=?([^&]*)/g;\n\n  // Remove the leading # or ?\n  var fragment = hashOrSearch.substring(1);\n\n  var obj = {};\n\n  // Loop until we have no more params\n  var param;\n  while (true) { // eslint-disable-line no-constant-condition\n    param = paramSplit.exec(fragment);\n    if (!param) { break; }\n\n    var key = param[1];\n    var value = param[2];\n\n    // id_token should remain base64url encoded\n    if (key === 'id_token' || key === 'access_token' || key === 'code') {\n      obj[key] = value;\n    } else {\n      obj[key] = decodeURIComponent(value.replace(plus2space, ' '));\n    }\n  }\n  return obj;\n}\n\nmodule.exports = {\n  generateState: generateState,\n  generateNonce: generateNonce,\n  getWellKnown: getWellKnown,\n  getKey: getKey,\n  validateClaims: validateClaims,\n  getOAuthUrls: getOAuthUrls,\n  loadFrame: loadFrame,\n  loadPopup: loadPopup,\n  urlParamsToObject: urlParamsToObject,\n  isToken: isToken,\n  addListener: addListener,\n  removeListener: removeListener\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./lib/oauthUtil.js\n// module id = 10\n// module chunks = 0","/*!\n * Copyright (c) 2015-present, Okta, Inc. and/or its affiliates. All rights reserved.\n * The Okta software accompanied by this notice is provided pursuant to the Apache License, Version 2.0 (the \"License.\")\n *\n * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0.\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS, WITHOUT\n * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n *\n * See the License for the specific language governing permissions and limitations under the License.\n *\n */\n\nvar fetchRequest = require('../../fetch/fetchRequest');\nvar storageUtil = require('./browserStorage');\n\nmodule.exports = require('./browser')(storageUtil, fetchRequest);\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./lib/browser/browserIndex.js\n// module id = 11\n// module chunks = 0","/*!\n * Copyright (c) 2018-present, Okta, Inc. and/or its affiliates. All rights reserved.\n * The Okta software accompanied by this notice is provided pursuant to the Apache License, Version 2.0 (the \"License.\")\n *\n * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0.\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS, WITHOUT\n * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n *\n * See the License for the specific language governing permissions and limitations under the License.\n */\n\nvar fetch = require('cross-fetch');\n\n/* eslint-disable complexity */\nfunction fetchRequest(method, url, args) {\n  var body = args.data;\n  var headers = args.headers || {};\n  var contentType = (headers['Content-Type'] || headers['content-type'] || '');\n\n  // JSON encode body (if appropriate)\n  if (contentType === 'application/json' && body && typeof body !== 'string') {\n    body = JSON.stringify(body);\n  }\n\n  var fetchPromise = fetch(url, {\n    method: method,\n    headers: args.headers,\n    body: body,\n    credentials: args.withCredentials === false ? 'omit' : 'include'\n  })\n  .then(function(response) {\n    var error = !response.ok;\n    var status = response.status;\n    var respHandler = function(resp) {\n      var result = {\n        responseText: resp,\n        status: status\n      };\n      if (error) {\n        // Throwing response object since error handling is done in http.js\n        throw result;\n      }\n      return result;\n    };\n    if (response.headers.get('Content-Type') &&\n        response.headers.get('Content-Type').toLowerCase().indexOf('application/json') >= 0) {\n      return response.json().then(respHandler);\n    } else {\n      return response.text().then(respHandler);\n    }\n  });\n  return fetchPromise;\n}\n\nmodule.exports = fetchRequest;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./fetch/fetchRequest.js\n// module id = 12\n// module chunks = 0","var __self__ = (function (root) {\nfunction F() {\nthis.fetch = false;\nthis.DOMException = root.DOMException\n}\nF.prototype = root;\nreturn new F();\n})(typeof self !== 'undefined' ? self : this);\n(function(self) {\n\nvar irrelevant = (function (exports) {\n  var support = {\n    searchParams: 'URLSearchParams' in self,\n    iterable: 'Symbol' in self && 'iterator' in Symbol,\n    blob:\n      'FileReader' in self &&\n      'Blob' in self &&\n      (function() {\n        try {\n          new Blob();\n          return true\n        } catch (e) {\n          return false\n        }\n      })(),\n    formData: 'FormData' in self,\n    arrayBuffer: 'ArrayBuffer' in self\n  };\n\n  function isDataView(obj) {\n    return obj && DataView.prototype.isPrototypeOf(obj)\n  }\n\n  if (support.arrayBuffer) {\n    var viewClasses = [\n      '[object Int8Array]',\n      '[object Uint8Array]',\n      '[object Uint8ClampedArray]',\n      '[object Int16Array]',\n      '[object Uint16Array]',\n      '[object Int32Array]',\n      '[object Uint32Array]',\n      '[object Float32Array]',\n      '[object Float64Array]'\n    ];\n\n    var isArrayBufferView =\n      ArrayBuffer.isView ||\n      function(obj) {\n        return obj && viewClasses.indexOf(Object.prototype.toString.call(obj)) > -1\n      };\n  }\n\n  function normalizeName(name) {\n    if (typeof name !== 'string') {\n      name = String(name);\n    }\n    if (/[^a-z0-9\\-#$%&'*+.^_`|~]/i.test(name)) {\n      throw new TypeError('Invalid character in header field name')\n    }\n    return name.toLowerCase()\n  }\n\n  function normalizeValue(value) {\n    if (typeof value !== 'string') {\n      value = String(value);\n    }\n    return value\n  }\n\n  // Build a destructive iterator for the value list\n  function iteratorFor(items) {\n    var iterator = {\n      next: function() {\n        var value = items.shift();\n        return {done: value === undefined, value: value}\n      }\n    };\n\n    if (support.iterable) {\n      iterator[Symbol.iterator] = function() {\n        return iterator\n      };\n    }\n\n    return iterator\n  }\n\n  function Headers(headers) {\n    this.map = {};\n\n    if (headers instanceof Headers) {\n      headers.forEach(function(value, name) {\n        this.append(name, value);\n      }, this);\n    } else if (Array.isArray(headers)) {\n      headers.forEach(function(header) {\n        this.append(header[0], header[1]);\n      }, this);\n    } else if (headers) {\n      Object.getOwnPropertyNames(headers).forEach(function(name) {\n        this.append(name, headers[name]);\n      }, this);\n    }\n  }\n\n  Headers.prototype.append = function(name, value) {\n    name = normalizeName(name);\n    value = normalizeValue(value);\n    var oldValue = this.map[name];\n    this.map[name] = oldValue ? oldValue + ', ' + value : value;\n  };\n\n  Headers.prototype['delete'] = function(name) {\n    delete this.map[normalizeName(name)];\n  };\n\n  Headers.prototype.get = function(name) {\n    name = normalizeName(name);\n    return this.has(name) ? this.map[name] : null\n  };\n\n  Headers.prototype.has = function(name) {\n    return this.map.hasOwnProperty(normalizeName(name))\n  };\n\n  Headers.prototype.set = function(name, value) {\n    this.map[normalizeName(name)] = normalizeValue(value);\n  };\n\n  Headers.prototype.forEach = function(callback, thisArg) {\n    for (var name in this.map) {\n      if (this.map.hasOwnProperty(name)) {\n        callback.call(thisArg, this.map[name], name, this);\n      }\n    }\n  };\n\n  Headers.prototype.keys = function() {\n    var items = [];\n    this.forEach(function(value, name) {\n      items.push(name);\n    });\n    return iteratorFor(items)\n  };\n\n  Headers.prototype.values = function() {\n    var items = [];\n    this.forEach(function(value) {\n      items.push(value);\n    });\n    return iteratorFor(items)\n  };\n\n  Headers.prototype.entries = function() {\n    var items = [];\n    this.forEach(function(value, name) {\n      items.push([name, value]);\n    });\n    return iteratorFor(items)\n  };\n\n  if (support.iterable) {\n    Headers.prototype[Symbol.iterator] = Headers.prototype.entries;\n  }\n\n  function consumed(body) {\n    if (body.bodyUsed) {\n      return Promise.reject(new TypeError('Already read'))\n    }\n    body.bodyUsed = true;\n  }\n\n  function fileReaderReady(reader) {\n    return new Promise(function(resolve, reject) {\n      reader.onload = function() {\n        resolve(reader.result);\n      };\n      reader.onerror = function() {\n        reject(reader.error);\n      };\n    })\n  }\n\n  function readBlobAsArrayBuffer(blob) {\n    var reader = new FileReader();\n    var promise = fileReaderReady(reader);\n    reader.readAsArrayBuffer(blob);\n    return promise\n  }\n\n  function readBlobAsText(blob) {\n    var reader = new FileReader();\n    var promise = fileReaderReady(reader);\n    reader.readAsText(blob);\n    return promise\n  }\n\n  function readArrayBufferAsText(buf) {\n    var view = new Uint8Array(buf);\n    var chars = new Array(view.length);\n\n    for (var i = 0; i < view.length; i++) {\n      chars[i] = String.fromCharCode(view[i]);\n    }\n    return chars.join('')\n  }\n\n  function bufferClone(buf) {\n    if (buf.slice) {\n      return buf.slice(0)\n    } else {\n      var view = new Uint8Array(buf.byteLength);\n      view.set(new Uint8Array(buf));\n      return view.buffer\n    }\n  }\n\n  function Body() {\n    this.bodyUsed = false;\n\n    this._initBody = function(body) {\n      this._bodyInit = body;\n      if (!body) {\n        this._bodyText = '';\n      } else if (typeof body === 'string') {\n        this._bodyText = body;\n      } else if (support.blob && Blob.prototype.isPrototypeOf(body)) {\n        this._bodyBlob = body;\n      } else if (support.formData && FormData.prototype.isPrototypeOf(body)) {\n        this._bodyFormData = body;\n      } else if (support.searchParams && URLSearchParams.prototype.isPrototypeOf(body)) {\n        this._bodyText = body.toString();\n      } else if (support.arrayBuffer && support.blob && isDataView(body)) {\n        this._bodyArrayBuffer = bufferClone(body.buffer);\n        // IE 10-11 can't handle a DataView body.\n        this._bodyInit = new Blob([this._bodyArrayBuffer]);\n      } else if (support.arrayBuffer && (ArrayBuffer.prototype.isPrototypeOf(body) || isArrayBufferView(body))) {\n        this._bodyArrayBuffer = bufferClone(body);\n      } else {\n        this._bodyText = body = Object.prototype.toString.call(body);\n      }\n\n      if (!this.headers.get('content-type')) {\n        if (typeof body === 'string') {\n          this.headers.set('content-type', 'text/plain;charset=UTF-8');\n        } else if (this._bodyBlob && this._bodyBlob.type) {\n          this.headers.set('content-type', this._bodyBlob.type);\n        } else if (support.searchParams && URLSearchParams.prototype.isPrototypeOf(body)) {\n          this.headers.set('content-type', 'application/x-www-form-urlencoded;charset=UTF-8');\n        }\n      }\n    };\n\n    if (support.blob) {\n      this.blob = function() {\n        var rejected = consumed(this);\n        if (rejected) {\n          return rejected\n        }\n\n        if (this._bodyBlob) {\n          return Promise.resolve(this._bodyBlob)\n        } else if (this._bodyArrayBuffer) {\n          return Promise.resolve(new Blob([this._bodyArrayBuffer]))\n        } else if (this._bodyFormData) {\n          throw new Error('could not read FormData body as blob')\n        } else {\n          return Promise.resolve(new Blob([this._bodyText]))\n        }\n      };\n\n      this.arrayBuffer = function() {\n        if (this._bodyArrayBuffer) {\n          return consumed(this) || Promise.resolve(this._bodyArrayBuffer)\n        } else {\n          return this.blob().then(readBlobAsArrayBuffer)\n        }\n      };\n    }\n\n    this.text = function() {\n      var rejected = consumed(this);\n      if (rejected) {\n        return rejected\n      }\n\n      if (this._bodyBlob) {\n        return readBlobAsText(this._bodyBlob)\n      } else if (this._bodyArrayBuffer) {\n        return Promise.resolve(readArrayBufferAsText(this._bodyArrayBuffer))\n      } else if (this._bodyFormData) {\n        throw new Error('could not read FormData body as text')\n      } else {\n        return Promise.resolve(this._bodyText)\n      }\n    };\n\n    if (support.formData) {\n      this.formData = function() {\n        return this.text().then(decode)\n      };\n    }\n\n    this.json = function() {\n      return this.text().then(JSON.parse)\n    };\n\n    return this\n  }\n\n  // HTTP methods whose capitalization should be normalized\n  var methods = ['DELETE', 'GET', 'HEAD', 'OPTIONS', 'POST', 'PUT'];\n\n  function normalizeMethod(method) {\n    var upcased = method.toUpperCase();\n    return methods.indexOf(upcased) > -1 ? upcased : method\n  }\n\n  function Request(input, options) {\n    options = options || {};\n    var body = options.body;\n\n    if (input instanceof Request) {\n      if (input.bodyUsed) {\n        throw new TypeError('Already read')\n      }\n      this.url = input.url;\n      this.credentials = input.credentials;\n      if (!options.headers) {\n        this.headers = new Headers(input.headers);\n      }\n      this.method = input.method;\n      this.mode = input.mode;\n      this.signal = input.signal;\n      if (!body && input._bodyInit != null) {\n        body = input._bodyInit;\n        input.bodyUsed = true;\n      }\n    } else {\n      this.url = String(input);\n    }\n\n    this.credentials = options.credentials || this.credentials || 'same-origin';\n    if (options.headers || !this.headers) {\n      this.headers = new Headers(options.headers);\n    }\n    this.method = normalizeMethod(options.method || this.method || 'GET');\n    this.mode = options.mode || this.mode || null;\n    this.signal = options.signal || this.signal;\n    this.referrer = null;\n\n    if ((this.method === 'GET' || this.method === 'HEAD') && body) {\n      throw new TypeError('Body not allowed for GET or HEAD requests')\n    }\n    this._initBody(body);\n  }\n\n  Request.prototype.clone = function() {\n    return new Request(this, {body: this._bodyInit})\n  };\n\n  function decode(body) {\n    var form = new FormData();\n    body\n      .trim()\n      .split('&')\n      .forEach(function(bytes) {\n        if (bytes) {\n          var split = bytes.split('=');\n          var name = split.shift().replace(/\\+/g, ' ');\n          var value = split.join('=').replace(/\\+/g, ' ');\n          form.append(decodeURIComponent(name), decodeURIComponent(value));\n        }\n      });\n    return form\n  }\n\n  function parseHeaders(rawHeaders) {\n    var headers = new Headers();\n    // Replace instances of \\r\\n and \\n followed by at least one space or horizontal tab with a space\n    // https://tools.ietf.org/html/rfc7230#section-3.2\n    var preProcessedHeaders = rawHeaders.replace(/\\r?\\n[\\t ]+/g, ' ');\n    preProcessedHeaders.split(/\\r?\\n/).forEach(function(line) {\n      var parts = line.split(':');\n      var key = parts.shift().trim();\n      if (key) {\n        var value = parts.join(':').trim();\n        headers.append(key, value);\n      }\n    });\n    return headers\n  }\n\n  Body.call(Request.prototype);\n\n  function Response(bodyInit, options) {\n    if (!options) {\n      options = {};\n    }\n\n    this.type = 'default';\n    this.status = options.status === undefined ? 200 : options.status;\n    this.ok = this.status >= 200 && this.status < 300;\n    this.statusText = 'statusText' in options ? options.statusText : 'OK';\n    this.headers = new Headers(options.headers);\n    this.url = options.url || '';\n    this._initBody(bodyInit);\n  }\n\n  Body.call(Response.prototype);\n\n  Response.prototype.clone = function() {\n    return new Response(this._bodyInit, {\n      status: this.status,\n      statusText: this.statusText,\n      headers: new Headers(this.headers),\n      url: this.url\n    })\n  };\n\n  Response.error = function() {\n    var response = new Response(null, {status: 0, statusText: ''});\n    response.type = 'error';\n    return response\n  };\n\n  var redirectStatuses = [301, 302, 303, 307, 308];\n\n  Response.redirect = function(url, status) {\n    if (redirectStatuses.indexOf(status) === -1) {\n      throw new RangeError('Invalid status code')\n    }\n\n    return new Response(null, {status: status, headers: {location: url}})\n  };\n\n  exports.DOMException = self.DOMException;\n  try {\n    new exports.DOMException();\n  } catch (err) {\n    exports.DOMException = function(message, name) {\n      this.message = message;\n      this.name = name;\n      var error = Error(message);\n      this.stack = error.stack;\n    };\n    exports.DOMException.prototype = Object.create(Error.prototype);\n    exports.DOMException.prototype.constructor = exports.DOMException;\n  }\n\n  function fetch(input, init) {\n    return new Promise(function(resolve, reject) {\n      var request = new Request(input, init);\n\n      if (request.signal && request.signal.aborted) {\n        return reject(new exports.DOMException('Aborted', 'AbortError'))\n      }\n\n      var xhr = new XMLHttpRequest();\n\n      function abortXhr() {\n        xhr.abort();\n      }\n\n      xhr.onload = function() {\n        var options = {\n          status: xhr.status,\n          statusText: xhr.statusText,\n          headers: parseHeaders(xhr.getAllResponseHeaders() || '')\n        };\n        options.url = 'responseURL' in xhr ? xhr.responseURL : options.headers.get('X-Request-URL');\n        var body = 'response' in xhr ? xhr.response : xhr.responseText;\n        resolve(new Response(body, options));\n      };\n\n      xhr.onerror = function() {\n        reject(new TypeError('Network request failed'));\n      };\n\n      xhr.ontimeout = function() {\n        reject(new TypeError('Network request failed'));\n      };\n\n      xhr.onabort = function() {\n        reject(new exports.DOMException('Aborted', 'AbortError'));\n      };\n\n      xhr.open(request.method, request.url, true);\n\n      if (request.credentials === 'include') {\n        xhr.withCredentials = true;\n      } else if (request.credentials === 'omit') {\n        xhr.withCredentials = false;\n      }\n\n      if ('responseType' in xhr && support.blob) {\n        xhr.responseType = 'blob';\n      }\n\n      request.headers.forEach(function(value, name) {\n        xhr.setRequestHeader(name, value);\n      });\n\n      if (request.signal) {\n        request.signal.addEventListener('abort', abortXhr);\n\n        xhr.onreadystatechange = function() {\n          // DONE (success or failure)\n          if (xhr.readyState === 4) {\n            request.signal.removeEventListener('abort', abortXhr);\n          }\n        };\n      }\n\n      xhr.send(typeof request._bodyInit === 'undefined' ? null : request._bodyInit);\n    })\n  }\n\n  fetch.polyfill = true;\n\n  if (!self.fetch) {\n    self.fetch = fetch;\n    self.Headers = Headers;\n    self.Request = Request;\n    self.Response = Response;\n  }\n\n  exports.Headers = Headers;\n  exports.Request = Request;\n  exports.Response = Response;\n  exports.fetch = fetch;\n\n  return exports;\n\n}({}));\n})(__self__);\ndelete __self__.fetch.polyfill\nexports = __self__.fetch // To enable: import fetch from 'cross-fetch'\nexports.default = __self__.fetch // For TypeScript consumers without esModuleInterop.\nexports.fetch = __self__.fetch // To enable: import {fetch} from 'cross-fetch'\nexports.Headers = __self__.Headers\nexports.Request = __self__.Request\nexports.Response = __self__.Response\nmodule.exports = exports\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// /root/okta/okta-auth-js/node_modules/cross-fetch/dist/browser-ponyfill.js\n// module id = 13\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// /root/okta/okta-auth-js/node_modules/js-cookie/src/js.cookie.js\n// module id = 14\n// module chunks = 0","/*!\n * Copyright (c) 2015-present, Okta, Inc. and/or its affiliates. All rights reserved.\n * The Okta software accompanied by this notice is provided pursuant to the Apache License, Version 2.0 (the \"License.\")\n *\n * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0.\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS, WITHOUT\n * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n *\n * See the License for the specific language governing permissions and limitations under the License.\n */\n/* eslint-disable complexity */\n/* eslint-disable max-statements */\n/* SDK_VERSION is defined in webpack config */ \n/* global SDK_VERSION */\n\nrequire('../vendor/polyfills');\n\nvar Emitter           = require('tiny-emitter');\nvar AuthSdkError      = require('../errors/AuthSdkError');\nvar builderUtil       = require('../builderUtil');\nvar constants         = require('../constants');\nvar cookies           = require('./browserStorage').storage;\nvar http              = require('../http');\nvar oauthUtil         = require('../oauthUtil');\nvar Q                 = require('q');\nvar session           = require('../session');\nvar token             = require('../token');\nvar TokenManager      = require('../TokenManager');\nvar tx                = require('../tx');\nvar util              = require('../util');\n\nfunction OktaAuthBuilder(args) {\n  var sdk = this;\n\n  var url = builderUtil.getValidUrl(args);\n  // OKTA-242989: support for grantType will be removed in 3.0 \n  var usePKCE = args.pkce || args.grantType === 'authorization_code';\n  this.options = {\n    url: util.removeTrailingSlash(url),\n    clientId: args.clientId,\n    issuer: util.removeTrailingSlash(args.issuer),\n    authorizeUrl: util.removeTrailingSlash(args.authorizeUrl),\n    userinfoUrl: util.removeTrailingSlash(args.userinfoUrl),\n    tokenUrl: util.removeTrailingSlash(args.tokenUrl),\n    revokeUrl: util.removeTrailingSlash(args.revokeUrl),\n    logoutUrl: util.removeTrailingSlash(args.logoutUrl),\n    pkce: usePKCE,\n    redirectUri: args.redirectUri,\n    postLogoutRedirectUri: args.postLogoutRedirectUri,\n    responseMode: args.responseMode,\n    httpRequestClient: args.httpRequestClient,\n    storageUtil: args.storageUtil,\n    transformErrorXHR: args.transformErrorXHR,\n    headers: args.headers,\n    onSessionExpired: args.onSessionExpired,\n  };\n\n  if (this.options.pkce && !sdk.features.isPKCESupported()) {\n    var errorMessage = 'PKCE requires a modern browser with encryption support running in a secure context.';\n    if (!sdk.features.isHTTPS()) {\n      errorMessage += '\\nThe current page is not being served with HTTPS protocol. Try using HTTPS.';\n    }\n    if (!sdk.features.hasTextEncoder()) {\n      errorMessage += '\\n\"TextEncoder\" is not defined. You may need a polyfill/shim for this browser.';\n    }\n    throw new AuthSdkError(errorMessage);\n  }\n\n  this.userAgent = 'okta-auth-js-' + SDK_VERSION;\n\n  // Digital clocks will drift over time, so the server\n  // can misalign with the time reported by the browser.\n  // The maxClockSkew allows relaxing the time-based\n  // validation of tokens (in seconds, not milliseconds).\n  // It currently defaults to 300, because 5 min is the\n  // default maximum tolerance allowed by Kerberos.\n  // (https://technet.microsoft.com/en-us/library/cc976357.aspx)\n  if (!args.maxClockSkew && args.maxClockSkew !== 0) {\n    this.options.maxClockSkew = constants.DEFAULT_MAX_CLOCK_SKEW;\n  } else {\n    this.options.maxClockSkew = args.maxClockSkew;\n  }\n\n  // Give the developer the ability to disable token signature\n  // validation.\n  this.options.ignoreSignature = !!args.ignoreSignature;\n\n  sdk.session = {\n    close: util.bind(session.closeSession, null, sdk),\n    exists: util.bind(session.sessionExists, null, sdk),\n    get: util.bind(session.getSession, null, sdk),\n    refresh: util.bind(session.refreshSession, null, sdk),\n    setCookieAndRedirect: util.bind(session.setCookieAndRedirect, null, sdk)\n  };\n\n  sdk.tx = {\n    status: util.bind(tx.transactionStatus, null, sdk),\n    resume: util.bind(tx.resumeTransaction, null, sdk),\n    exists: util.bind(tx.transactionExists, null, sdk),\n    introspect: util.bind(tx.introspect, null, sdk)\n  };\n\n  // This is exposed so we can mock document.cookie in our tests\n  sdk.tx.exists._get = function(name) {\n    return cookies.get(name);\n  };\n\n  // This is exposed so we can mock window.location.href in our tests\n  sdk.idToken = {\n    authorize: {\n      _getLocationHref: function() {\n        return window.location.href;\n      }\n    }\n  };\n\n  sdk.token = {\n    getWithoutPrompt: util.bind(token.getWithoutPrompt, null, sdk),\n    getWithPopup: util.bind(token.getWithPopup, null, sdk),\n    getWithRedirect: util.bind(token.getWithRedirect, null, sdk),\n    parseFromUrl: util.bind(token.parseFromUrl, null, sdk),\n    decode: token.decodeToken,\n    revoke: util.bind(token.revokeToken, null, sdk),\n    renew: util.bind(token.renewToken, null, sdk),\n    getUserInfo: util.bind(token.getUserInfo, null, sdk),\n    verify: util.bind(token.verifyToken, null, sdk)\n  };\n\n  // This is exposed so we can set window.location in our tests\n  sdk.token.getWithRedirect._setLocation = function(url) {\n    window.location = url;\n  };\n\n  // This is exposed so we can mock getting window.history in our tests\n  sdk.token.parseFromUrl._getHistory = function() {\n    return window.history;\n  };\n\n  // This is exposed so we can mock getting window.location in our tests\n  sdk.token.parseFromUrl._getLocation = function() {\n    return window.location;\n  };\n\n  // This is exposed so we can mock getting window.document in our tests\n  sdk.token.parseFromUrl._getDocument = function() {\n    return window.document;\n  };\n\n  sdk.fingerprint._getUserAgent = function() {\n    return navigator.userAgent;\n  };\n\n  var isWindowsPhone = /windows phone|iemobile|wpdesktop/i;\n  sdk.features.isFingerprintSupported = function() {\n    var agent = sdk.fingerprint._getUserAgent();\n    return agent && !isWindowsPhone.test(agent);\n  };\n\n  sdk.emitter = new Emitter();\n  sdk.tokenManager = new TokenManager(sdk, args.tokenManager);\n  sdk.tokenManager.on('error', this._onTokenManagerError, this);\n}\n\nvar proto = OktaAuthBuilder.prototype;\nproto._onTokenManagerError = function(error) {\n  var code = error.errorCode;\n  if (code === 'login_required' && error.accessToken) {\n    if (this.options.onSessionExpired) {\n      this.options.onSessionExpired();\n    } else {\n      // eslint-disable-next-line no-console\n      console.error('Session has expired or was closed outside the application.');\n    }\n  }\n};\n\nproto.features = {};\n\nproto.features.isPopupPostMessageSupported = function() {\n  var isIE8or9 = document.documentMode && document.documentMode < 10;\n  if (window.postMessage && !isIE8or9) {\n    return true;\n  }\n  return false;\n};\n\nproto.features.isTokenVerifySupported = function() {\n  return typeof crypto !== 'undefined' && crypto.subtle && typeof Uint8Array !== 'undefined';\n};\n\nproto.features.hasTextEncoder = function() {\n  return typeof TextEncoder !== 'undefined';\n};\n\nproto.features.isPKCESupported = function() {\n  return proto.features.isTokenVerifySupported() && proto.features.hasTextEncoder();\n};\n\nproto.features.isHTTPS = function() {\n  return window.location.protocol === 'https:';\n};\n\n// { username, password, (relayState), (context) }\nproto.signIn = function (opts) {\n  var sdk = this;\n  opts = util.clone(opts || {});\n  function postToTransaction(options) {\n    delete opts.sendFingerprint;\n    return tx.postToTransaction(sdk, '/api/v1/authn', opts, options);\n  }\n  if (!opts.sendFingerprint) {\n    return postToTransaction();\n  }\n  return sdk.fingerprint()\n  .then(function(fingerprint) {\n    return postToTransaction({\n      headers: {\n        'X-Device-Fingerprint': fingerprint\n      }\n    });\n  });\n};\n\n// Ends the current application session, clearing all local tokens\n// Optionally revokes the access token\n// Ends the user's Okta session using the API or redirect method\nproto.signOut = function (options) {\n  options = util.extend({}, options);\n\n  // postLogoutRedirectUri must be whitelisted in Okta Admin UI\n  var postLogoutRedirectUri = options.postLogoutRedirectUri || this.options.postLogoutRedirectUri;\n\n  var accessToken = options.accessToken;\n  var revokeAccessToken = options.revokeAccessToken;\n  var idToken = options.idToken;\n\n  var sdk = this;\n  var logoutUrl = oauthUtil.getOAuthUrls(sdk).logoutUrl;\n\n  function getAccessToken() {\n    return new Q()\n    .then(function() {\n      if (revokeAccessToken && typeof accessToken === 'undefined') {\n        return sdk.tokenManager.get('token');\n      }\n      return accessToken;\n    });\n  }\n\n  function getIdToken() {\n    return new Q()\n    .then(function() {\n      if (postLogoutRedirectUri && typeof idToken === 'undefined') {\n        return sdk.tokenManager.get('idToken');\n      }\n      return idToken;\n    });\n  }\n\n  function closeSession() {\n    return sdk.session.close() // DELETE /api/v1/sessions/me\n    .catch(function(e) {\n      if (e.name === 'AuthApiError') {\n        // Most likely cause is session does not exist or has already been closed\n        // Could also be a network error. Nothing we can do here.\n        return;\n      }\n      throw e;\n    });\n  }\n\n  return Q.allSettled([getAccessToken(), getIdToken()])\n    .then(function(tokens) {\n      accessToken = tokens[0].value;\n      idToken = tokens[1].value;\n\n      // Clear all local tokens\n      sdk.tokenManager.clear();\n\n      if (revokeAccessToken && accessToken) {\n        return sdk.token.revoke(accessToken)\n        .catch(function(e) {\n          if (e.name === 'AuthApiError') {\n            // Capture and ignore network errors\n            return;\n          }\n          throw e;\n        });\n      }\n    })\n    .then(function() {\n      // XHR signOut method\n      if (!postLogoutRedirectUri) {\n        return closeSession();\n      }\n\n      // No idToken? This can happen if the storage was cleared.\n      // Fallback to XHR signOut, then redirect to the post logout uri\n      if (!idToken) {\n        return closeSession()\n        .catch(function(err) {\n          // eslint-disable-next-line no-console\n          console.log('Unhandled exception while closing session', err);\n        })\n        .then(function() {\n          window.location.assign(postLogoutRedirectUri);\n        });\n      }\n\n      // logout redirect using the idToken.\n      var state = options.state;\n      var idTokenHint = idToken.idToken; // a string\n      var logoutUri = logoutUrl + '?id_token_hint=' + encodeURIComponent(idTokenHint) +\n        '&post_logout_redirect_uri=' + encodeURIComponent(postLogoutRedirectUri);\n    \n      // State allows option parameters to be passed to logout redirect uri\n      if (state) {\n        logoutUri += '&state=' + encodeURIComponent(state);\n      }\n      \n      window.location.assign(logoutUri);\n    });\n};\n\nbuilderUtil.addSharedPrototypes(proto);\n\n// { resource, (rel), (requestContext)}\nproto.webfinger = function (opts) {\n  var url = '/.well-known/webfinger' + util.toQueryParams(opts);\n  var options = {\n    headers: {\n      'Accept': 'application/jrd+json'\n    }\n  };\n  return http.get(this, url, options);\n};\n\nproto.fingerprint = function(options) {\n  options = options || {};\n  var sdk = this;\n  if (!sdk.features.isFingerprintSupported()) {\n    return Q.reject(new AuthSdkError('Fingerprinting is not supported on this device'));\n  }\n\n  var deferred = Q.defer();\n\n  var iframe = document.createElement('iframe');\n  iframe.style.display = 'none';\n\n  function listener(e) {\n    if (!e || !e.data || e.origin !== sdk.options.url) {\n      return;\n    }\n\n    try {\n      var msg = JSON.parse(e.data);\n    } catch (err) {\n      return deferred.reject(new AuthSdkError('Unable to parse iframe response'));\n    }\n\n    if (!msg) { return; }\n    if (msg.type === 'FingerprintAvailable') {\n      return deferred.resolve(msg.fingerprint);\n    }\n    if (msg.type === 'FingerprintServiceReady') {\n      e.source.postMessage(JSON.stringify({\n        type: 'GetFingerprint'\n      }), e.origin);\n    }\n  }\n  oauthUtil.addListener(window, 'message', listener);\n\n  iframe.src = sdk.options.url + '/auth/services/devicefingerprint';\n  document.body.appendChild(iframe);\n\n  var timeout = setTimeout(function() {\n    deferred.reject(new AuthSdkError('Fingerprinting timed out'));\n  }, options.timeout || 15000);\n\n  return deferred.promise.fin(function() {\n    clearTimeout(timeout);\n    oauthUtil.removeListener(window, 'message', listener);\n    if (document.body.contains(iframe)) {\n      iframe.parentElement.removeChild(iframe);\n    }\n  });\n};\n\nmodule.exports = builderUtil.buildOktaAuth(OktaAuthBuilder);\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./lib/browser/browser.js\n// module id = 15\n// module chunks = 0","/*!\n * Copyright (c) 2015-2016, Okta, Inc. and/or its affiliates. All rights reserved.\n * The Okta software accompanied by this notice is provided pursuant to the Apache License, Version 2.0 (the \"License.\")\n *\n * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0.\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS, WITHOUT\n * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n *\n * See the License for the specific language governing permissions and limitations under the License.\n */\n\nrequire('Base64');\n\n// Production steps of ECMA-262, Edition 5, 15.4.4.14\n// Reference: http://es5.github.io/#x15.4.4.14\n// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/indexOf#Polyfill\nif (!Array.prototype.indexOf) {\n  Array.prototype.indexOf = function(searchElement, fromIndex) {\n\n    var k;\n\n    // 1. Let o be the result of calling ToObject passing\n    //    the this value as the argument.\n    if (this == null) {\n      throw new TypeError('\"this\" is null or not defined');\n    }\n\n    var o = Object(this);\n\n    // 2. Let lenValue be the result of calling the Get\n    //    internal method of o with the argument \"length\".\n    // 3. Let len be ToUint32(lenValue).\n    var len = o.length >>> 0;\n\n    // 4. If len is 0, return -1.\n    if (len === 0) {\n      return -1;\n    }\n\n    // 5. If argument fromIndex was passed let n be\n    //    ToInteger(fromIndex); else let n be 0.\n    var n = +fromIndex || 0;\n\n    if (Math.abs(n) === Infinity) {\n      n = 0;\n    }\n\n    // 6. If n >= len, return -1.\n    if (n >= len) {\n      return -1;\n    }\n\n    // 7. If n >= 0, then Let k be n.\n    // 8. Else, n<0, Let k be len - abs(n).\n    //    If k is less than 0, then let k be 0.\n    k = Math.max(n >= 0 ? n : len - Math.abs(n), 0);\n\n    // 9. Repeat, while k < len\n    while (k < len) {\n      // a. Let Pk be ToString(k).\n      //   This is implicit for LHS operands of the in operator\n      // b. Let kPresent be the result of calling the\n      //    HasProperty internal method of o with argument Pk.\n      //   This step can be combined with c\n      // c. If kPresent is true, then\n      //    i.  Let elementK be the result of calling the Get\n      //        internal method of o with the argument ToString(k).\n      //   ii.  Let same be the result of applying the\n      //        Strict Equality Comparison Algorithm to\n      //        searchElement and elementK.\n      //  iii.  If same is true, return k.\n      if (k in o && o[k] === searchElement) {\n        return k;\n      }\n      k++;\n    }\n    return -1;\n  };\n}\n\nif (!Array.isArray) {\n  Array.isArray = function(obj) {\n    return Object.prototype.toString.call(obj) === '[object Array]';\n  };\n}\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./lib/vendor/polyfills.js\n// module id = 16\n// module chunks = 0",";(function () {\n\n  var object = typeof exports != 'undefined' ? exports : this; // #8: web workers\n  var chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=';\n\n  function InvalidCharacterError(message) {\n    this.message = message;\n  }\n  InvalidCharacterError.prototype = new Error;\n  InvalidCharacterError.prototype.name = 'InvalidCharacterError';\n\n  // encoder\n  // [https://gist.github.com/999166] by [https://github.com/nignag]\n  object.btoa || (\n  object.btoa = function (input) {\n    var str = String(input);\n    for (\n      // initialize result and counter\n      var block, charCode, idx = 0, map = chars, output = '';\n      // if the next str index does not exist:\n      //   change the mapping table to \"=\"\n      //   check if d has no fractional digits\n      str.charAt(idx | 0) || (map = '=', idx % 1);\n      // \"8 - idx % 1 * 8\" generates the sequence 2, 4, 6, 8\n      output += map.charAt(63 & block >> 8 - idx % 1 * 8)\n    ) {\n      charCode = str.charCodeAt(idx += 3/4);\n      if (charCode > 0xFF) {\n        throw new InvalidCharacterError(\"'btoa' failed: The string to be encoded contains characters outside of the Latin1 range.\");\n      }\n      block = block << 8 | charCode;\n    }\n    return output;\n  });\n\n  // decoder\n  // [https://gist.github.com/1020396] by [https://github.com/atk]\n  object.atob || (\n  object.atob = function (input) {\n    var str = String(input).replace(/=+$/, '');\n    if (str.length % 4 == 1) {\n      throw new InvalidCharacterError(\"'atob' failed: The string to be decoded is not correctly encoded.\");\n    }\n    for (\n      // initialize result and counters\n      var bc = 0, bs, buffer, idx = 0, output = '';\n      // get next character\n      buffer = str.charAt(idx++);\n      // character found in table? initialize bit storage and add its ascii value;\n      ~buffer && (bs = bc % 4 ? bs * 64 + buffer : buffer,\n        // and if not first of each 4 characters,\n        // convert the first 8 bits to one ascii character\n        bc++ % 4) ? output += String.fromCharCode(255 & bs >> (-2 * bc & 6)) : 0\n    ) {\n      // try to find character in table (0-63, not found => -1)\n      buffer = chars.indexOf(buffer);\n    }\n    return output;\n  });\n\n}());\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// /root/okta/okta-auth-js/node_modules/Base64/base64.js\n// module id = 17\n// module chunks = 0","function E () {\n  // Keep this empty so it's easier to inherit from\n  // (via https://github.com/lipsmack from https://github.com/scottcorgan/tiny-emitter/issues/3)\n}\n\nE.prototype = {\n  on: function (name, callback, ctx) {\n    var e = this.e || (this.e = {});\n\n    (e[name] || (e[name] = [])).push({\n      fn: callback,\n      ctx: ctx\n    });\n\n    return this;\n  },\n\n  once: function (name, callback, ctx) {\n    var self = this;\n    function listener () {\n      self.off(name, listener);\n      callback.apply(ctx, arguments);\n    };\n\n    listener._ = callback\n    return this.on(name, listener, ctx);\n  },\n\n  emit: function (name) {\n    var data = [].slice.call(arguments, 1);\n    var evtArr = ((this.e || (this.e = {}))[name] || []).slice();\n    var i = 0;\n    var len = evtArr.length;\n\n    for (i; i < len; i++) {\n      evtArr[i].fn.apply(evtArr[i].ctx, data);\n    }\n\n    return this;\n  },\n\n  off: function (name, callback) {\n    var e = this.e || (this.e = {});\n    var evts = e[name];\n    var liveEvents = [];\n\n    if (evts && callback) {\n      for (var i = 0, len = evts.length; i < len; i++) {\n        if (evts[i].fn !== callback && evts[i].fn._ !== callback)\n          liveEvents.push(evts[i]);\n      }\n    }\n\n    // Remove event from queue to prevent memory leak\n    // Suggested by https://github.com/lazd\n    // Ref: https://github.com/scottcorgan/tiny-emitter/commit/c6ebfaa9bc973b33d110a84a307742b7cf94c953#commitcomment-5024910\n\n    (liveEvents.length)\n      ? e[name] = liveEvents\n      : delete e[name];\n\n    return this;\n  }\n};\n\nmodule.exports = E;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// /root/okta/okta-auth-js/node_modules/tiny-emitter/index.js\n// module id = 18\n// module chunks = 0","/*!\n * Copyright (c) 2018-present, Okta, Inc. and/or its affiliates. All rights reserved.\n * The Okta software accompanied by this notice is provided pursuant to the Apache License, Version 2.0 (the \"License.\")\n *\n * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0.\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS, WITHOUT\n * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n *\n * See the License for the specific language governing permissions and limitations under the License.\n */\n\nvar AuthSdkError = require('./errors/AuthSdkError');\nvar tx = require('./tx');\nvar util = require('./util');\n\nfunction getValidUrl(args) {\n  if (!args) {\n    throw new AuthSdkError('No arguments passed to constructor. ' +\n      'Required usage: new OktaAuth(args)');\n  }\n\n  var url = args.url;\n  if (!url) {\n    var isUrlRegex = new RegExp('^http?s?://.+');\n    if (args.issuer && isUrlRegex.test(args.issuer)) {\n      // Infer the URL from the issuer URL, omitting the /oauth2/{authServerId}\n      url = args.issuer.split('/oauth2/')[0];\n    } else {\n      throw new AuthSdkError('No url passed to constructor. ' +\n      'Required usage: new OktaAuth({url: \"https://{yourOktaDomain}.com\"})');\n    }\n  }\n\n  if (url.indexOf('-admin.') !== -1) {\n    throw new AuthSdkError('URL passed to constructor contains \"-admin\" in subdomain. ' +\n      'Required usage: new OktaAuth({url: \"https://{yourOktaDomain}.com})');\n  }\n\n  return url;\n}\n\nfunction addSharedPrototypes(proto) {\n  // { username, (relayState) }\n  proto.forgotPassword = function (opts) {\n    return tx.postToTransaction(this, '/api/v1/authn/recovery/password', opts);\n  };\n\n  // { username, (relayState) }\n  proto.unlockAccount = function (opts) {\n    return tx.postToTransaction(this, '/api/v1/authn/recovery/unlock', opts);\n  };\n\n  // { recoveryToken }\n  proto.verifyRecoveryToken = function (opts) {\n    return tx.postToTransaction(this, '/api/v1/authn/recovery/token', opts);\n  };\n}\n\nfunction buildOktaAuth(OktaAuthBuilder) {\n  return function(storageUtil, httpRequestClient) {\n    function OktaAuth(args) {\n      if (!(this instanceof OktaAuth)) {\n        return new OktaAuth(args);\n      }\n\n      if (args) {\n        args.storageUtil = storageUtil;\n\n        if (args.ajaxRequest) {\n          util.deprecate('ajaxRequest is being deprecated, use httpRequestClient attribute instead.');\n          args.httpRequestClient = args.ajaxRequest;\n        } else if (!args.httpRequestClient) {\n          args.httpRequestClient = httpRequestClient;\n        }\n      }\n\n      util.bind(OktaAuthBuilder, this)(args);\n    }\n    OktaAuth.prototype = OktaAuthBuilder.prototype;\n    OktaAuth.prototype.constructor = OktaAuth;\n\n    // Hoist feature detection functions to static type\n    OktaAuth.features = OktaAuthBuilder.prototype.features;\n\n    return OktaAuth;\n  };\n}\n\nmodule.exports = {\n  addSharedPrototypes: addSharedPrototypes,\n  buildOktaAuth: buildOktaAuth,\n  getValidUrl: getValidUrl\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./lib/builderUtil.js\n// module id = 19\n// module chunks = 0","var scope = (typeof global !== \"undefined\" && global) ||\n            (typeof self !== \"undefined\" && self) ||\n            window;\nvar apply = Function.prototype.apply;\n\n// DOM APIs, for completeness\n\nexports.setTimeout = function() {\n  return new Timeout(apply.call(setTimeout, scope, arguments), clearTimeout);\n};\nexports.setInterval = function() {\n  return new Timeout(apply.call(setInterval, scope, arguments), clearInterval);\n};\nexports.clearTimeout =\nexports.clearInterval = function(timeout) {\n  if (timeout) {\n    timeout.close();\n  }\n};\n\nfunction Timeout(id, clearFn) {\n  this._id = id;\n  this._clearFn = clearFn;\n}\nTimeout.prototype.unref = Timeout.prototype.ref = function() {};\nTimeout.prototype.close = function() {\n  this._clearFn.call(scope, this._id);\n};\n\n// Does not start the time, just sets up the members needed.\nexports.enroll = function(item, msecs) {\n  clearTimeout(item._idleTimeoutId);\n  item._idleTimeout = msecs;\n};\n\nexports.unenroll = function(item) {\n  clearTimeout(item._idleTimeoutId);\n  item._idleTimeout = -1;\n};\n\nexports._unrefActive = exports.active = function(item) {\n  clearTimeout(item._idleTimeoutId);\n\n  var msecs = item._idleTimeout;\n  if (msecs >= 0) {\n    item._idleTimeoutId = setTimeout(function onTimeout() {\n      if (item._onTimeout)\n        item._onTimeout();\n    }, msecs);\n  }\n};\n\n// setimmediate attaches itself to the global object\nrequire(\"setimmediate\");\n// On some exotic environments, it's not clear which object `setimmediate` was\n// able to install onto.  Search each possibility in the same order as the\n// `setimmediate` library.\nexports.setImmediate = (typeof self !== \"undefined\" && self.setImmediate) ||\n                       (typeof global !== \"undefined\" && global.setImmediate) ||\n                       (this && this.setImmediate);\nexports.clearImmediate = (typeof self !== \"undefined\" && self.clearImmediate) ||\n                         (typeof global !== \"undefined\" && global.clearImmediate) ||\n                         (this && this.clearImmediate);\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// /root/okta/okta-auth-js/node_modules/timers-browserify/main.js\n// module id = 20\n// module chunks = 0","(function (global, undefined) {\n    \"use strict\";\n\n    if (global.setImmediate) {\n        return;\n    }\n\n    var nextHandle = 1; // Spec says greater than zero\n    var tasksByHandle = {};\n    var currentlyRunningATask = false;\n    var doc = global.document;\n    var registerImmediate;\n\n    function setImmediate(callback) {\n      // Callback can either be a function or a string\n      if (typeof callback !== \"function\") {\n        callback = new Function(\"\" + callback);\n      }\n      // Copy function arguments\n      var args = new Array(arguments.length - 1);\n      for (var i = 0; i < args.length; i++) {\n          args[i] = arguments[i + 1];\n      }\n      // Store and register the task\n      var task = { callback: callback, args: args };\n      tasksByHandle[nextHandle] = task;\n      registerImmediate(nextHandle);\n      return nextHandle++;\n    }\n\n    function clearImmediate(handle) {\n        delete tasksByHandle[handle];\n    }\n\n    function run(task) {\n        var callback = task.callback;\n        var args = task.args;\n        switch (args.length) {\n        case 0:\n            callback();\n            break;\n        case 1:\n            callback(args[0]);\n            break;\n        case 2:\n            callback(args[0], args[1]);\n            break;\n        case 3:\n            callback(args[0], args[1], args[2]);\n            break;\n        default:\n            callback.apply(undefined, args);\n            break;\n        }\n    }\n\n    function runIfPresent(handle) {\n        // From the spec: \"Wait until any invocations of this algorithm started before this one have completed.\"\n        // So if we're currently running a task, we'll need to delay this invocation.\n        if (currentlyRunningATask) {\n            // Delay by doing a setTimeout. setImmediate was tried instead, but in Firefox 7 it generated a\n            // \"too much recursion\" error.\n            setTimeout(runIfPresent, 0, handle);\n        } else {\n            var task = tasksByHandle[handle];\n            if (task) {\n                currentlyRunningATask = true;\n                try {\n                    run(task);\n                } finally {\n                    clearImmediate(handle);\n                    currentlyRunningATask = false;\n                }\n            }\n        }\n    }\n\n    function installNextTickImplementation() {\n        registerImmediate = function(handle) {\n            process.nextTick(function () { runIfPresent(handle); });\n        };\n    }\n\n    function canUsePostMessage() {\n        // The test against `importScripts` prevents this implementation from being installed inside a web worker,\n        // where `global.postMessage` means something completely different and can't be used for this purpose.\n        if (global.postMessage && !global.importScripts) {\n            var postMessageIsAsynchronous = true;\n            var oldOnMessage = global.onmessage;\n            global.onmessage = function() {\n                postMessageIsAsynchronous = false;\n            };\n            global.postMessage(\"\", \"*\");\n            global.onmessage = oldOnMessage;\n            return postMessageIsAsynchronous;\n        }\n    }\n\n    function installPostMessageImplementation() {\n        // Installs an event handler on `global` for the `message` event: see\n        // * https://developer.mozilla.org/en/DOM/window.postMessage\n        // * http://www.whatwg.org/specs/web-apps/current-work/multipage/comms.html#crossDocumentMessages\n\n        var messagePrefix = \"setImmediate$\" + Math.random() + \"$\";\n        var onGlobalMessage = function(event) {\n            if (event.source === global &&\n                typeof event.data === \"string\" &&\n                event.data.indexOf(messagePrefix) === 0) {\n                runIfPresent(+event.data.slice(messagePrefix.length));\n            }\n        };\n\n        if (global.addEventListener) {\n            global.addEventListener(\"message\", onGlobalMessage, false);\n        } else {\n            global.attachEvent(\"onmessage\", onGlobalMessage);\n        }\n\n        registerImmediate = function(handle) {\n            global.postMessage(messagePrefix + handle, \"*\");\n        };\n    }\n\n    function installMessageChannelImplementation() {\n        var channel = new MessageChannel();\n        channel.port1.onmessage = function(event) {\n            var handle = event.data;\n            runIfPresent(handle);\n        };\n\n        registerImmediate = function(handle) {\n            channel.port2.postMessage(handle);\n        };\n    }\n\n    function installReadyStateChangeImplementation() {\n        var html = doc.documentElement;\n        registerImmediate = function(handle) {\n            // Create a <script> element; its readystatechange event will be fired asynchronously once it is inserted\n            // into the document. Do so, thus queuing up the task. Remember to clean up once it's been called.\n            var script = doc.createElement(\"script\");\n            script.onreadystatechange = function () {\n                runIfPresent(handle);\n                script.onreadystatechange = null;\n                html.removeChild(script);\n                script = null;\n            };\n            html.appendChild(script);\n        };\n    }\n\n    function installSetTimeoutImplementation() {\n        registerImmediate = function(handle) {\n            setTimeout(runIfPresent, 0, handle);\n        };\n    }\n\n    // If supported, we should attach to the prototype of global, since that is where setTimeout et al. live.\n    var attachTo = Object.getPrototypeOf && Object.getPrototypeOf(global);\n    attachTo = attachTo && attachTo.setTimeout ? attachTo : global;\n\n    // Don't get fooled by e.g. browserify environments.\n    if ({}.toString.call(global.process) === \"[object process]\") {\n        // For Node.js before 0.9\n        installNextTickImplementation();\n\n    } else if (canUsePostMessage()) {\n        // For non-IE10 modern browsers\n        installPostMessageImplementation();\n\n    } else if (global.MessageChannel) {\n        // For web workers, where supported\n        installMessageChannelImplementation();\n\n    } else if (doc && \"onreadystatechange\" in doc.createElement(\"script\")) {\n        // For IE 6–8\n        installReadyStateChangeImplementation();\n\n    } else {\n        // For older browsers\n        installSetTimeoutImplementation();\n    }\n\n    attachTo.setImmediate = setImmediate;\n    attachTo.clearImmediate = clearImmediate;\n}(typeof self === \"undefined\" ? typeof global === \"undefined\" ? this : global : self));\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// /root/okta/okta-auth-js/node_modules/setimmediate/setImmediate.js\n// module id = 21\n// module chunks = 0","/*!\n * Copyright (c) 2015-present, Okta, Inc. and/or its affiliates. All rights reserved.\n * The Okta software accompanied by this notice is provided pursuant to the Apache License, Version 2.0 (the \"License.\")\n *\n * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0.\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS, WITHOUT\n * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n *\n * See the License for the specific language governing permissions and limitations under the License.\n */\n\nfunction AuthApiError(err, xhr) {\n  this.name = 'AuthApiError';\n  this.message = err.errorSummary;\n  this.errorSummary = err.errorSummary;\n  this.errorCode = err.errorCode;\n  this.errorLink = err.errorLink;\n  this.errorId = err.errorId;\n  this.errorCauses = err.errorCauses;\n\n  if (xhr) {\n    this.xhr = xhr;\n  }\n}\nAuthApiError.prototype = new Error();\n\nmodule.exports = AuthApiError;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./lib/errors/AuthApiError.js\n// module id = 22\n// module chunks = 0","/*!\n * Copyright (c) 2015-present, Okta, Inc. and/or its affiliates. All rights reserved.\n * The Okta software accompanied by this notice is provided pursuant to the Apache License, Version 2.0 (the \"License.\")\n *\n * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0.\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS, WITHOUT\n * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n *\n * See the License for the specific language governing permissions and limitations under the License.\n */\n\nfunction AuthPollStopError() {\n  this.name = 'AuthPollStopError';\n  this.message = 'The poll was stopped by the sdk';\n}\nAuthPollStopError.prototype = new Error();\n\nmodule.exports = AuthPollStopError;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./lib/errors/AuthPollStopError.js\n// module id = 23\n// module chunks = 0","/*!\n * Copyright (c) 2015-present, Okta, Inc. and/or its affiliates. All rights reserved.\n * The Okta software accompanied by this notice is provided pursuant to the Apache License, Version 2.0 (the \"License.\")\n *\n * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0.\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS, WITHOUT\n * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n *\n * See the License for the specific language governing permissions and limitations under the License.\n *\n */\n\nvar util = require('./util');\nvar http = require('./http');\n\nfunction sessionExists(sdk) {\n  return sdk.session.get()\n    .then(function(res) {\n      if (res.status === 'ACTIVE') {\n        return true;\n      }\n      return false;\n    })\n    .fail(function() {\n      return false;\n    });\n}\n\nfunction getSession(sdk) { \n  return http.get(sdk, '/api/v1/sessions/me')\n  .then(function(session) {\n    var res = util.omit(session, '_links');\n\n    res.refresh = function() {\n      return http.post(sdk, util.getLink(session, 'refresh').href);\n    };\n\n    res.user = function() {\n      return http.get(sdk, util.getLink(session, 'user').href);\n    };\n\n    return res;\n  })\n  .fail(function() {\n    // Return INACTIVE status on failure\n    return {status: 'INACTIVE'};\n  });\n}\n\nfunction closeSession(sdk) {\n  return http.httpRequest(sdk, {\n    url: sdk.options.url + '/api/v1/sessions/me',\n    method: 'DELETE'\n  });\n}\n\nfunction refreshSession(sdk) {\n  return http.post(sdk, '/api/v1/sessions/me/lifecycle/refresh');\n}\n\nfunction setCookieAndRedirect(sdk, sessionToken, redirectUrl) {\n  redirectUrl = redirectUrl || window.location.href;\n  window.location = sdk.options.url + '/login/sessionCookieRedirect' +\n    util.toQueryParams({\n      checkAccountSetupComplete: true,\n      token: sessionToken,\n      redirectUrl: redirectUrl\n    });\n}\n\nmodule.exports = {\n  sessionExists: sessionExists,\n  getSession: getSession,\n  closeSession: closeSession,\n  refreshSession: refreshSession,\n  setCookieAndRedirect: setCookieAndRedirect\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./lib/session.js\n// module id = 24\n// module chunks = 0","/*!\n * Copyright (c) 2015-present, Okta, Inc. and/or its affiliates. All rights reserved.\n * The Okta software accompanied by this notice is provided pursuant to the Apache License, Version 2.0 (the \"License.\")\n *\n * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0.\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS, WITHOUT\n * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n *\n * See the License for the specific language governing permissions and limitations under the License.\n *\n */\n\n/* eslint-disable complexity, max-statements */\nvar http          = require('./http');\nvar util          = require('./util');\nvar oauthUtil     = require('./oauthUtil');\nvar Q             = require('q');\nvar sdkCrypto     = require('./crypto');\nvar AuthSdkError  = require('./errors/AuthSdkError');\nvar OAuthError    = require('./errors/OAuthError');\nvar constants     = require('./constants');\nvar cookies       = require('./browser/browserStorage').storage;\nvar PKCE          = require('./pkce');\n\n// Only the access token can be revoked in SPA applications\nfunction revokeToken(sdk, token) {\n  return new Q()\n  .then(function() {\n    if (!token || !token.accessToken) {\n      throw new AuthSdkError('A valid access token object is required');\n    }\n    var clientId = sdk.options.clientId;\n    if (!clientId) {\n      throw new AuthSdkError('A clientId must be specified in the OktaAuth constructor to revoke a token');\n    }\n    var revokeUrl = oauthUtil.getOAuthUrls(sdk).revokeUrl;\n    var accessToken = token.accessToken;\n    var args = util.toQueryParams({\n      // eslint-disable-next-line camelcase\n      token_type_hint: 'access_token',\n      token: accessToken\n    }).slice(1);\n    var creds = btoa(clientId);\n    return http.post(sdk, revokeUrl, args, {\n      headers: {\n        'Content-Type': 'application/x-www-form-urlencoded',\n        'Authorization': 'Basic ' + creds\n      }\n    });\n  });\n}\n\nfunction decodeToken(token) {\n  var jwt = token.split('.');\n  var decodedToken;\n\n  try {\n    decodedToken = {\n      header: JSON.parse(util.base64UrlToString(jwt[0])),\n      payload: JSON.parse(util.base64UrlToString(jwt[1])),\n      signature: jwt[2]\n    };\n  } catch(e) {\n    throw new AuthSdkError('Malformed token');\n  }\n\n  return decodedToken;\n}\n\n// Verify the id token\nfunction verifyToken(sdk, token, validationParams) {\n  return new Q()\n  .then(function() {\n    if (!token || !token.idToken) {\n      throw new AuthSdkError('Only idTokens may be verified');\n    }\n\n    var jwt = decodeToken(token.idToken);\n\n    var validationOptions = {\n      clientId: sdk.options.clientId,\n      issuer: sdk.options.issuer || sdk.options.url,\n      ignoreSignature: sdk.options.ignoreSignature\n    };\n\n    util.extend(validationOptions, validationParams);\n\n    // Standard claim validation\n    oauthUtil.validateClaims(sdk, jwt.payload, validationOptions);\n\n    // If the browser doesn't support native crypto or we choose not\n    // to verify the signature, bail early\n    if (validationOptions.ignoreSignature == true || !sdk.features.isTokenVerifySupported()) {\n      return token;\n    }\n\n    return oauthUtil.getKey(sdk, token.issuer, jwt.header.kid)\n    .then(function(key) {\n      return sdkCrypto.verifyToken(token.idToken, key);\n    })\n    .then(function(valid) {\n      if (!valid) {\n        throw new AuthSdkError('The token signature is not valid');\n      }\n      return token;\n    });\n  });\n}\n\nfunction addPostMessageListener(sdk, timeout, state) {\n  var deferred = Q.defer();\n\n  function responseHandler(e) {\n    if (!e.data || e.data.state !== state) {\n      // A message not meant for us\n      return;\n    }\n\n    // Configuration mismatch between saved token and current app instance\n    // This may happen if apps with different issuers are running on the same host url\n    // If they share the same storage key, they may read and write tokens in the same location.\n    // Common when developing against http://localhost\n    if (e.origin !== sdk.options.url) {\n      return deferred.reject(new AuthSdkError('The request does not match client configuration'));\n    }\n\n    deferred.resolve(e.data);\n  }\n\n  oauthUtil.addListener(window, 'message', responseHandler);\n\n  return deferred.promise.timeout(timeout || 120000, new AuthSdkError('OAuth flow timed out'))\n    .fin(function() {\n      oauthUtil.removeListener(window, 'message', responseHandler);\n    });\n}\n\nfunction addFragmentListener(sdk, windowEl, timeout) {\n  var deferred = Q.defer();\n\n  function hashChangeHandler() {\n    /*\n      We are only able to access window.location.hash on a window\n      that has the same domain. A try/catch is necessary because\n      there's no other way to determine that the popup is in\n      another domain. When we try to access a window on another\n      domain, an error is thrown.\n    */\n    try {\n      if (windowEl &&\n          windowEl.location &&\n          windowEl.location.hash) {\n        deferred.resolve(oauthUtil.hashToObject(windowEl.location.hash));\n      } else if (windowEl && !windowEl.closed) {\n        setTimeout(hashChangeHandler, 500);\n      }\n    } catch (err) {\n      setTimeout(hashChangeHandler, 500);\n    }\n  }\n\n  hashChangeHandler();\n\n  return deferred.promise.timeout(timeout || 120000, new AuthSdkError('OAuth flow timed out'));\n}\n\nfunction exchangeCodeForToken(sdk, oauthParams, authorizationCode, urls) {\n  // PKCE authorization_code flow\n  // Retrieve saved values and build oauthParams for call to /token\n  var meta = PKCE.loadMeta(sdk);\n  var getTokenParams = {\n    clientId: oauthParams.clientId,\n    authorizationCode: authorizationCode,\n    codeVerifier: meta.codeVerifier,\n    redirectUri: meta.redirectUri\n  };\n  return PKCE.getToken(sdk, getTokenParams, urls)\n  .then(function(res) {\n    validateResponse(res, getTokenParams);\n    return res;\n  })\n  .fin(function() {\n    PKCE.clearMeta(sdk);\n  });\n}\n\nfunction validateResponse(res, oauthParams) {\n  if (res['error'] || res['error_description']) {\n    throw new OAuthError(res['error'], res['error_description']);\n  }\n\n  if (res.state !== oauthParams.state) {\n    throw new AuthSdkError('OAuth flow response state doesn\\'t match request state');\n  }\n}\n\nfunction handleOAuthResponse(sdk, oauthParams, res, urls) {\n  urls = urls || {};\n\n  var responseType = oauthParams.responseType;\n  var scopes = util.clone(oauthParams.scopes);\n  var clientId = oauthParams.clientId || sdk.options.clientId;\n\n  return new Q()\n  .then(function() {\n    validateResponse(res, oauthParams);\n\n    // We do not support \"hybrid\" scenarios where the response includes both a code and a token.\n    // If the response contains a code it is used immediately to obtain new tokens.\n    if (res['code']) {\n      responseType = ['token', 'id_token']; // what we expect the code to provide us\n      return exchangeCodeForToken(sdk, oauthParams, res['code'], urls);\n    }\n    return res;\n  }).then(function(res) {\n    var tokenDict = {};\n\n    if (res['access_token']) {\n      tokenDict['token'] = {\n        accessToken: res['access_token'],\n        expiresAt: Number(res['expires_in']) + Math.floor(Date.now()/1000),\n        tokenType: res['token_type'],\n        scopes: scopes,\n        authorizeUrl: urls.authorizeUrl,\n        userinfoUrl: urls.userinfoUrl\n      };\n    }\n\n    if (res['id_token']) {\n      var jwt = sdk.token.decode(res['id_token']);\n\n      var idToken = {\n        idToken: res['id_token'],\n        claims: jwt.payload,\n        expiresAt: jwt.payload.exp,\n        scopes: scopes,\n        authorizeUrl: urls.authorizeUrl,\n        issuer: urls.issuer,\n        clientId: clientId\n      };\n\n      var validationParams = {\n        clientId: clientId,\n        issuer: urls.issuer,\n        nonce: oauthParams.nonce\n      };\n\n      if (oauthParams.ignoreSignature !== undefined) {\n        validationParams.ignoreSignature = oauthParams.ignoreSignature;\n      }\n\n      return verifyToken(sdk, idToken, validationParams)\n      .then(function() {\n        tokenDict['id_token'] = idToken;\n        return tokenDict;\n      });\n    }\n\n    return tokenDict;\n  })\n  .then(function(tokenDict) {\n    if (!Array.isArray(responseType)) {\n      return tokenDict[responseType];\n    }\n\n    // Validate response against tokenTypes\n    var validateTokenTypes =  ['token', 'id_token'];\n    validateTokenTypes.filter(function(key) {\n      return (responseType.indexOf(key) !== -1);\n    }).forEach(function(key) {\n      if (!tokenDict[key]) {\n        throw new AuthSdkError('Unable to parse OAuth flow response: ' + key + ' was not returned.');\n      }     \n    });\n\n    // Create token array in the order of the responseType array\n    return responseType.map(function(item) {\n      return tokenDict[item];\n    });\n  });\n}\n\nfunction getDefaultOAuthParams(sdk) {\n  return {\n    pkce: sdk.options.pkce || false,\n    clientId: sdk.options.clientId,\n    redirectUri: sdk.options.redirectUri || window.location.href,\n    responseType: 'id_token',\n    responseMode: 'okta_post_message',\n    state: oauthUtil.generateState(),\n    nonce: oauthUtil.generateNonce(),\n    scopes: ['openid', 'email'],\n    ignoreSignature: sdk.options.ignoreSignature\n  };\n}\n\nfunction convertOAuthParamsToQueryParams(oauthParams) {\n  // Quick validation\n  if (!oauthParams.clientId) {\n    throw new AuthSdkError('A clientId must be specified in the OktaAuth constructor to get a token');\n  }\n\n  if (util.isString(oauthParams.responseType) && oauthParams.responseType.indexOf(' ') !== -1) {\n    throw new AuthSdkError('Multiple OAuth responseTypes must be defined as an array');\n  }\n\n  // Convert our params to their actual OAuth equivalents\n  var oauthQueryParams = util.removeNils({\n    'client_id': oauthParams.clientId,\n    'code_challenge': oauthParams.codeChallenge,\n    'code_challenge_method': oauthParams.codeChallengeMethod,\n    'display': oauthParams.display,\n    'idp': oauthParams.idp,\n    'idp_scope': oauthParams.idpScope,\n    'login_hint': oauthParams.loginHint,\n    'max_age': oauthParams.maxAge,\n    'nonce': oauthParams.nonce,\n    'prompt': oauthParams.prompt,\n    'redirect_uri': oauthParams.redirectUri,\n    'response_mode': oauthParams.responseMode,\n    'response_type': oauthParams.responseType,\n    'sessionToken': oauthParams.sessionToken,\n    'state': oauthParams.state,\n  });\n\n  ['idp_scope', 'response_type'].forEach( function( mayBeArray ) { \n    if (Array.isArray(oauthQueryParams[mayBeArray])) {\n      oauthQueryParams[mayBeArray] = oauthQueryParams[mayBeArray].join(' ');\n    }\n  });\n\n  if (oauthParams.responseType.indexOf('id_token') !== -1 &&\n      oauthParams.scopes.indexOf('openid') === -1) {\n    throw new AuthSdkError('openid scope must be specified in the scopes argument when requesting an id_token');\n  } else {\n    oauthQueryParams.scope = oauthParams.scopes.join(' ');\n  }\n\n  return oauthQueryParams;\n}\n\nfunction buildAuthorizeParams(oauthParams) {\n  var oauthQueryParams = convertOAuthParamsToQueryParams(oauthParams);\n  return util.toQueryParams(oauthQueryParams);\n}\n\n/*\n * Retrieve an idToken from an Okta or a third party idp\n *\n * Two main flows:\n *\n *  1) Exchange a sessionToken for a token\n *\n *    Required:\n *      clientId: passed via the OktaAuth constructor or into getToken\n *      sessionToken: 'yourtoken'\n *\n *    Optional:\n *      redirectUri: defaults to window.location.href\n *      scopes: defaults to ['openid', 'email']\n *\n *    Forced:\n *      prompt: 'none'\n *      responseMode: 'okta_post_message'\n *      display: undefined\n *\n *  2) Get a token from an idp\n *\n *    Required:\n *      clientId: passed via the OktaAuth constructor or into getToken\n *\n *    Optional:\n *      redirectUri: defaults to window.location.href\n *      scopes: defaults to ['openid', 'email']\n *      idp: defaults to Okta as an idp\n *      prompt: no default. Pass 'none' to throw an error if user is not signed in\n *\n *    Forced:\n *      display: 'popup'\n *\n *  Only common optional params shown. Any OAuth parameters not explicitly forced are available to override\n *\n * @param {Object} oauthOptions\n * @param {String} [oauthOptions.clientId] ID of this client\n * @param {String} [oauthOptions.redirectUri] URI that the iframe or popup will go to once authenticated\n * @param {String[]} [oauthOptions.scopes] OAuth 2.0 scopes to request (openid must be specified)\n * @param {String} [oauthOptions.idp] ID of an external IdP to use for user authentication\n * @param {String} [oauthOptions.sessionToken] Bootstrap Session Token returned by the Okta Authentication API\n * @param {String} [oauthOptions.prompt] Determines whether the Okta login will be displayed on failure.\n *                                       Use 'none' to prevent this behavior\n *\n * @param {Object} options\n * @param {Integer} [options.timeout] Time in ms before the flow is automatically terminated. Defaults to 120000\n * @param {String} [options.popupTitle] Title dispayed in the popup.\n *                                      Defaults to 'External Identity Provider User Authentication'\n */\nfunction getToken(sdk, oauthOptions, options) {\n  oauthOptions = oauthOptions || {};\n  options = options || {};\n\n  return prepareOauthParams(sdk, oauthOptions)\n  .then(function(oauthParams) {\n\n    // Start overriding any options that don't make sense\n    var sessionTokenOverrides = {\n      prompt: 'none',\n      responseMode: 'okta_post_message',\n      display: null\n    };\n\n    var idpOverrides = {\n      display: 'popup'\n    };\n\n    if (oauthOptions.sessionToken) {\n      util.extend(oauthParams, sessionTokenOverrides);\n    } else if (oauthOptions.idp) {\n      util.extend(oauthParams, idpOverrides);\n    }\n\n    // Use the query params to build the authorize url\n    var requestUrl,\n        endpoint,\n        urls;\n    try {\n      // Get authorizeUrl and issuer\n      urls = oauthUtil.getOAuthUrls(sdk, oauthParams, options);\n      endpoint = oauthOptions.codeVerifier ? urls.tokenUrl : urls.authorizeUrl;\n      requestUrl = endpoint + buildAuthorizeParams(oauthParams);\n    } catch (e) {\n      return Q.reject(e);\n    }\n\n    // Determine the flow type\n    var flowType;\n    if (oauthParams.sessionToken || oauthParams.display === null) {\n      flowType = 'IFRAME';\n    } else if (oauthParams.display === 'popup') {\n      flowType = 'POPUP';\n    } else {\n      flowType = 'IMPLICIT';\n    }\n\n    function getOrigin(url) {\n      /* eslint-disable-next-line no-useless-escape */\n      var originRegex = /^(https?\\:\\/\\/)?([^:\\/?#]*(?:\\:[0-9]+)?)/;\n      return originRegex.exec(url)[0];\n    }\n\n    // Execute the flow type\n    switch (flowType) {\n      case 'IFRAME':\n        var iframePromise = addPostMessageListener(sdk, options.timeout, oauthParams.state);\n        var iframeEl = oauthUtil.loadFrame(requestUrl);\n        return iframePromise\n          .then(function(res) {\n            return handleOAuthResponse(sdk, oauthParams, res, urls);\n          })\n          .fin(function() {\n            if (document.body.contains(iframeEl)) {\n              iframeEl.parentElement.removeChild(iframeEl);\n            }\n          });\n\n      case 'POPUP': // eslint-disable-line no-case-declarations\n        var popupPromise;\n\n        // Add listener on postMessage before window creation, so\n        // postMessage isn't triggered before we're listening\n        if (oauthParams.responseMode === 'okta_post_message') {\n          if (!sdk.features.isPopupPostMessageSupported()) {\n            return Q.reject(new AuthSdkError('This browser doesn\\'t have full postMessage support'));\n          }\n          popupPromise = addPostMessageListener(sdk, options.timeout, oauthParams.state);\n        }\n\n        // Create the window\n        var windowOptions = {\n          popupTitle: options.popupTitle\n        };\n        var windowEl = oauthUtil.loadPopup(requestUrl, windowOptions);\n\n        // Poll until we get a valid hash fragment\n        if (oauthParams.responseMode === 'fragment') {\n          var windowOrigin = getOrigin(sdk.idToken.authorize._getLocationHref());\n          var redirectUriOrigin = getOrigin(oauthParams.redirectUri);\n          if (windowOrigin !== redirectUriOrigin) {\n            return Q.reject(new AuthSdkError('Using fragment, the redirectUri origin (' + redirectUriOrigin +\n              ') must match the origin of this page (' + windowOrigin + ')'));\n          }\n          popupPromise = addFragmentListener(sdk, windowEl, options.timeout);\n        }\n\n        // Both postMessage and fragment require a poll to see if the popup closed\n        var popupDeferred = Q.defer();\n        /* eslint-disable-next-line no-case-declarations, no-inner-declarations */\n        function hasClosed(win) {\n          if (!win || win.closed) {\n            popupDeferred.reject(new AuthSdkError('Unable to parse OAuth flow response'));\n            return true;\n          }\n        }\n        var closePoller = setInterval(function() {\n          if (hasClosed(windowEl)) {\n            clearInterval(closePoller);\n          }\n        }, 500);\n\n        // Proxy the promise results into the deferred\n        popupPromise\n        .then(function(res) {\n          popupDeferred.resolve(res);\n        })\n        .fail(function(err) {\n          popupDeferred.reject(err);\n        });\n\n        return popupDeferred.promise\n          .then(function(res) {\n            return handleOAuthResponse(sdk, oauthParams, res, urls);\n          })\n          .fin(function() {\n            clearInterval(closePoller);\n            if (windowEl && !windowEl.closed) {\n              windowEl.close();\n            }\n          });\n\n      default:\n        return Q.reject(new AuthSdkError('The full page redirect flow is not supported'));\n    }\n  });\n}\n\nfunction getWithoutPrompt(sdk, oauthOptions, options) {\n  var oauthParams = util.clone(oauthOptions) || {};\n  util.extend(oauthParams, {\n    prompt: 'none',\n    responseMode: 'okta_post_message',\n    display: null\n  });\n  return getToken(sdk, oauthParams, options);\n}\n\nfunction getWithPopup(sdk, oauthOptions, options) {\n  var oauthParams = util.clone(oauthOptions) || {};\n  util.extend(oauthParams, {\n    display: 'popup',\n    responseMode: 'okta_post_message'\n  });\n  return getToken(sdk, oauthParams, options);\n}\n\nfunction prepareOauthParams(sdk, oauthOptions) {\n  // clone and prepare options\n  oauthOptions = util.clone(oauthOptions) || {};\n\n  // OKTA-242989: support for grantType will be removed in 3.0 \n  if (oauthOptions.grantType === 'authorization_code') {\n    oauthOptions.pkce = true;\n  }\n\n  // build params using defaults + options\n  var oauthParams = getDefaultOAuthParams(sdk);\n  util.extend(oauthParams, oauthOptions);\n\n  if (oauthParams.pkce !== true) {\n    return Q.resolve(oauthParams);\n  }\n\n  // PKCE flow\n  if (!sdk.features.isPKCESupported()) {\n    return Q.reject(new AuthSdkError('This browser doesn\\'t support PKCE'));\n  }\n\n  // set default code challenge method, if none provided\n  if (!oauthParams.codeChallengeMethod) {\n    oauthParams.codeChallengeMethod = PKCE.DEFAULT_CODE_CHALLENGE_METHOD;\n  }\n\n  // responseType is forced\n  oauthParams.responseType = 'code';\n\n  return oauthUtil.getWellKnown(sdk, null)\n    .then(function(res) {\n      var methods = res['code_challenge_methods_supported'] || [];\n      if (methods.indexOf(oauthParams.codeChallengeMethod) === -1) {\n        throw new AuthSdkError('Invalid code_challenge_method');\n      }\n    })\n    .then(function() {\n      // PKCE authorization_code flow\n      var codeVerifier = PKCE.generateVerifier(oauthParams.codeVerifier);\n\n      // We will need these values after redirect when we call /token\n      var meta = {\n        codeVerifier: codeVerifier,\n        redirectUri: oauthParams.redirectUri\n      };\n      PKCE.saveMeta(sdk, meta);\n\n      return PKCE.computeChallenge(codeVerifier);\n    })\n    .then(function(codeChallenge) {\n\n      // Clone/copy the params. Set codeChallenge\n      var clonedParams = util.clone(oauthParams) || {};\n      util.extend(clonedParams, oauthParams, {\n        codeChallenge: codeChallenge,\n      });\n      return clonedParams;\n    });\n}\n\nfunction getWithRedirect(sdk, oauthOptions, options) {\n  oauthOptions = util.clone(oauthOptions) || {};\n\n  return prepareOauthParams(sdk, oauthOptions)\n    .then(function(oauthParams) {\n\n      // Dynamically set the responseMode unless the user has provided one\n      // Server-side flow requires query. Client-side apps usually prefer fragment.\n      if (!oauthOptions.responseMode) {\n        if (oauthParams.responseType.includes('code') && !oauthParams.pkce) {\n          // server-side flows using authorization_code\n          oauthParams.responseMode = 'query';\n        } else {\n          // Client-side flow can use fragment or query. This can be configured on the SDK instance.\n          oauthParams.responseMode = sdk.options.responseMode || 'fragment';\n        }\n      }\n\n      var urls = oauthUtil.getOAuthUrls(sdk, oauthParams, options);\n      var requestUrl = urls.authorizeUrl + buildAuthorizeParams(oauthParams);\n\n      // Chrome >= 80 will block cookies with SameSite=None unless they are also Secure\n      // If the application is running on HTTPS, we can relax 3rd party cookie settings.\n      // This will allow embedding the app in an iframe (only if it is running on HTTPS protocol)\n      var isSecure = window.location.protocol === 'https:';\n      var cookieSettings = {\n        secure: isSecure,\n        sameSite: isSecure ? 'none' : 'lax'\n      };\n\n      // Set session cookie to store the oauthParams\n      cookies.set(constants.REDIRECT_OAUTH_PARAMS_COOKIE_NAME, JSON.stringify({\n        responseType: oauthParams.responseType,\n        state: oauthParams.state,\n        nonce: oauthParams.nonce,\n        scopes: oauthParams.scopes,\n        clientId: oauthParams.clientId,\n        urls: urls,\n        ignoreSignature: oauthParams.ignoreSignature\n      }), null, cookieSettings);\n\n      // Set nonce cookie for servers to validate nonce in id_token\n      cookies.set(constants.REDIRECT_NONCE_COOKIE_NAME, oauthParams.nonce, null, cookieSettings);\n\n      // Set state cookie for servers to validate state\n      cookies.set(constants.REDIRECT_STATE_COOKIE_NAME, oauthParams.state, null, cookieSettings);\n\n      sdk.token.getWithRedirect._setLocation(requestUrl);\n    });\n}\n\nfunction renewToken(sdk, token) {\n  if (!oauthUtil.isToken(token)) {\n    return Q.reject(new AuthSdkError('Renew must be passed a token with ' +\n      'an array of scopes and an accessToken or idToken'));\n  }\n\n  var responseType;\n  if (sdk.options.pkce) {\n    responseType = 'code';\n  } else if (token.accessToken) {\n    responseType = 'token';\n  } else {\n    responseType = 'id_token';\n  }\n\n  return sdk.token.getWithoutPrompt({\n    responseType: responseType,\n    scopes: token.scopes\n  }, {\n    authorizeUrl: token.authorizeUrl,\n    userinfoUrl: token.userinfoUrl,\n    issuer: token.issuer\n  });\n}\n\nfunction removeHash(sdk) {\n  var nativeHistory = sdk.token.parseFromUrl._getHistory();\n  var nativeDoc = sdk.token.parseFromUrl._getDocument();\n  var nativeLoc = sdk.token.parseFromUrl._getLocation();\n  if (nativeHistory && nativeHistory.replaceState) {\n    nativeHistory.replaceState(null, nativeDoc.title, nativeLoc.pathname + nativeLoc.search);\n  } else {\n    nativeLoc.hash = '';\n  }\n}\n\nfunction removeSearch(sdk) {\n  var nativeHistory = sdk.token.parseFromUrl._getHistory();\n  var nativeDoc = sdk.token.parseFromUrl._getDocument();\n  var nativeLoc = sdk.token.parseFromUrl._getLocation();\n  if (nativeHistory && nativeHistory.replaceState) {\n    nativeHistory.replaceState(null, nativeDoc.title, nativeLoc.pathname + nativeLoc.hash);\n  } else {\n    nativeLoc.search = '';\n  }\n}\n\nfunction parseFromUrl(sdk, options) {\n  options = options || {};\n  if (util.isString(options)) {\n    options = { url: options };\n  }\n\n  var url = options.url;\n  var responseMode = options.responseMode || sdk.options.responseMode || 'fragment';\n  var nativeLoc = sdk.token.parseFromUrl._getLocation();\n  var paramStr;\n\n  if (responseMode === 'query') {\n    paramStr = url ? url.substring(url.indexOf('?')) : nativeLoc.search;\n  } else {\n    paramStr = url ? url.substring(url.indexOf('#')) : nativeLoc.hash;\n  }\n\n  if (!paramStr) {\n    return Q.reject(new AuthSdkError('Unable to parse a token from the url'));\n  }\n\n  var oauthParamsCookie = cookies.get(constants.REDIRECT_OAUTH_PARAMS_COOKIE_NAME);\n  if (!oauthParamsCookie) {\n    return Q.reject(new AuthSdkError('Unable to retrieve OAuth redirect params cookie'));\n  }\n\n  try {\n    var oauthParams = JSON.parse(oauthParamsCookie);\n    var urls = oauthParams.urls;\n    delete oauthParams.urls;\n    cookies.delete(constants.REDIRECT_OAUTH_PARAMS_COOKIE_NAME);\n  } catch(e) {\n    return Q.reject(new AuthSdkError('Unable to parse the ' +\n    constants.REDIRECT_OAUTH_PARAMS_COOKIE_NAME + ' cookie: ' + e.message));\n  }\n\n  return Q.resolve(oauthUtil.urlParamsToObject(paramStr))\n    .then(function(res) {\n      if (!url) {\n        // Clean hash or search from the url\n        responseMode === 'query' ? removeSearch(sdk) : removeHash(sdk);\n      }\n      return handleOAuthResponse(sdk, oauthParams, res, urls);\n    });\n}\n\nfunction getUserInfo(sdk, accessTokenObject) {\n  if (!accessTokenObject ||\n      (!oauthUtil.isToken(accessTokenObject) && !accessTokenObject.accessToken && !accessTokenObject.userinfoUrl)) {\n    return Q.reject(new AuthSdkError('getUserInfo requires an access token object'));\n  }\n  return http.httpRequest(sdk, {\n    url: accessTokenObject.userinfoUrl,\n    method: 'GET',\n    accessToken: accessTokenObject.accessToken\n  })\n  .fail(function(err) {\n    if (err.xhr && (err.xhr.status === 401 || err.xhr.status === 403)) {\n      var authenticateHeader;\n      if (err.xhr.headers && util.isFunction(err.xhr.headers.get) && err.xhr.headers.get('WWW-Authenticate')) {\n        authenticateHeader = err.xhr.headers.get('WWW-Authenticate');\n      } else if (util.isFunction(err.xhr.getResponseHeader)) {\n        authenticateHeader = err.xhr.getResponseHeader('WWW-Authenticate');\n      }\n      if (authenticateHeader) {\n        var errorMatches = authenticateHeader.match(/error=\"(.*?)\"/) || [];\n        var errorDescriptionMatches = authenticateHeader.match(/error_description=\"(.*?)\"/) || [];\n        var error = errorMatches[1];\n        var errorDescription = errorDescriptionMatches[1];\n        if (error && errorDescription) {\n          err = new OAuthError(error, errorDescription);\n        }\n      }\n    }\n    throw err;\n  });\n}\n\nmodule.exports = {\n  revokeToken: revokeToken,\n  getToken: getToken,\n  getWithoutPrompt: getWithoutPrompt,\n  getWithPopup: getWithPopup,\n  getWithRedirect: getWithRedirect,\n  parseFromUrl: parseFromUrl,\n  decodeToken: decodeToken,\n  renewToken: renewToken,\n  getUserInfo: getUserInfo,\n  verifyToken: verifyToken,\n  handleOAuthResponse: handleOAuthResponse,\n  prepareOauthParams: prepareOauthParams\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./lib/token.js\n// module id = 25\n// module chunks = 0","/*!\n * Copyright (c) 2015-present, Okta, Inc. and/or its affiliates. All rights reserved.\n * The Okta software accompanied by this notice is provided pursuant to the Apache License, Version 2.0 (the \"License.\")\n *\n * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0.\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS, WITHOUT\n * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n *\n * See the License for the specific language governing permissions and limitations under the License.\n */\n\nvar util = require('./util');\n\nfunction verifyToken(idToken, key) {\n  key = util.clone(key);\n\n  var format = 'jwk';\n  var algo = {\n    name: 'RSASSA-PKCS1-v1_5',\n    hash: { name: 'SHA-256' }\n  };\n  var extractable = true;\n  var usages = ['verify'];\n\n  // https://connect.microsoft.com/IE/feedback/details/2242108/webcryptoapi-importing-jwk-with-use-field-fails\n  // This is a metadata tag that specifies the intent of how the key should be used.\n  // It's not necessary to properly verify the jwt's signature.\n  delete key.use;\n\n  return crypto.subtle.importKey(\n    format,\n    key,\n    algo,\n    extractable,\n    usages\n  )\n  .then(function(cryptoKey) {\n    var jwt = idToken.split('.');\n    var payload = util.stringToBuffer(jwt[0] + '.' + jwt[1]);\n    var b64Signature = util.base64UrlDecode(jwt[2]);\n    var signature = util.stringToBuffer(b64Signature);\n\n    return crypto.subtle.verify(\n      algo,\n      cryptoKey,\n      signature,\n      payload\n    );\n  });\n}\n\nmodule.exports = {\n  verifyToken: verifyToken\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./lib/crypto.js\n// module id = 26\n// module chunks = 0","/*!\n * Copyright (c) 2015-present, Okta, Inc. and/or its affiliates. All rights reserved.\n * The Okta software accompanied by this notice is provided pursuant to the Apache License, Version 2.0 (the \"License.\")\n *\n * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0.\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS, WITHOUT\n * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n *\n * See the License for the specific language governing permissions and limitations under the License.\n */\n\nfunction OAuthError(errorCode, summary) {\n  this.name = 'OAuthError';\n  this.message = summary;\n\n  this.errorCode = errorCode;\n  this.errorSummary = summary;\n}\nOAuthError.prototype = new Error();\n\nmodule.exports = OAuthError;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./lib/errors/OAuthError.js\n// module id = 27\n// module chunks = 0","/*!\n * Copyright (c) 2019-present, Okta, Inc. and/or its affiliates. All rights reserved.\n * The Okta software accompanied by this notice is provided pursuant to the Apache License, Version 2.0 (the \"License.\")\n *\n * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0.\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS, WITHOUT\n * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n *\n * See the License for the specific language governing permissions and limitations under the License.\n *\n */\n\n /* eslint-disable complexity, max-statements */\nvar AuthSdkError  = require('./errors/AuthSdkError');\nvar http          = require('./http');\nvar util          = require('./util');\n\n// Code verifier: Random URL-safe string with a minimum length of 43 characters.\n// Code challenge: Base64 URL-encoded SHA-256 hash of the code verifier.\nvar MIN_VERIFIER_LENGTH = 43;\nvar MAX_VERIFIER_LENGTH = 128;\nvar DEFAULT_CODE_CHALLENGE_METHOD = 'S256';\n\nfunction dec2hex (dec) {\n  return ('0' + dec.toString(16)).substr(-2);\n}\n\nfunction getRandomString(length) {\n  var a = new Uint8Array(Math.ceil(length / 2));\n  crypto.getRandomValues(a);\n  var str = Array.from(a, dec2hex).join('');\n  return str.slice(0, length);\n}\n\nfunction generateVerifier(prefix) {\n  var verifier = prefix || '';\n  if (verifier.length < MIN_VERIFIER_LENGTH) {\n    verifier = verifier + getRandomString(MIN_VERIFIER_LENGTH - verifier.length);\n  }\n  return encodeURIComponent(verifier).slice(0, MAX_VERIFIER_LENGTH);\n}\n\nfunction saveMeta(sdk, meta) {\n  var storage = sdk.options.storageUtil.getPKCEStorage();\n  storage.setStorage(meta);\n}\n\nfunction loadMeta(sdk) {\n  var storage = sdk.options.storageUtil.getPKCEStorage();\n  var obj = storage.getStorage();\n  return obj;\n}\n\nfunction clearMeta(sdk) {\n  var storage = sdk.options.storageUtil.getPKCEStorage();\n  storage.clearStorage();\n}\n\n/* global Uint8Array, TextEncoder */\nfunction computeChallenge(str) {  \n  var buffer = new TextEncoder().encode(str);\n  return crypto.subtle.digest('SHA-256', buffer).then(function(arrayBuffer) {\n    var hash = String.fromCharCode.apply(null, new Uint8Array(arrayBuffer));\n    var b64u = util.stringToBase64Url(hash); // url-safe base64 variant\n    return b64u;\n  });\n}\n\n\nfunction validateOptions(oauthOptions) {\n  // Quick validation\n  if (!oauthOptions.clientId) {\n    throw new AuthSdkError('A clientId must be specified in the OktaAuth constructor to get a token');\n  }\n\n  if (!oauthOptions.redirectUri) {\n    throw new AuthSdkError('The redirectUri passed to /authorize must also be passed to /token');\n  }\n\n  if (!oauthOptions.authorizationCode) {\n    throw new AuthSdkError('An authorization code (returned from /authorize) must be passed to /token');\n  }\n\n  if (!oauthOptions.codeVerifier) {\n    throw new AuthSdkError('The \"codeVerifier\" (generated and saved by your app) must be passed to /token');\n  }\n}\n\nfunction getPostData(options) {\n  // Convert options to OAuth params\n  var params = util.removeNils({\n    'client_id': options.clientId,\n    'redirect_uri': options.redirectUri,\n    'grant_type': 'authorization_code',\n    'code': options.authorizationCode,\n    'code_verifier': options.codeVerifier\n  });\n  // Encode as URL string\n  return util.toQueryParams(params).slice(1);\n}\n\n// exchange authorization code for an access token\nfunction getToken(sdk, oauthOptions, urls) {\n  validateOptions(oauthOptions);\n  var data = getPostData(oauthOptions);\n\n  return http.httpRequest(sdk, {\n    url: urls.tokenUrl,\n    method: 'POST',\n    args: data,\n    withCredentials: false,\n    headers: {\n      'Content-Type': 'application/x-www-form-urlencoded'\n    }\n  });\n}\n\nmodule.exports = {\n  DEFAULT_CODE_CHALLENGE_METHOD: DEFAULT_CODE_CHALLENGE_METHOD,\n  generateVerifier: generateVerifier,\n  clearMeta: clearMeta,\n  saveMeta: saveMeta,\n  loadMeta: loadMeta,\n  computeChallenge: computeChallenge,\n  getToken: getToken\n};\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./lib/pkce.js\n// module id = 28\n// module chunks = 0","/*!\n * Copyright (c) 2015-present, Okta, Inc. and/or its affiliates. All rights reserved.\n * The Okta software accompanied by this notice is provided pursuant to the Apache License, Version 2.0 (the \"License.\")\n *\n * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0.\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS, WITHOUT\n * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n *\n * See the License for the specific language governing permissions and limitations under the License.\n *\n */\n\n/* eslint complexity:[0,8] max-statements:[0,21] */\nvar util = require('./util');\nvar AuthSdkError = require('./errors/AuthSdkError');\nvar storageUtil = require('./browser/browserStorage');\nvar Q = require('q');\nvar constants = require('./constants');\nvar storageBuilder = require('./storageBuilder');\nvar SdkClock = require('./clock');\n\nvar DEFAULT_OPTIONS = {\n  autoRenew: true,\n  storage: 'localStorage',\n  expireEarlySeconds: 30\n};\n\nfunction getExpireTime(tokenMgmtRef, token) {\n  var expireTime = token.expiresAt - tokenMgmtRef.options.expireEarlySeconds;\n  return expireTime;\n}\n\nfunction hasExpired(tokenMgmtRef, token) {\n  var expireTime = getExpireTime(tokenMgmtRef, token);\n  return expireTime <= tokenMgmtRef.clock.now();\n}\n\nfunction emitExpired(tokenMgmtRef, key, token) {\n  tokenMgmtRef.emitter.emit('expired', key, token);\n}\n\nfunction emitError(tokenMgmtRef, error) {\n  tokenMgmtRef.emitter.emit('error', error);\n}\n\nfunction clearExpireEventTimeout(tokenMgmtRef, key) {\n  clearTimeout(tokenMgmtRef.expireTimeouts[key]);\n  delete tokenMgmtRef.expireTimeouts[key];\n\n  // Remove the renew promise (if it exists)\n  delete tokenMgmtRef.renewPromise[key];\n}\n\nfunction clearExpireEventTimeoutAll(tokenMgmtRef) {\n  var expireTimeouts = tokenMgmtRef.expireTimeouts;\n  for (var key in expireTimeouts) {\n    if (!expireTimeouts.hasOwnProperty(key)) {\n      continue;\n    }\n    clearExpireEventTimeout(tokenMgmtRef, key);\n  }\n}\n\nfunction setExpireEventTimeout(sdk, tokenMgmtRef, key, token) {\n  var expireTime = getExpireTime(tokenMgmtRef, token);\n  var expireEventWait = Math.max(expireTime - tokenMgmtRef.clock.now(), 0) * 1000;\n\n  // Clear any existing timeout\n  clearExpireEventTimeout(tokenMgmtRef, key);\n\n  var expireEventTimeout = setTimeout(function() {\n    emitExpired(tokenMgmtRef, key, token);\n  }, expireEventWait);\n\n  // Add a new timeout\n  tokenMgmtRef.expireTimeouts[key] = expireEventTimeout;\n}\n\nfunction setExpireEventTimeoutAll(sdk, tokenMgmtRef, storage) {\n  try {\n    var tokenStorage = storage.getStorage();\n  } catch(e) {\n    // Any errors thrown on instantiation will not be caught,\n    // because there are no listeners yet\n    emitError(tokenMgmtRef, e);\n    return;\n  }\n\n  for(var key in tokenStorage) {\n    if (!tokenStorage.hasOwnProperty(key)) {\n      continue;\n    }\n    var token = tokenStorage[key];\n    setExpireEventTimeout(sdk, tokenMgmtRef, key, token);\n  }\n}\n\nfunction add(sdk, tokenMgmtRef, storage, key, token) {\n  var tokenStorage = storage.getStorage();\n  if (!util.isObject(token) ||\n      !token.scopes ||\n      (!token.expiresAt && token.expiresAt !== 0) ||\n      (!token.idToken && !token.accessToken)) {\n    throw new AuthSdkError('Token must be an Object with scopes, expiresAt, and an idToken or accessToken properties');\n  }\n  tokenStorage[key] = token;\n  storage.setStorage(tokenStorage);\n  setExpireEventTimeout(sdk, tokenMgmtRef, key, token);\n}\n\nfunction get(storage, key) {\n  var tokenStorage = storage.getStorage();\n  return tokenStorage[key];\n}\n\nfunction getAsync(sdk, tokenMgmtRef, storage, key) {\n  return Q.Promise(function(resolve) {\n    var token = get(storage, key);\n    if (!token || !hasExpired(tokenMgmtRef, token)) {\n      return resolve(token);\n    }\n\n    var tokenPromise = tokenMgmtRef.options.autoRenew\n      ? renew(sdk, tokenMgmtRef, storage, key)\n      : remove(tokenMgmtRef, storage, key);\n\n    return resolve(tokenPromise);\n  });\n}\n\nfunction remove(tokenMgmtRef, storage, key) {\n  // Clear any listener for this token\n  clearExpireEventTimeout(tokenMgmtRef, key);\n\n  // Remove it from storage\n  var tokenStorage = storage.getStorage();\n  delete tokenStorage[key];\n  storage.setStorage(tokenStorage);\n}\n\nfunction renew(sdk, tokenMgmtRef, storage, key) {\n  // Multiple callers may receive the same promise. They will all resolve or reject from the same request.\n  var existingPromise = tokenMgmtRef.renewPromise[key];\n  if (existingPromise) {\n    return existingPromise;\n  }\n\n  try {\n    var token = get(storage, key);\n    if (!token) {\n      throw new AuthSdkError('The tokenManager has no token for the key: ' + key);\n    }\n  } catch (e) {\n    return Q.reject(e);\n  }\n\n  // Remove existing autoRenew timeout for this key\n  clearExpireEventTimeout(tokenMgmtRef, key);\n\n  // Store the renew promise state, to avoid renewing again\n  tokenMgmtRef.renewPromise[key] = sdk.token.renew(token)\n    .then(function(freshTokens) {\n      var freshToken = freshTokens;\n      // With PKCE flow we will receive multiple tokens. Find the one we are looking for\n      if (freshTokens instanceof Array) {\n        freshToken = freshTokens.find(function(freshToken) {\n          return (freshToken.idToken && token.idToken) || (freshToken.accessToken && token.accessToken);\n        });\n      }\n\n      var oldToken = get(storage, key);\n      if (!oldToken) {\n        // It is possible to enter a state where the tokens have been cleared\n        // after a renewal request was triggered. To ensure we do not store a\n        // renewed token, we verify the promise key doesn't exist and return.\n        return;\n      }\n      add(sdk, tokenMgmtRef, storage, key, freshToken);\n      tokenMgmtRef.emitter.emit('renewed', key, freshToken, oldToken);\n      return freshToken;\n    })\n    .catch(function(err) {\n      if (err.name === 'OAuthError' || err.name === 'AuthSdkError') {\n        remove(tokenMgmtRef, storage, key);\n        err.tokenKey = key;\n        err.accessToken = !!token.accessToken;\n        emitError(tokenMgmtRef, err);\n      }\n      throw err;\n    })\n    .finally(function() {\n      // Remove existing promise key\n      delete tokenMgmtRef.renewPromise[key];\n    });\n\n  return tokenMgmtRef.renewPromise[key];\n}\n\nfunction clear(tokenMgmtRef, storage) {\n  clearExpireEventTimeoutAll(tokenMgmtRef);\n  storage.clearStorage();\n}\n\nfunction TokenManager(sdk, options) {\n  options = util.extend({}, DEFAULT_OPTIONS, util.removeNils(options));\n\n  if (options.storage === 'localStorage' && !storageUtil.browserHasLocalStorage()) {\n    util.warn('This browser doesn\\'t support localStorage. Switching to sessionStorage.');\n    options.storage = 'sessionStorage';\n  }\n\n  if (options.storage === 'sessionStorage' && !storageUtil.browserHasSessionStorage()) {\n    util.warn('This browser doesn\\'t support sessionStorage. Switching to cookie-based storage.');\n    options.storage = 'cookie';\n  }\n\n  var storageProvider;\n  if (typeof options.storage === 'object') {\n    // A custom storage provider must implement getItem(key) and setItem(key, val)\n    storageProvider = options.storage;\n  } else {\n    switch(options.storage) {\n      case 'localStorage':\n        storageProvider = localStorage;\n        break;\n      case 'sessionStorage':\n        storageProvider = sessionStorage;\n        break;\n      case 'cookie':\n        storageProvider = storageUtil.getCookieStorage(options);\n        break;\n      case 'memory':\n        storageProvider = storageUtil.getInMemoryStorage();\n        break;\n      default:\n        throw new AuthSdkError('Unrecognized storage option');\n    }\n  }\n  var storageKey = options.storageKey || constants.TOKEN_STORAGE_NAME;\n  var storage = storageBuilder(storageProvider, storageKey);\n  var clock = SdkClock.create(sdk, options);\n  var tokenMgmtRef = {\n    clock: clock,\n    options: options,\n    emitter: sdk.emitter,\n    expireTimeouts: {},\n    renewPromise: {}\n  };\n\n  this.add = util.bind(add, this, sdk, tokenMgmtRef, storage);\n  this.get = util.bind(getAsync, this, sdk, tokenMgmtRef, storage);\n  this.remove = util.bind(remove, this, tokenMgmtRef, storage);\n  this.clear = util.bind(clear, this, tokenMgmtRef, storage);\n  this.renew = util.bind(renew, this, sdk, tokenMgmtRef, storage);\n  this.on = util.bind(tokenMgmtRef.emitter.on, tokenMgmtRef.emitter);\n  this.off = util.bind(tokenMgmtRef.emitter.off, tokenMgmtRef.emitter);\n\n  setExpireEventTimeoutAll(sdk, tokenMgmtRef, storage);\n}\n\nmodule.exports = TokenManager;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./lib/TokenManager.js\n// module id = 29\n// module chunks = 0","var util = require('./util');\n\nfunction SdkClock(localOffset) {\n  // Calculated local clock offset from server time (in milliseconds). Can be positive or negative.\n  this.localOffset = parseInt(localOffset || 0);\n}\n\nutil.extend(SdkClock.prototype, {\n  // Return the current time (in seconds)\n  now: function() {\n    var now = (Date.now() + this.localOffset) / 1000;\n    return now;\n  }\n});\n\n// factory method. Create an instance of a clock from current context.\nSdkClock.create = function(/* sdk, options */) {\n  // TODO: calculate localOffset\n  var localOffset = 0;\n  return new SdkClock(localOffset);\n};\n\nmodule.exports = SdkClock;\n\n\n\n//////////////////\n// WEBPACK FOOTER\n// ./lib/clock.js\n// module id = 30\n// module chunks = 0"],"sourceRoot":""}