{"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/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/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/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  FingerprintAPI,\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 { 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 '../authn/types';\nimport { OktaAuthHttpInterface } from '../http/types';\n\nexport default function fingerprint(sdk: OktaAuthHttpInterface, options?: FingerprintOptions): Promise<string> {\n  options = options || {};\n\n  if (!isFingerprintSupported()) {\n    return Promise.reject(new AuthSdkError('Fingerprinting is not supported on this device'));\n  }\n\n  var timeout;\n  var iframe;\n  var listener;\n  var 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) {\n      if (!e || !e.data || e.origin !== sdk.getIssuerOrigin()) {\n        return;\n      }\n\n      try {\n        var 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      }\n      if (msg.type === 'FingerprintServiceReady') {\n        e.source.postMessage(JSON.stringify({\n          type: 'GetFingerprint'\n        }), e.origin);\n      }\n    };\n    addListener(window, 'message', listener);\n\n    iframe.src = sdk.getIssuerOrigin() + '/auth/services/devicefingerprint';\n    document.body.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 (document.body.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, SyncStorageService, LeaderElectionService } from '../../services';\nimport { removeNils } from '../../util';\n\nconst AUTO_RENEW = 'autoRenew';\nconst SYNC_STORAGE = 'syncStorage';\nconst LEADER_ELECTION = 'leaderElection';\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];\n\n  private static defaultOptions = {\n    autoRenew: true,\n    autoRemove: true,\n    syncStorage: true\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      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';\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  constructor(errorCode: string, summary: string) {\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}\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';\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\nexport {\n  isAuthApiError,\n  isOAuthError,\n  AuthApiError,\n  AuthPollStopError,\n  AuthSdkError,\n  OAuthError\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\nexport function isTokenVerifySupported() {\n  return typeof webcrypto !== 'undefined'\n    && webcrypto !== null\n    && typeof webcrypto.subtle !== 'undefined'\n    && typeof Uint8Array !== 'undefined';\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","/*!\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, AuthSdkError, APIError } from '../errors';\n\ntype InsufficientAuthenticationError = {\n  error: string;\n  // eslint-disable-next-line camelcase\n  error_description: string;\n  // eslint-disable-next-line camelcase\n  max_age: string;\n  // eslint-disable-next-line camelcase\n  acr_values: string;\n};\n\nconst parseInsufficientAuthenticationError = (\n  header: string\n): InsufficientAuthenticationError => {\n  if (!header) {\n    throw new AuthSdkError('Missing header string');\n  }\n\n  return header\n    .split(',')\n    .map(part => part.trim())\n    .map(part => part.split('='))\n    .reduce((acc, curr) => {\n      // unwrap quotes from value\n      acc[curr[0]] = curr[1].replace(/^\"(.*)\"$/, '$1');\n      return acc;\n    }, {}) as InsufficientAuthenticationError;\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;\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  if (serverErr.error && serverErr.error_description) {\n    err = new OAuthError(serverErr.error, serverErr.error_description);\n  } else {\n    err = new AuthApiError(serverErr as APIError, resp);\n  }\n\n  if (resp?.status === 403 && !!resp?.headers?.['www-authenticate']) {\n    const { \n      error, \n      // eslint-disable-next-line camelcase\n      error_description,\n      // eslint-disable-next-line camelcase\n      max_age,\n      // eslint-disable-next-line camelcase\n      acr_values \n    } = parseInsufficientAuthenticationError(resp?.headers?.['www-authenticate']);\n    if (error === 'insufficient_authentication_context') {\n      err = new AuthApiError(\n        { \n          errorSummary: error,\n          // eslint-disable-next-line camelcase\n          errorCauses: [{ errorSummary: error_description }]\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  }\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 { interactionHandle } = options;\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 | 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}\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 } = values;\n    if (!credentials && !password && !passcode) {\n      return;\n    }\n    return credentials || { passcode: passcode || password };\n  }\n\n  getInputs(idxRemediationValue) {\n    return {\n      ...idxRemediationValue.form?.value[0],\n      name: 'password',\n      type: 'string',\n      required: idxRemediationValue.required\n    };\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 { 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 * 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    static webauthn: WebauthnAPI = webauthn;\n    \n    constructor(...args: any[]) {\n      super(...args);\n      this.idx = createIdxAPI(this);\n    }\n  };\n}\n","import { 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 * 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    static webauthn: WebauthnAPI = webauthn;\n    \n    constructor(...args: any[]) {\n      super(...args);\n      this.idx = createMinimalIdxAPI(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  } = 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 });\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 });\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 } 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\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}\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}\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}\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      if (!token) {\n        throw new AuthSdkError('The tokenManager has no token for the key: ' + key);\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        // 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","/* 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 } from '../../errors';\nimport { CustomUrls, OAuthParams, OAuthResponse, RefreshToken, TokenParams } from '../types';\nimport { removeNils, toQueryString } from '../../util';\nimport { httpRequest, OktaAuthHttpInterface } from '../../http';\n\nfunction validateOptions(options: TokenParams) {\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// exchange authorization code for an access token\nexport function postToTokenEndpoint(sdk, options: TokenParams, urls: CustomUrls): Promise<OAuthResponse> {\n  validateOptions(options);\n  var data = getPostData(sdk, options);\n\n  const headers = {\n    'Content-Type': 'application/x-www-form-urlencoded'\n  };\n\n  return httpRequest(sdk, {\n    url: urls.tokenUrl,\n    method: 'POST',\n    args: data,\n    headers\n  });\n}\n\nexport function postRefreshToken(\n  sdk: OktaAuthHttpInterface,\n  options: TokenParams,\n  refreshToken: RefreshToken\n): Promise<OAuthResponse> {\n  return httpRequest(sdk, {\n    url: refreshToken.tokenUrl,\n    method: 'POST',\n    headers: {\n      'Content-Type': 'application/x-www-form-urlencoded',\n    },\n\n    args: 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}","/*!\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 } from './endpoints/token';\nimport { handleOAuthResponse } from './handleOAuthResponse';\n\n// codeVerifier is required. May pass either an authorizationCode or interactionCode\nexport 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  } = tokenParams;\n\n  var getTokenOptions = {\n    clientId,\n    redirectUri,\n    authorizationCode,\n    interactionCode,\n    codeVerifier,\n  };\n\n  return postToTokenEndpoint(sdk, getTokenOptions, urls)\n    .then((response: OAuthResponse) => {\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      const handleResponseOptions: TokenParams = {\n        clientId,\n        redirectUri,\n        scopes,\n        responseType,\n        ignoreSignature,\n        acrValues\n      };\n      return handleOAuthResponse(sdk, handleResponseOptions, response, urls!)\n        .then((response: TokenResponse) => {\n          // For compatibility, \"code\" is returned in the TokenResponse. OKTA-326091\n          response.code = authorizationCode;\n          response.state = state!;\n          return response;\n        });\n    })\n    .finally(() => {\n      sdk.transactionManager.clear();\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 { isFunction } from '../util';\nimport { AuthSdkError, OAuthError } 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  return httpRequest(sdk, {\n    url: accessTokenObject.userinfoUrl,\n    method: 'GET',\n    accessToken: accessTokenObject.accessToken\n  })\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      if (err.xhr && (err.xhr.status === 401 || err.xhr.status === 403)) {\n        var authenticateHeader;\n        if (err.xhr.headers && isFunction(err.xhr.headers.get) && err.xhr.headers.get('WWW-Authenticate')) {\n          authenticateHeader = err.xhr.headers.get('WWW-Authenticate');\n        } else if (isFunction(err.xhr.getResponseHeader)) {\n          authenticateHeader = err.xhr.getResponseHeader('WWW-Authenticate');\n        }\n        if (authenticateHeader) {\n          var errorMatches = authenticateHeader.match(/error=\"(.*?)\"/) || [];\n          var errorDescriptionMatches = authenticateHeader.match(/error_description=\"(.*?)\"/) || [];\n          var error = errorMatches[1];\n          var errorDescription = errorDescriptionMatches[1];\n          if (error && errorDescription) {\n            err = new OAuthError(error, errorDescription);\n          }\n        }\n      }\n      throw err;\n    });\n}\n","/*!\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\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  // 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\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\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    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} 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} from '../types';\nimport PKCE from '../util/pkce';\nimport { createEndpoints, createTokenAPI } from '../factory/api';\nimport { TokenManager } from '../TokenManager';\nimport { getOAuthUrls, isLoginRedirect, hasResponseType } from '../util';\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    /**\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        accessToken = (await this.tokenManager.getTokens()).accessToken as AccessToken;\n        const accessTokenKey = this.tokenManager.getStorageKeyByType('accessToken');\n        this.tokenManager.remove(accessTokenKey);\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        refreshToken = (await this.tokenManager.getTokens()).refreshToken as RefreshToken;\n        const refreshTokenKey = this.tokenManager.getStorageKeyByType('refreshToken');\n        this.tokenManager.remove(refreshTokenKey);\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 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  };\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.') !== -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\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\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 } = token as (AccessToken & IDToken);\n  return getWithoutPrompt(sdk, {\n    responseType,\n    scopes,\n    authorizeUrl,\n    userinfoUrl,\n    issuer\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\n  // Get tokens using the SSO cookie\n  options = Object.assign({\n    scopes,\n    authorizeUrl,\n    userinfoUrl,\n    issuer\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 { postRefreshToken } from './endpoints/token';\nimport { isRefreshTokenInvalidError } from './util/errors';\n\nexport async function renewTokensWithRefresh(\n  sdk: OktaAuthOAuthInterface,\n  tokenParams: TokenParams,\n  refreshTokenObject: RefreshToken\n): Promise<Tokens> {\n  const { clientId } = 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, {\n      clientId,\n    });\n    const tokenResponse = await postRefreshToken(sdk, renewTokenParams, 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}\n\nexport interface AccessToken extends AbstractToken {\n  accessToken: string;\n  claims: UserClaims;\n  tokenType: string;\n  userinfoUrl: string;\n}\n\nexport interface RefreshToken extends AbstractToken {\n  refreshToken: string;\n  tokenUrl: string;\n  issuer: 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  } = 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  });\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  };\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.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","/*!\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';\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","iframe","document","createElement","style","display","listener","origin","msg","source","postMessage","addListener","src","body","appendChild","timeout","setTimeout","finally","clearTimeout","removeListener","contains","parentElement","removeChild","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","event","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","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","Error","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","error_description","OktaAuth","createIdxOptionsConstructor","StorageManager","createIdxStorageManager","TransactionManager","createIdxTransactionManager","WithIdx","createOktaAuthIdx","WithMyAccount","mixinMyAccount","mixinAuthn","agent","getUserAgent","isWindowsPhone","test","isBrowser","protocol","documentMode","hostname","isTokenVerifySupported","hasTextEncoder","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","resp","serverErr","isString","header","part","trim","acc","curr","parseInsufficientAuthenticationError","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","interactionHandle","clearStorage","createTransactionManager","password","authenticator","AuthenticatorKey","OKTA_PASSWORD","run","flow","Authenticator","OktaPassword","passcode","idxRemediationValue","form","required","OktaVerifyTotp","verificationCode","totp","VerificationCodeAuthenticator","SecurityQuestionEnrollment","questionKey","answer","question","label","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","wwwAuthHeader","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","stateHandle","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","canRemediate","getNextStep","getName","getData","getValuesAfterProceed","useGenericRemediator","gr","getAuthenticatorData","getAuthenticatorFromRemediation","methodType","phoneNumber","val","AuthenticatorData","valueKey","getAuthenticator","formatAuthenticatorData","authenticatorsData","compareAuthenticators","mapAuthenticatorDataFromValues","enrollmentId","Remediator","formatAuthenticators","formatAuthenticator","existing","getRequiredValues","hasData","getAllValues","titleCase","_authClient","_context","inputs","getInputs","inputFromRemediation","input","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","emitError","renewTokens","tokenKey","removedTokens","pendingRemove","REFRESH_TOKEN_STORAGE_KEY","enableSharedStorage","clearTransactionFromSharedStorage","isTransactionMeta","saveTransactionToSharedStorage","pruneSharedStorage","loadTransactionFromSharedStorage","decodedToken","base64UrlToString","oauthQueryParams","convertTokenParamsToOAuthParams","extraParams","oauthParams","idpScope","loginHint","prompt","responseMode","sessionToken","enrollAmrValues","mayBeArray","tokenUrl","grant_type","refresh_token","authorizationCode","validateOptions","code","getPostData","kid","getWellKnown","wellKnown","jwksUri","cachedKey","authServerUri","prepareEnrollAuthenticatorParams","createEnrollAuthenticatorMeta","authorizeUrl","buildAuthorizeParams","setLocation","getOAuthUrls","getDefaultTokenParams","getTokenOptions","postToTokenEndpoint","handleResponseOptions","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","close","userinfoUrl","userInfo","sub","claims","authenticateHeader","isFunction","getResponseHeader","errorMatches","match","errorDescriptionMatches","errorDescription","loadPopup","getToken","validateResponse","pkce","interaction_code","tokenDict","expiresIn","expires_in","tokenType","token_type","access_token","id_token","accessJwt","idJwt","idTokenObj","exp","iat","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","shouldRenew","onExpiredToken","shouldRemove","hasExpired","additionalParams","setOriginalUri","hasResponseType","accessTokenKey","refreshTokenKey","postLogoutRedirectUri","logoutUrl","idTokenHint","logoutUri","defaultUri","currentUri","revokeAccessToken","revokeRefreshToken","getSignOutRedirectUrl","closeSession","sessionClosed","append","clearTokensBeforeRedirect","addPendingRemoveFlags","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","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","open","eventTarget","addEventListener","attachEvent","removeEventListener","detachEvent","defaultRedirectUri","generateState","generateNonce","errorResponse","isOAuthError","hasTokensInHash","hasAuthorizationCode","hashOrSearch","hasInteractionCode","hasErrorInUrl","isRedirectUri","uri","authParams","isCodeFlow","getHashOrSearch","codeFlow","genRandomString","getIssuer","oauthMeta","dec2hex","dec","toString","substr","prefix","a","verifier","MIN_VERIFIER_LENGTH","ceil","getRandomValues","MAX_VERIFIER_LENGTH","prepareParams","getDefaultEnrollAuthenticatorParams","assertPKCESupport","isPKCESupported","errorMessage","isHTTPS","validateCodeChallengeMethod","preparePKCE","defaults","b","getSharedTansactionStorage","dateCreated","MAX_ENTRY_LIFETIME","plus2space","paramSplit","fragment","exec","aud","acr","configuredIssuer","validationOptions","validateClaims","getKey","sdkCrypto","at_hash","getOidcHash","renewTimeQueue","onTokenExpiredHandler","firstTime","shouldThrottleRenew","processExpiredTokens","onLeaderDuplicate","elector","hasLeader","BroadcastChannel","createLeaderElection","onduplicate","awaitLeadership","die","postInternal","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","db","OBJECT_STORE_ID","objectStore","openCursor","onsuccess","ev","cursor","getIdb","getMessagesHigherThan","getOldMessages","removeMessagesById","writeMessage","_obliviousSet","DB_PREFIX","durability","indexedDB","mozIndexedDB","webkitIndexedDB","msIndexedDB","commit","channelName","IndexedDB","dbName","openRequest","onupgradeneeded","createObjectStore","keyPath","autoIncrement","onerror","readerUuid","messageJson","writeObject","uuid","getTime","oncomplete","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","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","n","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","x","addRet","elems","t","_walk","l","_x","v","par","pr","cb","_slice","_eval","addType","valueType","isFinite","locProp","_step","_iterator","allowArrayLike","it","f","normalCompletion","didErr","return","_createForOfIteratorHelper","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":""}