{"version":3,"file":"okta-auth-js.min.js","mappings":"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","sources":["webpack://OktaAuth/./lib/authn/AuthnTransactionImpl.ts","webpack://OktaAuth/./lib/authn/api.ts","webpack://OktaAuth/./lib/authn/factory.ts","webpack://OktaAuth/./lib/authn/index.ts","webpack://OktaAuth/./lib/authn/mixin.ts","webpack://OktaAuth/./lib/authn/util/flattenEmbedded.ts","webpack://OktaAuth/./lib/authn/util/link2fn.ts","webpack://OktaAuth/./lib/authn/util/links2fns.ts","webpack://OktaAuth/./lib/authn/util/poll.ts","webpack://OktaAuth/./lib/authn/util/stateToken.ts","webpack://OktaAuth/./lib/base/factory.ts","webpack://OktaAuth/./lib/base/index.ts","webpack://OktaAuth/./lib/base/options.ts","webpack://OktaAuth/./lib/browser/browserStorage.ts","webpack://OktaAuth/./lib/browser/fingerprint.ts","webpack://OktaAuth/./lib/clock.ts","webpack://OktaAuth/./lib/constants.ts","webpack://OktaAuth/./lib/core/AuthStateManager.ts","webpack://OktaAuth/./lib/core/ServiceManager/browser.ts","webpack://OktaAuth/./lib/core/ServiceManager/index.ts","webpack://OktaAuth/./lib/core/factory.ts","webpack://OktaAuth/./lib/core/index.ts","webpack://OktaAuth/./lib/core/mixin.ts","webpack://OktaAuth/./lib/core/options.ts","webpack://OktaAuth/./lib/core/storage.ts","webpack://OktaAuth/./lib/core/types/index.ts","webpack://OktaAuth/./lib/crypto/base64.ts","webpack://OktaAuth/./lib/crypto/browser.ts","webpack://OktaAuth/./lib/crypto/index.ts","webpack://OktaAuth/./lib/crypto/oidcHash.ts","webpack://OktaAuth/./lib/crypto/verifyToken.ts","webpack://OktaAuth/./lib/crypto/webcrypto.ts","webpack://OktaAuth/./lib/errors/AuthApiError.ts","webpack://OktaAuth/./lib/errors/AuthPollStopError.ts","webpack://OktaAuth/./lib/errors/AuthSdkError.ts","webpack://OktaAuth/./lib/errors/CustomError.ts","webpack://OktaAuth/./lib/errors/OAuthError.ts","webpack://OktaAuth/./lib/errors/WWWAuthError.ts","webpack://OktaAuth/./lib/errors/index.ts","webpack://OktaAuth/./lib/exports/cdn/default.ts","webpack://OktaAuth/./lib/exports/common.ts","webpack://OktaAuth/./lib/exports/default.ts","webpack://OktaAuth/./lib/features.ts","webpack://OktaAuth/./lib/fetch/fetchRequest.ts","webpack://OktaAuth/./lib/http/OktaUserAgent.ts","webpack://OktaAuth/./lib/http/headers.ts","webpack://OktaAuth/./lib/http/index.ts","webpack://OktaAuth/./lib/http/mixin.ts","webpack://OktaAuth/./lib/http/options.ts","webpack://OktaAuth/./lib/http/request.ts","webpack://OktaAuth/./lib/idx/IdxTransactionManager.ts","webpack://OktaAuth/./lib/idx/authenticate.ts","webpack://OktaAuth/./lib/idx/authenticator/Authenticator.ts","webpack://OktaAuth/./lib/idx/authenticator/OktaPassword.ts","webpack://OktaAuth/./lib/idx/authenticator/OktaVerifyTotp.ts","webpack://OktaAuth/./lib/idx/authenticator/SecurityQuestionEnrollment.ts","webpack://OktaAuth/./lib/idx/authenticator/SecurityQuestionVerification.ts","webpack://OktaAuth/./lib/idx/authenticator/VerificationCodeAuthenticator.ts","webpack://OktaAuth/./lib/idx/authenticator/WebauthnEnrollment.ts","webpack://OktaAuth/./lib/idx/authenticator/WebauthnVerification.ts","webpack://OktaAuth/./lib/idx/authenticator/getAuthenticator.ts","webpack://OktaAuth/./lib/idx/authenticator/index.ts","webpack://OktaAuth/./lib/idx/authenticator/util.ts","webpack://OktaAuth/./lib/idx/cancel.ts","webpack://OktaAuth/./lib/idx/emailVerify.ts","webpack://OktaAuth/./lib/idx/factory/MinimalOktaAuthIdx.ts","webpack://OktaAuth/./lib/idx/factory/OktaAuthIdx.ts","webpack://OktaAuth/./lib/idx/factory/api.ts","webpack://OktaAuth/./lib/idx/factory/index.ts","webpack://OktaAuth/./lib/idx/factory/minimalApi.ts","webpack://OktaAuth/./lib/idx/flow/AccountUnlockFlow.ts","webpack://OktaAuth/./lib/idx/flow/AuthenticationFlow.ts","webpack://OktaAuth/./lib/idx/flow/FlowSpecification.ts","webpack://OktaAuth/./lib/idx/flow/PasswordRecoveryFlow.ts","webpack://OktaAuth/./lib/idx/flow/RegistrationFlow.ts","webpack://OktaAuth/./lib/idx/flow/index.ts","webpack://OktaAuth/./lib/idx/handleInteractionCodeRedirect.ts","webpack://OktaAuth/./lib/idx/idxState/index.ts","webpack://OktaAuth/./lib/idx/idxState/v1/actionParser.ts","webpack://OktaAuth/./lib/idx/idxState/v1/generateIdxAction.ts","webpack://OktaAuth/./lib/idx/idxState/v1/idxResponseParser.ts","webpack://OktaAuth/./lib/idx/idxState/v1/makeIdxState.ts","webpack://OktaAuth/./lib/idx/idxState/v1/parsers.ts","webpack://OktaAuth/./lib/idx/idxState/v1/remediationParser.ts","webpack://OktaAuth/./lib/idx/index.ts","webpack://OktaAuth/./lib/idx/interact.ts","webpack://OktaAuth/./lib/idx/introspect.ts","webpack://OktaAuth/./lib/idx/mixin.ts","webpack://OktaAuth/./lib/idx/mixinMinimal.ts","webpack://OktaAuth/./lib/idx/options.ts","webpack://OktaAuth/./lib/idx/poll.ts","webpack://OktaAuth/./lib/idx/proceed.ts","webpack://OktaAuth/./lib/idx/recoverPassword.ts","webpack://OktaAuth/./lib/idx/register.ts","webpack://OktaAuth/./lib/idx/remediate.ts","webpack://OktaAuth/./lib/idx/remediators/AuthenticatorEnrollmentData.ts","webpack://OktaAuth/./lib/idx/remediators/AuthenticatorVerificationData.ts","webpack://OktaAuth/./lib/idx/remediators/Base/AuthenticatorData.ts","webpack://OktaAuth/./lib/idx/remediators/Base/Remediator.ts","webpack://OktaAuth/./lib/idx/remediators/Base/SelectAuthenticator.ts","webpack://OktaAuth/./lib/idx/remediators/Base/VerifyAuthenticator.ts","webpack://OktaAuth/./lib/idx/remediators/ChallengeAuthenticator.ts","webpack://OktaAuth/./lib/idx/remediators/ChallengePoll.ts","webpack://OktaAuth/./lib/idx/remediators/EnrollAuthenticator.ts","webpack://OktaAuth/./lib/idx/remediators/EnrollPoll.ts","webpack://OktaAuth/./lib/idx/remediators/EnrollProfile.ts","webpack://OktaAuth/./lib/idx/remediators/EnrollmentChannelData.ts","webpack://OktaAuth/./lib/idx/remediators/GenericRemediator/GenericRemediator.ts","webpack://OktaAuth/./lib/idx/remediators/GenericRemediator/index.ts","webpack://OktaAuth/./lib/idx/remediators/GenericRemediator/util.ts","webpack://OktaAuth/./lib/idx/remediators/Identify.ts","webpack://OktaAuth/./lib/idx/remediators/ReEnrollAuthenticator.ts","webpack://OktaAuth/./lib/idx/remediators/ReEnrollAuthenticatorWarning.ts","webpack://OktaAuth/./lib/idx/remediators/RedirectIdp.ts","webpack://OktaAuth/./lib/idx/remediators/ResetAuthenticator.ts","webpack://OktaAuth/./lib/idx/remediators/SelectAuthenticatorAuthenticate.ts","webpack://OktaAuth/./lib/idx/remediators/SelectAuthenticatorEnroll.ts","webpack://OktaAuth/./lib/idx/remediators/SelectAuthenticatorUnlockAccount.ts","webpack://OktaAuth/./lib/idx/remediators/SelectEnrollProfile.ts","webpack://OktaAuth/./lib/idx/remediators/SelectEnrollmentChannel.ts","webpack://OktaAuth/./lib/idx/remediators/Skip.ts","webpack://OktaAuth/./lib/idx/remediators/index.ts","webpack://OktaAuth/./lib/idx/remediators/util.ts","webpack://OktaAuth/./lib/idx/run.ts","webpack://OktaAuth/./lib/idx/startTransaction.ts","webpack://OktaAuth/./lib/idx/storage.ts","webpack://OktaAuth/./lib/idx/transactionMeta.ts","webpack://OktaAuth/./lib/idx/types/api.ts","webpack://OktaAuth/./lib/idx/types/idx-js.ts","webpack://OktaAuth/./lib/idx/types/index.ts","webpack://OktaAuth/./lib/idx/unlockAccount.ts","webpack://OktaAuth/./lib/idx/util.ts","webpack://OktaAuth/./lib/idx/webauthn.ts","webpack://OktaAuth/./lib/myaccount/api.ts","webpack://OktaAuth/./lib/myaccount/emailApi.ts","webpack://OktaAuth/./lib/myaccount/factory.ts","webpack://OktaAuth/./lib/myaccount/index.ts","webpack://OktaAuth/./lib/myaccount/mixin.ts","webpack://OktaAuth/./lib/myaccount/passwordApi.ts","webpack://OktaAuth/./lib/myaccount/phoneApi.ts","webpack://OktaAuth/./lib/myaccount/profileApi.ts","webpack://OktaAuth/./lib/myaccount/request.ts","webpack://OktaAuth/./lib/myaccount/transactions/Base.ts","webpack://OktaAuth/./lib/myaccount/transactions/EmailChallengeTransaction.ts","webpack://OktaAuth/./lib/myaccount/transactions/EmailStatusTransaction.ts","webpack://OktaAuth/./lib/myaccount/transactions/EmailTransaction.ts","webpack://OktaAuth/./lib/myaccount/transactions/PasswordTransaction.ts","webpack://OktaAuth/./lib/myaccount/transactions/PhoneTransaction.ts","webpack://OktaAuth/./lib/myaccount/transactions/ProfileSchemaTransaction.ts","webpack://OktaAuth/./lib/myaccount/transactions/ProfileTransaction.ts","webpack://OktaAuth/./lib/myaccount/transactions/index.ts","webpack://OktaAuth/./lib/myaccount/types.ts","webpack://OktaAuth/./lib/oidc/TokenManager.ts","webpack://OktaAuth/./lib/oidc/TransactionManager.ts","webpack://OktaAuth/./lib/oidc/decodeToken.ts","webpack://OktaAuth/./lib/oidc/dpop.ts","webpack://OktaAuth/./lib/oidc/endpoints/authorize.ts","webpack://OktaAuth/./lib/oidc/endpoints/index.ts","webpack://OktaAuth/./lib/oidc/endpoints/token.ts","webpack://OktaAuth/./lib/oidc/endpoints/well-known.ts","webpack://OktaAuth/./lib/oidc/enrollAuthenticator.ts","webpack://OktaAuth/./lib/oidc/exchangeCodeForTokens.ts","webpack://OktaAuth/./lib/oidc/factory/OktaAuthOAuth.ts","webpack://OktaAuth/./lib/oidc/factory/api.ts","webpack://OktaAuth/./lib/oidc/factory/baseApi.ts","webpack://OktaAuth/./lib/oidc/factory/index.ts","webpack://OktaAuth/./lib/oidc/getToken.ts","webpack://OktaAuth/./lib/oidc/getUserInfo.ts","webpack://OktaAuth/./lib/oidc/getWithPopup.ts","webpack://OktaAuth/./lib/oidc/getWithRedirect.ts","webpack://OktaAuth/./lib/oidc/getWithoutPrompt.ts","webpack://OktaAuth/./lib/oidc/handleOAuthResponse.ts","webpack://OktaAuth/./lib/oidc/index.ts","webpack://OktaAuth/./lib/oidc/introspect.ts","webpack://OktaAuth/./lib/oidc/mixin/browser.ts","webpack://OktaAuth/./lib/oidc/mixin/index.ts","webpack://OktaAuth/./lib/oidc/mixin/minimal.ts","webpack://OktaAuth/./lib/oidc/options/OAuthOptionsConstructor.ts","webpack://OktaAuth/./lib/oidc/options/browser.ts","webpack://OktaAuth/./lib/oidc/options/index.ts","webpack://OktaAuth/./lib/oidc/parseFromUrl.ts","webpack://OktaAuth/./lib/oidc/renewToken.ts","webpack://OktaAuth/./lib/oidc/renewTokens.ts","webpack://OktaAuth/./lib/oidc/renewTokensWithRefresh.ts","webpack://OktaAuth/./lib/oidc/revokeToken.ts","webpack://OktaAuth/./lib/oidc/storage.ts","webpack://OktaAuth/./lib/oidc/types/Token.ts","webpack://OktaAuth/./lib/oidc/types/TokenManager.ts","webpack://OktaAuth/./lib/oidc/types/Transaction.ts","webpack://OktaAuth/./lib/oidc/types/index.ts","webpack://OktaAuth/./lib/oidc/util/browser.ts","webpack://OktaAuth/./lib/oidc/util/defaultEnrollAuthenticatorParams.ts","webpack://OktaAuth/./lib/oidc/util/defaultTokenParams.ts","webpack://OktaAuth/./lib/oidc/util/enrollAuthenticatorMeta.ts","webpack://OktaAuth/./lib/oidc/util/errors.ts","webpack://OktaAuth/./lib/oidc/util/index.ts","webpack://OktaAuth/./lib/oidc/util/loginRedirect.ts","webpack://OktaAuth/./lib/oidc/util/oauth.ts","webpack://OktaAuth/./lib/oidc/util/oauthMeta.ts","webpack://OktaAuth/./lib/oidc/util/pkce.ts","webpack://OktaAuth/./lib/oidc/util/prepareEnrollAuthenticatorParams.ts","webpack://OktaAuth/./lib/oidc/util/prepareTokenParams.ts","webpack://OktaAuth/./lib/oidc/util/refreshToken.ts","webpack://OktaAuth/./lib/oidc/util/sharedStorage.ts","webpack://OktaAuth/./lib/oidc/util/urlParams.ts","webpack://OktaAuth/./lib/oidc/util/validateClaims.ts","webpack://OktaAuth/./lib/oidc/util/validateToken.ts","webpack://OktaAuth/./lib/oidc/verifyToken.ts","webpack://OktaAuth/./lib/services/AutoRenewService.ts","webpack://OktaAuth/./lib/services/LeaderElectionService.ts","webpack://OktaAuth/./lib/services/RenewOnTabActivationService.ts","webpack://OktaAuth/./lib/services/SyncStorageService.ts","webpack://OktaAuth/./lib/services/index.ts","webpack://OktaAuth/./lib/session/api.ts","webpack://OktaAuth/./lib/session/factory.ts","webpack://OktaAuth/./lib/session/index.ts","webpack://OktaAuth/./lib/session/mixin.ts","webpack://OktaAuth/./lib/storage/BaseStorageManager.ts","webpack://OktaAuth/./lib/storage/SavedObject.ts","webpack://OktaAuth/./lib/storage/index.ts","webpack://OktaAuth/./lib/storage/mixin.ts","webpack://OktaAuth/./lib/storage/options/StorageOptionsConstructor.ts","webpack://OktaAuth/./lib/storage/options/browser.ts","webpack://OktaAuth/./lib/util/PromiseQueue.ts","webpack://OktaAuth/./lib/util/console.ts","webpack://OktaAuth/./lib/util/index.ts","webpack://OktaAuth/./lib/util/jsonpath.ts","webpack://OktaAuth/./lib/util/misc.ts","webpack://OktaAuth/./lib/util/object.ts","webpack://OktaAuth/./lib/util/types.ts","webpack://OktaAuth/./lib/util/url.ts","webpack://OktaAuth/./node_modules/p-cancelable/index.js","webpack://OktaAuth/./node_modules/broadcast-channel/dist/lib/broadcast-channel.js","webpack://OktaAuth/./node_modules/broadcast-channel/dist/lib/index.es5.js","webpack://OktaAuth/./node_modules/broadcast-channel/dist/lib/index.js","webpack://OktaAuth/./node_modules/broadcast-channel/dist/lib/leader-election-util.js","webpack://OktaAuth/./node_modules/broadcast-channel/dist/lib/leader-election-web-lock.js","webpack://OktaAuth/./node_modules/broadcast-channel/dist/lib/leader-election.js","webpack://OktaAuth/./node_modules/broadcast-channel/dist/lib/method-chooser.js","webpack://OktaAuth/./node_modules/broadcast-channel/dist/lib/methods/indexed-db.js","webpack://OktaAuth/./node_modules/broadcast-channel/dist/lib/methods/localstorage.js","webpack://OktaAuth/./node_modules/broadcast-channel/dist/lib/methods/native.js","webpack://OktaAuth/./node_modules/broadcast-channel/dist/lib/methods/simulate.js","webpack://OktaAuth/./node_modules/broadcast-channel/dist/lib/options.js","webpack://OktaAuth/./node_modules/broadcast-channel/dist/lib/util.js","webpack://OktaAuth/./node_modules/cross-fetch/dist/browser-ponyfill.js","webpack://OktaAuth/./node_modules/js-cookie/dist/js.cookie.js","webpack://OktaAuth/./node_modules/oblivious-set/dist/es/index.js","webpack://OktaAuth/./node_modules/tiny-emitter/index.js","webpack://OktaAuth/./node_modules/unload/dist/es/index.js","webpack://OktaAuth/./node_modules/unload/dist/es/node.js","webpack://OktaAuth/./node_modules/unload/dist/es/browser.js","webpack://OktaAuth/./node_modules/@babel/runtime/helpers/arrayLikeToArray.js","webpack://OktaAuth/./node_modules/@babel/runtime/helpers/arrayWithHoles.js","webpack://OktaAuth/./node_modules/@babel/runtime/helpers/arrayWithoutHoles.js","webpack://OktaAuth/./node_modules/@babel/runtime/helpers/assertThisInitialized.js","webpack://OktaAuth/./node_modules/@babel/runtime/helpers/asyncToGenerator.js","webpack://OktaAuth/./node_modules/@babel/runtime/helpers/classCallCheck.js","webpack://OktaAuth/./node_modules/@babel/runtime/helpers/construct.js","webpack://OktaAuth/./node_modules/@babel/runtime/helpers/createClass.js","webpack://OktaAuth/./node_modules/@babel/runtime/helpers/defineProperty.js","webpack://OktaAuth/./node_modules/@babel/runtime/helpers/get.js","webpack://OktaAuth/./node_modules/@babel/runtime/helpers/getPrototypeOf.js","webpack://OktaAuth/./node_modules/@babel/runtime/helpers/inherits.js","webpack://OktaAuth/./node_modules/@babel/runtime/helpers/interopRequireDefault.js","webpack://OktaAuth/./node_modules/@babel/runtime/helpers/isNativeFunction.js","webpack://OktaAuth/./node_modules/@babel/runtime/helpers/isNativeReflectConstruct.js","webpack://OktaAuth/./node_modules/@babel/runtime/helpers/iterableToArray.js","webpack://OktaAuth/./node_modules/@babel/runtime/helpers/iterableToArrayLimit.js","webpack://OktaAuth/./node_modules/@babel/runtime/helpers/nonIterableRest.js","webpack://OktaAuth/./node_modules/@babel/runtime/helpers/nonIterableSpread.js","webpack://OktaAuth/./node_modules/@babel/runtime/helpers/objectWithoutProperties.js","webpack://OktaAuth/./node_modules/@babel/runtime/helpers/objectWithoutPropertiesLoose.js","webpack://OktaAuth/./node_modules/@babel/runtime/helpers/possibleConstructorReturn.js","webpack://OktaAuth/./node_modules/@babel/runtime/helpers/regeneratorRuntime.js","webpack://OktaAuth/./node_modules/@babel/runtime/helpers/setPrototypeOf.js","webpack://OktaAuth/./node_modules/@babel/runtime/helpers/slicedToArray.js","webpack://OktaAuth/./node_modules/@babel/runtime/helpers/superPropBase.js","webpack://OktaAuth/./node_modules/@babel/runtime/helpers/toConsumableArray.js","webpack://OktaAuth/./node_modules/@babel/runtime/helpers/typeof.js","webpack://OktaAuth/./node_modules/@babel/runtime/helpers/unsupportedIterableToArray.js","webpack://OktaAuth/./node_modules/@babel/runtime/helpers/wrapNativeSuper.js","webpack://OktaAuth/./node_modules/@babel/runtime/regenerator/index.js","webpack://OktaAuth/./node_modules/broadcast-channel/node_modules/@babel/runtime/helpers/typeof.js","webpack://OktaAuth/./node_modules/jsonpath-plus/dist/index-browser-esm.js","webpack://OktaAuth/webpack/bootstrap","webpack://OktaAuth/webpack/runtime/define property getters","webpack://OktaAuth/webpack/runtime/global","webpack://OktaAuth/webpack/runtime/hasOwnProperty shorthand","webpack://OktaAuth/webpack/runtime/make namespace object","webpack://OktaAuth/webpack/startup"],"sourcesContent":["/*!\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\nimport { OktaAuthHttpInterface } from '../http/types';\nimport {\n  AuthnTransactionFunction,\n  AuthnTransaction,\n  AuthnTransactionAPI,\n  AuthnTransactionState\n} from './types';\nimport { flattenEmbedded } from './util/flattenEmbedded';\n\nexport class AuthnTransactionImpl implements AuthnTransaction {\n  next?: AuthnTransactionFunction;\n  cancel?: AuthnTransactionFunction;\n  skip?: AuthnTransactionFunction;\n  unlock?: AuthnTransactionFunction;\n  changePassword?: AuthnTransactionFunction;\n  resetPassword?: AuthnTransactionFunction;\n  answer?: AuthnTransactionFunction;\n  recovery?: AuthnTransactionFunction;\n  verify?: AuthnTransactionFunction;\n  resend?: AuthnTransactionFunction;\n  activate?: AuthnTransactionFunction;\n  poll?: AuthnTransactionFunction;\n  prev?: AuthnTransactionFunction;\n\n  data?: AuthnTransactionState;\n  stateToken?: string;\n  sessionToken?: string;\n  status: string;\n  user?: Record<string, any>;\n  factor?: Record<string, any>;\n  factors?: Array<Record<string, any> >;\n  policy?: Record<string, any>;\n  scopes?: Array<Record<string, any> >;\n  target?: Record<string, any>;\n  authentication?: Record<string, any>;\n  constructor(sdk: OktaAuthHttpInterface, tx: AuthnTransactionAPI, res: AuthnTransactionState | null = null) {\n    this.data = undefined;\n    this.status = undefined as unknown as string;\n    if (res) {\n      this.data = res;\n\n      // Parse response from Authn V1\n      Object.assign(this, flattenEmbedded(sdk, tx, 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 Promise.resolve(tx.createTransaction());\n        };\n      }\n    }\n  }\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 */\nimport { post } from '../http';\nimport AuthSdkError from '../errors/AuthSdkError';\nimport { STATE_TOKEN_KEY_NAME } from '../constants';\nimport { OktaAuthHttpInterface } from '../http/types';\nimport { OktaAuthStorageOptions } from '../storage/types';\nimport { addStateToken } from './util/stateToken';\nimport { AuthnTransactionAPI } from './types';\nimport { OktaAuthBaseInterface } from '../base/types';\n\nexport function transactionStatus(sdk: OktaAuthHttpInterface, args) {\n  args = addStateToken(sdk, args);\n  return post(sdk, sdk.getIssuerOrigin() + '/api/v1/authn', args, { withCredentials: true });\n}\n\nexport function resumeTransaction(sdk: OktaAuthHttpInterface, tx: AuthnTransactionAPI, args) {\n  if (!args || !args.stateToken) {\n    var stateToken = getSavedStateToken(sdk);\n    if (stateToken) {\n      args = {\n        stateToken: stateToken\n      };\n    } else {\n      return Promise.reject(new AuthSdkError('No transaction to resume'));\n    }\n  }\n  return transactionStatus(sdk, args)\n    .then(function(res) {\n      return tx.createTransaction(res);\n    });\n}\n\nexport function introspectAuthn (sdk: OktaAuthHttpInterface, tx: AuthnTransactionAPI, args) {\n  if (!args || !args.stateToken) {\n    var stateToken = getSavedStateToken(sdk);\n    if (stateToken) {\n      args = {\n        stateToken: stateToken\n      };\n    } else {\n      return Promise.reject(new AuthSdkError('No transaction to evaluate'));\n    }\n  }\n  return transactionStep(sdk, args)\n    .then(function (res) {\n      return tx.createTransaction(res);\n    });\n}\n\nexport function transactionStep(sdk: OktaAuthHttpInterface, args) {\n  args = addStateToken(sdk, args);\n  // v1 pipeline introspect API\n  return post(sdk, sdk.getIssuerOrigin() + '/api/v1/authn/introspect', args, { withCredentials: true });\n}\n\nexport function transactionExists(sdk: OktaAuthBaseInterface<OktaAuthStorageOptions>) {\n  // We have a cookie state token\n  return !!getSavedStateToken(sdk);\n}\n\nexport function postToTransaction(sdk: OktaAuthHttpInterface, tx: AuthnTransactionAPI, url: string, args, options?) {\n  options = Object.assign({ withCredentials: true }, options);\n  return post(sdk, url, args, options)\n    .then(function(res) {\n      return tx.createTransaction(res);\n    });\n}\n\nexport function getSavedStateToken(sdk: OktaAuthBaseInterface<OktaAuthStorageOptions>) {\n    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n    const storage = sdk.options.storageUtil!.storage;\n    return storage.get(STATE_TOKEN_KEY_NAME);\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\nimport { RequestData, RequestOptions, OktaAuthHttpInterface } from '../http/types';\nimport {\n  introspectAuthn,\n  transactionStatus,\n  transactionExists,\n  resumeTransaction,\n  postToTransaction\n} from './api';\nimport { AuthnTransactionImpl } from './AuthnTransactionImpl';\nimport { AuthnTransactionAPI, AuthnTransactionState } from './types';\n\n// Factory\nexport function createAuthnTransactionAPI(sdk: OktaAuthHttpInterface): AuthnTransactionAPI {\n  const tx: AuthnTransactionAPI = {\n    status: transactionStatus.bind(null, sdk),\n    resume(args) {\n      return resumeTransaction(sdk, tx, args);\n    },\n    exists: transactionExists.bind(null, sdk),\n    introspect(args) {\n      return introspectAuthn(sdk, tx, args);\n    },\n    createTransaction: (res?: AuthnTransactionState) => {\n      return new AuthnTransactionImpl(sdk, tx, res);\n    },\n    postToTransaction: (url: string, args?: RequestData, options?: RequestOptions) => {\n      return postToTransaction(sdk, tx, url, args, options);\n    }\n  };\n  return tx;\n}\n","export * from './factory';\nexport * from './mixin';\nexport * from './types';\n","/* eslint-disable max-statements */\n/* eslint-disable complexity */\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\nimport { \n  clone,\n} from '../util';\nimport fingerprint from '../browser/fingerprint';\nimport {\n  SigninWithCredentialsOptions,\n  ForgotPasswordOptions,\n  VerifyRecoveryTokenOptions,\n  SigninOptions,\n  OktaAuthTxInterface,\n  AuthnTransaction,\n  AuthnTransactionAPI\n} from './types';\nimport {\n  createAuthnTransactionAPI,\n} from './factory';\nimport { StorageManagerInterface } from '../storage/types';\nimport { OktaAuthHttpInterface, OktaAuthHttpOptions } from '../http/types';\nimport { FingerprintAPI, OktaAuthConstructor } from '../base/types';\n\nexport function mixinAuthn\n<\n  S extends StorageManagerInterface = StorageManagerInterface,\n  O extends OktaAuthHttpOptions = OktaAuthHttpOptions,\n  TBase extends OktaAuthConstructor<OktaAuthHttpInterface<S, O>>\n    = OktaAuthConstructor<OktaAuthHttpInterface<S, O>>\n>\n(Base: TBase): TBase & OktaAuthConstructor<OktaAuthTxInterface<S, O>>\n{\n  return class OktaAuthTx extends Base implements OktaAuthTxInterface<S, O> {\n    tx: AuthnTransactionAPI; // legacy, may be removed in future version\n    authn: AuthnTransactionAPI;\n    fingerprint: FingerprintAPI;\n\n    constructor(...args: any[]) {\n      super(...args);\n\n      this.authn = this.tx = createAuthnTransactionAPI(this);\n      \n      // Fingerprint API\n      this.fingerprint = fingerprint.bind(null, this);\n    }\n\n    // Authn  V1\n    async signIn(opts: SigninOptions): Promise<AuthnTransaction> {\n      opts = clone(opts || {});\n      const _postToTransaction = (options?) => {\n        delete opts.sendFingerprint;\n        return this.tx.postToTransaction('/api/v1/authn', opts, options);\n      };\n      if (!opts.sendFingerprint) {\n        return _postToTransaction();\n      }\n      return this.fingerprint()\n      .then(function(fingerprint) {\n        return _postToTransaction({\n          headers: {\n            'X-Device-Fingerprint': fingerprint\n          }\n        });\n      });\n    }\n\n    // Authn  V1\n    async signInWithCredentials(opts: SigninWithCredentialsOptions): Promise<AuthnTransaction> {\n      return this.signIn(opts);\n    }\n\n    // { username, (relayState) }\n    forgotPassword(opts): Promise<AuthnTransaction> {\n      return this.tx.postToTransaction('/api/v1/authn/recovery/password', opts);\n    }\n\n    // { username, (relayState) }\n    unlockAccount(opts: ForgotPasswordOptions): Promise<AuthnTransaction> {\n      return this.tx.postToTransaction('/api/v1/authn/recovery/unlock', opts);\n    }\n\n    // { recoveryToken }\n    verifyRecoveryToken(opts: VerifyRecoveryTokenOptions): Promise<AuthnTransaction> {\n      return this.tx.postToTransaction('/api/v1/authn/recovery/token', opts);\n    }\n\n  };\n}\n","/* eslint-disable complexity */\nimport { OktaAuthHttpInterface } from '../../http/types';\nimport { clone, isObject, omit } from '../../util';\nimport { AuthnTransactionAPI } from '../types';\nimport { links2fns } from './links2fns';\n\nexport function flattenEmbedded(sdk: OktaAuthHttpInterface, tx: AuthnTransactionAPI, res, obj, ref) {\n  obj = obj || res;\n  obj = 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, tx, res, obj[o], ref) as never);\n    }\n    return objArr;\n  }\n\n  var embedded = obj._embedded || {};\n\n  for (var key in embedded) {\n    if (!Object.prototype.hasOwnProperty.call(embedded, key)) {\n      continue;\n    }\n\n    // Flatten any nested _embedded objects\n    if (isObject(embedded[key]) || Array.isArray(embedded[key])) {\n      embedded[key] = flattenEmbedded(sdk, tx, res, embedded[key], ref);\n    }\n  }\n\n  // Convert any links on the embedded object\n  var fns = links2fns(sdk, tx, res, obj, ref);\n  Object.assign(embedded, fns);\n\n  obj = omit(obj, '_embedded', '_links');\n  Object.assign(obj, embedded);\n  return obj;\n}\n","import { OktaAuthHttpInterface } from '../../http/types';\nimport { find, omit, toQueryString } from '../../util';\nimport AuthSdkError from '../../errors/AuthSdkError';\nimport { get } from '../../http';\nimport { AuthnTransactionAPI, AuthnTransactionState } from '../types';\nimport { postToTransaction } from '../api';\nimport { addStateToken } from './stateToken';\n\n\n// query parameters to post url\ninterface PostToTransactionParams {\n  autoPush?: boolean;\n  rememberDevice?: boolean;\n  updatePhone?: boolean;\n}\n\n// eslint-disable-next-line max-params\nexport function link2fn(sdk: OktaAuthHttpInterface, tx: AuthnTransactionAPI, 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 = find(link, {name: name});\n      if (!lk) {\n        throw new AuthSdkError('No link found for that name');\n      }\n\n      return link2fn(sdk, tx, 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 get(sdk, link.href, { withCredentials: true });\n        };\n\n      case 'POST':\n        // eslint-disable-next-line max-statements,complexity\n        return function(opts: AuthnTransactionState) {\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            Object.assign(data, {\n              factorType: obj.factorType,\n              provider: obj.provider\n            });\n          }\n\n          var params = {} as PostToTransactionParams;\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 Promise.reject(new AuthSdkError('AutoPush resulted in an error.'));\n              }\n            }\n            else if (autoPush !== null) {\n              params.autoPush = !!autoPush;\n            }\n            data = 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 Promise.reject(new AuthSdkError('RememberDevice resulted in an error.'));\n              }\n            }\n            else if (rememberDevice !== null) {\n              params.rememberDevice = !!rememberDevice;\n            }\n            data = 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 = omit(data.profile, 'updatePhone');\n          }\n          var href = link.href + toQueryString(params);\n          return postToTransaction(sdk, tx, href, data);\n        };\n    }\n  }\n}\n\n\n","import { OktaAuthHttpInterface } from '../../http/types';\nimport { AuthnTransactionFunctions, AuthnTransactionAPI } from '../types';\nimport { link2fn } from './link2fn';\nimport { getPollFn } from './poll';\n\nexport function links2fns(sdk: OktaAuthHttpInterface, tx: AuthnTransactionAPI, res, obj, ref) {\n  var fns = {} as AuthnTransactionFunctions;\n  for (var linkName in obj._links) {\n    if (!Object.prototype.hasOwnProperty.call(obj._links, 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, tx, res, obj, link, ref);\n        if (fn) {\n          fns[linkName] = fn;\n        }\n    }\n  }\n  return fns;\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\nimport { post } from '../../http';\nimport { isNumber, isObject, getLink, toQueryString, delay as delayFn } from '../../util';\nimport { DEFAULT_POLLING_DELAY } from '../../constants';\nimport AuthSdkError from '../../errors/AuthSdkError';\nimport AuthPollStopError from '../../errors/AuthPollStopError';\nimport { AuthnTransactionState } from '../types';\nimport { getStateToken } from './stateToken';\n\ninterface PollOptions {\n  delay?: number;\n  rememberDevice?: boolean;\n  autoPush?: boolean;\n  transactionCallBack?: (AuthnTransactionState) => void;\n}\n\nexport function getPollFn(sdk, res: AuthnTransactionState, ref) {\n  return function (options: PollOptions | number) {\n    var delay;\n    var rememberDevice;\n    var autoPush;\n    var transactionCallBack;\n\n    if (isNumber(options)) {\n      delay = options;\n    } else if (isObject(options)) {\n      options = options as PollOptions;\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 = DEFAULT_POLLING_DELAY;\n    }\n\n    // Get the poll function\n    var pollLink = getLink(res, 'next', 'poll');\n    // eslint-disable-next-line complexity\n    function pollFn() {\n      var opts = {} as PollOptions;\n      if (typeof autoPush === 'function') {\n        try {\n          opts.autoPush = !!autoPush();\n        }\n        catch (e) {\n          return Promise.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 Promise.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 + toQueryString(opts);\n      return post(sdk, href, getStateToken(res), {\n        saveAuthnState: false,\n        withCredentials: true\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 Promise.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 delayFn(delay).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 sdk.tx.createTransaction(pollRes);\n          }\n        })\n        .catch(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 delayFn(delayLength)\n              .then(recursivePoll);\n          }\n          throw err;\n        });\n    };\n    return recursivePoll()\n      .catch(function(err) {\n        ref.isPolling = false;\n        throw err;\n      });\n  };\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\nimport { AuthnTransactionState } from '../types';\n\nexport function addStateToken(res, options?) {\n  var builtArgs = {} as AuthnTransactionState;\n  Object.assign(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\nexport function getStateToken(res) {\n  return addStateToken(res);\n}\n","\n\n// Do not use this type in code, so it won't be emitted in the declaration output\nimport { removeNils } from '../util';\n\nimport * as features from '../features';\nimport * as constants from '../constants';\n\n// eslint-disable-next-line @typescript-eslint/ban-ts-comment\n// @ts-ignore \n// Do not use this type in code, so it won't be emitted in the declaration output\nimport Emitter from 'tiny-emitter';\n\nimport {\n  EventEmitter,\n  OktaAuthConstructor,\n  OktaAuthBaseInterface,\n  OktaAuthBaseOptions,\n  OktaAuthOptionsConstructor, \n  FeaturesAPI,\n} from './types';\n\nexport function createOktaAuthBase\n<\n  O extends OktaAuthBaseOptions = OktaAuthBaseOptions,\n>\n(\n  OptionsConstructor: OktaAuthOptionsConstructor<O>\n): OktaAuthConstructor<OktaAuthBaseInterface<O>>\n{\n  class OktaAuthBase implements OktaAuthBaseInterface<O>\n  {\n    options: O;\n    emitter: EventEmitter;\n    features: FeaturesAPI;\n    static features: FeaturesAPI = features;\n    static constants = constants;\n    \n    constructor(...args: any[]) {\n      const options = new OptionsConstructor(args.length ? args[0] || {} : {});\n      this.options = removeNils(options) as O; // clear out undefined values\n      this.emitter = new Emitter();\n      this.features = features;\n    }\n  }\n\n  // Hoist feature detection functions to prototype & static type\n  OktaAuthBase.features = OktaAuthBase.prototype.features = features;\n\n  // Also hoist constants for CommonJS users\n  Object.assign(OktaAuthBase, {\n    constants\n  });\n\n  return OktaAuthBase;\n}\n","export * from './factory';\nexport * from './options';\nexport * from './types';\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\nimport { OktaAuthBaseOptions } from './types';\n\nexport function createBaseOptionsConstructor() {\n\n  return class BaseOptionsConstructor implements Required<OktaAuthBaseOptions> {\n    devMode: boolean;\n\n    constructor(args: any) {\n      this.devMode = !!args.devMode;\n    }\n  };\n\n}\n","/* eslint-disable @typescript-eslint/no-non-null-assertion */\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\nimport Cookies from 'js-cookie';\nimport AuthSdkError from '../errors/AuthSdkError';\nimport {\n  StorageOptions,\n  CookieOptions,\n  SimpleStorage,\n  StorageType,\n  StorageUtil,\n} from '../storage/types';\nimport { warn } from '../util';\nimport { isIE11OrLess } from '../features';\n\nexport interface CookieStorage extends SimpleStorage {\n  setItem(key: string, value: any, expiresAt?: string | null): void; // can customize expiresAt\n  getItem(key?: string): any; // if no key is passed, all cookies are returned\n  removeItem(key: string); // remove a cookie\n}\n\nexport interface BrowserStorageUtil extends StorageUtil {\n  browserHasLocalStorage(): boolean;\n  browserHasSessionStorage(): boolean;\n  getStorageByType(storageType: StorageType, options: StorageOptions): SimpleStorage;\n  getLocalStorage(): Storage;\n  getSessionStorage(): Storage;\n  getInMemoryStorage(): SimpleStorage;\n  getCookieStorage(options?: StorageOptions): CookieStorage;\n  testStorage(storage: any): boolean;\n  storage: Cookies;\n  inMemoryStore: Record<string, unknown>;\n}\n\n// Building this as an object allows us to mock the functions in our tests\nvar storageUtil: BrowserStorageUtil = {\n\n  // IE11 bug that Microsoft doesn't plan to fix\n  // https://connect.microsoft.com/IE/Feedback/Details/1496040\n  browserHasLocalStorage: function() {\n    try {\n      var storage = this.getLocalStorage();\n      return this.testStorage(storage);\n    } catch (e) {\n      return false;\n    }\n  },\n\n  browserHasSessionStorage: function() {\n    try {\n      var storage = this.getSessionStorage();\n      return this.testStorage(storage);\n    } catch (e) {\n      return false;\n    }\n  },\n\n  testStorageType: function(storageType: StorageType): boolean {\n    var supported = false;\n    switch (storageType) {\n      case 'sessionStorage':\n        supported = this.browserHasSessionStorage();\n        break;\n      case 'localStorage':\n        supported = this.browserHasLocalStorage();\n        break;\n      case 'cookie':\n      case 'memory':\n        supported = true;\n        break;\n      default:\n        supported = false;\n        break;\n    }\n    return supported;\n  },\n\n  getStorageByType: function(storageType: StorageType, options?: StorageOptions): SimpleStorage {\n    let storageProvider;\n    switch (storageType) {\n      case 'sessionStorage':\n        storageProvider = this.getSessionStorage();\n        break;\n      case 'localStorage':\n        storageProvider = this.getLocalStorage();\n        break;\n      case 'cookie':\n        storageProvider = this.getCookieStorage(options);\n        break;\n      case 'memory':\n        storageProvider = this.getInMemoryStorage();\n        break;\n      default:\n        throw new AuthSdkError(`Unrecognized storage option: ${storageType}`);\n        break;\n    }\n    return storageProvider;\n  },\n\n  findStorageType: function(types: StorageType[]) {\n    let curType;\n    let nextType;\n    \n    types = types.slice(); // copy array\n    curType = types.shift();\n    nextType = types.length ? types[0] : null;\n    if (!nextType) {\n      return curType;\n    }\n\n    if (this.testStorageType(curType)) {\n      return curType;\n    }\n\n    // preferred type was unsupported.\n    warn(`This browser doesn't support ${curType}. Switching to ${nextType}.`);\n\n    // fallback to the next type. this is a recursive call\n    return this.findStorageType(types);\n  },\n\n  getLocalStorage: function() {\n    // Workaound for synchronization issue of LocalStorage cross tabs in IE11\n    if (isIE11OrLess() && !window.onstorage) {\n      window.onstorage = function() {};\n    }\n    \n    return localStorage;\n  },\n\n  getSessionStorage: function() {\n    return sessionStorage;\n  },\n\n  // Provides webStorage-like interface for cookies\n  getCookieStorage: function(options): CookieStorage {\n    const secure = options!.secure;\n    const sameSite = options!.sameSite;\n    const sessionCookie = options!.sessionCookie;\n    if (typeof secure === 'undefined' || typeof sameSite === 'undefined') {\n      throw new AuthSdkError('getCookieStorage: \"secure\" and \"sameSite\" options must be provided');\n    }\n    const storage: CookieStorage = {\n      getItem: this.storage.get,\n      setItem: (key, value, expiresAt = '2200-01-01T00:00:00.000Z') => {\n        // By defauilt, cookie shouldn't expire\n        expiresAt = (sessionCookie ? null : expiresAt) as string;\n        this.storage.set(key, value, expiresAt, {\n          secure: secure, \n          sameSite: sameSite,\n        });\n      },\n      removeItem: (key) => {\n        this.storage.delete(key);\n      },\n    };\n\n    if (!options!.useSeparateCookies) {\n      return storage;\n    }\n\n    // Tokens are stored separately because cookies have size limits.\n    // Can only be used when storing an object value. Object properties will be saved to separate cookies.\n    // Each property of the object must also be an object.\n    return {\n      getItem: function(key) {\n        var data = storage.getItem(); // read all cookies\n        var value = {};\n        Object.keys(data).forEach(k => {\n          if (k.indexOf(key!) === 0) { // filter out unrelated cookies\n            value[k.replace(`${key}_`, '')] = JSON.parse(data[k]); // populate with cookie data\n          }\n        });\n        return JSON.stringify(value);\n      },\n      setItem: function(key, value) {\n        var existingValues = JSON.parse(this.getItem(key));\n        value = JSON.parse(value);\n        // Set key-value pairs from input to cookies\n        Object.keys(value).forEach(k => {\n          var storageKey = key + '_' + k;\n          var valueToStore = JSON.stringify(value[k]);\n          storage.setItem(storageKey, valueToStore);\n          delete existingValues[k];\n        });\n        // Delete unmatched keys from existing cookies\n        Object.keys(existingValues).forEach(k => {\n          storage.removeItem(key + '_' + k);\n        });\n      },\n      removeItem: function(key) {\n        var existingValues = JSON.parse(this.getItem(key));\n        Object.keys(existingValues).forEach(k => {\n          storage.removeItem(key + '_' + k);\n        });\n      },\n    };\n  },\n\n  // Provides an in-memory solution\n  inMemoryStore: {}, // override this for a unique memory store per instance\n  getInMemoryStorage: function() {\n    return {\n      getItem: (key) => {\n        return this.inMemoryStore[key];\n      },\n      setItem: (key, value) => {\n        this.inMemoryStore[key] = value;\n      },\n    };\n  },\n\n  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\n  storage: {\n    set: function(name: string, value: string, expiresAt: string, options: CookieOptions): string {\n      const { sameSite, secure } = options;\n      if (typeof secure === 'undefined' || typeof sameSite === 'undefined') {\n        throw new AuthSdkError('storage.set: \"secure\" and \"sameSite\" options must be provided');\n      }\n      var cookieOptions: CookieOptions = {\n        path: options.path || '/',\n        secure,\n        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 this.get(name);\n    },\n\n    get: function(name?: string): string {\n      // return all cookies when no args is provided\n      if (!arguments.length) {\n        return Cookies.get();\n      }\n      return Cookies.get(name);\n    },\n\n    delete: function(name: string): string {\n      return Cookies.remove(name, { path: '/' });\n    }\n  }\n};\n\nexport default storageUtil;\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\nimport { AuthSdkError } from '../errors';\nimport { isFingerprintSupported } from '../features';\nimport {\n  addListener,\n  removeListener\n} from '../oidc';\nimport { FingerprintOptions } from '../base/types';\nimport { OktaAuthHttpInterface } from '../http/types';\n\nconst isMessageFromCorrectSource = (iframe: HTMLIFrameElement, event: MessageEvent)\n: boolean => event.source === iframe.contentWindow;\n\nexport default function fingerprint(sdk: OktaAuthHttpInterface, options?: FingerprintOptions): Promise<string> {\n  if (!isFingerprintSupported()) {\n    return Promise.reject(new AuthSdkError('Fingerprinting is not supported on this device'));\n  }\n\n  const container = options?.container ?? document.body;\n  let timeout: NodeJS.Timeout;\n  let iframe: HTMLIFrameElement;\n  let listener: (this: Window, ev: MessageEvent) => void;\n  const promise = new Promise(function (resolve, reject) {\n    iframe = document.createElement('iframe');\n    iframe.style.display = 'none';\n\n    // eslint-disable-next-line complexity\n    listener = function listener(e: MessageEvent) {\n      if (!isMessageFromCorrectSource(iframe, e)) {\n        return;\n      }\n\n      if (!e || !e.data || e.origin !== sdk.getIssuerOrigin()) {\n        return;\n      }\n\n      let msg;\n      try {\n        msg = JSON.parse(e.data);\n      } catch (err) {\n        // iframe messages should all be parsable\n        // skip not parsable messages come from other sources in same origin (browser extensions)\n        // TODO: add namespace flag in okta-core to distinguish messages that come from other sources\n        return;\n      }\n\n      if (!msg) { return; }\n      if (msg.type === 'FingerprintAvailable') {\n        return resolve(msg.fingerprint as string);\n      } else if (msg.type === 'FingerprintServiceReady') {\n        iframe?.contentWindow?.postMessage(JSON.stringify({\n          type: 'GetFingerprint'\n        }), e.origin);\n      } else {\n        return reject(new AuthSdkError('No data'));\n      }\n    };\n    addListener(window, 'message', listener);\n\n    iframe.src = sdk.getIssuerOrigin() + '/auth/services/devicefingerprint';\n    container.appendChild(iframe);\n\n    timeout = setTimeout(function() {\n      reject(new AuthSdkError('Fingerprinting timed out'));\n    }, options?.timeout || 15000);\n  });\n\n  return promise.finally(function() {\n    clearTimeout(timeout);\n    removeListener(window, 'message', listener);\n    if (container.contains(iframe)) {\n      iframe.parentElement?.removeChild(iframe);\n    }\n  }) as Promise<string>;\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\nexport default class SdkClock {\n  localOffset: number;\n\n  constructor(localOffset) {\n    // Calculated local clock offset from server time (in milliseconds). Can be positive or negative.\n    this.localOffset = parseInt(localOffset || 0);\n  }\n\n  // factory method. Create an instance of a clock from current context.\n  static create(/* sdk, options */): SdkClock {\n    // TODO: calculate localOffset\n    var localOffset = 0;\n    return new SdkClock(localOffset);\n  }\n\n  // Return the current time (in seconds)\n  now() {\n    var now = (Date.now() + this.localOffset) / 1000;\n    return now;\n  }\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\nexport const STATE_TOKEN_KEY_NAME = 'oktaStateToken';\nexport const DEFAULT_POLLING_DELAY = 500;\nexport const DEFAULT_MAX_CLOCK_SKEW = 300;\nexport const DEFAULT_CACHE_DURATION = 86400;\nexport const TOKEN_STORAGE_NAME = 'okta-token-storage';\nexport const CACHE_STORAGE_NAME = 'okta-cache-storage';\nexport const PKCE_STORAGE_NAME = 'okta-pkce-storage';\nexport const TRANSACTION_STORAGE_NAME = 'okta-transaction-storage';\nexport const SHARED_TRANSACTION_STORAGE_NAME = 'okta-shared-transaction-storage';\nexport const ORIGINAL_URI_STORAGE_NAME = 'okta-original-uri-storage';\nexport const IDX_RESPONSE_STORAGE_NAME = 'okta-idx-response-storage';\nexport const ACCESS_TOKEN_STORAGE_KEY = 'accessToken';\nexport const ID_TOKEN_STORAGE_KEY =  'idToken';\nexport const REFRESH_TOKEN_STORAGE_KEY =  'refreshToken';\nexport const REFERRER_PATH_STORAGE_KEY = 'referrerPath';\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.\nexport const MIN_VERIFIER_LENGTH = 43;\nexport const MAX_VERIFIER_LENGTH = 128;\nexport const DEFAULT_CODE_CHALLENGE_METHOD = 'S256';\n\nexport const IDX_API_VERSION = '1.0.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// eslint-disable-next-line @typescript-eslint/ban-ts-comment\n// @ts-ignore \n// Do not use this type in code, so it won't be emitted in the declaration output\nimport PCancelable from 'p-cancelable';\nimport { AuthSdkError } from '../errors';\nimport {\n  EVENT_ADDED,\n  EVENT_REMOVED,\n  OAuthStorageManagerInterface,\n  OAuthTransactionMeta,\n  OktaAuthOAuthInterface\n} from '../oidc';\nimport {\n  AuthState,\n  AuthStateLogOptions,\n  OktaAuthCoreOptions,\n} from './types';\nimport { PromiseQueue, getConsole } from '../util';\n\nexport const INITIAL_AUTH_STATE = null;\nconst DEFAULT_PENDING = {\n  updateAuthStatePromise: null,\n  canceledTimes: 0\n};\nconst EVENT_AUTH_STATE_CHANGE = 'authStateChange';\nconst MAX_PROMISE_CANCEL_TIMES = 10;\n\n// only compare first level of authState\nconst isSameAuthState = (prevState: AuthState | null, state: AuthState) => {\n  // initial state is null\n  if (!prevState) {\n    return false;\n  }\n\n  return prevState.isAuthenticated === state.isAuthenticated \n    && JSON.stringify(prevState.idToken) === JSON.stringify(state.idToken)\n    && JSON.stringify(prevState.accessToken) === JSON.stringify(state.accessToken)\n    && prevState.error === state.error;\n};\n\n\nexport class AuthStateManager\n<\n  M extends OAuthTransactionMeta,\n  S extends OAuthStorageManagerInterface<M>,\n  O extends OktaAuthCoreOptions\n>\n{\n  _sdk: OktaAuthOAuthInterface<M, S, O>;\n  _pending: { \n    updateAuthStatePromise: any;\n    canceledTimes: number; \n  };\n  _authState: AuthState | null;\n  _prevAuthState: AuthState | null;\n  _logOptions: AuthStateLogOptions;\n  _transformQueue: PromiseQueue;\n\n  constructor(sdk: OktaAuthOAuthInterface<M, S, O>) {\n    if (!sdk.emitter) {\n      throw new AuthSdkError('Emitter should be initialized before AuthStateManager');\n    }\n\n    this._sdk = sdk;\n    this._pending = { ...DEFAULT_PENDING };\n    this._authState = INITIAL_AUTH_STATE;\n    this._logOptions = {};\n    this._prevAuthState = null;\n    this._transformQueue = new PromiseQueue({\n      quiet: true\n    });\n\n    // Listen on tokenManager events to start updateState process\n    // \"added\" event is emitted in both add and renew process\n    // Only listen on \"added\" event to update auth state\n    sdk.tokenManager.on(EVENT_ADDED, (key, token) => {\n      this._setLogOptions({ event: EVENT_ADDED, key, token });\n      this.updateAuthState();\n    });\n    sdk.tokenManager.on(EVENT_REMOVED, (key, token) => {\n      this._setLogOptions({ event: EVENT_REMOVED, key, token });\n      this.updateAuthState();\n    });\n  }\n\n  _setLogOptions(options) {\n    this._logOptions = options;\n  }\n\n  getAuthState(): AuthState | null {\n    return this._authState;\n  }\n\n  getPreviousAuthState(): AuthState | null {\n    return this._prevAuthState;\n  }\n\n  async updateAuthState(): Promise<AuthState> {\n    const { transformAuthState, devMode } = this._sdk.options;\n\n    const log = (status) => {\n      const { event, key, token } = this._logOptions;\n      getConsole().group(`OKTA-AUTH-JS:updateAuthState: Event:${event} Status:${status}`);\n      getConsole().log(key, token);\n      getConsole().log('Current authState', this._authState);\n      getConsole().groupEnd();\n      \n      // clear log options after logging\n      this._logOptions = {};\n    };\n\n    const emitAuthStateChange = (authState) => {\n      if (isSameAuthState(this._authState, authState)) {\n        devMode && log('unchanged'); \n        return;\n      }\n      this._prevAuthState = this._authState;\n      this._authState = authState;\n      // emit new authState object\n      this._sdk.emitter.emit(EVENT_AUTH_STATE_CHANGE, { ...authState });\n      devMode && log('emitted');\n    };\n\n    const finalPromise = (origPromise) => {       \n      return this._pending.updateAuthStatePromise.then(() => {\n        const curPromise = this._pending.updateAuthStatePromise;\n        if (curPromise && curPromise !== origPromise) {\n          return finalPromise(curPromise);\n        }\n        return this.getAuthState();\n      });\n    };\n\n    if (this._pending.updateAuthStatePromise) {\n      if (this._pending.canceledTimes >= MAX_PROMISE_CANCEL_TIMES) {\n        // stop canceling then starting a new promise\n        // let existing promise finish to prevent running into loops\n        devMode && log('terminated');\n        return finalPromise(this._pending.updateAuthStatePromise);\n      } else {\n        this._pending.updateAuthStatePromise.cancel();\n      }\n    }\n\n    /* eslint-disable complexity */\n    const cancelablePromise = new PCancelable((resolve, _, onCancel) => {\n      onCancel.shouldReject = false;\n      onCancel(() => {\n        this._pending.updateAuthStatePromise = null;\n        this._pending.canceledTimes = this._pending.canceledTimes + 1;\n        devMode && log('canceled');\n      });\n\n      const emitAndResolve = (authState) => {\n        if (cancelablePromise.isCanceled) {\n          resolve();\n          return;\n        }\n        // emit event and resolve promise \n        emitAuthStateChange(authState);\n        resolve();\n\n        // clear pending states after resolve\n        this._pending = { ...DEFAULT_PENDING };\n      };\n\n      this._sdk.isAuthenticated()\n        .then(() => {\n          if (cancelablePromise.isCanceled) {\n            resolve();\n            return;\n          }\n\n          const { accessToken, idToken, refreshToken } = this._sdk.tokenManager.getTokensSync();\n          const authState = {\n            accessToken,\n            idToken,\n            refreshToken,\n            isAuthenticated: !!(accessToken && idToken)\n          };\n\n          // Enqueue transformAuthState so that it does not run concurrently\n          const promise: Promise<AuthState> = transformAuthState\n            ? this._transformQueue.push(transformAuthState, null, this._sdk, authState) as Promise<AuthState>\n            : Promise.resolve(authState);\n\n          promise\n            .then(authState => emitAndResolve(authState))\n            .catch(error => emitAndResolve({\n              accessToken, \n              idToken, \n              refreshToken,\n              isAuthenticated: false, \n              error\n            }));\n        });\n    });\n    /* eslint-enable complexity */\n    this._pending.updateAuthStatePromise = cancelablePromise;\n\n    return finalPromise(cancelablePromise);\n  }\n\n  subscribe(handler): void {\n    this._sdk.emitter.on(EVENT_AUTH_STATE_CHANGE, handler);\n  }\n\n  unsubscribe(handler?): void {\n    this._sdk.emitter.off(EVENT_AUTH_STATE_CHANGE, handler);\n  }\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\nimport {\n  OAuthTransactionMeta,\n  OAuthStorageManagerInterface,\n} from '../../oidc';\n\nimport {\n  ServiceManagerInterface,\n  ServiceInterface,\n  ServiceManagerOptions,\n  OktaAuthCoreInterface,\n  OktaAuthCoreOptions\n} from '../types';\nimport { AutoRenewService,\n  SyncStorageService,\n  LeaderElectionService,\n  RenewOnTabActivationService\n} from '../../services';\nimport { removeNils } from '../../util';\n\nconst AUTO_RENEW = 'autoRenew';\nconst SYNC_STORAGE = 'syncStorage';\nconst LEADER_ELECTION = 'leaderElection';\nconst RENEW_ON_TAB_ACTIVATION = 'renewOnTabActivation';\n\nexport class ServiceManager\n<\n  M extends OAuthTransactionMeta,\n  S extends OAuthStorageManagerInterface<M>,\n  O extends OktaAuthCoreOptions\n>\nimplements ServiceManagerInterface \n{\n  private sdk: OktaAuthCoreInterface<M, S, O>;\n  private options: ServiceManagerOptions;\n  private services: Map<string, ServiceInterface>;\n  private started: boolean;\n\n  private static knownServices = [AUTO_RENEW, SYNC_STORAGE, LEADER_ELECTION, RENEW_ON_TAB_ACTIVATION];\n\n  private static defaultOptions: ServiceManagerOptions = {\n    autoRenew: true,\n    autoRemove: true,\n    syncStorage: true,\n    renewOnTabActivation: true,\n    tabInactivityDuration: 1800,    // 30 mins in seconds\n  };\n\n  constructor(sdk: OktaAuthCoreInterface<M, S, O>, options: ServiceManagerOptions = {}) {\n    this.sdk = sdk;\n    this.onLeader = this.onLeader.bind(this);\n\n    // TODO: backwards compatibility, remove in next major version - OKTA-473815\n    const { autoRenew, autoRemove, syncStorage } = sdk.tokenManager.getOptions();\n    options.electionChannelName = options.electionChannelName || options.broadcastChannelName;\n    this.options = Object.assign({}, \n      ServiceManager.defaultOptions,\n      { autoRenew, autoRemove, syncStorage }, \n      {\n        electionChannelName: `${sdk.options.clientId}-election`,\n        syncChannelName: `${sdk.options.clientId}-sync`,\n      },\n      removeNils(options)\n    );\n\n    this.started = false;\n    this.services = new Map();\n\n    ServiceManager.knownServices.forEach(name => {\n      const svc = this.createService(name);\n      if (svc) {\n        this.services.set(name, svc);\n      }\n    });\n  }\n\n  private async onLeader() {\n    if (this.started) {\n      // Start services that requires leadership\n      await this.startServices();\n    }\n  }\n\n  isLeader() {\n    return (this.getService(LEADER_ELECTION) as LeaderElectionService)?.isLeader();\n  }\n\n  isLeaderRequired() {\n    return [...this.services.values()].some(srv => srv.canStart() && srv.requiresLeadership());\n  }\n\n  async start() {\n    if (this.started) {\n      return;     // noop if services have already started\n    }\n    await this.startServices();\n    this.started = true;\n  }\n  \n  async stop() {\n    await this.stopServices();\n    this.started = false;\n  }\n\n  getService(name: string): ServiceInterface | undefined {\n    return this.services.get(name);\n  }\n\n  private async startServices() {\n    for (const [name, srv] of this.services.entries()) {\n      if (this.canStartService(name, srv)) {\n        await srv.start();\n      }\n    }\n  }\n\n  private async stopServices() {\n    for (const srv of this.services.values()) {\n      await srv.stop();\n    }\n  }\n\n  // eslint-disable-next-line complexity\n  private canStartService(name: string, srv: ServiceInterface): boolean {\n    let canStart = srv.canStart() && !srv.isStarted();\n    // only start election if a leader is required\n    if (name === LEADER_ELECTION) {\n      canStart &&= this.isLeaderRequired();\n    } else if (srv.requiresLeadership()) {\n      canStart &&= this.isLeader();\n    }\n    return canStart;\n  }\n\n  private createService(name: string): ServiceInterface {\n    const tokenManager = this.sdk.tokenManager;\n\n    let service: ServiceInterface;\n    switch (name) {\n      case LEADER_ELECTION:\n        service = new LeaderElectionService({...this.options, onLeader: this.onLeader});\n        break;\n      case AUTO_RENEW:\n        service = new AutoRenewService(tokenManager, {...this.options});\n        break;\n      case SYNC_STORAGE:\n        service = new SyncStorageService(tokenManager, {...this.options});\n        break;\n      case RENEW_ON_TAB_ACTIVATION:\n        service = new RenewOnTabActivationService(tokenManager, {...this.options});\n        break;\n      default:\n        throw new Error(`Unknown service ${name}`);\n    }\n    return service;\n  }\n\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// ./node is swapped for ./browser in webpack config\nexport * from './node';","import { StorageManagerConstructor } from '../storage/types';\nimport { OktaAuthConstructor, OktaAuthOptionsConstructor } from '../base/types';\n\nimport { OktaAuthCoreInterface, OktaAuthCoreOptions } from './types';\nimport { createOktaAuthBase } from '../base';\nimport { mixinStorage } from '../storage/mixin';\nimport { mixinHttp } from '../http/mixin';\nimport { mixinOAuth } from '../oidc/mixin';\nimport {\n  OAuthStorageManagerInterface,\n  PKCETransactionMeta,\n  TransactionManagerConstructor,\n  TransactionManagerInterface\n} from '../oidc/types';\nimport { mixinCore } from './mixin';\nimport { mixinSession } from '../session/mixin';\n\nexport function createOktaAuthCore<\n  M extends PKCETransactionMeta = PKCETransactionMeta,\n  S extends OAuthStorageManagerInterface<M> = OAuthStorageManagerInterface<M>,\n  O extends OktaAuthCoreOptions = OktaAuthCoreOptions,\n  TM extends TransactionManagerInterface = TransactionManagerInterface\n>(\n  StorageManagerConstructor: StorageManagerConstructor<S>,\n  OptionsConstructor: OktaAuthOptionsConstructor<O>,\n  TransactionManagerConstructor: TransactionManagerConstructor<TM>\n): OktaAuthConstructor<OktaAuthCoreInterface<M, S, O, TM>>\n{\n  const Base = createOktaAuthBase(OptionsConstructor);\n  const WithStorage = mixinStorage<S, O>(Base, StorageManagerConstructor);\n  const WithHttp = mixinHttp<S, O>(WithStorage);\n  const WithSession = mixinSession<S, O>(WithHttp);\n  const WithOAuth = mixinOAuth<M, S, O, TM>(WithSession, TransactionManagerConstructor);\n  const Core = mixinCore<M, S, O, TM>(WithOAuth);\n  return Core;\n}\n","export * from './AuthStateManager';\nexport * from './options';\nexport * from './factory';\nexport * from './mixin';\nexport * from './storage';\nexport * from './types';\nexport * from './ServiceManager';\n","import { parseOAuthResponseFromUrl } from '../oidc/parseFromUrl';\nimport { OktaAuthConstructor } from '../base/types';\nimport {\n  OAuthStorageManagerInterface,\n  OAuthTransactionMeta,\n  OktaAuthOAuthInterface,\n  PKCETransactionMeta,\n  Tokens,\n  TransactionManagerInterface,\n} from '../oidc/types';\nimport { AuthStateManager } from './AuthStateManager';\nimport { ServiceManager } from './ServiceManager';\nimport { OktaAuthCoreInterface, OktaAuthCoreOptions } from './types';\n\nexport function mixinCore\n<\n  M extends OAuthTransactionMeta = PKCETransactionMeta,\n  S extends OAuthStorageManagerInterface<M> = OAuthStorageManagerInterface<M>,\n  O extends OktaAuthCoreOptions = OktaAuthCoreOptions,\n  TM extends TransactionManagerInterface = TransactionManagerInterface,\n  TBase extends OktaAuthConstructor<OktaAuthOAuthInterface<M, S, O, TM>>\n    = OktaAuthConstructor<OktaAuthOAuthInterface<M, S, O, TM>>\n>\n(Base: TBase): TBase & OktaAuthConstructor<OktaAuthCoreInterface<M, S, O, TM>>\n{\n  return class OktaAuthCore extends Base implements OktaAuthCoreInterface<M, S, O, TM>\n  {\n    authStateManager: AuthStateManager<M, S, O>;\n    serviceManager: ServiceManager<M, S, O>;\n    \n    constructor(...args: any[]) {\n      super(...args);\n\n      // AuthStateManager\n      this.authStateManager = new AuthStateManager<M, S, O>(this);\n\n      // ServiceManager\n      this.serviceManager = new ServiceManager<M, S, O>(this, this.options.services);\n    }\n\n    async start() {\n      await this.serviceManager.start();\n      // TODO: review tokenManager.start\n      this.tokenManager.start();\n      if (!this.token.isLoginRedirect()) {\n        await this.authStateManager.updateAuthState();\n      }\n    }\n  \n    async stop() {\n      // TODO: review tokenManager.stop\n      this.tokenManager.stop();\n      await this.serviceManager.stop();\n    }\n\n    async handleRedirect(originalUri?: string): Promise<void> {\n      await this.handleLoginRedirect(undefined, originalUri);\n    }\n\n    // eslint-disable-next-line complexity\n    async handleLoginRedirect(tokens?: Tokens, originalUri?: string): Promise<void> {\n      let state = this.options.state;\n  \n      // Store tokens and update AuthState by the emitted events\n      if (tokens) {\n        this.tokenManager.setTokens(tokens);\n        originalUri = originalUri || this.getOriginalUri(this.options.state);\n      } else if (this.isLoginRedirect()) {\n        try {\n          // For redirect flow, get state from the URL and use it to retrieve the originalUri\n          const oAuthResponse = await parseOAuthResponseFromUrl(this, {});\n          state = oAuthResponse.state;\n          originalUri = originalUri || this.getOriginalUri(state);\n          await this.storeTokensFromRedirect();\n        } catch(e) {\n          // auth state should be updated\n          await this.authStateManager.updateAuthState();\n          throw e;\n        }\n      } else {\n        return; // nothing to do\n      }\n      \n      // ensure auth state has been updated\n      await this.authStateManager.updateAuthState();\n  \n      // clear originalUri from storage\n      this.removeOriginalUri(state);\n  \n      // Redirect to originalUri\n      const { restoreOriginalUri } = this.options;\n      if (restoreOriginalUri) {\n        await restoreOriginalUri(this, originalUri);\n      } else if (originalUri) {\n        window.location.replace(originalUri);\n      }\n    }\n  };\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\nimport { createOAuthOptionsConstructor } from '../oidc';\nimport { AuthState, OktaAuthCoreInterface, OktaAuthCoreOptions, ServiceManagerOptions } from './types';\n\n\nexport function createCoreOptionsConstructor()\n{\n  const OAuthOptionsConstructor = createOAuthOptionsConstructor();\n  return class CoreOptionsConstructor\n    extends OAuthOptionsConstructor\n    implements Required<OktaAuthCoreOptions>\n  {\n    services: ServiceManagerOptions;\n    transformAuthState: (oktaAuth: OktaAuthCoreInterface, authState: AuthState) => Promise<AuthState>;\n\n    constructor(options: any) {\n      super(options);\n      this.services = options.services;\n      this.transformAuthState = options.transformAuthState;\n    }\n  };\n}\n","import { createOAuthStorageManager } from '../oidc/storage';\nimport { PKCETransactionMeta } from '../oidc/types';\n\nexport function createCoreStorageManager<M extends PKCETransactionMeta = PKCETransactionMeta>() {\n  return createOAuthStorageManager<M>();\n}\n","export * from './api';\nexport * from './AuthState';\nexport * from './Service';\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\nimport { AuthSdkError } from '../errors';\nimport { atob, btoa } from './webcrypto';\n\n// converts a string to base64 (url/filename safe variant)\nexport function stringToBase64Url(str) {\n  var b64 = btoa(str);\n  return base64ToBase64Url(b64);\n}\n\n// converts a standard base64-encoded string to a \"url/filename safe\" variant\nexport function base64ToBase64Url(b64) {\n  return b64.replace(/\\+/g, '-').replace(/\\//g, '_').replace(/=+$/, '');\n}\n\n// converts a \"url/filename safe\" base64 string to a \"standard\" base64 string\nexport function base64UrlToBase64(b64u) {\n  return b64u.replace(/-/g, '+').replace(/_/g, '/');\n}\n\nexport function base64UrlToString(b64u) {\n  var b64 = 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 new AuthSdkError('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\nexport function stringToBuffer(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\nexport function base64UrlDecode(str) {\n  return atob(base64UrlToBase64(str));\n}\n\n// Converts base64 string to binary data view\nexport function base64UrlToBuffer(b64u) {\n  return Uint8Array.from(base64UrlDecode(b64u), (c: string) => c.charCodeAt(0));\n}\n\n// Converts an ArrayBuffer object that contains binary data to base64 encoded string\nexport function bufferToBase64Url(bin) {\n  return btoa(new Uint8Array(bin).reduce((s, byte) => s + String.fromCharCode(byte), ''));\n}\n\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/* global atob, btoa, crypto */\nconst a = function(str) { return atob(str); };\nconst b = function (str) { return btoa(str); };\nconst c = typeof crypto === 'undefined' ? null : crypto;\n\nexport { a as atob, b as btoa, c as webcrypto };\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\nexport * from './base64';\nexport * from './oidcHash';\nexport * from './types';\nexport * from './verifyToken';\nexport * from './webcrypto';\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/* global TextEncoder */\nimport { stringToBase64Url } from './base64';\nimport { webcrypto } from './webcrypto';\n\nexport function getOidcHash(str) {  \n  var buffer = new TextEncoder().encode(str);\n  return webcrypto.subtle.digest('SHA-256', buffer).then(function(arrayBuffer) {\n    var intBuffer = new Uint8Array(arrayBuffer);\n    var firstHalf = intBuffer.slice(0, 16);\n    var hash = String.fromCharCode.apply(null, firstHalf as unknown as number[]);\n    var b64u = stringToBase64Url(hash); // url-safe base64 variant\n    return b64u;\n  });\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\nimport { clone } from '../util';\nimport { stringToBuffer, base64UrlDecode } from './base64';\nimport { webcrypto } from './webcrypto';\n\nexport function verifyToken(idToken, key) {\n  key = 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  // eslint-disable-next-line @typescript-eslint/ban-ts-comment\n  // @ts-ignore\n  return webcrypto.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 = stringToBuffer(jwt[0] + '.' + jwt[1]);\n    var b64Signature = base64UrlDecode(jwt[2]);\n    var signature = stringToBuffer(b64Signature);\n\n    return webcrypto.subtle.verify(\n      algo,\n      cryptoKey,\n      signature,\n      payload\n    );\n  });\n}\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// ./node is swapped for ./browser in webpack config\nexport * from './node';","/*!\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\nimport CustomError from './CustomError';\nimport { HttpResponse } from '../http/types';\nimport { APIError, FieldError } from './types';\n\nexport default class AuthApiError extends CustomError implements APIError {\n  errorSummary: string;\n  errorCode?: string;\n  errorLink?: string;\n  errorId?: string;\n  errorCauses?: Array<FieldError>;\n  xhr?: HttpResponse;\n  meta?: Record<string, string | number>;\n\n  constructor(err: APIError, xhr?: HttpResponse, meta?: Record<string, string | number>) {\n    const message = err.errorSummary;\n    super(message);\n\n    this.name = 'AuthApiError';\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\n    if (meta) {\n      this.meta = meta;\n    }\n  }\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\nimport CustomError from './CustomError';\n\nexport default class AuthPollStopError extends CustomError {\n  constructor() {\n    const message = 'The poll was stopped by the sdk';\n    super(message);\n  }\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\nimport CustomError from './CustomError';\nimport { APIError, FieldError } from './types';\n\nexport default class AuthSdkError extends CustomError implements APIError {\n  errorSummary: string;\n  errorCode: string;\n  errorLink: string;\n  errorId: string;\n  errorCauses: Array<FieldError>;\n  xhr?: XMLHttpRequest;\n\n  constructor(msg: string, xhr?: XMLHttpRequest) {\n    super(msg);\n    this.name = 'AuthSdkError';\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  }\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\nexport default class CustomError extends Error {\n  constructor(message: string) {\n    // https://stackoverflow.com/questions/41102060/typescript-extending-error-class\n    super(message); // 'Error' breaks prototype chain here\n    Object.setPrototypeOf(this, new.target.prototype); // restore prototype chain\n  }\n}\n","/* eslint-disable camelcase */\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\nimport CustomError from './CustomError';\nimport type { HttpResponse } from '../http';\n\nexport default class OAuthError extends CustomError {\n  errorCode: string;\n  errorSummary: string;\n\n  // for widget / idx-js backward compatibility\n  error: string;\n  error_description: string;\n\n  resp: HttpResponse | null = null;\n\n  constructor(errorCode: string, summary: string, resp?: HttpResponse) {\n    super(summary);\n\n    this.name = 'OAuthError';\n    this.errorCode = errorCode;\n    this.errorSummary = summary;\n\n    // for widget / idx-js backward compatibility\n    this.error = errorCode;\n    this.error_description = summary;\n\n    // an OAuth error (should) always result from a network request\n    // therefore include that in error for potential error handling\n    if (resp) {\n      this.resp = resp;\n    }\n  }\n}\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\nimport type { HttpResponse } from '../http';\nimport CustomError from './CustomError';\nimport { isFunction } from '../util';\n\n// Error thrown after an unsuccessful network request which requires an Authorization header \n// and returns a 4XX error with a www-authenticate header. The header value is parsed to construct \n// an error instance, which contains key/value pairs parsed out\nexport default class WWWAuthError extends CustomError {\n  static UNKNOWN_ERROR = 'UNKNOWN_WWW_AUTH_ERROR';\n\n  scheme: string;\n  parameters: Record<string, string>;\n  name = 'WWWAuthError';\n\n  resp: HttpResponse | null = null;\n\n  constructor(scheme: string, parameters: Record<string, string>, resp?: HttpResponse) {\n    // defaults to unknown error. `error` being returned in the www-authenticate header is expected\n    // but cannot be guaranteed. Throwing an error within a error constructor seems awkward\n    super(parameters.error ?? WWWAuthError.UNKNOWN_ERROR);\n    this.scheme = scheme;\n    this.parameters = parameters;\n\n    if (resp) {\n      this.resp = resp;\n    }\n  }\n\n  // convenience references\n  get error (): string { return this.parameters.error; }\n  get errorCode (): string { return this.error; }                 // parity with other error props\n  // eslint-disable-next-line camelcase\n  get error_description (): string { return this.parameters.error_description; }\n  // eslint-disable-next-line camelcase\n  get errorDescription (): string { return this.error_description; }\n  get errorSummary (): string { return this.errorDescription; }   // parity with other error props\n  get realm (): string { return this.parameters.realm; }\n\n  // parses the www-authenticate header for releveant\n  static parseHeader (header: string): WWWAuthError | null {\n    // header cannot be empty string\n    if (!header) {\n      return null;\n    }\n\n    // example string: Bearer error=\"invalid_token\", error_description=\"The access token is invalid\"\n    // regex will match on `error=\"invalid_token\", error_description=\"The access token is invalid\"`\n    // see unit test for more examples of possible www-authenticate values\n    // eslint-disable-next-line max-len\n    const regex = /(?:,|, )?([a-zA-Z0-9!#$%&'*+\\-.^_`|~]+)=(?:\"([a-zA-Z0-9!#$%&'*+\\-.,^_`|~ /:]+)\"|([a-zA-Z0-9!#$%&'*+\\-.^_`|~/:]+))/g;\n    const firstSpace = header.indexOf(' ');\n    const scheme = header.slice(0, firstSpace);\n    const remaining = header.slice(firstSpace + 1);\n    const params = {};\n\n    // Reference: foo=\"hello\", bar=\"bye\"\n    // i=0, match=[foo=\"hello1\", foo, hello]\n    // i=1, match=[bar=\"bye\", bar, bye]\n    let match;\n    while ((match = regex.exec(remaining)) !== null) {\n      params[match[1]] = (match[2] ?? match[3]);\n    }\n\n    return new WWWAuthError(scheme, params);\n  }\n\n  // finds the value of the `www-authenticate` header. HeadersInit allows for a few different\n  // representations of headers with different access patterns (.get vs [key])\n  static getWWWAuthenticateHeader (headers: HeadersInit = {}): string | null {\n    if (isFunction((headers as Headers)?.get)) {\n      return (headers as Headers).get('WWW-Authenticate');\n    }\n    return headers['www-authenticate'] ?? headers['WWW-Authenticate'];\n  }\n}\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\nimport AuthApiError from './AuthApiError';\nimport AuthPollStopError from './AuthPollStopError';\nimport AuthSdkError from './AuthSdkError';\nimport OAuthError from './OAuthError';\nimport WWWAuthError from './WWWAuthError';\n\nfunction isAuthApiError(obj: any): obj is AuthApiError {\n  return (obj instanceof AuthApiError);\n}\n\nfunction isOAuthError(obj: any): obj is OAuthError {\n  return (obj instanceof OAuthError);\n}\n\nfunction isWWWAuthError(obj: any): obj is WWWAuthError {\n  return (obj instanceof WWWAuthError);\n}\n\nexport {\n  isAuthApiError,\n  isOAuthError,\n  isWWWAuthError,\n  AuthApiError,\n  AuthPollStopError,\n  AuthSdkError,\n  OAuthError,\n  WWWAuthError\n};\n\nexport * from './types';\n","import { OktaAuth } from '../default';\n\n// Export only a single object\nexport default OktaAuth;\n","import * as crypto from '../crypto';\n\nexport { crypto };\nexport * from '../base';\nexport * from '../constants';\nexport * from '../core';\nexport * from '../errors';\nexport * from '../http';\nexport * from '../oidc';\nexport * from '../session';\nexport * from '../storage';\nexport * from '../util';\n","import {\n  OktaAuthOptionsConstructor,\n} from '../base';\n\nimport {\n  IdxStorageManagerConstructor,\n  IdxTransactionManagerConstructor,\n  OktaAuthIdxOptions,\n  createIdxTransactionManager,\n  createOktaAuthIdx,\n  createIdxStorageManager,\n  createIdxOptionsConstructor\n} from '../idx';\n\nimport { mixinMyAccount } from '../myaccount';\nimport { mixinAuthn } from '../authn';\n\n\n// eslint-disable-next-line @typescript-eslint/no-empty-interface\nexport interface OktaAuthOptions extends OktaAuthIdxOptions {}\n\nconst OptionsConstructor: OktaAuthOptionsConstructor<OktaAuthOptions> = createIdxOptionsConstructor();\nconst StorageManager: IdxStorageManagerConstructor = createIdxStorageManager();\nconst TransactionManager: IdxTransactionManagerConstructor = createIdxTransactionManager();\n\n// Default bundle includes everything\nconst WithIdx = createOktaAuthIdx(StorageManager, OptionsConstructor, TransactionManager);\nconst WithMyAccount = mixinMyAccount(WithIdx);\nconst WithAuthn = mixinAuthn(WithMyAccount);\n\nclass OktaAuth extends WithAuthn {\n  constructor(options: OktaAuthOptions) {\n    super(options);\n  }\n}\n\nexport default OktaAuth;\nexport { OktaAuth };\nexport * from './common';\nexport * from '../idx';\nexport * from '../myaccount';\nexport * from '../authn';\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/* eslint-disable node/no-unsupported-features/node-builtins */\n/* global document, window, TextEncoder, navigator */\n\nimport { webcrypto } from './crypto';\n\nconst isWindowsPhone = /windows phone|iemobile|wpdesktop/i;\t\n\nexport function isBrowser() {\n  return typeof document !== 'undefined' && typeof window !== 'undefined';\n}\n\nexport function isIE11OrLess() {\n  if (!isBrowser()) {\n    return false;\n  }\n  const documentMode = (document as any).documentMode;\n  return !!documentMode && documentMode <= 11;\n}\n\nexport function getUserAgent() {\n  return navigator.userAgent;\n}\n\nexport function isFingerprintSupported() {\n  const agent = getUserAgent();\n  return agent && !isWindowsPhone.test(agent);\t\n}\n\nexport function isPopupPostMessageSupported() {\n  if (!isBrowser()) {\n    return false;\n  }\n  const documentMode = (document as any).documentMode;\n  var isIE8or9 = documentMode && documentMode < 10;\n  if (typeof window.postMessage !== 'undefined' && !isIE8or9) {\n    return true;\n  }\n  return false;\n}\n\nfunction isWebCryptoSubtleSupported () {\n  return typeof webcrypto !== 'undefined'\n    && webcrypto !== null\n    && typeof webcrypto.subtle !== 'undefined'\n    && typeof Uint8Array !== 'undefined';\n}\n\nexport function isTokenVerifySupported() {\n  return isWebCryptoSubtleSupported();\n}\n\nexport function hasTextEncoder() {\n  return typeof TextEncoder !== 'undefined';\n}\n\nexport function isPKCESupported() {\n  return isTokenVerifySupported() && hasTextEncoder();\n}\n\nexport function isHTTPS() {\n  if (!isBrowser()) {\n    return false;\n  }\n  return window.location.protocol === 'https:';\n}\n\nexport function isLocalhost() {\n  // eslint-disable-next-line compat/compat\n  return isBrowser() && window.location.hostname === 'localhost';\n}\n\n// For now, DPoP is only supported on browsers\nexport function isDPoPSupported () {\n  return !isIE11OrLess() &&\n    typeof window.indexedDB !== 'undefined' &&\n    hasTextEncoder() &&\n    isWebCryptoSubtleSupported();\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\nimport crossFetch from 'cross-fetch';\nimport { FetchOptions, HttpResponse } from '../http/types';\n\n// content-type = application/json OR application/ion+json\nconst appJsonContentTypeRegex = /application\\/\\w*\\+?json/;\n\nfunction readData(response: Response): Promise<object | string> {\n  if (response.headers.get('Content-Type') &&\n    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n    response.headers.get('Content-Type')!.toLowerCase().indexOf('application/json') >= 0) {\n  return response.json()\n    // JSON parse can fail if response is not a valid object\n    .catch(e => {\n      return {\n        error: e,\n        errorSummary: 'Could not parse server response'\n      };\n    });\n  } else {\n    return response.text();\n  }\n}\n\nfunction formatResult(status: number, data: object | string, response: Response) {\n  const isObject = typeof data === 'object';\n  const headers = {};\n  for (const pair of (response.headers as any).entries()) {\n    headers[pair[0]] = pair[1];\n  }\n  const result: HttpResponse = {\n    responseText: isObject ? JSON.stringify(data) : data as string,\n    status: status,\n    headers\n  };\n  if (isObject) {\n    result.responseType = 'json';\n    result.responseJSON = data as object;\n  }\n  return result;\n}\n\n/* eslint-disable complexity */\nfunction fetchRequest(method: string, url: string, args: FetchOptions) {\n  var body = args.data;\n  var headers = args.headers || {};\n  var contentType = (headers['Content-Type'] || headers['content-type'] || '');\n\n  if (body && typeof body !== 'string') {\n    // JSON encode body (if appropriate)\n    if (appJsonContentTypeRegex.test(contentType)) {\n      body = JSON.stringify(body);\n    }\n    else if (contentType === 'application/x-www-form-urlencoded') {\n      body = Object.entries(body)\n      .map( ([param, value]) => `${param}=${encodeURIComponent(value)}` )\n      .join('&');\n    }\n  }\n\n  var fetch = global.fetch || crossFetch;\n  var fetchPromise = fetch(url, {\n    method: method,\n    headers: args.headers,\n    body: body as string,\n    credentials: args.withCredentials ? 'include' : 'omit'\n  });\n\n  if (!fetchPromise.finally) {\n    fetchPromise = Promise.resolve(fetchPromise);\n  }\n\n  return fetchPromise.then(function(response) {\n    var error = !response.ok;\n    var status = response.status;\n    return readData(response)\n      .then(data => {\n        return formatResult(status, data, response);\n      })\n      .then(result => {\n        if (error || result.responseJSON?.error) {\n          // Throwing result object since error handling is done in http.js\n          throw result;\n        }\n        return result;\n      });\n  });\n}\n\nexport default fetchRequest;\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/* global SDK_VERSION */\n\nimport { isBrowser } from '../features';\nexport class OktaUserAgent {\n  environments: string[];\n\n  constructor() {\n    // add base sdk env\n    this.environments = [`okta-auth-js/${SDK_VERSION}`];\n    this.maybeAddNodeEnvironment();\n  }\n\n  addEnvironment(env: string) {\n    this.environments.push(env);\n  }\n\n  getHttpHeader() {\n    return { 'X-Okta-User-Agent-Extended': this.environments.join(' ') };\n  }\n\n  getVersion() {\n    return SDK_VERSION;\n  }\n\n  maybeAddNodeEnvironment() {\n    if (isBrowser() || !process || !process.versions) {\n      return;\n    }\n    const { node: version } = process.versions;\n    this.environments.push(`nodejs/${version}`);\n  }\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 */\nimport { OktaAuthHttpInterface } from './types';\n\nexport function setRequestHeader(authClient: OktaAuthHttpInterface, headerName, headerValue) {\n  authClient.options.headers = authClient.options.headers || {};\n  authClient.options.headers[headerName] = headerValue;\n}","export * from './headers';\nexport * from './OktaUserAgent';\nexport * from './request';\nexport * from './types';\nexport * from './mixin';\nexport * from './options';\n\n","import { OktaAuthStorageInterface, StorageManagerInterface } from '../storage/types';\nimport { OktaAuthConstructor } from '../base/types';\nimport {\n  HttpAPI,\n  OktaAuthHttpInterface,\n  OktaAuthHttpOptions,\n} from './types';\nimport { OktaUserAgent } from './OktaUserAgent';\nimport { setRequestHeader } from './headers';\nimport { toQueryString } from '../util';\nimport { get } from './request';\n\nexport function mixinHttp\n<\n  S extends StorageManagerInterface = StorageManagerInterface,\n  O extends OktaAuthHttpOptions = OktaAuthHttpOptions,\n  TBase extends OktaAuthConstructor<OktaAuthStorageInterface<S, O>>\n    = OktaAuthConstructor<OktaAuthStorageInterface<S, O>>\n>\n(Base: TBase): TBase & OktaAuthConstructor<OktaAuthHttpInterface<S, O>>\n{\n  return class OktaAuthHttp extends Base implements OktaAuthHttpInterface<S, O>\n  {\n    _oktaUserAgent: OktaUserAgent;\n    http: HttpAPI;\n    \n    constructor(...args: any[]) {\n      super(...args);\n\n      this._oktaUserAgent = new OktaUserAgent();\n\n      // HTTP\n      this.http = {\n        setRequestHeader: setRequestHeader.bind(null, this)\n      };\n    }\n\n    setHeaders(headers) {\n      this.options.headers = Object.assign({}, this.options.headers, headers);\n    }\n  \n    getIssuerOrigin(): string {\n      // Infer the URL from the issuer URL, omitting the /oauth2/{authServerId}\n      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n      return this.options.issuer!.split('/oauth2/')[0];\n    }\n  \n    webfinger(opts): Promise<object> {\n      var url = '/.well-known/webfinger' + toQueryString(opts);\n      var options = {\n        headers: {\n          'Accept': 'application/jrd+json'\n        }\n      };\n      return get(this, url, options);\n    }\n  };\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\nimport { createStorageOptionsConstructor } from '../storage';\nimport { HttpRequestClient, OktaAuthHttpOptions, RequestOptions } from './types';\nimport fetchRequest from '../fetch/fetchRequest';\n\nexport function createHttpOptionsConstructor() {\n  const StorageOptionsConstructor = createStorageOptionsConstructor();\n  return class HttpOptionsConstructor extends StorageOptionsConstructor implements Required<OktaAuthHttpOptions> {\n    issuer: string;\n    transformErrorXHR: (xhr: object) => any;\n    headers: object;\n    httpRequestClient: HttpRequestClient;\n    httpRequestInterceptors: ((request: RequestOptions) => void)[];\n    \n    constructor(args: any) {\n      super(args);\n      this.issuer = args.issuer;\n      this.transformErrorXHR = args.transformErrorXHR;\n      this.headers = args.headers;\n      this.httpRequestClient = args.httpRequestClient || fetchRequest;\n      this.httpRequestInterceptors = args.httpRequestInterceptors;\n    }\n  };\n}\n","/* eslint-disable @typescript-eslint/no-non-null-assertion */\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 */\nimport { isString, clone, isAbsoluteUrl, removeNils } from '../util';\nimport { STATE_TOKEN_KEY_NAME, DEFAULT_CACHE_DURATION } from '../constants';\nimport {\n  OktaAuthHttpInterface,\n  RequestOptions,\n  FetchOptions,\n  RequestData,\n  HttpResponse\n} from './types';\nimport { AuthApiError, OAuthError, APIError, WWWAuthError } from '../errors';\n\n\nconst formatError = (sdk: OktaAuthHttpInterface, error: HttpResponse | Error): AuthApiError | OAuthError => {\n  if (error instanceof Error) {\n    // fetch() can throw exceptions\n    // see https://developer.mozilla.org/en-US/docs/Web/API/fetch#exceptions\n    return new AuthApiError({\n      errorSummary: error.message,\n    });\n  }\n\n  let resp: HttpResponse = error;\n  let err: AuthApiError | OAuthError | WWWAuthError;\n  let serverErr: Record<string, any> = {};\n  if (resp.responseText && isString(resp.responseText)) {\n    try {\n      serverErr = JSON.parse(resp.responseText);\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(clone(resp));\n  }\n\n  // \n  const wwwAuthHeader = WWWAuthError.getWWWAuthenticateHeader(resp?.headers) ?? '';\n\n  if (serverErr.error && serverErr.error_description) {\n    err = new OAuthError(serverErr.error, serverErr.error_description, resp);\n  } else {\n    err = new AuthApiError(serverErr as APIError, resp, { wwwAuthHeader });\n  }\n\n  if (wwwAuthHeader && resp?.status >= 400 && resp?.status < 500) {\n    const wwwAuthErr = WWWAuthError.parseHeader(wwwAuthHeader);\n    // check for 403 to avoid breaking change\n    if (resp.status === 403 && wwwAuthErr?.error === 'insufficient_authentication_context') {\n      // eslint-disable-next-line camelcase\n      const { max_age, acr_values } = wwwAuthErr.parameters;\n      err = new AuthApiError(\n        {\n          errorSummary: wwwAuthErr.error,\n          errorCauses: [{ errorSummary: wwwAuthErr.errorDescription }]\n        },\n        resp,\n        {\n          // eslint-disable-next-line camelcase\n          max_age: +max_age,\n          // eslint-disable-next-line camelcase\n          ...(acr_values && { acr_values })\n        }\n      );\n    }\n    else if (wwwAuthErr?.scheme === 'DPoP') {\n      err = wwwAuthErr;\n    }\n    // else {\n    //   // WWWAuthError.parseHeader may return null, only overwrite if !null\n    //   err = wwwAuthErr ?? err;\n    // }\n  }\n\n  return err;\n};\n\nexport function httpRequest(sdk: OktaAuthHttpInterface, options: RequestOptions): Promise<any> {\n  options = options || {};\n\n  if (sdk.options.httpRequestInterceptors) {\n    for (const interceptor of sdk.options.httpRequestInterceptors) {\n      interceptor(options);\n    }\n  }\n\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 === true, // default value is false\n      storageUtil = sdk.options.storageUtil,\n      storage = storageUtil!.storage,\n      httpCache = sdk.storageManager.getHttpCache(sdk.options.cookies);\n\n  if (options.cacheResponse) {\n    var cacheContents = httpCache.getStorage();\n    var cachedResponse = cacheContents[url as string];\n    if (cachedResponse && Date.now()/1000 < cachedResponse.expiresAt) {\n      return Promise.resolve(cachedResponse.response);\n    }\n  }\n\n  var oktaUserAgentHeader = sdk._oktaUserAgent.getHttpHeader();\n  var headers: HeadersInit = {\n    'Accept': 'application/json',\n    'Content-Type': 'application/json',\n    ...oktaUserAgentHeader\n  };\n  Object.assign(headers, sdk.options.headers, options.headers);\n  headers = removeNils(headers) as HeadersInit;\n\n  if (accessToken && isString(accessToken)) {\n    headers['Authorization'] = 'Bearer ' + accessToken;\n  }\n\n  var ajaxOptions: FetchOptions = {\n    headers,\n    data: args || undefined,\n    withCredentials\n  };\n\n  var err, res;\n  return sdk.options.httpRequestClient!(method!, url!, ajaxOptions)\n    .then(function(resp) {\n      res = resp.responseText;\n      if (res && isString(res)) {\n        res = JSON.parse(res);\n        if (res && typeof res === 'object' && !res.headers) {\n          if (Array.isArray(res)) {\n            res.forEach(item => {\n              item.headers = resp.headers;\n            });\n          } else {\n            res.headers = resp.headers;\n          }\n        }\n      }\n\n      if (saveAuthnState) {\n        if (!res.stateToken) {\n          storage.delete(STATE_TOKEN_KEY_NAME);\n        }\n      }\n\n      if (res && res.stateToken && res.expiresAt) {\n        storage.set(STATE_TOKEN_KEY_NAME, res.stateToken, res.expiresAt, sdk.options.cookies!);\n      }\n\n      if (res && options.cacheResponse) {\n        httpCache.updateStorage(url!, {\n          expiresAt: Math.floor(Date.now()/1000) + DEFAULT_CACHE_DURATION,\n          response: res\n        });\n      }\n      \n      return res;\n    })\n    .catch(function(resp) {\n      err = formatError(sdk, resp);\n\n      if (err.errorCode === 'E0000011') {\n        storage.delete(STATE_TOKEN_KEY_NAME);\n      }\n\n      throw err;\n    });\n}\n\nexport function get(sdk: OktaAuthHttpInterface, url: string, options?: RequestOptions) {\n  url = isAbsoluteUrl(url) ? url : sdk.getIssuerOrigin() + url;\n  var getOptions = {\n    url: url,\n    method: 'GET'\n  };\n  Object.assign(getOptions, options);\n  return httpRequest(sdk, getOptions);\n}\n\nexport function post(sdk: OktaAuthHttpInterface, url: string, args?: RequestData, options?: RequestOptions) {\n  url = isAbsoluteUrl(url) ? url : sdk.getIssuerOrigin() + url;\n  var postOptions = {\n    url: url,\n    method: 'POST',\n    args: args,\n    saveAuthnState: true\n  };\n  Object.assign(postOptions, options);\n  return httpRequest(sdk, postOptions);\n}\n","import { ClearTransactionMetaOptions, TransactionManagerOptions } from '../oidc/types';\nimport { createTransactionManager } from '../oidc/TransactionManager';\nimport { IdxTransactionMeta, IntrospectOptions } from './types';\nimport { isRawIdxResponse } from './types/idx-js';\nimport { IdxStorageManagerInterface, SavedIdxResponse } from './types/storage';\n\nexport function createIdxTransactionManager\n<\n  M extends IdxTransactionMeta = IdxTransactionMeta,\n  S extends IdxStorageManagerInterface<M> = IdxStorageManagerInterface<M>\n>\n()\n{\n  const TransactionManager = createTransactionManager<M, S>();\n  return class IdxTransactionManager extends TransactionManager\n  {\n    constructor(options: TransactionManagerOptions) {\n      super(options);\n    }\n\n    clear(options: ClearTransactionMetaOptions = {}) {\n      super.clear(options);\n\n      if (options.clearIdxResponse !== false) {\n        this.clearIdxResponse();\n      }\n    }\n    \n    saveIdxResponse(data: SavedIdxResponse): void {\n      if (!this.saveLastResponse) {\n        return;\n      }\n      const storage = this.storageManager.getIdxResponseStorage();\n      if (!storage) {\n        return;\n      }\n      storage.setStorage(data);\n    }\n\n    // eslint-disable-next-line complexity\n    loadIdxResponse(options?: IntrospectOptions): SavedIdxResponse | null {\n      if (!this.saveLastResponse) {\n        return null;\n      }\n      const storage = this.storageManager.getIdxResponseStorage();\n      if (!storage) {\n        return null;\n      }\n      const storedValue = storage.getStorage();\n      if (!storedValue || !isRawIdxResponse(storedValue.rawIdxResponse)) {\n        return null;\n      }\n\n      if (options) {\n        const { stateHandle, interactionHandle } = options;\n        // only perform this check if NOT using generic remediator\n        if (!options.useGenericRemediator && stateHandle && storedValue.stateHandle !== stateHandle) {\n          return null;\n        }\n        if (interactionHandle && storedValue.interactionHandle !== interactionHandle) {\n          return null;\n        }\n      }\n\n      return storedValue;\n    }\n\n    clearIdxResponse(): void {\n      if (!this.saveLastResponse) {\n        return;\n      }\n      const storage = this.storageManager.getIdxResponseStorage();\n      storage?.clearStorage();\n    }\n  };\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\nimport { \n  OktaAuthIdxInterface,\n  IdxTransaction,\n  AuthenticatorKey,\n  AuthenticationOptions\n} from './types';\nimport { run } from './run';\n\nexport async function authenticate(\n  authClient: OktaAuthIdxInterface, options: AuthenticationOptions = {}\n): Promise<IdxTransaction> {\n  if (options.password && !options.authenticator) {\n    options.authenticator = AuthenticatorKey.OKTA_PASSWORD;\n  }\n  return run(authClient, { \n    ...options, \n    flow: 'authenticate'\n  });\n}\n","import { IdxAuthenticator, IdxRemediationValue } from '../types/idx-js';\n\n\nexport interface Credentials {\n  [key: string]: string | boolean | number | undefined;\n}\n\nexport abstract class Authenticator<Values> {\n  meta: IdxAuthenticator;\n\n  constructor(authenticator: IdxAuthenticator) {\n    this.meta = authenticator;\n  }\n\n  abstract canVerify(values: Values): boolean;\n\n  abstract mapCredentials(values: Values): Credentials | undefined;\n\n  abstract getInputs(idxRemediationValue: IdxRemediationValue): any; // TODO: add type\n}\n","import { Authenticator, Credentials } from './Authenticator';\n\nexport interface OktaPasswordInputValues {\n  password?: string;\n  passcode?: string;\n  credentials?: Credentials;\n  // for ResetAuthenticator\n  revokeSessions?: boolean;\n}\n\nexport class OktaPassword extends Authenticator<OktaPasswordInputValues> {\n  canVerify(values: OktaPasswordInputValues) {\n    return !!(values.credentials || values.password || values.passcode);\n  }\n\n  mapCredentials(values: OktaPasswordInputValues): Credentials | undefined {\n    const { credentials, password, passcode, revokeSessions } = values;\n    if (!credentials && !password && !passcode) {\n      return;\n    }\n    return credentials || {\n      passcode: passcode || password,\n      revokeSessions,\n    };\n  }\n\n  getInputs(idxRemediationValue) {\n    const inputs = [{\n      ...idxRemediationValue.form?.value[0],\n      name: 'password',\n      type: 'string',\n      required: idxRemediationValue.required,\n    }];\n    const revokeSessions = idxRemediationValue.form?.value.find(\n      input => input.name === 'revokeSessions'\n    );\n    if (revokeSessions) {\n      inputs.push({\n        name: 'revokeSessions',\n        type: 'boolean',\n        label: 'Sign me out of all other devices',\n        required: false,\n      });\n    }\n    return inputs;\n  }\n}\n","import { Credentials } from './Authenticator';\nimport { VerificationCodeAuthenticator } from './VerificationCodeAuthenticator';\n\ninterface TotpCredentials extends Credentials {\n  totp: string;\n}\n\nexport class OktaVerifyTotp extends VerificationCodeAuthenticator {\n  mapCredentials(values): TotpCredentials | undefined {\n    const { verificationCode } = values;\n    if (!verificationCode) {\n      return;\n    }\n    return { totp: verificationCode };\n  }\n}\n","import { Authenticator, Credentials } from './Authenticator';\n\nexport interface SecurityQuestionEnrollValues {\n  questionKey?: string;\n  question?: string;\n  answer?: string;\n  credentials?: Credentials;\n}\n\nexport class SecurityQuestionEnrollment extends Authenticator<SecurityQuestionEnrollValues> {\n  canVerify(values: SecurityQuestionEnrollValues) {\n    const { credentials } = values;\n    if (credentials && credentials.questionKey && credentials.answer) {\n      return true;\n    }\n    const { questionKey, question, answer } = values;\n    return !!(questionKey && answer) || !!(question && answer);\n  }\n\n  mapCredentials(values: SecurityQuestionEnrollValues): Credentials | undefined {\n    const { questionKey, question, answer } = values;\n    if (!answer || (!questionKey && !question)) {\n      return;\n    }\n    return {\n      questionKey: question ? 'custom' : questionKey,\n      question,\n      answer\n    };\n  }\n\n  getInputs() {\n    return [\n      { name: 'questionKey', type: 'string', required: true },\n      { name: 'question', type: 'string', label: 'Create a security question' },\n      { name: 'answer', type: 'string', label: 'Answer', required: true },\n    ];\n  }\n}\n","/* eslint-disable @typescript-eslint/no-non-null-assertion */\nimport { Authenticator, Credentials } from './Authenticator';\n\nexport interface SecurityQuestionVerificationValues {\n  answer?: string;\n  credentials?: Credentials;\n}\n\nexport class SecurityQuestionVerification extends Authenticator<SecurityQuestionVerificationValues> {\n  canVerify(values: SecurityQuestionVerificationValues) {\n    const { credentials } = values;\n    if (credentials && credentials.answer) {\n      return true;\n    }\n    const { answer } = values;\n    return !!answer;\n  }\n\n  mapCredentials(values: SecurityQuestionVerificationValues): Credentials | undefined {\n    const { answer } = values;\n    if (!answer) {\n      return;\n    }\n    return {\n      questionKey: this.meta.contextualData!.enrolledQuestion!.questionKey,\n      answer\n    };\n  }\n\n  getInputs() {\n    return [\n      { name: 'answer', type: 'string', label: 'Answer', required: true }\n    ];\n  }\n}\n","import { Authenticator, Credentials } from './Authenticator';\n\nexport interface VerificationCodeValues {\n  verificationCode?: string;\n  otp?: string;\n  credentials?: Credentials;\n}\n\ninterface VerificationCodeCredentials extends Credentials {\n  passcode: string;\n}\n\n// general authenticator to handle \"verificationCode\" input\n// it can be used for \"email\", \"phone\", \"google authenticator\"\n// a new authenticator class should be created if special cases need to be handled\nexport class VerificationCodeAuthenticator extends Authenticator<VerificationCodeValues> {\n  canVerify(values: VerificationCodeValues) {\n    return !!(values.credentials ||values.verificationCode || values.otp);\n  }\n\n  mapCredentials(values): VerificationCodeCredentials | Credentials | undefined {\n    const { credentials, verificationCode, otp } = values;\n    if (!credentials && !verificationCode && !otp) {\n      return;\n    }\n    return credentials || { passcode: verificationCode || otp };\n  }\n\n  getInputs(idxRemediationValue) {\n    return {\n      ...idxRemediationValue.form?.value[0],\n      name: 'verificationCode',\n      type: 'string',\n      required: idxRemediationValue.required\n    };\n  }\n}\n","import { Authenticator, Credentials } from './Authenticator';\n\nexport interface WebauthnEnrollValues {\n  clientData?: string;\n  attestation?: string;\n  credentials?: Credentials;\n}\n\nexport class WebauthnEnrollment extends Authenticator<WebauthnEnrollValues> {\n  canVerify(values: WebauthnEnrollValues) {\n    const { credentials } = values;\n    const obj = credentials || values;\n    const { clientData, attestation } = obj;\n    return !!(clientData && attestation);\n  }\n\n  mapCredentials(values: WebauthnEnrollValues): Credentials | undefined {\n    const { credentials, clientData, attestation } = values;\n    if (!credentials && !clientData && !attestation) {\n      return;\n    }\n    return credentials || ({\n      clientData,\n      attestation\n    });\n  }\n\n  getInputs() {\n    return [\n      { name: 'clientData', type: 'string', required: true, visible: false, label: 'Client Data' },\n      { name: 'attestation', type: 'string', required: true, visible: false, label: 'Attestation' },\n    ];\n  }\n}\n","import { Authenticator, Credentials } from './Authenticator';\n\nexport interface WebauthnVerificationValues {\n  clientData?: string;\n  authenticatorData?: string;\n  signatureData?: string;\n  credentials?: Credentials;\n}\n\nexport class WebauthnVerification extends Authenticator<WebauthnVerificationValues> {\n  canVerify(values: WebauthnVerificationValues) {\n    const { credentials } = values;\n    const obj = credentials || values;\n    const { clientData, authenticatorData, signatureData } = obj;\n    return !!(clientData && authenticatorData && signatureData);\n  }\n\n  mapCredentials(values: WebauthnVerificationValues): Credentials | undefined {\n    const { credentials, authenticatorData, clientData, signatureData } = values;\n    if (!credentials && !authenticatorData && !clientData && !signatureData) {\n      return;\n    }\n    return credentials || ({\n      authenticatorData,\n      clientData,\n      signatureData\n    });\n  }\n\n  getInputs() {\n    return [\n      { name: 'authenticatorData', type: 'string', label: 'Authenticator Data', required: true, visible: false },\n      { name: 'clientData', type: 'string', label: 'Client Data', required: true, visible: false },\n      { name: 'signatureData', type: 'string', label: 'Signature Data', required: true, visible: false },\n    ];\n  }\n}\n","import { OktaVerifyTotp } from './OktaVerifyTotp';\nimport { Authenticator } from './Authenticator';\nimport { VerificationCodeAuthenticator } from './VerificationCodeAuthenticator';\nimport { OktaPassword } from './OktaPassword';\nimport { SecurityQuestionEnrollment } from './SecurityQuestionEnrollment';\nimport { SecurityQuestionVerification } from './SecurityQuestionVerification';\nimport { WebauthnEnrollment } from './WebauthnEnrollment';\nimport { WebauthnVerification } from './WebauthnVerification';\nimport { IdxAuthenticator, IdxRemediation } from '../types/idx-js';\nimport { AuthenticatorKey } from '../types';\n\n/* eslint complexity:[0,8] */\nexport function getAuthenticator(remediation: IdxRemediation): Authenticator<any> {\n  const relatesTo = remediation.relatesTo;\n  const value = relatesTo?.value || {} as IdxAuthenticator;\n  switch (value.key) {\n    case AuthenticatorKey.OKTA_PASSWORD:\n      return new OktaPassword(value);\n    case AuthenticatorKey.SECURITY_QUESTION:\n      if (value.contextualData?.enrolledQuestion) {\n        return new SecurityQuestionVerification(value);\n      } else {\n        return new SecurityQuestionEnrollment(value);\n      }\n    case AuthenticatorKey.OKTA_VERIFY:\n      return new OktaVerifyTotp(value);\n    case AuthenticatorKey.WEBAUTHN:\n      if (value.contextualData?.challengeData) {\n        return new WebauthnVerification(value);\n      } else {\n        return new WebauthnEnrollment(value);\n      }\n    default:\n      return new VerificationCodeAuthenticator(value);\n  }\n}\n","export * from './getAuthenticator';\nexport * from './Authenticator';\nexport * from './VerificationCodeAuthenticator';\nexport * from './OktaPassword';\nexport * from './SecurityQuestionEnrollment';\nexport * from './SecurityQuestionVerification';\nexport * from './WebauthnEnrollment';\nexport * from './WebauthnVerification';\n\nimport { OktaPasswordInputValues } from './OktaPassword';\nimport { SecurityQuestionEnrollValues } from './SecurityQuestionEnrollment';\nimport { SecurityQuestionVerificationValues } from './SecurityQuestionVerification';\nimport { VerificationCodeValues } from './VerificationCodeAuthenticator';\nimport { WebauthnEnrollValues } from './WebauthnEnrollment';\nimport { WebauthnVerificationValues } from './WebauthnVerification';\n\nexport type AuthenticatorValues = OktaPasswordInputValues\n  & SecurityQuestionEnrollValues\n  & SecurityQuestionVerificationValues\n  & VerificationCodeValues\n  & WebauthnEnrollValues\n  & WebauthnVerificationValues;\n","import { Authenticator, isAuthenticator } from '../types';\n\nexport function formatAuthenticator(incoming: unknown): Authenticator {\n  let authenticator: Authenticator;\n  if  (isAuthenticator(incoming)) {\n    authenticator = incoming;\n  } else if (typeof incoming === 'string') {\n    authenticator = {\n      key: incoming\n    };\n  } else {\n    throw new Error('Invalid format for authenticator');\n  }\n  return authenticator;\n}\n\n// Returns true if the authenticators are equivalent\nexport function compareAuthenticators(auth1, auth2) {\n  if (!auth1 || !auth2) {\n    return false;\n  }\n  // by id\n  if (auth1.id && auth2.id) {\n    return (auth1.id === auth2.id);\n  }\n  // by key\n  if (auth1.key && auth2.key) {\n    return (auth1.key === auth2.key);\n  }\n  return false;\n}\n\n// Find matched authenticator in provided order\nexport function findMatchedOption(authenticators, options) {\n  let option;\n  for (let authenticator of authenticators) {\n    option = options\n      .find(({ relatesTo }) => relatesTo.key && relatesTo.key === authenticator.key);\n    if (option) {\n      break;\n    }\n  }\n  return option;\n}","/*!\n * Copyright (c) 2021, 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\nimport { OktaAuthIdxInterface, CancelOptions, IdxTransactionMeta } from './types';\nimport { run } from './run';\nimport { getFlowSpecification } from './flow';\n\nexport async function cancel (authClient: OktaAuthIdxInterface, options?: CancelOptions) {\n  const meta = authClient.transactionManager.load() as IdxTransactionMeta;\n  const flowSpec = getFlowSpecification(authClient, meta.flow);\n  return run(authClient, {\n    ...options,\n    ...flowSpec,\n    actions: ['cancel']\n  });\n}\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\nimport { OktaAuthIdxInterface } from './types';\n\nimport CustomError from '../errors/CustomError';\nimport { urlParamsToObject  } from '../oidc/util/urlParams';\nimport { EmailVerifyCallbackResponse } from './types/api';\n\nexport class EmailVerifyCallbackError extends CustomError {\n  state: string;\n  otp: string;\n\n  constructor(state: string, otp: string) {\n    super(`Enter the OTP code in the originating client: ${otp}`);\n    this.name = 'EmailVerifyCallbackError';\n    this.state = state;\n    this.otp = otp;\n  }\n}\n\nexport function isEmailVerifyCallbackError(error: Error) {\n  return (error.name === 'EmailVerifyCallbackError');\n}\n\n// Check if state && otp have been passed back in the url\nexport function isEmailVerifyCallback (urlPath: string): boolean {\n  return /(otp=)/i.test(urlPath) && /(state=)/i.test(urlPath);\n}\n\n// Parse state and otp from a urlPath (should be either a search or fragment from the URL)\nexport function parseEmailVerifyCallback(urlPath: string): EmailVerifyCallbackResponse {\n  return urlParamsToObject(urlPath) as EmailVerifyCallbackResponse;\n}\n\nexport async function handleEmailVerifyCallback(authClient: OktaAuthIdxInterface, search: string) {\n  if (isEmailVerifyCallback(search)) {\n    const { state, otp } = parseEmailVerifyCallback(search);\n    if (authClient.idx.canProceed({ state })) {\n      // same browser / device\n      return await authClient.idx.proceed({ state, otp });\n    } else {\n      // different browser or device\n      throw new EmailVerifyCallbackError(state, otp);\n    }\n  }\n}\n","import { OktaAuthOptionsConstructor } from '../../base/types';\nimport { StorageManagerConstructor } from '../../storage/types';\nimport { IdxTransactionManagerInterface, MinimalOktaAuthIdxInterface, OktaAuthIdxConstructor } from '../types/api';\nimport { IdxTransactionMeta } from '../types/meta';\nimport { IdxStorageManagerInterface } from '../types/storage';\nimport { OktaAuthIdxOptions } from '../types/options';\nimport { TransactionManagerConstructor, MinimalOktaOAuthInterface } from '../../oidc/types';\nimport { mixinMinimalIdx } from '../mixinMinimal';\nimport { createOktaAuthBase } from '../../base/factory';\nimport { mixinStorage } from '../../storage/mixin';\nimport { mixinHttp } from '../../http/mixin';\nimport { mixinSession } from '../../session/mixin';\nimport { mixinMinimalOAuth } from '../../oidc/mixin/minimal';\n\nexport function createMinimalOktaAuthIdx<\n  M extends IdxTransactionMeta = IdxTransactionMeta,\n  S extends IdxStorageManagerInterface<M> = IdxStorageManagerInterface<M>,\n  O extends OktaAuthIdxOptions = OktaAuthIdxOptions,\n  TM extends IdxTransactionManagerInterface = IdxTransactionManagerInterface\n>(\n  StorageManagerConstructor: StorageManagerConstructor<S>,\n  OptionsConstructor: OktaAuthOptionsConstructor<O>,\n  TransactionManagerConstructor: TransactionManagerConstructor<TM>\n)\n: OktaAuthIdxConstructor<\n  MinimalOktaAuthIdxInterface<M, S, O, TM> & MinimalOktaOAuthInterface<M, S, O, TM>\n>\n{\n  const Base = createOktaAuthBase(OptionsConstructor);\n  const WithStorage = mixinStorage<S, O>(Base, StorageManagerConstructor);\n  const WithHttp = mixinHttp<S, O>(WithStorage);\n  const WithSession = mixinSession<S, O>(WithHttp);\n  const WithOAuth = mixinMinimalOAuth<M, S, O, TM>(WithSession, TransactionManagerConstructor);\n  // do not mixin core\n  const WithIdx = mixinMinimalIdx(WithOAuth);\n  return WithIdx;\n}\n","import { createOktaAuthCore } from '../../core/factory';\nimport { OktaAuthOptionsConstructor } from '../../base/types';\nimport { StorageManagerConstructor } from '../../storage/types';\nimport { IdxTransactionManagerInterface, OktaAuthIdxInterface, OktaAuthIdxConstructor } from '../types/api';\nimport { IdxTransactionMeta } from '../types/meta';\nimport { IdxStorageManagerInterface } from '../types/storage';\nimport { OktaAuthIdxOptions } from '../types/options';\nimport { mixinIdx } from '../mixin';\nimport { TransactionManagerConstructor } from '../../oidc/types';\nimport { OktaAuthCoreInterface } from '../../core/types';\n\nexport function createOktaAuthIdx<\n  M extends IdxTransactionMeta = IdxTransactionMeta,\n  S extends IdxStorageManagerInterface<M> = IdxStorageManagerInterface<M>,\n  O extends OktaAuthIdxOptions = OktaAuthIdxOptions,\n  TM extends IdxTransactionManagerInterface = IdxTransactionManagerInterface\n>(\n  StorageManagerConstructor: StorageManagerConstructor<S>,\n  OptionsConstructor: OktaAuthOptionsConstructor<O>,\n  TransactionManagerConstructor: TransactionManagerConstructor<TM>\n)\n: OktaAuthIdxConstructor<OktaAuthIdxInterface<M, S, O, TM> & OktaAuthCoreInterface<M, S, O, TM>>\n{\n  const Core = createOktaAuthCore<M, S, O, TM>(\n    StorageManagerConstructor,\n    OptionsConstructor,\n    TransactionManagerConstructor\n  );\n  const WithIdx = mixinIdx(Core);\n  return WithIdx;\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\nimport { isInteractionRequired, isInteractionRequiredError } from '../../oidc';\nimport { authenticate } from '../authenticate';\nimport { cancel } from '../cancel';\nimport {\n  handleEmailVerifyCallback,\n  isEmailVerifyCallback,\n  isEmailVerifyCallbackError,\n  parseEmailVerifyCallback\n} from '../emailVerify';\nimport { handleInteractionCodeRedirect } from '../handleInteractionCodeRedirect';\nimport { makeIdxState } from '../idxState';\nimport { interact } from '../interact';\nimport { introspect } from '../introspect';\nimport { poll } from '../poll';\nimport { canProceed, proceed } from '../proceed';\nimport { recoverPassword } from '../recoverPassword';\nimport { register } from '../register';\nimport { startTransaction } from '../startTransaction';\nimport {\n  clearTransactionMeta,\n  createTransactionMeta,\n  getSavedTransactionMeta,\n  getTransactionMeta,\n  isTransactionMetaValid,\n  saveTransactionMeta\n} from '../transactionMeta';\nimport { FlowIdentifier, IdxAPI, OktaAuthIdxInterface } from '../types';\nimport { unlockAccount } from '../unlockAccount';\nimport * as remediators from '../remediators';\nimport { getFlowSpecification } from '../flow/FlowSpecification';\nimport { setRemediatorsCtx } from '../util';\n\n// Factory\nexport function createIdxAPI(sdk: OktaAuthIdxInterface): IdxAPI {\n  setRemediatorsCtx({\n    remediators,\n    getFlowSpecification,\n  });\n  const boundStartTransaction = startTransaction.bind(null, sdk);\n  const idx = {\n    interact: interact.bind(null, sdk),\n    introspect: introspect.bind(null, sdk),\n    makeIdxResponse: makeIdxState.bind(null, sdk),\n    \n    authenticate: authenticate.bind(null, sdk),\n    register: register.bind(null, sdk),\n    start: boundStartTransaction,\n    startTransaction: boundStartTransaction, // Use `start` instead. `startTransaction` will be removed in 7.0\n    poll: poll.bind(null, sdk),\n    proceed: proceed.bind(null, sdk),\n    cancel: cancel.bind(null, sdk),\n    recoverPassword: recoverPassword.bind(null, sdk),\n\n    // oauth redirect callback\n    handleInteractionCodeRedirect: handleInteractionCodeRedirect.bind(null, sdk),\n\n    // interaction required callback\n    isInteractionRequired: isInteractionRequired.bind(null, sdk),\n    isInteractionRequiredError,\n\n    // email verify callback\n    handleEmailVerifyCallback: handleEmailVerifyCallback.bind(null, sdk),\n    isEmailVerifyCallback,\n    parseEmailVerifyCallback,\n    isEmailVerifyCallbackError,\n    \n    getSavedTransactionMeta: getSavedTransactionMeta.bind(null, sdk),\n    createTransactionMeta: createTransactionMeta.bind(null, sdk),\n    getTransactionMeta: getTransactionMeta.bind(null, sdk),\n    saveTransactionMeta: saveTransactionMeta.bind(null, sdk),\n    clearTransactionMeta: clearTransactionMeta.bind(null, sdk),\n    isTransactionMetaValid,\n    setFlow: (flow: FlowIdentifier) => {\n      sdk.options.flow = flow;\n    },\n    getFlow: (): FlowIdentifier | undefined => {\n      return sdk.options.flow;\n    },\n    canProceed: canProceed.bind(null, sdk),\n    unlockAccount: unlockAccount.bind(null, sdk),\n  };\n  return idx;\n}\n\n","export * from './api';\nexport * from './OktaAuthIdx';\nexport * from './MinimalOktaAuthIdx';\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\nimport { makeIdxState } from '../idxState';\nimport { canProceed, proceed } from '../proceed';\nimport { startTransaction } from '../startTransaction';\nimport {\n  clearTransactionMeta,\n  createTransactionMeta,\n  getSavedTransactionMeta,\n  getTransactionMeta,\n  isTransactionMetaValid,\n  saveTransactionMeta\n} from '../transactionMeta';\nimport { MinimalIdxAPI, MinimalOktaAuthIdxInterface, OktaAuthIdxInterface } from '../types';\n\n// Factory\nexport function createMinimalIdxAPI(minimalSdk: MinimalOktaAuthIdxInterface): MinimalIdxAPI {\n  const sdk = minimalSdk as OktaAuthIdxInterface;\n  const boundStartTransaction = startTransaction.bind(null, sdk);\n  const idx = {\n    makeIdxResponse: makeIdxState.bind(null, sdk),\n\n    start: boundStartTransaction,\n    startTransaction: boundStartTransaction, // Use `start` instead. `startTransaction` will be removed in 7.0\n    proceed: proceed.bind(null, sdk),\n    canProceed: canProceed.bind(null, sdk),\n    \n    getSavedTransactionMeta: getSavedTransactionMeta.bind(null, sdk),\n    createTransactionMeta: createTransactionMeta.bind(null, sdk),\n    getTransactionMeta: getTransactionMeta.bind(null, sdk),\n    saveTransactionMeta: saveTransactionMeta.bind(null, sdk),\n    clearTransactionMeta: clearTransactionMeta.bind(null, sdk),\n    isTransactionMetaValid,\n  };\n  return idx;\n}\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\nimport { RemediationFlow } from './RemediationFlow';\nimport {\n  Identify,\n  SelectAuthenticatorUnlockAccount,\n  SelectAuthenticatorAuthenticate,\n  ChallengeAuthenticator,\n  ChallengePoll,\n  AuthenticatorVerificationData,\n  ReEnrollAuthenticatorWarning\n} from '../remediators';\n\nexport const AccountUnlockFlow: RemediationFlow = {\n  'identify': Identify,\n  // NOTE: unlock-account is purposely not included. Handled as action\n  // because it's a rememdiation which requires no input\n  // 'unlock-account': UnlockAccount,\n  'select-authenticator-unlock-account': SelectAuthenticatorUnlockAccount,\n  'select-authenticator-authenticate': SelectAuthenticatorAuthenticate,\n  'challenge-authenticator': ChallengeAuthenticator,\n  'challenge-poll': ChallengePoll,\n  'authenticator-verification-data': AuthenticatorVerificationData,\n  'reenroll-authenticator-warning': ReEnrollAuthenticatorWarning,\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\nimport { RemediationFlow } from './RemediationFlow';\nimport { \n  Identify,\n  SelectAuthenticatorAuthenticate,\n  ChallengeAuthenticator,\n  ReEnrollAuthenticator,\n  ReEnrollAuthenticatorWarning,\n  RedirectIdp,\n  AuthenticatorEnrollmentData,\n  SelectAuthenticatorEnroll,\n  EnrollAuthenticator,\n  AuthenticatorVerificationData,\n  EnrollPoll,\n  ChallengePoll,\n  SelectEnrollmentChannel,\n  EnrollmentChannelData,\n  Skip\n} from '../remediators';\n\nexport const AuthenticationFlow: RemediationFlow = {\n  'identify': Identify,\n  'select-authenticator-authenticate': SelectAuthenticatorAuthenticate,\n  'select-authenticator-enroll': SelectAuthenticatorEnroll,\n  'authenticator-enrollment-data': AuthenticatorEnrollmentData,\n  'authenticator-verification-data': AuthenticatorVerificationData,\n  'enroll-authenticator': EnrollAuthenticator,\n  'challenge-authenticator': ChallengeAuthenticator,\n  'challenge-poll': ChallengePoll,\n  'reenroll-authenticator': ReEnrollAuthenticator,\n  'reenroll-authenticator-warning': ReEnrollAuthenticatorWarning,\n  'enroll-poll': EnrollPoll,\n  'select-enrollment-channel': SelectEnrollmentChannel,\n  'enrollment-channel-data': EnrollmentChannelData,\n  'redirect-idp': RedirectIdp,\n  'skip': Skip,\n};\n","import { OktaAuthIdxInterface, FlowIdentifier, FlowSpecification } from '../types';\nimport { AuthenticationFlow } from './AuthenticationFlow';\nimport { PasswordRecoveryFlow } from './PasswordRecoveryFlow';\nimport { RegistrationFlow } from './RegistrationFlow';\nimport { AccountUnlockFlow } from './AccountUnlockFlow';\n\n// eslint-disable-next-line complexity\nexport function getFlowSpecification(\n  oktaAuth: OktaAuthIdxInterface,\n  flow: FlowIdentifier = 'default'\n): FlowSpecification {\n  let remediators, actions, withCredentials = true;\n  switch (flow) {\n    case 'register':\n    case 'signup':\n    case 'enrollProfile':\n      remediators = RegistrationFlow;\n      withCredentials = false;\n      break;\n    case 'recoverPassword':\n    case 'resetPassword':\n      remediators = PasswordRecoveryFlow;\n      actions = [\n        'currentAuthenticator-recover', \n        'currentAuthenticatorEnrollment-recover'\n      ];\n      withCredentials = false;\n      break;\n    case 'unlockAccount':\n      remediators = AccountUnlockFlow;\n      withCredentials = false;\n      actions = [\n        'unlock-account'\n      ];\n      break;\n    case 'authenticate':\n    case 'login':\n    case 'signin':\n      remediators = AuthenticationFlow;\n      break;\n    default:\n      // default case has no flow monitor\n      remediators = AuthenticationFlow;\n      break;\n  }\n  return { flow, remediators, actions, withCredentials };\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\nimport { RemediationFlow } from './RemediationFlow';\nimport {\n  Identify,\n  SelectAuthenticatorAuthenticate,\n  ChallengeAuthenticator,\n  AuthenticatorVerificationData,\n  ResetAuthenticator,\n  ReEnrollAuthenticator,\n  ReEnrollAuthenticatorWarning,\n  SelectAuthenticatorEnroll,\n  AuthenticatorEnrollmentData,\n  EnrollPoll\n} from '../remediators';\n\nexport const PasswordRecoveryFlow: RemediationFlow = {\n  'identify': Identify,\n  'identify-recovery': Identify,\n  'select-authenticator-authenticate': SelectAuthenticatorAuthenticate,\n  'select-authenticator-enroll': SelectAuthenticatorEnroll,\n  'challenge-authenticator': ChallengeAuthenticator,\n  'authenticator-verification-data': AuthenticatorVerificationData,\n  'authenticator-enrollment-data': AuthenticatorEnrollmentData,\n  'reset-authenticator': ResetAuthenticator,\n  'reenroll-authenticator': ReEnrollAuthenticator,\n  'reenroll-authenticator-warning': ReEnrollAuthenticatorWarning,\n  'enroll-poll': EnrollPoll,\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\nimport { RemediationFlow } from './RemediationFlow';\nimport { \n  SelectEnrollProfile,\n  EnrollPoll,\n  SelectEnrollmentChannel,\n  EnrollmentChannelData,\n  EnrollProfile,\n  SelectAuthenticatorEnroll,\n  EnrollAuthenticator,\n  AuthenticatorEnrollmentData,\n  Skip,\n} from '../remediators';\n\nexport const RegistrationFlow: RemediationFlow = {\n  'select-enroll-profile': SelectEnrollProfile,\n  'enroll-profile': EnrollProfile,\n  'authenticator-enrollment-data': AuthenticatorEnrollmentData,\n  'select-authenticator-enroll': SelectAuthenticatorEnroll,\n  'enroll-poll': EnrollPoll,\n  'select-enrollment-channel': SelectEnrollmentChannel,\n  'enrollment-channel-data': EnrollmentChannelData,\n  'enroll-authenticator': EnrollAuthenticator,\n  'skip': Skip,\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\nexport * from './AuthenticationFlow';\nexport * from './FlowSpecification';\nexport * from './PasswordRecoveryFlow';\nexport * from './RegistrationFlow';\nexport * from './AccountUnlockFlow';\nexport * from './RemediationFlow';\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\nimport { AuthSdkError, OAuthError } from '../errors';\nimport { IdxTransactionMeta } from './types/meta';\nimport { OktaAuthIdxInterface } from './types';\n\nexport async function handleInteractionCodeRedirect(\n  authClient: OktaAuthIdxInterface, \n  url: string\n): Promise<void> {\n  const meta = authClient.transactionManager.load() as IdxTransactionMeta;\n  if (!meta) {\n    throw new AuthSdkError('No transaction data was found in storage');\n  }\n\n  const { \n    codeVerifier,\n    state: savedState \n  } = meta;\n  const { \n    searchParams\n  // URL API has been added to the polyfill\n  // eslint-disable-next-line compat/compat\n  } = new URL(url); \n  const state = searchParams.get('state');\n  const interactionCode = searchParams.get('interaction_code');\n\n  // Error handling\n  const error = searchParams.get('error');\n  if (error) {\n    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n    throw new OAuthError(error, searchParams.get('error_description')!);\n  }\n  if (state !== savedState) {\n    throw new AuthSdkError('State in redirect uri does not match with transaction state');\n  }\n  if (!interactionCode) {\n    throw new AuthSdkError('Unable to parse interaction_code from the url');\n  }\n  \n  // Save tokens to storage\n  const { tokens } = await authClient.token.exchangeCodeForTokens({ interactionCode, codeVerifier });\n  authClient.tokenManager.setTokens(tokens);\n}","import { OktaAuthIdxInterface } from '../types';    // auth-js/types\nimport { IdxResponse, IdxToPersist, RawIdxResponse } from '../types/idx-js';      // idx/types\nimport { IDX_API_VERSION } from '../../constants';\nimport v1 from './v1/parsers';\n\n\nexport const parsersForVersion = function parsersForVersion( version ) {\n  switch (version) {\n    case '1.0.0':\n      return v1;\n    case undefined:\n    case null:\n      throw new Error('Api version is required');\n    default:\n      throw new Error(`Unknown api version: ${version}.  Use an exact semver version.`);\n  }\n};\n\nexport function validateVersionConfig(version) {\n  if ( !version ) {\n    throw new Error('version is required');\n  }\n\n  const cleanVersion = (version ?? '').replace(/[^0-9a-zA-Z._-]/, '');\n  if ( cleanVersion !== version || !version ) {\n    throw new Error('invalid version supplied - version is required and uses semver syntax');\n  }\n\n  parsersForVersion(version); // will throw for invalid version\n}\n\nexport function makeIdxState ( \n  authClient: OktaAuthIdxInterface,\n  rawIdxResponse: RawIdxResponse,\n  toPersist: IdxToPersist,\n  requestDidSucceed: boolean,\n): IdxResponse {\n  const version = rawIdxResponse?.version ?? IDX_API_VERSION;\n  validateVersionConfig(version);\n  \n  const { makeIdxState } = parsersForVersion(version);\n  return makeIdxState(authClient, rawIdxResponse, toPersist, requestDidSucceed);\n}\n","/*!\n * Copyright (c) 2021-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// eslint-disable-next-line @typescript-eslint/ban-ts-comment\n// @ts-nocheck\nconst isFieldMutable = function isFieldMutable(field) {\n  // mutable defaults to true, annoyingly\n  return ( field.mutable !== false );\n};\n\nconst divideSingleActionParamsByMutability = function divideSingleActionParamsByMutability( action ) {\n  const defaultParamsForAction = {}; // mutable and present\n  const neededParamsForAction = []; // mutable values\n  const immutableParamsForAction = {}; // immutable\n  // TODO: remove assumption that form names are unique, neededParams being an array is a temp fix\n  // not all actions have value (e.g. redirect)\n  // making sure they are not empty and instead hold the remediation object\n  if (!action.value) {\n    neededParamsForAction.push(action);\n    return { defaultParamsForAction, neededParamsForAction, immutableParamsForAction };\n  }\n\n  for ( let field of action.value ) {\n\n    if ( isFieldMutable( field ) ) {\n\n      neededParamsForAction.push(field);\n\n      if ( field.value ?? false ) {\n        defaultParamsForAction[field.name] = field.value;\n      }\n\n    } else {\n      immutableParamsForAction[field.name] = field.value ?? '';\n    }\n  }\n  return { defaultParamsForAction, neededParamsForAction, immutableParamsForAction };\n};\n\nexport const divideActionParamsByMutability = function divideActionParamsByMutability( actionList ) {\n  // TODO: when removing form name is unique assumption, this may all be redundant\n  actionList = Array.isArray(actionList) ? actionList : [ actionList ];\n  const neededParams = [];\n  const defaultParams = {};\n  const immutableParams = {};\n\n  for ( let action of actionList ) {\n    const { \n      defaultParamsForAction, \n      neededParamsForAction, \n      immutableParamsForAction \n    } = divideSingleActionParamsByMutability(action);\n    neededParams.push(neededParamsForAction);\n    defaultParams[action.name] = defaultParamsForAction;\n    immutableParams[action.name] = immutableParamsForAction;\n  }\n\n  return { defaultParams, neededParams, immutableParams };\n};\n\n","/*!\n * Copyright (c) 2021-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/* eslint-disable max-len, complexity */\nimport { httpRequest } from '../../../http';\nimport { OktaAuthIdxInterface } from '../../types';    // auth-js/types\nimport { IdxActionFunction, IdxActionParams, IdxResponse, IdxToPersist } from '../../types/idx-js';\nimport { divideActionParamsByMutability } from './actionParser';\nimport AuthApiError from '../../../errors/AuthApiError';\n\nconst generateDirectFetch = function generateDirectFetch(authClient: OktaAuthIdxInterface, { \n  actionDefinition, \n  defaultParamsForAction = {}, \n  immutableParamsForAction = {}, \n  toPersist = {} as IdxToPersist\n}): IdxActionFunction {\n  const target = actionDefinition.href;\n  return async function(params: IdxActionParams = {}): Promise<IdxResponse> {\n    const headers = {\n      'Content-Type': 'application/json',\n      'Accept': actionDefinition.accepts || 'application/ion+json',\n    };\n    const body = JSON.stringify({\n      ...defaultParamsForAction,\n      ...params,\n      ...immutableParamsForAction\n    });\n\n    try {\n      const response = await httpRequest(authClient, {\n        url: target,\n        method: actionDefinition.method,\n        headers,\n        args: body,\n        withCredentials: toPersist?.withCredentials ?? true\n      });\n\n      return authClient.idx.makeIdxResponse({ ...response }, toPersist, true);\n    }\n    catch (err) {\n      if (!(err instanceof AuthApiError) || !err?.xhr) {\n        throw err;\n      }\n\n      const response = err.xhr;\n      const payload = response.responseJSON || JSON.parse(response.responseText);\n      const wwwAuthHeader = response.headers['WWW-Authenticate'] || response.headers['www-authenticate'];\n\n      const idxResponse = authClient.idx.makeIdxResponse({ ...payload }, toPersist, false);\n      if (response.status === 401 && wwwAuthHeader === 'Oktadevicejwt realm=\"Okta Device\"') {\n        // Okta server responds 401 status code with WWW-Authenticate header and new remediation\n        // so that the iOS/MacOS credential SSO extension (Okta Verify) can intercept\n        // the response reaches here when Okta Verify is not installed\n        // set `stepUp` to true if flow should be continued without showing any errors\n        idxResponse.stepUp = true;\n      }\n\n      return idxResponse;\n    }\n  };\n};\n\n// TODO: Resolve in M2: Either build the final polling solution or remove this code\n// const generatePollingFetch = function generatePollingFetch( { actionDefinition, defaultParamsForAction = {}, immutableParamsForAction = {} } ) {\n//   // TODO: Discussions ongoing about when/how to terminate polling: OKTA-246581\n//   const target = actionDefinition.href;\n//   return async function(params) {\n//     return fetch(target, {\n//       method: actionDefinition.method,\n//       headers: {\n//         'content-type': actionDefinition.accepts,\n//       },\n//       body: JSON.stringify({ ...defaultParamsForAction, ...params, ...immutableParamsForAction })\n//     })\n//       .then( response => response.ok ? response.json() : response.json().then( err => Promise.reject(err)) )\n//       .then( idxResponse => makeIdxState(authClient, idxResponse) );\n//   };\n// };\n\nconst generateIdxAction = function generateIdxAction( authClient: OktaAuthIdxInterface, actionDefinition, toPersist ): IdxActionFunction {\n  // TODO: leaving this here to see where the polling is EXPECTED to drop into the code, but removing any accidental trigger of incomplete code\n  // const generator =  actionDefinition.refresh ? generatePollingFetch : generateDirectFetch;\n  const generator = generateDirectFetch;\n  const { defaultParams, neededParams, immutableParams } = divideActionParamsByMutability( actionDefinition );\n\n  const action = generator(authClient, {\n    actionDefinition,\n    defaultParamsForAction: defaultParams[actionDefinition.name],\n    immutableParamsForAction: immutableParams[actionDefinition.name],\n    toPersist\n  });\n  action.neededParams = neededParams;\n  return action;\n};\n\nexport default generateIdxAction;\n","/*!\n * Copyright (c) 2021-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/* eslint-disable max-len */\n\nimport { OktaAuthIdxInterface, IdxResponse, IdxRemediation, IdxContext } from '../../types';    // auth-js/types\nimport { IdxActions } from '../../types/idx-js';\nimport { generateRemediationFunctions } from './remediationParser';\nimport generateIdxAction from './generateIdxAction';\nimport { jsonpath } from '../../../util/jsonpath';\nimport { AuthSdkError } from '../../../errors';\n\nconst SKIP_FIELDS = {\n  'remediation': true, // remediations are put into proceed/neededToProceed\n  'context': true, // the API response of 'context' isn't externally useful.  We ignore it and put all non-action (contextual) info into idxState.context\n};\n\nexport const parseNonRemediations = function parseNonRemediations( authClient: OktaAuthIdxInterface, idxResponse: IdxResponse, toPersist = {} ) {\n  const actions = {};\n  const context = {} as IdxContext;\n\n  Object.keys(idxResponse)\n    .filter( field => !SKIP_FIELDS[field])\n    .forEach( field => {\n      const fieldIsObject = typeof idxResponse[field] === 'object' && !!idxResponse[field];\n\n      if ( !fieldIsObject ) {\n        // simple fields are contextual info\n        context[field] = idxResponse[field];\n        return;\n      }\n\n      if ( idxResponse[field].rel ) {\n        // top level actions\n        actions[idxResponse[field].name] = generateIdxAction(authClient, idxResponse[field], toPersist);\n        return;\n      }\n\n      const { value: fieldValue, type, ...info} = idxResponse[field];\n      context[field] = { type, ...info}; // add the non-action parts as context\n\n      if ( type !== 'object' ) {\n        // only object values hold actions\n        context[field].value = fieldValue;\n        return;\n      }\n\n      // We are an object field containing an object value\n      context[field].value = {};\n      Object.entries<IdxRemediation>(fieldValue)\n        .forEach( ([subField, value]) => {\n          if (value.rel) { // is [field].value[subField] an action?\n            // add any \"action\" value subfields to actions\n            // eslint-disable-next-line @typescript-eslint/ban-ts-comment\n            // @ts-ignore\n            actions[`${field}-${subField.name || subField}`] = generateIdxAction(authClient, value, toPersist);\n          } else {\n            // add non-action value subfields to context\n            context[field].value[subField] = value;\n          }\n        });\n    });\n\n  return { context, actions };\n};\n\nconst expandRelatesTo = (idxResponse, value) => {\n  Object.keys(value).forEach(k => {\n    if (k === 'relatesTo') {\n      const query = Array.isArray(value[k]) ? value[k][0] : value[k];\n      if (typeof query === 'string') {\n        const result = jsonpath({ path: query, json: idxResponse })[0];\n        if (result) {\n          value[k] = result;\n          return;\n        } else {\n          throw new AuthSdkError(`Cannot resolve relatesTo: ${query}`);\n        }\n      }\n    }\n    if (Array.isArray(value[k])) {\n      value[k].forEach(innerValue => expandRelatesTo(idxResponse, innerValue));\n    }\n  });\n};\n\nconst convertRemediationAction = (authClient: OktaAuthIdxInterface, remediation, toPersist) => {\n  // Only remediation that has `rel` field (indicator for form submission) can have http action\n  if (remediation.rel) {\n    const remediationActions = generateRemediationFunctions( authClient, [remediation], toPersist );\n    const actionFn = remediationActions[remediation.name];\n    return {\n      ...remediation,\n      action: actionFn,\n    };\n  }\n\n  return remediation;\n};\n\nexport const parseIdxResponse = function parseIdxResponse( authClient: OktaAuthIdxInterface, idxResponse, toPersist = {} ): {\n  remediations: IdxRemediation[];\n  context: IdxContext;\n  actions: IdxActions;\n} {\n  const remediationData = idxResponse.remediation?.value || [];\n\n  remediationData.forEach(\n    remediation => {\n      // TODO: remove once IDX is fixed - OKTA-659181\n      if (remediation.name === 'launch-authenticator' &&\n        remediation?.relatesTo?.[0] === 'authenticatorChallenge' &&\n        !idxResponse?.authenticatorChallenge\n      ) {\n        delete remediation.relatesTo;\n        return;\n      }\n\n      return expandRelatesTo(idxResponse, remediation);\n    }\n  );\n\n  const remediations = remediationData.map(remediation => convertRemediationAction( authClient, remediation, toPersist ));\n\n  const { context, actions } = parseNonRemediations( authClient, idxResponse, toPersist );\n\n  return {\n    remediations,\n    context,\n    actions,\n  };\n};\n","/*!\n * Copyright (c) 2021-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\nimport { IdxResponse, IdxToPersist, IdxActionParams } from '../../types/idx-js';\nimport { OktaAuthIdxInterface, RawIdxResponse } from '../../types';    // auth-js/types\nimport { parseIdxResponse } from './idxResponseParser';\n\nexport function makeIdxState( \n  authClient: OktaAuthIdxInterface,\n  idxResponse: RawIdxResponse,\n  toPersist: IdxToPersist,\n  requestDidSucceed: boolean\n): IdxResponse {\n  const rawIdxResponse =  idxResponse;\n  const { remediations, context, actions } = parseIdxResponse( authClient, idxResponse, toPersist );\n  const neededToProceed = [...remediations];\n\n  const proceed: IdxResponse['proceed'] = async function( remediationChoice, paramsFromUser = {} ) {\n    /*\n    remediationChoice is the name attribute on each form\n    name should remain unique for items inside the remediation that are considered forms(identify, select-factor)\n    name can be duplicate for items like redirect where its not considered a form(redirect)\n    when names are not unique its a redirect to a href, so widget wont POST to idx-js layer.\n    */\n    const remediationChoiceObject = remediations.find((remediation) => remediation.name === remediationChoice);\n    if ( !remediationChoiceObject ) {\n      return Promise.reject(`Unknown remediation choice: [${remediationChoice}]`);\n    }\n\n    const actionFn = remediationChoiceObject.action;\n    if (typeof actionFn !== 'function') {\n      return Promise.reject(`Current remediation cannot make form submit action: [${remediationChoice}]`);\n    }\n\n    return remediationChoiceObject.action!(paramsFromUser as IdxActionParams);\n  };\n\n  const findCode = item => item.name === 'interaction_code';\n  const interactionCode = rawIdxResponse.successWithInteractionCode?.value?.find( findCode )?.value as string;\n\n  return {\n    proceed,\n    neededToProceed,\n    actions,\n    context,\n    rawIdxState: rawIdxResponse,\n    interactionCode,\n    toPersist,\n    requestDidSucceed,\n  };\n}\n","/*!\n * Copyright (c) 2021-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\nimport { makeIdxState } from './makeIdxState';\n\nexport default {\n  makeIdxState,\n};\n","/*!\n * Copyright (c) 2021-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\nimport { OktaAuthIdxInterface, IdxRemediation } from '../../types';    // auth-js/types\nimport generateIdxAction from './generateIdxAction';\n\nexport const generateRemediationFunctions = function generateRemediationFunctions(\n  authClient: OktaAuthIdxInterface,\n  remediationValue: IdxRemediation[],\n  toPersist = {}\n) {\n  return remediationValue.reduce((obj, remediation) => ({\n    ...obj,\n    [remediation.name]: generateIdxAction(authClient, remediation, toPersist)\n  }), {});\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\nexport { authenticate } from './authenticate';\nexport { cancel } from './cancel';\nexport { \n  handleEmailVerifyCallback, \n  isEmailVerifyCallback, \n  parseEmailVerifyCallback, \n  isEmailVerifyCallbackError, \n} from './emailVerify';\nexport { interact } from './interact';\nexport { introspect } from './introspect';\nexport { poll } from './poll';\nexport { proceed, canProceed } from './proceed';\nexport { register } from './register';\nexport { recoverPassword } from './recoverPassword';\nexport { handleInteractionCodeRedirect } from './handleInteractionCodeRedirect';\nexport { startTransaction } from './startTransaction';\nexport { unlockAccount } from './unlockAccount';\nexport * from './transactionMeta';\nexport * from './factory';\nexport * from './mixin';\nexport * from './options';\nexport * from './storage';\nexport * from './types';\nexport * from './IdxTransactionManager';\n","/* eslint-disable @typescript-eslint/no-non-null-assertion */\n/*!\n * Copyright (c) 2021, 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 complexity:[0,8] */\nimport { OktaAuthIdxInterface, IdxTransactionMeta, InteractOptions, InteractResponse } from './types';\nimport { getSavedTransactionMeta, saveTransactionMeta, createTransactionMeta } from './transactionMeta';\nimport { getOAuthBaseUrl } from '../oidc';\nimport { removeNils } from '../util';\nimport { httpRequest } from '../http';\n\n\n/* eslint-disable camelcase */\nexport interface InteractParams {\n  client_id: string;\n  scope: string;\n  redirect_uri: string;\n  code_challenge: string;\n  code_challenge_method: string;\n  state: string;\n  activation_token?: string;\n  recovery_token?: string;\n  client_secret?: string;\n  max_age?: string | number;\n  acr_values?: string;\n  nonce?: string;\n}\n/* eslint-enable camelcase */\n\nfunction getResponse(meta: IdxTransactionMeta): InteractResponse {\n  return {\n    meta,\n    interactionHandle: meta.interactionHandle!,\n    state: meta.state\n  };\n}\n\n// Begin or resume a transaction. Returns an interaction handle\nexport async function interact (\n  authClient: OktaAuthIdxInterface, \n  options: InteractOptions = {}\n): Promise<InteractResponse> {\n  options = removeNils(options);\n\n  let meta = getSavedTransactionMeta(authClient, options);\n  // If meta exists, it has been validated against all options\n\n  if (meta?.interactionHandle) {\n    return getResponse(meta); // Saved transaction, return meta\n  }\n\n  // Create new meta, respecting previous meta if it has been set and is not overridden\n  meta = await createTransactionMeta(authClient, { ...meta, ...options });\n  const baseUrl = getOAuthBaseUrl(authClient);\n  let {\n    clientId,\n    redirectUri,\n    state,\n    scopes,\n    withCredentials,\n    codeChallenge,\n    codeChallengeMethod,\n    activationToken,\n    recoveryToken,\n    maxAge,\n    acrValues,\n    nonce\n  } = meta as IdxTransactionMeta;\n  const clientSecret = options.clientSecret || authClient.options.clientSecret;\n  withCredentials = withCredentials ?? true;\n\n  /* eslint-disable camelcase */\n  const url = `${baseUrl}/v1/interact`;\n  const params = {\n    client_id: clientId,\n    scope: scopes!.join(' '),\n    redirect_uri: redirectUri,\n    code_challenge: codeChallenge,\n    code_challenge_method: codeChallengeMethod,\n    state,\n    ...(activationToken && { activation_token: activationToken }),\n    ...(recoveryToken && { recovery_token: recoveryToken }),\n    // X-Device-Token header need to pair with `client_secret`\n    // eslint-disable-next-line max-len\n    // https://oktawiki.atlassian.net/wiki/spaces/eng/pages/2445902453/Support+Device+Binding+in+interact#Scenario-1%3A-Non-User-Agent-with-Confidential-Client-(top-priority)\n    ...(clientSecret && { client_secret: clientSecret }),\n    ...(maxAge && { max_age: maxAge }),\n    ...(acrValues && { acr_values: acrValues }),\n    ...(nonce && { nonce }),\n  } as InteractParams;\n  /* eslint-enable camelcase */\n\n  const headers = {\n    'Content-Type': 'application/x-www-form-urlencoded',\n  };\n\n  const resp = await httpRequest(authClient, {\n    method: 'POST',\n    url,\n    headers,\n    withCredentials,\n    args: params\n  });\n  const interactionHandle = resp.interaction_handle;\n\n  const newMeta = {\n    ...meta,\n    interactionHandle,\n    \n    // Options which can be passed into interact() should be saved in the meta\n    withCredentials,\n    state,\n    scopes,\n    recoveryToken,\n    activationToken\n  };\n  // Save transaction meta so it can be resumed\n  saveTransactionMeta(authClient, newMeta);\n\n  return getResponse(newMeta);\n}\n","/* eslint-disable complexity */\n/*!\n * Copyright (c) 2021, 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\nimport { makeIdxState, validateVersionConfig } from './idxState';\nimport { IntrospectOptions, OktaAuthIdxInterface } from './types';\nimport { IdxResponse, isRawIdxResponse } from './types/idx-js';\nimport { getOAuthDomain } from '../oidc';\nimport { IDX_API_VERSION } from '../constants';\nimport { httpRequest } from '../http';\nimport { isAuthApiError } from '../errors';\n\nexport async function introspect (\n  authClient: OktaAuthIdxInterface, \n  options: IntrospectOptions = {}\n): Promise<IdxResponse> {\n  let rawIdxResponse;\n  let requestDidSucceed;\n\n  // try load from storage first\n  const savedIdxResponse = authClient.transactionManager.loadIdxResponse(options);\n  if (savedIdxResponse) {\n    rawIdxResponse = savedIdxResponse.rawIdxResponse;\n    requestDidSucceed = savedIdxResponse.requestDidSucceed;\n  }\n\n  // call idx.introspect if no existing idx response available in storage\n  if (!rawIdxResponse) {\n    const version = options.version || IDX_API_VERSION;\n    const domain = getOAuthDomain(authClient);\n    const { interactionHandle, stateHandle } = options;\n    const withCredentials = options.withCredentials ?? true;\n    try {\n      requestDidSucceed = true;\n      validateVersionConfig(version);\n      const url = `${domain}/idp/idx/introspect`;\n      const body = stateHandle ? { stateToken: stateHandle } : { interactionHandle };\n      const headers = {\n        'Content-Type': `application/ion+json; okta-version=${version}`, // Server wants this version info\n        Accept: `application/ion+json; okta-version=${version}`,\n      };\n      rawIdxResponse = await httpRequest(authClient, {\n        method: 'POST',\n        url,\n        headers,\n        withCredentials,\n        args: body\n      });\n    } catch (err) {\n      if (isAuthApiError(err) && err.xhr && isRawIdxResponse(err.xhr.responseJSON)) {\n        rawIdxResponse = err.xhr.responseJSON;\n        requestDidSucceed = false;\n      } else {\n        throw err;\n      }\n    }\n  }\n\n  const { withCredentials } = options;\n  return makeIdxState(authClient, rawIdxResponse, { withCredentials }, requestDidSucceed);\n}\n","import { FingerprintAPI, OktaAuthConstructor } from '../base/types';\nimport { OktaAuthOAuthInterface } from '../oidc/types';\nimport {\n  IdxAPI, \n  IdxTransactionManagerInterface, \n  OktaAuthIdxInterface, \n  OktaAuthIdxConstructor, \n  OktaAuthIdxOptions, \n  WebauthnAPI\n} from './types';\nimport { IdxTransactionMeta } from './types/meta';\nimport { IdxStorageManagerInterface } from './types/storage';\nimport { createIdxAPI } from './factory/api';\nimport fingerprint from '../browser/fingerprint';\nimport * as webauthn from './webauthn';\n\nexport function mixinIdx\n<\n  M extends IdxTransactionMeta = IdxTransactionMeta,\n  S extends IdxStorageManagerInterface<M> = IdxStorageManagerInterface<M>,\n  O extends OktaAuthIdxOptions = OktaAuthIdxOptions,\n  TM extends IdxTransactionManagerInterface = IdxTransactionManagerInterface,\n  TBase extends OktaAuthConstructor<OktaAuthOAuthInterface<M, S, O, TM>>\n    = OktaAuthConstructor<OktaAuthOAuthInterface<M, S, O, TM>>\n>\n(Base: TBase): TBase & OktaAuthIdxConstructor<OktaAuthIdxInterface<M, S, O, TM>>\n{\n  return class OktaAuthIdx extends Base implements OktaAuthIdxInterface<M, S, O, TM>\n  {\n    idx: IdxAPI;\n    fingerprint: FingerprintAPI;\n    static webauthn: WebauthnAPI = webauthn;\n    \n    constructor(...args: any[]) {\n      super(...args);\n      this.idx = createIdxAPI(this);\n      this.fingerprint = fingerprint.bind(null, this);\n    }\n  };\n}\n","import { FingerprintAPI, OktaAuthConstructor } from '../base/types';\nimport { MinimalOktaOAuthInterface } from '../oidc/types';\nimport {\n  IdxTransactionManagerInterface,\n  OktaAuthIdxConstructor,\n  OktaAuthIdxOptions,\n  MinimalIdxAPI,\n  WebauthnAPI,\n  MinimalOktaAuthIdxInterface\n} from './types';\nimport { IdxTransactionMeta } from './types/meta';\nimport { IdxStorageManagerInterface } from './types/storage';\nimport { createMinimalIdxAPI } from '../idx/factory/minimalApi';\nimport fingerprint from '../browser/fingerprint';\nimport * as webauthn from './webauthn';\n\nexport function mixinMinimalIdx\n<\n  M extends IdxTransactionMeta = IdxTransactionMeta,\n  S extends IdxStorageManagerInterface<M> = IdxStorageManagerInterface<M>,\n  O extends OktaAuthIdxOptions = OktaAuthIdxOptions,\n  TM extends IdxTransactionManagerInterface = IdxTransactionManagerInterface,\n  TBase extends OktaAuthConstructor<MinimalOktaOAuthInterface<M, S, O, TM>>\n    = OktaAuthConstructor<MinimalOktaOAuthInterface<M, S, O, TM>>\n>\n(\n  Base: TBase\n): TBase & OktaAuthIdxConstructor<MinimalOktaAuthIdxInterface<M, S, O, TM>>\n{\n  return class OktaAuthIdx extends Base implements MinimalOktaAuthIdxInterface<M, S, O, TM>\n  {\n    idx: MinimalIdxAPI;\n    fingerprint: FingerprintAPI;\n    static webauthn: WebauthnAPI = webauthn;\n    \n    constructor(...args: any[]) {\n      super(...args);\n      this.idx = createMinimalIdxAPI(this);\n      this.fingerprint = fingerprint.bind(null, this);\n    }\n  };\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\nimport { createCoreOptionsConstructor } from '../core/options';\nimport { FlowIdentifier } from './types/FlowIdentifier';\nimport { OktaAuthIdxOptions } from './types/options';\n\n\nexport function createIdxOptionsConstructor() {\n  const CoreOptionsConstructor = createCoreOptionsConstructor();\n  return class IdxOptionsConstructor\n    extends CoreOptionsConstructor \n    implements Required<OktaAuthIdxOptions>\n  {\n    flow: FlowIdentifier;\n    activationToken: string;\n    recoveryToken: string;\n  \n    // BETA WARNING: configs in this section are subject to change without a breaking change notice\n    idx: {\n      useGenericRemediator?: boolean;\n      exchangeCodeForTokens?: boolean;\n    };\n  \n    constructor(options: any) {\n      super(options);\n  \n      this.flow = options.flow;\n      this.activationToken = options.activationToken;\n      this.recoveryToken = options.recoveryToken;\n      this.idx = options.idx;\n    }\n  };\n  \n}\n","/*!\n * Copyright (c) 2021-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\nimport { proceed } from './proceed';\n\nimport { \n  IdxPollOptions,\n  IdxTransaction,\n  OktaAuthIdxInterface,\n} from './types';\nimport { getSavedTransactionMeta } from './transactionMeta';\nimport { warn } from '../util';\n\nexport async function poll(authClient: OktaAuthIdxInterface, options: IdxPollOptions = {}): Promise<IdxTransaction> {\n  let transaction = await proceed(authClient, {\n    startPolling: true\n  });\n\n  const meta = getSavedTransactionMeta(authClient);\n  let availablePollingRemeditaions = meta?.remediations?.find(remediation => remediation.includes('poll'));\n  if (!availablePollingRemeditaions?.length) {\n    warn('No polling remediations available at the current IDX flow stage');\n  }\n\n  if (Number.isInteger(options.refresh)) {\n    return new Promise(function (resolve, reject) {\n      setTimeout(async function () {\n        try {\n          const refresh = transaction.nextStep?.poll?.refresh;\n          if (refresh) {\n            resolve(poll(authClient, {\n              refresh\n            }));\n          } else {\n            resolve(transaction);\n          }\n        } catch (err) {\n          reject(err);\n        }\n      }, options.refresh);\n    });\n  }\n\n  return transaction;\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\nimport { \n  OktaAuthIdxInterface,\n  IdxTransaction,\n  ProceedOptions,\n} from './types';\nimport { run } from './run';\nimport { getSavedTransactionMeta } from './transactionMeta';\nimport { AuthSdkError } from '../errors';\n\nexport function canProceed(authClient: OktaAuthIdxInterface, options: ProceedOptions = {}): boolean {\n  const meta = getSavedTransactionMeta(authClient, options);\n  return !!(meta || options.stateHandle);\n}\n\nexport async function proceed(\n  authClient: OktaAuthIdxInterface,\n  options: ProceedOptions = {}\n): Promise<IdxTransaction> {\n\n  if (!canProceed(authClient, options)) {\n    throw new AuthSdkError('Unable to proceed: saved transaction could not be loaded');\n  }\n\n  let { flow, state } = options;\n  if (!flow) {\n    const meta = getSavedTransactionMeta(authClient, { state });\n    flow = meta?.flow;\n  }\n\n  return run(authClient, { \n    ...options, \n    flow\n  });\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\nimport { run } from './run';\nimport { getFlowSpecification } from './flow';\nimport { \n  OktaAuthIdxInterface, \n  PasswordRecoveryOptions, \n  IdxTransaction,\n} from './types';\n\nexport async function recoverPassword(\n  authClient: OktaAuthIdxInterface, options: PasswordRecoveryOptions = {}\n): Promise<IdxTransaction> {\n  const flowSpec = getFlowSpecification(authClient, 'recoverPassword');\n  return run(\n    authClient, \n    { \n      ...options,\n      ...flowSpec,\n    }\n  );\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\nimport { run } from './run';\nimport { hasSavedInteractionHandle } from './transactionMeta';\nimport { startTransaction } from './startTransaction';\nimport { AuthSdkError } from '../errors';\nimport { \n  RegistrationOptions, \n  IdxTransaction, \n  OktaAuthIdxInterface, \n  IdxFeature,\n} from './types';\n\nexport async function register(\n  authClient: OktaAuthIdxInterface, options: RegistrationOptions = {}\n): Promise<IdxTransaction> {\n\n  // Only check at the beginning of the transaction\n  if (!hasSavedInteractionHandle(authClient)) {\n    const { enabledFeatures } = await startTransaction(authClient, {\n      ...options,\n      flow: 'register',\n      autoRemediate: false\n    });\n    if (!options.activationToken && enabledFeatures && !enabledFeatures.includes(IdxFeature.REGISTRATION)) {\n      throw new AuthSdkError('Registration is not supported based on your current org configuration.');\n    }\n  }\n\n  return run(authClient, {\n    ...options,\n    flow: 'register'\n  });\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 max-statements, max-depth, complexity */\nimport { AuthSdkError } from '../errors';\nimport { RemediationValues } from './remediators';\nimport { OktaAuthIdxInterface, RemediateOptions, RemediationResponse } from './types';\nimport { \n  IdxResponse,\n  IdxActionParams, \n} from './types/idx-js';\nimport {\n  isTerminalResponse,\n  filterValuesForRemediation,\n  getRemediator,\n  getNextStep,\n  handleFailedResponse\n} from './util';\n\nexport interface RemediateActionWithOptionalParams {\n  name: string;\n  params?: IdxActionParams;\n}\n\nexport type RemediateAction = string | RemediateActionWithOptionalParams;\n\n\nfunction getActionFromValues(values: RemediationValues, idxResponse: IdxResponse): string | undefined {\n  // Currently support resend actions only\n  return Object.keys(idxResponse.actions).find(action => !!values.resend && action.includes('-resend'));\n}\n\nfunction removeActionFromValues(values: RemediationValues): RemediationValues {\n  // Currently support resend actions only\n  return {\n    ...values,\n    resend: undefined\n  };\n}\n\nfunction removeActionFromOptions(options: RemediateOptions, actionName: string): RemediateOptions {\n  let actions = options.actions || [];\n  actions = actions.filter(entry => {\n    if (typeof entry === 'string') {\n      return entry !== actionName;\n    }\n    return entry.name !== actionName;\n  });\n\n  return { ...options, actions };\n}\n\n// This function is called recursively until it reaches success or cannot be remediated\nexport async function remediate(\n  authClient: OktaAuthIdxInterface,\n  idxResponse: IdxResponse,\n  values: RemediationValues,\n  options: RemediateOptions\n): Promise<RemediationResponse> {\n  let { neededToProceed, interactionCode } = idxResponse;\n  const { flow } = options;\n\n  // If the response contains an interaction code, there is no need to remediate\n  if (interactionCode) {\n    return { idxResponse };\n  }\n\n  const remediator = getRemediator(idxResponse, values, options);\n\n  // Try actions in idxResponse first\n  const actionFromValues = getActionFromValues(values, idxResponse);\n  const actionFromOptions = options.actions || [];\n  const actions = [\n    ...actionFromOptions,\n    ...(actionFromValues && [actionFromValues] || []),\n  ];\n  if (actions) {\n    for (let action of actions) {\n      // Action can either be specified as a string, or as an object with name and optional params\n      let params: IdxActionParams = {};\n      if (typeof action !== 'string') {\n        params = action.params || {};\n        action = action.name;\n      }\n      let valuesWithoutExecutedAction = removeActionFromValues(values);\n      let optionsWithoutExecutedAction = removeActionFromOptions(options, action);\n\n      if (typeof idxResponse.actions[action] === 'function') {\n        idxResponse = await idxResponse.actions[action](params);\n        if (idxResponse.requestDidSucceed === false) {\n          return handleFailedResponse(authClient, idxResponse, options);\n        }\n        if (action === 'cancel') {\n          return { idxResponse, canceled: true };\n        }\n        return remediate(\n          authClient, \n          idxResponse, \n          valuesWithoutExecutedAction, \n          optionsWithoutExecutedAction\n        ); // recursive call\n      }\n\n      // search for action in remediation list\n      const remediationAction = neededToProceed.find(({ name }) => name === action);\n      if (remediationAction) {\n        idxResponse = await idxResponse.proceed(action, params);\n        if (idxResponse.requestDidSucceed === false) {\n          return handleFailedResponse(authClient, idxResponse, options);\n        }\n        return remediate(authClient, idxResponse, values, optionsWithoutExecutedAction); // recursive call\n      }\n    }\n  }\n\n  // Do not attempt to remediate if response is in terminal state\n  const terminal = isTerminalResponse(idxResponse);\n  if (terminal) {\n    return { idxResponse, terminal };\n  }\n\n  if (!remediator) {\n    // With options.step, remediator is not required\n    if (options.step) {\n      values = filterValuesForRemediation(idxResponse, options.step, values); // include only requested values\n      idxResponse = await idxResponse.proceed(options.step, values);\n      if (idxResponse.requestDidSucceed === false) {\n        return handleFailedResponse(authClient, idxResponse, options);\n      }\n      return { idxResponse };\n    }\n\n    // With default flow, remediator is not required\n    if (flow === 'default') {\n      return { idxResponse };\n    }\n    throw new AuthSdkError(`\n      No remediation can match current flow, check policy settings in your org.\n      Remediations: [${neededToProceed.reduce((acc, curr) => acc ? acc + ' ,' + curr.name : curr.name, '')}]\n    `);\n  }\n\n  // Return next step to the caller\n  if (!remediator.canRemediate()) {\n    const nextStep = getNextStep(authClient, remediator, idxResponse);\n    return {\n      idxResponse,\n      nextStep,\n    };\n  }\n\n  const name = remediator.getName();\n  const data = remediator.getData();\n\n  idxResponse = await idxResponse.proceed(name, data);\n  if (idxResponse.requestDidSucceed === false) {\n    return handleFailedResponse(authClient, idxResponse, options);\n  }\n  // We may want to trim the values bag for the next remediation\n  // Let the remediator decide what the values should be (default to current values)\n  values = remediator.getValuesAfterProceed();\n  options = { ...options, step: undefined }; // do not re-use the step\n\n  // generic remediator should not auto proceed in pending status\n  // return nextStep directly\n  if (options.useGenericRemediator && !idxResponse.interactionCode && !isTerminalResponse(idxResponse)) {\n    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n    const gr = getRemediator(idxResponse, values, options)!;\n    const nextStep = getNextStep(authClient, gr, idxResponse);\n    return {\n      idxResponse,\n      nextStep,\n    };\n  }\n  \n  return remediate(authClient, idxResponse, values, options); // recursive call\n\n}\n","/* eslint-disable @typescript-eslint/no-non-null-assertion */\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\nimport { AuthenticatorData, AuthenticatorDataValues } from './Base/AuthenticatorData';\nimport { getAuthenticatorFromRemediation } from './util';\n\nexport type AuthenticatorEnrollmentDataValues =  AuthenticatorDataValues & {\n  phoneNumber?: string;\n  resend?: boolean; // resend is not a remediator value - revise when IdxResponse structure is updated\n}\nexport class AuthenticatorEnrollmentData extends AuthenticatorData<AuthenticatorEnrollmentDataValues> {\n  static remediationName = 'authenticator-enrollment-data';\n\n  mapAuthenticator() {\n    const authenticatorData = this.getAuthenticatorData();\n    const authenticatorFromRemediation = getAuthenticatorFromRemediation(this.remediation)!;\n    return { \n      id: authenticatorFromRemediation.form!.value\n        .find(({ name }) => name === 'id')!.value,\n      methodType: authenticatorData!.methodType,\n      phoneNumber: authenticatorData!.phoneNumber,\n    };\n  }\n\n  getInputAuthenticator(remediation) {\n    return [\n      { name: 'methodType', type: 'string' }, \n      { name: 'phoneNumber', label: 'Phone Number', type: 'string' }\n    ].map(item => {\n      const value = remediation.form.value.find(val => val.name === item.name);\n      return { ...value, ...item };\n    });\n  }\n\n  protected mapAuthenticatorDataFromValues(data?) {\n    // get mapped authenticator from base class\n    data = super.mapAuthenticatorDataFromValues(data);\n    // add phoneNumber to authenticator if it exists in values\n    const { phoneNumber } = this.values;\n    if (!data && !phoneNumber) {\n      return;\n    }\n\n    return { \n      ...(data && data), \n      ...(phoneNumber && { phoneNumber }) \n    };\n  }\n\n}\n","/* eslint-disable @typescript-eslint/no-non-null-assertion */\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\nimport { AuthenticatorData, AuthenticatorDataValues } from './Base/AuthenticatorData';\n\nexport type AuthenticatorVerificationDataValues = AuthenticatorDataValues;\n\nexport class AuthenticatorVerificationData extends AuthenticatorData<AuthenticatorVerificationDataValues> {\n  static remediationName = 'authenticator-verification-data';\n\n  mapAuthenticator() {\n    return this.getAuthenticatorData();\n  }\n\n  getInputAuthenticator() {\n    const authenticator = this.getAuthenticatorFromRemediation();\n    const methodType = authenticator.form!.value.find(({ name }) => name === 'methodType');\n    // if has methodType in form, let user select the methodType\n    if (methodType && methodType.options) {\n      return { \n        name: 'methodType', \n        type: 'string', \n        required: true, \n        options: methodType.options \n      };\n    }\n    // no methodType, then return form values\n    const inputs = [...authenticator.form!.value];\n    return inputs;\n  }\n\n  getValuesAfterProceed(): AuthenticatorVerificationDataValues {\n    this.values = super.getValuesAfterProceed();\n    let trimmedValues = Object.keys(this.values).filter(valueKey => valueKey !== 'authenticator');\n    return trimmedValues.reduce((values, valueKey) => ({...values, [valueKey]: this.values[valueKey]}), {});\n  }\n}\n","/* eslint-disable @typescript-eslint/no-non-null-assertion */\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\nimport { Remediator, RemediationValues } from './Remediator';\nimport { IdxRemediationValue, IdxRemediation, IdxAuthenticator } from '../../types/idx-js';\nimport { isAuthenticator } from '../../types/api';\nimport { compareAuthenticators } from '../../authenticator/util';\n\nexport type AuthenticatorDataValues = RemediationValues & {\n  methodType?: string;\n};\n\n// Base class - DO NOT expose static remediationName\nexport class AuthenticatorData<T extends AuthenticatorDataValues = AuthenticatorDataValues> extends Remediator<T> {\n  authenticator: IdxAuthenticator;\n\n  constructor(remediation: IdxRemediation, values: T = {} as T) {\n    super(remediation, values);\n\n    // set before other data calculation\n    this.authenticator = this.getAuthenticator()!;\n\n    this.formatAuthenticatorData();\n  }\n\n  protected formatAuthenticatorData() {\n    const authenticatorData = this.getAuthenticatorData();\n    if (authenticatorData) {\n      this.values.authenticatorsData = this.values.authenticatorsData!.map(data => {\n        if (compareAuthenticators(this.authenticator, data)) {\n          return this.mapAuthenticatorDataFromValues(data);\n        }\n        return data;\n      });\n    } else {\n      const data = this.mapAuthenticatorDataFromValues();\n      if (data) {\n        this.values.authenticatorsData!.push(data);\n      }\n    }\n  }\n\n  protected getAuthenticatorData() {\n    return this.values.authenticatorsData!\n      .find((data) => compareAuthenticators(this.authenticator, data));\n  }\n\n  canRemediate() {\n    return this.values.authenticatorsData!\n      .some(data => compareAuthenticators(this.authenticator, data));\n  }\n\n  protected mapAuthenticatorDataFromValues(authenticatorData?) {\n    // add methodType to authenticatorData if it exists in values\n    let { methodType, authenticator } = this.values;\n    if (!methodType && isAuthenticator(authenticator)) {\n     methodType = authenticator?.methodType;\n    }\n    \n    const { id, enrollmentId } = this.authenticator;\n    const data = { \n      id,\n      enrollmentId,\n      ...(authenticatorData && authenticatorData),\n      ...(methodType && { methodType }) \n    };\n\n    return data.methodType ? data : null;\n  }\n\n  protected getAuthenticatorFromRemediation(): IdxRemediationValue {\n    const authenticator = this.remediation.value!\n      .find(({ name }) => name === 'authenticator') as IdxRemediationValue;\n    return authenticator;\n  }\n\n  getValuesAfterProceed(): T {\n    this.values = super.getValuesAfterProceed();\n    // remove used authenticatorData\n    const authenticatorsData = this.values.authenticatorsData!\n      .filter(data => compareAuthenticators(this.authenticator, data) !== true);\n    return { ...this.values, authenticatorsData };\n  }\n}\n","/* eslint-disable @typescript-eslint/no-non-null-assertion */\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 */\nimport { OktaAuthIdxInterface, NextStep, IdxMessage, Authenticator, Input, RemediateOptions } from '../../types';\nimport { IdxAuthenticator, IdxRemediation, IdxContext } from '../../types/idx-js';\nimport { getAllValues, getRequiredValues, titleCase, getAuthenticatorFromRemediation } from '../util';\nimport { formatAuthenticator, compareAuthenticators } from '../../authenticator/util';\n\n// A map from IDX data values (server spec) to RemediationValues (client spec)\nexport type IdxToRemediationValueMap = Record<string, string[]>;\n\nexport interface RemediationValues {\n  stateHandle?: string;\n  authenticators?: (Authenticator | string)[];\n  authenticator?: string | Authenticator;\n  authenticatorsData?: Authenticator[];\n  resend?: boolean;\n}\n\nexport interface RemediatorConstructor {\n  remediationName: string;\n  new<T extends RemediationValues>(\n    remediation: IdxRemediation, \n    values?: T, \n    options?: RemediateOptions\n  ): any;\n}\n\n// Base class - DO NOT expose static remediationName\nexport class Remediator<T extends RemediationValues = RemediationValues> {\n  static remediationName: string;\n\n  remediation: IdxRemediation;\n  values: T;\n  options: RemediateOptions;\n  map?: IdxToRemediationValueMap;\n\n  constructor(\n    remediation: IdxRemediation, \n    values: T = {} as T, \n    options: RemediateOptions = {}\n  ) {\n    // assign fields to the instance\n    this.values = { ...values };\n    this.options = { ...options };\n    this.formatAuthenticators();\n    this.remediation = remediation;\n  }\n\n  private formatAuthenticators() {\n    this.values.authenticators = (this.values.authenticators || []) as Authenticator[];\n\n    // ensure authenticators are in the correct format\n    this.values.authenticators = this.values.authenticators.map(authenticator => {\n      return formatAuthenticator(authenticator);\n    });\n\n    // add authenticator (if any) to \"authenticators\"\n    if (this.values.authenticator) {\n      const authenticator = formatAuthenticator(this.values.authenticator);\n      const hasAuthenticatorInList = this.values.authenticators.some(existing => {\n        return compareAuthenticators(authenticator, existing);\n      });\n      if (!hasAuthenticatorInList) {\n        this.values.authenticators.push(authenticator);\n      }\n    }\n\n    // save non-key meta to \"authenticatorsData\" field\n    // authenticators will be removed after selection to avoid select-authenticator loop\n    this.values.authenticatorsData = this.values.authenticators.reduce((acc, authenticator) => {\n      if (typeof authenticator === 'object' && Object.keys(authenticator).length > 1) {\n        // save authenticator meta into authenticator data\n        acc.push(authenticator);\n      }\n      return acc;\n    }, this.values.authenticatorsData || []);\n  }\n\n  getName(): string {\n    return this.remediation.name;\n  }\n\n  // Override this method to provide custom check\n  /* eslint-disable-next-line no-unused-vars, @typescript-eslint/no-unused-vars */\n  canRemediate(context?: IdxContext): boolean {\n    const required = getRequiredValues(this.remediation);\n    const needed = required!.find((key) => !this.hasData(key));\n    if (needed) {\n      return false; // missing data for a required field\n    }\n    return true; // all required fields have available data\n  }\n\n  // returns an object for the entire remediation form, or just a part\n  getData(key?: string) {\n    if (!key) {\n      let allValues = getAllValues(this.remediation);\n      let res = allValues!.reduce((data, key) => {\n        data[key] = this.getData(key); // recursive\n        return data;\n      }, {});\n      return res;\n    }\n\n    // Map value by \"map${Property}\" function in each subClass\n    if (typeof this[`map${titleCase(key)}`] === 'function') {\n      const val = this[`map${titleCase(key)}`](\n        this.remediation.value!.find(({name}) => name === key)\n      );\n      if (val) {\n        return val;\n      }\n    }\n\n    // If a map is defined for this key, return the first aliased property that returns a truthy value\n    if (this.map && this.map[key]) {\n      const entry = this.map[key];\n      for (let i = 0; i < entry.length; i++) {\n        let val = this.values[entry[i]];\n        if (val) {\n          return val;\n        }\n      }\n    }\n\n    // fallback: return the value by key\n    return this.values[key];\n  }\n\n  hasData(\n    key: string // idx name\n  ): boolean \n  {\n    // no attempt to format, we want simple true/false\n    return !!this.getData(key);\n  }\n\n  getNextStep(_authClient: OktaAuthIdxInterface, _context?: IdxContext): NextStep {\n    const name = this.getName();\n    const inputs = this.getInputs();\n    const authenticator = this.getAuthenticator();\n    // TODO: remove type field in the next major version change\n    // https://oktainc.atlassian.net/browse/OKTA-431749\n    const type = authenticator?.type;\n    return { \n      name, \n      inputs, \n      ...(type && { type }),\n      ...(authenticator && { authenticator }),\n    };\n  }\n\n  // Get inputs for the next step\n  getInputs(): Input[] {\n    const inputs: Input[] = [];\n    const inputsFromRemediation = this.remediation.value || [];\n    inputsFromRemediation.forEach(inputFromRemediation => {\n      let input;\n      let { name, type, visible, messages } = inputFromRemediation;\n      if (visible === false) {\n        return; // Filter out invisible inputs, like stateHandle\n      }\n      if (typeof this[`getInput${titleCase(name)}`] === 'function') {\n        input = this[`getInput${titleCase(name)}`](inputFromRemediation);\n      } else if (type !== 'object') {\n        // handle general primitive types\n        let alias;\n        const aliases = (this.map ? this.map[name] : null) || [];\n        if (aliases.length === 1) {\n          alias = aliases[0];\n        } else {\n          // try find key from values\n          alias = aliases.find(name => Object.keys(this.values).includes(name));\n        }\n        if (alias) {\n          input = { ...inputFromRemediation, name: alias };\n        }\n      }\n      if (!input) {\n        input = inputFromRemediation;\n      }\n      if (Array.isArray(input)) {\n        input.forEach(i => inputs.push(i));\n      } else {\n        // guarantees field-level messages are passed back\n        if (messages) {\n          input.messages = messages;\n        }\n        inputs.push(input);\n      }\n    });\n    return inputs;\n  }\n\n  static getMessages(remediation: IdxRemediation): IdxMessage[] | undefined {\n    if (!remediation.value) {\n      return;\n    }\n    return remediation.value[0]?.form?.value.reduce((messages: IdxMessage[], field) => {\n      if (field.messages) {\n        messages = [...messages, ...field.messages.value];\n      }\n      return messages;\n    }, []);\n  }\n\n  // Prepare values for the next remediation\n  // In general, remove used values from inputs for the current remediation\n  // Override this method if special cases need be handled\n  getValuesAfterProceed(): T {\n    const inputsFromRemediation = this.remediation.value || []; // \"raw\" inputs from server response\n    const inputsFromRemediator = this.getInputs(); // \"aliased\" inputs from SDK remediator\n    const inputs = [\n      ...inputsFromRemediation,\n      ...inputsFromRemediator\n    ];\n    // scrub all values related to this remediation\n    for (const input of inputs) {\n      delete this.values[input.name];\n    }\n    return this.values;\n  }\n\n  protected getAuthenticator(): IdxAuthenticator | undefined {\n    // relatesTo value may be an authenticator or an authenticatorEnrollment\n    const relatesTo = this.remediation.relatesTo?.value;\n    if (!relatesTo) {\n      return;\n    }\n\n    const authenticatorFromRemediation = getAuthenticatorFromRemediation(this.remediation);\n    if (!authenticatorFromRemediation) {\n      // Hopefully value is an authenticator\n      return relatesTo;\n    }\n\n    // If relatesTo is an authenticatorEnrollment, the id is actually the enrollmentId\n    // Let's get the correct authenticator id from the form value\n    const id = authenticatorFromRemediation.form!.value\n      .find(({ name }) => name === 'id')!.value as string;\n    const enrollmentId = authenticatorFromRemediation.form!.value\n      .find(({ name }) => name === 'enrollmentId')?.value as string;\n\n    return {\n      ...relatesTo,\n      id,\n      enrollmentId\n    };\n  }\n}\n","/* eslint-disable @typescript-eslint/no-non-null-assertion */\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\nimport { Remediator, RemediationValues } from './Remediator';\nimport { getAuthenticatorFromRemediation } from '../util';\nimport { IdxRemediationValue, IdxContext, IdxOption } from '../../types/idx-js';\nimport { Authenticator, isAuthenticator } from '../../types/api';\nimport { compareAuthenticators, findMatchedOption} from '../../authenticator/util';\n\nexport type SelectAuthenticatorValues = RemediationValues & {\n  authenticator?: string | Authenticator;\n};\n\n// Base class - DO NOT expose static remediationName\nexport class SelectAuthenticator<T extends SelectAuthenticatorValues = SelectAuthenticatorValues>\n  extends Remediator<T> {\n  selectedAuthenticator?: Authenticator;\n  selectedOption?: any;\n\n  // Find matched authenticator in provided order\n  findMatchedOption(authenticators, options) {\n    let option: IdxOption | undefined;\n    for (let authenticator of authenticators) {\n      option = options\n        .find(({ relatesTo }) => relatesTo.key && relatesTo.key === authenticator.key);\n      if (option) {\n        break;\n      }\n    }\n    return option;\n  }\n\n  /* eslint complexity:[0,9] */\n  canRemediate(context?: IdxContext) {\n    const { authenticators, authenticator } = this.values;\n    const authenticatorFromRemediation = getAuthenticatorFromRemediation(this.remediation);\n    const { options } = authenticatorFromRemediation;\n    // Let users select authenticator if no input is provided\n    if (!authenticators || !authenticators.length) {\n      return false;\n    }\n\n    // Authenticator is explicitly specified by id\n    if (isAuthenticator(authenticator) && authenticator.id) {\n      return true;\n    }\n\n    // Proceed with provided authenticators\n    const matchedOption = this.findMatchedOption(authenticators, options!);\n    if (matchedOption) {\n      // Don't select current authenticator (OKTA-612939)\n      const isCurrentAuthenticator = context?.currentAuthenticator\n        && context?.currentAuthenticator.value.id === matchedOption.relatesTo?.id;\n      const isCurrentAuthenticatorEnrollment = context?.currentAuthenticatorEnrollment\n        && context?.currentAuthenticatorEnrollment.value.id === matchedOption.relatesTo?.id;\n      return !isCurrentAuthenticator && !isCurrentAuthenticatorEnrollment;\n    }\n    \n    return false;\n  }\n\n  mapAuthenticator(remediationValue: IdxRemediationValue) {\n    const { authenticators, authenticator } = this.values;\n\n    // Authenticator is explicitly specified by id\n    if (isAuthenticator(authenticator) && authenticator.id) {\n      this.selectedAuthenticator = authenticator; // track the selected authenticator\n      return authenticator;\n    }\n\n    const { options } = remediationValue;\n    const selectedOption = findMatchedOption(authenticators, options);\n    this.selectedAuthenticator = selectedOption.relatesTo; // track the selected authenticator\n    this.selectedOption = selectedOption;\n    return {\n      id: selectedOption?.value.form.value.find(({ name }) => name === 'id').value\n    };\n  }\n\n  getInputAuthenticator(remediation) {\n    const options = remediation.options.map(({ label, relatesTo }) => {\n      return {\n        label,\n        value: relatesTo.key\n      };\n    });\n    return { name: 'authenticator', type: 'string', options };\n  }\n\n  getValuesAfterProceed(): T {\n    this.values = super.getValuesAfterProceed();\n    // remove used authenticators\n    const authenticators = (this.values.authenticators as Authenticator[])\n      .filter(authenticator => {\n        return compareAuthenticators(authenticator, this.selectedAuthenticator) !== true;\n      });\n    return { ...this.values, authenticators };\n  }\n\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\nimport { Remediator, RemediationValues } from './Remediator';\nimport { getAuthenticator, Authenticator, AuthenticatorValues } from '../../authenticator';\nimport { IdxRemediation, IdxContext } from '../../types/idx-js';\nimport { OktaAuthIdxInterface, NextStep } from '../../types';\n\nexport type VerifyAuthenticatorValues = AuthenticatorValues & RemediationValues;\n\n// Base class - DO NOT expose static remediationName\nexport class VerifyAuthenticator<T extends VerifyAuthenticatorValues = VerifyAuthenticatorValues>\n  extends Remediator<T> {\n\n  authenticator: Authenticator<VerifyAuthenticatorValues>;\n\n  constructor(remediation: IdxRemediation, values: T = {} as T) {\n    super(remediation, values);\n    this.authenticator = getAuthenticator(remediation);\n  }\n\n  getNextStep(authClient: OktaAuthIdxInterface, context?: IdxContext): NextStep {\n    const nextStep = super.getNextStep(authClient, context);\n    const authenticatorEnrollments = context?.authenticatorEnrollments?.value;\n\n    return {\n      ...nextStep,\n      authenticatorEnrollments\n    };\n  }\n\n  canRemediate() {\n    return this.authenticator.canVerify(this.values);\n  }\n\n  mapCredentials() {\n    return this.authenticator.mapCredentials(this.values);\n  }\n\n  getInputCredentials(input) {\n    return this.authenticator.getInputs(input);\n  }\n\n  getValuesAfterProceed(): T {\n    this.values = super.getValuesAfterProceed();\n    let trimmedValues = Object.keys(this.values).filter(valueKey => valueKey !== 'credentials');\n    return trimmedValues.reduce((values, valueKey) => ({...values, [valueKey]: this.values[valueKey]}), {} as T);\n  }\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\nimport { VerifyAuthenticator, VerifyAuthenticatorValues } from './Base/VerifyAuthenticator';\n\nexport type ChallengeAuthenticatorValues = VerifyAuthenticatorValues;\n\nexport class ChallengeAuthenticator extends VerifyAuthenticator<ChallengeAuthenticatorValues> {\n  static remediationName = 'challenge-authenticator';\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\nimport { EnrollPoll } from './EnrollPoll';\n\nexport class ChallengePoll extends EnrollPoll{\n  static remediationName = 'challenge-poll';\n\n  canRemediate() {\n    return !!this.values.startPolling || this.options.step === 'challenge-poll';\n  }\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\nimport { VerifyAuthenticator, VerifyAuthenticatorValues } from './Base/VerifyAuthenticator';\n\nexport type EnrollAuthenticatorValues = VerifyAuthenticatorValues;\n\nexport class EnrollAuthenticator extends VerifyAuthenticator<EnrollAuthenticatorValues> {\n  static remediationName = 'enroll-authenticator';\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\nimport { Remediator, RemediationValues } from './Base/Remediator';\nimport { NextStep, OktaAuthIdxInterface } from '../types';\nimport { IdxContext } from '../types/idx-js';\n\nexport interface EnrollPollValues extends RemediationValues {\n  startPolling?: boolean;\n}\n\nexport class EnrollPoll extends Remediator<EnrollPollValues> {\n  static remediationName = 'enroll-poll';\n\n  canRemediate() {\n    return !!this.values.startPolling || this.options.step === 'enroll-poll';\n  }\n\n  getNextStep(authClient: OktaAuthIdxInterface, context?: IdxContext): NextStep {\n    const common = super.getNextStep(authClient, context);\n    let authenticator = this.getAuthenticator();\n    if (!authenticator && context?.currentAuthenticator) {\n      authenticator = context.currentAuthenticator.value;\n    }\n    return {\n      ...common,\n      authenticator,\n      poll: {\n        required: true,\n        refresh: this.remediation.refresh\n      },\n    };\n  }\n\n  getValuesAfterProceed(): EnrollPollValues {\n    let trimmedValues = Object.keys(this.values).filter(valueKey => valueKey !== 'startPolling');\n    return trimmedValues.reduce((values, valueKey) => ({...values, [valueKey]: this.values[valueKey]}), {});\n  }\n}\n","/* eslint-disable @typescript-eslint/no-non-null-assertion */\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\nimport { IdxRemediation, IdxRemediationValue, IdxAuthenticator } from '../types/idx-js';\nimport { RemediateOptions } from '../types';\nimport { Remediator, RemediationValues } from './Base/Remediator';\nimport { Authenticator, Credentials, OktaPassword } from '../authenticator';\n\nexport interface EnrollProfileValues extends RemediationValues {\n  firstName?: string;\n  lastName?: string;\n  email?: string;\n  credentials?: Credentials;\n  password?: string;\n  passcode?: string;\n}\n\nexport class EnrollProfile extends Remediator<EnrollProfileValues> {\n  static remediationName = 'enroll-profile';\n\n  authenticator: Authenticator<any> | null = null;\n\n  constructor(\n    remediation: IdxRemediation,\n    values: EnrollProfileValues = {},\n    options: RemediateOptions = {}\n  ) {\n    super(remediation, values, options);\n\n    // credentials are only required when Profile Enrollment policy requires them\n    // if credentials are included in the remediation, they are considered required\n    // otherwise it will be omitted\n    const credentials = this.getCredentialsFromRemediation();\n    if (credentials) {\n      this.authenticator = this.authenticator = new OktaPassword({} as IdxAuthenticator);\n    }\n  }\n\n  canRemediate() {\n    // ensure credentials can be verified, if required\n    if (this.authenticator && !this.authenticator.canVerify(this.values)) {\n      return false;\n    }\n\n    const userProfileFromValues = this.getData().userProfile;\n    if (!userProfileFromValues) {\n      return false;\n    }\n    // eslint-disable-next-line max-len\n    const userProfileFromRemediation = this.remediation.value!.find(({ name }) => name === 'userProfile') as IdxRemediationValue;\n    return userProfileFromRemediation.form!.value.reduce((canRemediate, curr) => {\n      if (curr.required) {\n        canRemediate = canRemediate && !!userProfileFromValues[curr.name];\n      }\n      return canRemediate;\n    }, true);\n  }\n\n  getCredentialsFromRemediation () {\n    return this.remediation.value!.find(({ name }) => name === 'credentials');\n  }\n\n  mapUserProfile({form: { value: profileAttributes }}) {\n    const attributeNames = profileAttributes.map(({name}) => name);\n    const data = attributeNames.reduce((attributeValues, attributeName) => (\n      this.values[attributeName] ? {\n      ...attributeValues,\n      [attributeName]: this.values[attributeName]\n    } : attributeValues), {});\n    if (Object.keys(data).length === 0) {\n      return;\n    }\n    return data;\n  }\n\n  mapCredentials() {\n    const val = this.authenticator && this.authenticator.mapCredentials(this.values);\n    if (!val) {\n      return;\n    }\n    return val;\n  }\n\n  getInputUserProfile(input) {\n    return [...input.form.value];\n  }\n\n  getInputCredentials(input) {\n    return [...input.form.value];\n  }\n\n  getErrorMessages(errorRemediation) {\n    return errorRemediation.value[0].form.value.reduce((errors, field) => {\n      if (field.messages) {\n        errors.push(field.messages.value[0].message);\n      }\n      return errors;\n    }, []);\n  }\n}","/*!\n * Copyright (c) 2021-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\nimport { Remediator, RemediationValues } from './Base/Remediator';\nimport { IdxContext } from '../types/idx-js';\nimport { OktaAuthIdxInterface } from '../types';\n\n\nexport type EnrollmentChannelDataValues = RemediationValues & {\n  email?: string;\n  phoneNumber?: string;\n};\n\nexport class EnrollmentChannelData extends Remediator<EnrollmentChannelDataValues> {\n  static remediationName = 'enrollment-channel-data';\n\n  getInputEmail() {\n    return [\n      { name: 'email', type: 'string', required: true, label: 'Email' },\n    ];\n  }\n\n  getInputPhoneNumber() {\n    return [\n      { name: 'phoneNumber', type: 'string', required: true, label: 'Phone Number' },\n    ];\n  }\n\n  canRemediate() {\n    return Boolean(this.values.email || this.values.phoneNumber);\n  }\n\n  getNextStep(authClient: OktaAuthIdxInterface, context: IdxContext) {\n    const common = super.getNextStep(authClient, context);\n    const authenticator = context.currentAuthenticator.value;\n    return {\n      ...common,\n      authenticator,\n    };\n  }\n\n  getData() {\n    return {\n      stateHandle: this.values.stateHandle,\n      email: this.values.email,\n      phoneNumber: this.values.phoneNumber\n    };\n  }\n\n  getValuesAfterProceed(): EnrollmentChannelDataValues {\n    let trimmedValues = Object.keys(this.values).filter(valueKey => !['email', 'phoneNumber'].includes(valueKey));\n    return trimmedValues.reduce((values, valueKey) => ({...values, [valueKey]: this.values[valueKey]}), {});\n  }\n}\n","import { OktaAuthIdxInterface, IdxContext, NextStep, Input } from '../../types';\nimport { Remediator } from '../Base/Remediator';\nimport { unwrapFormValue } from './util';\n\nexport class GenericRemediator extends Remediator {\n  canRemediate(): boolean {\n    // only handle remediations that are able to submit form (xhr)\n    if (typeof this.remediation.action !== 'function') {\n      return false;\n    }\n\n    // DO NOT REMOVE - bring it back when enable client side validation for GenericRemediator - OKTA-512003\n    // const inputs = this.getInputs();\n    // const res = inputs.reduce((acc, input) => {\n    //   return acc && hasValidInputValue(input, this.values);\n    // }, true);\n    // return res;\n\n    if (this.remediation.name === 'poll' || this.remediation.name.endsWith('-poll')) {\n      return true;\n    }\n\n    if (this.options.step) {\n      return true;\n    }\n    \n    // disable auto proceed for unknown remediations\n    return false;\n  }\n\n  getData() {\n    const data = this.getInputs().reduce((acc, { name }) => {\n      acc[name] = this.values[name];\n      return acc;\n    }, {});\n    return data;\n  }\n\n  getNextStep(authClient: OktaAuthIdxInterface, _context?: IdxContext): NextStep {\n    const name = this.getName();\n    const inputs = this.getInputs();\n    \n    /* eslint-disable no-unused-vars, @typescript-eslint/no-unused-vars */\n    // excludes transformed fields\n    const { \n      // http metas have been transformed to action\n      href, \n      method, \n      rel, \n      accepts, \n      produces, \n      // value has been transform to inputs\n      value,\n      // will be transformed to a function that resolves IdxTransaction\n      action,\n      ...rest \n    } = this.remediation;\n    /* eslint-enable no-unused-vars, @typescript-eslint/no-unused-vars */\n\n    // step to handle form submission\n    if (action) {\n      return { \n        ...rest,\n        ...(!!inputs.length && { inputs }),\n        action: async (params?) => {\n          return authClient.idx.proceed({\n            step: name,\n            ...params\n          });\n        }\n      };\n    }\n\n    // return whole remediation data for other steps, eg \"redirect-idp\"\n    return { ...this.remediation } as NextStep;\n    \n  }\n\n  getInputs(): Input[] {\n    return (this.remediation.value || [])\n      .filter(({ name }) => name !== 'stateHandle')\n      .map(unwrapFormValue)\n      .map(input => {\n        // use string as default input type\n        input.type = input.type || 'string';\n        return input;\n      });\n  }\n\n}\n","export * from './GenericRemediator';","/* eslint-disable complexity */\nimport { AuthSdkError } from '../../../errors';\nimport { Input } from '../../types';\n\nexport function unwrapFormValue(remediation): Input { \n  if (Array.isArray(remediation)) {\n    return remediation\n      .map(item => {\n        if (typeof item === 'string' || typeof item === 'number' || typeof item === 'boolean') {\n          return item;\n        }\n        return unwrapFormValue(item);\n      }) as any;\n  }\n\n  const res = {};\n  for (const [key, value] of Object.entries(remediation)) {\n    if (value === null || typeof value === 'undefined') {\n      continue;\n    }\n\n    if (typeof value === 'object') {\n      const formKeys = Object.keys(value as object);\n      // detect patterns like:\n      // value -> form -> value | form -> value\n      if (['value', 'form'].includes(key) \n        && formKeys.length === 1 \n        && ['value', 'form'].includes(formKeys[0])\n      ) {\n        // unwrap nested form\n        const unwrappedForm = unwrapFormValue(value);\n        Object.entries(unwrappedForm).forEach(([key, value]) => {\n          res[key] = value;\n        });\n      } else {\n        // dfs\n        res[key] = unwrapFormValue(value);\n      }\n    } else {\n      // handle primitive value\n      res[key] = value;\n    }\n  }\n\n  return res as Input;\n}\n\n// only check if value is required for now\n// TODO: support SDK layer type based input validation\nexport function hasValidInputValue(input, values) {\n  const fn = (input, values, requiredTracker) => {\n    const { name, value, type, options, required } = input;\n    const isRequired = required || requiredTracker;\n\n    // handle nested value - all required fields should be avaiable in values \n    if (Array.isArray(value)) {\n      return value.reduce((acc, item) => {\n        return acc && fn(item, values[name], isRequired); // recursive call\n      }, true);\n    }\n\n    // handle options field\n    // 1. object type options - check if each object field is required and value can be found from the selectedOption\n    // 2. primitive options - required field is avaiable from top level\n    // 3. unknown format - pass to backend for validation\n    if (options) {\n      // object type options\n      if (type === 'object') {\n        const selectedOption = values[name];\n        if (!selectedOption) {\n          return false;\n        }\n        if (!selectedOption.id) {\n          // unknown option format, pass to backend for validation\n          return true;\n        }\n        const optionSchema = options.find((option) => {\n          const idSchema = option.value.find(({ name }) => name === 'id' );\n          return idSchema.value === selectedOption.id;\n        });\n        if (!optionSchema) {\n          return false;\n        }\n        return optionSchema.value\n          .filter(({ required }) => !!required)\n          .reduce((acc, { name }) => {\n            return acc && !!selectedOption[name];\n          }, true);\n      }\n\n      // primitive options, not required - always valid\n      if (required === false) {\n        return true;\n      }\n\n      // primitive options, required - check if value is available\n      if (required === true) {\n        return !!values[name];\n      }\n\n      // unknown options, throw\n      throw new AuthSdkError(`Unknown options type, ${JSON.stringify(input)}`);\n    }\n\n    // base case\n    if (!isRequired) {\n      return true;\n    }\n      \n    return !!(values && values[name]);\n  };\n\n  return fn(input, values, false);\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\nimport { Credentials } from '../authenticator';\nimport { Remediator, RemediationValues } from './Base/Remediator';\n\nexport interface IdentifyValues extends RemediationValues {\n  username?: string;\n  password?: string;\n  credentials?: Credentials;\n  rememberMe?: boolean;\n}\n\nexport class Identify extends Remediator<IdentifyValues> {\n  static remediationName = 'identify';\n\n  map = {\n    'identifier': ['username']\n  };\n\n  canRemediate(): boolean {\n    const { identifier } = this.getData();\n    return !!identifier;\n  }\n\n  mapCredentials() {\n    const { credentials, password } = this.values;\n    if (!credentials && !password) {\n      return;\n    }\n    return credentials || { passcode: password };\n  }\n\n  getInputCredentials(input) {\n    return {\n      ...input.form.value[0],\n      name: 'password',\n      required: input.required\n    };\n  }\n\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\nimport { Remediator, RemediationValues } from './Base/Remediator';\n\nexport interface ReEnrollAuthenticatorValues extends RemediationValues {\n  newPassword?: string;\n}\n\nexport class ReEnrollAuthenticator extends Remediator<ReEnrollAuthenticatorValues> {\n  static remediationName = 'reenroll-authenticator';\n\n  mapCredentials() {\n    const { newPassword } = this.values;\n    if (!newPassword) {\n      return;\n    }\n    return { \n      passcode: newPassword,\n    };\n  }\n\n  getInputCredentials(input) {\n    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n    const challengeType = this.getAuthenticator()!.type;\n    const name = challengeType === 'password' ? 'newPassword' : 'verificationCode';\n    return {\n      ...input.form.value[0],\n      name\n    };\n  }\n\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\nimport { ReEnrollAuthenticator } from './ReEnrollAuthenticator';\n\nexport class ReEnrollAuthenticatorWarning extends ReEnrollAuthenticator {\n  static remediationName = 'reenroll-authenticator-warning';\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\nimport { Remediator } from './Base/Remediator';\n\nexport class RedirectIdp extends Remediator {\n  static remediationName = 'redirect-idp';\n\n  canRemediate() {\n    return false;\n  }\n\n  getNextStep() {\n    const { name, type, idp, href } = this.remediation;\n    return {\n      name,\n      type,\n      idp,\n      href\n    };\n  }\n\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\nimport { VerifyAuthenticator, VerifyAuthenticatorValues } from './Base/VerifyAuthenticator';\n\nexport type ResetAuthenticatorValues = VerifyAuthenticatorValues;\n\nexport class ResetAuthenticator extends VerifyAuthenticator<ResetAuthenticatorValues> {\n  static remediationName = 'reset-authenticator';\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\nimport { SelectAuthenticator, SelectAuthenticatorValues } from './Base/SelectAuthenticator';\nimport { getAuthenticatorFromRemediation } from './util';\nimport { IdxRemediation } from '../types/idx-js';\nimport { AuthenticatorKey, Authenticator, RemediateOptions } from '../types';\n\nexport type SelectAuthenticatorAuthenticateValues = SelectAuthenticatorValues & {\n  password?: string;\n};\n\nexport class SelectAuthenticatorAuthenticate extends SelectAuthenticator<SelectAuthenticatorAuthenticateValues> {\n  static remediationName = 'select-authenticator-authenticate';\n\n  constructor(\n    remediation: IdxRemediation, \n    values: SelectAuthenticatorValues = {}, \n    options: RemediateOptions = {}\n  ) {\n    super(remediation, values, options);\n\n    // Preset password authenticator to trigger recover action\n    const isRecoveryFlow = this.options.flow === 'recoverPassword';\n    const hasPasswordInOptions = getAuthenticatorFromRemediation(remediation)\n      .options?.some(({ relatesTo }) => relatesTo?.key === AuthenticatorKey.OKTA_PASSWORD);\n    if (hasPasswordInOptions && (isRecoveryFlow || this.values.password)) {\n      this.values.authenticators = [\n        ...this.values.authenticators || [],\n        { key: AuthenticatorKey.OKTA_PASSWORD }\n      ] as Authenticator[];\n    }\n  }\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\nimport { SelectAuthenticator, SelectAuthenticatorValues } from './Base/SelectAuthenticator';\n\nexport type SelectAuthenticatorEnrollValues = SelectAuthenticatorValues;\n\nexport class SelectAuthenticatorEnroll extends SelectAuthenticator<SelectAuthenticatorEnrollValues> {\n  static remediationName = 'select-authenticator-enroll';\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\nimport { SelectAuthenticator, SelectAuthenticatorValues } from './Base/SelectAuthenticator';\nimport { Authenticator } from '../types';\nimport { IdxRemediationValue } from '../types/idx-js';\n\n\nexport type SelectAuthenticatorUnlockAccountValues = SelectAuthenticatorValues & {\n  identifier?: string;\n  methodType?: string;\n};\n\nexport class SelectAuthenticatorUnlockAccount extends SelectAuthenticator<SelectAuthenticatorUnlockAccountValues> {\n  static remediationName = 'select-authenticator-unlock-account';\n  authenticator?: Authenticator;\n\n  map = {\n    identifier: ['username']\n  };\n\n  canRemediate() {\n    const identifier = this.getData('identifier');\n    return !!identifier && super.canRemediate();\n  }\n\n  mapAuthenticator(remediationValue: IdxRemediationValue) {\n    const authenticatorMap = super.mapAuthenticator(remediationValue);\n    const methodTypeOption = this.selectedOption?.value.form.value.find(({ name }) => name === 'methodType');\n\n    // defaults to 'manually defined' value\n    // 2nd: option may have pre-defined value, like stateHandle\n    // 3rd: if only a single OV option is available, default to that option\n    const methodTypeValue = this.values.methodType ||\n      methodTypeOption?.value as string || methodTypeOption?.options?.[0]?.value as string;\n\n    if (methodTypeValue) {\n      return {\n        ...authenticatorMap,\n        methodType: methodTypeValue\n      };\n    }\n\n    return authenticatorMap;\n  }\n\n  getInputUsername () {\n    return { name: 'username', type: 'string' };\n  }\n\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\nimport { Remediator, RemediationValues } from './Base/Remediator';\n\n// eslint-disable-next-line @typescript-eslint/no-empty-interface\nexport interface SelectEnrollProfileValues extends RemediationValues {}\n\nexport class SelectEnrollProfile extends Remediator<SelectEnrollProfileValues> {\n  static remediationName = 'select-enroll-profile';\n\n  canRemediate() {\n    return true;\n  }\n}\n","/*!\n * Copyright (c) 2021-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\nimport { Remediator, RemediationValues } from './Base/Remediator';\nimport { IdxRemediationValueForm, IdxContext } from '../types/idx-js';\nimport { Authenticator, OktaAuthIdxInterface } from '../types/api';\n\n\nexport type SelectEnrollmentChannelValues = RemediationValues & {\n  channel?: string;\n};\n\nexport class SelectEnrollmentChannel extends Remediator<SelectEnrollmentChannelValues> {\n  static remediationName = 'select-enrollment-channel';\n\n  canRemediate() {\n    if (this.values.channel) {\n      return true;\n    }\n\n    if (this.values.authenticator) {\n      const { id, channel } = this.values.authenticator as Authenticator;\n      if (!!id && !!channel) {\n        return true;\n      }\n    }\n\n    return false;\n  }\n\n  getNextStep(authClient: OktaAuthIdxInterface, context: IdxContext) {\n    const common = super.getNextStep(authClient, context);\n    const authenticator = context.currentAuthenticator.value;\n    return {\n      ...common,\n      authenticator,\n    };\n  }\n\n  getData() {\n    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n    const remediationValue = this.remediation!.value![0].value as IdxRemediationValueForm;\n    return {\n      authenticator: {\n        id: remediationValue.form.value[0].value,\n        channel: (this.values.authenticator as Authenticator)?.channel || this.values.channel,\n      },\n      stateHandle: this.values.stateHandle,\n\n    };\n  }\n\n  getValuesAfterProceed(): SelectEnrollmentChannelValues {\n    this.values = super.getValuesAfterProceed();\n    delete this.values.authenticators;    // required to prevent infinite loops from auto-remediating via values\n    const filterKey = this.values.channel ? 'channel' : 'authenticator';\n    let trimmedValues = Object.keys(this.values).filter(valueKey => valueKey !== filterKey);\n    return trimmedValues.reduce((values, valueKey) => ({...values, [valueKey]: this.values[valueKey]}), {});\n  }\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\nimport { Remediator, RemediationValues } from './Base/Remediator';\n\nexport interface SkipValues extends RemediationValues {\n  skip?: boolean;\n}\n\nexport class Skip extends Remediator<SkipValues> {\n  static remediationName = 'skip';\n\n  canRemediate() {\n    return !!this.values.skip || this.options.step === 'skip';\n  }\n\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\nexport * from './Base/Remediator';\nexport * from './EnrollAuthenticator';\nexport * from './EnrollPoll';\nexport * from './SelectEnrollmentChannel';\nexport * from './EnrollmentChannelData';\nexport * from './ChallengeAuthenticator';\nexport * from './ChallengePoll';\nexport * from './ResetAuthenticator';\nexport * from './EnrollProfile';\nexport * from './Identify';\nexport * from './ReEnrollAuthenticator';\nexport * from './ReEnrollAuthenticatorWarning';\nexport * from './RedirectIdp';\nexport * from './SelectAuthenticatorAuthenticate';\nexport * from './SelectAuthenticatorEnroll';\nexport * from './SelectAuthenticatorUnlockAccount';\nexport * from './SelectEnrollProfile';\nexport * from './AuthenticatorVerificationData';\nexport * from './AuthenticatorEnrollmentData';\nexport * from './Skip';\nexport * from './GenericRemediator';\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\nimport { IdxRemediation, IdxRemediationValue } from '../types/idx-js';\n\nexport function getAllValues(idxRemediation: IdxRemediation) {\n  return idxRemediation.value?.map(r => r.name);\n}\n\nexport function getRequiredValues(idxRemediation: IdxRemediation) {\n  return idxRemediation.value?.reduce((required, cur) => {\n    if (cur.required) {\n      required.push(cur.name as never);\n    }\n    return required;\n  }, []);\n}\n\nexport function titleCase(str: string) {\n  return str.charAt(0).toUpperCase() + str.substring(1);\n}\n\nexport function getAuthenticatorFromRemediation(\n  remediation: IdxRemediation\n): IdxRemediationValue {\n  // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n  return remediation.value!.find(({ name }) => name === 'authenticator') as IdxRemediationValue;\n}\n","/* eslint-disable @typescript-eslint/no-non-null-assertion */\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 max-statements, complexity, max-depth */\nimport { interact } from './interact';\nimport { introspect } from './introspect';\nimport { remediate } from './remediate';\nimport { RemediationValues } from './remediators/Base/Remediator';\nimport { \n  OktaAuthIdxInterface,\n  IdxStatus,\n  IdxTransaction,\n  IdxFeature,\n  NextStep,\n  RunOptions,\n  IdxTransactionMeta,\n} from './types';\nimport { IdxMessage, IdxResponse } from './types/idx-js';\nimport { getSavedTransactionMeta, saveTransactionMeta } from './transactionMeta';\nimport {\n  getAvailableSteps,\n  getEnabledFeatures,\n  getMessagesFromResponse,\n  isTerminalResponse,\n  getFlowSpecification\n} from './util';\nimport { Tokens } from '../oidc/types';\nimport { APIError } from '../errors/types';\ndeclare interface RunData {\n  options: RunOptions;\n  values: RemediationValues;\n  status?: IdxStatus;\n  tokens?: Tokens;\n  nextStep?: NextStep;\n  messages?: IdxMessage[];\n  error?: APIError | IdxResponse;\n  meta?: IdxTransactionMeta;\n  enabledFeatures?: IdxFeature[];\n  availableSteps?: NextStep[];\n  idxResponse?: IdxResponse;\n  canceled?: boolean;\n  interactionCode?: string;\n  shouldSaveResponse?: boolean;\n  shouldClearTransaction?: boolean;\n  clearSharedStorage?: boolean;\n  terminal?: boolean;\n}\n\nfunction initializeValues(options: RunOptions) {\n  // remove known options, everything else is assumed to be a value\n  const knownOptions = [\n    'flow', \n    'remediators', \n    'actions', \n    'withCredentials', \n    'step',\n    'useGenericRemediator',\n    'exchangeCodeForTokens',\n  ];\n  const values = { ...options };\n  knownOptions.forEach(option => {\n    delete values[option];\n  });\n  return values;\n}\n\nfunction initializeData(authClient: OktaAuthIdxInterface, data: RunData): RunData {\n  let { options } = data;\n  options = {\n    ...authClient.options.idx,\n    ...options\n  };\n  let {\n    flow,\n    withCredentials,\n    remediators,\n    actions,\n  } = options;\n\n  const status = IdxStatus.PENDING;\n\n  // certain options can be set by the flow specification\n  flow = flow || authClient.idx.getFlow?.() || 'default';\n  if (flow) {\n    authClient.idx.setFlow?.(flow);\n    const flowSpec = getFlowSpecification(authClient, flow);\n    // Favor option values over flow spec\n    withCredentials = (typeof withCredentials !== 'undefined') ? withCredentials : flowSpec.withCredentials;\n    remediators = remediators || flowSpec.remediators;\n    actions = actions || flowSpec.actions;\n  }\n\n  return { \n    ...data,\n    options: { \n      ...options, \n      flow, \n      withCredentials, \n      remediators, \n      actions,\n    },\n    status\n  };\n}\n\nasync function getDataFromIntrospect(authClient: OktaAuthIdxInterface, data: RunData): Promise<RunData> {\n  const { options } = data;\n  const {\n    stateHandle,\n    withCredentials,\n    version,\n    state,\n    scopes,\n    recoveryToken,\n    activationToken,\n    maxAge,\n    acrValues,\n    nonce,\n    useGenericRemediator,\n  } = options;\n\n  let idxResponse;\n  let meta = getSavedTransactionMeta(authClient, { state, recoveryToken, activationToken }); // may be undefined\n\n  if (stateHandle) {\n    idxResponse = await introspect(authClient, { withCredentials, version, stateHandle, useGenericRemediator });\n  } else {\n    let interactionHandle = meta?.interactionHandle; // may be undefined\n    if (!interactionHandle) {\n      // start a new transaction\n      authClient.transactionManager.clear();\n      const interactResponse = await interact(authClient, {\n        withCredentials,\n        state,\n        scopes,\n        activationToken,\n        recoveryToken,\n        maxAge,\n        acrValues,\n        nonce,\n      }); \n      interactionHandle = interactResponse.interactionHandle;\n      meta = interactResponse.meta;\n    }\n  \n    // Introspect to get idx response\n    idxResponse = await introspect(authClient, { withCredentials, version, interactionHandle, useGenericRemediator });\n  }\n  return { ...data, idxResponse, meta };\n}\n\nasync function getDataFromRemediate(authClient: OktaAuthIdxInterface, data: RunData): Promise<RunData> {\n  let {\n    idxResponse,\n    options,\n    values\n  } = data;\n\n  const {\n    autoRemediate,\n    remediators,\n    actions,\n    flow,\n    step,\n    useGenericRemediator,\n  } = options;\n  \n  const shouldRemediate = (autoRemediate !== false && (remediators || actions || step));\n  if (!shouldRemediate) {\n    return data;\n  }\n\n  values = { \n    ...values, \n    stateHandle: idxResponse!.rawIdxState.stateHandle \n  };\n\n  // Can we handle the remediations?\n  const { \n    idxResponse: idxResponseFromRemediation, \n    nextStep,\n    canceled,\n  } = await remediate(\n    authClient,\n    idxResponse!, \n    values, \n    {\n      remediators,\n      actions,\n      flow,\n      step,\n      useGenericRemediator,\n    }\n  );\n  idxResponse = idxResponseFromRemediation;\n\n  return { ...data, idxResponse, nextStep, canceled };\n}\n\nasync function getTokens(authClient: OktaAuthIdxInterface, data: RunData): Promise<Tokens> {\n  let { meta, idxResponse } = data;\n  const { interactionCode } = idxResponse as IdxResponse;\n  const {\n    clientId,\n    codeVerifier,\n    ignoreSignature,\n    redirectUri,\n    urls,\n    scopes,\n  } = meta as IdxTransactionMeta;\n  const tokenResponse = await authClient.token.exchangeCodeForTokens({\n    interactionCode,\n    clientId,\n    codeVerifier,\n    ignoreSignature,\n    redirectUri,\n    scopes\n  }, urls);\n  return tokenResponse.tokens;\n}\n\nasync function finalizeData(authClient: OktaAuthIdxInterface, data: RunData): Promise<RunData> {\n  let {\n    options,\n    idxResponse,\n    canceled,\n    status,\n  } = data;\n  const { exchangeCodeForTokens } = options;\n  let shouldSaveResponse = false;\n  let shouldClearTransaction = false;\n  let clearSharedStorage = true;\n  let interactionCode;\n  let tokens;\n  let enabledFeatures;\n  let availableSteps;\n  let messages;\n  let terminal;\n\n  if (idxResponse) {\n    shouldSaveResponse = !!(idxResponse.requestDidSucceed || idxResponse.stepUp);\n    enabledFeatures = getEnabledFeatures(idxResponse);\n    availableSteps = getAvailableSteps(authClient, idxResponse, options.useGenericRemediator);\n    messages = getMessagesFromResponse(idxResponse, options);\n    terminal = isTerminalResponse(idxResponse);\n  }\n\n  if (terminal) {\n    status = IdxStatus.TERMINAL;\n\n    // In most cases a terminal response should not clear transaction data. The user should cancel or skip to continue.\n    // A terminal \"success\" is a non-error response with no further actions available.\n    // In these narrow cases, saved transaction data should be cleared.\n    // One example of a terminal success is when the email verify flow is continued in another tab\n    const hasActions = Object.keys(idxResponse!.actions).length > 0;\n    const hasErrors = !!messages.find(msg => msg.class === 'ERROR');\n    const isTerminalSuccess = !hasActions && !hasErrors && idxResponse!.requestDidSucceed === true;\n    if (isTerminalSuccess) {\n      shouldClearTransaction = true;\n    } else {\n      // save response if there are actions available (ignore messages)\n      shouldSaveResponse = !!hasActions;\n    }\n    // leave shared storage intact so the transaction can be continued in another tab\n    clearSharedStorage = false;\n  } else if (canceled) {\n    status = IdxStatus.CANCELED;\n    shouldClearTransaction = true;\n  } else if (idxResponse?.interactionCode) { \n    interactionCode = idxResponse.interactionCode;\n    if (exchangeCodeForTokens === false) {\n      status = IdxStatus.SUCCESS;\n      shouldClearTransaction = false;\n    } else {\n      tokens = await getTokens(authClient, data);\n      status = IdxStatus.SUCCESS;\n      shouldClearTransaction = true;\n    }\n  }\n  return {\n    ...data,\n    status,\n    interactionCode,\n    tokens,\n    shouldSaveResponse,\n    shouldClearTransaction,\n    clearSharedStorage,\n    enabledFeatures,\n    availableSteps,\n    messages,\n    terminal\n  };\n}\n\nexport async function run(\n  authClient: OktaAuthIdxInterface, \n  options: RunOptions = {},\n): Promise<IdxTransaction> {\n  let data: RunData = {\n    options,\n    values: initializeValues(options)\n  };\n\n  data = initializeData(authClient, data);\n  data = await getDataFromIntrospect(authClient, data);\n  data = await getDataFromRemediate(authClient, data);\n  data = await finalizeData(authClient, data);\n\n  const {\n    idxResponse,\n    meta,\n    shouldSaveResponse,\n    shouldClearTransaction,\n    clearSharedStorage,\n    status,\n    enabledFeatures,\n    availableSteps,\n    tokens,\n    nextStep,\n    messages,\n    error,\n    interactionCode\n  } = data;\n\n  if (shouldClearTransaction) {\n    authClient.transactionManager.clear({ clearSharedStorage });\n  }\n  else {\n    // ensures state is saved to sessionStorage\n    saveTransactionMeta(authClient, { ...meta });\n\n    if (shouldSaveResponse) {\n      // Save intermediate idx response in storage to reduce introspect call\n      const { rawIdxState: rawIdxResponse, requestDidSucceed } = idxResponse!;\n      authClient.transactionManager.saveIdxResponse({\n        rawIdxResponse,\n        requestDidSucceed,\n        stateHandle: idxResponse!.context?.stateHandle,\n        interactionHandle: meta?.interactionHandle\n      });\n    }\n  }\n  \n  // copy all fields from idxResponse which are needed by the widget\n  const { actions, context, neededToProceed, proceed, rawIdxState, requestDidSucceed, stepUp } = idxResponse || {};\n  return {\n    status: status!,\n    ...(meta && { meta }),\n    ...(enabledFeatures && { enabledFeatures }),\n    ...(availableSteps && { availableSteps }),\n    ...(tokens && { tokens }),\n    ...(nextStep && { nextStep }),\n    ...(messages && messages.length && { messages }),\n    ...(error && { error }),\n    ...(stepUp && { stepUp }),\n    interactionCode, // if options.exchangeCodeForTokens is false\n\n    // from idx-js\n    actions: actions!,\n    context: context!,\n    neededToProceed: neededToProceed!,\n    proceed: proceed!,\n    rawIdxState: rawIdxState!,\n    requestDidSucceed\n  };\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\nimport { run } from './run';\nimport { OktaAuthIdxInterface, IdxTransaction, StartOptions } from './types';\n\nexport async function startTransaction(\n  authClient: OktaAuthIdxInterface, \n  options: StartOptions = {}\n): Promise<IdxTransaction> {\n  // Clear IDX response cache and saved transaction meta (if any)\n  authClient.transactionManager.clear();\n\n  return run(authClient, {\n    exchangeCodeForTokens: false,\n    ...options\n  });\n}\n","import { CookieOptions, StorageManagerOptions, StorageOptions, StorageUtil } from '../storage/types';\nimport {  IdxTransactionMeta } from './types';\nimport { SavedObject } from '../storage';\nimport { IDX_RESPONSE_STORAGE_NAME } from '../constants';\nimport { createCoreStorageManager } from '../core/storage';\nimport { IdxResponseStorage } from './types/storage';\nimport { isBrowser } from '../features';\nimport { warn } from '../util';\nimport AuthSdkError from '../errors/AuthSdkError';\n\nexport function createIdxStorageManager<M extends IdxTransactionMeta>()\n{\n  const CoreStorageManager = createCoreStorageManager<M>();\n  return class IdxStorageManager extends CoreStorageManager\n  {\n    constructor(storageManagerOptions: StorageManagerOptions, cookieOptions: CookieOptions, storageUtil: StorageUtil) {\n      super(storageManagerOptions, cookieOptions, storageUtil);\n    }\n\n    // intermediate idxResponse\n    // store for network traffic optimazation purpose\n    // TODO: revisit in auth-js 6.0 epic JIRA: OKTA-399791\n    getIdxResponseStorage(options?: StorageOptions): IdxResponseStorage | null {\n      let storage;\n      if (isBrowser()) {\n        // on browser side only use memory storage \n        try {\n          storage = this.storageUtil.getStorageByType('memory', options);\n        } catch (e) {\n          // it's ok to miss response storage\n          // eslint-disable-next-line max-len\n          warn('No response storage found, you may want to provide custom implementation for intermediate idx responses to optimize the network traffic');\n        }\n      } else {\n        // on server side re-use transaction custom storage\n        const transactionStorage = this.getTransactionStorage(options);\n        if (transactionStorage) {\n          storage = {\n            getItem: (key) => {\n              const transaction = transactionStorage.getStorage();\n              if (transaction && transaction[key]) {\n                return transaction[key];\n              }\n              return null;\n            },\n            setItem: (key, val) => {\n              const transaction = transactionStorage.getStorage();\n              if (!transaction) {\n                throw new AuthSdkError('Transaction has been cleared, failed to save idxState');\n              }\n              transaction[key] = val;\n              transactionStorage.setStorage(transaction);\n            },\n            removeItem: (key) => {\n              const transaction = transactionStorage.getStorage();\n              if (!transaction) {\n                return;\n              }\n              delete transaction[key];\n              transactionStorage.setStorage(transaction);\n            }\n          };\n        }\n      }\n\n      if (!storage) {\n        return null;\n      }\n\n      return new SavedObject(storage, IDX_RESPONSE_STORAGE_NAME);\n    }\n  };\n}\n","/* eslint-disable @typescript-eslint/no-non-null-assertion */\n/*!\n * Copyright (c) 2021, 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\nimport { OktaAuthIdxInterface, IdxTransactionMeta, IdxTransactionMetaOptions } from './types';\nimport { removeNils, warn } from '../util';\nimport { createOAuthMeta, PKCETransactionMeta } from '../oidc';\n\n// Calculate new values\nexport async function createTransactionMeta(\n  authClient: OktaAuthIdxInterface,\n  options: IdxTransactionMetaOptions = {}\n): Promise<IdxTransactionMeta> {\n  const tokenParams = await authClient.token.prepareTokenParams(options);\n  const pkceMeta = createOAuthMeta(authClient, tokenParams) as PKCETransactionMeta;\n  let {\n    flow = 'default',\n    withCredentials = true,\n    activationToken = undefined,\n    recoveryToken = undefined,\n    maxAge = undefined,\n    acrValues = undefined,\n  } = { ...authClient.options, ...options }; // local options override SDK options\n\n  const meta: IdxTransactionMeta = {\n    ...pkceMeta,\n    flow,\n    withCredentials,\n    activationToken,\n    recoveryToken,\n    maxAge,\n    acrValues\n  };\n  return meta;\n}\n\nexport function hasSavedInteractionHandle(\n  authClient: OktaAuthIdxInterface,\n  options?: IdxTransactionMetaOptions\n): boolean {\n  const savedMeta = getSavedTransactionMeta(authClient, options);\n  if (savedMeta?.interactionHandle) {\n    return true;\n  }\n  return false;\n}\n\n// Returns the saved transaction meta, if it exists and is valid\nexport function getSavedTransactionMeta(\n  authClient: OktaAuthIdxInterface,\n  options?: IdxTransactionMetaOptions\n): IdxTransactionMeta | undefined {\n  options = removeNils(options);\n  options = { ...authClient.options, ...options }; // local options override SDK options\n  let savedMeta;\n  try {\n    savedMeta = authClient.transactionManager.load(options) as IdxTransactionMeta;\n  } catch (e) {\n    // ignore errors here\n  }\n\n  if (!savedMeta) {\n    return;\n  }\n\n  if (isTransactionMetaValid(savedMeta, options)) {\n    return savedMeta;\n  }\n\n  // existing meta is not valid for this configuration\n  // this is common when changing configuration in local development environment\n  // in a production environment, this may indicate that two apps are sharing a storage key\n  warn('Saved transaction meta does not match the current configuration. ' + \n    'This may indicate that two apps are sharing a storage key.');\n\n}\n\nexport async function getTransactionMeta(\n  authClient: OktaAuthIdxInterface,\n  options?: IdxTransactionMetaOptions\n): Promise<IdxTransactionMeta> {\n  options = removeNils(options);\n  options = { ...authClient.options, ...options }; // local options override SDK options\n  // Load existing transaction meta from storage\n  const validExistingMeta = getSavedTransactionMeta(authClient, options);\n  if (validExistingMeta) {\n    return validExistingMeta;\n  }\n  // No existing? Create new transaction meta.\n  return createTransactionMeta(authClient, options);\n}\n\nexport function saveTransactionMeta (authClient: OktaAuthIdxInterface, meta): void {\n  authClient.transactionManager.save(meta, { muteWarning: true });\n}\n\nexport function clearTransactionMeta (authClient: OktaAuthIdxInterface): void {\n  authClient.transactionManager.clear();\n}\n\nexport function isTransactionMetaValid (meta, options: IdxTransactionMetaOptions  = {}): boolean {\n  // Validate against certain options. If these exist in options, they must match in meta\n  const keys = [\n    'issuer',\n    'clientId',\n    'redirectUri',\n    'state',\n    'codeChallenge',\n    'codeChallengeMethod',\n    'activationToken',\n    'recoveryToken'\n  ];\n  if (isTransactionMetaValidForOptions(meta, options, keys) === false) {\n    return false;\n  }\n\n  // Validate configured flow\n  const { flow } = options;\n  if (isTransactionMetaValidForFlow(meta, flow) === false) {\n    return false;\n  }\n\n  return true;\n}\n\nexport function isTransactionMetaValidForFlow(meta, flow) {\n  // Specific flows should not share transaction data\n  const shouldValidateFlow = flow && flow !== 'default' && flow !== 'proceed';\n  if (shouldValidateFlow) {\n    if (flow !== meta.flow) {\n      // The flow has changed; abandon the old transaction\n      return false;\n    }\n  }\n  return true;\n}\n\nexport function isTransactionMetaValidForOptions(meta, options, keys) {\n  // returns false if values in meta do not match options\n  // if the option does not have a value for a specific key, it is ignored\n  const mismatch = keys.some(key => {\n    const value = options[key];\n    if (value && value !== meta[key]) {\n      return true;\n    }\n  });\n  return !mismatch;\n}\n","/*!\n * Copyright (c) 2021-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\nimport { APIError } from '../../errors/types';\nimport {\n  OktaAuthOAuthInterface,\n  MinimalOktaOAuthInterface,\n  Tokens,\n  TransactionManagerConstructor,\n  TransactionManagerInterface\n} from '../../oidc/types';\nimport { FlowIdentifier } from './FlowIdentifier';\nimport {\n  IdxActions,\n  IdxAuthenticator,\n  IdxContext,\n  IdxForm,\n  IdxMessage,\n  IdxOption,\n  IdxRemediation,\n  IdxResponse,\n  RawIdxResponse,\n  IdxActionParams,\n  IdpConfig,\n  IdxToPersist,\n  ChallengeData,\n  ActivationData,\n} from './idx-js';\nimport {\n  AccountUnlockOptions,\n  AuthenticationOptions,\n  CancelOptions,\n  InteractOptions,\n  IntrospectOptions,\n  OktaAuthIdxOptions,\n  PasswordRecoveryOptions,\n  ProceedOptions,\n  RegistrationOptions,\n  StartOptions,\n  IdxTransactionMetaOptions\n} from './options';\nimport { IdxTransactionMeta } from './meta';\nimport { IdxStorageManagerInterface, SavedIdxResponse } from './storage';\nimport type {\n  WebauthnEnrollValues,\n  WebauthnVerificationValues\n} from '../authenticator';\nimport { OktaAuthConstructor, FingerprintAPI } from '../../base/types';\n\nexport enum IdxStatus {\n  SUCCESS = 'SUCCESS',\n  PENDING = 'PENDING',\n  FAILURE = 'FAILURE',\n  TERMINAL = 'TERMINAL',\n  CANCELED = 'CANCELED',\n}\n\nexport enum AuthenticatorKey {\n  OKTA_PASSWORD = 'okta_password',\n  OKTA_EMAIL = 'okta_email',\n  PHONE_NUMBER = 'phone_number',\n  GOOGLE_AUTHENTICATOR = 'google_otp',\n  SECURITY_QUESTION = 'security_question',\n  OKTA_VERIFY = 'okta_verify',\n  WEBAUTHN = 'webauthn',\n}\n\nexport type Input = {\n  name: string;\n  key?: string;\n  type?: string;\n  label?: string;\n  value?: string | {form: IdxForm} | Input[];\n  minLength?: number;\n  maxLength?: number;\n  secret?: boolean;\n  required?: boolean;\n  options?: IdxOption[];\n  mutable?: boolean;\n  visible?: boolean;\n  customLabel?: boolean\n}\n\n\nexport interface IdxPollOptions {\n  required?: boolean;\n  refresh?: number;\n}\n\nexport type NextStep = {\n  name: string;\n  authenticator?: IdxAuthenticator;\n  canSkip?: boolean;\n  canResend?: boolean;\n  inputs?: Input[];\n  poll?: IdxPollOptions;\n  authenticatorEnrollments?: IdxAuthenticator[];\n  // eslint-disable-next-line no-use-before-define\n  action?: (params?: IdxActionParams) => Promise<IdxTransaction>;\n  idp?: IdpConfig;\n  href?: string;\n  relatesTo?: {\n    type?: string;\n    value: IdxAuthenticator;\n  };\n  refresh?: number;\n}\n\nexport enum IdxFeature {\n  PASSWORD_RECOVERY = 'recover-password',\n  REGISTRATION = 'enroll-profile',\n  SOCIAL_IDP = 'redirect-idp',\n  ACCOUNT_UNLOCK = 'unlock-account',\n}\n\n\nexport interface IdxTransaction {\n  status: IdxStatus;\n  tokens?: Tokens;\n  nextStep?: NextStep;\n  messages?: IdxMessage[];\n  error?: APIError | IdxResponse;\n  meta?: IdxTransactionMeta;\n  enabledFeatures?: IdxFeature[];\n  availableSteps?: NextStep[];\n  requestDidSucceed?: boolean;\n  stepUp?: boolean;\n  \n  // from idx-js, used by signin widget\n  proceed: (remediationName: string, params: unknown) => Promise<IdxResponse>;\n  neededToProceed: IdxRemediation[];\n  rawIdxState: RawIdxResponse;\n  interactionCode?: string;\n  actions: IdxActions;\n  context: IdxContext;\n}\n\n\nexport type Authenticator = {\n  id?: string;\n  key?: string;\n  methodType?: string;\n  phoneNumber?: string;\n  channel?: string;\n};\n\nexport function isAuthenticator(obj: any): obj is Authenticator {\n  return obj && (obj.key || obj.id);\n}\n\nexport interface RemediationResponse {\n  idxResponse: IdxResponse;\n  nextStep?: NextStep;\n  messages?: IdxMessage[];\n  terminal?: boolean;\n  canceled?: boolean;\n}\n\nexport interface InteractResponse {\n  state?: string;\n  interactionHandle: string;\n  meta: IdxTransactionMeta;\n}\n\nexport interface EmailVerifyCallbackResponse {\n  state: string;\n  otp: string;\n}\n\nexport interface MinimalIdxAPI {\n  // lowest level api\n  makeIdxResponse: (rawIdxResponse: RawIdxResponse, toPersist: IdxToPersist, requestDidSucceed: boolean) => IdxResponse;\n\n  // flow control\n  start: (options?: StartOptions) => Promise<IdxTransaction>;\n  canProceed(options?: ProceedOptions): boolean;\n  proceed: (options?: ProceedOptions) => Promise<IdxTransaction>;\n\n  // call `start` instead of `startTransaction`. `startTransaction` will be removed in next major version (7.0)\n  startTransaction: (options?: StartOptions) => Promise<IdxTransaction>;\n\n  // transaction meta\n  getSavedTransactionMeta: (options?: IdxTransactionMetaOptions) => IdxTransactionMeta | undefined;\n  createTransactionMeta: (options?: IdxTransactionMetaOptions) => Promise<IdxTransactionMeta>;\n  getTransactionMeta: (options?: IdxTransactionMetaOptions) => Promise<IdxTransactionMeta>;\n  saveTransactionMeta: (meta: unknown) => void;\n  clearTransactionMeta: () => void;\n  isTransactionMetaValid: (meta: unknown) => boolean;\n}\n\nexport interface IdxAPI {\n  // lowest level api\n  interact: (options?: InteractOptions) => Promise<InteractResponse>;\n  introspect: (options?: IntrospectOptions) => Promise<IdxResponse>;\n  makeIdxResponse: (rawIdxResponse: RawIdxResponse, toPersist: IdxToPersist, requestDidSucceed: boolean) => IdxResponse;\n\n  // flow entrypoints\n  authenticate: (options?: AuthenticationOptions) => Promise<IdxTransaction>;\n  register: (options?: RegistrationOptions) => Promise<IdxTransaction>;\n  recoverPassword: (options?: PasswordRecoveryOptions) => Promise<IdxTransaction>;\n  unlockAccount: (options?: AccountUnlockOptions) => Promise<IdxTransaction>;\n  poll: (options?: IdxPollOptions) => Promise<IdxTransaction>;\n\n  // flow control\n  start: (options?: StartOptions) => Promise<IdxTransaction>;\n  canProceed(options?: ProceedOptions): boolean;\n  proceed: (options?: ProceedOptions) => Promise<IdxTransaction>;\n  cancel: (options?: CancelOptions) => Promise<IdxTransaction>;\n  getFlow(): FlowIdentifier | undefined;\n  setFlow(flow: FlowIdentifier): void;\n\n  // call `start` instead of `startTransaction`. `startTransaction` will be removed in next major version (7.0)\n  startTransaction: (options?: StartOptions) => Promise<IdxTransaction>;\n\n  // redirect callbacks\n  isInteractionRequired: (hashOrSearch?: string) => boolean;\n  isInteractionRequiredError: (error: Error) => boolean; \n  handleInteractionCodeRedirect: (url: string) => Promise<void>;\n  isEmailVerifyCallback: (search: string) => boolean;\n  parseEmailVerifyCallback: (search: string) => EmailVerifyCallbackResponse;\n  handleEmailVerifyCallback: (search: string) => Promise<IdxTransaction | undefined>;\n  isEmailVerifyCallbackError: (error: Error) => boolean;\n\n  // transaction meta\n  getSavedTransactionMeta: (options?: IdxTransactionMetaOptions) => IdxTransactionMeta | undefined;\n  createTransactionMeta: (options?: IdxTransactionMetaOptions) => Promise<IdxTransactionMeta>;\n  getTransactionMeta: (options?: IdxTransactionMetaOptions) => Promise<IdxTransactionMeta>;\n  saveTransactionMeta: (meta: unknown) => void;\n  clearTransactionMeta: () => void;\n  isTransactionMetaValid: (meta: unknown) => boolean;\n}\n\nexport interface IdxTransactionManagerInterface extends TransactionManagerInterface {\n  saveIdxResponse(data: SavedIdxResponse): void;\n  loadIdxResponse(options?: IntrospectOptions): SavedIdxResponse | null;\n  clearIdxResponse(): void;\n}\n\nexport type IdxTransactionManagerConstructor = TransactionManagerConstructor<IdxTransactionManagerInterface>;\n\nexport interface WebauthnAPI {\n  getAssertion(credential: PublicKeyCredential): WebauthnVerificationValues;\n  getAttestation(credential: PublicKeyCredential): WebauthnEnrollValues;\n  buildCredentialRequestOptions(\n    challengeData: ChallengeData, authenticatorEnrollments: IdxAuthenticator[]\n  ): CredentialRequestOptions;\n  buildCredentialCreationOptions(\n    activationData: ActivationData, authenticatorEnrollments: IdxAuthenticator[]\n  ): CredentialCreationOptions;\n}\n\n\nexport interface OktaAuthIdxInterface\n<\n  M extends IdxTransactionMeta = IdxTransactionMeta,\n  S extends IdxStorageManagerInterface<M> = IdxStorageManagerInterface<M>,\n  O extends OktaAuthIdxOptions = OktaAuthIdxOptions,\n  TM extends IdxTransactionManagerInterface = IdxTransactionManagerInterface\n>\n  extends OktaAuthOAuthInterface<M, S, O, TM>\n{\n  idx: IdxAPI;\n  fingerprint: FingerprintAPI;\n}\n\nexport interface MinimalOktaAuthIdxInterface\n<\n  M extends IdxTransactionMeta = IdxTransactionMeta,\n  S extends IdxStorageManagerInterface<M> = IdxStorageManagerInterface<M>,\n  O extends OktaAuthIdxOptions = OktaAuthIdxOptions,\n  TM extends IdxTransactionManagerInterface = IdxTransactionManagerInterface\n>\n  extends MinimalOktaOAuthInterface<M, S, O, TM>\n{\n  idx: MinimalIdxAPI;\n  fingerprint: FingerprintAPI;\n}\n\nexport interface OktaAuthIdxConstructor\n<\n  I extends MinimalOktaAuthIdxInterface = OktaAuthIdxInterface\n>\n extends OktaAuthConstructor<I>\n{\n  new(...args: any[]): I;\n  webauthn: WebauthnAPI;\n}\n","/* eslint-disable no-use-before-define */\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\nimport { Input } from './api';\n\n\n// TODO: remove when idx-js provides type information\n\nexport interface ChallengeData {\n  challenge: string; \n  userVerification: string; \n  extensions?: {\n    appid: string;\n  };\n}\nexport interface ActivationData {\n  challenge: string;\n  rp: {\n    name: string;\n  };\n  user: {\n    id: string;\n    name: string;\n    displayName: string;\n  };\n  pubKeyCredParams: {\n    type: string;\n    alg: number;\n  }[];\n  attestation?: string;\n  authenticatorSelection?: {\n    userVerification?: string;\n    authenticatorAttachment?: string;\n    requireResidentKey?: boolean;\n    residentKey?: string;\n  };\n  excludeCredentials?: {\n    id: string;\n    type: string;\n  }[];\n}\nexport interface IdxAuthenticatorMethod {\n  type: string;\n}\nexport interface IdxAuthenticator {\n  displayName: string;\n  id: string;\n  key: string;\n  methods: IdxAuthenticatorMethod[];\n  type: string;\n  settings?: {\n    complexity?: unknown;\n    age?: unknown;\n  };\n  contextualData?: {\n    enrolledQuestion?: {\n      question: string;\n      questionKey: string;\n    };\n    qrcode?: { \n      href: string; \n      method: string; \n      type: string; \n    };\n    sharedSecret?: string;\n    questions?: {\n      questionKey: string;\n      question: string;\n    }[];\n    questionKeys?: string[];\n    selectedChannel?: string;\n    activationData?: ActivationData;\n    challengeData?: ChallengeData;\n  };\n  credentialId?: string;\n  enrollmentId?: string;\n  profile?: Record<string, unknown>;\n  resend?: Record<string, unknown>;\n  poll?: Record<string, unknown>;\n  recover?: Record<string, unknown>;\n  deviceKnown?: boolean;\n  nickname?: string;\n}\n\nexport interface IdxForm {\n  value: IdxRemediationValue[];\n}\n\nexport interface IdxOption {\n  value: string | {form: IdxForm} | Input[];\n  label: string;\n  relatesTo?: IdxAuthenticator;\n}\n\nexport interface IdpConfig {\n  id: string;\n  name: string;\n}\n\nexport interface IdxRemediationValueForm {\n  form: IdxForm;\n}\n\nexport interface IdxRemediationValue {\n  name: string;\n  type?: string;\n  required?: boolean;\n  secret?: boolean;\n  visible?: boolean;\n  mutable?: boolean;\n  value?: string | IdxRemediationValueForm;\n  label?: string;\n  form?: IdxForm;\n  options?: IdxOption[];\n  messages?: IdxMessages;\n  minLength?: number;\n  maxLength?: number;\n  relatesTo?: {\n    type?: string;\n    value: IdxAuthenticator;\n  };\n}\n\nexport interface IdxRemediation {\n  name: string;\n  label?: string;\n  value?: IdxRemediationValue[];\n  relatesTo?: {\n    type?: string;\n    value: IdxAuthenticator;\n  };\n  idp?: IdpConfig;\n  href?: string;\n  method?: string;\n  type?: string;\n  accepts?: string;\n  produces?: string;\n  refresh?: number;\n  rel?: string[];\n  action?: (payload?: IdxActionParams) => Promise<IdxResponse>;\n}\n\nexport interface IdxContext {\n  version: string;\n  stateHandle: string;\n  expiresAt: string;\n  intent: string;\n  currentAuthenticator: {\n    type: string;\n    value: IdxAuthenticator;\n  };\n  currentAuthenticatorEnrollment: {\n    type: string;\n    value: IdxAuthenticator;\n  };\n  authenticators: {\n    type: string;\n    value: IdxAuthenticator[];\n  };\n  authenticatorEnrollments: {\n    type: string;\n    value: IdxAuthenticator[];\n  };\n  enrollmentAuthenticator: {\n    type: string;\n    value: IdxAuthenticator;\n  };\n  user?: {\n    type: string;\n    value: Record<string, unknown>;\n  };\n  uiDisplay?: IdxContextUIDisplay\n  app: {\n    type: string;\n    value: Record<string, unknown>;\n  };\n  messages?: IdxMessages;\n  success?: IdxRemediation;\n  failure?: IdxRemediation;\n}\n\nexport interface IdxContextUIDisplay {\n  type: string;\n  value: {\n    label?: string;\n    buttonLabel?: string;\n  }\n}\n\nexport interface IdxMessage {\n  message: string;\n  class: string;\n  i18n: {\n    key: string;\n    params?: unknown[];\n  };\n}\n\nexport interface IdxMessages {\n  type: 'array';\n  value: IdxMessage[];\n}\n\n// JSON response from the server\nexport interface RawIdxResponse {\n  version: string;\n  stateHandle: string;\n  intent?: string;\n  expiresAt?: string;\n  remediation?: {\n    type: 'array';\n    value: IdxRemediation[];\n  };\n  messages?: IdxMessages;\n  success?: boolean;\n  successWithInteractionCode?: IdxRemediation;\n  currentAuthenticator?: {\n    type: string;\n    value: IdxAuthenticator;\n  };\n  currentAuthenticatorEnrollment?: {\n    type: string;\n    value: IdxAuthenticator;\n  };\n}\n\nexport function isRawIdxResponse(obj: any): obj is RawIdxResponse {\n  return obj && obj.version;\n}\n\nexport interface IdxActionParams {\n  [key: string]: string | boolean | number | object;\n}\n\nexport interface IdxActions {\n  [key: string]: (params?: IdxActionParams) => Promise<IdxResponse>;\n}\n\nexport interface IdxToPersist {\n  interactionHandle?: string;\n  withCredentials?: boolean;\n}\n\nexport interface IdxActionFunction {\n  (params: IdxActionParams): Promise<IdxResponse>;\n  neededParams?: Array<Array<IdxRemediationValue>>;\n}\n\nexport interface IdxResponse {\n  proceed: (remediationName: string, params: unknown) => Promise<IdxResponse>;\n  neededToProceed: IdxRemediation[];\n  rawIdxState: RawIdxResponse;\n  interactionCode?: string;\n  actions: IdxActions;\n  toPersist: IdxToPersist;\n  context?: IdxContext;\n  requestDidSucceed?: boolean;\n  stepUp?: boolean;\n}\n\nexport function isIdxResponse(obj: any): obj is IdxResponse {\n  return obj && isRawIdxResponse(obj.rawIdxState);\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\nexport * from './api';\nexport * from './options';\nexport type {\n  IdxMessage,\n  IdxMessages,\n  ChallengeData,\n  ActivationData,\n  IdxResponse,\n  IdxContext,\n  RawIdxResponse,\n  IdxRemediation,\n  IdxAuthenticator,\n  IdxActionParams,\n  IdxContextUIDisplay,\n\n} from './idx-js';\nexport * from './meta';\nexport type { FlowIdentifier } from './FlowIdentifier';\nexport type { FlowSpecification } from './FlowSpecification';\nexport type { WebauthnEnrollValues } from '../authenticator/WebauthnEnrollment';\nexport type { WebauthnVerificationValues } from '../authenticator/WebauthnVerification';\nexport * from './storage';\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\nimport { run } from './run';\nimport { hasSavedInteractionHandle } from './transactionMeta';\nimport { startTransaction } from './startTransaction';\nimport { AuthSdkError } from '../errors';\nimport { \n  OktaAuthIdxInterface, \n  AccountUnlockOptions, \n  IdxTransaction,\n  IdxFeature,\n} from './types';\n\nexport async function unlockAccount(\n  authClient: OktaAuthIdxInterface, options: AccountUnlockOptions = {}\n): Promise<IdxTransaction> {\n  options.flow = 'unlockAccount';\n\n  // Only check at the beginning of the transaction\n  if (!hasSavedInteractionHandle(authClient)) {\n    const { enabledFeatures } = await startTransaction(authClient, { ...options, autoRemediate: false });\n    if (enabledFeatures && !enabledFeatures.includes(IdxFeature.ACCOUNT_UNLOCK)) {\n      throw new AuthSdkError(\n        'Self Service Account Unlock is not supported based on your current org configuration.'\n      );\n    }\n  }\n\n  return run(authClient, { ...options });\n}\n","import { warn, split2 } from '../util';\nimport { RemediationValues, Remediator, RemediatorConstructor } from './remediators';\nimport { GenericRemediator } from './remediators/GenericRemediator';\nimport {\n  OktaAuthIdxInterface,\n  IdxFeature,\n  NextStep,\n  RemediateOptions,\n  RemediationResponse,\n  RunOptions,\n  FlowIdentifier,\n  FlowSpecification\n} from './types';\nimport { IdxMessage, IdxRemediation, IdxRemediationValue, IdxResponse } from './types/idx-js';\n\ntype GetFlowSpecification = (\n  oktaAuth: OktaAuthIdxInterface,\n  flow: FlowIdentifier\n) => FlowSpecification;\n\nconst ctx: {\n  remediators: Record<string, RemediatorConstructor>,\n  getFlowSpecification: GetFlowSpecification,\n} = {\n  // default values to be used by minimal IDX API\n  remediators: {},\n  getFlowSpecification: function(_oktaAuth: OktaAuthIdxInterface, _flow: FlowIdentifier = 'default') {\n    return {\n      remediators: {}\n    } as FlowSpecification;\n  }\n};\n\n// should be set in createIdxAPI() factory\nexport function setRemediatorsCtx(newCtx: Partial<typeof ctx>) {\n  Object.assign(ctx, newCtx);\n}\n\nexport function getFlowSpecification(oktaAuth: OktaAuthIdxInterface, flow: FlowIdentifier = 'default') {\n  return ctx.getFlowSpecification(oktaAuth, flow);\n}\n\nexport function isTerminalResponse(idxResponse: IdxResponse) {\n  const { neededToProceed, interactionCode } = idxResponse;\n  return !neededToProceed.length && !interactionCode;\n}\n\nexport function canSkipFn(idxResponse: IdxResponse) {\n  return idxResponse.neededToProceed.some(({ name }) => name === 'skip');\n}\n\nexport function canResendFn(idxResponse: IdxResponse) {\n  return Object.keys(idxResponse.actions).some(actionName => actionName.includes('resend'));\n}\n\nexport function getMessagesFromIdxRemediationValue(\n  value?: IdxRemediationValue[]\n): IdxMessage[] | undefined {\n  if (!value || !Array.isArray(value)) {\n    return;\n  }\n  return value.reduce((messages, value) => {\n    if (value.messages) {\n      messages = [...messages, ...value.messages.value] as never;\n    }\n    if (value.form) {\n      const messagesFromForm = getMessagesFromIdxRemediationValue(value.form.value) || [];\n      messages = [...messages, ...messagesFromForm] as never;\n    } \n    if (value.options) {\n      let optionValues = [];\n      value.options.forEach(option => {\n        if (!option.value || typeof option.value === 'string') {\n          return;\n        }\n        optionValues = [...optionValues, option.value] as never;\n      });\n      const messagesFromOptions = getMessagesFromIdxRemediationValue(optionValues) || [];\n      messages = [...messages, ...messagesFromOptions] as never;\n    }\n    return messages;\n  }, []);\n}\n\nexport function getMessagesFromResponse(idxResponse: IdxResponse, options: RunOptions): IdxMessage[] {\n  let messages: IdxMessage[] = [];\n  const { rawIdxState, neededToProceed } = idxResponse;\n\n  // Handle global messages\n  const globalMessages = rawIdxState.messages?.value.map(message => message);\n  if (globalMessages) {\n    messages = [...messages, ...globalMessages] as never;\n  }\n\n  // Handle field messages for current flow\n  // Preserve existing logic for general cases, remove in the next major version\n  // Follow ion response format for top level messages when useGenericRemediator is true\n  if (!options.useGenericRemediator) {\n    for (let remediation of neededToProceed) {\n      const fieldMessages = getMessagesFromIdxRemediationValue(remediation.value);\n      if (fieldMessages) {\n        messages = [...messages, ...fieldMessages] as never;\n      }\n    }\n  }\n\n  // API may return identical error on same field, filter by i18n key\n  const seen = {};\n  messages = messages.reduce((filtered, message) => {\n    const key = message.i18n?.key;\n    if (key && seen[key] && message.message === seen[key].message) {\n      return filtered;\n    }\n    seen[key] = message;\n    filtered = [...filtered, message] as never;\n    return filtered;\n  }, []);\n\n  return messages;\n}\n\n\nexport function getEnabledFeatures(idxResponse: IdxResponse): IdxFeature[] {\n  const res = [];\n  const { actions, neededToProceed } = idxResponse;\n\n  if (actions['currentAuthenticator-recover']) {\n    res.push(IdxFeature.PASSWORD_RECOVERY as never);\n  }\n\n  if (neededToProceed.some(({ name }) => name === 'select-enroll-profile')) {\n    res.push(IdxFeature.REGISTRATION as never);\n  }\n\n  if (neededToProceed.some(({ name }) => name === 'redirect-idp')) {\n    res.push(IdxFeature.SOCIAL_IDP as never);\n  }\n\n  if (neededToProceed.some(({ name }) => name === 'unlock-account')) {\n    res.push(IdxFeature.ACCOUNT_UNLOCK as never);\n  }\n\n  return res;\n}\n\nexport function getAvailableSteps(\n  authClient: OktaAuthIdxInterface, \n  idxResponse: IdxResponse, \n  useGenericRemediator?: boolean\n): NextStep[] {\n  const res: NextStep[] = [];\n\n  const remediatorMap: Record<string, RemediatorConstructor> = Object.values(ctx.remediators)\n    .reduce((map, remediatorClass) => {\n      // Only add concrete subclasses to the map\n      if (remediatorClass.remediationName) {\n        map[remediatorClass.remediationName] = remediatorClass;\n      }\n      return map;\n    }, {});\n\n  for (let remediation of idxResponse.neededToProceed) {\n    const T = getRemediatorClass(remediation, { useGenericRemediator, remediators: remediatorMap });\n    if (T) {\n      const remediator: Remediator = new T(remediation);\n      res.push (remediator.getNextStep(authClient, idxResponse.context) as never);\n    }\n  }\n\n  for (const [name] of Object.entries((idxResponse.actions || {}))) {\n    let stepObj = {\n      name, \n      action: async (params?) => {\n        return authClient.idx.proceed({ \n          actions: [{ name, params }] \n        });\n      }\n    };\n    if (name.startsWith('currentAuthenticator')) {\n      const [part1, part2] = split2(name, '-');\n      const actionObj = idxResponse.rawIdxState[part1].value[part2];\n      /* eslint-disable no-unused-vars, @typescript-eslint/no-unused-vars */\n      const {\n        href, \n        method, \n        rel, \n        accepts, \n        produces, \n        ...rest\n      } = actionObj;\n      /* eslint-enable no-unused-vars, @typescript-eslint/no-unused-vars */\n      const value = actionObj.value?.filter(item => item.name !== 'stateHandle');\n      stepObj = { \n        ...rest,  \n        ...(value && { value }),\n        ...stepObj,\n      };\n    }\n    res.push(stepObj);\n  }\n\n  return res;\n}\n\nexport function filterValuesForRemediation(\n  idxResponse: IdxResponse,\n  remediationName: string,\n  values: RemediationValues\n): RemediationValues {\n  const remediations = idxResponse.neededToProceed || [];\n  const remediation = remediations.find(r => r.name === remediationName);\n  if (!remediation) {\n    // step was specified, but remediation was not found. This is unexpected!\n    warn(`filterValuesForRemediation: \"${remediationName}\" did not match any remediations`);\n    return values;\n  }\n\n  // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n  const valuesForRemediation = remediation.value!.reduce((res, entry) => {\n    const { name, value } = entry;\n    if (name === 'stateHandle') {\n      res[name] = value; // use the stateHandle value in the remediation\n    } else {\n      res[name] = values[name]; // use the value provided by the caller\n    }\n    return res;\n  }, {});\n  return valuesForRemediation;\n}\n\nfunction getRemediatorClass(remediation: IdxRemediation, options: RemediateOptions) {\n  const { useGenericRemediator, remediators } = options;\n  \n  if (!remediation) {\n    return undefined;\n  }\n\n  if (useGenericRemediator) {\n    return GenericRemediator;\n  }\n\n  // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n  return remediators![remediation.name];\n}\n\n// Return first match idxRemediation in allowed remediators\n// eslint-disable-next-line complexity\nexport function getRemediator(\n  idxResponse: IdxResponse,\n  values: RemediationValues,\n  options: RemediateOptions,\n): Remediator | undefined {\n  // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n  const remediators = options.remediators!;\n  const useGenericRemediator = options.useGenericRemediator;\n  const {neededToProceed: idxRemediations, context} = idxResponse;\n\n  let remediator: Remediator;\n  // remediation name specified by caller - fast-track remediator lookup \n  if (options.step) {\n    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n    const remediation = idxRemediations.find(({ name }) => name === options.step)!;\n    if (remediation) {\n      const T = getRemediatorClass(remediation, options);\n      return T ? new T(remediation, values, options) : undefined;\n    } else {\n      // step was specified, but remediation was not found. This is unexpected!\n      warn(`step \"${options.step}\" did not match any remediations`);\n      return;\n    }\n  }\n\n  const remediatorCandidates: Remediator[] = [];\n  if (useGenericRemediator) {\n    // always pick the first remediation for when use GenericRemediator\n    remediatorCandidates.push(new GenericRemediator(idxRemediations[0], values, options));\n  } else {\n    for (let remediation of idxRemediations) {\n      const isRemeditionInFlow = Object.keys(remediators as object).includes(remediation.name);\n      if (!isRemeditionInFlow) {\n        continue;\n      }\n\n      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n      const T = getRemediatorClass(remediation, options)!;\n      remediator = new T(remediation, values, options);\n      if (remediator.canRemediate(context)) {\n        // found the remediator\n        return remediator;\n      }\n      // remediator cannot handle the current values\n      // maybe return for next step\n      remediatorCandidates.push(remediator);  \n    }\n  }\n  \n  return remediatorCandidates[0];\n}\n\n\nexport function getNextStep(\n  authClient: OktaAuthIdxInterface, remediator: Remediator, idxResponse: IdxResponse\n): NextStep {\n  const nextStep = remediator.getNextStep(authClient, idxResponse.context);\n  const canSkip = canSkipFn(idxResponse);\n  const canResend = canResendFn(idxResponse);\n  return {\n    ...nextStep,\n    ...(canSkip && {canSkip}),\n    ...(canResend && {canResend}),\n  };\n}\n\nexport function handleFailedResponse(\n  authClient: OktaAuthIdxInterface,\n  idxResponse: IdxResponse,\n  options = {}\n): RemediationResponse {\n  const terminal = isTerminalResponse(idxResponse);\n  const messages = getMessagesFromResponse(idxResponse, options);\n  if (terminal) {\n    return { idxResponse, terminal, messages };\n  } else {\n    const remediator = getRemediator(idxResponse, {}, options);\n    const nextStep = remediator && getNextStep(authClient, remediator, idxResponse);\n    return {\n      idxResponse,\n      messages,\n      ...(nextStep && { nextStep }),\n    };\n  }\n  \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\nimport { base64UrlToBuffer, bufferToBase64Url } from '../crypto/base64';\nimport {\n  ActivationData,\n  ChallengeData,\n  IdxAuthenticator,\n} from './types';\n\n\n// Get known credentials from list of enrolled authenticators\nconst getEnrolledCredentials = (authenticatorEnrollments: IdxAuthenticator[] = []) => {\n  const credentials: PublicKeyCredentialDescriptor[] = [];\n  authenticatorEnrollments.forEach((enrollement) => {\n    if (enrollement.key === 'webauthn') {\n      credentials.push({\n        type: 'public-key',\n        id: base64UrlToBuffer(enrollement.credentialId),\n      });\n    }\n  });\n  return credentials;\n};\n\n// Build options for navigator.credentials.create\n// https://developer.mozilla.org/en-US/docs/Web/API/CredentialsContainer/create\nexport const buildCredentialCreationOptions = (\n  activationData: ActivationData, authenticatorEnrollments: IdxAuthenticator[]\n) => {\n  return {\n    publicKey: {\n      rp: activationData.rp,\n      user: {\n        id: base64UrlToBuffer(activationData.user.id),\n        name: activationData.user.name,\n        displayName: activationData.user.displayName\n      },\n      challenge: base64UrlToBuffer(activationData.challenge),\n      pubKeyCredParams: activationData.pubKeyCredParams,\n      attestation: activationData.attestation,\n      authenticatorSelection: activationData.authenticatorSelection,\n      excludeCredentials: getEnrolledCredentials(authenticatorEnrollments),\n    }\n  } as CredentialCreationOptions;\n};\n\n\n// Build options for navigator.credentials.get\n// https://developer.mozilla.org/en-US/docs/Web/API/CredentialsContainer/get\nexport const buildCredentialRequestOptions = (\n  challengeData: ChallengeData, authenticatorEnrollments: IdxAuthenticator[]\n) => {\n  return {\n    publicKey: {\n      challenge: base64UrlToBuffer(challengeData.challenge),\n      userVerification: challengeData.userVerification,\n      allowCredentials: getEnrolledCredentials(authenticatorEnrollments),\n    }\n  } as CredentialRequestOptions;\n};\n\n// Build attestation for webauthn enroll\n// https://developer.mozilla.org/en-US/docs/Web/API/AuthenticatorAttestationResponse\nexport const getAttestation = (credential: PublicKeyCredential) => {\n  const response = credential.response as AuthenticatorAttestationResponse;\n  const id = credential.id;\n  const clientData = bufferToBase64Url(response.clientDataJSON);\n  const attestation = bufferToBase64Url(response.attestationObject);\n  return {\n    id,\n    clientData,\n    attestation\n  };\n};\n\n// Build assertion for webauthn verification\n// https://developer.mozilla.org/en-US/docs/Web/API/AuthenticatorAssertionResponse\nexport const getAssertion = (credential: PublicKeyCredential) => {\n  const response = credential.response as AuthenticatorAssertionResponse;\n  const id = credential.id;\n  const clientData = bufferToBase64Url(response.clientDataJSON);\n  const authenticatorData = bufferToBase64Url(response.authenticatorData);\n  const signatureData = bufferToBase64Url(response.signature);\n  return {\n    id,\n    clientData,\n    authenticatorData,\n    signatureData\n  };\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// exports all public methods from myaccount module\n\nexport * from './profileApi';\nexport * from './emailApi';\nexport * from './phoneApi';\nexport * from './passwordApi';","import { sendRequest } from './request';\nimport { IAPIFunction } from './types';\nimport {\n  BaseTransaction, \n  EmailTransaction, \n  EmailChallengeTransaction \n} from './transactions';\n\n/**\n * @scope: okta.myAccount.email.read\n */\nexport const getEmails: IAPIFunction<EmailTransaction[]> = async (\n  oktaAuth,\n  options?\n) => {\n  const transaction = await sendRequest<EmailTransaction, 'plural'>(oktaAuth, {\n    url: '/idp/myaccount/emails',\n    method: 'GET',\n    accessToken: options?.accessToken\n  }, EmailTransaction);\n  return transaction;\n};\n\n/**\n * @scope: okta.myAccount.email.read\n */\nexport const getEmail: IAPIFunction<EmailTransaction> = async (\n  oktaAuth, \n  options\n) => {\n  const { id, accessToken } = options!;\n  const transaction = await sendRequest(oktaAuth, {\n    url: `/idp/myaccount/emails/${id}`,\n    method: 'GET',\n    accessToken,\n  }, EmailTransaction);\n  return transaction;\n};\n\n/**\n * @scope: okta.myAccount.email.manage\n */\nexport const addEmail: IAPIFunction<EmailTransaction> = async (\n  oktaAuth, \n  options\n): Promise<EmailTransaction> => {\n  const { accessToken, payload } = options!;\n  const transaction = await sendRequest(oktaAuth, {\n    url: '/idp/myaccount/emails',\n    method: 'POST',\n    payload,\n    accessToken,\n  }, EmailTransaction);\n  return transaction;\n};\n\n/**\n * @scope: okta.myAccount.email.manage\n */\nexport const deleteEmail: IAPIFunction<BaseTransaction> = async (\n  oktaAuth, \n  options\n) => {\n  const { id, accessToken } = options!;\n  const transaction = await sendRequest(oktaAuth, {\n    url: `/idp/myaccount/emails/${id}`,\n    method: 'DELETE',\n    accessToken\n  });\n  return transaction;\n};\n\n/**\n * @scope: okta.myAccount.email.read\n */\nexport const sendEmailChallenge: IAPIFunction<EmailChallengeTransaction> = async (\n  oktaAuth, \n  options\n) => {\n  const { id, accessToken } = options!;\n  const transaction = await sendRequest(oktaAuth, {\n    url: `/idp/myaccount/emails/${id}/challenge`,\n    method: 'POST',\n    accessToken,\n  }, EmailChallengeTransaction);\n  return transaction;\n};\n\n/**\n * @scope: okta.myAccount.email.read\n */\nexport const getEmailChallenge: IAPIFunction<EmailChallengeTransaction> = async (\n  oktaAuth, \n  options\n) => {\n  const { emailId, challengeId, accessToken } = options!;\n  const transaction = await sendRequest(oktaAuth, {\n    url: `/idp/myaccount/emails/${emailId}/challenge/${challengeId}`,\n    method: 'POST',\n    accessToken,\n  }, EmailChallengeTransaction);\n  return transaction;\n};\n\n/**\n * @scope: okta.myAccount.email.manage\n */\nexport const verifyEmailChallenge: IAPIFunction<BaseTransaction> = async (\n  oktaAuth,\n  options\n) => {\n  const { emailId, challengeId, payload, accessToken } = options!;\n  const transaction = await sendRequest(oktaAuth, {\n    url: `/idp/myaccount/emails/${emailId}/challenge/${challengeId}/verify`,\n    method: 'POST',\n    payload,\n    accessToken\n  });\n  return transaction;\n};\n","import { StorageManagerConstructor } from '../storage/types';\nimport { OktaAuthConstructor, OktaAuthOptionsConstructor } from '../base/types';\nimport {\n  OAuthStorageManagerInterface,\n  PKCETransactionMeta,\n  TransactionManagerConstructor,\n  TransactionManagerInterface\n} from '../oidc/types';\nimport { createOktaAuthCore } from '../core/factory';\nimport { OktaAuthCoreOptions } from '../core/types';\nimport { mixinMyAccount } from './mixin';\nimport { OktaAuthMyAccountInterface } from './types';\n\nexport function createOktaAuthMyAccount\n<\n  M extends PKCETransactionMeta = PKCETransactionMeta,\n  S extends OAuthStorageManagerInterface<M> = OAuthStorageManagerInterface<M>,\n  O extends OktaAuthCoreOptions = OktaAuthCoreOptions,\n  TM extends TransactionManagerInterface = TransactionManagerInterface\n>\n(\n  StorageManagerConstructor: StorageManagerConstructor<S>,\n  OptionsConstructor: OktaAuthOptionsConstructor<O>,\n  TransactionManager: TransactionManagerConstructor<TM>\n)\n: OktaAuthConstructor<OktaAuthMyAccountInterface<M, S, O>>\n{\n  const Core = createOktaAuthCore<M, S, O>(StorageManagerConstructor, OptionsConstructor, TransactionManager);\n  const WithMyAccount = mixinMyAccount<M, S, O>(Core);\n  return WithMyAccount;\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\nexport * from './api';\nexport * from './factory';\nexport * from './mixin';\nexport * from './types';\n","import { OktaAuthConstructor } from '../base/types';\nimport {\n  OAuthStorageManagerInterface,\n  OAuthTransactionMeta,\n  OktaAuthOAuthInterface,\n  OktaAuthOAuthOptions,\n  PKCETransactionMeta,\n} from '../oidc/types';\nimport { OktaAuthMyAccountInterface } from './types';\n\nimport * as MyAccountMethods from './api';\n\nexport function mixinMyAccount\n<\n  M extends OAuthTransactionMeta = PKCETransactionMeta,\n  S extends OAuthStorageManagerInterface<M> = OAuthStorageManagerInterface<M>,\n  O extends OktaAuthOAuthOptions = OktaAuthOAuthOptions,\n  TBase extends OktaAuthConstructor<OktaAuthOAuthInterface<M, S, O>>\n    = OktaAuthConstructor<OktaAuthOAuthInterface<M, S, O>>\n>\n(Base: TBase): TBase & OktaAuthConstructor<OktaAuthMyAccountInterface<M, S, O>>\n{\n  return class OktaAuthMyAccount extends Base implements OktaAuthMyAccountInterface<M, S, O>\n  {\n    myaccount: any;\n    \n    constructor(...args: any[]) {\n      super(...args);\n\n      this.myaccount = Object.entries(MyAccountMethods)\n        .filter(([ name ]) => name !== 'default')\n        .reduce((acc, [name, fn]) => {\n          acc[name] = (fn as any).bind(null, this);\n          return acc;\n        }, {});\n    }\n  };\n}\n","import { sendRequest } from './request';\nimport { IAPIFunction } from './types';\nimport {\n  BaseTransaction, \n  PasswordTransaction\n} from './transactions';\n\n/**\n * @scope: okta.myAccount.password.read\n */\nexport const getPassword: IAPIFunction<PasswordTransaction> = async (\n  oktaAuth,\n  options\n) => {\n  const transaction = await sendRequest(oktaAuth, {\n    url: `/idp/myaccount/password`,\n    method: 'GET',\n    accessToken: options?.accessToken,\n  }, PasswordTransaction);\n  return transaction;\n};\n\n/**\n * @scope: okta.myAccount.password.manage\n */\nexport const enrollPassword: IAPIFunction<PasswordTransaction> = async (\n  oktaAuth, \n  options\n): Promise<PasswordTransaction> => {\n  const { accessToken, payload } = options!;\n  const transaction = await sendRequest(oktaAuth, {\n    url: '/idp/myaccount/password',\n    method: 'POST',\n    payload,\n    accessToken,\n  }, PasswordTransaction);\n  return transaction;\n};\n\n/**\n * @scope: okta.myAccount.password.manage\n */\nexport const updatePassword: IAPIFunction<PasswordTransaction> = async (\n  oktaAuth, \n  options\n): Promise<PasswordTransaction> => {\n  const { accessToken, payload } = options!;\n  const transaction = await sendRequest(oktaAuth, {\n    url: '/idp/myaccount/password',\n    method: 'PUT',\n    payload,\n    accessToken,\n  }, PasswordTransaction);\n  return transaction;\n};\n\n/**\n * @scope: okta.myAccount.password.manage\n */\nexport const deletePassword: IAPIFunction<BaseTransaction> = async (\n  oktaAuth, \n  options?\n) => {\n  const transaction = await sendRequest(oktaAuth, {\n    url: `/idp/myaccount/password`,\n    method: 'DELETE',\n    accessToken: options?.accessToken,\n  });\n  return transaction;\n};\n","import { sendRequest } from './request';\nimport { IAPIFunction } from './types';\nimport {\n  BaseTransaction, \n  PhoneTransaction\n} from './transactions';\n\n/**\n * @scope: okta.myAccount.phone.read\n */\nexport const getPhones: IAPIFunction<PhoneTransaction[]> = async (\n  oktaAuth,\n  options?\n) => {\n  const transaction = await sendRequest<PhoneTransaction, 'plural'>(oktaAuth, {\n    url: '/idp/myaccount/phones',\n    method: 'GET',\n    accessToken: options?.accessToken,\n  }, PhoneTransaction);\n  return transaction;\n};\n\n/**\n * @scope: okta.myAccount.phone.read\n */\nexport const getPhone: IAPIFunction<PhoneTransaction> = async (\n  oktaAuth,\n  options\n) => {\n  const { accessToken, id } = options!;\n  const transaction = await sendRequest(oktaAuth, {\n    url: `/idp/myaccount/phones/${id}`,\n    method: 'GET',\n    accessToken,\n  }, PhoneTransaction);\n  return transaction;\n};\n\n/**\n * @scope: okta.myAccount.phone.manage\n */\nexport const addPhone: IAPIFunction<PhoneTransaction> = async (\n  oktaAuth, \n  options\n): Promise<PhoneTransaction> => {\n  const { accessToken, payload } = options!;\n  const transaction = await sendRequest(oktaAuth, {\n    url: '/idp/myaccount/phones',\n    method: 'POST',\n    payload,\n    accessToken,\n  }, PhoneTransaction);\n  return transaction;\n};\n\n/**\n * @scope: okta.myAccount.phone.manage\n */\nexport const deletePhone: IAPIFunction<BaseTransaction> = async (\n  oktaAuth, \n  options\n) => {\n  const { id, accessToken } = options!;\n  const transaction = await sendRequest(oktaAuth, {\n    url: `/idp/myaccount/phones/${id}`,\n    method: 'DELETE',\n    accessToken,\n  });\n  return transaction;\n};\n\n/**\n * @scope: okta.myAccount.phone.manage\n */\nexport const sendPhoneChallenge: IAPIFunction<BaseTransaction> = async (\n  oktaAuth, \n  options\n) => {\n  const { accessToken, id, payload } = options!;\n  const transaction = await sendRequest(oktaAuth, {\n    url: `/idp/myaccount/phones/${id}/challenge`,\n    method: 'POST',\n    payload,\n    accessToken\n  });\n  return transaction;\n};\n\n/**\n * @scope: okta.myAccount.phone.manage\n */\nexport const verifyPhoneChallenge: IAPIFunction<BaseTransaction> = async (\n  oktaAuth,\n  options\n) => {\n  const { id, payload, accessToken } = options!;\n  const transaction = await sendRequest(oktaAuth, {\n    url: `/idp/myaccount/phones/${id}/verify`,\n    method: 'POST',\n    payload,\n    accessToken\n  });\n  return transaction;\n};\n","import { sendRequest } from './request';\nimport { IAPIFunction } from './types';\nimport {\n  ProfileTransaction,\n  ProfileSchemaTransaction\n} from './transactions';\n\n/**\n * @scope: okta.myAccount.profile.read\n */\nexport const getProfile: IAPIFunction<ProfileTransaction> = async (oktaAuth, options?) => {\n  const transaction = await sendRequest(oktaAuth, {\n    url: '/idp/myaccount/profile',\n    method: 'GET',\n    accessToken: options?.accessToken,\n  }, ProfileTransaction);\n  return transaction;\n};\n\n/**\n * @scope: okta.myAccount.profile.manage\n */\nexport const updateProfile: IAPIFunction<ProfileTransaction> = async (\n  oktaAuth, \n  options\n) => {\n  const { payload, accessToken } = options!;\n  const transaction = await sendRequest(oktaAuth, {\n    url: '/idp/myaccount/profile',\n    method: 'PUT',\n    payload,\n    accessToken,\n  }, ProfileTransaction);\n  return transaction;\n};\n\n/**\n * @scope: okta.myAccount.profile.read\n */\nexport const getProfileSchema: IAPIFunction<ProfileSchemaTransaction> = async (\n  oktaAuth, \n  options?\n): Promise<ProfileSchemaTransaction> => {\n  const transaction = await sendRequest(oktaAuth, {\n    url: '/idp/myaccount/profile/schema',\n    method: 'GET',\n    accessToken: options?.accessToken,\n  }, ProfileSchemaTransaction);\n  return transaction;\n};\n","import { \n  default as BaseTransaction,\n  TransactionType,\n  TransactionLinks\n} from './transactions/Base';\nimport { httpRequest } from '../http';\nimport { AuthSdkError } from '../errors';\nimport { MyAccountRequestOptions as RequestOptions } from './types';\nimport { OktaAuthOAuthInterface } from '../oidc/types';\n\ntype SendRequestOptions = RequestOptions & {\n  url: string;\n  method: string;\n}\n\n/* eslint-disable complexity */\nexport async function sendRequest<\n  T extends BaseTransaction = BaseTransaction,\n  N extends 'plural' | 'single' = 'single',\n  NT = N extends 'plural' ? T[] : T\n> (\n  oktaAuth: OktaAuthOAuthInterface, \n  options: SendRequestOptions,\n  TransactionClass: TransactionType<T> = BaseTransaction as TransactionType<T>,\n): Promise<NT> {\n  const {\n    accessToken: accessTokenObj\n  } = oktaAuth.tokenManager.getTokensSync();\n  \n  const accessToken = options.accessToken || accessTokenObj?.accessToken;\n  const issuer = oktaAuth.getIssuerOrigin();\n  const { url, method, payload } = options;\n  const requestUrl = url.startsWith(issuer!) ? url : `${issuer}${url}`;\n\n  if (!accessToken) {\n    throw new AuthSdkError('AccessToken is required to request MyAccount API endpoints.');\n  }\n  \n  const res = await httpRequest(oktaAuth, {\n    headers: { 'Accept': '*/*;okta-version=1.0.0' },\n    accessToken,\n    url: requestUrl,\n    method,\n    ...(payload && { args: payload })\n  });\n\n  let ret: T | T[];\n  if (Array.isArray(res)) {\n    ret = res.map(item => new TransactionClass(oktaAuth, { \n      res: item, \n      accessToken\n    }));\n  } else {\n    ret = new TransactionClass(oktaAuth, { \n      res, \n      accessToken\n    });\n  }\n  return ret as NT;\n}\n/* eslint-enable complexity */\n\nexport type GenerateRequestFnFromLinksOptions = {\n  oktaAuth: OktaAuthOAuthInterface;\n  accessToken: string;\n  methodName: string;\n  links: TransactionLinks;\n}\n\ntype IRequestFnFromLinks<T extends BaseTransaction> = (payload?) => Promise<T>;\n\nexport function generateRequestFnFromLinks<T extends BaseTransaction>(\n  {\n    oktaAuth, \n    accessToken,\n    methodName,\n    links,\n  }: GenerateRequestFnFromLinksOptions,\n  TransactionClass: TransactionType<T> = BaseTransaction as TransactionType<T>,\n): IRequestFnFromLinks<T> {\n  for (const method of ['GET', 'POST', 'PUT', 'DELETE']) {\n    if (method.toLowerCase() === methodName) {\n      const link = links.self;\n      return (async (payload?) => sendRequest<T, 'single'>(oktaAuth, {\n        accessToken,\n        url: link.href,\n        method,\n        payload,\n      }, TransactionClass));\n    }\n  }\n  \n  const link = links[methodName];\n  if (!link) {\n    throw new AuthSdkError(`No link is found with methodName: ${methodName}`);\n  }\n\n  return (async (payload?) => sendRequest<T, 'single'>(oktaAuth, {\n    accessToken,\n    url: link.href,\n    method: link.hints!.allow![0],\n    payload,\n  }, TransactionClass));\n}\n","import { OktaAuthHttpInterface } from '../../http/types';\n\nexport type TransactionLink = {\n  href: string;\n  hints?: {\n    allow?: string[];\n  };\n}\n\nexport type TransactionLinks = {\n  self: TransactionLink;\n  [property: string]: TransactionLink;\n}\n\ntype TransactionOptions = {\n  // TODO: move res type to http module\n  res: {\n    headers: Record<string, string>;\n    _links?: Record<string, TransactionLink>;\n    [property: string]: unknown;\n  };\n  accessToken: string;\n};\n\nexport default class BaseTransaction {\n  // Deprecated\n  headers?: Record<string, string>;\n\n  constructor(oktaAuth: OktaAuthHttpInterface, options: TransactionOptions) {\n    const { res } = options;\n    const { headers, ...rest } = res;\n    \n    // assign required fields from res\n    if (headers) {\n      this.headers = headers;\n    }\n\n    // add all rest fields from res\n    Object.keys(rest).forEach(key => {\n      if (key === '_links') {\n        return;\n      }\n      this[key] = rest[key];\n    });\n  }\n}\n\nexport interface TransactionType<T extends BaseTransaction = BaseTransaction> extends Function {\n  new (oktaAuth: OktaAuthHttpInterface, options: TransactionOptions): T;\n  prototype: T;\n}\n","import EmailStatusTransaction from './EmailStatusTransaction';\nimport { \n  EmailProfile, \n  Status,\n  VerificationPayload, \n} from '../types';\nimport BaseTransaction from './Base';\nimport { generateRequestFnFromLinks } from '../request';\n\nexport default class EmailChallengeTransaction extends BaseTransaction {\n  id: string;\n  expiresAt: string;\n  profile: EmailProfile;\n  status: Status;\n\n  poll: () => Promise<EmailStatusTransaction>;\n  // eslint-disable-next-line no-use-before-define\n  verify: (payload: VerificationPayload) => Promise<EmailChallengeTransaction>;\n\n  constructor(oktaAuth, options) {\n    super(oktaAuth, options);\n\n    const { accessToken, res } = options;\n    // assign required fields from res\n    const { id, expiresAt, profile, status, _links } = res;\n    this.id = id;\n    this.expiresAt = expiresAt;\n    this.profile = profile;\n    this.status = status;\n\n    // assign transformed fns to transaction\n    this.poll = async () => {\n      const fn = generateRequestFnFromLinks({ \n        oktaAuth, \n        accessToken, \n        methodName: 'poll', \n        links: _links,\n      }, EmailStatusTransaction);\n      return await fn();\n    };\n    this.verify = async (payload) => {\n      const fn = generateRequestFnFromLinks({ \n        oktaAuth, \n        accessToken, \n        methodName: 'verify', \n        links: _links,\n      }, EmailChallengeTransaction);\n      return await fn(payload);\n    };\n  }\n}\n","import { EmailProfile, Status } from '../types';\nimport BaseTransaction from './Base';\n\nexport default class EmailStatusTransaction extends BaseTransaction {\n  id: string;\n  expiresAt: string;\n  profile: EmailProfile;\n  status: Status;\n\n  constructor(oktaAuth, options) {\n    super(oktaAuth, options);\n\n    const { res } = options;\n    // assign required fields from res\n    const { id, profile, expiresAt, status } = res;\n    this.id = id;\n    this.expiresAt = expiresAt;\n    this.profile = profile;\n    this.status = status;\n  }\n}\n","import EmailChallengeTransaction from './EmailChallengeTransaction';\nimport EmailStatusTransaction from './EmailStatusTransaction';\nimport { EmailProfile, EmailRole, Status, VerificationPayload } from '../types';\nimport BaseTransaction from './Base';\nimport { generateRequestFnFromLinks } from '../request';\n\nexport default class EmailTransaction extends BaseTransaction {\n  id: string;\n  profile: EmailProfile;\n  roles: EmailRole[];\n  status: Status;\n\n  // eslint-disable-next-line no-use-before-define\n  get: () => Promise<EmailTransaction>;\n  delete: () => Promise<BaseTransaction>;\n  challenge: () => Promise<EmailChallengeTransaction>;\n  poll?: () => Promise<EmailStatusTransaction>;\n  verify?: (payload: VerificationPayload) => Promise<BaseTransaction>;\n\n  constructor(oktaAuth, options) {\n    super(oktaAuth, options);\n\n    const { accessToken, res } = options;\n    // assign required fields from res\n    const { id, profile, roles, status, _links } = res;\n    this.id = id;\n    this.profile = profile;\n    this.roles = roles;\n    this.status = status;\n\n    // assign transformed fns to transaction\n    this.get = async () => {\n      const fn = generateRequestFnFromLinks({ \n        oktaAuth, \n        accessToken, \n        methodName: 'get', \n        links: _links,\n      }, EmailTransaction);\n      return await fn();\n    };\n    this.delete = async () => {\n      const fn = generateRequestFnFromLinks({ \n        oktaAuth, \n        accessToken, \n        methodName: 'delete', \n        links: _links \n      });\n      return await fn();\n    };\n    this.challenge = async () => {\n      const fn = generateRequestFnFromLinks({ \n        oktaAuth, \n        accessToken, \n        methodName: 'challenge', \n        links: _links,\n      }, EmailChallengeTransaction);\n      return await fn();\n    };\n    if (_links.poll) {\n      this.poll = async () => {\n        const fn = generateRequestFnFromLinks({ \n          oktaAuth, \n          accessToken, \n          methodName: 'poll', \n          links: _links,\n        }, EmailStatusTransaction);\n        return await fn();\n      };\n    }\n    if (_links.verify) {\n      this.verify = async (payload: VerificationPayload) => {\n        const fn = generateRequestFnFromLinks({ \n          oktaAuth, \n          accessToken, \n          methodName: 'verify', \n          links: _links,\n        });\n        return await fn(payload);\n      };\n    }\n  }\n}\n","import { EnrollPasswordPayload, UpdatePasswordPayload, PasswordStatus } from '../types';\nimport BaseTransaction from './Base';\nimport { generateRequestFnFromLinks } from '../request';\n\nexport default class PasswordTransaction extends BaseTransaction {\n  id: string;\n  created: string;\n  lastUpdated: string;\n  status: PasswordStatus;\n\n  // eslint-disable-next-line no-use-before-define\n  get?: () => Promise<PasswordTransaction>;\n  // eslint-disable-next-line no-use-before-define\n  enroll?: (payload: EnrollPasswordPayload) => Promise<PasswordTransaction>;\n  // eslint-disable-next-line no-use-before-define\n  update?: (payload: UpdatePasswordPayload) => Promise<PasswordTransaction>;\n  delete?: () => Promise<BaseTransaction>;\n\n  constructor(oktaAuth, options) {\n    super(oktaAuth, options);\n\n    const { res, accessToken } = options;\n    // assign required fields from res\n    const { id, status, created, lastUpdated, _links } = res;\n    this.id = id;\n    this.status = status;\n    this.created = created;\n    this.lastUpdated = lastUpdated;\n\n    // assign transformed fns to transaction\n    if (this.status == PasswordStatus.NOT_ENROLLED) {\n      this.enroll = async (payload) => {\n        const fn = generateRequestFnFromLinks({ \n          oktaAuth, \n          accessToken, \n          methodName: 'enroll',\n          links: _links,\n        }, PasswordTransaction);\n        return await fn(payload);\n      };\n    }\n    else {\n      this.get = async () => {\n        const fn = generateRequestFnFromLinks({ \n          oktaAuth, \n          accessToken, \n          methodName: 'get',\n          links: _links,\n        }, PasswordTransaction);\n        return await fn();\n      };\n\n      this.update = async (payload) => {\n        const fn = generateRequestFnFromLinks({ \n          oktaAuth, \n          accessToken, \n          methodName: 'put', \n          links: _links,\n        }, PasswordTransaction);\n        return await fn(payload);\n      };\n  \n      this.delete = async () => {\n        const fn = generateRequestFnFromLinks({ \n          oktaAuth, \n          accessToken, \n          methodName: 'delete', \n          links: _links \n        });\n        return await fn();\n      };\n    }\n  }\n}\n","import { ChallengePhonePayload, PhoneProfile, Status, VerificationPayload } from '../types';\nimport BaseTransaction from './Base';\nimport { generateRequestFnFromLinks } from '../request';\n\nexport default class PhoneTransaction extends BaseTransaction {\n  id: string;\n  profile: PhoneProfile;\n  status: Status;\n\n  // eslint-disable-next-line no-use-before-define\n  get: () => Promise<PhoneTransaction>;\n  delete: () => Promise<BaseTransaction>;\n  challenge: (payload: ChallengePhonePayload) => Promise<BaseTransaction>;\n  verify?: (payload: VerificationPayload) => Promise<BaseTransaction>;\n\n  constructor(oktaAuth, options) {\n    super(oktaAuth, options);\n\n    const { res, accessToken } = options;\n    // assign required fields from res\n    const { id, profile, status, _links } = res;\n    this.id = id;\n    this.profile = profile;\n    this.status = status;\n\n    // assign transformed fns to transaction\n    this.get = async () => {\n      const fn = generateRequestFnFromLinks({ \n        oktaAuth, \n        accessToken, \n        methodName: 'get', \n        links: _links,\n      }, PhoneTransaction);\n      return await fn();\n    };\n    this.delete = async () => {\n      const fn = generateRequestFnFromLinks({ \n        oktaAuth, \n        accessToken, \n        methodName: 'delete', \n        links: _links \n      });\n      return await fn();\n    };\n    this.challenge = async (payload) => {\n      const fn = generateRequestFnFromLinks({ \n        oktaAuth, \n        accessToken, \n        methodName: 'challenge', \n        links: _links \n      });\n      return await fn(payload);\n    };\n    if (_links.verify) {\n      this.verify = async (payload) => {\n        const fn = generateRequestFnFromLinks({ \n          oktaAuth, \n          accessToken, \n          methodName: 'verify', \n          links: _links \n        });\n        return await fn(payload);\n      } ;\n    }\n  }\n}\n","import BaseTransaction from './Base';\n\nexport default class ProfileSchemaTransaction extends BaseTransaction {\n  properties: Record<string, object>;\n\n  constructor(oktaAuth, options) {\n    super(oktaAuth, options);\n\n    this.properties = options.res.properties;\n  }\n}\n","import BaseTransaction from './Base';\n\nexport default class ProfileTransaction extends BaseTransaction {\n  createdAt: string;\n  modifiedAt: string;\n  profile: Record<string, string>;\n\n  constructor(oktaAuth, options) {\n    super(oktaAuth, options);\n\n    const { createdAt, modifiedAt, profile } = options.res;\n    this.createdAt = createdAt;\n    this.modifiedAt = modifiedAt;\n    this.profile = profile;\n  }\n}\n","export { default as ProfileTransaction } from './ProfileTransaction';\nexport { default as ProfileSchemaTransaction } from './ProfileSchemaTransaction';\nexport { default as EmailTransaction } from './EmailTransaction';\nexport { default as EmailStatusTransaction } from './EmailStatusTransaction';\nexport { default as EmailChallengeTransaction } from './EmailChallengeTransaction';\nexport { default as PhoneTransaction } from './PhoneTransaction';\nexport { default as PasswordTransaction } from './PasswordTransaction';\nexport { default as BaseTransaction } from './Base';\n","import {\n  OAuthStorageManagerInterface,\n  OAuthTransactionMeta,\n  OktaAuthOAuthInterface,\n  OktaAuthOAuthOptions,\n  PKCETransactionMeta\n} from '../oidc/types';\n\nexport type { \n  EmailTransaction, \n  EmailStatusTransaction,\n  EmailChallengeTransaction,\n  PhoneTransaction,\n  ProfileTransaction,\n  ProfileSchemaTransaction,\n  PasswordTransaction,\n  BaseTransaction\n} from './transactions';\n\nexport enum EmailRole {\n  PRIMARY = 'PRIMARY',\n  SECONDARY = 'SECONDARY'\n}\n\nexport enum Status {\n  VERIFIED = 'VERIFIED',\n  UNVERIFIED = 'UNVERIFIED'\n}\n\nexport enum PasswordStatus {\n  NOT_ENROLLED = 'NOT_ENROLLED',\n  ACTIVE = 'ACTIVE'\n}\n\nexport type EmailProfile = {\n  email: string;\n}\n\nexport type AddEmailPayload = {\n  profile: {\n    email: string;\n  };\n  sendEmail: boolean;\n  role: EmailRole;\n}\n\nexport type PhoneProfile = {\n  profile: {\n    phoneNumber: string;\n  };\n}\n\nexport type AddPhonePayload = {\n  profile: {\n    phoneNumber: string;\n  };\n  sendCode: boolean;\n  method: string;\n};\n\nexport type ChallengePhonePayload = {\n  method: string;\n}\n\nexport type VerificationPayload = {\n  verificationCode: string;\n};\n\nexport type EnrollPasswordPayload = {\n  profile: {\n    password: string;\n  }\n}\n\nexport type UpdatePasswordPayload = {\n  profile: {\n    password: string;\n    currentPassword?: string;\n  }\n}\n\nexport type UpdateProfilePayload = {\n  profile: {\n    firstName?: string;\n    lastName?: string;\n    email?: string;\n    login?: string;\n    [property: string]: any;\n  };\n};\n\nexport type MyAccountRequestOptions = {\n  id?: string;\n  emailId?: string;\n  challengeId?: string;\n  payload?: AddEmailPayload \n    | AddPhonePayload \n    | ChallengePhonePayload\n    | VerificationPayload \n    | UpdateProfilePayload\n    | EnrollPasswordPayload\n    | UpdatePasswordPayload;\n  accessToken?: string;\n}\n\nexport type IAPIFunction<T> = (\n  oktaAuth: OktaAuthOAuthInterface, \n  options?: MyAccountRequestOptions\n) => Promise<T>;\n\nexport interface OktaAuthMyAccountInterface\n<\n  M extends OAuthTransactionMeta = PKCETransactionMeta,\n  S extends OAuthStorageManagerInterface<M> = OAuthStorageManagerInterface<M>,\n  O extends OktaAuthOAuthOptions = OktaAuthOAuthOptions\n> \n  extends OktaAuthOAuthInterface<M, S, O>\n{\n  myaccount;\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 */\nimport { removeNils, clone } from '../util';\nimport { AuthSdkError } from '../errors';\nimport { validateToken  } from '../oidc/util';\nimport { isLocalhost, isIE11OrLess } from '../features';\nimport SdkClock from '../clock';\nimport {\n  Token, \n  Tokens, \n  TokenType, \n  TokenManagerOptions, \n  isIDToken, \n  isAccessToken,\n  isRefreshToken,\n  TokenManagerErrorEventHandler,\n  TokenManagerSetStorageEventHandler,\n  TokenManagerRenewEventHandler,\n  TokenManagerEventHandler,\n  TokenManagerInterface,\n  RefreshToken,\n  AccessTokenCallback,\n  IDTokenCallback,\n  RefreshTokenCallback,\n  EVENT_RENEWED,\n  EVENT_ADDED,\n  EVENT_ERROR,\n  EVENT_EXPIRED,\n  EVENT_REMOVED,\n  EVENT_SET_STORAGE,\n  TokenManagerAnyEventHandler,\n  TokenManagerAnyEvent,\n  OktaAuthOAuthInterface\n} from './types';\nimport { REFRESH_TOKEN_STORAGE_KEY, TOKEN_STORAGE_NAME } from '../constants';\nimport { EventEmitter } from '../base/types';\nimport { StorageOptions, StorageProvider, StorageType } from '../storage/types';\n\nconst DEFAULT_OPTIONS = {\n  // TODO: remove in next major version - OKTA-473815\n  autoRenew: true,\n  autoRemove: true,\n  syncStorage: true,\n  // --- //\n  clearPendingRemoveTokens: true,\n  storage: undefined, // will use value from storageManager config\n  expireEarlySeconds: 30,\n  storageKey: TOKEN_STORAGE_NAME\n};\n\ninterface TokenManagerState {\n  expireTimeouts: Record<string, unknown>;\n  renewPromise: Promise<Token | undefined> | null;\n  started?: boolean;\n}\nfunction defaultState(): TokenManagerState {\n  return {\n    expireTimeouts: {},\n    renewPromise: null\n  };\n}\nexport class TokenManager implements TokenManagerInterface {\n  private sdk: OktaAuthOAuthInterface;\n  private clock: SdkClock;\n  private emitter: EventEmitter;\n  private storage: StorageProvider;\n  private state: TokenManagerState;\n  private options: TokenManagerOptions;\n\n  on(event: typeof EVENT_RENEWED, handler: TokenManagerRenewEventHandler, context?: object): void;\n  on(event: typeof EVENT_ERROR, handler: TokenManagerErrorEventHandler, context?: object): void;\n  on(event: typeof EVENT_SET_STORAGE, handler: TokenManagerSetStorageEventHandler, context?: object): void;\n  on(event: typeof EVENT_EXPIRED | typeof EVENT_ADDED | typeof EVENT_REMOVED, \n    handler: TokenManagerEventHandler, context?: object): void;\n  on(event: TokenManagerAnyEvent, handler: TokenManagerAnyEventHandler, context?: object): void {\n    if (context) {\n      this.emitter.on(event, handler, context);\n    } else {\n      this.emitter.on(event, handler);\n    }\n  }\n\n  off(event: typeof EVENT_RENEWED, handler?: TokenManagerRenewEventHandler): void;\n  off(event: typeof EVENT_ERROR, handler?: TokenManagerErrorEventHandler): void;\n  off(event: typeof EVENT_SET_STORAGE, handler?: TokenManagerSetStorageEventHandler): void;\n  off(event: typeof EVENT_EXPIRED | typeof EVENT_ADDED | typeof EVENT_REMOVED, \n    handler?: TokenManagerEventHandler): void;\n  off(event: TokenManagerAnyEvent, handler?: TokenManagerAnyEventHandler): void {\n    if (handler) {\n      this.emitter.off(event, handler);\n    } else {\n      this.emitter.off(event);\n    }\n  }\n\n  // eslint-disable-next-line complexity\n  constructor(sdk: OktaAuthOAuthInterface, options: TokenManagerOptions = {}) {\n    this.sdk = sdk;\n    this.emitter = (sdk as any).emitter;\n    if (!this.emitter) {\n      throw new AuthSdkError('Emitter should be initialized before TokenManager');\n    }\n    \n    options = Object.assign({}, DEFAULT_OPTIONS, removeNils(options));\n    if (!isLocalhost()) {\n      options.expireEarlySeconds = DEFAULT_OPTIONS.expireEarlySeconds;\n    }\n\n    this.options = options;\n\n    const storageOptions: StorageOptions = removeNils({\n      storageKey: options.storageKey,\n      secure: options.secure,\n    });\n    if (typeof options.storage === 'object') {\n      // A custom storage provider must implement getItem(key) and setItem(key, val)\n      storageOptions.storageProvider = options.storage;\n    } else if (options.storage) {\n      storageOptions.storageType = options.storage as StorageType;\n    }\n\n    this.storage = sdk.storageManager.getTokenStorage({...storageOptions, useSeparateCookies: true});\n    this.clock = SdkClock.create(/* sdk, options */);\n    this.state = defaultState();\n  }\n\n  start() {\n    if (this.options.clearPendingRemoveTokens) {\n      this.clearPendingRemoveTokens();\n    }\n    this.setExpireEventTimeoutAll();\n    this.state.started = true;\n  }\n  \n  stop() {\n    this.clearExpireEventTimeoutAll();\n    this.state.started = false;\n  }\n\n  isStarted() {\n    return !!this.state.started;\n  }\n\n  getOptions(): TokenManagerOptions {\n    return clone(this.options);\n  }\n  \n  getExpireTime(token) {\n    const expireEarlySeconds = this.options.expireEarlySeconds || 0;\n    var expireTime = token.expiresAt - expireEarlySeconds;\n    return expireTime;\n  }\n  \n  hasExpired(token) {\n    var expireTime = this.getExpireTime(token);\n    return expireTime <= this.clock.now();\n  }\n  \n  emitExpired(key, token) {\n    this.emitter.emit(EVENT_EXPIRED, key, token);\n  }\n  \n  emitRenewed(key, freshToken, oldToken) {\n    this.emitter.emit(EVENT_RENEWED, key, freshToken, oldToken);\n  }\n  \n  emitAdded(key, token) {\n    this.emitter.emit(EVENT_ADDED, key, token);\n  }\n  \n  emitRemoved(key, token?) {\n    this.emitter.emit(EVENT_REMOVED, key, token);\n  }\n  \n  emitError(error) {\n    this.emitter.emit(EVENT_ERROR, error);\n  }\n  \n  clearExpireEventTimeout(key) {\n    clearTimeout(this.state.expireTimeouts[key] as any);\n    delete this.state.expireTimeouts[key];\n  \n    // Remove the renew promise (if it exists)\n    this.state.renewPromise = null;\n  }\n  \n  clearExpireEventTimeoutAll() {\n    var expireTimeouts = this.state.expireTimeouts;\n    for (var key in expireTimeouts) {\n      if (!Object.prototype.hasOwnProperty.call(expireTimeouts, key)) {\n        continue;\n      }\n      this.clearExpireEventTimeout(key);\n    }\n  }\n  \n  setExpireEventTimeout(key, token) {\n    if (isRefreshToken(token)) {\n      return;\n    }\n\n    var expireTime = this.getExpireTime(token);\n    var expireEventWait = Math.max(expireTime - this.clock.now(), 0) * 1000;\n  \n    // Clear any existing timeout\n    this.clearExpireEventTimeout(key);\n  \n    var expireEventTimeout = setTimeout(() => {\n      this.emitExpired(key, token);\n    }, expireEventWait);\n  \n    // Add a new timeout\n    this.state.expireTimeouts[key] = expireEventTimeout;\n  }\n  \n  setExpireEventTimeoutAll() {\n    var tokenStorage = this.storage.getStorage();\n    for(var key in tokenStorage) {\n      if (!Object.prototype.hasOwnProperty.call(tokenStorage, key)) {\n        continue;\n      }\n      var token = tokenStorage[key];\n      this.setExpireEventTimeout(key, token);\n    }\n  }\n  \n  // reset timeouts to setup autoRenew for tokens from other document context (tabs)\n  resetExpireEventTimeoutAll() {\n    this.clearExpireEventTimeoutAll();\n    this.setExpireEventTimeoutAll();\n  }\n  \n  add(key, token: Token) {\n    var tokenStorage = this.storage.getStorage();\n    validateToken(token);\n    tokenStorage[key] = token;\n    this.storage.setStorage(tokenStorage);\n    this.emitSetStorageEvent();\n    this.emitAdded(key, token);\n    this.setExpireEventTimeout(key, token);\n  }\n  \n  getSync(key): Token | undefined {\n    var tokenStorage = this.storage.getStorage();\n    return tokenStorage[key];\n  }\n  \n  async get(key): Promise<Token | undefined> {\n    return this.getSync(key);\n  }\n  \n  getTokensSync(): Tokens {\n    const tokens = {} as Tokens;\n    const tokenStorage = this.storage.getStorage();\n    Object.keys(tokenStorage).forEach(key => {\n      const token = tokenStorage[key];\n      if (isAccessToken(token)) {\n        tokens.accessToken = token;\n      } else if (isIDToken(token)) {\n        tokens.idToken = token;\n      } else if (isRefreshToken(token)) { \n        tokens.refreshToken = token;\n      }\n    });\n    return tokens;\n  }\n  \n  async getTokens(): Promise<Tokens> {\n    return this.getTokensSync();\n  }\n\n  getStorageKeyByType(type: TokenType): string {\n    const tokenStorage = this.storage.getStorage();\n    const key = Object.keys(tokenStorage).filter(key => {\n      const token = tokenStorage[key];\n      return (isAccessToken(token) && type === 'accessToken') \n        || (isIDToken(token) && type === 'idToken')\n        || (isRefreshToken(token) && type === 'refreshToken');\n    })[0];\n    return key;\n  }\n\n  private getTokenType(token: Token): TokenType {\n    if (isAccessToken(token)) {\n      return 'accessToken';\n    }\n    if (isIDToken(token)) {\n      return 'idToken';\n    }\n    if(isRefreshToken(token)) {\n      return 'refreshToken';\n    }\n    throw new AuthSdkError('Unknown token type');\n  }\n\n  // for synchronization of LocalStorage cross tabs for IE11\n  private emitSetStorageEvent() {\n    if (isIE11OrLess()) {\n      const storage = this.storage.getStorage();\n      this.emitter.emit(EVENT_SET_STORAGE, storage);\n    }\n  }\n\n  // used in `SyncStorageService` for synchronization of LocalStorage cross tabs for IE11\n  public getStorage() {\n    return this.storage;\n  }\n\n  setTokens(\n    tokens: Tokens,\n    // TODO: callbacks can be removed in the next major version OKTA-407224\n    accessTokenCb?: AccessTokenCallback, \n    idTokenCb?: IDTokenCallback,\n    refreshTokenCb?: RefreshTokenCallback\n  ): void {\n    const handleTokenCallback = (key, token) => {\n      const type = this.getTokenType(token);\n      if (type === 'accessToken') {\n        accessTokenCb && accessTokenCb(key, token);\n      } else if (type === 'idToken') {\n        idTokenCb && idTokenCb(key, token);\n      } else if (type === 'refreshToken') {\n        refreshTokenCb && refreshTokenCb(key, token);\n      }\n    };\n    const handleAdded = (key, token) => {\n      this.emitAdded(key, token);\n      this.setExpireEventTimeout(key, token);\n      handleTokenCallback(key, token);\n    };\n    const handleRenewed = (key, token, oldToken) => {\n      this.emitRenewed(key, token, oldToken);\n      this.clearExpireEventTimeout(key);\n      this.setExpireEventTimeout(key, token);\n      handleTokenCallback(key, token);\n    };\n    const handleRemoved = (key, token) => {\n      this.clearExpireEventTimeout(key);\n      this.emitRemoved(key, token);\n      handleTokenCallback(key, token);\n    };\n    \n    const types: TokenType[] = ['idToken', 'accessToken', 'refreshToken'];\n    const existingTokens = this.getTokensSync();\n\n    // valid tokens\n    types.forEach((type) => {\n      const token = tokens[type];\n      if (token) {\n        validateToken(token, type);\n      }\n    });\n  \n    // add token to storage\n    const storage = types.reduce((storage, type) => {\n      const token = tokens[type];\n      if (token) {\n        const storageKey = this.getStorageKeyByType(type) || type;\n        storage[storageKey] = token;\n      }\n      return storage;\n    }, {});\n    this.storage.setStorage(storage);\n    this.emitSetStorageEvent();\n\n    // emit event and start expiration timer\n    types.forEach(type => {\n      const newToken = tokens[type];\n      const existingToken = existingTokens[type];\n      const storageKey = this.getStorageKeyByType(type) || type;\n      if (newToken && existingToken) { // renew\n        // call handleRemoved first, since it clears timers\n        handleRemoved(storageKey, existingToken);\n        handleAdded(storageKey, newToken);\n        handleRenewed(storageKey, newToken, existingToken);\n      } else if (newToken) { // add\n        handleAdded(storageKey, newToken);\n      } else if (existingToken) { //remove\n        handleRemoved(storageKey, existingToken);\n      }\n    });\n  }\n  \n  remove(key) {\n    // Clear any listener for this token\n    this.clearExpireEventTimeout(key);\n  \n    var tokenStorage = this.storage.getStorage();\n    var removedToken = tokenStorage[key];\n    delete tokenStorage[key];\n    this.storage.setStorage(tokenStorage);\n    this.emitSetStorageEvent();\n  \n    this.emitRemoved(key, removedToken);\n  }\n  \n  // TODO: this methods is redundant and can be removed in the next major version OKTA-407224\n  async renewToken(token) {\n    return this.sdk.token?.renew(token);\n  }\n  // TODO: this methods is redundant and can be removed in the next major version OKTA-407224\n  validateToken(token: Token) {\n    return validateToken(token);\n  }\n\n  // TODO: renew method should take no param, change in the next major version OKTA-407224\n  renew(key): Promise<Token | undefined> {\n    // Multiple callers may receive the same promise. They will all resolve or reject from the same request.\n    if (this.state.renewPromise) {\n      return this.state.renewPromise;\n    }\n\n    try {\n      var token = this.getSync(key);\n      let shouldRenew = token !== undefined;\n      // explicitly check if key='accessToken' because token keys are not guaranteed (long story, features dragons)\n      if (!token && key === 'accessToken') {\n        // attempt token renewal if refresh token is present (improves consistency of autoRenew)\n        const refreshKey = this.getStorageKeyByType('refreshToken');\n        const refreshToken = this.getSync(refreshKey);\n        shouldRenew = refreshToken !== undefined;\n      }\n\n      if (!shouldRenew) {\n        throw new AuthSdkError('The tokenManager has no token for the key: ' + key);\n      }\n    }\n    catch (err) {\n      this.emitError(err);\n      return Promise.reject(err);\n    }\n\n    // Remove existing autoRenew timeout\n    this.clearExpireEventTimeout(key);\n  \n    // A refresh token means a replace instead of renewal\n    // Store the renew promise state, to avoid renewing again\n    const renewPromise = this.state.renewPromise = this.sdk.token.renewTokens()\n      .then(tokens => {\n        this.setTokens(tokens);\n\n        // return accessToken in case where access token doesn't exist\n        // but refresh token exists\n        if (!token && key === 'accessToken') {\n          const accessToken = tokens['accessToken'];\n          this.emitRenewed(key, accessToken, null);\n          return accessToken;\n        }\n\n        // resolve token based on the key\n        const tokenType = this.getTokenType(token!);\n        return tokens[tokenType];\n      })\n      .catch(err => {\n        // If renew fails, remove token from storage and emit error\n        this.remove(key);\n        err.tokenKey = key;\n        this.emitError(err);\n        throw err;\n      })\n      .finally(() => {\n        // Remove existing promise key\n        this.state.renewPromise = null;\n      });\n  \n    return renewPromise;\n  }\n  \n  clear() {\n    const tokens = this.getTokensSync();\n    this.clearExpireEventTimeoutAll();\n    this.storage.clearStorage();\n    this.emitSetStorageEvent();\n\n    Object.keys(tokens).forEach(key => {\n      this.emitRemoved(key, tokens[key]);\n    });\n  }\n\n  clearPendingRemoveTokens() {\n    const tokenStorage = this.storage.getStorage();\n    const removedTokens = {};\n    Object.keys(tokenStorage).forEach(key => {\n      if (tokenStorage[key].pendingRemove) {\n        removedTokens[key] = tokenStorage[key];\n        delete tokenStorage[key];\n      }\n    });\n    this.storage.setStorage(tokenStorage);\n    this.emitSetStorageEvent();\n    Object.keys(removedTokens).forEach(key => {\n      this.clearExpireEventTimeout(key);\n      this.emitRemoved(key, removedTokens[key]);\n    });\n  }\n\n  updateRefreshToken(token: RefreshToken) {\n    const key = this.getStorageKeyByType('refreshToken') || REFRESH_TOKEN_STORAGE_KEY;\n\n    // do not emit any event\n    var tokenStorage = this.storage.getStorage();\n    validateToken(token);\n    tokenStorage[key] = token;\n    this.storage.setStorage(tokenStorage);\n    this.emitSetStorageEvent();\n  }\n\n  removeRefreshToken () {\n    const key = this.getStorageKeyByType('refreshToken') || REFRESH_TOKEN_STORAGE_KEY;\n    this.remove(key);\n  }\n\n  addPendingRemoveFlags() {\n    const tokens = this.getTokensSync();\n    Object.keys(tokens).forEach(key => {\n      tokens[key].pendingRemove = true;\n    });\n    this.setTokens(tokens);\n  }\n  \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\nimport { StorageProvider } from '../storage/types';\nimport {\n  TransactionMeta,\n  isTransactionMeta,\n  TransactionMetaOptions,\n  TransactionManagerOptions,\n  OAuthTransactionMeta,\n  OAuthStorageManagerInterface,\n  ClearTransactionMetaOptions,\n  TransactionManagerInterface,\n  PKCETransactionMeta\n} from './types';\nimport { warn } from '../util';\nimport {\n  clearTransactionFromSharedStorage,\n  loadTransactionFromSharedStorage,\n  pruneSharedStorage,\n  saveTransactionToSharedStorage\n} from './util/sharedStorage';\n\n\nexport function createTransactionManager\n<\n  M extends OAuthTransactionMeta = PKCETransactionMeta,\n  S extends OAuthStorageManagerInterface<M> = OAuthStorageManagerInterface<M>\n>\n()\n{\n  return class TransactionManager implements TransactionManagerInterface\n  {\n    options: TransactionManagerOptions;\n    storageManager: S;\n    enableSharedStorage: boolean;\n    saveLastResponse: boolean;\n\n    constructor(options: TransactionManagerOptions) {\n      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n      this.storageManager = options.storageManager! as S;\n      this.enableSharedStorage = options.enableSharedStorage === false ? false : true;\n      this.saveLastResponse = options.saveLastResponse === false ? false : true;\n      this.options = options;\n    }\n\n    // eslint-disable-next-line complexity\n    clear(options: ClearTransactionMetaOptions = {}) {\n      const transactionStorage: StorageProvider = this.storageManager.getTransactionStorage();\n      const meta = transactionStorage.getStorage();\n\n      // Clear primary storage (by default, sessionStorage on browser)\n      transactionStorage.clearStorage();\n\n      // Usually we want to also clear shared storage unless another tab may need it to continue/complete a flow\n      if (this.enableSharedStorage && options.clearSharedStorage !== false) {\n        const state = options.state || meta?.state;\n        if (state) {\n          clearTransactionFromSharedStorage(this.storageManager, state);\n        }\n      }\n    }\n\n    // eslint-disable-next-line complexity\n    save(meta: M, options: TransactionMetaOptions = {}) {\n      // There must be only one transaction executing at a time.\n      // Before saving, check to see if a transaction is already stored.\n      // An existing transaction indicates a concurrency/race/overlap condition\n\n      let storage: StorageProvider = this.storageManager.getTransactionStorage();\n      const obj = storage.getStorage();\n      // oie process may need to update transaction in the middle of process for tracking purpose\n      // false alarm might be caused \n      // TODO: revisit for a better solution, https://oktainc.atlassian.net/browse/OKTA-430919\n      if (isTransactionMeta(obj) && !options.muteWarning) {\n        // eslint-disable-next-line max-len\n        warn('a saved auth transaction exists in storage. This may indicate another auth flow is already in progress.');\n      }\n\n      storage.setStorage(meta);\n\n      // Shared storage allows continuation of transaction in another tab\n      if (this.enableSharedStorage && meta.state) {\n        saveTransactionToSharedStorage(this.storageManager, meta.state, meta);\n      }\n    }\n\n    exists(options: TransactionMetaOptions = {}): boolean {\n      try {\n        const meta = this.load(options);\n        return !!meta;\n      } catch {\n        return false;\n      }\n    }\n\n    // load transaction meta from storage\n    // eslint-disable-next-line complexity,max-statements\n    load(options: TransactionMetaOptions = {}): TransactionMeta | null {\n\n      let meta: TransactionMeta;\n\n      // If state was passed, try loading transaction data from shared storage\n      if (this.enableSharedStorage && options.state) {\n        pruneSharedStorage(this.storageManager); // prune before load\n        meta = loadTransactionFromSharedStorage(this.storageManager, options.state);\n        if (isTransactionMeta(meta)) {\n          return meta;\n        }\n      }\n\n      let storage: StorageProvider = this.storageManager.getTransactionStorage();\n      meta = storage.getStorage();\n      if (isTransactionMeta(meta)) {\n        // if we have meta in the new location, there is no need to go further\n        return meta;\n      }\n\n      return null;\n    }\n\n  };\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 */\nimport { AuthSdkError } from '../errors';\nimport { JWTObject } from './types';\nimport { base64UrlToString } from '../crypto';\n\nexport function decodeToken(token: string): JWTObject {\n  var jwt = token.split('.');\n  var decodedToken: JWTObject;\n\n  try {\n    decodedToken = {\n      header: JSON.parse(base64UrlToString(jwt[0])),\n      payload: JSON.parse(base64UrlToString(jwt[1])),\n      signature: jwt[2]\n    };\n  } catch (e) {\n    throw new AuthSdkError('Malformed token');\n  }\n\n  return decodedToken;\n}\n","// References:\n// https://www.w3.org/TR/WebCryptoAPI/#concepts-key-storage\n// https://datatracker.ietf.org/doc/html/rfc9449\n\nimport {\n  webcrypto,\n  stringToBase64Url,\n  stringToBuffer,\n  bufferToBase64Url,\n  base64ToBase64Url,\n  btoa\n} from '../crypto';\nimport { AuthSdkError, OAuthError, WWWAuthError, isOAuthError, isWWWAuthError } from '../errors';\nimport { Tokens } from './types';\n\nexport interface DPoPClaims {\n  htm: string;\n  htu: string;\n  iat: number;\n  jti: string;\n  nonce?: string;\n  ath?: string;\n}\n\nexport interface DPoPProofParams {\n  keyPair: CryptoKeyPair;\n  url: string;\n  method: string;\n  nonce?: string;\n  accessToken?: string;\n}\n\nexport type ResourceDPoPProofParams = Omit<DPoPProofParams, 'keyPair' | 'nonce'>;\ntype DPoPProofTokenRequestParams = Omit<DPoPProofParams, 'accessToken'>;\n\nconst INDEXEDDB_NAME = 'OktaAuthJs';\nconst DB_KEY = 'DPoPKeys';\n\nexport function isDPoPNonceError(obj: any): obj is OAuthError | WWWAuthError {\n  return (\n    (isOAuthError(obj) || isWWWAuthError(obj)) &&\n    obj.errorCode === 'use_dpop_nonce'\n  );\n}\n\n/////////// crypto ///////////\n\nexport async function createJwt(header: object, claims: object, signingKey: CryptoKey): Promise<string> {\n  const head = stringToBase64Url(JSON.stringify(header));\n  const body = stringToBase64Url(JSON.stringify(claims));\n  const signature = await webcrypto.subtle.sign(\n    { name: signingKey.algorithm.name }, signingKey, stringToBuffer(`${head}.${body}`)\n  );\n  return `${head}.${body}.${base64ToBase64Url(bufferToBase64Url(signature))}`;\n}\n\nexport function cryptoRandomValue (byteLen = 32) {\n  return [...webcrypto.getRandomValues(new Uint8Array(byteLen))].map(v => v.toString(16)).join('');\n}\n\nexport async function generateKeyPair (): Promise<CryptoKeyPair> {\n  const algorithm = {\n    name: 'RSASSA-PKCS1-v1_5',\n    hash: 'SHA-256',\n    modulusLength: 2048,\n    publicExponent: new Uint8Array([0x01, 0x00, 0x01]),\n  };\n\n  // The \"false\" here makes it non-exportable\n  // https://caniuse.com/mdn-api_subtlecrypto_generatekey\n  return webcrypto.subtle.generateKey(algorithm, false, ['sign', 'verify']);\n}\n\nasync function hashAccessToken (accessToken: string): Promise<string> {\n  const buffer = new TextEncoder().encode(accessToken);\n  const hash = await webcrypto.subtle.digest('SHA-256', buffer);\n\n  return btoa(String.fromCharCode.apply(null, new Uint8Array(hash) as unknown as number[]))\n    .replace(/\\+/g, '-').replace(/\\//g, '_').replace(/=+$/, '');\n}\n\n/////////// indexeddb / keystore ///////////\n\n\n// https://developer.mozilla.org/en-US/docs/Web/API/IDBObjectStore#instance_methods\n// add additional methods as needed\nexport type StoreMethod = 'get' | 'add' | 'delete' | 'clear';\n\n// convenience abstraction for exposing IDBObjectStore instance\nfunction keyStore (): Promise<IDBObjectStore> {\n  return new Promise((resolve, reject) => {\n    try {\n      const indexedDB = window.indexedDB;\n      const req = indexedDB.open(INDEXEDDB_NAME, 1);\n\n      req.onerror = function () {\n        reject(req.error!);\n      };\n\n      req.onupgradeneeded = function () {\n        const db = req.result;\n        db.createObjectStore(DB_KEY);\n      };\n\n      req.onsuccess = function () {\n        const db = req.result;\n        const tx = db.transaction(DB_KEY, 'readwrite');\n\n        tx.onerror = function () {\n          reject(tx.error!);\n        };\n\n        const store = tx.objectStore(DB_KEY);\n\n        resolve(store);\n\n        tx.oncomplete = function () {\n          db.close();\n        };\n      };\n    }\n    catch (err) {\n      reject(err);\n    }\n  });\n}\n\n// convenience abstraction for wrapping IDBObjectStore methods in promises\nasync function invokeStoreMethod (method: StoreMethod, ...args: any[]): Promise<IDBRequest> {\n  const store = await keyStore();\n  return new Promise((resolve, reject) => {\n    // https://github.com/microsoft/TypeScript/issues/49700\n    // https://github.com/microsoft/TypeScript/issues/49802\n    // @ts-expect-error ts(2556)\n    const req = store[method](...args);\n    req.onsuccess = function () {\n      resolve(req);\n    };\n    req.onerror = function () {\n      reject(req.error);\n    };\n  });\n}\n\nasync function storeKeyPair (pairId: string, keyPair: CryptoKeyPair) {\n  await invokeStoreMethod('add', keyPair, pairId);\n  return keyPair;\n}\n\n// attempts to find keyPair stored at given key, otherwise throws\nexport async function findKeyPair (pairId?: string): Promise<CryptoKeyPair> {\n  if (pairId) {\n    const req = await invokeStoreMethod('get', pairId);\n    if (req.result) {\n      return req.result;\n    }\n  }\n\n  // defaults to throwing unless keyPair is found\n  throw new AuthSdkError(`Unable to locate dpop key pair required for refresh${pairId ? ` (${pairId})` : ''}`);\n}\n\nexport async function clearDPoPKeyPair (pairId: string): Promise<void> {\n  await invokeStoreMethod('delete', pairId);\n}\n\nexport async function clearAllDPoPKeyPairs (): Promise<void> {\n  await invokeStoreMethod('clear');\n}\n\n// generates a crypto (non-extractable) private key pair and writes it to indexeddb, returns key (id)\nexport async function createDPoPKeyPair (): Promise<{keyPair: CryptoKeyPair, keyPairId: string}> {\n  const keyPairId = cryptoRandomValue(4);\n  const keyPair = await generateKeyPair();\n  await storeKeyPair(keyPairId, keyPair);\n  return { keyPair, keyPairId };\n}\n\n// will clear PK from storage if certain token conditions are met\n/* eslint max-len: [2, 132], complexity: [2, 12] */\nexport async function clearDPoPKeyPairAfterRevoke (revokedToken: 'access' | 'refresh', tokens: Tokens): Promise<void> {\n  let shouldClear = false;\n\n  const { accessToken, refreshToken } = tokens;\n\n  // revoking access token and refresh token doesn't exist\n  if (revokedToken === 'access' && accessToken && accessToken.tokenType === 'DPoP' && !refreshToken) {\n    shouldClear = true;\n  }\n\n  // revoking refresh token and access token doesn't exist\n  if (revokedToken === 'refresh' && refreshToken && !accessToken) {\n    shouldClear = true;\n  }\n\n  const pairId = accessToken?.dpopPairId ?? refreshToken?.dpopPairId;\n  if (shouldClear && pairId) {\n    await clearDPoPKeyPair(pairId);\n  }\n}\n\n/////////// proof generation methods ///////////\n\nexport async function generateDPoPProof ({ keyPair, url, method, nonce, accessToken }: DPoPProofParams): Promise<string> {\n  const { kty, crv, e, n, x, y } = await webcrypto.subtle.exportKey('jwk', keyPair.publicKey);\n  const header = {\n    alg: 'RS256',\n    typ: 'dpop+jwt',\n    jwk: { kty, crv, e, n, x, y }\n  };\n\n  const claims: DPoPClaims = {\n    htm: method,\n    htu: url,\n    iat: Math.floor(Date.now() / 1000),\n    jti: cryptoRandomValue(),\n  };\n\n  if (nonce) {\n    claims.nonce = nonce;\n  }\n\n  // encode access token\n  if (accessToken) {\n    claims.ath = await hashAccessToken(accessToken);\n  }\n\n  return createJwt(header, claims, keyPair.privateKey);\n}\n\n/* eslint max-len: [2, 132] */\nexport async function generateDPoPForTokenRequest ({ keyPair, url, method, nonce }: DPoPProofTokenRequestParams): Promise<string> {\n  const params: DPoPProofParams = { keyPair, url, method };\n  if (nonce) {\n    params.nonce = nonce;\n  }\n\n  return generateDPoPProof(params);\n}\n","/* eslint-disable @typescript-eslint/no-non-null-assertion */\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\nimport { isString, removeNils, toQueryString } from '../../util';\nimport { AuthSdkError } from '../../errors';\nimport { OAuthParams, TokenParams } from '../types';\n\nexport function convertTokenParamsToOAuthParams(tokenParams: TokenParams) {\n  // Quick validation\n  if (!tokenParams.clientId) {\n    throw new AuthSdkError('A clientId must be specified in the OktaAuth constructor to get a token');\n  }\n\n  if (isString(tokenParams.responseType) && tokenParams.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 oauthParams: OAuthParams = {\n    'client_id': tokenParams.clientId,\n    'code_challenge': tokenParams.codeChallenge,\n    'code_challenge_method': tokenParams.codeChallengeMethod,\n    'display': tokenParams.display,\n    'idp': tokenParams.idp,\n    'idp_scope': tokenParams.idpScope,\n    'login_hint': tokenParams.loginHint,\n    'max_age': tokenParams.maxAge,\n    'nonce': tokenParams.nonce,\n    'prompt': tokenParams.prompt,\n    'redirect_uri': tokenParams.redirectUri,\n    'response_mode': tokenParams.responseMode,\n    'response_type': tokenParams.responseType,\n    'sessionToken': tokenParams.sessionToken,\n    'state': tokenParams.state,\n    'acr_values': tokenParams.acrValues,\n    'enroll_amr_values': tokenParams.enrollAmrValues,\n  };\n  oauthParams = removeNils(oauthParams) as OAuthParams;\n\n  ['idp_scope', 'response_type', 'enroll_amr_values'].forEach(function (mayBeArray) {\n    if (Array.isArray(oauthParams[mayBeArray])) {\n      oauthParams[mayBeArray] = oauthParams[mayBeArray].join(' ');\n    }\n  });\n\n  if (tokenParams.responseType!.indexOf('id_token') !== -1 &&\n    tokenParams.scopes!.indexOf('openid') === -1) {\n    throw new AuthSdkError('openid scope must be specified in the scopes argument when requesting an id_token');\n  } else if (tokenParams.scopes) {\n    oauthParams.scope = tokenParams.scopes!.join(' ');\n  }\n\n  return oauthParams;\n}\n\nexport function buildAuthorizeParams(tokenParams: TokenParams) {\n  var oauthQueryParams = convertTokenParamsToOAuthParams(tokenParams);\n  return toQueryString({ \n    ...oauthQueryParams, \n    ...(tokenParams.extraParams && { ...tokenParams.extraParams })\n  });\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\nexport * from './authorize';\nexport * from './token';\nexport * from './well-known';\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\nimport { AuthSdkError, AuthApiError } from '../../errors';\nimport { CustomUrls, OAuthParams, OAuthResponse, RefreshToken, TokenParams } from '../types';\nimport { removeNils, toQueryString } from '../../util';\nimport { httpRequest, OktaAuthHttpInterface } from '../../http';\nimport { generateDPoPForTokenRequest, isDPoPNonceError } from '../dpop';\n\nexport interface TokenEndpointParams extends TokenParams {\n  dpopKeyPair?: CryptoKeyPair;\n}\n\ninterface TokenRequestParams {\n  url: string;\n  data: any;\n  dpopKeyPair?: CryptoKeyPair;\n  nonce?: string;\n}\n\nfunction validateOptions(options: TokenEndpointParams) {\n  // Quick validation\n  if (!options.clientId) {\n    throw new AuthSdkError('A clientId must be specified in the OktaAuth constructor to get a token');\n  }\n\n  if (!options.redirectUri) {\n    throw new AuthSdkError('The redirectUri passed to /authorize must also be passed to /token');\n  }\n\n  if (!options.authorizationCode && !options.interactionCode) {\n    throw new AuthSdkError('An authorization code (returned from /authorize) must be passed to /token');\n  }\n\n  if (!options.codeVerifier) {\n    throw new AuthSdkError('The \"codeVerifier\" (generated and saved by your app) must be passed to /token');\n  }\n}\n\nfunction getPostData(sdk, options: TokenParams): string {\n  // Convert Token params to OAuth params, sent to the /token endpoint\n  var params: OAuthParams = removeNils({\n    'client_id': options.clientId,\n    'redirect_uri': options.redirectUri,\n    'grant_type': options.interactionCode ? 'interaction_code' : 'authorization_code',\n    'code_verifier': options.codeVerifier\n  });\n\n  if (options.interactionCode) {\n    params['interaction_code'] = options.interactionCode;\n  } else if (options.authorizationCode) {\n    params.code = options.authorizationCode;\n  }\n\n  const { clientSecret } = sdk.options;\n  if (clientSecret) {\n    params['client_secret'] = clientSecret;\n  }\n\n  // Encode as URL string\n  return toQueryString(params).slice(1);\n}\n\n/* eslint complexity: [2, 10] */\nasync function makeTokenRequest (sdk, { url, data, nonce, dpopKeyPair }: TokenRequestParams): Promise<OAuthResponse> {\n  const method = 'POST';\n  const headers: any = {\n    'Content-Type': 'application/x-www-form-urlencoded',\n  };\n\n  if (sdk.options.dpop) {\n    if (!dpopKeyPair) {\n      throw new AuthSdkError('DPoP is configured but no key pair was provided');\n    }\n\n    const proof = await generateDPoPForTokenRequest({ url, method, nonce, keyPair: dpopKeyPair });\n    headers.DPoP = proof;\n  }\n\n  try {\n    const resp = await httpRequest(sdk, {\n      url,\n      method,\n      args: data,\n      headers\n    });\n    return resp;\n  }\n  catch (err) {\n    if (isDPoPNonceError(err) && !nonce) {\n      const dpopNonce = err.resp?.headers['dpop-nonce'];\n      if (!dpopNonce) {\n        // throws error is dpop-nonce header cannot be found, prevents infinite loop\n        throw new AuthApiError(\n          {errorSummary: 'No `dpop-nonce` header found when required'},\n          err.resp ?? undefined    // yay ts\n        );\n      }\n      return makeTokenRequest(sdk, { url, data, dpopKeyPair, nonce: dpopNonce });\n    }\n    throw err;\n  }\n}\n\n// exchange authorization code for an access token\nexport async function postToTokenEndpoint(sdk, options: TokenEndpointParams, urls: CustomUrls): Promise<OAuthResponse> {\n  validateOptions(options);\n  var data = getPostData(sdk, options);\n\n  const params: TokenRequestParams = {\n    url: urls.tokenUrl!,\n    data,\n    dpopKeyPair: options?.dpopKeyPair\n  };\n\n  return makeTokenRequest(sdk, params);\n}\n\nexport async function postRefreshToken(\n  sdk: OktaAuthHttpInterface,\n  options: TokenEndpointParams,\n  refreshToken: RefreshToken\n): Promise<OAuthResponse> {\n  const data = Object.entries({\n    client_id: options.clientId, // eslint-disable-line camelcase\n    grant_type: 'refresh_token', // eslint-disable-line camelcase\n    scope: refreshToken.scopes.join(' '),\n    refresh_token: refreshToken.refreshToken, // eslint-disable-line camelcase\n  }).map(function ([name, value]) {\n    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n    return name + '=' + encodeURIComponent(value!);\n  }).join('&');\n\n  let url = refreshToken.tokenUrl;\n  if (options.extraParams && Object.keys(options.extraParams).length >= 1) {\n    url += toQueryString(options.extraParams);\n  }\n\n  const params: TokenRequestParams = {\n    url,\n    data,\n    dpopKeyPair: options?.dpopKeyPair\n  };\n\n  return makeTokenRequest(sdk, params);\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 */\nimport { get } from '../../http';\nimport { find } from '../../util';\nimport { OktaAuthOAuthInterface, WellKnownResponse } from '../types';\nimport AuthSdkError from '../../errors/AuthSdkError';\n\nexport function getWellKnown(sdk: OktaAuthOAuthInterface, issuer?: string): Promise<WellKnownResponse> {\n  var authServerUri = (issuer || sdk.options.issuer);\n  return get(sdk, authServerUri + '/.well-known/openid-configuration', {\n    cacheResponse: true\n  });\n}\n\nexport function getKey(sdk: OktaAuthOAuthInterface, issuer: string, kid: string): Promise<string> {\n  var httpCache = sdk.storageManager.getHttpCache(sdk.options.cookies);\n\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 = 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 get(sdk, jwksUri, {\n      cacheResponse: true\n    })\n    .then(function(res) {\n      var key = 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","/* eslint-disable @typescript-eslint/no-non-null-assertion */\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 */\nimport { OktaAuthOAuthInterface, EnrollAuthenticatorOptions } from './types';\nimport { clone } from '../util';\nimport { prepareEnrollAuthenticatorParams, createEnrollAuthenticatorMeta } from './util';\nimport { buildAuthorizeParams } from './endpoints/authorize';\n\nexport function enrollAuthenticator(\n  sdk: OktaAuthOAuthInterface, \n  options: EnrollAuthenticatorOptions\n): void {\n  options = clone(options) || {};\n\n  const params = prepareEnrollAuthenticatorParams(sdk, options);\n  const meta = createEnrollAuthenticatorMeta(sdk, params);\n  const requestUrl = meta.urls.authorizeUrl + buildAuthorizeParams(params);\n  sdk.transactionManager.save(meta);\n  if (sdk.options.setLocation) {\n    sdk.options.setLocation(requestUrl);\n  } else {\n    window.location.assign(requestUrl);\n  }\n}\n","/* eslint-disable @typescript-eslint/no-non-null-assertion */\n/* eslint-disable max-len */\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 */\nimport { CustomUrls, OAuthResponse, OAuthResponseType, OktaAuthOAuthInterface, TokenParams, TokenResponse } from './types';\nimport { getOAuthUrls, getDefaultTokenParams } from './util';\nimport { clone } from '../util';\nimport { postToTokenEndpoint, TokenEndpointParams } from './endpoints/token';\nimport { handleOAuthResponse } from './handleOAuthResponse';\nimport { createDPoPKeyPair, findKeyPair } from './dpop';\n\n// codeVerifier is required. May pass either an authorizationCode or interactionCode\nexport async function exchangeCodeForTokens(sdk: OktaAuthOAuthInterface, tokenParams: TokenParams, urls?: CustomUrls): Promise<TokenResponse> {\n  urls = urls || getOAuthUrls(sdk, tokenParams);\n  // build params using defaults + options\n  tokenParams = Object.assign({}, getDefaultTokenParams(sdk), clone(tokenParams));\n\n  const {\n    authorizationCode,\n    interactionCode,\n    codeVerifier,\n    clientId,\n    redirectUri,\n    scopes,\n    ignoreSignature,\n    state,\n    acrValues,\n    dpop,\n    dpopPairId,\n    extraParams\n  } = tokenParams;\n\n  // postToTokenEndpoint() params\n  const getTokenOptions: TokenEndpointParams = {\n    clientId,\n    redirectUri,\n    authorizationCode,\n    interactionCode,\n    codeVerifier,\n    dpop,\n  };\n\n  // `handleOAuthResponse` hanadles responses from both `/authorize` and `/token` endpoints\n  // Here we modify the response from `/token` so that it more closely matches a response from `/authorize`\n  // `responseType` is used to validate that the expected tokens were returned\n  const responseType: OAuthResponseType[] = ['token']; // an accessToken will always be returned\n  if (scopes!.indexOf('openid') !== -1) {\n    responseType.push('id_token'); // an idToken will be returned if \"openid\" is in the scopes\n  }\n  // handleOAuthResponse() params\n  const handleResponseOptions: TokenParams = {\n    clientId,\n    redirectUri,\n    scopes,\n    responseType,\n    ignoreSignature,\n    acrValues,\n    extraParams\n  };\n\n  try {\n    if (dpop) {\n      // token refresh, KP should already exist\n      if (dpopPairId) {\n        const keyPair = await findKeyPair(dpopPairId);\n        getTokenOptions.dpopKeyPair = keyPair;\n        handleResponseOptions.dpop = dpop;\n        handleResponseOptions.dpopPairId = dpopPairId;\n      }\n      else {\n        const { keyPair, keyPairId } = await createDPoPKeyPair();\n        getTokenOptions.dpopKeyPair = keyPair;\n        handleResponseOptions.dpop = dpop;\n        handleResponseOptions.dpopPairId = keyPairId;\n      }\n    }\n\n    const oauthResponse: OAuthResponse = await postToTokenEndpoint(sdk, getTokenOptions, urls);\n\n    const tokenResponse: TokenResponse = await handleOAuthResponse(sdk, handleResponseOptions, oauthResponse, urls!);\n    tokenResponse.code = authorizationCode;\n    tokenResponse.state = state!;\n    return tokenResponse;\n  }\n  finally {\n    sdk.transactionManager.clear();\n  }\n}\n","import { StorageManagerConstructor } from '../../storage/types';\nimport { OktaAuthConstructor, OktaAuthOptionsConstructor } from '../../base/types';\n\nimport { createOktaAuthBase } from '../../base';\nimport { mixinStorage } from '../../storage/mixin';\nimport { mixinSession } from '../../session/mixin';\nimport { mixinHttp } from '../../http/mixin';\nimport { mixinOAuth } from '../mixin';\nimport {\n  OAuthTransactionMeta,\n  OktaAuthOAuthInterface,\n  OktaAuthOAuthOptions,\n  OAuthStorageManagerInterface,\n  PKCETransactionMeta,\n  TransactionManagerConstructor,\n  TransactionManagerInterface\n} from '../types';\n\nexport function createOktaAuthOAuth\n<\n  M extends OAuthTransactionMeta = PKCETransactionMeta,\n  S extends OAuthStorageManagerInterface<M> = OAuthStorageManagerInterface<M>,\n  O extends OktaAuthOAuthOptions = OktaAuthOAuthOptions,\n  TM extends TransactionManagerInterface = TransactionManagerInterface\n>\n(\n  StorageManagerConstructor: StorageManagerConstructor<S>,\n  OptionsConstructor: OktaAuthOptionsConstructor<O>,\n  TransactionManagerConstructor: TransactionManagerConstructor<TM>\n):  OktaAuthConstructor<OktaAuthOAuthInterface<M, S, O, TM>>\n{\n  const Base = createOktaAuthBase(OptionsConstructor);\n  const WithStorage = mixinStorage<S, O>(Base, StorageManagerConstructor);\n  const WithHttp = mixinHttp<S, O>(WithStorage);\n  const WithSession = mixinSession<S, O>(WithHttp);\n  const WithOAuth = mixinOAuth<M, S, O, TM>(WithSession, TransactionManagerConstructor);\n  return WithOAuth;\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\nimport { PromiseQueue } from '../../util';\nimport { decodeToken } from '../decodeToken';\nimport { exchangeCodeForTokens } from '../exchangeCodeForTokens';\nimport { getUserInfo } from '../getUserInfo';\nimport { getWithoutPrompt } from '../getWithoutPrompt';\nimport { getWithPopup } from '../getWithPopup';\nimport { getWithRedirect } from '../getWithRedirect';\nimport { parseFromUrl } from '../parseFromUrl';\nimport { renewToken } from '../renewToken';\nimport { renewTokens } from '../renewTokens';\nimport { renewTokensWithRefresh } from '../renewTokensWithRefresh';\nimport { revokeToken } from '../revokeToken';\nimport { oidcIntrospect } from '../introspect';\nimport {\n  AccessToken,\n  CustomUserClaims,\n  GetWithRedirectFunction,\n  IDToken,\n  OktaAuthOAuthInterface,\n  ParseFromUrlInterface,\n  TokenAPI,\n  UserClaims,\n  Endpoints,\n} from '../types';\nimport { isLoginRedirect, prepareTokenParams } from '../util';\nimport { verifyToken } from '../verifyToken';\nimport { enrollAuthenticator } from '../enrollAuthenticator';\n\n// Factory\nexport function createTokenAPI(sdk: OktaAuthOAuthInterface, queue: PromiseQueue): TokenAPI {\n  const useQueue = (method) => {\n    return PromiseQueue.prototype.push.bind(queue, method, null);\n  };\n\n  const getWithRedirectFn = useQueue(getWithRedirect.bind(null, sdk)) as GetWithRedirectFunction;\n\n  // eslint-disable-next-line max-len\n  const parseFromUrlFn = useQueue(parseFromUrl.bind(null, sdk)) as ParseFromUrlInterface;\n  const parseFromUrlApi: ParseFromUrlInterface = Object.assign(parseFromUrlFn, {\n    // This is exposed so we can mock getting window.history in our tests\n    _getHistory: function() {\n      return window.history;\n    },\n\n    // This is exposed so we can mock getting window.location in our tests\n    _getLocation: function() {\n      return window.location;\n    },\n\n    // This is exposed so we can mock getting window.document in our tests\n    _getDocument: function() {\n      return window.document;\n    }\n  });\n\n  const token: TokenAPI ={\n    prepareTokenParams: prepareTokenParams.bind(null, sdk),\n    exchangeCodeForTokens: exchangeCodeForTokens.bind(null, sdk),\n    getWithoutPrompt: getWithoutPrompt.bind(null, sdk),\n    getWithPopup: getWithPopup.bind(null, sdk),\n    getWithRedirect: getWithRedirectFn,\n    parseFromUrl: parseFromUrlApi,\n    decode: decodeToken,\n    revoke: revokeToken.bind(null, sdk),\n    renew: renewToken.bind(null, sdk),\n    renewTokensWithRefresh: renewTokensWithRefresh.bind(null, sdk),\n    renewTokens: renewTokens.bind(null, sdk),\n    getUserInfo: <C extends CustomUserClaims = CustomUserClaims>(\n      accessTokenObject: AccessToken,\n      idTokenObject: IDToken\n    ): Promise<UserClaims<C>> => {\n      return getUserInfo(sdk, accessTokenObject, idTokenObject);\n    },\n    verify: verifyToken.bind(null, sdk),\n    isLoginRedirect: isLoginRedirect.bind(null, sdk),\n    introspect: oidcIntrospect.bind(null, sdk),\n  };\n\n  // Wrap certain async token API methods using PromiseQueue to avoid issues with concurrency\n  // 'getWithRedirect' and 'parseFromUrl' are already wrapped\n  const toWrap = [\n    'getWithoutPrompt',\n    'getWithPopup',\n    'revoke',\n    'renew',\n    'renewTokensWithRefresh',\n    'renewTokens'\n  ];\n  toWrap.forEach(key => {\n    token[key] = useQueue(token[key]);\n  });\n\n  return token;\n}\n\nexport function createEndpoints(sdk: OktaAuthOAuthInterface): Endpoints {\n  return {\n    authorize: {\n      enrollAuthenticator: enrollAuthenticator.bind(null, sdk),\n    }\n  };\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\nimport { decodeToken } from '../decodeToken';\nimport { exchangeCodeForTokens } from '../exchangeCodeForTokens';\nimport {\n  OktaAuthOAuthInterface,\n  BaseTokenAPI,\n} from '../types';\nimport { prepareTokenParams } from '../util';\n\n// Factory\nexport function createBaseTokenAPI(sdk: OktaAuthOAuthInterface): BaseTokenAPI {\n  const token: BaseTokenAPI = {\n    prepareTokenParams: prepareTokenParams.bind(null, sdk),\n    exchangeCodeForTokens: exchangeCodeForTokens.bind(null, sdk),\n    decode: decodeToken,\n  };\n\n  return token;\n}\n","export * from './api';\nexport * from './OktaAuthOAuth';\n","\n/* global document */\n/* eslint-disable complexity, max-statements */\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 */\nimport {\n  getOAuthUrls,\n  loadFrame,\n  addPostMessageListener\n} from './util';\n\nimport AuthSdkError from '../errors/AuthSdkError';\n\nimport {\n  OktaAuthOAuthInterface,\n  TokenParams,\n  PopupParams,\n  OAuthResponse,\n} from './types';\n\nimport { prepareTokenParams } from './util/prepareTokenParams';\nimport { buildAuthorizeParams } from './endpoints/authorize';\nimport { handleOAuthResponse } from './handleOAuthResponse';\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 */\nexport function getToken(sdk: OktaAuthOAuthInterface, options: TokenParams & PopupParams) {\n  if (arguments.length > 2) {\n    return Promise.reject(new AuthSdkError('As of version 3.0, \"getToken\" takes only a single set of options'));\n  }\n\n  options = options || {};\n\n  // window object cannot be serialized, save for later use\n  // TODO: move popup related params into a separate options object\n  const popupWindow = options.popupWindow;\n  options.popupWindow = undefined;\n\n  return prepareTokenParams(sdk, options)\n    .then(function (tokenParams: TokenParams) {\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 (options.sessionToken) {\n        Object.assign(tokenParams, sessionTokenOverrides);\n      } else if (options.idp) {\n        Object.assign(tokenParams, idpOverrides);\n      }\n\n      // Use the query params to build the authorize url\n      var requestUrl,\n        endpoint,\n        urls;\n\n      // Get authorizeUrl and issuer\n      urls = getOAuthUrls(sdk, tokenParams);\n      endpoint = options.codeVerifier ? urls.tokenUrl : urls.authorizeUrl;\n      requestUrl = endpoint + buildAuthorizeParams(tokenParams);\n\n      // Determine the flow type\n      var flowType;\n      if (tokenParams.sessionToken || tokenParams.display === null) {\n        flowType = 'IFRAME';\n      } else if (tokenParams.display === 'popup') {\n        flowType = 'POPUP';\n      } else {\n        flowType = 'IMPLICIT';\n      }\n\n      // Execute the flow type\n      switch (flowType) {\n        case 'IFRAME':\n          var iframePromise = addPostMessageListener(sdk, options.timeout, tokenParams.state);\n          var iframeEl = loadFrame(requestUrl);\n          return iframePromise\n            .then(function (res) {\n              return handleOAuthResponse(sdk, tokenParams, res as OAuthResponse, urls);\n            })\n            .finally(function () {\n              if (document.body.contains(iframeEl)) {\n                iframeEl.parentElement?.removeChild(iframeEl);\n              }\n            });\n\n        case 'POPUP':\n          var oauthPromise; // resolves with OAuth response\n\n          // Add listener on postMessage before window creation, so\n          // postMessage isn't triggered before we're listening\n          if (tokenParams.responseMode === 'okta_post_message') {\n            if (!sdk.features.isPopupPostMessageSupported()) {\n              throw new AuthSdkError('This browser doesn\\'t have full postMessage support');\n            }\n            oauthPromise = addPostMessageListener(sdk, options.timeout, tokenParams.state);\n          }\n\n          // Redirect for authorization\n          // popupWindown can be null when popup is blocked\n          if (popupWindow) { \n            popupWindow.location.assign(requestUrl);\n          }\n\n          // The popup may be closed without receiving an OAuth response. Setup a poller to monitor the window.\n          var popupPromise = new Promise(function (resolve, reject) {\n            var closePoller = setInterval(function () {\n              if (!popupWindow || popupWindow.closed) {\n                clearInterval(closePoller);\n                reject(new AuthSdkError('Unable to parse OAuth flow response'));\n              }\n            }, 100);\n\n            // Proxy the OAuth promise results\n            oauthPromise\n              .then(function (res) {\n                clearInterval(closePoller);\n                resolve(res);\n              })\n              .catch(function (err) {\n                clearInterval(closePoller);\n                reject(err);\n              });\n          });\n\n          return popupPromise\n            .then(function (res) {\n              return handleOAuthResponse(sdk, tokenParams, res as OAuthResponse, urls);\n            })\n            .finally(function () {\n              if (popupWindow && !popupWindow.closed) {\n                popupWindow.close();\n              }\n            });\n\n        default:\n          throw new AuthSdkError('The full page redirect flow is not supported');\n      }\n    });\n}","/* eslint-disable complexity */\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 */\nimport { AuthSdkError, OAuthError, WWWAuthError, AuthApiError } from '../errors';\nimport { httpRequest } from '../http';\nimport { AccessToken, IDToken, UserClaims, isAccessToken, isIDToken, CustomUserClaims } from './types';\n\nexport async function getUserInfo<T extends CustomUserClaims = CustomUserClaims>(\n  sdk, accessTokenObject: AccessToken,\n  idTokenObject: IDToken\n): Promise<UserClaims<T>> {\n  // If token objects were not passed, attempt to read from the TokenManager\n  if (!accessTokenObject) {\n    accessTokenObject = (await sdk.tokenManager.getTokens()).accessToken as AccessToken;\n  }\n  if (!idTokenObject) {\n    idTokenObject = (await sdk.tokenManager.getTokens()).idToken as IDToken;\n  }\n\n  if (!accessTokenObject || !isAccessToken(accessTokenObject)) {\n    return Promise.reject(new AuthSdkError('getUserInfo requires an access token object'));\n  }\n\n  if (!idTokenObject || !isIDToken(idTokenObject)) {\n    return Promise.reject(new AuthSdkError('getUserInfo requires an ID token object'));\n  }\n\n  const options: any = {\n    url: accessTokenObject.userinfoUrl,\n    method: 'GET',\n    accessToken: accessTokenObject.accessToken\n  };\n\n  if (sdk.options.dpop) {\n    const headers = await sdk.getDPoPAuthorizationHeaders({...options, accessToken: accessTokenObject });\n    options.headers = headers;\n    delete options.accessToken;      // unset to prevent overriding Auth header with Bearer Token\n  }\n\n  return httpRequest(sdk, options)\n    .then(userInfo => {\n      // Only return the userinfo response if subjects match to mitigate token substitution attacks\n      if (userInfo.sub === idTokenObject.claims.sub) {\n        return userInfo;\n      }\n      return Promise.reject(new AuthSdkError('getUserInfo request was rejected due to token mismatch'));\n    })\n    .catch(function (err) {\n      // throw OAuthError to avoid breaking change (when dpop is not being used)\n      if (err instanceof WWWAuthError && !sdk.options.dpop) {\n        const { error, errorDescription } = err;\n        throw new OAuthError(error, errorDescription);\n      }\n\n      // throw OAuthError to avoid breaking change (when dpop is not being used)\n      if (!sdk.options.dpop) {\n        let e = err;\n        if (err instanceof AuthApiError && err?.meta?.wwwAuthHeader) {\n          e = WWWAuthError.parseHeader(err.meta.wwwAuthHeader as string);\n        }\n\n        if (e instanceof WWWAuthError) {\n          const { error, errorDescription } = e;\n          throw new OAuthError(error, errorDescription);\n        }\n      }\n\n      throw err;\n    });\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 */\nimport { AuthSdkError } from '../errors';\nimport { OktaAuthOAuthInterface, TokenParams, TokenResponse } from './types';\nimport { clone } from '../util';\nimport { getToken } from './getToken';\nimport { loadPopup } from './util';\n\nexport function getWithPopup(sdk: OktaAuthOAuthInterface, options: TokenParams): Promise<TokenResponse> {\n  if (arguments.length > 2) {\n    return Promise.reject(new AuthSdkError('As of version 3.0, \"getWithPopup\" takes only a single set of options'));\n  }\n\n  // some browsers (safari, firefox) block popup if it's initialed from an async process\n  // here we create the popup window immediately after user interaction\n  // then redirect to the /authorize endpoint when the requestUrl is available\n  const popupWindow = loadPopup('/', options);\n  options = clone(options) || {};\n  Object.assign(options, {\n    display: 'popup',\n    responseMode: 'okta_post_message',\n    popupWindow\n  });\n  return getToken(sdk, options);\n}\n","/* eslint-disable @typescript-eslint/no-non-null-assertion */\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 */\nimport { AuthSdkError } from '../errors';\nimport { OktaAuthOAuthInterface, TokenParams } from './types';\nimport { clone } from '../util';\nimport { prepareTokenParams, createOAuthMeta } from './util';\nimport { buildAuthorizeParams } from './endpoints/authorize';\n\nexport async function getWithRedirect(sdk: OktaAuthOAuthInterface, options?: TokenParams): Promise<void> {\n  if (arguments.length > 2) {\n    return Promise.reject(new AuthSdkError('As of version 3.0, \"getWithRedirect\" takes only a single set of options'));\n  }\n\n  options = clone(options) || {};\n\n  const tokenParams = await prepareTokenParams(sdk, options);\n  const meta = createOAuthMeta(sdk, tokenParams);\n  const requestUrl = meta.urls.authorizeUrl + buildAuthorizeParams(tokenParams);\n  sdk.transactionManager.save(meta);\n  if (sdk.options.setLocation) {\n    sdk.options.setLocation(requestUrl);\n  } else {\n    window.location.assign(requestUrl);\n  }\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 */\nimport { AuthSdkError } from '../errors';\nimport { OktaAuthOAuthInterface, TokenParams, TokenResponse } from './types';\nimport { clone } from '../util';\nimport { getToken } from './getToken';\n\nexport function getWithoutPrompt(sdk: OktaAuthOAuthInterface, options: TokenParams): Promise<TokenResponse> {\n  if (arguments.length > 2) {\n    return Promise.reject(new AuthSdkError('As of version 3.0, \"getWithoutPrompt\" takes only a single set of options'));\n  }\n  \n  options = clone(options) || {};\n  Object.assign(options, {\n    prompt: 'none',\n    responseMode: 'okta_post_message',\n    display: null\n  });\n  return getToken(sdk, options);\n}\n\n","/* eslint-disable @typescript-eslint/no-non-null-assertion */\n\n/* eslint-disable complexity, max-statements */\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 */\nimport { clone } from '../util';\nimport {\n  getOAuthUrls,\n} from './util/oauth';\nimport { AuthSdkError, OAuthError } from '../errors';\nimport {\n  OktaAuthOAuthInterface,\n  TokenVerifyParams,\n  IDToken,\n  OAuthResponse,\n  TokenParams,\n  TokenResponse,\n  CustomUrls,\n  Tokens,\n} from './types';\nimport { verifyToken } from './verifyToken';\nimport { getDefaultTokenParams } from './util';\n\nfunction validateResponse(res: OAuthResponse, oauthParams: TokenParams) {\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  // https://datatracker.ietf.org/doc/html/rfc9449#token-response\n  // \"A token_type of DPoP MUST be included in the access token response to signal to the client\"\n  if (oauthParams.dpop && res.token_type !== 'DPoP') {\n    throw new AuthSdkError('Unable to parse OAuth flow response: DPoP was configured but \"token_type\" was not DPoP');\n  }\n}\n\nexport async function handleOAuthResponse(\n  sdk: OktaAuthOAuthInterface,\n  tokenParams: TokenParams,\n  res: OAuthResponse,\n  urls?: CustomUrls\n): Promise<TokenResponse> {\n  const pkce = sdk.options.pkce !== false;\n\n\n  // The result contains an authorization_code and PKCE is enabled \n  // `exchangeCodeForTokens` will call /token then call `handleOauthResponse` recursively with the result\n  if (pkce && (res.code || res.interaction_code)) {\n    return sdk.token.exchangeCodeForTokens(Object.assign({}, tokenParams, {\n      authorizationCode: res.code,\n      interactionCode: res.interaction_code\n    }), urls);\n  }\n\n  tokenParams = tokenParams || getDefaultTokenParams(sdk);\n  urls = urls || getOAuthUrls(sdk, tokenParams);\n\n  let responseType = tokenParams.responseType || [];\n  if (!Array.isArray(responseType) && responseType !== 'none') {\n    responseType = [responseType];\n  }\n\n  let scopes;\n  if (res.scope) {\n    scopes = res.scope.split(' ');\n  } else {\n    scopes = clone(tokenParams.scopes);\n  }\n  const clientId = tokenParams.clientId || sdk.options.clientId;\n\n  // Handling the result from implicit flow or PKCE token exchange\n  validateResponse(res, tokenParams);\n\n  const tokenDict = {} as Tokens;\n  const expiresIn = res.expires_in;\n  const tokenType = res.token_type;\n  const accessToken = res.access_token;\n  const idToken = res.id_token;\n  const refreshToken = res.refresh_token;\n  const now = Math.floor(Date.now()/1000);\n\n  if (accessToken) {\n    const accessJwt = sdk.token.decode(accessToken);\n    tokenDict.accessToken = {\n      accessToken: accessToken,\n      claims: accessJwt.payload,\n      expiresAt: Number(expiresIn) + now,\n      tokenType: tokenType!,\n      scopes: scopes,\n      authorizeUrl: urls.authorizeUrl!,\n      userinfoUrl: urls.userinfoUrl!\n    };\n\n    if (tokenParams.dpopPairId) {\n      tokenDict.accessToken.dpopPairId = tokenParams.dpopPairId;\n    }\n\n    if (tokenParams.extraParams) {\n      tokenDict.accessToken.extraParams = tokenParams.extraParams;\n    }\n  }\n\n  if (refreshToken) {\n    tokenDict.refreshToken = {\n      refreshToken: refreshToken,\n      // should not be used, this is the accessToken expire time\n      // TODO: remove \"expiresAt\" in the next major version OKTA-407224\n      expiresAt: Number(expiresIn) + now, \n      scopes: scopes,\n      tokenUrl: urls.tokenUrl!,\n      authorizeUrl: urls.authorizeUrl!,\n      issuer: urls.issuer!,\n    };\n\n    if (tokenParams.dpopPairId) {\n      tokenDict.refreshToken.dpopPairId = tokenParams.dpopPairId;\n    }\n\n    if (tokenParams.extraParams) {\n      tokenDict.refreshToken.extraParams = tokenParams.extraParams;\n    }\n  }\n\n  if (idToken) {\n    const idJwt = sdk.token.decode(idToken);\n    const idTokenObj: IDToken = {\n      idToken: idToken,\n      claims: idJwt.payload,\n      expiresAt: idJwt.payload.exp! - idJwt.payload.iat! + now, // adjusting expiresAt to be in local time\n      scopes: scopes,\n      authorizeUrl: urls.authorizeUrl!,\n      issuer: urls.issuer!,\n      clientId: clientId!\n    };\n\n    if (tokenParams.extraParams) {\n      idTokenObj.extraParams = tokenParams.extraParams;\n    }\n\n    const validationParams: TokenVerifyParams = {\n      clientId: clientId!,\n      issuer: urls.issuer!,\n      nonce: tokenParams.nonce,\n      accessToken: accessToken,\n      acrValues: tokenParams.acrValues\n    };\n\n    if (tokenParams.ignoreSignature !== undefined) {\n      validationParams.ignoreSignature = tokenParams.ignoreSignature;\n    }\n\n    await verifyToken(sdk, idTokenObj, validationParams);\n    tokenDict.idToken = idTokenObj;\n  }\n\n  // Validate received tokens against requested response types \n  if (responseType.indexOf('token') !== -1 && !tokenDict.accessToken) {\n    // eslint-disable-next-line max-len\n    throw new AuthSdkError('Unable to parse OAuth flow response: response type \"token\" was requested but \"access_token\" was not returned.');\n  }\n  if (responseType.indexOf('id_token') !== -1 && !tokenDict.idToken) {\n    // eslint-disable-next-line max-len\n    throw new AuthSdkError('Unable to parse OAuth flow response: response type \"id_token\" was requested but \"id_token\" was not returned.');\n  }\n\n  return {\n    tokens: tokenDict,\n    state: res.state!,\n    code: res.code,\n    responseType\n  };\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 */\nexport * from './factory';\nexport * from './mixin';\nexport * from './storage';\nexport * from './endpoints';\nexport * from './options';\nexport * from './types';\nexport * from './TokenManager';\nexport * from './TransactionManager';\nexport * from './util';\n\nexport { decodeToken } from './decodeToken';\nexport { revokeToken } from './revokeToken';\nexport { renewToken } from './renewToken';\nexport { renewTokensWithRefresh } from './renewTokensWithRefresh';\nexport { renewTokens } from './renewTokens';\nexport { verifyToken } from './verifyToken';\nexport { getUserInfo } from './getUserInfo';\nexport { handleOAuthResponse } from './handleOAuthResponse';\nexport { exchangeCodeForTokens } from './exchangeCodeForTokens';\nexport { getToken } from './getToken';\nexport { getWithoutPrompt } from './getWithoutPrompt';\nexport { getWithPopup } from './getWithPopup';\nexport { getWithRedirect } from './getWithRedirect';\nexport { parseFromUrl } from './parseFromUrl';\nexport { oidcIntrospect } from './introspect';\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\nimport { AuthSdkError } from '../errors';\nimport { getWellKnown } from './endpoints/well-known';\nimport { post } from '../http';\nimport { toQueryString } from '../util';\nimport { btoa } from '../crypto';\nimport { Token, TokenKind } from './types';\n\nconst hintMap = {\n  accessToken: 'access_token',\n  idToken: 'id_token',\n  refreshToken: 'refresh_token'\n};\n\n/* eslint complexity: [2, 9] */\nexport async function oidcIntrospect (sdk, kind: TokenKind, token?: Token) {\n  let issuer: string;\n  let clientId: string = sdk.options.clientId;\n  let clientSecret: string | undefined = sdk.options.clientSecret;\n\n  if (!token) {\n    token = sdk.tokenManager.getTokens()[kind];\n  }\n\n  if (!token) {\n    throw new AuthSdkError(`unable to find ${kind} in storage or fn params`);\n  }\n\n  if (kind !== TokenKind.ACCESS) {\n    issuer = (token as any)?.issuer;\n  }\n  else {\n    issuer = (token as any)?.claims?.iss;\n  }\n  issuer = issuer || sdk.options.issuer;\n\n  if (!clientId) {\n    throw new AuthSdkError('A clientId must be specified in the OktaAuth constructor to introspect a token');\n  }\n  if (!issuer) {\n    throw new AuthSdkError('Unable to find issuer');\n  }\n\n  const { introspection_endpoint: introspectUrl }  = await getWellKnown(sdk, issuer);\n  const authHeader = clientSecret ? btoa(`${clientId}:${clientSecret}`) : btoa(clientId);\n  const args = toQueryString({\n    // eslint-disable-next-line camelcase\n    token_type_hint: hintMap[kind],\n    token: token[kind]    // extract raw token string from token object\n  }).slice(1);\n  return post(sdk, introspectUrl, args, {\n    headers: {\n      'Content-Type': 'application/x-www-form-urlencoded',\n      'Authorization': 'Basic ' + authHeader\n    }\n  });\n}\n","import { REFERRER_PATH_STORAGE_KEY } from '../../constants';\nimport browserStorage from '../../browser/browserStorage';\nimport { OktaAuthStorageInterface } from '../../storage';\nimport { OktaAuthConstructor } from '../../base';\nimport {\n  OAuthStorageManagerInterface,\n  OAuthTransactionMeta,\n  OktaAuthOAuthOptions,\n  OriginalUriApi,\n  PKCETransactionMeta,\n} from '../types';\n\nexport function provideOriginalUri\n<\n  M extends OAuthTransactionMeta = PKCETransactionMeta,\n  S extends OAuthStorageManagerInterface<M> = OAuthStorageManagerInterface<M>,\n  O extends OktaAuthOAuthOptions = OktaAuthOAuthOptions,\n  TBase extends OktaAuthConstructor<OktaAuthStorageInterface<S, O>>\n    = OktaAuthConstructor<OktaAuthStorageInterface<S, O>> \n>\n(BaseClass: TBase) {\n  return class WithOriginalUri extends BaseClass implements OriginalUriApi {\n    setOriginalUri(originalUri: string, state?: string): void {\n      // always store in session storage\n      const sessionStorage = browserStorage.getSessionStorage();\n      sessionStorage.setItem(REFERRER_PATH_STORAGE_KEY, originalUri);\n  \n      // to support multi-tab flows, set a state in constructor or pass as param\n      state = state || this.options.state;\n      if (state) {\n        const sharedStorage = this.storageManager.getOriginalUriStorage();\n        sharedStorage.setItem(state, originalUri);\n      }\n    }\n  \n    getOriginalUri(state?: string): string | undefined {\n      // Prefer shared storage (if state is available)\n      state = state || this.options.state;\n      if (state) {\n        const sharedStorage = this.storageManager.getOriginalUriStorage();\n        const originalUri = sharedStorage.getItem(state);\n        if (originalUri) {\n          return originalUri;\n        }\n      }\n  \n      // Try to load from session storage\n      const storage = browserStorage.getSessionStorage();\n      return storage ? storage.getItem(REFERRER_PATH_STORAGE_KEY) || undefined : undefined;\n    }\n  \n    removeOriginalUri(state?: string): void {\n      // Remove from sessionStorage\n      const storage = browserStorage.getSessionStorage();\n      storage.removeItem(REFERRER_PATH_STORAGE_KEY);\n  \n      // Also remove from shared storage\n      state = state || this.options.state;\n      if (state) {\n        const sharedStorage = this.storageManager.getOriginalUriStorage();\n        sharedStorage.removeItem && sharedStorage.removeItem(state);\n      }\n    }\n  };\n}\n","import { httpRequest, RequestOptions } from '../../http';\nimport { OktaAuthConstructor } from '../../base/types';\nimport { \n  PromiseQueue,\n  isFunction\n} from '../../util';\nimport { CryptoAPI } from '../../crypto/types';\nimport * as crypto from '../../crypto';\nimport {\n  AccessToken,\n  CustomUserClaims,\n  IDToken,\n  IsAuthenticatedOptions,\n  OAuthResponseType,\n  OAuthStorageManagerInterface,\n  OAuthTransactionMeta,\n  OktaAuthOAuthInterface,\n  OktaAuthOAuthOptions,\n  PkceAPI,\n  PKCETransactionMeta,\n  RefreshToken,\n  SigninWithRedirectOptions,\n  SignoutOptions,\n  SignoutRedirectUrlOptions,\n  TokenAPI,\n  TransactionManagerInterface,\n  TransactionManagerConstructor,\n  UserClaims,\n  Endpoints,\n  DPoPRequest,\n  DPoPHeaders\n} from '../types';\nimport PKCE from '../util/pkce';\nimport { createEndpoints, createTokenAPI } from '../factory/api';\nimport { TokenManager } from '../TokenManager';\nimport { getOAuthUrls, isLoginRedirect, hasResponseType } from '../util';\nimport { \n  generateDPoPProof,\n  clearDPoPKeyPair,\n  clearAllDPoPKeyPairs,\n  clearDPoPKeyPairAfterRevoke,\n  findKeyPair,\n  isDPoPNonceError\n} from '../dpop';\nimport { AuthSdkError, WWWAuthError } from '../../errors';\n\nimport { OktaAuthSessionInterface } from '../../session/types';\nimport { provideOriginalUri } from './node';\nexport function mixinOAuth\n<\n  M extends OAuthTransactionMeta = PKCETransactionMeta,\n  S extends OAuthStorageManagerInterface<M> = OAuthStorageManagerInterface<M>,\n  O extends OktaAuthOAuthOptions = OktaAuthOAuthOptions,\n  TM extends TransactionManagerInterface = TransactionManagerInterface,\n  TBase extends OktaAuthConstructor<OktaAuthSessionInterface<S, O>>\n    = OktaAuthConstructor<OktaAuthSessionInterface<S, O>>\n>\n(\n  Base: TBase,\n  TransactionManagerConstructor: TransactionManagerConstructor<TM>,\n): TBase & OktaAuthConstructor<OktaAuthOAuthInterface<M, S, O, TM>>\n{\n  const WithOriginalUri = provideOriginalUri(Base);\n  return class OktaAuthOAuth extends WithOriginalUri\n  implements OktaAuthOAuthInterface<M, S, O, TM>\n  {\n    static crypto: CryptoAPI = crypto;\n    token: TokenAPI;\n    tokenManager: TokenManager;\n    transactionManager: TM;\n    pkce: PkceAPI;\n    endpoints: Endpoints;\n\n    _pending: { handleLogin: boolean };\n    _tokenQueue: PromiseQueue;\n    \n    constructor(...args: any[]) {\n      super(...args);\n\n      this.transactionManager = new TransactionManagerConstructor(Object.assign({\n        storageManager: this.storageManager,\n      }, this.options.transactionManager));\n  \n      this.pkce = {\n        DEFAULT_CODE_CHALLENGE_METHOD: PKCE.DEFAULT_CODE_CHALLENGE_METHOD,\n        generateVerifier: PKCE.generateVerifier,\n        computeChallenge: PKCE.computeChallenge\n      };\n  \n      this._pending = { handleLogin: false };\n\n      this._tokenQueue = new PromiseQueue();\n\n      this.token = createTokenAPI(this, this._tokenQueue);\n\n      // TokenManager\n      this.tokenManager = new TokenManager(this, this.options.tokenManager);\n\n      this.endpoints = createEndpoints(this);\n    }\n\n    // inherited from subclass\n    clearStorage(): void {\n      super.clearStorage();\n      \n      // Clear all local tokens\n      this.tokenManager.clear();\n    }\n\n    // Returns true if both accessToken and idToken are not expired\n    // If `autoRenew` option is set, will attempt to renew expired tokens before returning.\n    // eslint-disable-next-line complexity\n    async isAuthenticated(options: IsAuthenticatedOptions = {}): Promise<boolean> {\n      // TODO: remove dependency on tokenManager options in next major version - OKTA-473815\n      const { autoRenew, autoRemove } = this.tokenManager.getOptions();\n\n      const shouldRenew = options.onExpiredToken ? options.onExpiredToken === 'renew' : autoRenew;\n      const shouldRemove = options.onExpiredToken ? options.onExpiredToken === 'remove' : autoRemove;\n\n      let { accessToken } = this.tokenManager.getTokensSync();\n      if (accessToken && this.tokenManager.hasExpired(accessToken)) {\n        accessToken = undefined;\n        if (shouldRenew) {\n          try {\n            accessToken = await this.tokenManager.renew('accessToken') as AccessToken;\n          } catch {\n            // Renew errors will emit an \"error\" event \n          }\n        } else if (shouldRemove) {\n          this.tokenManager.remove('accessToken');\n        }\n      }\n\n      let { idToken } = this.tokenManager.getTokensSync();\n      if (idToken && this.tokenManager.hasExpired(idToken)) {\n        idToken = undefined;\n        if (shouldRenew) {\n          try {\n            idToken = await this.tokenManager.renew('idToken') as IDToken;\n          } catch {\n            // Renew errors will emit an \"error\" event \n          }\n        } else if (shouldRemove) {\n          this.tokenManager.remove('idToken');\n        }\n      }\n\n      return !!(accessToken && idToken);\n    }\n\n\n    async signInWithRedirect(opts: SigninWithRedirectOptions = {}) {\n      const { originalUri, ...additionalParams } = opts;\n      if(this._pending.handleLogin) { \n        // Don't trigger second round\n        return;\n      }\n\n      this._pending.handleLogin = true;\n      try {\n        // Trigger default signIn redirect flow\n        if (originalUri) {\n          this.setOriginalUri(originalUri);\n        }\n        const params = Object.assign({\n          // TODO: remove this line when default scopes are changed OKTA-343294\n          scopes: this.options.scopes || ['openid', 'email', 'profile']\n        }, additionalParams);\n        await this.token.getWithRedirect(params);\n      } finally {\n        this._pending.handleLogin = false;\n      }\n    }\n\n    async getUser<T extends CustomUserClaims = CustomUserClaims>(): Promise<UserClaims<T>> {\n      const { idToken, accessToken } = this.tokenManager.getTokensSync();\n      return this.token.getUserInfo(accessToken, idToken);\n    }\n  \n    getIdToken(): string | undefined {\n      const { idToken } = this.tokenManager.getTokensSync();\n      return idToken ? idToken.idToken : undefined;\n    }\n  \n    getAccessToken(): string | undefined {\n      const { accessToken } = this.tokenManager.getTokensSync();\n      return accessToken ? accessToken.accessToken : undefined;\n    }\n  \n    getRefreshToken(): string | undefined {\n      const { refreshToken } = this.tokenManager.getTokensSync();\n      return refreshToken ? refreshToken.refreshToken : undefined;\n    }\n\n    async getOrRenewAccessToken(): Promise<string | null> {\n      const { accessToken } = this.tokenManager.getTokensSync();\n      if (accessToken && !this.tokenManager.hasExpired(accessToken)) {\n        return accessToken.accessToken;\n      }\n      try {\n        const key = this.tokenManager.getStorageKeyByType('accessToken');\n        const token = await this.tokenManager.renew(key ?? 'accessToken');\n        return (token as AccessToken)?.accessToken ?? null;\n      }\n      catch (err) {\n        this.emitter.emit('error', err);\n        return null;\n      }\n    }\n  \n    /**\n     * Store parsed tokens from redirect url\n     */\n    async storeTokensFromRedirect(): Promise<void> {\n      const { tokens, responseType } = await this.token.parseFromUrl();\n      if (responseType !== 'none') {\n        this.tokenManager.setTokens(tokens);\n      }\n    }\n  \n    isLoginRedirect(): boolean {\n      return isLoginRedirect(this);\n    }\n\n    isPKCE(): boolean {\n      return !!this.options.pkce;\n    }\n\n    hasResponseType(responseType: OAuthResponseType): boolean {\n      return hasResponseType(responseType, this.options);\n    }\n  \n    isAuthorizationCodeFlow(): boolean {\n      return this.hasResponseType('code');\n    }\n\n    // Escape hatch method to make arbitrary OKTA API call\n    async invokeApiMethod(options: RequestOptions): Promise<unknown> {\n      if (!options.accessToken) {\n        const accessToken = (await this.tokenManager.getTokens()).accessToken as AccessToken;\n        options.accessToken = accessToken?.accessToken;\n      }\n      return httpRequest(this, options);\n    }\n    \n    // Revokes the access token for the application session\n    async revokeAccessToken(accessToken?: AccessToken): Promise<unknown> {\n      if (!accessToken) {\n        const tokens = await this.tokenManager.getTokens();\n        accessToken = tokens.accessToken;\n        const accessTokenKey = this.tokenManager.getStorageKeyByType('accessToken');\n        this.tokenManager.remove(accessTokenKey);\n\n        if (this.options.dpop) {\n          await clearDPoPKeyPairAfterRevoke('access', tokens);\n        }\n      }\n      // Access token may have been removed. In this case, we will silently succeed.\n      if (!accessToken) {\n        return Promise.resolve(null);\n      }\n      return this.token.revoke(accessToken);\n    }\n\n    // Revokes the refresh token for the application session\n    async revokeRefreshToken(refreshToken?: RefreshToken): Promise<unknown> {\n      if (!refreshToken) {\n        const tokens = await this.tokenManager.getTokens();\n        refreshToken = tokens.refreshToken;\n        const refreshTokenKey = this.tokenManager.getStorageKeyByType('refreshToken');\n        this.tokenManager.remove(refreshTokenKey);\n\n        if (this.options.dpop) {\n          await clearDPoPKeyPairAfterRevoke('refresh', tokens);\n        }\n      }\n      // Refresh token may have been removed. In this case, we will silently succeed.\n      if (!refreshToken) {\n        return Promise.resolve(null);\n      }\n      return this.token.revoke(refreshToken);\n    }\n\n    getSignOutRedirectUrl(options: SignoutRedirectUrlOptions = {}) {\n      let {\n        idToken,\n        postLogoutRedirectUri,\n        state,\n      } = options;\n      if (!idToken) {\n        idToken = this.tokenManager.getTokensSync().idToken as IDToken;\n      }\n      if (!idToken) {\n        return '';\n      }\n      if (postLogoutRedirectUri === undefined) {\n        postLogoutRedirectUri = this.options.postLogoutRedirectUri;\n      }\n\n      const logoutUrl = getOAuthUrls(this).logoutUrl;\n      const idTokenHint = idToken.idToken; // a string\n      let logoutUri = logoutUrl + '?id_token_hint=' + encodeURIComponent(idTokenHint);\n      if (postLogoutRedirectUri) {\n        logoutUri += '&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      return logoutUri;\n    }\n\n    // Revokes refreshToken or accessToken, clears all local tokens, then redirects to Okta to end the SSO session.\n    // eslint-disable-next-line complexity, max-statements\n    async signOut(options?: SignoutOptions): Promise<boolean> {\n      options = Object.assign({}, options);\n    \n      // postLogoutRedirectUri must be whitelisted in Okta Admin UI\n      const defaultUri = window.location.origin;\n      const currentUri = window.location.href;\n      // Fix for issue/1410 - allow for no postLogoutRedirectUri to be passed, resulting in /logout default behavior\n      //    \"If no Okta session exists, this endpoint has no effect and the browser is redirected immediately to the\n      //    Okta sign-in page or the post_logout_redirect_uri (if specified).\"\n      // - https://developer.okta.com/docs/reference/api/oidc/#logout\n      const postLogoutRedirectUri = options.postLogoutRedirectUri === null ? null :\n        (options.postLogoutRedirectUri\n        || this.options.postLogoutRedirectUri\n        || defaultUri);\n      const state = options?.state;\n      \n    \n      let accessToken = options.accessToken;\n      let refreshToken = options.refreshToken;\n      const revokeAccessToken = options.revokeAccessToken !== false;\n      const revokeRefreshToken = options.revokeRefreshToken !== false;\n    \n      if (revokeRefreshToken && typeof refreshToken === 'undefined') {\n        refreshToken = this.tokenManager.getTokensSync().refreshToken as RefreshToken;\n      }\n\n      if (revokeAccessToken && typeof accessToken === 'undefined') {\n        accessToken = this.tokenManager.getTokensSync().accessToken as AccessToken;\n      }\n    \n      if (!options.idToken) {\n        options.idToken = this.tokenManager.getTokensSync().idToken as IDToken;\n      }\n\n      if (revokeRefreshToken && refreshToken) {\n        await this.revokeRefreshToken(refreshToken);\n      }\n\n      if (revokeAccessToken && accessToken) {\n        await this.revokeAccessToken(accessToken);\n      }\n\n      const dpopPairId = accessToken?.dpopPairId ?? refreshToken?.dpopPairId;\n      if (this.options.dpop && dpopPairId) {\n        await clearDPoPKeyPair(dpopPairId);\n      }\n\n      const logoutUri = this.getSignOutRedirectUrl({ ...options, postLogoutRedirectUri });\n      // No logoutUri? This can happen if the storage was cleared.\n      // Fallback to XHR signOut, then simulate a redirect to the post logout uri\n      if (!logoutUri) {\n        // local tokens are cleared once session is closed\n        const sessionClosed = await this.closeSession();   // can throw if the user cannot be signed out\n        const redirectUri = new URL(postLogoutRedirectUri || defaultUri); // during fallback, redirectUri cannot be null\n        if (state) {\n          redirectUri.searchParams.append('state', state);\n        }\n        if (postLogoutRedirectUri === currentUri) {\n          // window.location.reload(); // force a hard reload if URI is not changing\n          window.location.href = redirectUri.href;\n        } else {\n          window.location.assign(redirectUri.href);\n        }\n        return sessionClosed;\n      } else {\n        if (options.clearTokensBeforeRedirect) {\n          // Clear all local tokens\n          this.tokenManager.clear();\n        } else {\n          this.tokenManager.addPendingRemoveFlags();\n        }\n        // Flow ends with logout redirect\n        window.location.assign(logoutUri);\n        return true;\n      }\n    }\n\n    async getDPoPAuthorizationHeaders (params: DPoPRequest): Promise<DPoPHeaders> {\n      if (!this.options.dpop) {\n        throw new AuthSdkError('DPoP is not configured for this client instance');\n      }\n\n      let { accessToken } = params;\n      if (!accessToken) {\n        accessToken = (this.tokenManager.getTokensSync()).accessToken;\n      }\n\n      if (!accessToken) {\n        throw new AuthSdkError('AccessToken is required to generate a DPoP Proof');\n      }\n\n      const keyPair = await findKeyPair(accessToken?.dpopPairId);\n      const proof = await generateDPoPProof({...params, keyPair, accessToken: accessToken.accessToken});\n      return {\n        Authorization: `DPoP ${accessToken.accessToken}`,\n        Dpop: proof\n      };\n    }\n\n    async clearDPoPStorage (clearAll=false): Promise<void> {\n      if (clearAll) {\n        return clearAllDPoPKeyPairs();\n      }\n\n      const tokens = await this.tokenManager.getTokens();\n      const keyPair = tokens.accessToken?.dpopPairId || tokens.refreshToken?.dpopPairId;\n\n      if (keyPair) {\n        await clearDPoPKeyPair(keyPair);\n      }\n    }\n\n    parseUseDPoPNonceError (headers: HeadersInit): string | null {\n      const wwwAuth = WWWAuthError.getWWWAuthenticateHeader(headers);\n      const wwwErr = WWWAuthError.parseHeader(wwwAuth ?? '');\n      if (isDPoPNonceError(wwwErr)) {\n        let nonce: string | null = null;\n        if (isFunction((headers as Headers)?.get)) {\n          nonce = (headers as Headers).get('DPoP-Nonce');\n        }\n        nonce = nonce ?? headers['dpop-nonce'] ?? headers['DPoP-Nonce'];\n        return nonce;\n      }\n\n      return null;\n    }\n  };\n\n}\n","\nimport { OktaAuthConstructor } from '../../base/types';\nimport {\n  OAuthResponseType,\n  OAuthStorageManagerInterface,\n  OAuthTransactionMeta,\n  MinimalOktaOAuthInterface,\n  OktaAuthOAuthOptions,\n  PKCETransactionMeta,\n  BaseTokenAPI,\n  TransactionManagerInterface,\n  TransactionManagerConstructor,\n} from '../types';\nimport { createBaseTokenAPI } from '../factory/baseApi';\nimport { isLoginRedirect, hasResponseType } from '../util';\n\nimport { OktaAuthSessionInterface } from '../../session/types';\nexport function mixinMinimalOAuth\n<\n  M extends OAuthTransactionMeta = PKCETransactionMeta,\n  S extends OAuthStorageManagerInterface<M> = OAuthStorageManagerInterface<M>,\n  O extends OktaAuthOAuthOptions = OktaAuthOAuthOptions,\n  TM extends TransactionManagerInterface = TransactionManagerInterface,\n  TBase extends OktaAuthConstructor<OktaAuthSessionInterface<S, O>>\n    = OktaAuthConstructor<OktaAuthSessionInterface<S, O>>\n>\n(\n  Base: TBase,\n  TransactionManagerConstructor: TransactionManagerConstructor<TM>,\n): TBase & OktaAuthConstructor<MinimalOktaOAuthInterface<M, S, O, TM>>\n{\n  return class OktaAuthOAuth extends Base implements MinimalOktaOAuthInterface<M, S, O, TM>\n  {\n    token: BaseTokenAPI;\n    transactionManager: TM;\n    \n    constructor(...args: any[]) {\n      super(...args);\n\n      this.transactionManager = new TransactionManagerConstructor(Object.assign({\n        storageManager: this.storageManager,\n      }, this.options.transactionManager));\n  \n      this.token = createBaseTokenAPI(this as any);\n    }\n\n    isLoginRedirect(): boolean {\n      return isLoginRedirect(this as any);\n    }\n\n    isPKCE(): boolean {\n      return !!this.options.pkce;\n    }\n\n    hasResponseType(responseType: OAuthResponseType): boolean {\n      return hasResponseType(responseType, this.options);\n    }\n\n    isAuthorizationCodeFlow(): boolean {\n      return this.hasResponseType('code');\n    }\n\n  };\n\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\nimport { DEFAULT_MAX_CLOCK_SKEW } from '../../constants';\nimport { removeTrailingSlash, toAbsoluteUrl } from '../../util/url';\nimport { isBrowser } from '../../features';\nimport { createHttpOptionsConstructor } from '../../http/options';\nimport {\n  OAuthResponseMode,\n  OAuthResponseType,\n  OktaAuthOAuthInterface,\n  OktaAuthOAuthOptions,\n  SetLocationFunction,\n  TokenManagerOptions,\n  TransactionManagerOptions\n} from '../types';\nimport { enableSharedStorage } from './node';\nimport AuthSdkError from '../../errors/AuthSdkError';\n\nfunction assertValidConfig(args) {\n  args = args || {};\n\n  var scopes = args.scopes;\n  if (scopes && !Array.isArray(scopes)) {\n    throw new AuthSdkError('scopes must be a array of strings. ' +\n      'Required usage: new OktaAuth({scopes: [\"openid\", \"email\"]})');\n  }\n\n  // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n  var issuer = args.issuer!;\n  if (!issuer) {\n    throw new AuthSdkError('No issuer passed to constructor. ' + \n      'Required usage: new OktaAuth({issuer: \"https://{yourOktaDomain}.com/oauth2/{authServerId}\"})');\n  }\n\n  var isUrlRegex = new RegExp('^http?s?://.+');\n  if (!isUrlRegex.test(issuer)) {\n    throw new AuthSdkError('Issuer must be a valid URL. ' + \n      'Required usage: new OktaAuth({issuer: \"https://{yourOktaDomain}.com/oauth2/{authServerId}\"})');\n  }\n\n  if (issuer.indexOf('-admin.okta') !== -1) {\n    throw new AuthSdkError('Issuer URL passed to constructor contains \"-admin\" in subdomain. ' +\n      'Required usage: new OktaAuth({issuer: \"https://{yourOktaDomain}.com})');\n  }\n}\n\nexport function createOAuthOptionsConstructor() {\n  const HttpOptionsConstructor = createHttpOptionsConstructor();\n  return class OAuthOptionsConstructor\n    extends HttpOptionsConstructor\n    implements Required<OktaAuthOAuthOptions>\n  {\n    // CustomUrls\n    issuer: string;\n    authorizeUrl: string;\n    userinfoUrl: string;\n    tokenUrl: string;\n    revokeUrl: string;\n    logoutUrl: string;\n    \n    // TokenParams\n    pkce: boolean;\n    clientId: string;\n    redirectUri: string;\n    responseType: OAuthResponseType | OAuthResponseType[];\n    responseMode: OAuthResponseMode;\n    state: string;\n    scopes: string[];\n    ignoreSignature: boolean;\n    codeChallenge: string;\n    codeChallengeMethod: string;\n    acrValues: string;\n    maxAge: string | number;\n    dpop: boolean;\n\n    // Additional options\n    tokenManager: TokenManagerOptions;\n    postLogoutRedirectUri: string;\n    restoreOriginalUri: (oktaAuth: OktaAuthOAuthInterface, originalUri?: string) => Promise<void>;\n    transactionManager: TransactionManagerOptions;\n\n    // For server-side web applications ONLY!\n    clientSecret: string;\n    setLocation: SetLocationFunction;\n\n    // Workaround for bad client time/clock\n    ignoreLifetime: boolean;\n    maxClockSkew: number;\n\n\n    // eslint-disable-next-line max-statements\n    constructor(options: any) {\n      super(options);\n      \n      assertValidConfig(options);\n      \n      this.issuer = removeTrailingSlash(options.issuer);\n      this.tokenUrl = removeTrailingSlash(options.tokenUrl);\n      this.authorizeUrl = removeTrailingSlash(options.authorizeUrl);\n      this.userinfoUrl = removeTrailingSlash(options.userinfoUrl);\n      this.revokeUrl = removeTrailingSlash(options.revokeUrl);\n      this.logoutUrl = removeTrailingSlash(options.logoutUrl);\n\n      this.pkce = options.pkce === false ? false : true; // PKCE defaults to true\n      this.clientId = options.clientId;\n      this.redirectUri = options.redirectUri;\n      if (isBrowser()) {\n        this.redirectUri = toAbsoluteUrl(options.redirectUri, window.location.origin); // allow relative URIs\n      }\n      this.responseType = options.responseType;\n      this.responseMode = options.responseMode;\n      this.state = options.state;\n      this.scopes = options.scopes;\n      // Give the developer the ability to disable token signature validation.\n      this.ignoreSignature = !!options.ignoreSignature;\n      this.codeChallenge = options.codeChallenge;\n      this.codeChallengeMethod = options.codeChallengeMethod;\n      this.acrValues = options.acrValues;\n      this.maxAge = options.maxAge;\n      this.dpop = options.dpop === true; // dpop defaults to false\n\n      this.tokenManager = options.tokenManager;\n      this.postLogoutRedirectUri = options.postLogoutRedirectUri;\n      this.restoreOriginalUri = options.restoreOriginalUri;\n      this.transactionManager = { enableSharedStorage, ...options.transactionManager };\n      \n      this.clientSecret = options.clientSecret;\n      this.setLocation = options.setLocation;\n      \n      // As some end user's devices can have their date \n      // and time incorrectly set, allow for the disabling\n      // of the jwt liftetime validation\n      this.ignoreLifetime = !!options.ignoreLifetime;\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 (!options.maxClockSkew && options.maxClockSkew !== 0) {\n        this.maxClockSkew = DEFAULT_MAX_CLOCK_SKEW;\n      } else {\n        this.maxClockSkew = options.maxClockSkew;\n      }\n\n    }\n  };\n}\n","export const enableSharedStorage = true;\n","export * from './OAuthOptionsConstructor';\n","/* eslint-disable complexity */\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 */\nimport { AuthSdkError } from '../errors';\nimport { isInteractionRequiredError, urlParamsToObject } from './util';\nimport {\n  ParseFromUrlOptions,\n  TokenResponse,\n  CustomUrls,\n  TransactionMeta,\n  OAuthResponse\n} from './types';\nimport { isString } from '../util';\nimport { handleOAuthResponse } from './handleOAuthResponse';\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\nexport function getResponseMode(sdk): 'query' | 'fragment' {\n  // https://openid.net/specs/openid-connect-core-1_0.html#Authentication\n  var defaultResponseMode = sdk.options.pkce ? 'query' : 'fragment';\n  var responseMode = sdk.options.responseMode || defaultResponseMode;\n  return responseMode;\n}\n\nexport function parseOAuthResponseFromUrl(sdk, options: string | ParseFromUrlOptions): OAuthResponse {\n  options = options || {};\n  if (isString(options)) {\n    options = { url: options } as ParseFromUrlOptions;\n  } else {\n    options = options as ParseFromUrlOptions;\n  }\n\n  var url = options.url;\n  var responseMode = options.responseMode || getResponseMode(sdk);\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    throw new AuthSdkError('Unable to parse a token from the url');\n  }\n\n  return urlParamsToObject(paramStr);\n}\n\nexport function cleanOAuthResponseFromUrl(sdk, options: ParseFromUrlOptions) {\n  // Clean hash or search from the url\n  const responseMode = options.responseMode || getResponseMode(sdk);\n  responseMode === 'query' ? removeSearch(sdk) : removeHash(sdk);\n}\n\nexport async function parseFromUrl(sdk, options?: string | ParseFromUrlOptions): Promise<TokenResponse> {\n  options = options || {};\n  if (isString(options)) {\n    options = { url: options } as ParseFromUrlOptions;\n  } else {\n    options = options as ParseFromUrlOptions;\n  }\n\n  const res: OAuthResponse = parseOAuthResponseFromUrl(sdk, options);\n  const state = res.state;\n  const oauthParams: TransactionMeta = sdk.transactionManager.load({\n    state\n  });\n  if (!oauthParams) {\n    if (sdk.options.pkce) {\n      // eslint-disable-next-line max-len\n      throw new AuthSdkError('Could not load PKCE codeVerifier from storage. This may indicate the auth flow has already completed or multiple auth flows are executing concurrently.', undefined);\n    }\n    throw new AuthSdkError('Unable to retrieve OAuth redirect params from storage');\n  }\n  const urls: CustomUrls = oauthParams.urls as CustomUrls;\n  delete oauthParams.urls;\n\n  if (!options.url) {\n    // Clean hash or search from the url\n    cleanOAuthResponseFromUrl(sdk, options);\n  }\n\n  return handleOAuthResponse(sdk, oauthParams, res, urls)\n    .catch(err => {\n      if (!isInteractionRequiredError(err)) {\n        sdk.transactionManager.clear({\n          state\n        });\n      }\n      throw err;\n    })\n    .then(res => {\n      sdk.transactionManager.clear({\n        state\n      });\n      return res;\n    });\n\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 */\nimport { AuthSdkError } from '../errors';\nimport { OktaAuthOAuthInterface, Token, Tokens, isAccessToken, AccessToken, IDToken, isIDToken } from './types';\nimport { getWithoutPrompt } from './getWithoutPrompt';\nimport { renewTokensWithRefresh } from './renewTokensWithRefresh';\n\nfunction throwInvalidTokenError() {\n  throw new AuthSdkError(\n    'Renew must be passed a token with an array of scopes and an accessToken or idToken'\n  );\n}\n\n// Multiple tokens may have come back. Return only the token which was requested.\nfunction getSingleToken(originalToken: Token, tokens: Tokens) {\n  if (isIDToken(originalToken)) {\n    return tokens.idToken;\n  }\n  if (isAccessToken(originalToken)) {\n    return tokens.accessToken;\n  }\n  throwInvalidTokenError();\n}\n\n// If we have a refresh token, renew using that, otherwise getWithoutPrompt\nexport async function renewToken(sdk: OktaAuthOAuthInterface, token: Token): Promise<Token | undefined> {\n  if (!isIDToken(token) && !isAccessToken(token)) {\n    throwInvalidTokenError();\n  }\n\n  let tokens = sdk.tokenManager.getTokensSync();\n  if (tokens.refreshToken) {\n    tokens = await renewTokensWithRefresh(sdk, {\n      scopes: token.scopes,\n    }, tokens.refreshToken);\n    return getSingleToken(token, tokens);\n  }\n\n  var responseType;\n  if (sdk.options.pkce) {\n    responseType = 'code';\n  } else if (isAccessToken(token)) {\n    responseType = 'token';\n  } else {\n    responseType = 'id_token';\n  }\n\n  const { scopes, authorizeUrl, userinfoUrl, issuer, dpopPairId, extraParams } = token as (AccessToken & IDToken);\n  return getWithoutPrompt(sdk, {\n    responseType,\n    scopes,\n    authorizeUrl,\n    userinfoUrl,\n    issuer,\n    dpopPairId,\n    extraParams\n  })\n    .then(function (res) {\n      return getSingleToken(token, res.tokens);\n    });\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 */\nimport { AuthSdkError } from '../errors';\nimport { RenewTokensParams, Tokens } from './types';\nimport { getWithoutPrompt } from './getWithoutPrompt';\nimport { renewTokensWithRefresh } from './renewTokensWithRefresh';\nimport { getDefaultTokenParams } from './util';\n\n// If we have a refresh token, renew using that, otherwise getWithoutPrompt\n// eslint-disable-next-line complexity\nexport async function renewTokens(sdk, options?: RenewTokensParams): Promise<Tokens> {\n  const tokens = options?.tokens ?? sdk.tokenManager.getTokensSync();\n  if (tokens.refreshToken) {\n    return renewTokensWithRefresh(sdk, options || {}, tokens.refreshToken);\n  }\n\n  if (!tokens.accessToken && !tokens.idToken) {\n    throw new AuthSdkError('renewTokens() was called but there is no existing token');\n  }\n\n  const accessToken = tokens.accessToken || {};\n  const idToken = tokens.idToken || {};\n  const scopes = accessToken.scopes || idToken.scopes;\n  if (!scopes) {\n    throw new AuthSdkError('renewTokens: invalid tokens: could not read scopes');\n  }\n  const authorizeUrl = accessToken.authorizeUrl || idToken.authorizeUrl;\n  if (!authorizeUrl) {\n    throw new AuthSdkError('renewTokens: invalid tokens: could not read authorizeUrl');\n  }\n  const userinfoUrl = accessToken.userinfoUrl || sdk.options.userinfoUrl;\n  const issuer = idToken.issuer || sdk.options.issuer;\n  const dpopPairId = accessToken?.dpopPairId;\n  const extraParams = accessToken?.extraParams || idToken?.extraParams;\n\n  // Get tokens using the SSO cookie\n  options = Object.assign({\n    scopes,\n    authorizeUrl,\n    userinfoUrl,\n    issuer,\n    dpopPairId,\n    extraParams\n  }, options);\n\n  if (sdk.options.pkce) {\n    options.responseType = 'code';\n  } else {\n    const { responseType } = getDefaultTokenParams(sdk);\n    options.responseType = responseType;\n  }\n\n  return getWithoutPrompt(sdk, options)\n    .then(res => res.tokens);\n    \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 */\nimport { AuthSdkError } from '../errors';\nimport { getOAuthUrls } from './util/oauth';\nimport { isSameRefreshToken } from './util/refreshToken';\nimport { OktaAuthOAuthInterface, TokenParams, RefreshToken, Tokens } from './types';\nimport { handleOAuthResponse } from './handleOAuthResponse';\nimport { TokenEndpointParams, postRefreshToken } from './endpoints/token';\nimport { findKeyPair } from './dpop';\nimport { isRefreshTokenInvalidError } from './util/errors';\n\n/* eslint complexity:[0,8] */\nexport async function renewTokensWithRefresh(\n  sdk: OktaAuthOAuthInterface,\n  tokenParams: TokenParams,\n  refreshTokenObject: RefreshToken\n): Promise<Tokens> {\n  const { clientId, dpop } = sdk.options;\n  if (!clientId) {\n    throw new AuthSdkError('A clientId must be specified in the OktaAuth constructor to renew tokens');\n  }\n\n  try {\n    const renewTokenParams: TokenParams = Object.assign({}, tokenParams, { clientId });\n\n    if (refreshTokenObject.extraParams) {\n      renewTokenParams.extraParams = refreshTokenObject.extraParams;\n    }\n\n    const endpointParams: TokenEndpointParams = {...renewTokenParams};\n\n    if (dpop) {\n      const keyPair = await findKeyPair(refreshTokenObject?.dpopPairId);    // will throw if KP cannot be found\n      endpointParams.dpopKeyPair = keyPair;\n      renewTokenParams.dpop = dpop;\n      renewTokenParams.dpopPairId = refreshTokenObject.dpopPairId;\n    }\n\n    const tokenResponse = await postRefreshToken(sdk, endpointParams, refreshTokenObject);\n    const urls = getOAuthUrls(sdk, tokenParams);\n    const { tokens } = await handleOAuthResponse(sdk, renewTokenParams, tokenResponse, urls);\n\n    // Support rotating refresh tokens\n    const { refreshToken } = tokens;\n    if (refreshToken && !isSameRefreshToken(refreshToken, refreshTokenObject)) {\n      sdk.tokenManager.updateRefreshToken(refreshToken);\n    }\n\n    return tokens;\n  }\n  catch (err) {\n    if (isRefreshTokenInvalidError(err)) {\n      // if the refresh token is invalid, remove it from storage\n      sdk.tokenManager.removeRefreshToken();\n    }\n    throw err;\n  }\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] */\nimport { post } from '../http';\nimport { toQueryString } from '../util';\nimport {\n  getOAuthUrls,\n} from './util/oauth';\nimport { btoa } from '../crypto';\nimport AuthSdkError from '../errors/AuthSdkError';\nimport {\n  OktaAuthOAuthInterface,\n  RevocableToken,\n  AccessToken,\n  RefreshToken\n} from './types';\n\n// refresh tokens have precedence to be revoked if no token is specified\nexport async function revokeToken(sdk: OktaAuthOAuthInterface, token: RevocableToken): Promise<any> {\n  let accessToken = '';\n  let refreshToken = '';\n  if (token) { \n      accessToken = (token as AccessToken).accessToken;\n      refreshToken = (token as RefreshToken).refreshToken;  \n  }\n  if(!accessToken && !refreshToken) { \n    throw new AuthSdkError('A valid access or refresh token object is required');\n  }\n  var clientId = sdk.options.clientId;\n  var clientSecret = sdk.options.clientSecret;\n  if (!clientId) {\n    throw new AuthSdkError('A clientId must be specified in the OktaAuth constructor to revoke a token');\n  }\n  // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n  var revokeUrl = getOAuthUrls(sdk).revokeUrl!;\n  var args = toQueryString({\n    // eslint-disable-next-line camelcase\n    token_type_hint: refreshToken ? 'refresh_token' : 'access_token', \n    token: refreshToken || accessToken,\n  }).slice(1);\n  var creds = clientSecret ? btoa(`${clientId}:${clientSecret}`) : btoa(clientId);\n  return post(sdk, revokeUrl, args, {\n    headers: {\n      'Content-Type': 'application/x-www-form-urlencoded',\n      'Authorization': 'Basic ' + creds\n    }\n  });\n}\n","import {\n  CookieOptions,\n  StorageManagerOptions,\n  StorageOptions,\n  StorageUtil\n} from '../storage/types';\nimport { BaseStorageManager, logServerSideMemoryStorageWarning } from '../storage/BaseStorageManager';\nimport { TransactionStorage, OAuthTransactionMeta, OAuthStorageManagerInterface, PKCETransactionMeta } from './types';\nimport { SavedObject } from '../storage';\nimport { ORIGINAL_URI_STORAGE_NAME, SHARED_TRANSACTION_STORAGE_NAME, TRANSACTION_STORAGE_NAME } from '../constants';\n\n\nexport function createOAuthStorageManager<M extends OAuthTransactionMeta = PKCETransactionMeta>()\n{\n  return class OAuthStorageManager\n    extends BaseStorageManager\n    implements OAuthStorageManagerInterface<M>\n  {\n    constructor(storageManagerOptions: StorageManagerOptions, cookieOptions: CookieOptions, storageUtil: StorageUtil) {\n      super(storageManagerOptions, cookieOptions, storageUtil);\n    }\n\n    getTransactionStorage(options?: StorageOptions): TransactionStorage<M> {\n      options = this.getOptionsForSection('transaction', options);\n      logServerSideMemoryStorageWarning(options);\n      const storage = this.getStorage(options);\n      const storageKey = options.storageKey || TRANSACTION_STORAGE_NAME;\n      return new SavedObject(storage, storageKey);\n    }\n\n    getSharedTansactionStorage(options?: StorageOptions): TransactionStorage<M> {\n      options = this.getOptionsForSection('shared-transaction', options);\n      logServerSideMemoryStorageWarning(options);\n      const storage = this.getStorage(options);\n      const storageKey = options.storageKey || SHARED_TRANSACTION_STORAGE_NAME;\n      return new SavedObject(storage, storageKey);\n    }\n\n    getOriginalUriStorage(options?: StorageOptions): TransactionStorage<M> {\n      options = this.getOptionsForSection('original-uri', options);\n      logServerSideMemoryStorageWarning(options);\n      const storage = this.getStorage(options);\n      const storageKey = options.storageKey || ORIGINAL_URI_STORAGE_NAME;\n      return new SavedObject(storage, storageKey);\n    }\n  };\n\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\nimport { UserClaims } from './UserClaims';\n\nexport interface AbstractToken {\n  expiresAt: number;\n  authorizeUrl: string;\n  scopes: string[];\n  pendingRemove?: boolean;\n  extraParams?: Record<string, string>;\n}\n\nexport interface AccessToken extends AbstractToken {\n  accessToken: string;\n  claims: UserClaims;\n  tokenType: string;\n  userinfoUrl: string;\n  dpopPairId?: string;\n}\n\nexport interface RefreshToken extends AbstractToken {\n  refreshToken: string;\n  tokenUrl: string;\n  issuer: string;\n  dpopPairId?: string;\n}\n\nexport interface IDToken extends AbstractToken {\n  idToken: string;\n  claims: UserClaims;\n  issuer: string;\n  clientId: string;\n}\n\nexport type Token = AccessToken | IDToken | RefreshToken;\nexport type RevocableToken = AccessToken | RefreshToken;\n\nexport type TokenType = 'accessToken' | 'idToken' | 'refreshToken';\nexport enum TokenKind {\n  ACCESS = 'accessToken',\n  ID = 'idToken',\n  REFRESH = 'refreshToken',\n}\n\nexport function isToken(obj: any): obj is Token {\n  if (obj &&\n      (obj.accessToken || obj.idToken || obj.refreshToken) &&\n      Array.isArray(obj.scopes)) {\n    return true;\n  }\n  return false;\n}\n\nexport function isAccessToken(obj: any): obj is AccessToken {\n  return obj && obj.accessToken;\n}\n\nexport function isIDToken(obj: any): obj is IDToken {\n  return obj && obj.idToken;\n}\n\nexport function isRefreshToken(obj: any): obj is RefreshToken {\n  return obj && obj.refreshToken;\n}\n\nexport interface Tokens {\n  accessToken?: AccessToken;\n  idToken?: IDToken;\n  refreshToken?: RefreshToken;\n}\n","/* eslint-disable max-len */\nimport { StorageProvider } from '../../storage/types';\nimport { TokenManagerOptions } from './options';\nimport { AccessToken, IDToken, RefreshToken, Token, Tokens, TokenType } from './Token';\n\nexport interface TokenManagerError {\n  errorSummary: string;\n  errorCode: string;\n  message: string;\n  name: string;\n  tokenKey: string;\n}\n\nexport declare type AccessTokenCallback = (key: string, token: AccessToken) => void;\nexport declare type IDTokenCallback = (key: string, token: IDToken) => void;\nexport declare type RefreshTokenCallback = (key: string, token: RefreshToken) => void;\n\nexport const EVENT_EXPIRED = 'expired';\nexport const EVENT_RENEWED = 'renewed';\nexport const EVENT_ADDED = 'added';\nexport const EVENT_REMOVED = 'removed';\nexport const EVENT_ERROR = 'error';\nexport const EVENT_SET_STORAGE = 'set_storage';\n\nexport declare type TokenManagerErrorEventHandler = (error: TokenManagerError) => void;\nexport declare type TokenManagerEventHandler = (key: string, token: Token) => void;\nexport declare type TokenManagerRenewEventHandler = (key: string, token: Token, oldtoken: Token) => void;\nexport declare type TokenManagerSetStorageEventHandler = (storage: Tokens) => void;\n\nexport declare type TokenManagerAnyEventHandler = TokenManagerErrorEventHandler | TokenManagerRenewEventHandler | TokenManagerSetStorageEventHandler | TokenManagerEventHandler;\nexport declare type TokenManagerAnyEvent = typeof EVENT_RENEWED | typeof EVENT_ERROR | typeof EVENT_SET_STORAGE | typeof EVENT_EXPIRED | typeof EVENT_ADDED | typeof EVENT_REMOVED;\n\n// only add methods needed internally\nexport interface TokenManagerInterface {\n  on(event: typeof EVENT_RENEWED, handler: TokenManagerRenewEventHandler, context?: object): void;\n  on(event: typeof EVENT_ERROR, handler: TokenManagerErrorEventHandler, context?: object): void;\n  on(event: typeof EVENT_SET_STORAGE, handler: TokenManagerSetStorageEventHandler, context?: object): void;\n  on(event: typeof EVENT_EXPIRED | typeof EVENT_ADDED | typeof EVENT_REMOVED, handler: TokenManagerEventHandler, context?: object): void;\n\n  off(event: typeof EVENT_RENEWED, handler?: TokenManagerRenewEventHandler): void;\n  off(event: typeof EVENT_ERROR, handler?: TokenManagerErrorEventHandler): void;\n  off(event: typeof EVENT_SET_STORAGE, handler?: TokenManagerSetStorageEventHandler): void;\n  off(event: typeof EVENT_EXPIRED | typeof EVENT_ADDED | typeof EVENT_REMOVED, handler?: TokenManagerEventHandler): void;\n\n  clear(): void;\n  setExpireEventTimeout(key: string, token: Token): void;\n  clearExpireEventTimeout(key: string): void;\n  clearExpireEventTimeoutAll(): void;\n  emitAdded(key: string, token: Token): void;\n  emitError(error: Error): void;\n  emitRemoved(key: string, token: Token): void;\n  emitRenewed(key: string, token: Token, oldToken?: Token): void;\n  renew(key: string): Promise<Token | undefined>;\n  remove(key: string): void;\n  hasExpired(token: Token): boolean;\n  getExpireTime(token: Token): number;\n\n  get(key): Promise<Token | undefined>;\n  getSync(key): Token | undefined;\n  getTokens(): Promise<Tokens>;\n  getTokensSync(): Tokens;\n  setTokens({ accessToken, idToken, refreshToken }: Tokens, accessTokenCb?: AccessTokenCallback, idTokenCb?: IDTokenCallback, refreshTokenCb?: RefreshTokenCallback): void;\n  getStorageKeyByType(type: TokenType): string;\n  add(key: any, token: Token): void;\n  updateRefreshToken(token: RefreshToken);\n  removeRefreshToken(): void;\n  clearPendingRemoveTokens(): void;\n\n  getOptions(): TokenManagerOptions;\n  getStorage(): StorageProvider;\n\n  start();\n  stop();\n  isStarted(): boolean;\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\nimport { IdxTransactionMeta } from '../../idx/types/meta';\nimport { OAuthTransactionMeta, PKCETransactionMeta } from './meta';\nimport { OAuthStorageManagerInterface } from './storage';\n\nexport interface TransactionManagerOptions\n{\n  storageManager?: OAuthStorageManagerInterface;\n  enableSharedStorage?: boolean; // default true\n  saveNonceCookie?: boolean; // default true\n  saveStateCookie?: boolean; // default true\n  saveParamsCookie?: boolean; // default true\n  saveLastResponse?: boolean; // default true\n}\n\n\nexport type CustomAuthTransactionMeta = Record<string, string | undefined>;\n\nexport type TransactionMeta =\n  IdxTransactionMeta |\n  PKCETransactionMeta |\n  OAuthTransactionMeta |\n  CustomAuthTransactionMeta;\n\n\nfunction isObjectWithProperties(obj) {\n  if (!obj || typeof obj !== 'object' || Object.values(obj).length === 0) {\n    return false;\n  }\n  return true;\n}\n\nexport function isOAuthTransactionMeta(obj: any): obj is OAuthTransactionMeta {\n  if (!isObjectWithProperties(obj)) {\n    return false;\n  }\n  return !!obj.redirectUri || !!obj.responseType;\n}\n\nexport function isPKCETransactionMeta(obj: any): obj is PKCETransactionMeta {\n  if (!isOAuthTransactionMeta(obj)) {\n    return false;\n  }\n  return !!(obj as any).codeVerifier;\n}\n\nexport function isIdxTransactionMeta(obj: any): obj is IdxTransactionMeta {\n  if (!isPKCETransactionMeta(obj)) {\n    return false;\n  }\n  return !!(obj as any).interactionHandle;\n}\n\nexport function isCustomAuthTransactionMeta(obj: any): obj is CustomAuthTransactionMeta {\n  if (!isObjectWithProperties(obj)) {\n    return false;\n  }\n  const isAllStringValues = Object.values(obj).find((value) => (typeof value !== 'string')) === undefined;\n  return isAllStringValues;\n}\n\nexport function isTransactionMeta(obj: any): obj is TransactionMeta {\n  if (isOAuthTransactionMeta(obj) || isCustomAuthTransactionMeta(obj)) {\n    return true;\n  }\n  return false;\n}\n","/*!\n * Copyright (c) 2021-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\nexport * from './api';\nexport * from './JWT';\nexport * from './meta';\nexport * from './options';\nexport * from './proto';\nexport * from './storage';\nexport * from './Token';\nexport * from './TokenManager';\nexport * from './Transaction';\nexport * from './TransactionManager';\nexport * from './UserClaims';\nexport * from './endpoints';\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/* global window, document */\n/* eslint-disable complexity, max-statements */\nimport { AuthSdkError } from '../../errors';\nimport { OktaAuthOAuthInterface } from '../types';\n\nexport function addListener(eventTarget, name, fn) {\n  if (eventTarget.addEventListener) {\n    eventTarget.addEventListener(name, fn);\n  } else {\n    eventTarget.attachEvent('on' + name, fn);\n  }\n}\n\nexport function removeListener(eventTarget, name, fn) {\n  if (eventTarget.removeEventListener) {\n    eventTarget.removeEventListener(name, fn);\n  } else {\n    eventTarget.detachEvent('on' + name, fn);\n  }\n}\n\nexport function 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\nexport function 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  return window.open(src, title, appearance);\n}\n\nexport function addPostMessageListener(sdk: OktaAuthOAuthInterface, timeout, state) {\n  var responseHandler;\n  var timeoutId;\n  var msgReceivedOrTimeout = new Promise(function (resolve, reject) {\n\n    responseHandler = 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.getIssuerOrigin()) {\n        return reject(new AuthSdkError('The request does not match client configuration'));\n      }\n      resolve(e.data);\n    };\n\n    addListener(window, 'message', responseHandler);\n\n    timeoutId = setTimeout(function () {\n      reject(new AuthSdkError('OAuth flow timed out'));\n    }, timeout || 120000);\n  });\n\n  return msgReceivedOrTimeout\n    .finally(function () {\n      clearTimeout(timeoutId);\n      removeListener(window, 'message', responseHandler);\n    });\n}\n","\n/* global window */\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 */\nimport { generateState } from './oauth';\nimport { OktaAuthOAuthInterface, TokenParams } from '../types';\nimport { isBrowser } from '../../features';\nimport { removeNils } from '../../util';\n\nexport function getDefaultEnrollAuthenticatorParams(sdk: OktaAuthOAuthInterface): TokenParams {\n  const {\n    clientId,\n    redirectUri,\n    responseMode,\n    state,\n  } = sdk.options;\n  const defaultRedirectUri = isBrowser() ? window.location.href : undefined;\n  return removeNils({\n    clientId,\n    redirectUri: redirectUri || defaultRedirectUri,\n    responseMode,\n    state: state || generateState(),\n    responseType: 'none',\n    prompt: 'enroll_authenticator',\n  });\n}","\n/* global window */\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 */\nimport { generateNonce, generateState } from './oauth';\nimport { OktaAuthOAuthInterface, TokenParams } from '../types';\nimport { isBrowser } from '../../features';\nimport { removeNils } from '../../util';\n\nexport function getDefaultTokenParams(sdk: OktaAuthOAuthInterface): TokenParams {\n  const {\n    pkce,\n    clientId,\n    redirectUri,\n    responseType,\n    responseMode,\n    scopes,\n    acrValues,\n    maxAge,\n    state,\n    ignoreSignature,\n    dpop\n  } = sdk.options;\n  const defaultRedirectUri = isBrowser() ? window.location.href : undefined;\n  return removeNils({\n    pkce,\n    clientId,\n    redirectUri: redirectUri || defaultRedirectUri,\n    responseType: responseType || ['token', 'id_token'],\n    responseMode,\n    state: state || generateState(),\n    nonce: generateNonce(),\n    scopes: scopes || ['openid', 'email'],\n    acrValues,\n    maxAge,\n    ignoreSignature,\n    dpop,\n  });\n}","/* eslint-disable @typescript-eslint/no-non-null-assertion */\nimport { OAuthTransactionMeta, OktaAuthOAuthInterface, EnrollAuthenticatorOptions } from '../types';\nimport { getOAuthUrls } from './oauth';\n\nexport function createEnrollAuthenticatorMeta(\n  sdk: OktaAuthOAuthInterface, \n  params: EnrollAuthenticatorOptions\n): OAuthTransactionMeta {\n  const issuer = sdk.options.issuer!;\n  const urls = getOAuthUrls(sdk, params);\n  const oauthMeta: OAuthTransactionMeta = {\n    issuer,\n    urls,\n    clientId: params.clientId!,\n    redirectUri: params.redirectUri!,\n    responseType: params.responseType!,\n    responseMode: params.responseMode!,\n    state: params.state!,\n    acrValues: params.acrValues,\n    enrollAmrValues: params.enrollAmrValues,\n  };\n\n  return oauthMeta;\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\nimport { OktaAuthOAuthInterface } from '../types';\nimport { OAuthError, AuthApiError, isOAuthError } from '../../errors';\n\nexport function isInteractionRequiredError(error: Error) {\n  if (error.name !== 'OAuthError') {\n    return false;\n  }\n  const oauthError = error as OAuthError;\n  return (oauthError.errorCode === 'interaction_required');\n}\n\nexport function isAuthorizationCodeError(sdk: OktaAuthOAuthInterface, error: Error) {\n  if (error.name !== 'AuthApiError') {\n    return false;\n  }\n  const authApiError = error as AuthApiError;\n  // xhr property doesn't seem to match XMLHttpRequest type\n  const errorResponse = authApiError.xhr as unknown as Record<string, unknown>;\n  const responseJSON = errorResponse?.responseJSON as Record<string, unknown>;\n  return sdk.options.pkce && (responseJSON?.error as string === 'invalid_grant');\n}\n\nexport function isRefreshTokenInvalidError(error: unknown): boolean {\n  // error: {\"error\":\"invalid_grant\",\"error_description\":\"The refresh token is invalid or expired.\"}\n  return isOAuthError(error) &&\n    error.errorCode === 'invalid_grant' &&\n    error.errorSummary === 'The refresh token is invalid or expired.';\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\nexport * from './browser';\nexport * from './defaultTokenParams';\nexport * from './defaultEnrollAuthenticatorParams';\nexport * from './errors';\nexport * from './loginRedirect';\nexport * from './oauth';\nexport * from './oauthMeta';\nexport * from './enrollAuthenticatorMeta';\nimport pkce from './pkce';\nexport { pkce };\nexport * from './prepareTokenParams';\nexport * from './prepareEnrollAuthenticatorParams';\nexport * from './refreshToken';\nexport * from './urlParams';\nexport * from './validateClaims';\nexport * from './validateToken';\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/* global window */\n/* eslint-disable complexity, max-statements */\nimport { OktaAuthOAuthOptions, OktaAuthOAuthInterface, OAuthResponseType } from '../types';\n\nexport function hasTokensInHash(hash: string): boolean {\n  return /((id|access)_token=)/i.test(hash);\n}\n\n// authorization_code\nexport function hasAuthorizationCode(hashOrSearch: string): boolean {\n  return /(code=)/i.test(hashOrSearch);\n}\n\n// interaction_code\nexport function hasInteractionCode(hashOrSearch: string): boolean {\n  return /(interaction_code=)/i.test(hashOrSearch);\n}\n\nexport function hasErrorInUrl(hashOrSearch: string): boolean {\n  return /(error=)/i.test(hashOrSearch) || /(error_description)/i.test(hashOrSearch);\n}\n\nexport function isRedirectUri(uri: string, sdk: OktaAuthOAuthInterface): boolean {\n  var authParams = sdk.options;\n  if (!uri || !authParams.redirectUri) {\n    return false;\n  }\n  return uri.indexOf(authParams.redirectUri) === 0;\n}\n\nexport function isCodeFlow(options: OktaAuthOAuthOptions) {\n  return options.pkce || options.responseType === 'code' || options.responseMode === 'query';\n}\n\nexport function hasResponseType(responseType: OAuthResponseType, options: OktaAuthOAuthOptions): boolean {\n  let hasResponseType = false;\n  if (Array.isArray(options.responseType) && options.responseType.length) {\n    hasResponseType = options.responseType.indexOf(responseType) >= 0;\n  } else {\n    hasResponseType = options.responseType === responseType;\n  }\n  return hasResponseType;\n}\n\nexport function getHashOrSearch(options: OktaAuthOAuthOptions) {\n  var codeFlow = isCodeFlow(options);\n  var useQuery = codeFlow && options.responseMode !== 'fragment';\n  return useQuery ? window.location.search : window.location.hash;\n}\n\n/**\n * Check if tokens or a code have been passed back into the url, which happens in\n * the OIDC (including social auth IDP) redirect flow.\n */\nexport function isLoginRedirect (sdk: OktaAuthOAuthInterface) {\n  // First check, is this a redirect URI?\n  if (!isRedirectUri(window.location.href, sdk)){\n    return false;\n  }\n\n  // The location contains either a code, token, or an error + error_description\n  var codeFlow = isCodeFlow(sdk.options);\n  var hashOrSearch = getHashOrSearch(sdk.options);\n\n  if (hasErrorInUrl(hashOrSearch)) {\n    return true;\n  }\n\n  if (codeFlow) {\n    var hasCode =  hasAuthorizationCode(hashOrSearch) || hasInteractionCode(hashOrSearch);\n    return hasCode;\n  }\n\n  // implicit flow, will always be hash fragment\n  return hasTokensInHash(window.location.hash);\n}\n\n/**\n * Check if error=interaction_required has been passed back in the url, which happens in\n * the social auth IDP redirect flow.\n */\nexport function isInteractionRequired (sdk: OktaAuthOAuthInterface, hashOrSearch?: string) {\n  if (!hashOrSearch) { // web only\n    // First check, is this a redirect URI?\n    if (!isLoginRedirect(sdk)){\n      return false;\n    }\n  \n    hashOrSearch = getHashOrSearch(sdk.options);\n  }\n  return /(error=interaction_required)/i.test(hashOrSearch);\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/* eslint-disable complexity, max-statements */\nimport { genRandomString, removeTrailingSlash } from '../../util';\nimport AuthSdkError from '../../errors/AuthSdkError';\nimport { OktaAuthOAuthInterface, CustomUrls } from '../types';\n\nexport function generateState() {\n  return genRandomString(64);\n}\n\nexport function generateNonce() {\n  return genRandomString(64);\n}\n\nfunction getIssuer(sdk: OktaAuthOAuthInterface, options: CustomUrls = {}) {\n  const issuer = removeTrailingSlash(options.issuer) || sdk.options.issuer;\n  return issuer;\n}\n\nexport function getOAuthBaseUrl(sdk: OktaAuthOAuthInterface, options: CustomUrls = {}) {\n  const issuer = getIssuer(sdk, options);\n  const baseUrl = issuer.indexOf('/oauth2') > 0 ? issuer : issuer + '/oauth2';\n  return baseUrl;\n}\n\nexport function getOAuthDomain(sdk: OktaAuthOAuthInterface, options: CustomUrls = {}) {\n  const issuer = getIssuer(sdk, options);\n  const domain = issuer.split('/oauth2')[0];\n  return domain;\n}\n\nexport function getOAuthUrls(sdk: OktaAuthOAuthInterface, options?: CustomUrls): CustomUrls {\n  if (arguments.length > 2) {\n    throw new AuthSdkError('As of version 3.0, \"getOAuthUrls\" takes only a single set of options');\n  }\n  options = options || {};\n\n  // Get user-supplied arguments\n  var authorizeUrl = removeTrailingSlash(options.authorizeUrl) || sdk.options.authorizeUrl;\n  var issuer = getIssuer(sdk, options);\n  var userinfoUrl = removeTrailingSlash(options.userinfoUrl) || sdk.options.userinfoUrl;\n  var tokenUrl = removeTrailingSlash(options.tokenUrl) || sdk.options.tokenUrl;\n  var logoutUrl = removeTrailingSlash(options.logoutUrl) || sdk.options.logoutUrl;\n  var revokeUrl = removeTrailingSlash(options.revokeUrl) || sdk.options.revokeUrl;\n\n  var baseUrl = getOAuthBaseUrl(sdk, options);\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","/* eslint-disable @typescript-eslint/no-non-null-assertion */\nimport { OAuthTransactionMeta, OktaAuthOAuthInterface, PKCETransactionMeta, TokenParams } from '../types';\nimport { getOAuthUrls } from './oauth';\n\nexport function createOAuthMeta(\n  sdk: OktaAuthOAuthInterface, \n  tokenParams: TokenParams\n): OAuthTransactionMeta | PKCETransactionMeta {\n  const issuer = sdk.options.issuer!;\n  const urls = getOAuthUrls(sdk, tokenParams);\n  const oauthMeta: OAuthTransactionMeta = {\n    issuer,\n    urls,\n    clientId: tokenParams.clientId!,\n    redirectUri: tokenParams.redirectUri!,\n    responseType: tokenParams.responseType!,\n    responseMode: tokenParams.responseMode!,\n    scopes: tokenParams.scopes!,\n    state: tokenParams.state!,\n    nonce: tokenParams.nonce!,\n    ignoreSignature: tokenParams.ignoreSignature!,\n    acrValues: tokenParams.acrValues,\n    extraParams: tokenParams.extraParams\n  };\n\n  if (tokenParams.pkce === false) {\n    // Implicit flow or authorization_code without PKCE\n    return oauthMeta;\n  }\n\n  const pkceMeta: PKCETransactionMeta = {\n    ...oauthMeta,\n    codeVerifier: tokenParams.codeVerifier!,\n    codeChallengeMethod: tokenParams.codeChallengeMethod!,\n    codeChallenge: tokenParams.codeChallenge!,\n  };\n\n  return pkceMeta;\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 */\nimport { stringToBase64Url, webcrypto } from '../../crypto';\nimport { MIN_VERIFIER_LENGTH, MAX_VERIFIER_LENGTH, DEFAULT_CODE_CHALLENGE_METHOD } from '../../constants';\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  webcrypto.getRandomValues(a);\n  var str = Array.from(a, dec2hex).join('');\n  return str.slice(0, length);\n}\n\nfunction generateVerifier(prefix?: string): string {\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 computeChallenge(str: string): PromiseLike<any> {  \n  var buffer = new TextEncoder().encode(str);\n  return webcrypto.subtle.digest('SHA-256', buffer).then(function(arrayBuffer) {\n    var hash = String.fromCharCode.apply(null, new Uint8Array(arrayBuffer) as unknown as number[]);\n    var b64u = stringToBase64Url(hash); // url-safe base64 variant\n    return b64u;\n  });\n}\n\nexport default {\n  DEFAULT_CODE_CHALLENGE_METHOD,\n  generateVerifier,\n  computeChallenge\n};\n","/* eslint-disable complexity */\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 */\nimport { AuthSdkError } from '../../errors';\nimport { OktaAuthOAuthInterface, EnrollAuthenticatorOptions } from '../types';\nimport { getDefaultEnrollAuthenticatorParams } from './defaultEnrollAuthenticatorParams';\n\nfunction prepareParams(\n  params: EnrollAuthenticatorOptions\n): EnrollAuthenticatorOptions {\n  params = {\n    ...params,\n    // forced params:\n    responseType: 'none',\n    prompt: 'enroll_authenticator',\n    maxAge: 0,\n  };\n\n  if (!params.enrollAmrValues) {\n    throw new AuthSdkError('enroll_amr_values must be specified');\n  }\n  if (!params.acrValues) {\n    // `acr_values` is required and should equal 'urn:okta:2fa:any:ifpossible'\n    // But this can be changed in future\n    throw new AuthSdkError('acr_values must be specified');\n  }\n\n  // `scope`, `nonce` must be omitted\n  delete params.scopes;\n  delete params.nonce;\n\n  return params;\n}\n\n// Prepares params for a call to /authorize\nexport function prepareEnrollAuthenticatorParams(\n  sdk: OktaAuthOAuthInterface,\n  options: EnrollAuthenticatorOptions\n): EnrollAuthenticatorOptions {\n  return prepareParams({\n    ...getDefaultEnrollAuthenticatorParams(sdk),\n    ...options\n  });\n}\n","/* eslint-disable complexity */\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 */\nimport { getWellKnown } from '../endpoints/well-known';\nimport { AuthSdkError } from '../../errors';\nimport { OktaAuthOAuthInterface, TokenParams } from '../types';\nimport { getDefaultTokenParams } from './defaultTokenParams';\nimport { DEFAULT_CODE_CHALLENGE_METHOD } from '../../constants';\nimport PKCE from './pkce';\nimport { OktaAuthBaseInterface } from '../../base/types';\n\nexport function assertPKCESupport(sdk: OktaAuthBaseInterface) {\n  if (!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      // eslint-disable-next-line max-len\n      errorMessage += '\\nThe current page is not being served with HTTPS protocol. PKCE requires secure HTTPS protocol.';\n    }\n    if (!sdk.features.hasTextEncoder()) {\n      // eslint-disable-next-line max-len\n      errorMessage += '\\n\"TextEncoder\" is not defined. To use PKCE, you may need to include a polyfill/shim for this browser.';\n    }\n    throw new AuthSdkError(errorMessage);\n  }\n}\n\nexport async function validateCodeChallengeMethod(sdk: OktaAuthOAuthInterface, codeChallengeMethod?: string) {\n  // set default code challenge method, if none provided\n  codeChallengeMethod = codeChallengeMethod || sdk.options.codeChallengeMethod || DEFAULT_CODE_CHALLENGE_METHOD;\n\n  // validate against .well-known/openid-configuration\n  const wellKnownResponse = await getWellKnown(sdk);\n  var methods = wellKnownResponse['code_challenge_methods_supported'] || [];\n  if (methods.indexOf(codeChallengeMethod) === -1) {\n    throw new AuthSdkError('Invalid code_challenge_method');\n  }\n  return codeChallengeMethod;\n}\n\nexport async function preparePKCE(\n  sdk: OktaAuthOAuthInterface, \n  tokenParams: TokenParams\n): Promise<TokenParams> {\n  let {\n    codeVerifier,\n    codeChallenge,\n    codeChallengeMethod\n  } = tokenParams;\n\n  // PKCE calculations can be avoided by passing a codeChallenge\n  codeChallenge = codeChallenge || sdk.options.codeChallenge;\n  if (!codeChallenge) {\n    assertPKCESupport(sdk);\n    codeVerifier = codeVerifier || PKCE.generateVerifier();\n    codeChallenge = await PKCE.computeChallenge(codeVerifier);\n  }\n  codeChallengeMethod = await validateCodeChallengeMethod(sdk, codeChallengeMethod);\n\n  // Clone/copy the params. Set PKCE values\n  tokenParams = {\n    ...tokenParams,\n    responseType: 'code', // responseType is forced\n    codeVerifier,\n    codeChallenge,\n    codeChallengeMethod\n  };\n\n  return tokenParams;\n}\n\n// Prepares params for a call to /authorize or /token\nexport async function prepareTokenParams(\n  sdk: OktaAuthOAuthInterface,\n  tokenParams: TokenParams = {}\n): Promise<TokenParams> {\n  // build params using defaults + options\n  const defaults = getDefaultTokenParams(sdk);\n  tokenParams = { ...defaults, ...tokenParams };\n\n  if (tokenParams.dpop && !sdk.features.isDPoPSupported()) {\n    throw new AuthSdkError('DPoP has been configured, but is not supported by browser');\n  }\n\n  if (tokenParams.pkce === false) {\n    // Implicit flow or authorization_code without PKCE\n    return tokenParams;\n  }\n\n  return preparePKCE(sdk, tokenParams);\n}","import { RefreshToken } from '../types';\nimport { isAuthApiError } from '../../errors';\n\nexport function isSameRefreshToken(a: RefreshToken, b: RefreshToken) {\n  return (a.refreshToken === b.refreshToken);\n}\n\nexport function isRefreshTokenError(err: Error) {\n  if (!isAuthApiError(err)) {\n    return false;\n  }\n\n  if (!err.xhr || !err.xhr.responseJSON) {\n    return false;\n  }\n\n  const { responseJSON } = err.xhr;\n  if (responseJSON.error === 'invalid_grant') {\n    return true;\n  }\n\n  return false;\n}","import { OAuthStorageManagerInterface, OAuthTransactionMeta, isTransactionMeta } from '../types';\n\nconst MAX_ENTRY_LIFETIME = 30 * 60 * 1000; // 30 minutes\n\nexport function pruneSharedStorage<M extends OAuthTransactionMeta>(storageManager: OAuthStorageManagerInterface<M>) {\n  const sharedStorage = storageManager.getSharedTansactionStorage();\n  const entries = sharedStorage.getStorage();\n  Object.keys(entries).forEach(state => {\n    const entry = entries[state];\n    const age = Date.now() - entry.dateCreated;\n    if (age > MAX_ENTRY_LIFETIME) {\n      delete entries[state];\n    }\n  });\n  sharedStorage.setStorage(entries);\n}\n\nexport function saveTransactionToSharedStorage<M extends OAuthTransactionMeta>(\n  storageManager: OAuthStorageManagerInterface<M>, state: string, meta: M\n) {\n  const sharedStorage = storageManager.getSharedTansactionStorage();\n  const entries = sharedStorage.getStorage();\n  entries[state] = {\n    dateCreated: Date.now(),\n    transaction: meta\n  };\n  sharedStorage.setStorage(entries);\n}\n\n\nexport function loadTransactionFromSharedStorage<M extends OAuthTransactionMeta>(\n  storageManager: OAuthStorageManagerInterface<M>, state: string\n) {\n  const sharedStorage = storageManager.getSharedTansactionStorage();\n  const entries = sharedStorage.getStorage();\n  const entry = entries[state];\n  if (entry && entry.transaction && isTransactionMeta(entry.transaction)) {\n    return entry.transaction;\n  }\n  return null;\n}\n\nexport function clearTransactionFromSharedStorage<M extends OAuthTransactionMeta>(\n  storageManager: OAuthStorageManagerInterface<M>, state: string\n) {\n  const sharedStorage = storageManager.getSharedTansactionStorage();\n  const entries = sharedStorage.getStorage();\n  delete entries[state];\n  sharedStorage.setStorage(entries);\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/* eslint-disable complexity, max-statements */\n\nexport function urlParamsToObject(hashOrSearch: string) {\n  // Predefine regexs for parsing hash\n  var plus2space = /\\+/g;\n  var paramSplit = /([^&=]+)=?([^&]*)/g;\n  var fragment = hashOrSearch || '';\n\n  // Some hash based routers will automatically add a / character after the hash\n  if (fragment.charAt(0) === '#' && fragment.charAt(1) === '/') {\n    fragment = fragment.substring(2);\n  }\n\n  // Remove the leading # or ?\n  if (fragment.charAt(0) === '#' || fragment.charAt(0) === '?') {\n    fragment = fragment.substring(1);\n  }\n\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","/* eslint-disable @typescript-eslint/no-non-null-assertion */\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/* eslint-disable complexity, max-statements */\n\nimport AuthSdkError from '../../errors/AuthSdkError';\nimport { OktaAuthOAuthInterface, TokenVerifyParams, UserClaims } from '../../oidc/types';\n\nexport function validateClaims(sdk: OktaAuthOAuthInterface, claims: UserClaims, validationParams: TokenVerifyParams) {\n  const aud = validationParams.clientId;\n  const iss = validationParams.issuer;\n  const nonce = validationParams.nonce;\n  const acr = validationParams.acrValues;\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  const 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 ((Array.isArray(claims.aud) && claims.aud.indexOf(aud) < 0) ||\n    (!Array.isArray(claims.aud) && claims.aud !== aud))\n  {\n    throw new AuthSdkError('The audience [' + claims.aud + '] ' +\n      'does not match [' + aud + ']');\n  }\n\n  if (acr && claims.acr !== acr) {\n    throw new AuthSdkError('The acr [' + claims.acr + '] ' +\n      'does not match acr_values [' + acr + ']');\n  }\n\n  if (claims.iat! > claims.exp!) {\n    throw new AuthSdkError('The JWT expired before it was issued');\n  }\n\n  if (!sdk.options.ignoreLifetime) {\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}\n","/* eslint-disable complexity */\n\nimport { AuthSdkError } from '../../errors';\nimport { isAccessToken, isIDToken, isRefreshToken, Token, TokenType } from '../../oidc/types';\n\nexport function validateToken(token: Token, type?: TokenType) {\n  if (!isIDToken(token) && !isAccessToken(token) && !isRefreshToken(token)) {\n    throw new AuthSdkError(\n      'Token must be an Object with scopes, expiresAt, and one of: an idToken, accessToken, or refreshToken property'\n    );\n  }\n  \n  if (type === 'accessToken' && !isAccessToken(token)) {\n    throw new AuthSdkError('invalid accessToken');\n  } \n  if (type === 'idToken' && !isIDToken(token)) {\n    throw new AuthSdkError('invalid idToken');\n  }\n\n  if (type === 'refreshToken' && !isRefreshToken(token)) {\n    throw new AuthSdkError('invalid refreshToken');\n  }\n}","/* eslint-disable max-len */\n/* eslint-disable complexity */\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 */\nimport { getWellKnown, getKey } from './endpoints/well-known';\nimport { validateClaims } from './util';\nimport { AuthSdkError } from '../errors';\nimport { IDToken, OktaAuthOAuthInterface, TokenVerifyParams } from '../oidc/types';\nimport { decodeToken } from './decodeToken';\nimport * as sdkCrypto from '../crypto';\n\n// Verify the id token\nexport async function verifyToken(sdk: OktaAuthOAuthInterface, token: IDToken, validationParams: TokenVerifyParams): Promise<IDToken> {\n  if (!token || !token.idToken) {\n    throw new AuthSdkError('Only idTokens may be verified');\n  }\n\n  // Decode the Jwt object (may throw)\n  const jwt = decodeToken(token.idToken);\n\n  // The configured issuer may point to a frontend proxy.\n  // Get the \"real\" issuer from .well-known/openid-configuration\n  const configuredIssuer = validationParams?.issuer || sdk.options.issuer;\n  const { issuer } = await getWellKnown(sdk, configuredIssuer);\n\n  const validationOptions: TokenVerifyParams = Object.assign({\n    // base options, can be overridden by params\n    clientId: sdk.options.clientId,\n    ignoreSignature: sdk.options.ignoreSignature\n  }, validationParams, {\n    // final options, cannot be overridden\n    issuer\n  });\n\n  // Standard claim validation (may throw)\n  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  // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n  const key = await getKey(sdk, token.issuer, jwt.header.kid!);\n  const valid = await sdkCrypto.verifyToken(token.idToken, key);\n  if (!valid) {\n    throw new AuthSdkError('The token signature is not valid');\n  }\n  if (validationParams && validationParams.accessToken && token.claims.at_hash) {\n    const hash = await sdkCrypto.getOidcHash(validationParams.accessToken);\n    if (hash !== token.claims.at_hash) {\n      throw new AuthSdkError('Token hash verification failed');\n    }\n  }\n  return token;\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\nimport { AuthSdkError } from '../errors';\nimport { ServiceInterface, ServiceManagerOptions } from '../core/types';\nimport { EVENT_EXPIRED, TokenManagerInterface, isRefreshToken } from '../oidc/types';\nimport { isBrowser } from '../features';\n\nexport class AutoRenewService implements ServiceInterface {\n  private tokenManager: TokenManagerInterface;\n  private options: ServiceManagerOptions;\n  private renewTimeQueue: Array<number>;\n  private started = false;\n\n  constructor(tokenManager: TokenManagerInterface, options: ServiceManagerOptions = {}) {\n    this.tokenManager = tokenManager;\n    this.options = options;\n    this.renewTimeQueue = [];\n    this.onTokenExpiredHandler = this.onTokenExpiredHandler.bind(this);\n  }\n  \n  private shouldThrottleRenew(): boolean {\n    let res = false;\n    this.renewTimeQueue.push(Date.now());\n    if (this.renewTimeQueue.length >= 10) {\n      // get and remove first item from queue\n      const firstTime = this.renewTimeQueue.shift() as number;\n      const lastTime = this.renewTimeQueue[this.renewTimeQueue.length - 1];\n      res = (lastTime - firstTime) < 30 * 1000;\n    }\n    return res;\n  }\n\n  requiresLeadership() {\n    // If tokens sync storage is enabled, handle tokens expiration only in 1 leader tab\n    return !!this.options.syncStorage && isBrowser();\n  }\n\n  private processExpiredTokens() {\n    const tokenStorage = this.tokenManager.getStorage();\n    const tokens = tokenStorage.getStorage();\n    Object.keys(tokens).forEach(key => {\n      const token = tokens[key];\n      if (!isRefreshToken(token) && this.tokenManager.hasExpired(token)) {\n        this.onTokenExpiredHandler(key);\n      }\n    });\n  }\n\n  private onTokenExpiredHandler(key: string) {\n    if (this.options.autoRenew) {\n      if (this.shouldThrottleRenew()) {\n        const error = new AuthSdkError('Too many token renew requests');\n        this.tokenManager.emitError(error);\n      } else {\n        this.tokenManager.renew(key).catch(() => {}); // Renew errors will emit an \"error\" event \n      }\n    } else if (this.options.autoRemove) {\n      this.tokenManager.remove(key);\n    }\n  }\n\n  canStart() {\n    return (!!this.options.autoRenew || !!this.options.autoRemove) && !this.started;\n  }\n\n  async start() {\n    if (this.canStart()) {\n      this.tokenManager.on(EVENT_EXPIRED, this.onTokenExpiredHandler);\n      if (this.tokenManager.isStarted()) {\n        // If token manager has been already started, we could miss token expire events,\n        //  so need to process expired tokens manually.\n        this.processExpiredTokens();\n      }\n      this.started = true;\n    }\n  }\n\n  async stop() {\n    if (this.started) {\n      this.tokenManager.off(EVENT_EXPIRED, this.onTokenExpiredHandler);\n      this.renewTimeQueue = [];\n      this.started = false;\n    }\n  }\n\n  isStarted() {\n    return this.started;\n  }\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\nimport { ServiceInterface, ServiceManagerOptions } from '../core/types';\nimport {\n  BroadcastChannel,\n  createLeaderElection,\n  LeaderElector\n} from 'broadcast-channel';\nimport { isBrowser } from '../features';\n\ndeclare type OnLeaderHandler = (() => Promise<void>);\ndeclare type ServiceOptions = ServiceManagerOptions & {\n  onLeader?: OnLeaderHandler;\n};\n\nexport class LeaderElectionService implements ServiceInterface {\n  private options: ServiceOptions;\n  private channel?: BroadcastChannel;\n  private elector?: LeaderElector;\n  private started = false;\n\n  constructor(options: ServiceOptions = {}) {\n    this.options = options;\n    this.onLeaderDuplicate = this.onLeaderDuplicate.bind(this);\n    this.onLeader = this.onLeader.bind(this);\n  }\n\n  private onLeaderDuplicate() {\n  }\n\n  private async onLeader() {\n    await this.options.onLeader?.();\n  }\n\n  isLeader() {\n    return !!this.elector?.isLeader;\n  }\n\n  hasLeader() {\n    return !!this.elector?.hasLeader;\n  }\n\n  async start() {\n    if (this.canStart()) {\n      const { electionChannelName } = this.options;\n      this.channel = new BroadcastChannel(electionChannelName as string);\n      this.elector = createLeaderElection(this.channel);\n      this.elector.onduplicate = this.onLeaderDuplicate;\n      this.elector.awaitLeadership().then(this.onLeader);\n      this.started = true;\n    }\n  }\n\n  async stop() {\n    if (this.started) {\n      if (this.elector) {\n        await this.elector.die();\n        this.elector = undefined;\n      }\n      if (this.channel) {\n        // Workaround to fix error `Failed to execute 'postMessage' on 'BroadcastChannel': Channel is closed`\n        (this.channel as any).postInternal = () => Promise.resolve();\n        await this.channel.close();\n        this.channel = undefined;\n      }\n      this.started = false;\n    }\n  }\n\n  requiresLeadership() {\n    return false;\n  }\n\n  isStarted() {\n    return this.started;\n  }\n\n  canStart() {\n    return isBrowser() && !this.started;\n  }\n\n}\n","import { ServiceInterface, ServiceManagerOptions } from '../core/types';\nimport { TokenManagerInterface } from '../oidc/types';\nimport { isBrowser } from '../features';\n\nconst getNow = () => Math.floor(Date.now() / 1000);\n\nexport class RenewOnTabActivationService implements ServiceInterface {\n  private tokenManager: TokenManagerInterface;\n  private started = false;\n  private options: ServiceManagerOptions;\n  private lastHidden = -1;\n  onPageVisbilityChange: () => void;\n\n  constructor(tokenManager: TokenManagerInterface, options: ServiceManagerOptions = {}) {\n    this.tokenManager = tokenManager;\n    this.options = options;\n    // store this context for event handler\n    this.onPageVisbilityChange = this._onPageVisbilityChange.bind(this);\n  }\n\n  // do not use directly, use `onPageVisbilityChange` (with binded this context)\n  /* eslint complexity: [0, 10] */\n  private _onPageVisbilityChange () {\n    if (document.hidden) {\n      this.lastHidden = getNow();\n    }\n    // renew will only attempt if tab was inactive for duration\n    else if (this.lastHidden > 0 && (getNow() - this.lastHidden >= this.options.tabInactivityDuration!)) {\n      const { accessToken, idToken } = this.tokenManager.getTokensSync();\n      if (!!accessToken && this.tokenManager.hasExpired(accessToken)) {\n        const key = this.tokenManager.getStorageKeyByType('accessToken');\n        // Renew errors will emit an \"error\" event\n        this.tokenManager.renew(key).catch(() => {});\n      }\n      else if (!!idToken && this.tokenManager.hasExpired(idToken)) {\n        const key = this.tokenManager.getStorageKeyByType('idToken');\n        // Renew errors will emit an \"error\" event\n        this.tokenManager.renew(key).catch(() => {});\n      }\n    }\n  }\n\n  async start () {\n    if (this.canStart() && !!document) {\n      document.addEventListener('visibilitychange', this.onPageVisbilityChange);\n      this.started = true;\n    }\n  }\n\n  async stop () {\n    if (document) {\n      document.removeEventListener('visibilitychange', this.onPageVisbilityChange);\n      this.started = false;\n    }\n  }\n\n  canStart(): boolean {\n    return isBrowser() &&\n    !!this.options.autoRenew &&\n    !!this.options.renewOnTabActivation &&\n    !this.started;\n  }\n\n  requiresLeadership(): boolean {\n    return false;\n  }\n\n  isStarted(): boolean {\n    return this.started;\n  }\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\nimport { BroadcastChannel } from 'broadcast-channel';\nimport { isBrowser } from '../features';\nimport {\n  ServiceManagerOptions, ServiceInterface\n} from '../core/types';\nimport {\n  Token, Tokens, \n  EVENT_ADDED, EVENT_REMOVED, EVENT_RENEWED, EVENT_SET_STORAGE, TokenManagerInterface\n} from '../oidc/types';\nimport { AuthSdkError } from '../errors';\n\nexport type SyncMessage = {\n  type: string;\n  key?: string;\n  token?: Token;\n  oldToken?: Token;\n  storage?: Tokens;\n};\nexport class SyncStorageService implements ServiceInterface {\n  private tokenManager: TokenManagerInterface;\n  private options: ServiceManagerOptions;\n  private channel?: BroadcastChannel<SyncMessage>;\n  private started = false;\n  private enablePostMessage = true;\n\n  constructor(tokenManager: TokenManagerInterface, options: ServiceManagerOptions = {}) {\n    this.tokenManager = tokenManager;\n    this.options = options;\n    this.onTokenAddedHandler = this.onTokenAddedHandler.bind(this);\n    this.onTokenRemovedHandler = this.onTokenRemovedHandler.bind(this);\n    this.onTokenRenewedHandler = this.onTokenRenewedHandler.bind(this);\n    this.onSetStorageHandler = this.onSetStorageHandler.bind(this);\n    this.onSyncMessageHandler = this.onSyncMessageHandler.bind(this);\n  }\n\n  requiresLeadership() {\n    return false;\n  }\n\n  isStarted() {\n    return this.started;\n  }\n\n  canStart() {\n    return !!this.options.syncStorage && isBrowser() && !this.started;\n  }\n\n  async start() {\n    if (!this.canStart()) {\n      return;\n    }\n    \n    const { syncChannelName } = this.options;\n    try {\n      // BroadcastChannel throws if no supported method can be found\n      this.channel = new BroadcastChannel(syncChannelName as string);\n    } catch (err) {\n      throw new AuthSdkError('SyncStorageService is not supported in current browser.');\n    }\n\n    this.tokenManager.on(EVENT_ADDED, this.onTokenAddedHandler);\n    this.tokenManager.on(EVENT_REMOVED, this.onTokenRemovedHandler);\n    this.tokenManager.on(EVENT_RENEWED, this.onTokenRenewedHandler);\n    this.tokenManager.on(EVENT_SET_STORAGE, this.onSetStorageHandler);\n    this.channel.addEventListener('message', this.onSyncMessageHandler);\n    this.started = true;\n  }\n\n  async stop() {\n    if (this.started) {\n      this.tokenManager.off(EVENT_ADDED, this.onTokenAddedHandler);\n      this.tokenManager.off(EVENT_REMOVED, this.onTokenRemovedHandler);\n      this.tokenManager.off(EVENT_RENEWED, this.onTokenRenewedHandler);\n      this.tokenManager.off(EVENT_SET_STORAGE, this.onSetStorageHandler);\n      this.channel?.removeEventListener('message', this.onSyncMessageHandler);\n      await this.channel?.close();\n      this.channel = undefined;\n      this.started = false;\n    }\n  }\n\n  private onTokenAddedHandler(key: string, token: Token) {\n    if (!this.enablePostMessage) {\n      return;\n    }\n    this.channel?.postMessage({\n      type: EVENT_ADDED,\n      key,\n      token\n    });\n  }\n\n  private onTokenRemovedHandler(key: string, token: Token) {\n    if (!this.enablePostMessage) {\n      return;\n    }\n    this.channel?.postMessage({\n      type: EVENT_REMOVED,\n      key,\n      token\n    });\n  }\n\n  private onTokenRenewedHandler(key: string, token: Token, oldToken?: Token) {\n    if (!this.enablePostMessage) {\n      return;\n    }\n    this.channel?.postMessage({\n      type: EVENT_RENEWED,\n      key,\n      token,\n      oldToken\n    });\n  }\n\n  private onSetStorageHandler(storage: Tokens) {\n    this.channel?.postMessage({\n      type: EVENT_SET_STORAGE,\n      storage\n    });\n  }\n\n  /* eslint-disable complexity */\n  private onSyncMessageHandler(msg: SyncMessage) {\n    // Notes:\n    // 1. Using `enablePostMessage` flag here to prevent sync message loop.\n    //    If this flag is on, tokenManager event handlers do not post sync message.\n    // 2. IE11 has known issue with synchronization of LocalStorage cross tabs.\n    //    One workaround is to set empty event handler for `window.onstorage`.\n    //    But it's not 100% working, sometimes you still get old value from LocalStorage.\n    //    Better approch is to explicitly udpate LocalStorage with `setStorage`.\n\n    this.enablePostMessage = false;\n    switch (msg.type) {\n      case EVENT_SET_STORAGE:\n        this.tokenManager.getStorage().setStorage(msg.storage);\n        break;\n      case EVENT_ADDED:\n        this.tokenManager.emitAdded(msg.key!, msg.token!);\n        this.tokenManager.setExpireEventTimeout(msg.key!, msg.token!);\n        break;\n      case EVENT_REMOVED:\n        this.tokenManager.clearExpireEventTimeout(msg.key!);\n        this.tokenManager.emitRemoved(msg.key!, msg.token!);\n        break;\n      case EVENT_RENEWED:\n        this.tokenManager.emitRenewed(msg.key!, msg.token!, msg.oldToken);\n        break;\n      default:\n        break;\n    }\n    this.enablePostMessage = true;\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\nexport * from './AutoRenewService';\nexport * from './SyncStorageService';\nexport * from './LeaderElectionService';\nexport * from './RenewOnTabActivationService';\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/* global window */\nimport { omit, getLink, toQueryString } from '../util';\nimport { get, post, httpRequest } from '../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    .catch(function() {\n      return false;\n    });\n}\n\nfunction getSession(sdk) { \n  return get(sdk, '/api/v1/sessions/me', { withCredentials: true })\n  .then(function(session) {\n    var res = omit(session, '_links');\n\n    res.refresh = function() {\n      return post(sdk, getLink(session, 'refresh').href, {}, { withCredentials: true });\n    };\n\n    res.user = function() {\n      return get(sdk, getLink(session, 'user').href, { withCredentials: true });\n    };\n\n    return res;\n  })\n  .catch(function() {\n    // Return INACTIVE status on failure\n    return {status: 'INACTIVE'};\n  });\n}\n\nfunction closeSession(sdk) {\n  return httpRequest(sdk, {\n    url: sdk.getIssuerOrigin() + '/api/v1/sessions/me',\n    method: 'DELETE',\n    withCredentials: true\n  });\n}\n\nfunction refreshSession(sdk) {\n  return post(sdk, '/api/v1/sessions/me/lifecycle/refresh', {}, { withCredentials: true });\n}\n\nfunction setCookieAndRedirect(sdk, sessionToken, redirectUrl) {\n  redirectUrl = redirectUrl || window.location.href;\n  window.location.assign(sdk.getIssuerOrigin() + '/login/sessionCookieRedirect' +\n    toQueryString({\n      checkAccountSetupComplete: true,\n      token: sessionToken,\n      redirectUrl: redirectUrl\n    }));\n}\n\nexport {\n  sessionExists,\n  getSession,\n  closeSession,\n  refreshSession,\n  setCookieAndRedirect\n};\n","import { SessionAPI } from './types';\nimport { closeSession, getSession, refreshSession, sessionExists, setCookieAndRedirect } from './api';\nimport { OktaAuthBaseInterface } from '../base/types';\n\nexport function createSessionApi(sdk: OktaAuthBaseInterface): SessionAPI {\n  const session = {\n    close: closeSession.bind(null, sdk),\n    exists: sessionExists.bind(null, sdk),\n    get: getSession.bind(null, sdk),\n    refresh: refreshSession.bind(null, sdk),\n    setCookieAndRedirect: setCookieAndRedirect.bind(null, sdk)\n  };\n  return session;\n}\n","export * from './api';\nexport * from './factory';\nexport * from './mixin';\nexport * from './types';\n","import { OktaAuthHttpInterface, OktaAuthHttpOptions } from '../http/types';\nimport { OktaAuthConstructor } from '../base/types';\nimport { createSessionApi } from './factory';\nimport {\n  OktaAuthSessionInterface, SessionAPI,\n} from './types';\nimport { StorageManagerInterface } from '../storage/types';\n\nexport function mixinSession\n<\n  S extends StorageManagerInterface = StorageManagerInterface,\n  O extends OktaAuthHttpOptions = OktaAuthHttpOptions,\n  TBase extends OktaAuthConstructor<OktaAuthHttpInterface<S, O>>\n    = OktaAuthConstructor<OktaAuthHttpInterface<S, O>>\n>\n(Base: TBase): TBase & OktaAuthConstructor<OktaAuthSessionInterface<S, O>>\n{\n  return class OktaAuthSession extends Base implements OktaAuthSessionInterface<S, O>\n  {\n    session: SessionAPI;\n\n    constructor(...args: any[]) {\n      super(...args);\n\n      this.session = createSessionApi(this);\n    }\n\n    // Ends the current Okta SSO session without redirecting to Okta.\n    closeSession(): Promise<boolean> {\n      return this.session.close() // DELETE /api/v1/sessions/me\n      .then(async () => {\n        // Clear all local tokens\n        this.clearStorage();\n        return true;\n      })\n      .catch(function(e) {\n        if (e.name === 'AuthApiError' && e.errorCode === 'E0000007') {\n          // Session does not exist or has already been closed\n          return false;\n        }\n        throw e;\n      });\n    }\n  };\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\nimport {\n  TOKEN_STORAGE_NAME,\n  CACHE_STORAGE_NAME,\n} from '../constants';\nimport {\n  StorageUtil,\n  StorageProvider,\n  StorageOptions,\n  CookieOptions,\n  StorageManagerOptions,\n  SimpleStorage,\n  StorageManagerInterface\n} from './types';\nimport { SavedObject } from './SavedObject';\nimport { isBrowser } from '../features';\nimport { warn } from '../util';\n\nexport function logServerSideMemoryStorageWarning(options: StorageOptions) {\n  if (!isBrowser() && !options.storageProvider && !options.storageKey) {\n    // eslint-disable-next-line max-len\n    warn('Memory storage can only support simple single user use case on server side, please provide custom storageProvider or storageKey if advanced scenarios need to be supported.');\n  }\n}\n\n\nexport class BaseStorageManager implements StorageManagerInterface {\n  storageManagerOptions: StorageManagerOptions;\n  cookieOptions: CookieOptions;\n  storageUtil: StorageUtil;\n\n  constructor(storageManagerOptions: StorageManagerOptions, cookieOptions: CookieOptions, storageUtil: StorageUtil) {\n    this.storageManagerOptions = storageManagerOptions;\n    this.cookieOptions = cookieOptions;\n    this.storageUtil = storageUtil;\n  }\n\n  // combines defaults in order\n  getOptionsForSection(sectionName: string, overrideOptions?: StorageOptions) {\n    return Object.assign({}, this.storageManagerOptions[sectionName], overrideOptions);\n  }\n \n  // generic method to get any available storage provider\n  // eslint-disable-next-line complexity\n  getStorage(options: StorageOptions): SimpleStorage {\n    options = Object.assign({}, this.cookieOptions, options); // set defaults\n\n    if (options.storageProvider) {\n      return options.storageProvider;\n    }\n\n    let { storageType, storageTypes } = options;\n\n    if(storageType === 'sessionStorage') {\n      options.sessionCookie = true;\n    }\n\n    // If both storageType and storageTypes are specified, then storageType will be used first\n    // If storageType cannot be used but it matches an entry in storageTypes, subsequent entries may be used as fallback\n    // if storageType does not match an entry in storageTypes then storageType is used with no fallback.\n    if (storageType && storageTypes) {\n      const idx = storageTypes.indexOf(storageType);\n      if (idx >= 0) {\n        storageTypes = storageTypes.slice(idx);\n        storageType = undefined;\n      }\n    }\n\n    if (!storageType) {\n      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n      storageType = this.storageUtil.findStorageType(storageTypes!);\n    }\n    return this.storageUtil.getStorageByType(storageType, options);\n  }\n\n  // access_token, id_token, refresh_token\n  getTokenStorage(options?: StorageOptions): StorageProvider {\n    options = this.getOptionsForSection('token', options);\n    logServerSideMemoryStorageWarning(options);\n    const storage = this.getStorage(options);\n    const storageKey = options.storageKey || TOKEN_STORAGE_NAME;\n    return new SavedObject(storage, storageKey);\n  }\n\n  // caches well-known response, among others\n  getHttpCache(options?: StorageOptions): StorageProvider {\n    options = this.getOptionsForSection('cache', options);\n    const storage = this.getStorage(options);\n    const storageKey = options.storageKey || CACHE_STORAGE_NAME;\n    return new SavedObject(storage, storageKey);\n  }\n\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\nimport AuthSdkError from '../errors/AuthSdkError';\nimport { StorageProvider, SimpleStorage } from './types';\n\n// formerly known as \"storageBuilder\". Represents an object saved under a key/name.\nexport class SavedObject implements StorageProvider {\n  storageProvider: SimpleStorage;\n  storageName: string;\n\n  constructor(storage: SimpleStorage, storageName: string) {\n    if (!storage) {\n      throw new AuthSdkError('\"storage\" is required');\n    }\n\n    if (typeof storageName !== 'string' || !storageName.length) {\n      throw new AuthSdkError('\"storageName\" is required');\n    }\n\n    this.storageName = storageName;\n    this.storageProvider = storage;\n  }\n\n  //\n  // SimpleStorage interface\n  //\n\n  getItem(key: string) {\n    return this.getStorage()[key];\n  }\n\n  setItem(key: string, value: any) {\n    return this.updateStorage(key, value);\n  }\n\n  removeItem(key: string) {\n    return this.clearStorage(key);\n  }\n\n  //\n  // StorageProvider interface\n  //\n\n  getStorage() {\n    var storageString = this.storageProvider.getItem(this.storageName);\n    storageString = storageString || '{}';\n    try {\n      return JSON.parse(storageString);\n    } catch(e) {\n      throw new AuthSdkError('Unable to parse storage string: ' + this.storageName);\n    }\n  }\n\n  setStorage(obj?: any) {\n    try {\n      var storageString = obj ? JSON.stringify(obj) : '{}';\n      this.storageProvider.setItem(this.storageName, storageString);\n    } catch(e) {\n      throw new AuthSdkError('Unable to set storage: ' + this.storageName);\n    }\n  }\n\n  clearStorage(key?: string) {\n    if (!key) {\n      // clear all\n      if (this.storageProvider.removeItem) {\n        this.storageProvider.removeItem(this.storageName);\n      } else {\n        this.setStorage();\n      }\n      return;\n    }\n\n    var obj = this.getStorage();\n    delete obj[key];\n    this.setStorage(obj);\n  }\n\n  updateStorage(key, value) {\n    var obj = this.getStorage();\n    obj[key] = value;\n    this.setStorage(obj);\n  }\n}\n","export * from './options/StorageOptionsConstructor';\nexport * from './BaseStorageManager';\nexport * from './mixin';\nexport * from './SavedObject';\nexport * from './types';\n","import { OktaAuthBaseInterface, OktaAuthConstructor } from '../base/types';\nimport {\n  OktaAuthStorageInterface,\n  OktaAuthStorageOptions,\n  StorageManagerConstructor,\n  StorageManagerInterface,\n} from './types';\n\nexport function mixinStorage\n<\n  S extends StorageManagerInterface = StorageManagerInterface,\n  O extends OktaAuthStorageOptions = OktaAuthStorageOptions,\n  TBase extends OktaAuthConstructor<OktaAuthBaseInterface<O>> = OktaAuthConstructor<OktaAuthBaseInterface<O>>\n>\n(\n  Base: TBase, StorageManager: StorageManagerConstructor<S>\n): TBase & OktaAuthConstructor<OktaAuthStorageInterface<S, O>>\n{\n  return class OktaAuthStorage extends Base implements OktaAuthStorageInterface<S, O>\n  {\n    storageManager: S;\n    constructor(...args: any[]) {\n      super(...args);\n      const { storageManager, cookies, storageUtil } = this.options;\n      this.storageManager = new StorageManager(storageManager!, cookies!, storageUtil!);\n    }\n    clearStorage(): void {\n      // override in subclass\n    }\n  };\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\nimport { createBaseOptionsConstructor } from '../../base';\nimport { CookieOptions, OktaAuthStorageOptions, StorageManagerOptions, StorageUtil } from '../types';\nimport { getStorage, STORAGE_MANAGER_OPTIONS, getCookieSettings } from './node';\nimport { isHTTPS } from '../../features';\n\nexport function createStorageOptionsConstructor() {\n\n  const BaseOptionsConstructor = createBaseOptionsConstructor();\n  return class StorageOptionsConstructor extends BaseOptionsConstructor implements Required<OktaAuthStorageOptions> {\n    cookies: CookieOptions;\n    storageUtil: StorageUtil;\n    storageManager: StorageManagerOptions;\n    \n    constructor(args: any) {\n      super(args);\n      this.cookies = getCookieSettings(args, isHTTPS())!;\n      this.storageUtil = args.storageUtil || getStorage();\n      this.storageManager = { ...STORAGE_MANAGER_OPTIONS, ...args.storageManager };\n    }\n  };\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/* eslint-disable complexity */\nimport { StorageManagerOptions, StorageUtil, OktaAuthStorageOptions } from '../types';\nimport { warn } from '../../util';\n\nimport { default as browserStorage } from '../../browser/browserStorage';\n\nexport function getStorage(): StorageUtil {\n  const storageUtil = Object.assign({}, browserStorage, {\n    inMemoryStore: {} // create unique storage for this instance\n  });\n  return storageUtil;\n}\n\nexport const STORAGE_MANAGER_OPTIONS: StorageManagerOptions = {\n  token: {\n    storageTypes: [\n      'localStorage',\n      'sessionStorage',\n      'cookie'\n    ]\n  },\n  cache: {\n    storageTypes: [\n      'localStorage',\n      'sessionStorage',\n      'cookie'\n    ]\n  },\n  transaction: {\n    storageTypes: [\n      'sessionStorage',\n      'localStorage',\n      'cookie'\n    ]\n  },\n  'shared-transaction': {\n    storageTypes: [\n      'localStorage'\n    ]\n  },\n  'original-uri': {\n    storageTypes: [\n      'localStorage'\n    ]\n  }\n};\n\nexport function getCookieSettings(args: OktaAuthStorageOptions = {}, isHTTPS: boolean) {\n  // Secure cookies will be automatically used on a HTTPS connection\n  // Non-secure cookies will be automatically used on a HTTP connection\n  // secure option can override the automatic behavior\n  var cookieSettings = args.cookies || {};\n  if (typeof cookieSettings.secure === 'undefined') {\n    cookieSettings.secure = isHTTPS;\n  }\n  if (typeof cookieSettings.sameSite === 'undefined') {\n    cookieSettings.sameSite = cookieSettings.secure ? 'none' : 'lax';\n  }\n\n  // If secure=true, but the connection is not HTTPS, set secure=false.\n  if (cookieSettings.secure && !isHTTPS) {\n    // eslint-disable-next-line no-console\n    warn(\n      'The current page is not being served with the HTTPS protocol.\\n' +\n      'For security reasons, we strongly recommend using HTTPS.\\n' +\n      'If you cannot use HTTPS, set \"cookies.secure\" option to false.'\n    );\n    cookieSettings.secure = false;\n  }\n\n  // Chrome >= 80 will block cookies with SameSite=None unless they are also Secure\n  // If sameSite=none, but the connection is not HTTPS, set sameSite=lax.\n  if (cookieSettings.sameSite === 'none' && !cookieSettings.secure) {\n    cookieSettings.sameSite = 'lax';\n  }\n\n  return cookieSettings;\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// Implements a queue for synchronous or asynchronous methods\n// Methods will be wrapped in a promise and execute sequentially\n// This can be used to prevent concurrent calls to a single method or a set of methods\n\nimport { isPromise } from './types';\nimport { warn } from './console';\n\ninterface QueueItem {\n  method: () => void;\n  thisObject: object;\n  args: any[];\n  resolve: (value?: unknown) => void;\n  reject: (reason?: unknown) => void;\n}\n\ninterface PromiseQueueOptions {\n  quiet?: boolean; // if false, concurrrency warnings will not be logged\n}\nexport class PromiseQueue {\n  queue: QueueItem[];\n  running: boolean;\n  options: PromiseQueueOptions;\n\n  constructor(options: PromiseQueueOptions = { quiet: false }) {\n    this.queue = [];\n    this.running = false;\n    this.options = options;\n  }\n\n  // Returns a promise\n  // If the method is synchronous, it will resolve when the method completes\n  // If the method returns a promise, it will resolve (or reject) with the value from the method's promise\n  push(method: (...args: any) => any, thisObject: any, ...args: any[]) {\n    return new Promise((resolve, reject) => {\n      if (this.queue.length > 0) {\n        // There is at least one other pending call.\n        // The PromiseQueue will prevent these methods from running concurrently.\n        if (this.options.quiet !== false) {\n          warn(\n            'Async method is being called but another async method is already running. ' +\n            'The new method will be delayed until the previous method completes.'\n          );\n        }\n      }\n      this.queue.push({\n        method,\n        thisObject,\n        args,\n        resolve,\n        reject\n      });\n      this.run();\n    });\n  }\n\n  run() {\n    if (this.running) {\n      return;\n    }\n    if (this.queue.length === 0) {\n      return;\n    }\n    this.running = true;\n    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion\n    var queueItem = this.queue.shift()!;\n    var res = queueItem.method.apply(queueItem.thisObject, queueItem.args as never) as unknown;\n    if (isPromise(res)) {\n      (res as Promise<unknown>).then(queueItem.resolve, queueItem.reject).finally(() => {\n        this.running = false;\n        this.run();\n      });\n    } else {\n      queueItem.resolve(res);\n      this.running = false;\n      this.run();\n    }\n  }\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/* global window */\n\nexport function getNativeConsole() {\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\nexport function getConsole() {\n  var nativeConsole = getNativeConsole();\n  // eslint-disable-next-line @typescript-eslint/ban-ts-comment\n  // @ts-ignore\n  if (nativeConsole && nativeConsole.log) {\n    return nativeConsole;\n  }\n  return {\n    log: function() {},\n    warn: function() {},\n    group: function() {},\n    groupEnd: function() {}\n  };\n}\n\nexport function warn(text) {\n  /* eslint-disable no-console */\n  getConsole().warn('[okta-auth-sdk] WARN: ' + text);\n  /* eslint-enable */\n}\n\nexport function deprecate(text) {\n  /* eslint-disable no-console */\n  getConsole().warn('[okta-auth-sdk] DEPRECATION: ' + text);\n  /* eslint-enable */\n}\n\nexport function deprecateWrap(text, fn) {\n  return function() {\n    deprecate(text);\n    return fn.apply(null, arguments);\n  };\n}\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\nexport * from './console';\nexport * from './misc';\nexport * from './object';\nexport * from './PromiseQueue';\nexport * from './types';\nexport * from './url';\n","import { JSONPath, JSONPathOptions } from 'jsonpath-plus';\n\nexport function jsonpath(options: JSONPathOptions): any {\n  // eslint-disable-next-line new-cap\n  return JSONPath({\n    // Disable javascript evaluation by default\n\tpreventEval: true, ...options, });\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\nexport function isoToUTCString(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\nexport function genRandomString(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\nexport function delay(ms) {\n  return new Promise(function(resolve) {\n    setTimeout(resolve, ms);\n  });\n}\n\nexport function split2(str, delim) {\n  const parts = str.split(delim);\n  return [\n    parts[0], \n    parts.splice(1, parts.length).join(delim),\n  ];\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\nexport function bind(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\n// TODO: replace all references with `Object.assign` then remove this function\nexport function extend() {\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 (Object.prototype.hasOwnProperty.call(obj, prop) && obj[prop] !== undefined) {\n        obj1[prop] = obj[prop];\n      }\n    }\n  });\n  return obj1; // return the modified object\n}\n\nexport function removeNils(obj) {\n  var cleaned = {};\n  for (var prop in obj) {\n    if (Object.prototype.hasOwnProperty.call(obj, prop)) {\n      var value = obj[prop];\n      if (value !== null && value !== undefined) {\n        cleaned[prop] = value;\n      }\n    }\n  }\n  return cleaned;\n}\n\nexport function clone(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\nexport function omit(obj, ...props: any[]) {\n  // var props = Array.prototype.slice.call(arguments, 1);\n  var newobj = {};\n  for (var p in obj) {\n    if (Object.prototype.hasOwnProperty.call(obj, p) && props.indexOf(p) == -1) {\n      newobj[p] = obj[p];\n    }\n  }\n  return clone(newobj);\n}\n\nexport function find(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 (!Object.prototype.hasOwnProperty.call(searchParams, 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\nexport function getLink(obj, linkName, altName?) {\n  if (!obj || !obj._links) {\n    return;\n  }\n\n  var link = 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\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\nexport function isString(obj: any): obj is string {\n  return Object.prototype.toString.call(obj) === '[object String]';\n}\n\nexport function isObject(obj: any): obj is object {\n  return Object.prototype.toString.call(obj) === '[object Object]';\n}\n\nexport function isNumber(obj: any): obj is number {\n  return Object.prototype.toString.call(obj) === '[object Number]';\n}\n\nexport function isFunction(fn: any): fn is (...any: any[]) => any {\n  return !!fn && {}.toString.call(fn) === '[object Function]';\n}\n\nexport function isPromise(obj) {\n  return obj && obj.finally && (typeof obj.finally === 'function');\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\nexport function isAbsoluteUrl(url) {\n  return /^[a-z][a-z0-9+.-]*:/i.test(url);\n}\n\nexport function toAbsoluteUrl(url = '', baseUrl) {\n  if (isAbsoluteUrl(url)) {\n    return url;\n  }\n  baseUrl = removeTrailingSlash(baseUrl);\n  return url[0] === '/' ? `${baseUrl}${url}` : `${baseUrl}/${url}`;\n}\n\nexport function toRelativeUrl(url = '', baseUrl) {\n  if (isAbsoluteUrl(url)) {\n    url = url.substring(baseUrl.length);\n  }\n\n  return url[0] === '/' ? url : `/${url}`;\n}\n\nexport function toQueryString(obj) {\n  var str = [];\n  if (obj !== null) {\n    for (var key in obj) {\n      if (Object.prototype.hasOwnProperty.call(obj, key) &&\n          obj[key] !== undefined &&\n          obj[key] !== null) {\n        str.push(key + '=' + encodeURIComponent(obj[key]) as never);\n      }\n    }\n  }\n  if (str.length) {\n    return '?' + str.join('&');\n  } else {\n    return '';\n  }\n}\n\nexport function removeTrailingSlash(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","'use strict';\n\nclass CancelError extends Error {\n\tconstructor(reason) {\n\t\tsuper(reason || 'Promise was canceled');\n\t\tthis.name = 'CancelError';\n\t}\n\n\tget isCanceled() {\n\t\treturn true;\n\t}\n}\n\nclass PCancelable {\n\tstatic fn(userFn) {\n\t\treturn (...arguments_) => {\n\t\t\treturn new PCancelable((resolve, reject, onCancel) => {\n\t\t\t\targuments_.push(onCancel);\n\t\t\t\t// eslint-disable-next-line promise/prefer-await-to-then\n\t\t\t\tuserFn(...arguments_).then(resolve, reject);\n\t\t\t});\n\t\t};\n\t}\n\n\tconstructor(executor) {\n\t\tthis._cancelHandlers = [];\n\t\tthis._isPending = true;\n\t\tthis._isCanceled = false;\n\t\tthis._rejectOnCancel = true;\n\n\t\tthis._promise = new Promise((resolve, reject) => {\n\t\t\tthis._reject = reject;\n\n\t\t\tconst onResolve = value => {\n\t\t\t\tif (!this._isCanceled || !onCancel.shouldReject) {\n\t\t\t\t\tthis._isPending = false;\n\t\t\t\t\tresolve(value);\n\t\t\t\t}\n\t\t\t};\n\n\t\t\tconst onReject = error => {\n\t\t\t\tthis._isPending = false;\n\t\t\t\treject(error);\n\t\t\t};\n\n\t\t\tconst onCancel = handler => {\n\t\t\t\tif (!this._isPending) {\n\t\t\t\t\tthrow new Error('The `onCancel` handler was attached after the promise settled.');\n\t\t\t\t}\n\n\t\t\t\tthis._cancelHandlers.push(handler);\n\t\t\t};\n\n\t\t\tObject.defineProperties(onCancel, {\n\t\t\t\tshouldReject: {\n\t\t\t\t\tget: () => this._rejectOnCancel,\n\t\t\t\t\tset: boolean => {\n\t\t\t\t\t\tthis._rejectOnCancel = boolean;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t});\n\n\t\t\treturn executor(onResolve, onReject, onCancel);\n\t\t});\n\t}\n\n\tthen(onFulfilled, onRejected) {\n\t\t// eslint-disable-next-line promise/prefer-await-to-then\n\t\treturn this._promise.then(onFulfilled, onRejected);\n\t}\n\n\tcatch(onRejected) {\n\t\treturn this._promise.catch(onRejected);\n\t}\n\n\tfinally(onFinally) {\n\t\treturn this._promise.finally(onFinally);\n\t}\n\n\tcancel(reason) {\n\t\tif (!this._isPending || this._isCanceled) {\n\t\t\treturn;\n\t\t}\n\n\t\tthis._isCanceled = true;\n\n\t\tif (this._cancelHandlers.length > 0) {\n\t\t\ttry {\n\t\t\t\tfor (const handler of this._cancelHandlers) {\n\t\t\t\t\thandler();\n\t\t\t\t}\n\t\t\t} catch (error) {\n\t\t\t\tthis._reject(error);\n\t\t\t\treturn;\n\t\t\t}\n\t\t}\n\n\t\tif (this._rejectOnCancel) {\n\t\t\tthis._reject(new CancelError(reason));\n\t\t}\n\t}\n\n\tget isCanceled() {\n\t\treturn this._isCanceled;\n\t}\n}\n\nObject.setPrototypeOf(PCancelable.prototype, Promise.prototype);\n\nmodule.exports = PCancelable;\nmodule.exports.CancelError = CancelError;\n","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.OPEN_BROADCAST_CHANNELS = exports.BroadcastChannel = void 0;\nexports.clearNodeFolder = clearNodeFolder;\nexports.enforceOptions = enforceOptions;\nvar _util = require(\"./util.js\");\nvar _methodChooser = require(\"./method-chooser.js\");\nvar _options = require(\"./options.js\");\n/**\n * Contains all open channels,\n * used in tests to ensure everything is closed.\n */\nvar OPEN_BROADCAST_CHANNELS = new Set();\nexports.OPEN_BROADCAST_CHANNELS = OPEN_BROADCAST_CHANNELS;\nvar lastId = 0;\nvar BroadcastChannel = function BroadcastChannel(name, options) {\n  // identifier of the channel to debug stuff\n  this.id = lastId++;\n  OPEN_BROADCAST_CHANNELS.add(this);\n  this.name = name;\n  if (ENFORCED_OPTIONS) {\n    options = ENFORCED_OPTIONS;\n  }\n  this.options = (0, _options.fillOptionsWithDefaults)(options);\n  this.method = (0, _methodChooser.chooseMethod)(this.options);\n\n  // isListening\n  this._iL = false;\n\n  /**\n   * _onMessageListener\n   * setting onmessage twice,\n   * will overwrite the first listener\n   */\n  this._onML = null;\n\n  /**\n   * _addEventListeners\n   */\n  this._addEL = {\n    message: [],\n    internal: []\n  };\n\n  /**\n   * Unsent message promises\n   * where the sending is still in progress\n   * @type {Set<Promise>}\n   */\n  this._uMP = new Set();\n\n  /**\n   * _beforeClose\n   * array of promises that will be awaited\n   * before the channel is closed\n   */\n  this._befC = [];\n\n  /**\n   * _preparePromise\n   */\n  this._prepP = null;\n  _prepareChannel(this);\n};\n\n// STATICS\n\n/**\n * used to identify if someone overwrites\n * window.BroadcastChannel with this\n * See methods/native.js\n */\nexports.BroadcastChannel = BroadcastChannel;\nBroadcastChannel._pubkey = true;\n\n/**\n * clears the tmp-folder if is node\n * @return {Promise<boolean>} true if has run, false if not node\n */\nfunction clearNodeFolder(options) {\n  options = (0, _options.fillOptionsWithDefaults)(options);\n  var method = (0, _methodChooser.chooseMethod)(options);\n  if (method.type === 'node') {\n    return method.clearNodeFolder().then(function () {\n      return true;\n    });\n  } else {\n    return _util.PROMISE_RESOLVED_FALSE;\n  }\n}\n\n/**\n * if set, this method is enforced,\n * no mather what the options are\n */\nvar ENFORCED_OPTIONS;\nfunction enforceOptions(options) {\n  ENFORCED_OPTIONS = options;\n}\n\n// PROTOTYPE\nBroadcastChannel.prototype = {\n  postMessage: function postMessage(msg) {\n    if (this.closed) {\n      throw new Error('BroadcastChannel.postMessage(): ' + 'Cannot post message after channel has closed ' +\n      /**\n       * In the past when this error appeared, it was really hard to debug.\n       * So now we log the msg together with the error so it at least\n       * gives some clue about where in your application this happens.\n       */\n      JSON.stringify(msg));\n    }\n    return _post(this, 'message', msg);\n  },\n  postInternal: function postInternal(msg) {\n    return _post(this, 'internal', msg);\n  },\n  set onmessage(fn) {\n    var time = this.method.microSeconds();\n    var listenObj = {\n      time: time,\n      fn: fn\n    };\n    _removeListenerObject(this, 'message', this._onML);\n    if (fn && typeof fn === 'function') {\n      this._onML = listenObj;\n      _addListenerObject(this, 'message', listenObj);\n    } else {\n      this._onML = null;\n    }\n  },\n  addEventListener: function addEventListener(type, fn) {\n    var time = this.method.microSeconds();\n    var listenObj = {\n      time: time,\n      fn: fn\n    };\n    _addListenerObject(this, type, listenObj);\n  },\n  removeEventListener: function removeEventListener(type, fn) {\n    var obj = this._addEL[type].find(function (obj) {\n      return obj.fn === fn;\n    });\n    _removeListenerObject(this, type, obj);\n  },\n  close: function close() {\n    var _this = this;\n    if (this.closed) {\n      return;\n    }\n    OPEN_BROADCAST_CHANNELS[\"delete\"](this);\n    this.closed = true;\n    var awaitPrepare = this._prepP ? this._prepP : _util.PROMISE_RESOLVED_VOID;\n    this._onML = null;\n    this._addEL.message = [];\n    return awaitPrepare\n    // wait until all current sending are processed\n    .then(function () {\n      return Promise.all(Array.from(_this._uMP));\n    })\n    // run before-close hooks\n    .then(function () {\n      return Promise.all(_this._befC.map(function (fn) {\n        return fn();\n      }));\n    })\n    // close the channel\n    .then(function () {\n      return _this.method.close(_this._state);\n    });\n  },\n  get type() {\n    return this.method.type;\n  },\n  get isClosed() {\n    return this.closed;\n  }\n};\n\n/**\n * Post a message over the channel\n * @returns {Promise} that resolved when the message sending is done\n */\nfunction _post(broadcastChannel, type, msg) {\n  var time = broadcastChannel.method.microSeconds();\n  var msgObj = {\n    time: time,\n    type: type,\n    data: msg\n  };\n  var awaitPrepare = broadcastChannel._prepP ? broadcastChannel._prepP : _util.PROMISE_RESOLVED_VOID;\n  return awaitPrepare.then(function () {\n    var sendPromise = broadcastChannel.method.postMessage(broadcastChannel._state, msgObj);\n\n    // add/remove to unsent messages list\n    broadcastChannel._uMP.add(sendPromise);\n    sendPromise[\"catch\"]().then(function () {\n      return broadcastChannel._uMP[\"delete\"](sendPromise);\n    });\n    return sendPromise;\n  });\n}\nfunction _prepareChannel(channel) {\n  var maybePromise = channel.method.create(channel.name, channel.options);\n  if ((0, _util.isPromise)(maybePromise)) {\n    channel._prepP = maybePromise;\n    maybePromise.then(function (s) {\n      // used in tests to simulate slow runtime\n      /*if (channel.options.prepareDelay) {\n           await new Promise(res => setTimeout(res, this.options.prepareDelay));\n      }*/\n      channel._state = s;\n    });\n  } else {\n    channel._state = maybePromise;\n  }\n}\nfunction _hasMessageListeners(channel) {\n  if (channel._addEL.message.length > 0) return true;\n  if (channel._addEL.internal.length > 0) return true;\n  return false;\n}\nfunction _addListenerObject(channel, type, obj) {\n  channel._addEL[type].push(obj);\n  _startListening(channel);\n}\nfunction _removeListenerObject(channel, type, obj) {\n  channel._addEL[type] = channel._addEL[type].filter(function (o) {\n    return o !== obj;\n  });\n  _stopListening(channel);\n}\nfunction _startListening(channel) {\n  if (!channel._iL && _hasMessageListeners(channel)) {\n    // someone is listening, start subscribing\n\n    var listenerFn = function listenerFn(msgObj) {\n      channel._addEL[msgObj.type].forEach(function (listenerObject) {\n        /**\n         * Getting the current time in JavaScript has no good precision.\n         * So instead of only listening to events that happened 'after' the listener\n         * was added, we also listen to events that happened 100ms before it.\n         * This ensures that when another process, like a WebWorker, sends events\n         * we do not miss them out because their timestamp is a bit off compared to the main process.\n         * Not doing this would make messages missing when we send data directly after subscribing and awaiting a response.\n         * @link https://johnresig.com/blog/accuracy-of-javascript-time/\n         */\n        var hundredMsInMicro = 100 * 1000;\n        var minMessageTime = listenerObject.time - hundredMsInMicro;\n        if (msgObj.time >= minMessageTime) {\n          listenerObject.fn(msgObj.data);\n        }\n      });\n    };\n    var time = channel.method.microSeconds();\n    if (channel._prepP) {\n      channel._prepP.then(function () {\n        channel._iL = true;\n        channel.method.onMessage(channel._state, listenerFn, time);\n      });\n    } else {\n      channel._iL = true;\n      channel.method.onMessage(channel._state, listenerFn, time);\n    }\n  }\n}\nfunction _stopListening(channel) {\n  if (channel._iL && !_hasMessageListeners(channel)) {\n    // no one is listening, stop subscribing\n    channel._iL = false;\n    var time = channel.method.microSeconds();\n    channel.method.onMessage(channel._state, null, time);\n  }\n}","\"use strict\";\n\nvar _index = require(\"./index.js\");\n/**\n * because babel can only export on default-attribute,\n * we use this for the non-module-build\n * this ensures that users do not have to use\n * var BroadcastChannel = require('broadcast-channel').default;\n * but\n * var BroadcastChannel = require('broadcast-channel');\n */\n\nmodule.exports = {\n  BroadcastChannel: _index.BroadcastChannel,\n  createLeaderElection: _index.createLeaderElection,\n  clearNodeFolder: _index.clearNodeFolder,\n  enforceOptions: _index.enforceOptions,\n  beLeader: _index.beLeader\n};","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nObject.defineProperty(exports, \"BroadcastChannel\", {\n  enumerable: true,\n  get: function get() {\n    return _broadcastChannel.BroadcastChannel;\n  }\n});\nObject.defineProperty(exports, \"OPEN_BROADCAST_CHANNELS\", {\n  enumerable: true,\n  get: function get() {\n    return _broadcastChannel.OPEN_BROADCAST_CHANNELS;\n  }\n});\nObject.defineProperty(exports, \"beLeader\", {\n  enumerable: true,\n  get: function get() {\n    return _leaderElectionUtil.beLeader;\n  }\n});\nObject.defineProperty(exports, \"clearNodeFolder\", {\n  enumerable: true,\n  get: function get() {\n    return _broadcastChannel.clearNodeFolder;\n  }\n});\nObject.defineProperty(exports, \"createLeaderElection\", {\n  enumerable: true,\n  get: function get() {\n    return _leaderElection.createLeaderElection;\n  }\n});\nObject.defineProperty(exports, \"enforceOptions\", {\n  enumerable: true,\n  get: function get() {\n    return _broadcastChannel.enforceOptions;\n  }\n});\nvar _broadcastChannel = require(\"./broadcast-channel.js\");\nvar _leaderElection = require(\"./leader-election.js\");\nvar _leaderElectionUtil = require(\"./leader-election-util.js\");","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.beLeader = beLeader;\nexports.sendLeaderMessage = sendLeaderMessage;\nvar _unload = require(\"unload\");\n/**\n * sends and internal message over the broadcast-channel\n */\nfunction sendLeaderMessage(leaderElector, action) {\n  var msgJson = {\n    context: 'leader',\n    action: action,\n    token: leaderElector.token\n  };\n  return leaderElector.broadcastChannel.postInternal(msgJson);\n}\nfunction beLeader(leaderElector) {\n  leaderElector.isLeader = true;\n  leaderElector._hasLeader = true;\n  var unloadFn = (0, _unload.add)(function () {\n    return leaderElector.die();\n  });\n  leaderElector._unl.push(unloadFn);\n  var isLeaderListener = function isLeaderListener(msg) {\n    if (msg.context === 'leader' && msg.action === 'apply') {\n      sendLeaderMessage(leaderElector, 'tell');\n    }\n    if (msg.context === 'leader' && msg.action === 'tell' && !leaderElector._dpLC) {\n      /**\n       * another instance is also leader!\n       * This can happen on rare events\n       * like when the CPU is at 100% for long time\n       * or the tabs are open very long and the browser throttles them.\n       * @link https://github.com/pubkey/broadcast-channel/issues/414\n       * @link https://github.com/pubkey/broadcast-channel/issues/385\n       */\n      leaderElector._dpLC = true;\n      leaderElector._dpL(); // message the lib user so the app can handle the problem\n      sendLeaderMessage(leaderElector, 'tell'); // ensure other leader also knows the problem\n    }\n  };\n\n  leaderElector.broadcastChannel.addEventListener('internal', isLeaderListener);\n  leaderElector._lstns.push(isLeaderListener);\n  return sendLeaderMessage(leaderElector, 'tell');\n}","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.LeaderElectionWebLock = void 0;\nvar _util = require(\"./util.js\");\nvar _leaderElectionUtil = require(\"./leader-election-util.js\");\n/**\n * A faster version of the leader elector that uses the WebLock API\n * @link https://developer.mozilla.org/en-US/docs/Web/API/Web_Locks_API\n */\nvar LeaderElectionWebLock = function LeaderElectionWebLock(broadcastChannel, options) {\n  var _this = this;\n  this.broadcastChannel = broadcastChannel;\n  broadcastChannel._befC.push(function () {\n    return _this.die();\n  });\n  this._options = options;\n  this.isLeader = false;\n  this.isDead = false;\n  this.token = (0, _util.randomToken)();\n  this._lstns = [];\n  this._unl = [];\n  this._dpL = function () {}; // onduplicate listener\n  this._dpLC = false; // true when onduplicate called\n\n  this._wKMC = {}; // stuff for cleanup\n\n  // lock name\n  this.lN = 'pubkey-bc||' + broadcastChannel.method.type + '||' + broadcastChannel.name;\n};\nexports.LeaderElectionWebLock = LeaderElectionWebLock;\nLeaderElectionWebLock.prototype = {\n  hasLeader: function hasLeader() {\n    var _this2 = this;\n    return navigator.locks.query().then(function (locks) {\n      var relevantLocks = locks.held ? locks.held.filter(function (lock) {\n        return lock.name === _this2.lN;\n      }) : [];\n      if (relevantLocks && relevantLocks.length > 0) {\n        return true;\n      } else {\n        return false;\n      }\n    });\n  },\n  awaitLeadership: function awaitLeadership() {\n    var _this3 = this;\n    if (!this._wLMP) {\n      this._wKMC.c = new AbortController();\n      var returnPromise = new Promise(function (res, rej) {\n        _this3._wKMC.res = res;\n        _this3._wKMC.rej = rej;\n      });\n      this._wLMP = new Promise(function (res) {\n        navigator.locks.request(_this3.lN, {\n          signal: _this3._wKMC.c.signal\n        }, function () {\n          // if the lock resolved, we can drop the abort controller\n          _this3._wKMC.c = undefined;\n          (0, _leaderElectionUtil.beLeader)(_this3);\n          res();\n          return returnPromise;\n        })[\"catch\"](function () {});\n      });\n    }\n    return this._wLMP;\n  },\n  set onduplicate(_fn) {\n    // Do nothing because there are no duplicates in the WebLock version\n  },\n  die: function die() {\n    var _this4 = this;\n    this._lstns.forEach(function (listener) {\n      return _this4.broadcastChannel.removeEventListener('internal', listener);\n    });\n    this._lstns = [];\n    this._unl.forEach(function (uFn) {\n      return uFn.remove();\n    });\n    this._unl = [];\n    if (this.isLeader) {\n      this.isLeader = false;\n    }\n    this.isDead = true;\n    if (this._wKMC.res) {\n      this._wKMC.res();\n    }\n    if (this._wKMC.c) {\n      this._wKMC.c.abort('LeaderElectionWebLock.die() called');\n    }\n    return (0, _leaderElectionUtil.sendLeaderMessage)(this, 'death');\n  }\n};","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.createLeaderElection = createLeaderElection;\nvar _util = require(\"./util.js\");\nvar _leaderElectionUtil = require(\"./leader-election-util.js\");\nvar _leaderElectionWebLock = require(\"./leader-election-web-lock.js\");\nvar LeaderElection = function LeaderElection(broadcastChannel, options) {\n  var _this = this;\n  this.broadcastChannel = broadcastChannel;\n  this._options = options;\n  this.isLeader = false;\n  this._hasLeader = false;\n  this.isDead = false;\n  this.token = (0, _util.randomToken)();\n\n  /**\n   * Apply Queue,\n   * used to ensure we do not run applyOnce()\n   * in parallel.\n   */\n  this._aplQ = _util.PROMISE_RESOLVED_VOID;\n  // amount of unfinished applyOnce() calls\n  this._aplQC = 0;\n\n  // things to clean up\n  this._unl = []; // _unloads\n  this._lstns = []; // _listeners\n  this._dpL = function () {}; // onduplicate listener\n  this._dpLC = false; // true when onduplicate called\n\n  /**\n   * Even when the own instance is not applying,\n   * we still listen to messages to ensure the hasLeader flag\n   * is set correctly.\n   */\n  var hasLeaderListener = function hasLeaderListener(msg) {\n    if (msg.context === 'leader') {\n      if (msg.action === 'death') {\n        _this._hasLeader = false;\n      }\n      if (msg.action === 'tell') {\n        _this._hasLeader = true;\n      }\n    }\n  };\n  this.broadcastChannel.addEventListener('internal', hasLeaderListener);\n  this._lstns.push(hasLeaderListener);\n};\nLeaderElection.prototype = {\n  hasLeader: function hasLeader() {\n    return Promise.resolve(this._hasLeader);\n  },\n  /**\n   * Returns true if the instance is leader,\n   * false if not.\n   * @async\n   */\n  applyOnce: function applyOnce(\n  // true if the applyOnce() call came from the fallbackInterval cycle\n  isFromFallbackInterval) {\n    var _this2 = this;\n    if (this.isLeader) {\n      return (0, _util.sleep)(0, true);\n    }\n    if (this.isDead) {\n      return (0, _util.sleep)(0, false);\n    }\n\n    /**\n     * Already applying more than once,\n     * -> wait for the apply queue to be finished.\n     */\n    if (this._aplQC > 1) {\n      return this._aplQ;\n    }\n\n    /**\n     * Add a new apply-run\n     */\n    var applyRun = function applyRun() {\n      /**\n       * Optimization shortcuts.\n       * Directly return if a previous run\n       * has already elected a leader.\n       */\n      if (_this2.isLeader) {\n        return _util.PROMISE_RESOLVED_TRUE;\n      }\n      var stopCriteria = false;\n      var stopCriteriaPromiseResolve;\n      /**\n       * Resolves when a stop criteria is reached.\n       * Uses as a performance shortcut so we do not\n       * have to await the responseTime when it is already clear\n       * that the election failed.\n       */\n      var stopCriteriaPromise = new Promise(function (res) {\n        stopCriteriaPromiseResolve = function stopCriteriaPromiseResolve() {\n          stopCriteria = true;\n          res();\n        };\n      });\n      var handleMessage = function handleMessage(msg) {\n        if (msg.context === 'leader' && msg.token != _this2.token) {\n          if (msg.action === 'apply') {\n            // other is applying\n            if (msg.token > _this2.token) {\n              /**\n               * other has higher token\n               * -> stop applying and let other become leader.\n               */\n              stopCriteriaPromiseResolve();\n            }\n          }\n          if (msg.action === 'tell') {\n            // other is already leader\n            stopCriteriaPromiseResolve();\n            _this2._hasLeader = true;\n          }\n        }\n      };\n      _this2.broadcastChannel.addEventListener('internal', handleMessage);\n\n      /**\n       * If the applyOnce() call came from the fallbackInterval,\n       * we can assume that the election runs in the background and\n       * not critical process is waiting for it.\n       * When this is true, we give the other instances\n       * more time to answer to messages in the election cycle.\n       * This makes it less likely to elect duplicate leaders.\n       * But also it takes longer which is not a problem because we anyway\n       * run in the background.\n       */\n      var waitForAnswerTime = isFromFallbackInterval ? _this2._options.responseTime * 4 : _this2._options.responseTime;\n      return (0, _leaderElectionUtil.sendLeaderMessage)(_this2, 'apply') // send out that this one is applying\n      .then(function () {\n        return Promise.race([(0, _util.sleep)(waitForAnswerTime), stopCriteriaPromise.then(function () {\n          return Promise.reject(new Error());\n        })]);\n      })\n      // send again in case another instance was just created\n      .then(function () {\n        return (0, _leaderElectionUtil.sendLeaderMessage)(_this2, 'apply');\n      })\n      // let others time to respond\n      .then(function () {\n        return Promise.race([(0, _util.sleep)(waitForAnswerTime), stopCriteriaPromise.then(function () {\n          return Promise.reject(new Error());\n        })]);\n      })[\"catch\"](function () {}).then(function () {\n        _this2.broadcastChannel.removeEventListener('internal', handleMessage);\n        if (!stopCriteria) {\n          // no stop criteria -> own is leader\n          return (0, _leaderElectionUtil.beLeader)(_this2).then(function () {\n            return true;\n          });\n        } else {\n          // other is leader\n          return false;\n        }\n      });\n    };\n    this._aplQC = this._aplQC + 1;\n    this._aplQ = this._aplQ.then(function () {\n      return applyRun();\n    }).then(function () {\n      _this2._aplQC = _this2._aplQC - 1;\n    });\n    return this._aplQ.then(function () {\n      return _this2.isLeader;\n    });\n  },\n  awaitLeadership: function awaitLeadership() {\n    if ( /* _awaitLeadershipPromise */\n    !this._aLP) {\n      this._aLP = _awaitLeadershipOnce(this);\n    }\n    return this._aLP;\n  },\n  set onduplicate(fn) {\n    this._dpL = fn;\n  },\n  die: function die() {\n    var _this3 = this;\n    this._lstns.forEach(function (listener) {\n      return _this3.broadcastChannel.removeEventListener('internal', listener);\n    });\n    this._lstns = [];\n    this._unl.forEach(function (uFn) {\n      return uFn.remove();\n    });\n    this._unl = [];\n    if (this.isLeader) {\n      this._hasLeader = false;\n      this.isLeader = false;\n    }\n    this.isDead = true;\n    return (0, _leaderElectionUtil.sendLeaderMessage)(this, 'death');\n  }\n};\n\n/**\n * @param leaderElector {LeaderElector}\n */\nfunction _awaitLeadershipOnce(leaderElector) {\n  if (leaderElector.isLeader) {\n    return _util.PROMISE_RESOLVED_VOID;\n  }\n  return new Promise(function (res) {\n    var resolved = false;\n    function finish() {\n      if (resolved) {\n        return;\n      }\n      resolved = true;\n      leaderElector.broadcastChannel.removeEventListener('internal', whenDeathListener);\n      res(true);\n    }\n\n    // try once now\n    leaderElector.applyOnce().then(function () {\n      if (leaderElector.isLeader) {\n        finish();\n      }\n    });\n\n    /**\n     * Try on fallbackInterval\n     * @recursive\n     */\n    var tryOnFallBack = function tryOnFallBack() {\n      return (0, _util.sleep)(leaderElector._options.fallbackInterval).then(function () {\n        if (leaderElector.isDead || resolved) {\n          return;\n        }\n        if (leaderElector.isLeader) {\n          finish();\n        } else {\n          return leaderElector.applyOnce(true).then(function () {\n            if (leaderElector.isLeader) {\n              finish();\n            } else {\n              tryOnFallBack();\n            }\n          });\n        }\n      });\n    };\n    tryOnFallBack();\n\n    // try when other leader dies\n    var whenDeathListener = function whenDeathListener(msg) {\n      if (msg.context === 'leader' && msg.action === 'death') {\n        leaderElector._hasLeader = false;\n        leaderElector.applyOnce().then(function () {\n          if (leaderElector.isLeader) {\n            finish();\n          }\n        });\n      }\n    };\n    leaderElector.broadcastChannel.addEventListener('internal', whenDeathListener);\n    leaderElector._lstns.push(whenDeathListener);\n  });\n}\nfunction fillOptionsWithDefaults(options, channel) {\n  if (!options) options = {};\n  options = JSON.parse(JSON.stringify(options));\n  if (!options.fallbackInterval) {\n    options.fallbackInterval = 3000;\n  }\n  if (!options.responseTime) {\n    options.responseTime = channel.method.averageResponseTime(channel.options);\n  }\n  return options;\n}\nfunction createLeaderElection(channel, options) {\n  if (channel._leaderElector) {\n    throw new Error('BroadcastChannel already has a leader-elector');\n  }\n  options = fillOptionsWithDefaults(options, channel);\n  var elector = (0, _util.supportsWebLockAPI)() ? new _leaderElectionWebLock.LeaderElectionWebLock(channel, options) : new LeaderElection(channel, options);\n  channel._befC.push(function () {\n    return elector.die();\n  });\n  channel._leaderElector = elector;\n  return elector;\n}","\"use strict\";\n\nvar _typeof = require(\"@babel/runtime/helpers/typeof\");\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.chooseMethod = chooseMethod;\nvar _native = require(\"./methods/native.js\");\nvar _indexedDb = require(\"./methods/indexed-db.js\");\nvar _localstorage = require(\"./methods/localstorage.js\");\nvar _simulate = require(\"./methods/simulate.js\");\nfunction _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== \"function\") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }\nfunction _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== \"object\" && typeof obj !== \"function\") { return { \"default\": obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== \"default\" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj[\"default\"] = obj; if (cache) { cache.set(obj, newObj); } return newObj; }\n// the line below will be removed from es5/browser builds\n\n// order is important\nvar METHODS = [_native.NativeMethod,\n// fastest\n_indexedDb.IndexedDBMethod, _localstorage.LocalstorageMethod];\nfunction chooseMethod(options) {\n  var chooseMethods = [].concat(options.methods, METHODS).filter(Boolean);\n\n  // the line below will be removed from es5/browser builds\n\n  // directly chosen\n  if (options.type) {\n    if (options.type === 'simulate') {\n      // only use simulate-method if directly chosen\n      return _simulate.SimulateMethod;\n    }\n    var ret = chooseMethods.find(function (m) {\n      return m.type === options.type;\n    });\n    if (!ret) throw new Error('method-type ' + options.type + ' not found');else return ret;\n  }\n\n  /**\n   * if no webworker support is needed,\n   * remove idb from the list so that localstorage will be chosen\n   */\n  if (!options.webWorkerSupport) {\n    chooseMethods = chooseMethods.filter(function (m) {\n      return m.type !== 'idb';\n    });\n  }\n  var useMethod = chooseMethods.find(function (method) {\n    return method.canBeUsed();\n  });\n  if (!useMethod) {\n    throw new Error(\"No usable method found in \" + JSON.stringify(METHODS.map(function (m) {\n      return m.type;\n    })));\n  } else {\n    return useMethod;\n  }\n}","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.TRANSACTION_SETTINGS = exports.IndexedDBMethod = void 0;\nexports.averageResponseTime = averageResponseTime;\nexports.canBeUsed = canBeUsed;\nexports.cleanOldMessages = cleanOldMessages;\nexports.close = close;\nexports.commitIndexedDBTransaction = commitIndexedDBTransaction;\nexports.create = create;\nexports.createDatabase = createDatabase;\nexports.getAllMessages = getAllMessages;\nexports.getIdb = getIdb;\nexports.getMessagesHigherThan = getMessagesHigherThan;\nexports.getOldMessages = getOldMessages;\nexports.microSeconds = void 0;\nexports.onMessage = onMessage;\nexports.postMessage = postMessage;\nexports.removeMessagesById = removeMessagesById;\nexports.type = void 0;\nexports.writeMessage = writeMessage;\nvar _util = require(\"../util.js\");\nvar _obliviousSet = require(\"oblivious-set\");\nvar _options = require(\"../options.js\");\n/**\n * this method uses indexeddb to store the messages\n * There is currently no observerAPI for idb\n * @link https://github.com/w3c/IndexedDB/issues/51\n * \n * When working on this, ensure to use these performance optimizations:\n * @link https://rxdb.info/slow-indexeddb.html\n */\n\nvar microSeconds = _util.microSeconds;\nexports.microSeconds = microSeconds;\nvar DB_PREFIX = 'pubkey.broadcast-channel-0-';\nvar OBJECT_STORE_ID = 'messages';\n\n/**\n * Use relaxed durability for faster performance on all transactions.\n * @link https://nolanlawson.com/2021/08/22/speeding-up-indexeddb-reads-and-writes/\n */\nvar TRANSACTION_SETTINGS = {\n  durability: 'relaxed'\n};\nexports.TRANSACTION_SETTINGS = TRANSACTION_SETTINGS;\nvar type = 'idb';\nexports.type = type;\nfunction getIdb() {\n  if (typeof indexedDB !== 'undefined') return indexedDB;\n  if (typeof window !== 'undefined') {\n    if (typeof window.mozIndexedDB !== 'undefined') return window.mozIndexedDB;\n    if (typeof window.webkitIndexedDB !== 'undefined') return window.webkitIndexedDB;\n    if (typeof window.msIndexedDB !== 'undefined') return window.msIndexedDB;\n  }\n  return false;\n}\n\n/**\n * If possible, we should explicitly commit IndexedDB transactions\n * for better performance.\n * @link https://nolanlawson.com/2021/08/22/speeding-up-indexeddb-reads-and-writes/\n */\nfunction commitIndexedDBTransaction(tx) {\n  if (tx.commit) {\n    tx.commit();\n  }\n}\nfunction createDatabase(channelName) {\n  var IndexedDB = getIdb();\n\n  // create table\n  var dbName = DB_PREFIX + channelName;\n\n  /**\n   * All IndexedDB databases are opened without version\n   * because it is a bit faster, especially on firefox\n   * @link http://nparashuram.com/IndexedDB/perf/#Open%20Database%20with%20version\n   */\n  var openRequest = IndexedDB.open(dbName);\n  openRequest.onupgradeneeded = function (ev) {\n    var db = ev.target.result;\n    db.createObjectStore(OBJECT_STORE_ID, {\n      keyPath: 'id',\n      autoIncrement: true\n    });\n  };\n  return new Promise(function (res, rej) {\n    openRequest.onerror = function (ev) {\n      return rej(ev);\n    };\n    openRequest.onsuccess = function () {\n      res(openRequest.result);\n    };\n  });\n}\n\n/**\n * writes the new message to the database\n * so other readers can find it\n */\nfunction writeMessage(db, readerUuid, messageJson) {\n  var time = new Date().getTime();\n  var writeObject = {\n    uuid: readerUuid,\n    time: time,\n    data: messageJson\n  };\n  var tx = db.transaction([OBJECT_STORE_ID], 'readwrite', TRANSACTION_SETTINGS);\n  return new Promise(function (res, rej) {\n    tx.oncomplete = function () {\n      return res();\n    };\n    tx.onerror = function (ev) {\n      return rej(ev);\n    };\n    var objectStore = tx.objectStore(OBJECT_STORE_ID);\n    objectStore.add(writeObject);\n    commitIndexedDBTransaction(tx);\n  });\n}\nfunction getAllMessages(db) {\n  var tx = db.transaction(OBJECT_STORE_ID, 'readonly', TRANSACTION_SETTINGS);\n  var objectStore = tx.objectStore(OBJECT_STORE_ID);\n  var ret = [];\n  return new Promise(function (res) {\n    objectStore.openCursor().onsuccess = function (ev) {\n      var cursor = ev.target.result;\n      if (cursor) {\n        ret.push(cursor.value);\n        //alert(\"Name for SSN \" + cursor.key + \" is \" + cursor.value.name);\n        cursor[\"continue\"]();\n      } else {\n        commitIndexedDBTransaction(tx);\n        res(ret);\n      }\n    };\n  });\n}\nfunction getMessagesHigherThan(db, lastCursorId) {\n  var tx = db.transaction(OBJECT_STORE_ID, 'readonly', TRANSACTION_SETTINGS);\n  var objectStore = tx.objectStore(OBJECT_STORE_ID);\n  var ret = [];\n  var keyRangeValue = IDBKeyRange.bound(lastCursorId + 1, Infinity);\n\n  /**\n   * Optimization shortcut,\n   * if getAll() can be used, do not use a cursor.\n   * @link https://rxdb.info/slow-indexeddb.html\n   */\n  if (objectStore.getAll) {\n    var getAllRequest = objectStore.getAll(keyRangeValue);\n    return new Promise(function (res, rej) {\n      getAllRequest.onerror = function (err) {\n        return rej(err);\n      };\n      getAllRequest.onsuccess = function (e) {\n        res(e.target.result);\n      };\n    });\n  }\n  function openCursor() {\n    // Occasionally Safari will fail on IDBKeyRange.bound, this\n    // catches that error, having it open the cursor to the first\n    // item. When it gets data it will advance to the desired key.\n    try {\n      keyRangeValue = IDBKeyRange.bound(lastCursorId + 1, Infinity);\n      return objectStore.openCursor(keyRangeValue);\n    } catch (e) {\n      return objectStore.openCursor();\n    }\n  }\n  return new Promise(function (res, rej) {\n    var openCursorRequest = openCursor();\n    openCursorRequest.onerror = function (err) {\n      return rej(err);\n    };\n    openCursorRequest.onsuccess = function (ev) {\n      var cursor = ev.target.result;\n      if (cursor) {\n        if (cursor.value.id < lastCursorId + 1) {\n          cursor[\"continue\"](lastCursorId + 1);\n        } else {\n          ret.push(cursor.value);\n          cursor[\"continue\"]();\n        }\n      } else {\n        commitIndexedDBTransaction(tx);\n        res(ret);\n      }\n    };\n  });\n}\nfunction removeMessagesById(channelState, ids) {\n  if (channelState.closed) {\n    return Promise.resolve([]);\n  }\n  var tx = channelState.db.transaction(OBJECT_STORE_ID, 'readwrite', TRANSACTION_SETTINGS);\n  var objectStore = tx.objectStore(OBJECT_STORE_ID);\n  return Promise.all(ids.map(function (id) {\n    var deleteRequest = objectStore[\"delete\"](id);\n    return new Promise(function (res) {\n      deleteRequest.onsuccess = function () {\n        return res();\n      };\n    });\n  }));\n}\nfunction getOldMessages(db, ttl) {\n  var olderThen = new Date().getTime() - ttl;\n  var tx = db.transaction(OBJECT_STORE_ID, 'readonly', TRANSACTION_SETTINGS);\n  var objectStore = tx.objectStore(OBJECT_STORE_ID);\n  var ret = [];\n  return new Promise(function (res) {\n    objectStore.openCursor().onsuccess = function (ev) {\n      var cursor = ev.target.result;\n      if (cursor) {\n        var msgObk = cursor.value;\n        if (msgObk.time < olderThen) {\n          ret.push(msgObk);\n          //alert(\"Name for SSN \" + cursor.key + \" is \" + cursor.value.name);\n          cursor[\"continue\"]();\n        } else {\n          // no more old messages,\n          commitIndexedDBTransaction(tx);\n          res(ret);\n        }\n      } else {\n        res(ret);\n      }\n    };\n  });\n}\nfunction cleanOldMessages(channelState) {\n  return getOldMessages(channelState.db, channelState.options.idb.ttl).then(function (tooOld) {\n    return removeMessagesById(channelState, tooOld.map(function (msg) {\n      return msg.id;\n    }));\n  });\n}\nfunction create(channelName, options) {\n  options = (0, _options.fillOptionsWithDefaults)(options);\n  return createDatabase(channelName).then(function (db) {\n    var state = {\n      closed: false,\n      lastCursorId: 0,\n      channelName: channelName,\n      options: options,\n      uuid: (0, _util.randomToken)(),\n      /**\n       * emittedMessagesIds\n       * contains all messages that have been emitted before\n       * @type {ObliviousSet}\n       */\n      eMIs: new _obliviousSet.ObliviousSet(options.idb.ttl * 2),\n      // ensures we do not read messages in parallel\n      writeBlockPromise: _util.PROMISE_RESOLVED_VOID,\n      messagesCallback: null,\n      readQueuePromises: [],\n      db: db\n    };\n\n    /**\n     * Handle abrupt closes that do not originate from db.close().\n     * This could happen, for example, if the underlying storage is\n     * removed or if the user clears the database in the browser's\n     * history preferences.\n     */\n    db.onclose = function () {\n      state.closed = true;\n      if (options.idb.onclose) options.idb.onclose();\n    };\n\n    /**\n     * if service-workers are used,\n     * we have no 'storage'-event if they post a message,\n     * therefore we also have to set an interval\n     */\n    _readLoop(state);\n    return state;\n  });\n}\nfunction _readLoop(state) {\n  if (state.closed) return;\n  readNewMessages(state).then(function () {\n    return (0, _util.sleep)(state.options.idb.fallbackInterval);\n  }).then(function () {\n    return _readLoop(state);\n  });\n}\nfunction _filterMessage(msgObj, state) {\n  if (msgObj.uuid === state.uuid) return false; // send by own\n  if (state.eMIs.has(msgObj.id)) return false; // already emitted\n  if (msgObj.data.time < state.messagesCallbackTime) return false; // older then onMessageCallback\n  return true;\n}\n\n/**\n * reads all new messages from the database and emits them\n */\nfunction readNewMessages(state) {\n  // channel already closed\n  if (state.closed) return _util.PROMISE_RESOLVED_VOID;\n\n  // if no one is listening, we do not need to scan for new messages\n  if (!state.messagesCallback) return _util.PROMISE_RESOLVED_VOID;\n  return getMessagesHigherThan(state.db, state.lastCursorId).then(function (newerMessages) {\n    var useMessages = newerMessages\n    /**\n     * there is a bug in iOS where the msgObj can be undefined sometimes\n     * so we filter them out\n     * @link https://github.com/pubkey/broadcast-channel/issues/19\n     */.filter(function (msgObj) {\n      return !!msgObj;\n    }).map(function (msgObj) {\n      if (msgObj.id > state.lastCursorId) {\n        state.lastCursorId = msgObj.id;\n      }\n      return msgObj;\n    }).filter(function (msgObj) {\n      return _filterMessage(msgObj, state);\n    }).sort(function (msgObjA, msgObjB) {\n      return msgObjA.time - msgObjB.time;\n    }); // sort by time\n    useMessages.forEach(function (msgObj) {\n      if (state.messagesCallback) {\n        state.eMIs.add(msgObj.id);\n        state.messagesCallback(msgObj.data);\n      }\n    });\n    return _util.PROMISE_RESOLVED_VOID;\n  });\n}\nfunction close(channelState) {\n  channelState.closed = true;\n  channelState.db.close();\n}\nfunction postMessage(channelState, messageJson) {\n  channelState.writeBlockPromise = channelState.writeBlockPromise.then(function () {\n    return writeMessage(channelState.db, channelState.uuid, messageJson);\n  }).then(function () {\n    if ((0, _util.randomInt)(0, 10) === 0) {\n      /* await (do not await) */\n      cleanOldMessages(channelState);\n    }\n  });\n  return channelState.writeBlockPromise;\n}\nfunction onMessage(channelState, fn, time) {\n  channelState.messagesCallbackTime = time;\n  channelState.messagesCallback = fn;\n  readNewMessages(channelState);\n}\nfunction canBeUsed() {\n  return !!getIdb();\n}\nfunction averageResponseTime(options) {\n  return options.idb.fallbackInterval * 2;\n}\nvar IndexedDBMethod = {\n  create: create,\n  close: close,\n  onMessage: onMessage,\n  postMessage: postMessage,\n  canBeUsed: canBeUsed,\n  type: type,\n  averageResponseTime: averageResponseTime,\n  microSeconds: microSeconds\n};\nexports.IndexedDBMethod = IndexedDBMethod;","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.LocalstorageMethod = void 0;\nexports.addStorageEventListener = addStorageEventListener;\nexports.averageResponseTime = averageResponseTime;\nexports.canBeUsed = canBeUsed;\nexports.close = close;\nexports.create = create;\nexports.getLocalStorage = getLocalStorage;\nexports.microSeconds = void 0;\nexports.onMessage = onMessage;\nexports.postMessage = postMessage;\nexports.removeStorageEventListener = removeStorageEventListener;\nexports.storageKey = storageKey;\nexports.type = void 0;\nvar _obliviousSet = require(\"oblivious-set\");\nvar _options = require(\"../options.js\");\nvar _util = require(\"../util.js\");\n/**\n * A localStorage-only method which uses localstorage and its 'storage'-event\n * This does not work inside webworkers because they have no access to localstorage\n * This is basically implemented to support IE9 or your grandmother's toaster.\n * @link https://caniuse.com/#feat=namevalue-storage\n * @link https://caniuse.com/#feat=indexeddb\n */\n\nvar microSeconds = _util.microSeconds;\nexports.microSeconds = microSeconds;\nvar KEY_PREFIX = 'pubkey.broadcastChannel-';\nvar type = 'localstorage';\n\n/**\n * copied from crosstab\n * @link https://github.com/tejacques/crosstab/blob/master/src/crosstab.js#L32\n */\nexports.type = type;\nfunction getLocalStorage() {\n  var localStorage;\n  if (typeof window === 'undefined') return null;\n  try {\n    localStorage = window.localStorage;\n    localStorage = window['ie8-eventlistener/storage'] || window.localStorage;\n  } catch (e) {\n    // New versions of Firefox throw a Security exception\n    // if cookies are disabled. See\n    // https://bugzilla.mozilla.org/show_bug.cgi?id=1028153\n  }\n  return localStorage;\n}\nfunction storageKey(channelName) {\n  return KEY_PREFIX + channelName;\n}\n\n/**\n* writes the new message to the storage\n* and fires the storage-event so other readers can find it\n*/\nfunction postMessage(channelState, messageJson) {\n  return new Promise(function (res) {\n    (0, _util.sleep)().then(function () {\n      var key = storageKey(channelState.channelName);\n      var writeObj = {\n        token: (0, _util.randomToken)(),\n        time: new Date().getTime(),\n        data: messageJson,\n        uuid: channelState.uuid\n      };\n      var value = JSON.stringify(writeObj);\n      getLocalStorage().setItem(key, value);\n\n      /**\n       * StorageEvent does not fire the 'storage' event\n       * in the window that changes the state of the local storage.\n       * So we fire it manually\n       */\n      var ev = document.createEvent('Event');\n      ev.initEvent('storage', true, true);\n      ev.key = key;\n      ev.newValue = value;\n      window.dispatchEvent(ev);\n      res();\n    });\n  });\n}\nfunction addStorageEventListener(channelName, fn) {\n  var key = storageKey(channelName);\n  var listener = function listener(ev) {\n    if (ev.key === key) {\n      fn(JSON.parse(ev.newValue));\n    }\n  };\n  window.addEventListener('storage', listener);\n  return listener;\n}\nfunction removeStorageEventListener(listener) {\n  window.removeEventListener('storage', listener);\n}\nfunction create(channelName, options) {\n  options = (0, _options.fillOptionsWithDefaults)(options);\n  if (!canBeUsed()) {\n    throw new Error('BroadcastChannel: localstorage cannot be used');\n  }\n  var uuid = (0, _util.randomToken)();\n\n  /**\n   * eMIs\n   * contains all messages that have been emitted before\n   * @type {ObliviousSet}\n   */\n  var eMIs = new _obliviousSet.ObliviousSet(options.localstorage.removeTimeout);\n  var state = {\n    channelName: channelName,\n    uuid: uuid,\n    eMIs: eMIs // emittedMessagesIds\n  };\n\n  state.listener = addStorageEventListener(channelName, function (msgObj) {\n    if (!state.messagesCallback) return; // no listener\n    if (msgObj.uuid === uuid) return; // own message\n    if (!msgObj.token || eMIs.has(msgObj.token)) return; // already emitted\n    if (msgObj.data.time && msgObj.data.time < state.messagesCallbackTime) return; // too old\n\n    eMIs.add(msgObj.token);\n    state.messagesCallback(msgObj.data);\n  });\n  return state;\n}\nfunction close(channelState) {\n  removeStorageEventListener(channelState.listener);\n}\nfunction onMessage(channelState, fn, time) {\n  channelState.messagesCallbackTime = time;\n  channelState.messagesCallback = fn;\n}\nfunction canBeUsed() {\n  var ls = getLocalStorage();\n  if (!ls) return false;\n  try {\n    var key = '__broadcastchannel_check';\n    ls.setItem(key, 'works');\n    ls.removeItem(key);\n  } catch (e) {\n    // Safari 10 in private mode will not allow write access to local\n    // storage and fail with a QuotaExceededError. See\n    // https://developer.mozilla.org/en-US/docs/Web/API/Web_Storage_API#Private_Browsing_Incognito_modes\n    return false;\n  }\n  return true;\n}\nfunction averageResponseTime() {\n  var defaultTime = 120;\n  var userAgent = navigator.userAgent.toLowerCase();\n  if (userAgent.includes('safari') && !userAgent.includes('chrome')) {\n    // safari is much slower so this time is higher\n    return defaultTime * 2;\n  }\n  return defaultTime;\n}\nvar LocalstorageMethod = {\n  create: create,\n  close: close,\n  onMessage: onMessage,\n  postMessage: postMessage,\n  canBeUsed: canBeUsed,\n  type: type,\n  averageResponseTime: averageResponseTime,\n  microSeconds: microSeconds\n};\nexports.LocalstorageMethod = LocalstorageMethod;","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.NativeMethod = void 0;\nexports.averageResponseTime = averageResponseTime;\nexports.canBeUsed = canBeUsed;\nexports.close = close;\nexports.create = create;\nexports.microSeconds = void 0;\nexports.onMessage = onMessage;\nexports.postMessage = postMessage;\nexports.type = void 0;\nvar _util = require(\"../util.js\");\nvar microSeconds = _util.microSeconds;\nexports.microSeconds = microSeconds;\nvar type = 'native';\nexports.type = type;\nfunction create(channelName) {\n  var state = {\n    messagesCallback: null,\n    bc: new BroadcastChannel(channelName),\n    subFns: [] // subscriberFunctions\n  };\n\n  state.bc.onmessage = function (msg) {\n    if (state.messagesCallback) {\n      state.messagesCallback(msg.data);\n    }\n  };\n  return state;\n}\nfunction close(channelState) {\n  channelState.bc.close();\n  channelState.subFns = [];\n}\nfunction postMessage(channelState, messageJson) {\n  try {\n    channelState.bc.postMessage(messageJson, false);\n    return _util.PROMISE_RESOLVED_VOID;\n  } catch (err) {\n    return Promise.reject(err);\n  }\n}\nfunction onMessage(channelState, fn) {\n  channelState.messagesCallback = fn;\n}\nfunction canBeUsed() {\n  if ((typeof window !== 'undefined' || typeof self !== 'undefined') && typeof BroadcastChannel === 'function') {\n    if (BroadcastChannel._pubkey) {\n      throw new Error('BroadcastChannel: Do not overwrite window.BroadcastChannel with this module, this is not a polyfill');\n    }\n    return true;\n  } else {\n    return false;\n  }\n}\nfunction averageResponseTime() {\n  return 150;\n}\nvar NativeMethod = {\n  create: create,\n  close: close,\n  onMessage: onMessage,\n  postMessage: postMessage,\n  canBeUsed: canBeUsed,\n  type: type,\n  averageResponseTime: averageResponseTime,\n  microSeconds: microSeconds\n};\nexports.NativeMethod = NativeMethod;","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.SimulateMethod = void 0;\nexports.averageResponseTime = averageResponseTime;\nexports.canBeUsed = canBeUsed;\nexports.close = close;\nexports.create = create;\nexports.microSeconds = void 0;\nexports.onMessage = onMessage;\nexports.postMessage = postMessage;\nexports.type = void 0;\nvar _util = require(\"../util.js\");\nvar microSeconds = _util.microSeconds;\nexports.microSeconds = microSeconds;\nvar type = 'simulate';\nexports.type = type;\nvar SIMULATE_CHANNELS = new Set();\nfunction create(channelName) {\n  var state = {\n    name: channelName,\n    messagesCallback: null\n  };\n  SIMULATE_CHANNELS.add(state);\n  return state;\n}\nfunction close(channelState) {\n  SIMULATE_CHANNELS[\"delete\"](channelState);\n}\nfunction postMessage(channelState, messageJson) {\n  return new Promise(function (res) {\n    return setTimeout(function () {\n      var channelArray = Array.from(SIMULATE_CHANNELS);\n      channelArray.filter(function (channel) {\n        return channel.name === channelState.name;\n      }).filter(function (channel) {\n        return channel !== channelState;\n      }).filter(function (channel) {\n        return !!channel.messagesCallback;\n      }).forEach(function (channel) {\n        return channel.messagesCallback(messageJson);\n      });\n      res();\n    }, 5);\n  });\n}\nfunction onMessage(channelState, fn) {\n  channelState.messagesCallback = fn;\n}\nfunction canBeUsed() {\n  return true;\n}\nfunction averageResponseTime() {\n  return 5;\n}\nvar SimulateMethod = {\n  create: create,\n  close: close,\n  onMessage: onMessage,\n  postMessage: postMessage,\n  canBeUsed: canBeUsed,\n  type: type,\n  averageResponseTime: averageResponseTime,\n  microSeconds: microSeconds\n};\nexports.SimulateMethod = SimulateMethod;","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.fillOptionsWithDefaults = fillOptionsWithDefaults;\nfunction fillOptionsWithDefaults() {\n  var originalOptions = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};\n  var options = JSON.parse(JSON.stringify(originalOptions));\n\n  // main\n  if (typeof options.webWorkerSupport === 'undefined') options.webWorkerSupport = true;\n\n  // indexed-db\n  if (!options.idb) options.idb = {};\n  //  after this time the messages get deleted\n  if (!options.idb.ttl) options.idb.ttl = 1000 * 45;\n  if (!options.idb.fallbackInterval) options.idb.fallbackInterval = 150;\n  //  handles abrupt db onclose events.\n  if (originalOptions.idb && typeof originalOptions.idb.onclose === 'function') options.idb.onclose = originalOptions.idb.onclose;\n\n  // localstorage\n  if (!options.localstorage) options.localstorage = {};\n  if (!options.localstorage.removeTimeout) options.localstorage.removeTimeout = 1000 * 60;\n\n  // custom methods\n  if (originalOptions.methods) options.methods = originalOptions.methods;\n\n  // node\n  if (!options.node) options.node = {};\n  if (!options.node.ttl) options.node.ttl = 1000 * 60 * 2; // 2 minutes;\n  /**\n   * On linux use 'ulimit -Hn' to get the limit of open files.\n   * On ubuntu this was 4096 for me, so we use half of that as maxParallelWrites default.\n   */\n  if (!options.node.maxParallelWrites) options.node.maxParallelWrites = 2048;\n  if (typeof options.node.useFastPath === 'undefined') options.node.useFastPath = true;\n  return options;\n}","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.PROMISE_RESOLVED_VOID = exports.PROMISE_RESOLVED_TRUE = exports.PROMISE_RESOLVED_FALSE = void 0;\nexports.isPromise = isPromise;\nexports.microSeconds = microSeconds;\nexports.randomInt = randomInt;\nexports.randomToken = randomToken;\nexports.sleep = sleep;\nexports.supportsWebLockAPI = supportsWebLockAPI;\n/**\n * returns true if the given object is a promise\n */\nfunction isPromise(obj) {\n  return obj && typeof obj.then === 'function';\n}\nvar PROMISE_RESOLVED_FALSE = Promise.resolve(false);\nexports.PROMISE_RESOLVED_FALSE = PROMISE_RESOLVED_FALSE;\nvar PROMISE_RESOLVED_TRUE = Promise.resolve(true);\nexports.PROMISE_RESOLVED_TRUE = PROMISE_RESOLVED_TRUE;\nvar PROMISE_RESOLVED_VOID = Promise.resolve();\nexports.PROMISE_RESOLVED_VOID = PROMISE_RESOLVED_VOID;\nfunction sleep(time, resolveWith) {\n  if (!time) time = 0;\n  return new Promise(function (res) {\n    return setTimeout(function () {\n      return res(resolveWith);\n    }, time);\n  });\n}\nfunction randomInt(min, max) {\n  return Math.floor(Math.random() * (max - min + 1) + min);\n}\n\n/**\n * https://stackoverflow.com/a/8084248\n */\nfunction randomToken() {\n  return Math.random().toString(36).substring(2);\n}\nvar lastMs = 0;\nvar additional = 0;\n\n/**\n * returns the current time in micro-seconds,\n * WARNING: This is a pseudo-function\n * Performance.now is not reliable in webworkers, so we just make sure to never return the same time.\n * This is enough in browsers, and this function will not be used in nodejs.\n * The main reason for this hack is to ensure that BroadcastChannel behaves equal to production when it is used in fast-running unit tests.\n */\nfunction microSeconds() {\n  var ms = new Date().getTime();\n  if (ms === lastMs) {\n    additional++;\n    return ms * 1000 + additional;\n  } else {\n    lastMs = ms;\n    additional = 0;\n    return ms * 1000;\n  }\n}\n\n/**\n * Check if WebLock API is supported.\n * @link https://developer.mozilla.org/en-US/docs/Web/API/Web_Locks_API\n */\nfunction supportsWebLockAPI() {\n  if (typeof navigator !== 'undefined' && typeof navigator.locks !== 'undefined' && typeof navigator.locks.request === 'function') {\n    return true;\n  } else {\n    return false;\n  }\n}","var global = typeof self !== 'undefined' ? self : this;\nvar __self__ = (function () {\nfunction F() {\nthis.fetch = false;\nthis.DOMException = global.DOMException\n}\nF.prototype = global;\nreturn new F();\n})();\n(function(self) {\n\nvar irrelevant = (function (exports) {\n\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  Object.defineProperty(exports, '__esModule', { value: true });\n\n  return exports;\n\n})({});\n})(__self__);\n__self__.fetch.ponyfill = true;\n// Remove \"polyfill\" property added by whatwg-fetch\ndelete __self__.fetch.polyfill;\n// Choose between native implementation (global) or custom implementation (__self__)\n// var ctx = global.fetch ? global : __self__;\nvar ctx = __self__; // this line disable service worker support temporarily\nexports = ctx.fetch // To enable: import fetch from 'cross-fetch'\nexports.default = ctx.fetch // For TypeScript consumers without esModuleInterop.\nexports.fetch = ctx.fetch // To enable: import {fetch} from 'cross-fetch'\nexports.Headers = ctx.Headers\nexports.Request = ctx.Request\nexports.Response = ctx.Response\nmodule.exports = exports\n","/*! js-cookie v3.0.1 | MIT */\n;\n(function (global, factory) {\n  typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() :\n  typeof define === 'function' && define.amd ? define(factory) :\n  (global = global || self, (function () {\n    var current = global.Cookies;\n    var exports = global.Cookies = factory();\n    exports.noConflict = function () { global.Cookies = current; return exports; };\n  }()));\n}(this, (function () { 'use strict';\n\n  /* eslint-disable no-var */\n  function assign (target) {\n    for (var i = 1; i < arguments.length; i++) {\n      var source = arguments[i];\n      for (var key in source) {\n        target[key] = source[key];\n      }\n    }\n    return target\n  }\n  /* eslint-enable no-var */\n\n  /* eslint-disable no-var */\n  var defaultConverter = {\n    read: function (value) {\n      if (value[0] === '\"') {\n        value = value.slice(1, -1);\n      }\n      return value.replace(/(%[\\dA-F]{2})+/gi, decodeURIComponent)\n    },\n    write: function (value) {\n      return encodeURIComponent(value).replace(\n        /%(2[346BF]|3[AC-F]|40|5[BDE]|60|7[BCD])/g,\n        decodeURIComponent\n      )\n    }\n  };\n  /* eslint-enable no-var */\n\n  /* eslint-disable no-var */\n\n  function init (converter, defaultAttributes) {\n    function set (key, value, attributes) {\n      if (typeof document === 'undefined') {\n        return\n      }\n\n      attributes = assign({}, defaultAttributes, attributes);\n\n      if (typeof attributes.expires === 'number') {\n        attributes.expires = new Date(Date.now() + attributes.expires * 864e5);\n      }\n      if (attributes.expires) {\n        attributes.expires = attributes.expires.toUTCString();\n      }\n\n      key = encodeURIComponent(key)\n        .replace(/%(2[346B]|5E|60|7C)/g, decodeURIComponent)\n        .replace(/[()]/g, escape);\n\n      var stringifiedAttributes = '';\n      for (var attributeName in attributes) {\n        if (!attributes[attributeName]) {\n          continue\n        }\n\n        stringifiedAttributes += '; ' + attributeName;\n\n        if (attributes[attributeName] === true) {\n          continue\n        }\n\n        // Considers RFC 6265 section 5.2:\n        // ...\n        // 3.  If the remaining unparsed-attributes contains a %x3B (\";\")\n        //     character:\n        // Consume the characters of the unparsed-attributes up to,\n        // not including, the first %x3B (\";\") character.\n        // ...\n        stringifiedAttributes += '=' + attributes[attributeName].split(';')[0];\n      }\n\n      return (document.cookie =\n        key + '=' + converter.write(value, key) + stringifiedAttributes)\n    }\n\n    function get (key) {\n      if (typeof document === 'undefined' || (arguments.length && !key)) {\n        return\n      }\n\n      // To prevent the for loop in the first place assign an empty array\n      // in case there are no cookies at all.\n      var cookies = document.cookie ? document.cookie.split('; ') : [];\n      var jar = {};\n      for (var i = 0; i < cookies.length; i++) {\n        var parts = cookies[i].split('=');\n        var value = parts.slice(1).join('=');\n\n        try {\n          var foundKey = decodeURIComponent(parts[0]);\n          jar[foundKey] = converter.read(value, foundKey);\n\n          if (key === foundKey) {\n            break\n          }\n        } catch (e) {}\n      }\n\n      return key ? jar[key] : jar\n    }\n\n    return Object.create(\n      {\n        set: set,\n        get: get,\n        remove: function (key, attributes) {\n          set(\n            key,\n            '',\n            assign({}, attributes, {\n              expires: -1\n            })\n          );\n        },\n        withAttributes: function (attributes) {\n          return init(this.converter, assign({}, this.attributes, attributes))\n        },\n        withConverter: function (converter) {\n          return init(assign({}, this.converter, converter), this.attributes)\n        }\n      },\n      {\n        attributes: { value: Object.freeze(defaultAttributes) },\n        converter: { value: Object.freeze(converter) }\n      }\n    )\n  }\n\n  var api = init(defaultConverter, { path: '/' });\n  /* eslint-enable no-var */\n\n  return api;\n\n})));\n","/**\n * this is a set which automatically forgets\n * a given entry when a new entry is set and the ttl\n * of the old one is over\n */\nvar ObliviousSet = /** @class */ (function () {\n    function ObliviousSet(ttl) {\n        this.ttl = ttl;\n        this.map = new Map();\n        /**\n         * Creating calls to setTimeout() is expensive,\n         * so we only do that if there is not timeout already open.\n         */\n        this._to = false;\n    }\n    ObliviousSet.prototype.has = function (value) {\n        return this.map.has(value);\n    };\n    ObliviousSet.prototype.add = function (value) {\n        var _this = this;\n        this.map.set(value, now());\n        /**\n         * When a new value is added,\n         * start the cleanup at the next tick\n         * to not block the cpu for more important stuff\n         * that might happen.\n         */\n        if (!this._to) {\n            this._to = true;\n            setTimeout(function () {\n                _this._to = false;\n                removeTooOldValues(_this);\n            }, 0);\n        }\n    };\n    ObliviousSet.prototype.clear = function () {\n        this.map.clear();\n    };\n    return ObliviousSet;\n}());\nexport { ObliviousSet };\n/**\n * Removes all entries from the set\n * where the TTL has expired\n */\nexport function removeTooOldValues(obliviousSet) {\n    var olderThen = now() - obliviousSet.ttl;\n    var iterator = obliviousSet.map[Symbol.iterator]();\n    /**\n     * Because we can assume the new values are added at the bottom,\n     * we start from the top and stop as soon as we reach a non-too-old value.\n     */\n    while (true) {\n        var next = iterator.next().value;\n        if (!next) {\n            return; // no more elements\n        }\n        var value = next[0];\n        var time = next[1];\n        if (time < olderThen) {\n            obliviousSet.map.delete(value);\n        }\n        else {\n            // We reached a value that is not old enough\n            return;\n        }\n    }\n}\nexport function now() {\n    return new Date().getTime();\n}\n//# sourceMappingURL=index.js.map","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","import { addBrowser } from './browser.js';\nimport { addNode } from './node.js';\n\n/**\n * Use the code directly to prevent import problems\n * with the detect-node package.\n * @link https://github.com/iliakan/detect-node/blob/master/index.js\n */\nvar isNode = Object.prototype.toString.call(typeof process !== 'undefined' ? process : 0) === '[object process]';\nvar USE_METHOD = isNode ? addNode : addBrowser;\nvar LISTENERS = new Set();\nvar startedListening = false;\nfunction startListening() {\n  if (startedListening) {\n    return;\n  }\n  startedListening = true;\n  USE_METHOD(runAll);\n}\nexport function add(fn) {\n  startListening();\n  if (typeof fn !== 'function') {\n    throw new Error('Listener is no function');\n  }\n  LISTENERS.add(fn);\n  var addReturn = {\n    remove: function remove() {\n      return LISTENERS[\"delete\"](fn);\n    },\n    run: function run() {\n      LISTENERS[\"delete\"](fn);\n      return fn();\n    }\n  };\n  return addReturn;\n}\nexport function runAll() {\n  var promises = [];\n  LISTENERS.forEach(function (fn) {\n    promises.push(fn());\n    LISTENERS[\"delete\"](fn);\n  });\n  return Promise.all(promises);\n}\nexport function removeAll() {\n  LISTENERS.clear();\n}\nexport function getSize() {\n  return LISTENERS.size;\n}","export function addNode(fn) {\n  process.on('exit', function () {\n    return fn();\n  });\n\n  /**\n   * on the following events,\n   * the process will not end if there are\n   * event-handlers attached,\n   * therefore we have to call process.exit()\n   */\n  process.on('beforeExit', function () {\n    return fn().then(function () {\n      return process.exit();\n    });\n  });\n  // catches ctrl+c event\n  process.on('SIGINT', function () {\n    return fn().then(function () {\n      return process.exit();\n    });\n  });\n  // catches uncaught exceptions\n  process.on('uncaughtException', function (err) {\n    return fn().then(function () {\n      console.trace(err);\n      process.exit(101);\n    });\n  });\n}","/* global WorkerGlobalScope */\n\nexport function addBrowser(fn) {\n  if (typeof WorkerGlobalScope === 'function' && self instanceof WorkerGlobalScope) {\n    /**\n     * Because killing a worker does directly stop the excution\n     * of the code, our only chance is to overwrite the close function\n     * which could work some times.\n     * @link https://stackoverflow.com/q/72903255/3443137\n     */\n    var oldClose = self.close.bind(self);\n    self.close = function () {\n      fn();\n      return oldClose();\n    };\n  } else {\n    /**\n     * if we are on react-native, there is no window.addEventListener\n     * @link https://github.com/pubkey/unload/issues/6\n     */\n    if (typeof window.addEventListener !== 'function') {\n      return;\n    }\n\n    /**\n     * for normal browser-windows, we use the beforeunload-event\n     */\n    window.addEventListener('beforeunload', function () {\n      fn();\n    }, true);\n\n    /**\n     * for iframes, we have to use the unload-event\n     * @link https://stackoverflow.com/q/47533670/3443137\n     */\n    window.addEventListener('unload', function () {\n      fn();\n    }, true);\n  }\n\n  /**\n   * TODO add fallback for safari-mobile\n   * @link https://stackoverflow.com/a/26193516/3443137\n   */\n}","function _arrayLikeToArray(arr, len) {\n  if (len == null || len > arr.length) len = arr.length;\n  for (var i = 0, arr2 = new Array(len); i < len; i++) {\n    arr2[i] = arr[i];\n  }\n  return arr2;\n}\nmodule.exports = _arrayLikeToArray, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","function _arrayWithHoles(arr) {\n  if (Array.isArray(arr)) return arr;\n}\nmodule.exports = _arrayWithHoles, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","var arrayLikeToArray = require(\"./arrayLikeToArray.js\");\nfunction _arrayWithoutHoles(arr) {\n  if (Array.isArray(arr)) return arrayLikeToArray(arr);\n}\nmodule.exports = _arrayWithoutHoles, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","function _assertThisInitialized(self) {\n  if (self === void 0) {\n    throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\");\n  }\n  return self;\n}\nmodule.exports = _assertThisInitialized, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {\n  try {\n    var info = gen[key](arg);\n    var value = info.value;\n  } catch (error) {\n    reject(error);\n    return;\n  }\n  if (info.done) {\n    resolve(value);\n  } else {\n    Promise.resolve(value).then(_next, _throw);\n  }\n}\nfunction _asyncToGenerator(fn) {\n  return function () {\n    var self = this,\n      args = arguments;\n    return new Promise(function (resolve, reject) {\n      var gen = fn.apply(self, args);\n      function _next(value) {\n        asyncGeneratorStep(gen, resolve, reject, _next, _throw, \"next\", value);\n      }\n      function _throw(err) {\n        asyncGeneratorStep(gen, resolve, reject, _next, _throw, \"throw\", err);\n      }\n      _next(undefined);\n    });\n  };\n}\nmodule.exports = _asyncToGenerator, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","function _classCallCheck(instance, Constructor) {\n  if (!(instance instanceof Constructor)) {\n    throw new TypeError(\"Cannot call a class as a function\");\n  }\n}\nmodule.exports = _classCallCheck, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","var setPrototypeOf = require(\"./setPrototypeOf.js\");\nvar isNativeReflectConstruct = require(\"./isNativeReflectConstruct.js\");\nfunction _construct(Parent, args, Class) {\n  if (isNativeReflectConstruct()) {\n    module.exports = _construct = Reflect.construct.bind(), module.exports.__esModule = true, module.exports[\"default\"] = module.exports;\n  } else {\n    module.exports = _construct = function _construct(Parent, args, Class) {\n      var a = [null];\n      a.push.apply(a, args);\n      var Constructor = Function.bind.apply(Parent, a);\n      var instance = new Constructor();\n      if (Class) setPrototypeOf(instance, Class.prototype);\n      return instance;\n    }, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;\n  }\n  return _construct.apply(null, arguments);\n}\nmodule.exports = _construct, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","function _defineProperties(target, props) {\n  for (var i = 0; i < props.length; i++) {\n    var descriptor = props[i];\n    descriptor.enumerable = descriptor.enumerable || false;\n    descriptor.configurable = true;\n    if (\"value\" in descriptor) descriptor.writable = true;\n    Object.defineProperty(target, descriptor.key, descriptor);\n  }\n}\nfunction _createClass(Constructor, protoProps, staticProps) {\n  if (protoProps) _defineProperties(Constructor.prototype, protoProps);\n  if (staticProps) _defineProperties(Constructor, staticProps);\n  Object.defineProperty(Constructor, \"prototype\", {\n    writable: false\n  });\n  return Constructor;\n}\nmodule.exports = _createClass, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","function _defineProperty(obj, key, value) {\n  if (key in obj) {\n    Object.defineProperty(obj, key, {\n      value: value,\n      enumerable: true,\n      configurable: true,\n      writable: true\n    });\n  } else {\n    obj[key] = value;\n  }\n  return obj;\n}\nmodule.exports = _defineProperty, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","var superPropBase = require(\"./superPropBase.js\");\nfunction _get() {\n  if (typeof Reflect !== \"undefined\" && Reflect.get) {\n    module.exports = _get = Reflect.get.bind(), module.exports.__esModule = true, module.exports[\"default\"] = module.exports;\n  } else {\n    module.exports = _get = function _get(target, property, receiver) {\n      var base = superPropBase(target, property);\n      if (!base) return;\n      var desc = Object.getOwnPropertyDescriptor(base, property);\n      if (desc.get) {\n        return desc.get.call(arguments.length < 3 ? target : receiver);\n      }\n      return desc.value;\n    }, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;\n  }\n  return _get.apply(this, arguments);\n}\nmodule.exports = _get, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","function _getPrototypeOf(o) {\n  module.exports = _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) {\n    return o.__proto__ || Object.getPrototypeOf(o);\n  }, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;\n  return _getPrototypeOf(o);\n}\nmodule.exports = _getPrototypeOf, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","var setPrototypeOf = require(\"./setPrototypeOf.js\");\nfunction _inherits(subClass, superClass) {\n  if (typeof superClass !== \"function\" && superClass !== null) {\n    throw new TypeError(\"Super expression must either be null or a function\");\n  }\n  subClass.prototype = Object.create(superClass && superClass.prototype, {\n    constructor: {\n      value: subClass,\n      writable: true,\n      configurable: true\n    }\n  });\n  Object.defineProperty(subClass, \"prototype\", {\n    writable: false\n  });\n  if (superClass) setPrototypeOf(subClass, superClass);\n}\nmodule.exports = _inherits, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","function _interopRequireDefault(obj) {\n  return obj && obj.__esModule ? obj : {\n    \"default\": obj\n  };\n}\nmodule.exports = _interopRequireDefault, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","function _isNativeFunction(fn) {\n  return Function.toString.call(fn).indexOf(\"[native code]\") !== -1;\n}\nmodule.exports = _isNativeFunction, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","function _isNativeReflectConstruct() {\n  if (typeof Reflect === \"undefined\" || !Reflect.construct) return false;\n  if (Reflect.construct.sham) return false;\n  if (typeof Proxy === \"function\") return true;\n  try {\n    Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {}));\n    return true;\n  } catch (e) {\n    return false;\n  }\n}\nmodule.exports = _isNativeReflectConstruct, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","function _iterableToArray(iter) {\n  if (typeof Symbol !== \"undefined\" && iter[Symbol.iterator] != null || iter[\"@@iterator\"] != null) return Array.from(iter);\n}\nmodule.exports = _iterableToArray, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","function _iterableToArrayLimit(arr, i) {\n  var _i = arr == null ? null : typeof Symbol !== \"undefined\" && arr[Symbol.iterator] || arr[\"@@iterator\"];\n  if (_i == null) return;\n  var _arr = [];\n  var _n = true;\n  var _d = false;\n  var _s, _e;\n  try {\n    for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) {\n      _arr.push(_s.value);\n      if (i && _arr.length === i) break;\n    }\n  } catch (err) {\n    _d = true;\n    _e = err;\n  } finally {\n    try {\n      if (!_n && _i[\"return\"] != null) _i[\"return\"]();\n    } finally {\n      if (_d) throw _e;\n    }\n  }\n  return _arr;\n}\nmodule.exports = _iterableToArrayLimit, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","function _nonIterableRest() {\n  throw new TypeError(\"Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\");\n}\nmodule.exports = _nonIterableRest, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","function _nonIterableSpread() {\n  throw new TypeError(\"Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\");\n}\nmodule.exports = _nonIterableSpread, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","var objectWithoutPropertiesLoose = require(\"./objectWithoutPropertiesLoose.js\");\nfunction _objectWithoutProperties(source, excluded) {\n  if (source == null) return {};\n  var target = objectWithoutPropertiesLoose(source, excluded);\n  var key, i;\n  if (Object.getOwnPropertySymbols) {\n    var sourceSymbolKeys = Object.getOwnPropertySymbols(source);\n    for (i = 0; i < sourceSymbolKeys.length; i++) {\n      key = sourceSymbolKeys[i];\n      if (excluded.indexOf(key) >= 0) continue;\n      if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue;\n      target[key] = source[key];\n    }\n  }\n  return target;\n}\nmodule.exports = _objectWithoutProperties, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","function _objectWithoutPropertiesLoose(source, excluded) {\n  if (source == null) return {};\n  var target = {};\n  var sourceKeys = Object.keys(source);\n  var key, i;\n  for (i = 0; i < sourceKeys.length; i++) {\n    key = sourceKeys[i];\n    if (excluded.indexOf(key) >= 0) continue;\n    target[key] = source[key];\n  }\n  return target;\n}\nmodule.exports = _objectWithoutPropertiesLoose, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","var _typeof = require(\"./typeof.js\")[\"default\"];\nvar assertThisInitialized = require(\"./assertThisInitialized.js\");\nfunction _possibleConstructorReturn(self, call) {\n  if (call && (_typeof(call) === \"object\" || typeof call === \"function\")) {\n    return call;\n  } else if (call !== void 0) {\n    throw new TypeError(\"Derived constructors may only return object or undefined\");\n  }\n  return assertThisInitialized(self);\n}\nmodule.exports = _possibleConstructorReturn, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","var _typeof = require(\"./typeof.js\")[\"default\"];\nfunction _regeneratorRuntime() {\n  \"use strict\"; /*! regenerator-runtime -- Copyright (c) 2014-present, Facebook, Inc. -- license (MIT): https://github.com/facebook/regenerator/blob/main/LICENSE */\n  module.exports = _regeneratorRuntime = function _regeneratorRuntime() {\n    return exports;\n  }, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;\n  var exports = {},\n    Op = Object.prototype,\n    hasOwn = Op.hasOwnProperty,\n    $Symbol = \"function\" == typeof Symbol ? Symbol : {},\n    iteratorSymbol = $Symbol.iterator || \"@@iterator\",\n    asyncIteratorSymbol = $Symbol.asyncIterator || \"@@asyncIterator\",\n    toStringTagSymbol = $Symbol.toStringTag || \"@@toStringTag\";\n  function define(obj, key, value) {\n    return Object.defineProperty(obj, key, {\n      value: value,\n      enumerable: !0,\n      configurable: !0,\n      writable: !0\n    }), obj[key];\n  }\n  try {\n    define({}, \"\");\n  } catch (err) {\n    define = function define(obj, key, value) {\n      return obj[key] = value;\n    };\n  }\n  function wrap(innerFn, outerFn, self, tryLocsList) {\n    var protoGenerator = outerFn && outerFn.prototype instanceof Generator ? outerFn : Generator,\n      generator = Object.create(protoGenerator.prototype),\n      context = new Context(tryLocsList || []);\n    return generator._invoke = function (innerFn, self, context) {\n      var state = \"suspendedStart\";\n      return function (method, arg) {\n        if (\"executing\" === state) throw new Error(\"Generator is already running\");\n        if (\"completed\" === state) {\n          if (\"throw\" === method) throw arg;\n          return doneResult();\n        }\n        for (context.method = method, context.arg = arg;;) {\n          var delegate = context.delegate;\n          if (delegate) {\n            var delegateResult = maybeInvokeDelegate(delegate, context);\n            if (delegateResult) {\n              if (delegateResult === ContinueSentinel) continue;\n              return delegateResult;\n            }\n          }\n          if (\"next\" === context.method) context.sent = context._sent = context.arg;else if (\"throw\" === context.method) {\n            if (\"suspendedStart\" === state) throw state = \"completed\", context.arg;\n            context.dispatchException(context.arg);\n          } else \"return\" === context.method && context.abrupt(\"return\", context.arg);\n          state = \"executing\";\n          var record = tryCatch(innerFn, self, context);\n          if (\"normal\" === record.type) {\n            if (state = context.done ? \"completed\" : \"suspendedYield\", record.arg === ContinueSentinel) continue;\n            return {\n              value: record.arg,\n              done: context.done\n            };\n          }\n          \"throw\" === record.type && (state = \"completed\", context.method = \"throw\", context.arg = record.arg);\n        }\n      };\n    }(innerFn, self, context), generator;\n  }\n  function tryCatch(fn, obj, arg) {\n    try {\n      return {\n        type: \"normal\",\n        arg: fn.call(obj, arg)\n      };\n    } catch (err) {\n      return {\n        type: \"throw\",\n        arg: err\n      };\n    }\n  }\n  exports.wrap = wrap;\n  var ContinueSentinel = {};\n  function Generator() {}\n  function GeneratorFunction() {}\n  function GeneratorFunctionPrototype() {}\n  var IteratorPrototype = {};\n  define(IteratorPrototype, iteratorSymbol, function () {\n    return this;\n  });\n  var getProto = Object.getPrototypeOf,\n    NativeIteratorPrototype = getProto && getProto(getProto(values([])));\n  NativeIteratorPrototype && NativeIteratorPrototype !== Op && hasOwn.call(NativeIteratorPrototype, iteratorSymbol) && (IteratorPrototype = NativeIteratorPrototype);\n  var Gp = GeneratorFunctionPrototype.prototype = Generator.prototype = Object.create(IteratorPrototype);\n  function defineIteratorMethods(prototype) {\n    [\"next\", \"throw\", \"return\"].forEach(function (method) {\n      define(prototype, method, function (arg) {\n        return this._invoke(method, arg);\n      });\n    });\n  }\n  function AsyncIterator(generator, PromiseImpl) {\n    function invoke(method, arg, resolve, reject) {\n      var record = tryCatch(generator[method], generator, arg);\n      if (\"throw\" !== record.type) {\n        var result = record.arg,\n          value = result.value;\n        return value && \"object\" == _typeof(value) && hasOwn.call(value, \"__await\") ? PromiseImpl.resolve(value.__await).then(function (value) {\n          invoke(\"next\", value, resolve, reject);\n        }, function (err) {\n          invoke(\"throw\", err, resolve, reject);\n        }) : PromiseImpl.resolve(value).then(function (unwrapped) {\n          result.value = unwrapped, resolve(result);\n        }, function (error) {\n          return invoke(\"throw\", error, resolve, reject);\n        });\n      }\n      reject(record.arg);\n    }\n    var previousPromise;\n    this._invoke = function (method, arg) {\n      function callInvokeWithMethodAndArg() {\n        return new PromiseImpl(function (resolve, reject) {\n          invoke(method, arg, resolve, reject);\n        });\n      }\n      return previousPromise = previousPromise ? previousPromise.then(callInvokeWithMethodAndArg, callInvokeWithMethodAndArg) : callInvokeWithMethodAndArg();\n    };\n  }\n  function maybeInvokeDelegate(delegate, context) {\n    var method = delegate.iterator[context.method];\n    if (undefined === method) {\n      if (context.delegate = null, \"throw\" === context.method) {\n        if (delegate.iterator[\"return\"] && (context.method = \"return\", context.arg = undefined, maybeInvokeDelegate(delegate, context), \"throw\" === context.method)) return ContinueSentinel;\n        context.method = \"throw\", context.arg = new TypeError(\"The iterator does not provide a 'throw' method\");\n      }\n      return ContinueSentinel;\n    }\n    var record = tryCatch(method, delegate.iterator, context.arg);\n    if (\"throw\" === record.type) return context.method = \"throw\", context.arg = record.arg, context.delegate = null, ContinueSentinel;\n    var info = record.arg;\n    return info ? info.done ? (context[delegate.resultName] = info.value, context.next = delegate.nextLoc, \"return\" !== context.method && (context.method = \"next\", context.arg = undefined), context.delegate = null, ContinueSentinel) : info : (context.method = \"throw\", context.arg = new TypeError(\"iterator result is not an object\"), context.delegate = null, ContinueSentinel);\n  }\n  function pushTryEntry(locs) {\n    var entry = {\n      tryLoc: locs[0]\n    };\n    1 in locs && (entry.catchLoc = locs[1]), 2 in locs && (entry.finallyLoc = locs[2], entry.afterLoc = locs[3]), this.tryEntries.push(entry);\n  }\n  function resetTryEntry(entry) {\n    var record = entry.completion || {};\n    record.type = \"normal\", delete record.arg, entry.completion = record;\n  }\n  function Context(tryLocsList) {\n    this.tryEntries = [{\n      tryLoc: \"root\"\n    }], tryLocsList.forEach(pushTryEntry, this), this.reset(!0);\n  }\n  function values(iterable) {\n    if (iterable) {\n      var iteratorMethod = iterable[iteratorSymbol];\n      if (iteratorMethod) return iteratorMethod.call(iterable);\n      if (\"function\" == typeof iterable.next) return iterable;\n      if (!isNaN(iterable.length)) {\n        var i = -1,\n          next = function next() {\n            for (; ++i < iterable.length;) {\n              if (hasOwn.call(iterable, i)) return next.value = iterable[i], next.done = !1, next;\n            }\n            return next.value = undefined, next.done = !0, next;\n          };\n        return next.next = next;\n      }\n    }\n    return {\n      next: doneResult\n    };\n  }\n  function doneResult() {\n    return {\n      value: undefined,\n      done: !0\n    };\n  }\n  return GeneratorFunction.prototype = GeneratorFunctionPrototype, define(Gp, \"constructor\", GeneratorFunctionPrototype), define(GeneratorFunctionPrototype, \"constructor\", GeneratorFunction), GeneratorFunction.displayName = define(GeneratorFunctionPrototype, toStringTagSymbol, \"GeneratorFunction\"), exports.isGeneratorFunction = function (genFun) {\n    var ctor = \"function\" == typeof genFun && genFun.constructor;\n    return !!ctor && (ctor === GeneratorFunction || \"GeneratorFunction\" === (ctor.displayName || ctor.name));\n  }, exports.mark = function (genFun) {\n    return Object.setPrototypeOf ? Object.setPrototypeOf(genFun, GeneratorFunctionPrototype) : (genFun.__proto__ = GeneratorFunctionPrototype, define(genFun, toStringTagSymbol, \"GeneratorFunction\")), genFun.prototype = Object.create(Gp), genFun;\n  }, exports.awrap = function (arg) {\n    return {\n      __await: arg\n    };\n  }, defineIteratorMethods(AsyncIterator.prototype), define(AsyncIterator.prototype, asyncIteratorSymbol, function () {\n    return this;\n  }), exports.AsyncIterator = AsyncIterator, exports.async = function (innerFn, outerFn, self, tryLocsList, PromiseImpl) {\n    void 0 === PromiseImpl && (PromiseImpl = Promise);\n    var iter = new AsyncIterator(wrap(innerFn, outerFn, self, tryLocsList), PromiseImpl);\n    return exports.isGeneratorFunction(outerFn) ? iter : iter.next().then(function (result) {\n      return result.done ? result.value : iter.next();\n    });\n  }, defineIteratorMethods(Gp), define(Gp, toStringTagSymbol, \"Generator\"), define(Gp, iteratorSymbol, function () {\n    return this;\n  }), define(Gp, \"toString\", function () {\n    return \"[object Generator]\";\n  }), exports.keys = function (object) {\n    var keys = [];\n    for (var key in object) {\n      keys.push(key);\n    }\n    return keys.reverse(), function next() {\n      for (; keys.length;) {\n        var key = keys.pop();\n        if (key in object) return next.value = key, next.done = !1, next;\n      }\n      return next.done = !0, next;\n    };\n  }, exports.values = values, Context.prototype = {\n    constructor: Context,\n    reset: function reset(skipTempReset) {\n      if (this.prev = 0, this.next = 0, this.sent = this._sent = undefined, this.done = !1, this.delegate = null, this.method = \"next\", this.arg = undefined, this.tryEntries.forEach(resetTryEntry), !skipTempReset) for (var name in this) {\n        \"t\" === name.charAt(0) && hasOwn.call(this, name) && !isNaN(+name.slice(1)) && (this[name] = undefined);\n      }\n    },\n    stop: function stop() {\n      this.done = !0;\n      var rootRecord = this.tryEntries[0].completion;\n      if (\"throw\" === rootRecord.type) throw rootRecord.arg;\n      return this.rval;\n    },\n    dispatchException: function dispatchException(exception) {\n      if (this.done) throw exception;\n      var context = this;\n      function handle(loc, caught) {\n        return record.type = \"throw\", record.arg = exception, context.next = loc, caught && (context.method = \"next\", context.arg = undefined), !!caught;\n      }\n      for (var i = this.tryEntries.length - 1; i >= 0; --i) {\n        var entry = this.tryEntries[i],\n          record = entry.completion;\n        if (\"root\" === entry.tryLoc) return handle(\"end\");\n        if (entry.tryLoc <= this.prev) {\n          var hasCatch = hasOwn.call(entry, \"catchLoc\"),\n            hasFinally = hasOwn.call(entry, \"finallyLoc\");\n          if (hasCatch && hasFinally) {\n            if (this.prev < entry.catchLoc) return handle(entry.catchLoc, !0);\n            if (this.prev < entry.finallyLoc) return handle(entry.finallyLoc);\n          } else if (hasCatch) {\n            if (this.prev < entry.catchLoc) return handle(entry.catchLoc, !0);\n          } else {\n            if (!hasFinally) throw new Error(\"try statement without catch or finally\");\n            if (this.prev < entry.finallyLoc) return handle(entry.finallyLoc);\n          }\n        }\n      }\n    },\n    abrupt: function abrupt(type, arg) {\n      for (var i = this.tryEntries.length - 1; i >= 0; --i) {\n        var entry = this.tryEntries[i];\n        if (entry.tryLoc <= this.prev && hasOwn.call(entry, \"finallyLoc\") && this.prev < entry.finallyLoc) {\n          var finallyEntry = entry;\n          break;\n        }\n      }\n      finallyEntry && (\"break\" === type || \"continue\" === type) && finallyEntry.tryLoc <= arg && arg <= finallyEntry.finallyLoc && (finallyEntry = null);\n      var record = finallyEntry ? finallyEntry.completion : {};\n      return record.type = type, record.arg = arg, finallyEntry ? (this.method = \"next\", this.next = finallyEntry.finallyLoc, ContinueSentinel) : this.complete(record);\n    },\n    complete: function complete(record, afterLoc) {\n      if (\"throw\" === record.type) throw record.arg;\n      return \"break\" === record.type || \"continue\" === record.type ? this.next = record.arg : \"return\" === record.type ? (this.rval = this.arg = record.arg, this.method = \"return\", this.next = \"end\") : \"normal\" === record.type && afterLoc && (this.next = afterLoc), ContinueSentinel;\n    },\n    finish: function finish(finallyLoc) {\n      for (var i = this.tryEntries.length - 1; i >= 0; --i) {\n        var entry = this.tryEntries[i];\n        if (entry.finallyLoc === finallyLoc) return this.complete(entry.completion, entry.afterLoc), resetTryEntry(entry), ContinueSentinel;\n      }\n    },\n    \"catch\": function _catch(tryLoc) {\n      for (var i = this.tryEntries.length - 1; i >= 0; --i) {\n        var entry = this.tryEntries[i];\n        if (entry.tryLoc === tryLoc) {\n          var record = entry.completion;\n          if (\"throw\" === record.type) {\n            var thrown = record.arg;\n            resetTryEntry(entry);\n          }\n          return thrown;\n        }\n      }\n      throw new Error(\"illegal catch attempt\");\n    },\n    delegateYield: function delegateYield(iterable, resultName, nextLoc) {\n      return this.delegate = {\n        iterator: values(iterable),\n        resultName: resultName,\n        nextLoc: nextLoc\n      }, \"next\" === this.method && (this.arg = undefined), ContinueSentinel;\n    }\n  }, exports;\n}\nmodule.exports = _regeneratorRuntime, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","function _setPrototypeOf(o, p) {\n  module.exports = _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) {\n    o.__proto__ = p;\n    return o;\n  }, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;\n  return _setPrototypeOf(o, p);\n}\nmodule.exports = _setPrototypeOf, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","var arrayWithHoles = require(\"./arrayWithHoles.js\");\nvar iterableToArrayLimit = require(\"./iterableToArrayLimit.js\");\nvar unsupportedIterableToArray = require(\"./unsupportedIterableToArray.js\");\nvar nonIterableRest = require(\"./nonIterableRest.js\");\nfunction _slicedToArray(arr, i) {\n  return arrayWithHoles(arr) || iterableToArrayLimit(arr, i) || unsupportedIterableToArray(arr, i) || nonIterableRest();\n}\nmodule.exports = _slicedToArray, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","var getPrototypeOf = require(\"./getPrototypeOf.js\");\nfunction _superPropBase(object, property) {\n  while (!Object.prototype.hasOwnProperty.call(object, property)) {\n    object = getPrototypeOf(object);\n    if (object === null) break;\n  }\n  return object;\n}\nmodule.exports = _superPropBase, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","var arrayWithoutHoles = require(\"./arrayWithoutHoles.js\");\nvar iterableToArray = require(\"./iterableToArray.js\");\nvar unsupportedIterableToArray = require(\"./unsupportedIterableToArray.js\");\nvar nonIterableSpread = require(\"./nonIterableSpread.js\");\nfunction _toConsumableArray(arr) {\n  return arrayWithoutHoles(arr) || iterableToArray(arr) || unsupportedIterableToArray(arr) || nonIterableSpread();\n}\nmodule.exports = _toConsumableArray, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","function _typeof(obj) {\n  \"@babel/helpers - typeof\";\n\n  return (module.exports = _typeof = \"function\" == typeof Symbol && \"symbol\" == typeof Symbol.iterator ? function (obj) {\n    return typeof obj;\n  } : function (obj) {\n    return obj && \"function\" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj;\n  }, module.exports.__esModule = true, module.exports[\"default\"] = module.exports), _typeof(obj);\n}\nmodule.exports = _typeof, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","var arrayLikeToArray = require(\"./arrayLikeToArray.js\");\nfunction _unsupportedIterableToArray(o, minLen) {\n  if (!o) return;\n  if (typeof o === \"string\") return arrayLikeToArray(o, minLen);\n  var n = Object.prototype.toString.call(o).slice(8, -1);\n  if (n === \"Object\" && o.constructor) n = o.constructor.name;\n  if (n === \"Map\" || n === \"Set\") return Array.from(o);\n  if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return arrayLikeToArray(o, minLen);\n}\nmodule.exports = _unsupportedIterableToArray, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","var getPrototypeOf = require(\"./getPrototypeOf.js\");\nvar setPrototypeOf = require(\"./setPrototypeOf.js\");\nvar isNativeFunction = require(\"./isNativeFunction.js\");\nvar construct = require(\"./construct.js\");\nfunction _wrapNativeSuper(Class) {\n  var _cache = typeof Map === \"function\" ? new Map() : undefined;\n  module.exports = _wrapNativeSuper = function _wrapNativeSuper(Class) {\n    if (Class === null || !isNativeFunction(Class)) return Class;\n    if (typeof Class !== \"function\") {\n      throw new TypeError(\"Super expression must either be null or a function\");\n    }\n    if (typeof _cache !== \"undefined\") {\n      if (_cache.has(Class)) return _cache.get(Class);\n      _cache.set(Class, Wrapper);\n    }\n    function Wrapper() {\n      return construct(Class, arguments, getPrototypeOf(this).constructor);\n    }\n    Wrapper.prototype = Object.create(Class.prototype, {\n      constructor: {\n        value: Wrapper,\n        enumerable: false,\n        writable: true,\n        configurable: true\n      }\n    });\n    return setPrototypeOf(Wrapper, Class);\n  }, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;\n  return _wrapNativeSuper(Class);\n}\nmodule.exports = _wrapNativeSuper, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","// TODO(Babel 8): Remove this file.\n\nvar runtime = require(\"../helpers/regeneratorRuntime\")();\nmodule.exports = runtime;\n\n// Copied from https://github.com/facebook/regenerator/blob/main/packages/runtime/runtime.js#L736=\ntry {\n  regeneratorRuntime = runtime;\n} catch (accidentalStrictMode) {\n  if (typeof globalThis === \"object\") {\n    globalThis.regeneratorRuntime = runtime;\n  } else {\n    Function(\"r\", \"regeneratorRuntime = r\")(runtime);\n  }\n}\n","function _typeof(obj) {\n  \"@babel/helpers - typeof\";\n\n  return (module.exports = _typeof = \"function\" == typeof Symbol && \"symbol\" == typeof Symbol.iterator ? function (obj) {\n    return typeof obj;\n  } : function (obj) {\n    return obj && \"function\" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj;\n  }, module.exports.__esModule = true, module.exports[\"default\"] = module.exports), _typeof(obj);\n}\nmodule.exports = _typeof, module.exports.__esModule = true, module.exports[\"default\"] = module.exports;","function _typeof(obj) {\n  \"@babel/helpers - typeof\";\n\n  if (typeof Symbol === \"function\" && typeof Symbol.iterator === \"symbol\") {\n    _typeof = function (obj) {\n      return typeof obj;\n    };\n  } else {\n    _typeof = function (obj) {\n      return obj && typeof Symbol === \"function\" && obj.constructor === Symbol && obj !== Symbol.prototype ? \"symbol\" : typeof obj;\n    };\n  }\n\n  return _typeof(obj);\n}\n\nfunction _classCallCheck(instance, Constructor) {\n  if (!(instance instanceof Constructor)) {\n    throw new TypeError(\"Cannot call a class as a function\");\n  }\n}\n\nfunction _inherits(subClass, superClass) {\n  if (typeof superClass !== \"function\" && superClass !== null) {\n    throw new TypeError(\"Super expression must either be null or a function\");\n  }\n\n  subClass.prototype = Object.create(superClass && superClass.prototype, {\n    constructor: {\n      value: subClass,\n      writable: true,\n      configurable: true\n    }\n  });\n  if (superClass) _setPrototypeOf(subClass, superClass);\n}\n\nfunction _getPrototypeOf(o) {\n  _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) {\n    return o.__proto__ || Object.getPrototypeOf(o);\n  };\n  return _getPrototypeOf(o);\n}\n\nfunction _setPrototypeOf(o, p) {\n  _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) {\n    o.__proto__ = p;\n    return o;\n  };\n\n  return _setPrototypeOf(o, p);\n}\n\nfunction _isNativeReflectConstruct() {\n  if (typeof Reflect === \"undefined\" || !Reflect.construct) return false;\n  if (Reflect.construct.sham) return false;\n  if (typeof Proxy === \"function\") return true;\n\n  try {\n    Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {}));\n    return true;\n  } catch (e) {\n    return false;\n  }\n}\n\nfunction _construct(Parent, args, Class) {\n  if (_isNativeReflectConstruct()) {\n    _construct = Reflect.construct;\n  } else {\n    _construct = function _construct(Parent, args, Class) {\n      var a = [null];\n      a.push.apply(a, args);\n      var Constructor = Function.bind.apply(Parent, a);\n      var instance = new Constructor();\n      if (Class) _setPrototypeOf(instance, Class.prototype);\n      return instance;\n    };\n  }\n\n  return _construct.apply(null, arguments);\n}\n\nfunction _isNativeFunction(fn) {\n  return Function.toString.call(fn).indexOf(\"[native code]\") !== -1;\n}\n\nfunction _wrapNativeSuper(Class) {\n  var _cache = typeof Map === \"function\" ? new Map() : undefined;\n\n  _wrapNativeSuper = function _wrapNativeSuper(Class) {\n    if (Class === null || !_isNativeFunction(Class)) return Class;\n\n    if (typeof Class !== \"function\") {\n      throw new TypeError(\"Super expression must either be null or a function\");\n    }\n\n    if (typeof _cache !== \"undefined\") {\n      if (_cache.has(Class)) return _cache.get(Class);\n\n      _cache.set(Class, Wrapper);\n    }\n\n    function Wrapper() {\n      return _construct(Class, arguments, _getPrototypeOf(this).constructor);\n    }\n\n    Wrapper.prototype = Object.create(Class.prototype, {\n      constructor: {\n        value: Wrapper,\n        enumerable: false,\n        writable: true,\n        configurable: true\n      }\n    });\n    return _setPrototypeOf(Wrapper, Class);\n  };\n\n  return _wrapNativeSuper(Class);\n}\n\nfunction _assertThisInitialized(self) {\n  if (self === void 0) {\n    throw new ReferenceError(\"this hasn't been initialised - super() hasn't been called\");\n  }\n\n  return self;\n}\n\nfunction _possibleConstructorReturn(self, call) {\n  if (call && (typeof call === \"object\" || typeof call === \"function\")) {\n    return call;\n  }\n\n  return _assertThisInitialized(self);\n}\n\nfunction _createSuper(Derived) {\n  var hasNativeReflectConstruct = _isNativeReflectConstruct();\n\n  return function _createSuperInternal() {\n    var Super = _getPrototypeOf(Derived),\n        result;\n\n    if (hasNativeReflectConstruct) {\n      var NewTarget = _getPrototypeOf(this).constructor;\n\n      result = Reflect.construct(Super, arguments, NewTarget);\n    } else {\n      result = Super.apply(this, arguments);\n    }\n\n    return _possibleConstructorReturn(this, result);\n  };\n}\n\nfunction _toConsumableArray(arr) {\n  return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread();\n}\n\nfunction _arrayWithoutHoles(arr) {\n  if (Array.isArray(arr)) return _arrayLikeToArray(arr);\n}\n\nfunction _iterableToArray(iter) {\n  if (typeof Symbol !== \"undefined\" && iter[Symbol.iterator] != null || iter[\"@@iterator\"] != null) return Array.from(iter);\n}\n\nfunction _unsupportedIterableToArray(o, minLen) {\n  if (!o) return;\n  if (typeof o === \"string\") return _arrayLikeToArray(o, minLen);\n  var n = Object.prototype.toString.call(o).slice(8, -1);\n  if (n === \"Object\" && o.constructor) n = o.constructor.name;\n  if (n === \"Map\" || n === \"Set\") return Array.from(o);\n  if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);\n}\n\nfunction _arrayLikeToArray(arr, len) {\n  if (len == null || len > arr.length) len = arr.length;\n\n  for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];\n\n  return arr2;\n}\n\nfunction _nonIterableSpread() {\n  throw new TypeError(\"Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\");\n}\n\nfunction _createForOfIteratorHelper(o, allowArrayLike) {\n  var it = typeof Symbol !== \"undefined\" && o[Symbol.iterator] || o[\"@@iterator\"];\n\n  if (!it) {\n    if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === \"number\") {\n      if (it) o = it;\n      var i = 0;\n\n      var F = function () {};\n\n      return {\n        s: F,\n        n: function () {\n          if (i >= o.length) return {\n            done: true\n          };\n          return {\n            done: false,\n            value: o[i++]\n          };\n        },\n        e: function (e) {\n          throw e;\n        },\n        f: F\n      };\n    }\n\n    throw new TypeError(\"Invalid attempt to iterate non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\");\n  }\n\n  var normalCompletion = true,\n      didErr = false,\n      err;\n  return {\n    s: function () {\n      it = it.call(o);\n    },\n    n: function () {\n      var step = it.next();\n      normalCompletion = step.done;\n      return step;\n    },\n    e: function (e) {\n      didErr = true;\n      err = e;\n    },\n    f: function () {\n      try {\n        if (!normalCompletion && it.return != null) it.return();\n      } finally {\n        if (didErr) throw err;\n      }\n    }\n  };\n}\n\nvar hasOwnProp = Object.prototype.hasOwnProperty;\n/**\n* @typedef {null|boolean|number|string|PlainObject|GenericArray} JSONObject\n*/\n\n/**\n * Copies array and then pushes item into it.\n * @param {GenericArray} arr Array to copy and into which to push\n * @param {any} item Array item to add (to end)\n * @returns {GenericArray} Copy of the original array\n */\n\nfunction push(arr, item) {\n  arr = arr.slice();\n  arr.push(item);\n  return arr;\n}\n/**\n * Copies array and then unshifts item into it.\n * @param {any} item Array item to add (to beginning)\n * @param {GenericArray} arr Array to copy and into which to unshift\n * @returns {GenericArray} Copy of the original array\n */\n\n\nfunction unshift(item, arr) {\n  arr = arr.slice();\n  arr.unshift(item);\n  return arr;\n}\n/**\n * Caught when JSONPath is used without `new` but rethrown if with `new`\n * @extends Error\n */\n\n\nvar NewError = /*#__PURE__*/function (_Error) {\n  _inherits(NewError, _Error);\n\n  var _super = _createSuper(NewError);\n\n  /**\n   * @param {any} value The evaluated scalar value\n   */\n  function NewError(value) {\n    var _this;\n\n    _classCallCheck(this, NewError);\n\n    _this = _super.call(this, 'JSONPath should not be called with \"new\" (it prevents return ' + 'of (unwrapped) scalar values)');\n    _this.avoidNew = true;\n    _this.value = value;\n    _this.name = 'NewError';\n    return _this;\n  }\n\n  return NewError;\n}( /*#__PURE__*/_wrapNativeSuper(Error));\n/**\n* @typedef {PlainObject} ReturnObject\n* @property {string} path\n* @property {JSONObject} value\n* @property {PlainObject|GenericArray} parent\n* @property {string} parentProperty\n*/\n\n/**\n* @callback JSONPathCallback\n* @param {string|PlainObject} preferredOutput\n* @param {\"value\"|\"property\"} type\n* @param {ReturnObject} fullRetObj\n* @returns {void}\n*/\n\n/**\n* @callback OtherTypeCallback\n* @param {JSONObject} val\n* @param {string} path\n* @param {PlainObject|GenericArray} parent\n* @param {string} parentPropName\n* @returns {boolean}\n*/\n\n/* eslint-disable max-len -- Can make multiline type after https://github.com/syavorsky/comment-parser/issues/109 */\n\n/**\n * @typedef {PlainObject} JSONPathOptions\n * @property {JSON} json\n * @property {string|string[]} path\n * @property {\"value\"|\"path\"|\"pointer\"|\"parent\"|\"parentProperty\"|\"all\"} [resultType=\"value\"]\n * @property {boolean} [flatten=false]\n * @property {boolean} [wrap=true]\n * @property {PlainObject} [sandbox={}]\n * @property {boolean} [preventEval=false]\n * @property {PlainObject|GenericArray|null} [parent=null]\n * @property {string|null} [parentProperty=null]\n * @property {JSONPathCallback} [callback]\n * @property {OtherTypeCallback} [otherTypeCallback] Defaults to\n *   function which throws on encountering `@other`\n * @property {boolean} [autostart=true]\n */\n\n/* eslint-enable max-len -- Can make multiline type after https://github.com/syavorsky/comment-parser/issues/109 */\n\n/**\n * @param {string|JSONPathOptions} opts If a string, will be treated as `expr`\n * @param {string} [expr] JSON path to evaluate\n * @param {JSON} [obj] JSON object to evaluate against\n * @param {JSONPathCallback} [callback] Passed 3 arguments: 1) desired payload\n *     per `resultType`, 2) `\"value\"|\"property\"`, 3) Full returned object with\n *     all payloads\n * @param {OtherTypeCallback} [otherTypeCallback] If `@other()` is at the end\n *   of one's query, this will be invoked with the value of the item, its\n *   path, its parent, and its parent's property name, and it should return\n *   a boolean indicating whether the supplied value belongs to the \"other\"\n *   type or not (or it may handle transformations and return `false`).\n * @returns {JSONPath}\n * @class\n */\n\n\nfunction JSONPath(opts, expr, obj, callback, otherTypeCallback) {\n  // eslint-disable-next-line no-restricted-syntax\n  if (!(this instanceof JSONPath)) {\n    try {\n      return new JSONPath(opts, expr, obj, callback, otherTypeCallback);\n    } catch (e) {\n      if (!e.avoidNew) {\n        throw e;\n      }\n\n      return e.value;\n    }\n  }\n\n  if (typeof opts === 'string') {\n    otherTypeCallback = callback;\n    callback = obj;\n    obj = expr;\n    expr = opts;\n    opts = null;\n  }\n\n  var optObj = opts && _typeof(opts) === 'object';\n  opts = opts || {};\n  this.json = opts.json || obj;\n  this.path = opts.path || expr;\n  this.resultType = opts.resultType || 'value';\n  this.flatten = opts.flatten || false;\n  this.wrap = hasOwnProp.call(opts, 'wrap') ? opts.wrap : true;\n  this.sandbox = opts.sandbox || {};\n  this.preventEval = opts.preventEval || false;\n  this.parent = opts.parent || null;\n  this.parentProperty = opts.parentProperty || null;\n  this.callback = opts.callback || callback || null;\n\n  this.otherTypeCallback = opts.otherTypeCallback || otherTypeCallback || function () {\n    throw new TypeError('You must supply an otherTypeCallback callback option ' + 'with the @other() operator.');\n  };\n\n  if (opts.autostart !== false) {\n    var args = {\n      path: optObj ? opts.path : expr\n    };\n\n    if (!optObj) {\n      args.json = obj;\n    } else if ('json' in opts) {\n      args.json = opts.json;\n    }\n\n    var ret = this.evaluate(args);\n\n    if (!ret || _typeof(ret) !== 'object') {\n      throw new NewError(ret);\n    }\n\n    return ret;\n  }\n} // PUBLIC METHODS\n\n\nJSONPath.prototype.evaluate = function (expr, json, callback, otherTypeCallback) {\n  var _this2 = this;\n\n  var currParent = this.parent,\n      currParentProperty = this.parentProperty;\n  var flatten = this.flatten,\n      wrap = this.wrap;\n  this.currResultType = this.resultType;\n  this.currPreventEval = this.preventEval;\n  this.currSandbox = this.sandbox;\n  callback = callback || this.callback;\n  this.currOtherTypeCallback = otherTypeCallback || this.otherTypeCallback;\n  json = json || this.json;\n  expr = expr || this.path;\n\n  if (expr && _typeof(expr) === 'object' && !Array.isArray(expr)) {\n    if (!expr.path && expr.path !== '') {\n      throw new TypeError('You must supply a \"path\" property when providing an object ' + 'argument to JSONPath.evaluate().');\n    }\n\n    if (!hasOwnProp.call(expr, 'json')) {\n      throw new TypeError('You must supply a \"json\" property when providing an object ' + 'argument to JSONPath.evaluate().');\n    }\n\n    var _expr = expr;\n    json = _expr.json;\n    flatten = hasOwnProp.call(expr, 'flatten') ? expr.flatten : flatten;\n    this.currResultType = hasOwnProp.call(expr, 'resultType') ? expr.resultType : this.currResultType;\n    this.currSandbox = hasOwnProp.call(expr, 'sandbox') ? expr.sandbox : this.currSandbox;\n    wrap = hasOwnProp.call(expr, 'wrap') ? expr.wrap : wrap;\n    this.currPreventEval = hasOwnProp.call(expr, 'preventEval') ? expr.preventEval : this.currPreventEval;\n    callback = hasOwnProp.call(expr, 'callback') ? expr.callback : callback;\n    this.currOtherTypeCallback = hasOwnProp.call(expr, 'otherTypeCallback') ? expr.otherTypeCallback : this.currOtherTypeCallback;\n    currParent = hasOwnProp.call(expr, 'parent') ? expr.parent : currParent;\n    currParentProperty = hasOwnProp.call(expr, 'parentProperty') ? expr.parentProperty : currParentProperty;\n    expr = expr.path;\n  }\n\n  currParent = currParent || null;\n  currParentProperty = currParentProperty || null;\n\n  if (Array.isArray(expr)) {\n    expr = JSONPath.toPathString(expr);\n  }\n\n  if (!expr && expr !== '' || !json) {\n    return undefined;\n  }\n\n  var exprList = JSONPath.toPathArray(expr);\n\n  if (exprList[0] === '$' && exprList.length > 1) {\n    exprList.shift();\n  }\n\n  this._hasParentSelector = null;\n\n  var result = this._trace(exprList, json, ['$'], currParent, currParentProperty, callback).filter(function (ea) {\n    return ea && !ea.isParentSelector;\n  });\n\n  if (!result.length) {\n    return wrap ? [] : undefined;\n  }\n\n  if (!wrap && result.length === 1 && !result[0].hasArrExpr) {\n    return this._getPreferredOutput(result[0]);\n  }\n\n  return result.reduce(function (rslt, ea) {\n    var valOrPath = _this2._getPreferredOutput(ea);\n\n    if (flatten && Array.isArray(valOrPath)) {\n      rslt = rslt.concat(valOrPath);\n    } else {\n      rslt.push(valOrPath);\n    }\n\n    return rslt;\n  }, []);\n}; // PRIVATE METHODS\n\n\nJSONPath.prototype._getPreferredOutput = function (ea) {\n  var resultType = this.currResultType;\n\n  switch (resultType) {\n    case 'all':\n      {\n        var path = Array.isArray(ea.path) ? ea.path : JSONPath.toPathArray(ea.path);\n        ea.pointer = JSONPath.toPointer(path);\n        ea.path = typeof ea.path === 'string' ? ea.path : JSONPath.toPathString(ea.path);\n        return ea;\n      }\n\n    case 'value':\n    case 'parent':\n    case 'parentProperty':\n      return ea[resultType];\n\n    case 'path':\n      return JSONPath.toPathString(ea[resultType]);\n\n    case 'pointer':\n      return JSONPath.toPointer(ea.path);\n\n    default:\n      throw new TypeError('Unknown result type');\n  }\n};\n\nJSONPath.prototype._handleCallback = function (fullRetObj, callback, type) {\n  if (callback) {\n    var preferredOutput = this._getPreferredOutput(fullRetObj);\n\n    fullRetObj.path = typeof fullRetObj.path === 'string' ? fullRetObj.path : JSONPath.toPathString(fullRetObj.path); // eslint-disable-next-line node/callback-return\n\n    callback(preferredOutput, type, fullRetObj);\n  }\n};\n/**\n *\n * @param {string} expr\n * @param {JSONObject} val\n * @param {string} path\n * @param {PlainObject|GenericArray} parent\n * @param {string} parentPropName\n * @param {JSONPathCallback} callback\n * @param {boolean} hasArrExpr\n * @param {boolean} literalPriority\n * @returns {ReturnObject|ReturnObject[]}\n */\n\n\nJSONPath.prototype._trace = function (expr, val, path, parent, parentPropName, callback, hasArrExpr, literalPriority) {\n  var _this3 = this;\n\n  // No expr to follow? return path and value as the result of\n  //  this trace branch\n  var retObj;\n\n  if (!expr.length) {\n    retObj = {\n      path: path,\n      value: val,\n      parent: parent,\n      parentProperty: parentPropName,\n      hasArrExpr: hasArrExpr\n    };\n\n    this._handleCallback(retObj, callback, 'value');\n\n    return retObj;\n  }\n\n  var loc = expr[0],\n      x = expr.slice(1); // We need to gather the return value of recursive trace calls in order to\n  // do the parent sel computation.\n\n  var ret = [];\n  /**\n   *\n   * @param {ReturnObject|ReturnObject[]} elems\n   * @returns {void}\n   */\n\n  function addRet(elems) {\n    if (Array.isArray(elems)) {\n      // This was causing excessive stack size in Node (with or\n      //  without Babel) against our performance test:\n      //  `ret.push(...elems);`\n      elems.forEach(function (t) {\n        ret.push(t);\n      });\n    } else {\n      ret.push(elems);\n    }\n  }\n\n  if ((typeof loc !== 'string' || literalPriority) && val && hasOwnProp.call(val, loc)) {\n    // simple case--directly follow property\n    addRet(this._trace(x, val[loc], push(path, loc), val, loc, callback, hasArrExpr)); // eslint-disable-next-line unicorn/prefer-switch -- Part of larger `if`\n  } else if (loc === '*') {\n    // all child properties\n    this._walk(loc, x, val, path, parent, parentPropName, callback, function (m, l, _x, v, p, par, pr, cb) {\n      addRet(_this3._trace(unshift(m, _x), v, p, par, pr, cb, true, true));\n    });\n  } else if (loc === '..') {\n    // all descendent parent properties\n    // Check remaining expression with val's immediate children\n    addRet(this._trace(x, val, path, parent, parentPropName, callback, hasArrExpr));\n\n    this._walk(loc, x, val, path, parent, parentPropName, callback, function (m, l, _x, v, p, par, pr, cb) {\n      // We don't join m and x here because we only want parents,\n      //   not scalar values\n      if (_typeof(v[m]) === 'object') {\n        // Keep going with recursive descent on val's\n        //   object children\n        addRet(_this3._trace(unshift(l, _x), v[m], push(p, m), v, m, cb, true));\n      }\n    }); // The parent sel computation is handled in the frame above using the\n    // ancestor object of val\n\n  } else if (loc === '^') {\n    // This is not a final endpoint, so we do not invoke the callback here\n    this._hasParentSelector = true;\n    return {\n      path: path.slice(0, -1),\n      expr: x,\n      isParentSelector: true\n    };\n  } else if (loc === '~') {\n    // property name\n    retObj = {\n      path: push(path, loc),\n      value: parentPropName,\n      parent: parent,\n      parentProperty: null\n    };\n\n    this._handleCallback(retObj, callback, 'property');\n\n    return retObj;\n  } else if (loc === '$') {\n    // root only\n    addRet(this._trace(x, val, path, null, null, callback, hasArrExpr));\n  } else if (/^(\\x2D?[0-9]*):(\\x2D?[0-9]*):?([0-9]*)$/.test(loc)) {\n    // [start:end:step]  Python slice syntax\n    addRet(this._slice(loc, x, val, path, parent, parentPropName, callback));\n  } else if (loc.indexOf('?(') === 0) {\n    // [?(expr)] (filtering)\n    if (this.currPreventEval) {\n      throw new Error('Eval [?(expr)] prevented in JSONPath expression.');\n    }\n\n    this._walk(loc, x, val, path, parent, parentPropName, callback, function (m, l, _x, v, p, par, pr, cb) {\n      if (_this3._eval(l.replace(/^\\?\\(((?:[\\0-\\t\\x0B\\f\\x0E-\\u2027\\u202A-\\uD7FF\\uE000-\\uFFFF]|[\\uD800-\\uDBFF][\\uDC00-\\uDFFF]|[\\uD800-\\uDBFF](?![\\uDC00-\\uDFFF])|(?:[^\\uD800-\\uDBFF]|^)[\\uDC00-\\uDFFF])*?)\\)$/, '$1'), v[m], m, p, par, pr)) {\n        addRet(_this3._trace(unshift(m, _x), v, p, par, pr, cb, true));\n      }\n    });\n  } else if (loc[0] === '(') {\n    // [(expr)] (dynamic property/index)\n    if (this.currPreventEval) {\n      throw new Error('Eval [(expr)] prevented in JSONPath expression.');\n    } // As this will resolve to a property name (but we don't know it\n    //  yet), property and parent information is relative to the\n    //  parent of the property to which this expression will resolve\n\n\n    addRet(this._trace(unshift(this._eval(loc, val, path[path.length - 1], path.slice(0, -1), parent, parentPropName), x), val, path, parent, parentPropName, callback, hasArrExpr));\n  } else if (loc[0] === '@') {\n    // value type: @boolean(), etc.\n    var addType = false;\n    var valueType = loc.slice(1, -2);\n\n    switch (valueType) {\n      case 'scalar':\n        if (!val || !['object', 'function'].includes(_typeof(val))) {\n          addType = true;\n        }\n\n        break;\n\n      case 'boolean':\n      case 'string':\n      case 'undefined':\n      case 'function':\n        // eslint-disable-next-line valid-typeof\n        if (_typeof(val) === valueType) {\n          addType = true;\n        }\n\n        break;\n\n      case 'integer':\n        if (Number.isFinite(val) && !(val % 1)) {\n          addType = true;\n        }\n\n        break;\n\n      case 'number':\n        if (Number.isFinite(val)) {\n          addType = true;\n        }\n\n        break;\n\n      case 'nonFinite':\n        if (typeof val === 'number' && !Number.isFinite(val)) {\n          addType = true;\n        }\n\n        break;\n\n      case 'object':\n        // eslint-disable-next-line valid-typeof\n        if (val && _typeof(val) === valueType) {\n          addType = true;\n        }\n\n        break;\n\n      case 'array':\n        if (Array.isArray(val)) {\n          addType = true;\n        }\n\n        break;\n\n      case 'other':\n        addType = this.currOtherTypeCallback(val, path, parent, parentPropName);\n        break;\n\n      case 'null':\n        if (val === null) {\n          addType = true;\n        }\n\n        break;\n\n      /* c8 ignore next 2 */\n\n      default:\n        throw new TypeError('Unknown value type ' + valueType);\n    }\n\n    if (addType) {\n      retObj = {\n        path: path,\n        value: val,\n        parent: parent,\n        parentProperty: parentPropName\n      };\n\n      this._handleCallback(retObj, callback, 'value');\n\n      return retObj;\n    } // `-escaped property\n\n  } else if (loc[0] === '`' && val && hasOwnProp.call(val, loc.slice(1))) {\n    var locProp = loc.slice(1);\n    addRet(this._trace(x, val[locProp], push(path, locProp), val, locProp, callback, hasArrExpr, true));\n  } else if (loc.includes(',')) {\n    // [name1,name2,...]\n    var parts = loc.split(',');\n\n    var _iterator = _createForOfIteratorHelper(parts),\n        _step;\n\n    try {\n      for (_iterator.s(); !(_step = _iterator.n()).done;) {\n        var part = _step.value;\n        addRet(this._trace(unshift(part, x), val, path, parent, parentPropName, callback, true));\n      } // simple case--directly follow property\n\n    } catch (err) {\n      _iterator.e(err);\n    } finally {\n      _iterator.f();\n    }\n  } else if (!literalPriority && val && hasOwnProp.call(val, loc)) {\n    addRet(this._trace(x, val[loc], push(path, loc), val, loc, callback, hasArrExpr, true));\n  } // We check the resulting values for parent selections. For parent\n  // selections we discard the value object and continue the trace with the\n  // current val object\n\n\n  if (this._hasParentSelector) {\n    for (var t = 0; t < ret.length; t++) {\n      var rett = ret[t];\n\n      if (rett && rett.isParentSelector) {\n        var tmp = this._trace(rett.expr, val, rett.path, parent, parentPropName, callback, hasArrExpr);\n\n        if (Array.isArray(tmp)) {\n          ret[t] = tmp[0];\n          var tl = tmp.length;\n\n          for (var tt = 1; tt < tl; tt++) {\n            t++;\n            ret.splice(t, 0, tmp[tt]);\n          }\n        } else {\n          ret[t] = tmp;\n        }\n      }\n    }\n  }\n\n  return ret;\n};\n\nJSONPath.prototype._walk = function (loc, expr, val, path, parent, parentPropName, callback, f) {\n  if (Array.isArray(val)) {\n    var n = val.length;\n\n    for (var i = 0; i < n; i++) {\n      f(i, loc, expr, val, path, parent, parentPropName, callback);\n    }\n  } else if (val && _typeof(val) === 'object') {\n    Object.keys(val).forEach(function (m) {\n      f(m, loc, expr, val, path, parent, parentPropName, callback);\n    });\n  }\n};\n\nJSONPath.prototype._slice = function (loc, expr, val, path, parent, parentPropName, callback) {\n  if (!Array.isArray(val)) {\n    return undefined;\n  }\n\n  var len = val.length,\n      parts = loc.split(':'),\n      step = parts[2] && Number.parseInt(parts[2]) || 1;\n  var start = parts[0] && Number.parseInt(parts[0]) || 0,\n      end = parts[1] && Number.parseInt(parts[1]) || len;\n  start = start < 0 ? Math.max(0, start + len) : Math.min(len, start);\n  end = end < 0 ? Math.max(0, end + len) : Math.min(len, end);\n  var ret = [];\n\n  for (var i = start; i < end; i += step) {\n    var tmp = this._trace(unshift(i, expr), val, path, parent, parentPropName, callback, true); // Should only be possible to be an array here since first part of\n    //   ``unshift(i, expr)` passed in above would not be empty, nor `~`,\n    //     nor begin with `@` (as could return objects)\n    // This was causing excessive stack size in Node (with or\n    //  without Babel) against our performance test: `ret.push(...tmp);`\n\n\n    tmp.forEach(function (t) {\n      ret.push(t);\n    });\n  }\n\n  return ret;\n};\n\nJSONPath.prototype._eval = function (code, _v, _vname, path, parent, parentPropName) {\n  if (code.includes('@parentProperty')) {\n    this.currSandbox._$_parentProperty = parentPropName;\n    code = code.replace(/@parentProperty/g, '_$_parentProperty');\n  }\n\n  if (code.includes('@parent')) {\n    this.currSandbox._$_parent = parent;\n    code = code.replace(/@parent/g, '_$_parent');\n  }\n\n  if (code.includes('@property')) {\n    this.currSandbox._$_property = _vname;\n    code = code.replace(/@property/g, '_$_property');\n  }\n\n  if (code.includes('@path')) {\n    this.currSandbox._$_path = JSONPath.toPathString(path.concat([_vname]));\n    code = code.replace(/@path/g, '_$_path');\n  }\n\n  if (code.includes('@root')) {\n    this.currSandbox._$_root = this.json;\n    code = code.replace(/@root/g, '_$_root');\n  }\n\n  if (/@([\\t-\\r \\)\\.\\[\\xA0\\u1680\\u2000-\\u200A\\u2028\\u2029\\u202F\\u205F\\u3000\\uFEFF])/.test(code)) {\n    this.currSandbox._$_v = _v;\n    code = code.replace(/@([\\t-\\r \\)\\.\\[\\xA0\\u1680\\u2000-\\u200A\\u2028\\u2029\\u202F\\u205F\\u3000\\uFEFF])/g, '_$_v$1');\n  }\n\n  try {\n    return this.vm.runInNewContext(code, this.currSandbox);\n  } catch (e) {\n    // eslint-disable-next-line no-console\n    console.log(e);\n    throw new Error('jsonPath: ' + e.message + ': ' + code);\n  }\n}; // PUBLIC CLASS PROPERTIES AND METHODS\n// Could store the cache object itself\n\n\nJSONPath.cache = {};\n/**\n * @param {string[]} pathArr Array to convert\n * @returns {string} The path string\n */\n\nJSONPath.toPathString = function (pathArr) {\n  var x = pathArr,\n      n = x.length;\n  var p = '$';\n\n  for (var i = 1; i < n; i++) {\n    if (!/^(~|\\^|@(?:[\\0-\\t\\x0B\\f\\x0E-\\u2027\\u202A-\\uD7FF\\uE000-\\uFFFF]|[\\uD800-\\uDBFF][\\uDC00-\\uDFFF]|[\\uD800-\\uDBFF](?![\\uDC00-\\uDFFF])|(?:[^\\uD800-\\uDBFF]|^)[\\uDC00-\\uDFFF])*?\\(\\))$/.test(x[i])) {\n      p += /^[\\*0-9]+$/.test(x[i]) ? '[' + x[i] + ']' : \"['\" + x[i] + \"']\";\n    }\n  }\n\n  return p;\n};\n/**\n * @param {string} pointer JSON Path\n * @returns {string} JSON Pointer\n */\n\n\nJSONPath.toPointer = function (pointer) {\n  var x = pointer,\n      n = x.length;\n  var p = '';\n\n  for (var i = 1; i < n; i++) {\n    if (!/^(~|\\^|@(?:[\\0-\\t\\x0B\\f\\x0E-\\u2027\\u202A-\\uD7FF\\uE000-\\uFFFF]|[\\uD800-\\uDBFF][\\uDC00-\\uDFFF]|[\\uD800-\\uDBFF](?![\\uDC00-\\uDFFF])|(?:[^\\uD800-\\uDBFF]|^)[\\uDC00-\\uDFFF])*?\\(\\))$/.test(x[i])) {\n      p += '/' + x[i].toString().replace(/~/g, '~0').replace(/\\//g, '~1');\n    }\n  }\n\n  return p;\n};\n/**\n * @param {string} expr Expression to convert\n * @returns {string[]}\n */\n\n\nJSONPath.toPathArray = function (expr) {\n  var cache = JSONPath.cache;\n\n  if (cache[expr]) {\n    return cache[expr].concat();\n  }\n\n  var subx = [];\n  var normalized = expr // Properties\n  .replace(/@(?:null|boolean|number|string|integer|undefined|nonFinite|scalar|array|object|function|other)\\(\\)/g, ';$&;') // Parenthetical evaluations (filtering and otherwise), directly\n  //   within brackets or single quotes\n  .replace(/['\\[](\\??\\((?:[\\0-\\t\\x0B\\f\\x0E-\\u2027\\u202A-\\uD7FF\\uE000-\\uFFFF]|[\\uD800-\\uDBFF][\\uDC00-\\uDFFF]|[\\uD800-\\uDBFF](?![\\uDC00-\\uDFFF])|(?:[^\\uD800-\\uDBFF]|^)[\\uDC00-\\uDFFF])*?\\))['\\]]/g, function ($0, $1) {\n    return '[#' + (subx.push($1) - 1) + ']';\n  }) // Escape periods and tildes within properties\n  .replace(/\\[[\"']((?:(?!['\\]])[\\s\\S])*)[\"']\\]/g, function ($0, prop) {\n    return \"['\" + prop.replace(/\\./g, '%@%').replace(/~/g, '%%@@%%') + \"']\";\n  }) // Properties operator\n  .replace(/~/g, ';~;') // Split by property boundaries\n  .replace(/[\"']?\\.[\"']?(?!(?:(?!\\[)[\\s\\S])*\\])|\\[[\"']?/g, ';') // Reinsert periods within properties\n  .replace(/%@%/g, '.') // Reinsert tildes within properties\n  .replace(/%%@@%%/g, '~') // Parent\n  .replace(/(?:;)?(\\^+)(?:;)?/g, function ($0, ups) {\n    return ';' + ups.split('').join(';') + ';';\n  }) // Descendents\n  .replace(/;;;|;;/g, ';..;') // Remove trailing\n  .replace(/;$|'?\\]|'$/g, '');\n  var exprList = normalized.split(';').map(function (exp) {\n    var match = exp.match(/#([0-9]+)/);\n    return !match || !match[1] ? exp : subx[match[1]];\n  });\n  cache[expr] = exprList;\n  return cache[expr].concat();\n};\n\n/**\n* @callback ConditionCallback\n* @param {any} item\n* @returns {boolean}\n*/\n\n/**\n * Copy items out of one array into another.\n * @param {GenericArray} source Array with items to copy\n * @param {GenericArray} target Array to which to copy\n * @param {ConditionCallback} conditionCb Callback passed the current item;\n *     will move item if evaluates to `true`\n * @returns {void}\n */\n\nvar moveToAnotherArray = function moveToAnotherArray(source, target, conditionCb) {\n  var il = source.length;\n\n  for (var i = 0; i < il; i++) {\n    var item = source[i];\n\n    if (conditionCb(item)) {\n      target.push(source.splice(i--, 1)[0]);\n    }\n  }\n};\n\nJSONPath.prototype.vm = {\n  /**\n   * @param {string} expr Expression to evaluate\n   * @param {PlainObject} context Object whose items will be added\n   *   to evaluation\n   * @returns {any} Result of evaluated code\n   */\n  runInNewContext: function runInNewContext(expr, context) {\n    var keys = Object.keys(context);\n    var funcs = [];\n    moveToAnotherArray(keys, funcs, function (key) {\n      return typeof context[key] === 'function';\n    });\n    var values = keys.map(function (vr, i) {\n      return context[vr];\n    });\n    var funcString = funcs.reduce(function (s, func) {\n      var fString = context[func].toString();\n\n      if (!/function/.test(fString)) {\n        fString = 'function ' + fString;\n      }\n\n      return 'var ' + func + '=' + fString + ';' + s;\n    }, '');\n    expr = funcString + expr; // Mitigate http://perfectionkills.com/global-eval-what-are-the-options/#new_function\n\n    if (!/([\"'])use strict\\1/.test(expr) && !keys.includes('arguments')) {\n      expr = 'var arguments = undefined;' + expr;\n    } // Remove last semi so `return` will be inserted before\n    //  the previous one instead, allowing for the return\n    //  of a bare ending expression\n\n\n    expr = expr.replace(/;[\\t-\\r \\xA0\\u1680\\u2000-\\u200A\\u2028\\u2029\\u202F\\u205F\\u3000\\uFEFF]*$/, ''); // Insert `return`\n\n    var lastStatementEnd = expr.lastIndexOf(';');\n    var code = lastStatementEnd > -1 ? expr.slice(0, lastStatementEnd + 1) + ' return ' + expr.slice(lastStatementEnd + 1) : ' return ' + expr; // eslint-disable-next-line no-new-func\n\n    return _construct(Function, _toConsumableArray(keys).concat([code])).apply(void 0, _toConsumableArray(values));\n  }\n};\n\nexport { JSONPath };\n","// The module cache\nvar __webpack_module_cache__ = {};\n\n// The require function\nfunction __webpack_require__(moduleId) {\n\t// Check if module is in cache\n\tvar cachedModule = __webpack_module_cache__[moduleId];\n\tif (cachedModule !== undefined) {\n\t\treturn cachedModule.exports;\n\t}\n\t// Create a new module (and put it into the cache)\n\tvar module = __webpack_module_cache__[moduleId] = {\n\t\t// no module.id needed\n\t\t// no module.loaded needed\n\t\texports: {}\n\t};\n\n\t// Execute the module function\n\t__webpack_modules__[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n\t// Return the exports of the module\n\treturn module.exports;\n}\n\n","// define getter functions for harmony exports\n__webpack_require__.d = function(exports, definition) {\n\tfor(var key in definition) {\n\t\tif(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {\n\t\t\tObject.defineProperty(exports, key, { enumerable: true, get: definition[key] });\n\t\t}\n\t}\n};","__webpack_require__.g = (function() {\n\tif (typeof globalThis === 'object') return globalThis;\n\ttry {\n\t\treturn this || new Function('return this')();\n\t} catch (e) {\n\t\tif (typeof window === 'object') return window;\n\t}\n})();","__webpack_require__.o = function(obj, prop) { return Object.prototype.hasOwnProperty.call(obj, prop); }","// define __esModule on exports\n__webpack_require__.r = function(exports) {\n\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n\t}\n\tObject.defineProperty(exports, '__esModule', { value: true });\n};","// startup\n// Load entry module and return exports\n// This entry module is referenced by other modules so it can't be inlined\nvar __webpack_exports__ = __webpack_require__(8193);\n"],"names":["AuthnTransactionImpl","sdk","tx","res","this","data","undefined","status","Object","assign","flattenEmbedded","stateToken","_links","cancel","Promise","resolve","createTransaction","args","getSavedStateToken","reject","AuthSdkError","transactionStep","then","url","options","withCredentials","post","transactionStatus","addStateToken","getIssuerOrigin","storageUtil","storage","get","STATE_TOKEN_KEY_NAME","bind","resume","resumeTransaction","exists","transactionExists","introspect","introspectAuthn","postToTransaction","Base","authn","createAuthnTransactionAPI","fingerprint","opts","clone","_postToTransaction","sendFingerprint","headers","signIn","obj","ref","Array","isArray","objArr","o","ol","length","push","embedded","_embedded","key","prototype","hasOwnProperty","call","isObject","fns","links2fns","omit","link2fn","link","name","lk","find","hints","allow","href","isPolling","factorType","provider","params","autoPush","e","rememberDevice","profile","updatePhone","toQueryString","linkName","type","poll","getPollFn","fn","delay","transactionCallBack","isNumber","DEFAULT_POLLING_DELAY","pollLink","getLink","retryCount","recursivePoll","getStateToken","saveAuthnState","pollFn","pollRes","factorResult","AuthPollStopError","delayFn","catch","err","xhr","delayLength","Math","pow","builtArgs","OptionsConstructor","OktaAuthBase","removeNils","emitter","Emitter","features","constants","devMode","browserHasLocalStorage","getLocalStorage","testStorage","browserHasSessionStorage","getSessionStorage","testStorageType","storageType","supported","getStorageByType","storageProvider","getCookieStorage","getInMemoryStorage","findStorageType","types","curType","nextType","slice","shift","warn","isIE11OrLess","window","onstorage","localStorage","sessionStorage","secure","sameSite","sessionCookie","getItem","setItem","value","expiresAt","set","removeItem","delete","useSeparateCookies","keys","forEach","k","indexOf","replace","JSON","parse","stringify","existingValues","storageKey","valueToStore","inMemoryStore","cookieOptions","path","Date","expires","Cookies","arguments","remove","isFingerprintSupported","timeout","iframe","listener","container","document","body","createElement","style","display","isMessageFromCorrectSource","origin","msg","contentWindow","postMessage","addListener","src","appendChild","setTimeout","finally","clearTimeout","removeListener","contains","parentElement","removeChild","event","source","SdkClock","localOffset","parseInt","now","DEFAULT_PENDING","updateAuthStatePromise","canceledTimes","EVENT_AUTH_STATE_CHANGE","AuthStateManager","_sdk","_pending","_authState","_logOptions","_prevAuthState","_transformQueue","PromiseQueue","quiet","tokenManager","on","EVENT_ADDED","token","_setLogOptions","updateAuthState","EVENT_REMOVED","transformAuthState","log","getConsole","group","groupEnd","emitAuthStateChange","authState","prevState","state","isAuthenticated","idToken","accessToken","error","emit","finalPromise","origPromise","curPromise","getAuthState","cancelablePromise","PCancelable","_","onCancel","shouldReject","emitAndResolve","isCanceled","getTokensSync","refreshToken","handler","off","AUTO_RENEW","SYNC_STORAGE","LEADER_ELECTION","RENEW_ON_TAB_ACTIVATION","ServiceManager","onLeader","getOptions","autoRenew","autoRemove","syncStorage","electionChannelName","broadcastChannelName","defaultOptions","clientId","syncChannelName","started","services","Map","knownServices","svc","createService","startServices","getService","isLeader","values","some","srv","canStart","requiresLeadership","stopServices","entries","canStartService","start","stop","isStarted","isLeaderRequired","service","LeaderElectionService","AutoRenewService","SyncStorageService","RenewOnTabActivationService","Error","renewOnTabActivation","tabInactivityDuration","StorageManagerConstructor","TransactionManagerConstructor","createOktaAuthBase","WithStorage","mixinStorage","WithHttp","mixinHttp","WithSession","mixinSession","WithOAuth","mixinOAuth","mixinCore","authStateManager","serviceManager","isLoginRedirect","originalUri","handleLoginRedirect","tokens","setTokens","getOriginalUri","parseOAuthResponseFromUrl","oAuthResponse","storeTokensFromRedirect","removeOriginalUri","restoreOriginalUri","location","createOAuthOptionsConstructor","createOAuthStorageManager","b64u","Uint8Array","from","base64UrlDecode","c","charCodeAt","b64","base64UrlToBase64","utf8","atob","decodeURIComponent","escape","bin","btoa","reduce","s","byte","String","fromCharCode","str","base64ToBase64Url","buffer","i","crypto","TextEncoder","encode","webcrypto","subtle","digest","arrayBuffer","firstHalf","hash","apply","stringToBase64Url","algo","use","importKey","cryptoKey","jwt","split","payload","stringToBuffer","b64Signature","signature","verify","AuthApiError","meta","message","errorSummary","errorCode","errorLink","errorId","errorCauses","CustomError","setPrototypeOf","OAuthError","summary","resp","error_description","WWWAuthError","scheme","parameters","UNKNOWN_ERROR","errorDescription","realm","header","match","regex","firstSpace","remaining","exec","isFunction","OktaAuth","createIdxOptionsConstructor","StorageManager","createIdxStorageManager","TransactionManager","createIdxTransactionManager","WithIdx","createOktaAuthIdx","WithMyAccount","mixinMyAccount","mixinAuthn","indexedDB","hasTextEncoder","isWebCryptoSubtleSupported","agent","getUserAgent","isWindowsPhone","test","isBrowser","protocol","hostname","isTokenVerifySupported","documentMode","isIE8or9","navigator","userAgent","appJsonContentTypeRegex","method","contentType","map","param","encodeURIComponent","join","fetchPromise","global","fetch","crossFetch","credentials","response","ok","toLowerCase","json","text","readData","pair","result","responseText","responseType","responseJSON","formatResult","OktaUserAgent","environments","SDK_VERSION","maybeAddNodeEnvironment","env","process","versions","version","node","authClient","headerName","headerValue","_oktaUserAgent","http","setRequestHeader","issuer","transformErrorXHR","httpRequestClient","fetchRequest","httpRequestInterceptors","createStorageOptionsConstructor","isAbsoluteUrl","httpRequest","postOptions","formatError","serverErr","isString","wwwAuthHeader","getWWWAuthenticateHeader","wwwAuthErr","parseHeader","max_age","acr_values","interceptor","httpCache","storageManager","getHttpCache","cookies","cacheResponse","cachedResponse","getStorage","getHttpHeader","ajaxOptions","item","updateStorage","floor","DEFAULT_CACHE_DURATION","clearIdxResponse","saveLastResponse","getIdxResponseStorage","setStorage","storedValue","isRawIdxResponse","rawIdxResponse","stateHandle","interactionHandle","useGenericRemediator","clearStorage","createTransactionManager","password","authenticator","AuthenticatorKey","OKTA_PASSWORD","run","flow","Authenticator","OktaPassword","passcode","revokeSessions","idxRemediationValue","inputs","form","required","input","label","OktaVerifyTotp","verificationCode","totp","VerificationCodeAuthenticator","SecurityQuestionEnrollment","questionKey","answer","question","SecurityQuestionVerification","contextualData","enrolledQuestion","otp","WebauthnEnrollment","clientData","attestation","visible","WebauthnVerification","authenticatorData","signatureData","remediation","relatesTo","SECURITY_QUESTION","OKTA_VERIFY","WEBAUTHN","challengeData","auth1","auth2","id","authenticators","option","incoming","isAuthenticator","transactionManager","load","flowSpec","getFlowSpecification","actions","EmailVerifyCallbackError","isEmailVerifyCallback","urlPath","parseEmailVerifyCallback","urlParamsToObject","search","idx","canProceed","proceed","mixinMinimalOAuth","mixinMinimalIdx","Core","createOktaAuthCore","mixinIdx","setRemediatorsCtx","remediators","boundStartTransaction","startTransaction","interact","makeIdxResponse","makeIdxState","authenticate","register","recoverPassword","handleInteractionCodeRedirect","isInteractionRequired","isInteractionRequiredError","handleEmailVerifyCallback","isEmailVerifyCallbackError","getSavedTransactionMeta","createTransactionMeta","getTransactionMeta","saveTransactionMeta","clearTransactionMeta","isTransactionMetaValid","setFlow","getFlow","unlockAccount","minimalSdk","AccountUnlockFlow","Identify","SelectAuthenticatorUnlockAccount","SelectAuthenticatorAuthenticate","ChallengeAuthenticator","ChallengePoll","AuthenticatorVerificationData","ReEnrollAuthenticatorWarning","AuthenticationFlow","SelectAuthenticatorEnroll","AuthenticatorEnrollmentData","EnrollAuthenticator","ReEnrollAuthenticator","EnrollPoll","SelectEnrollmentChannel","EnrollmentChannelData","RedirectIdp","Skip","oktaAuth","RegistrationFlow","PasswordRecoveryFlow","ResetAuthenticator","SelectEnrollProfile","EnrollProfile","codeVerifier","savedState","URL","searchParams","interactionCode","exchangeCodeForTokens","toPersist","requestDidSucceed","IDX_API_VERSION","validateVersionConfig","parsersForVersion","v1","isFieldMutable","field","mutable","divideSingleActionParamsByMutability","action","defaultParamsForAction","neededParamsForAction","immutableParamsForAction","actionList","neededParams","defaultParams","immutableParams","generateDirectFetch","actionDefinition","target","accepts","idxResponse","stepUp","generator","divideActionParamsByMutability","SKIP_FIELDS","parseNonRemediations","context","filter","rel","generateIdxAction","fieldValue","info","subField","expandRelatesTo","query","jsonpath","innerValue","remediationData","authenticatorChallenge","remediations","actionFn","generateRemediationFunctions","convertRemediationAction","parseIdxResponse","neededToProceed","remediationChoice","paramsFromUser","remediationChoiceObject","rawIdxState","successWithInteractionCode","remediationValue","getResponse","baseUrl","getOAuthBaseUrl","redirectUri","scopes","codeChallenge","codeChallengeMethod","activationToken","recoveryToken","maxAge","acrValues","nonce","clientSecret","client_id","scope","redirect_uri","code_challenge","code_challenge_method","activation_token","recovery_token","client_secret","interaction_handle","newMeta","savedIdxResponse","loadIdxResponse","domain","getOAuthDomain","Accept","isAuthApiError","createIdxAPI","webauthn","createMinimalIdxAPI","createCoreOptionsConstructor","startPolling","transaction","availablePollingRemeditaions","includes","Number","isInteger","refresh","nextStep","hasSavedInteractionHandle","autoRemediate","enabledFeatures","IdxFeature","REGISTRATION","getActionFromValues","resend","removeActionFromValues","removeActionFromOptions","actionName","entry","remediate","remediator","getRemediator","actionFromValues","actionFromOptions","valuesWithoutExecutedAction","optionsWithoutExecutedAction","handleFailedResponse","canceled","terminal","isTerminalResponse","step","filterValuesForRemediation","acc","curr","canRemediate","getNextStep","getName","getData","getValuesAfterProceed","gr","getAuthenticatorData","getAuthenticatorFromRemediation","methodType","phoneNumber","val","AuthenticatorData","valueKey","getAuthenticator","formatAuthenticatorData","authenticatorsData","compareAuthenticators","mapAuthenticatorDataFromValues","enrollmentId","Remediator","formatAuthenticators","formatAuthenticator","existing","getRequiredValues","hasData","getAllValues","titleCase","_authClient","_context","getInputs","inputFromRemediation","messages","alias","aliases","inputsFromRemediation","inputsFromRemediator","authenticatorFromRemediation","SelectAuthenticator","matchedOption","findMatchedOption","isCurrentAuthenticator","currentAuthenticator","isCurrentAuthenticatorEnrollment","currentAuthenticatorEnrollment","selectedAuthenticator","selectedOption","VerifyAuthenticator","authenticatorEnrollments","canVerify","mapCredentials","common","getCredentialsFromRemediation","userProfileFromValues","userProfile","attributeValues","attributeName","errorRemediation","errors","Boolean","email","GenericRemediator","endsWith","produces","rest","unwrapFormValue","requiredTracker","isRequired","optionSchema","formKeys","unwrappedForm","identifier","newPassword","idp","isRecoveryFlow","authenticatorMap","methodTypeOption","methodTypeValue","channel","filterKey","skip","idxRemediation","r","cur","charAt","toUpperCase","substring","initializeValues","initializeData","IdxStatus","PENDING","getDataFromIntrospect","clear","interactResponse","getDataFromRemediate","idxResponseFromRemediation","getTokens","ignoreSignature","urls","tokenResponse","finalizeData","shouldSaveResponse","shouldClearTransaction","clearSharedStorage","getEnabledFeatures","availableSteps","getAvailableSteps","getMessagesFromResponse","TERMINAL","hasActions","hasErrors","class","CANCELED","SUCCESS","saveIdxResponse","storageManagerOptions","transactionStorage","getTransactionStorage","SavedObject","IDX_RESPONSE_STORAGE_NAME","createCoreStorageManager","savedMeta","save","muteWarning","prepareTokenParams","tokenParams","pkceMeta","createOAuthMeta","validExistingMeta","isTransactionMetaValidForOptions","isTransactionMetaValidForFlow","ACCOUNT_UNLOCK","remediationName","remediatorMap","ctx","remediatorClass","T","getRemediatorClass","stepObj","startsWith","split2","part1","part2","actionObj","PASSWORD_RECOVERY","SOCIAL_IDP","newCtx","_oktaAuth","canSkipFn","canResendFn","getMessagesFromIdxRemediationValue","messagesFromForm","optionValues","messagesFromOptions","globalMessages","fieldMessages","seen","filtered","i18n","idxRemediations","remediatorCandidates","canSkip","canResend","getEnrolledCredentials","enrollement","base64UrlToBuffer","credentialId","activationData","publicKey","rp","user","displayName","challenge","pubKeyCredParams","authenticatorSelection","excludeCredentials","userVerification","allowCredentials","credential","bufferToBase64Url","clientDataJSON","attestationObject","getEmails","sendRequest","EmailTransaction","getEmail","addEmail","deleteEmail","sendEmailChallenge","EmailChallengeTransaction","getEmailChallenge","emailId","challengeId","verifyEmailChallenge","myaccount","MyAccountMethods","getPassword","PasswordTransaction","enrollPassword","updatePassword","deletePassword","getPhones","PhoneTransaction","getPhone","addPhone","deletePhone","sendPhoneChallenge","verifyPhoneChallenge","getProfile","ProfileTransaction","updateProfile","getProfileSchema","ProfileSchemaTransaction","methodName","links","TransactionClass","BaseTransaction","self","accessTokenObj","requestUrl","ret","generateRequestFnFromLinks","EmailStatusTransaction","roles","created","lastUpdated","PasswordStatus","NOT_ENROLLED","enroll","update","properties","createdAt","modifiedAt","EmailRole","Status","DEFAULT_OPTIONS","clearPendingRemoveTokens","expireEarlySeconds","TOKEN_STORAGE_NAME","TokenManager","isLocalhost","storageOptions","getTokenStorage","clock","create","expireTimeouts","renewPromise","setExpireEventTimeoutAll","clearExpireEventTimeoutAll","getExpireTime","EVENT_EXPIRED","freshToken","oldToken","EVENT_RENEWED","EVENT_ERROR","clearExpireEventTimeout","isRefreshToken","expireTime","expireEventWait","max","expireEventTimeout","emitExpired","tokenStorage","setExpireEventTimeout","validateToken","emitSetStorageEvent","emitAdded","getSync","isAccessToken","isIDToken","EVENT_SET_STORAGE","accessTokenCb","idTokenCb","refreshTokenCb","handleTokenCallback","getTokenType","handleAdded","handleRemoved","emitRemoved","existingTokens","getStorageKeyByType","newToken","existingToken","emitRenewed","removedToken","renew","shouldRenew","refreshKey","emitError","renewTokens","tokenKey","removedTokens","pendingRemove","REFRESH_TOKEN_STORAGE_KEY","enableSharedStorage","clearTransactionFromSharedStorage","isTransactionMeta","saveTransactionToSharedStorage","pruneSharedStorage","loadTransactionFromSharedStorage","decodedToken","base64UrlToString","isOAuthError","isWWWAuthError","INDEXEDDB_NAME","DB_KEY","createJwt","claims","signingKey","head","sign","algorithm","cryptoRandomValue","byteLen","getRandomValues","v","toString","generateKeyPair","modulusLength","publicExponent","generateKey","hashAccessToken","invokeStoreMethod","req","open","onerror","onupgradeneeded","createObjectStore","onsuccess","db","store","objectStore","oncomplete","close","storeKeyPair","pairId","keyPair","clearDPoPKeyPair","keyPairId","revokedToken","shouldClear","tokenType","dpopPairId","generateDPoPProof","exportKey","kty","crv","n","x","y","alg","typ","jwk","htm","htu","iat","jti","ath","privateKey","oauthQueryParams","convertTokenParamsToOAuthParams","extraParams","oauthParams","idpScope","loginHint","prompt","responseMode","sessionToken","enrollAmrValues","mayBeArray","validateOptions","authorizationCode","getPostData","code","makeTokenRequest","dpopKeyPair","dpop","generateDPoPForTokenRequest","proof","DPoP","isDPoPNonceError","dpopNonce","tokenUrl","grant_type","refresh_token","kid","getWellKnown","wellKnown","jwksUri","cachedKey","authServerUri","prepareEnrollAuthenticatorParams","createEnrollAuthenticatorMeta","authorizeUrl","buildAuthorizeParams","setLocation","getOAuthUrls","getDefaultTokenParams","getTokenOptions","handleResponseOptions","findKeyPair","createDPoPKeyPair","postToTokenEndpoint","oauthResponse","handleOAuthResponse","authorize","enrollAuthenticator","queue","useQueue","getWithRedirectFn","getWithRedirect","parseFromUrlFn","parseFromUrl","parseFromUrlApi","_getHistory","history","_getLocation","_getDocument","getWithoutPrompt","getWithPopup","decode","decodeToken","revoke","revokeToken","renewToken","renewTokensWithRefresh","getUserInfo","accessTokenObject","idTokenObject","verifyToken","oidcIntrospect","popupWindow","iframePromise","addPostMessageListener","iframeEl","loadFrame","oauthPromise","isPopupPostMessageSupported","closePoller","setInterval","closed","clearInterval","userinfoUrl","getDPoPAuthorizationHeaders","userInfo","sub","loadPopup","getToken","validateResponse","token_type","pkce","interaction_code","tokenDict","expiresIn","expires_in","access_token","id_token","accessJwt","idJwt","idTokenObj","exp","validationParams","hintMap","kind","TokenKind","ACCESS","iss","introspectUrl","introspection_endpoint","authHeader","token_type_hint","BaseClass","browserStorage","REFERRER_PATH_STORAGE_KEY","getOriginalUriStorage","sharedStorage","DEFAULT_CODE_CHALLENGE_METHOD","PKCE","generateVerifier","computeChallenge","handleLogin","_tokenQueue","createTokenAPI","endpoints","createEndpoints","onExpiredToken","shouldRemove","hasExpired","additionalParams","setOriginalUri","hasResponseType","accessTokenKey","clearDPoPKeyPairAfterRevoke","refreshTokenKey","postLogoutRedirectUri","logoutUrl","idTokenHint","logoutUri","defaultUri","currentUri","revokeAccessToken","revokeRefreshToken","getSignOutRedirectUrl","closeSession","sessionClosed","append","clearTokensBeforeRedirect","addPendingRemoveFlags","Authorization","Dpop","clearAllDPoPKeyPairs","wwwAuth","wwwErr","provideOriginalUri","createBaseTokenAPI","RegExp","assertValidConfig","removeTrailingSlash","revokeUrl","toAbsoluteUrl","ignoreLifetime","maxClockSkew","DEFAULT_MAX_CLOCK_SKEW","createHttpOptionsConstructor","getResponseMode","defaultResponseMode","paramStr","nativeLoc","cleanOAuthResponseFromUrl","nativeHistory","nativeDoc","replaceState","title","pathname","removeSearch","removeHash","throwInvalidTokenError","getSingleToken","originalToken","refreshTokenObject","renewTokenParams","endpointParams","postRefreshToken","isSameRefreshToken","updateRefreshToken","isRefreshTokenInvalidError","removeRefreshToken","creds","getOptionsForSection","logServerSideMemoryStorageWarning","TRANSACTION_STORAGE_NAME","SHARED_TRANSACTION_STORAGE_NAME","ORIGINAL_URI_STORAGE_NAME","BaseStorageManager","isPKCETransactionMeta","isOAuthTransactionMeta","isCustomAuthTransactionMeta","isObjectWithProperties","responseHandler","timeoutId","popupTitle","eventTarget","addEventListener","attachEvent","removeEventListener","detachEvent","defaultRedirectUri","generateState","generateNonce","errorResponse","hasTokensInHash","hasAuthorizationCode","hashOrSearch","hasInteractionCode","hasErrorInUrl","isRedirectUri","uri","authParams","isCodeFlow","getHashOrSearch","codeFlow","genRandomString","getIssuer","oauthMeta","dec2hex","dec","substr","prefix","a","verifier","MIN_VERIFIER_LENGTH","ceil","MAX_VERIFIER_LENGTH","prepareParams","getDefaultEnrollAuthenticatorParams","assertPKCESupport","isPKCESupported","errorMessage","isHTTPS","validateCodeChallengeMethod","preparePKCE","defaults","isDPoPSupported","b","getSharedTansactionStorage","dateCreated","MAX_ENTRY_LIFETIME","plus2space","paramSplit","fragment","aud","acr","configuredIssuer","validationOptions","validateClaims","getKey","sdkCrypto","at_hash","getOidcHash","renewTimeQueue","onTokenExpiredHandler","firstTime","shouldThrottleRenew","processExpiredTokens","onLeaderDuplicate","elector","hasLeader","BroadcastChannel","createLeaderElection","onduplicate","awaitLeadership","die","postInternal","getNow","onPageVisbilityChange","_onPageVisbilityChange","hidden","lastHidden","onTokenAddedHandler","onTokenRemovedHandler","onTokenRenewedHandler","onSetStorageHandler","onSyncMessageHandler","enablePostMessage","session","redirectUrl","checkAccountSetupComplete","sessionExists","getSession","refreshSession","setCookieAndRedirect","createSessionApi","sectionName","overrideOptions","storageTypes","CACHE_STORAGE_NAME","storageName","storageString","getCookieSettings","STORAGE_MANAGER_OPTIONS","createBaseOptionsConstructor","cookieSettings","cache","running","thisObject","queueItem","isPromise","getNativeConsole","console","nativeConsole","deprecate","JSONPath","preventEval","ms","random","randomCharset","parts","isoTime","UTC","toUTCString","delim","splice","additionalArgs","concat","obj1","prop","collection","found","altName","newobj","props","p","cleaned","trimmed","CancelError","reason","executor","_cancelHandlers","_isPending","_isCanceled","_rejectOnCancel","_promise","_reject","defineProperties","boolean","onFulfilled","onRejected","onFinally","userFn","arguments_","module","exports","defineProperty","OPEN_BROADCAST_CHANNELS","clearNodeFolder","_options","fillOptionsWithDefaults","_methodChooser","chooseMethod","_util","PROMISE_RESOLVED_FALSE","enforceOptions","ENFORCED_OPTIONS","Set","lastId","maybePromise","add","_iL","_onML","_addEL","internal","_uMP","_befC","_prepP","_state","_post","broadcastChannel","msgObj","time","microSeconds","PROMISE_RESOLVED_VOID","sendPromise","_hasMessageListeners","_addListenerObject","listenerFn","listenerObject","minMessageTime","onMessage","_startListening","_removeListenerObject","_stopListening","_pubkey","onmessage","listenObj","_this","awaitPrepare","all","isClosed","_index","beLeader","enumerable","_broadcastChannel","_leaderElectionUtil","_leaderElection","leaderElector","_hasLeader","unloadFn","_unload","_unl","isLeaderListener","sendLeaderMessage","_dpLC","_dpL","_lstns","msgJson","LeaderElectionWebLock","isDead","randomToken","_wKMC","lN","_this2","locks","relevantLocks","held","lock","_this3","_wLMP","AbortController","returnPromise","rej","request","signal","_fn","_this4","uFn","abort","_leaderElector","fallbackInterval","responseTime","averageResponseTime","supportsWebLockAPI","_leaderElectionWebLock","LeaderElection","_aplQ","_aplQC","hasLeaderListener","applyOnce","isFromFallbackInterval","sleep","PROMISE_RESOLVED_TRUE","stopCriteriaPromiseResolve","stopCriteria","stopCriteriaPromise","handleMessage","waitForAnswerTime","race","applyRun","_aLP","resolved","finish","whenDeathListener","tryOnFallBack","chooseMethods","methods","METHODS","_simulate","SimulateMethod","m","webWorkerSupport","useMethod","canBeUsed","_native","_indexedDb","_localstorage","NativeMethod","IndexedDBMethod","LocalstorageMethod","TRANSACTION_SETTINGS","cleanOldMessages","commitIndexedDBTransaction","createDatabase","getAllMessages","OBJECT_STORE_ID","openCursor","ev","cursor","getIdb","getMessagesHigherThan","getOldMessages","removeMessagesById","writeMessage","_obliviousSet","DB_PREFIX","durability","mozIndexedDB","webkitIndexedDB","msIndexedDB","commit","channelName","IndexedDB","dbName","openRequest","keyPath","autoIncrement","readerUuid","messageJson","writeObject","uuid","getTime","lastCursorId","keyRangeValue","IDBKeyRange","bound","Infinity","getAll","getAllRequest","openCursorRequest","channelState","ids","deleteRequest","ttl","olderThen","msgObk","idb","tooOld","eMIs","ObliviousSet","writeBlockPromise","messagesCallback","readQueuePromises","onclose","_readLoop","readNewMessages","newerMessages","useMessages","has","messagesCallbackTime","_filterMessage","sort","msgObjA","msgObjB","randomInt","addStorageEventListener","removeStorageEventListener","KEY_PREFIX","writeObj","createEvent","initEvent","newValue","dispatchEvent","localstorage","removeTimeout","ls","defaultTime","bc","subFns","SIMULATE_CHANNELS","originalOptions","maxParallelWrites","useFastPath","lastMs","additional","min","resolveWith","__self__","F","DOMException","support","iterable","Symbol","blob","Blob","formData","viewClasses","isArrayBufferView","ArrayBuffer","isView","normalizeName","TypeError","normalizeValue","iteratorFor","items","iterator","next","done","Headers","getOwnPropertyNames","consumed","bodyUsed","fileReaderReady","reader","onload","readBlobAsArrayBuffer","FileReader","promise","readAsArrayBuffer","bufferClone","buf","view","byteLength","Body","_initBody","_bodyInit","_bodyText","isPrototypeOf","_bodyBlob","FormData","_bodyFormData","URLSearchParams","DataView","_bodyArrayBuffer","rejected","readAsText","chars","readArrayBufferAsText","oldValue","callback","thisArg","Request","upcased","mode","referrer","trim","bytes","Response","bodyInit","statusText","redirectStatuses","redirect","RangeError","stack","constructor","init","aborted","XMLHttpRequest","abortXhr","rawHeaders","getAllResponseHeaders","line","responseURL","ontimeout","onabort","onreadystatechange","readyState","send","polyfill","ponyfill","converter","defaultAttributes","attributes","stringifiedAttributes","cookie","write","jar","foundKey","read","withAttributes","withConverter","freeze","factory","_to","removeTooOldValues","obliviousSet","E","once","evtArr","len","evts","liveEvents","USE_METHOD","exit","trace","WorkerGlobalScope","oldClose","LISTENERS","startedListening","runAll","promises","removeAll","getSize","size","arr","arr2","__esModule","arrayLikeToArray","ReferenceError","asyncGeneratorStep","gen","_next","_throw","arg","instance","Constructor","isNativeReflectConstruct","_construct","Parent","Class","Reflect","construct","Function","_defineProperties","descriptor","configurable","writable","protoProps","staticProps","superPropBase","_get","property","receiver","base","desc","getOwnPropertyDescriptor","_getPrototypeOf","getPrototypeOf","__proto__","subClass","superClass","sham","Proxy","valueOf","iter","_i","_s","_e","_arr","_n","_d","objectWithoutPropertiesLoose","excluded","getOwnPropertySymbols","sourceSymbolKeys","propertyIsEnumerable","sourceKeys","_typeof","assertThisInitialized","_regeneratorRuntime","Op","hasOwn","$Symbol","iteratorSymbol","asyncIteratorSymbol","asyncIterator","toStringTagSymbol","toStringTag","define","wrap","innerFn","outerFn","tryLocsList","protoGenerator","Generator","Context","_invoke","delegate","delegateResult","maybeInvokeDelegate","ContinueSentinel","sent","_sent","dispatchException","abrupt","record","tryCatch","GeneratorFunction","GeneratorFunctionPrototype","IteratorPrototype","getProto","NativeIteratorPrototype","Gp","defineIteratorMethods","AsyncIterator","PromiseImpl","invoke","__await","unwrapped","previousPromise","callInvokeWithMethodAndArg","resultName","nextLoc","pushTryEntry","locs","tryLoc","catchLoc","finallyLoc","afterLoc","tryEntries","resetTryEntry","completion","reset","iteratorMethod","isNaN","doneResult","isGeneratorFunction","genFun","ctor","mark","awrap","async","object","reverse","pop","skipTempReset","prev","rootRecord","rval","exception","handle","loc","caught","hasCatch","hasFinally","finallyEntry","complete","thrown","delegateYield","_setPrototypeOf","arrayWithHoles","iterableToArrayLimit","unsupportedIterableToArray","nonIterableRest","arrayWithoutHoles","iterableToArray","nonIterableSpread","minLen","isNativeFunction","_wrapNativeSuper","_cache","Wrapper","runtime","regeneratorRuntime","accidentalStrictMode","globalThis","_isNativeReflectConstruct","_toConsumableArray","_arrayLikeToArray","_arrayWithoutHoles","_iterableToArray","_unsupportedIterableToArray","_nonIterableSpread","hasOwnProp","unshift","NewError","_Error","_inherits","Derived","hasNativeReflectConstruct","_super","Super","NewTarget","_assertThisInitialized","_possibleConstructorReturn","_classCallCheck","avoidNew","expr","otherTypeCallback","optObj","resultType","flatten","sandbox","parent","parentProperty","autostart","evaluate","currParent","currParentProperty","currResultType","currPreventEval","currSandbox","currOtherTypeCallback","toPathString","exprList","toPathArray","_hasParentSelector","_trace","ea","isParentSelector","hasArrExpr","rslt","valOrPath","_getPreferredOutput","pointer","toPointer","_handleCallback","fullRetObj","preferredOutput","parentPropName","literalPriority","retObj","addRet","elems","t","_walk","l","_x","par","pr","cb","_slice","_eval","addType","valueType","isFinite","locProp","_step","_iterator","allowArrayLike","it","f","normalCompletion","didErr","return","_createForOfIteratorHelper","part","rett","tmp","tl","tt","end","_v","_vname","_$_parentProperty","_$_parent","_$_property","_$_path","_$_root","_$_v","vm","runInNewContext","pathArr","subx","$0","$1","ups","funcs","conditionCb","il","moveToAnotherArray","vr","funcString","func","fString","lastStatementEnd","lastIndexOf","__webpack_module_cache__","__webpack_require__","moduleId","cachedModule","__webpack_modules__","d","definition","g","__webpack_exports__"],"sourceRoot":""}