{"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/OktaAuthIdx.ts","webpack://OktaAuth/./lib/idx/factory/api.ts","webpack://OktaAuth/./lib/idx/factory/index.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/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/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/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/mixin/browser.ts","webpack://OktaAuth/./lib/oidc/mixin/index.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.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/detect-node/browser.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/browser.js","webpack://OktaAuth/./node_modules/unload/dist/es/index.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/jsonpath-plus/dist/index-browser-esm.js","webpack://OktaAuth/webpack/bootstrap","webpack://OktaAuth/webpack/runtime/compat get default export","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  }\n\n  addEnvironment(env: string) {\n    this.environments.push(env);\n  }\n\n  getHttpHeader() {\n    this.maybeAddNodeEnvironment();\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, resp: HttpResponse): AuthApiError | OAuthError => {\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 === 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 { 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';\n\n// Factory\nexport function createIdxAPI(sdk: OktaAuthIdxInterface): IdxAPI {\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';\n","/*!\n * Copyright (c) 2015-present, Okta, Inc. and/or its affiliates. All rights reserved.\n * The Okta software accompanied by this notice is provided pursuant to the Apache License, Version 2.0 (the \"License.\")\n *\n * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0.\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS, WITHOUT\n * WARRANTIES OR CONDITIONS OF 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} 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};\n","/*!\n * Copyright (c) 2015-present, Okta, Inc. and/or its affiliates. All rights reserved.\n * The Okta software accompanied by this notice is provided pursuant to the Apache License, Version 2.0 (the \"License.\")\n *\n * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0.\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS, WITHOUT\n * WARRANTIES OR CONDITIONS OF 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  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  '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 } from '../types';\nimport { AuthenticationFlow } from './AuthenticationFlow';\nimport { PasswordRecoveryFlow } from './PasswordRecoveryFlow';\nimport { RegistrationFlow } from './RegistrationFlow';\nimport { AccountUnlockFlow } from './AccountUnlockFlow';\nimport { RemediationFlow } from './RemediationFlow';\n\nexport interface FlowSpecification {\n  flow: FlowIdentifier;\n  remediators: RemediationFlow;\n  actions?: string[];\n  withCredentials?: boolean;\n}\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  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  '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// eslint-disable-next-line @typescript-eslint/ban-ts-comment\n// @ts-nocheck\nimport { OktaAuthIdxInterface } from '../../types';    // auth-js/types\nimport { generateRemediationFunctions } from './remediationParser';\nimport generateIdxAction from './generateIdxAction';\nimport { jsonpath } from '../../../util/jsonpath';\n\nconst SKIP_FIELDS = Object.fromEntries([\n  'remediation', // remediations are put into proceed/neededToProceed\n  'context', // the API response of 'context' isn't externally useful.  We ignore it and put all non-action (contextual) info into idxState.context\n].map( (field) => [ field, !!'skip this field' ] ));\n\nexport const parseNonRemediations = function parseNonRemediations( authClient: OktaAuthIdxInterface, idxResponse, toPersist = {} ) {\n  const actions = {};\n  const context = {};\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(fieldValue)\n        .forEach( ([subField, value]) => {\n          if (value.rel) { // is [field].value[subField] an action?\n            // add any \"action\" value subfields to actions\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        }\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 => expandRelatesTo(idxResponse, remediation)\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 } 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);\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\n// eslint-disable-next-line @typescript-eslint/ban-ts-comment\n// @ts-nocheck\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\n// eslint-disable-next-line @typescript-eslint/ban-ts-comment\n// @ts-nocheck\nimport { OktaAuthIdxInterface } from '../../types';    // auth-js/types\nimport generateIdxAction from './generateIdxAction';\n\nexport const generateRemediationFunctions = function generateRemediationFunctions(\n  authClient: OktaAuthIdxInterface,\n  remediationValue,\n  toPersist = {}\n) {\n  return Object.fromEntries( remediationValue.map( remediation => {\n    return [\n      remediation.name,\n      generateIdxAction(authClient, remediation, toPersist),\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 { 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","/*!\n * Copyright (c) 2015-present, Okta, Inc. and/or its affiliates. All rights reserved.\n * The Okta software accompanied by this notice is provided pursuant to the Apache License, Version 2.0 (the \"License.\")\n *\n * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0.\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS, WITHOUT\n * WARRANTIES OR CONDITIONS OF 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(neededToProceed, 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.neededToProceed, 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  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(): 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 } 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;\n    for (let authenticator of authenticators) {\n      option = options\n        .find(({ relatesTo }) => relatesTo.key === authenticator.key);\n      if (option) {\n        break;\n      }\n    }\n    return option;\n  }\n\n  canRemediate() {\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      return true;\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}\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 { 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 './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 { getFlowSpecification } from './flow';\nimport * as remediators from './remediators';\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 { getAvailableSteps, getEnabledFeatures, getMessagesFromResponse, isTerminalResponse } from './util';\nimport { Tokens } from '../oidc/types';\nimport { APIError } from '../errors/types';\ndeclare interface RunData {\n  options: RunOptions;\n  values: remediators.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, 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, 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, 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, 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, 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  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}\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 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 OktaAuthIdxConstructor\n<\n  I extends OktaAuthIdxInterface = OktaAuthIdxInterface\n>\n extends OktaAuthConstructor<I>\n{\n  new(...args: any[]): I;\n  webauthn: WebauthnAPI;\n}\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 { 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 * as remediators from './remediators';\nimport { RemediationValues, Remediator, RemediatorConstructor } from './remediators';\nimport { GenericRemediator } from './remediators/GenericRemediator';\nimport { OktaAuthIdxInterface, IdxFeature, NextStep, RemediateOptions, RemediationResponse, RunOptions } from './types';\nimport { IdxMessage, IdxRemediation, IdxRemediationValue, IdxResponse } from './types/idx-js';\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]) {\n      return filtered;\n    }\n    seen[key] = message;\n    filtered = [...filtered, message] as never;\n    return filtered;\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(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  idxRemediations: IdxRemediation[],\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\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()) {\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.neededToProceed, {}, 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 { \n  IAPIFunction, \n  BaseTransaction, \n  EmailTransaction, \n  EmailChallengeTransaction \n} from './types';\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(oktaAuth, {\n    url: '/idp/myaccount/emails',\n    method: 'GET',\n    accessToken: options?.accessToken,\n    transactionClassName: 'EmailTransaction'\n  }) as 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    transactionClassName: 'EmailTransaction'\n  }) as 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    transactionClassName: 'EmailTransaction'\n  }) as 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  }) as BaseTransaction;\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    transactionClassName: 'EmailChallengeTransaction'\n  }) as 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    transactionClassName: 'EmailChallengeTransaction'\n  }) as 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  }) as BaseTransaction;\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 { \n  IAPIFunction,\n  BaseTransaction, \n  PasswordTransaction\n} from './types';\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    transactionClassName: 'PasswordTransaction'\n  }) as 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    transactionClassName: 'PasswordTransaction'\n  }) as 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    transactionClassName: 'PasswordTransaction'\n  }) as 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  }) as BaseTransaction;\n  return transaction;\n};\n","import { sendRequest } from './request';\nimport { \n  IAPIFunction,\n  BaseTransaction, \n  PhoneTransaction\n} from './types';\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(oktaAuth, {\n    url: '/idp/myaccount/phones',\n    method: 'GET',\n    accessToken: options?.accessToken,\n    transactionClassName: 'PhoneTransaction'\n  }) as 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    transactionClassName: 'PhoneTransaction'\n  }) as 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    transactionClassName: 'PhoneTransaction'\n  }) as 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  }) as BaseTransaction;\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  }) as BaseTransaction;\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  }) as BaseTransaction;\n  return transaction;\n};\n","import { sendRequest } from './request';\nimport { \n  IAPIFunction,\n  ProfileTransaction,\n  ProfileSchemaTransaction\n} from './types';\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    transactionClassName: 'ProfileTransaction'\n  }) as 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    transactionClassName: 'ProfileTransaction'\n  }) as 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    transactionClassName: 'ProfileSchemaTransaction'\n  }) as ProfileSchemaTransaction;\n  return transaction;\n};\n","import { \n  BaseTransaction,\n  EmailTransaction,\n  EmailStatusTransaction,\n  EmailChallengeTransaction,\n  ProfileTransaction,\n  ProfileSchemaTransaction,\n  PhoneTransaction,\n  PasswordTransaction\n} from './transactions';\nimport { httpRequest } from '../http';\nimport { AuthSdkError } from '../errors';\nimport { MyAccountRequestOptions as RequestOptions } from './types';\nimport { OktaAuthOAuthInterface } from '../oidc/types';\n\nexport type TransactionLink = {\n  href: string;\n  hints?: {\n    allow?: string[];\n  };\n}\n\ntype TransactionLinks = {\n  self: TransactionLink;\n  [property: string]: TransactionLink;\n}\n\ntype SendRequestOptions = RequestOptions & {\n  url: string;\n  method: string;\n  transactionClassName?: string;\n}\n\n/* eslint-disable complexity */\nexport async function sendRequest<T extends BaseTransaction> (\n  oktaAuth: OktaAuthOAuthInterface, \n  options: SendRequestOptions\n): Promise<T | T[]> {\n  const { \n    accessToken: accessTokenObj\n  } = oktaAuth.tokenManager.getTokensSync();\n  \n  const accessToken = options.accessToken || accessTokenObj?.accessToken;\n  const { issuer } = oktaAuth.options;\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  const map = {\n    EmailTransaction,\n    EmailStatusTransaction,\n    EmailChallengeTransaction,\n    ProfileTransaction,\n    ProfileSchemaTransaction,\n    PhoneTransaction,\n    PasswordTransaction\n  };\n  const TransactionClass = map[options.transactionClassName!] || BaseTransaction;\n\n  if (Array.isArray(res)) {\n    return res.map(item => new TransactionClass(oktaAuth, { \n      res: item, \n      accessToken\n    }));\n  }\n\n  return new TransactionClass(oktaAuth, { \n    res, \n    accessToken\n  });\n}\n/* eslint-enable complexity */\n\nexport type GenerateRequestFnFromLinksOptions = {\n  oktaAuth: OktaAuthOAuthInterface;\n  accessToken: string;\n  methodName: string;\n  links: TransactionLinks;\n  transactionClassName?: string;\n}\n\ntype IRequestFnFromLinks = <T extends BaseTransaction>(payload?) => Promise<T | T[]>;\n\nexport function generateRequestFnFromLinks ({\n  oktaAuth, \n  accessToken,\n  methodName,\n  links,\n  transactionClassName\n}: GenerateRequestFnFromLinksOptions): IRequestFnFromLinks {\n  for (const method of ['GET', 'POST', 'PUT', 'DELETE']) {\n    if (method.toLowerCase() === methodName) {\n      const link = links.self;\n      return (async (payload?) => sendRequest(oktaAuth, {\n        accessToken,\n        url: link.href,\n        method,\n        payload,\n        transactionClassName\n      }));\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(oktaAuth, {\n    accessToken,\n    url: link.href,\n    method: link.hints!.allow![0],\n    payload,\n    transactionClassName\n  }));\n}\n","import { OktaAuthHttpInterface } from '../../http/types';\nimport { TransactionLink } from '../request';\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};\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","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        transactionClassName: 'EmailStatusTransaction'\n      });\n      return await fn() as EmailStatusTransaction;\n    };\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) as EmailChallengeTransaction;\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, EmailStatusTransaction } from '.';\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        transactionClassName: 'EmailTransaction'\n      });\n      return await fn() as EmailTransaction;\n    };\n    this.delete = async () => {\n      const fn = generateRequestFnFromLinks({ \n        oktaAuth, \n        accessToken, \n        methodName: 'delete', \n        links: _links \n      });\n      return await fn() as BaseTransaction;\n    };\n    this.challenge = async () => {\n      const fn = generateRequestFnFromLinks({ \n        oktaAuth, \n        accessToken, \n        methodName: 'challenge', \n        links: _links,\n        transactionClassName: 'EmailChallengeTransaction'\n      });\n      return await fn() as EmailChallengeTransaction;\n    };\n    if (_links.poll) {\n      this.poll = async () => {\n        const fn = generateRequestFnFromLinks({ \n          oktaAuth, \n          accessToken, \n          methodName: 'poll', \n          links: _links,\n          transactionClassName: 'EmailStatusTransaction'\n        });\n        return await fn() as EmailStatusTransaction;\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) as BaseTransaction;\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          transactionClassName: 'PasswordTransaction'\n        });\n        return await fn(payload) as PasswordTransaction;\n      };\n    }\n    else {\n      this.get = async () => {\n        const fn = generateRequestFnFromLinks({ \n          oktaAuth, \n          accessToken, \n          methodName: 'get',\n          links: _links,\n          transactionClassName: 'PasswordTransaction'\n        });\n        return await fn() as PasswordTransaction;\n      };\n\n      this.update = async (payload) => {\n        const fn = generateRequestFnFromLinks({ \n          oktaAuth, \n          accessToken, \n          methodName: 'put', \n          links: _links,\n          transactionClassName: 'PasswordTransaction'\n        });\n        return await fn(payload) as PasswordTransaction;\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() as BaseTransaction;\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        transactionClassName: 'PhoneTransaction'\n      });\n      return await fn() as PhoneTransaction;\n    };\n    this.delete = async () => {\n      const fn = generateRequestFnFromLinks({ \n        oktaAuth, \n        accessToken, \n        methodName: 'delete', \n        links: _links \n      });\n      return await fn() as BaseTransaction;\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) as BaseTransaction;\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) as BaseTransaction;\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 { \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 {\n    var tokenStorage = this.storage.getStorage();\n    return tokenStorage[key];\n  }\n  \n  async get(key): Promise<Token> {\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 (e) {\n      return Promise.reject(e);\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 {\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  };\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","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';\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';\nimport { TokenManager } from '../TokenManager';\nimport { getOAuthUrls, isLoginRedirect } 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      let hasResponseType = false;\n      if (Array.isArray(this.options.responseType) && this.options.responseType.length) {\n        hasResponseType = this.options.responseType.indexOf(responseType) >= 0;\n      } else {\n        hasResponseType = this.options.responseType === responseType;\n      }\n      return hasResponseType;\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) {\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\n    async signOut(options?: SignoutOptions): Promise<void> {\n      options = Object.assign({}, options);\n    \n      // postLogoutRedirectUri must be whitelisted in Okta Admin UI\n      var defaultUri = window.location.origin;\n      var currentUri = window.location.href;\n      var postLogoutRedirectUri = options.postLogoutRedirectUri\n        || this.options.postLogoutRedirectUri\n        || defaultUri;\n    \n      var accessToken = options.accessToken;\n      var refreshToken = options.refreshToken;\n      var revokeAccessToken = options.revokeAccessToken !== false;\n      var 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        return this.closeSession() // can throw if the user cannot be signed out\n        .then(function() {\n          if (postLogoutRedirectUri === currentUri) {\n            window.location.reload(); // force a hard reload if URI is not changing\n          } else {\n            window.location.assign(postLogoutRedirectUri);\n          }\n        });\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      }\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 { TokenParams, 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?: TokenParams): Promise<Tokens> {\n  const 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';\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>;\n  getSync(key): Token;\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 } 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 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 (claims.aud !== aud) {\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);\n  }\n\n  async start() {\n    if (this.canStart()) {\n      await this.stop();\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    await this.stop();\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();\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();\n  }\n\n  async start() {\n    if (!this.canStart()) {\n      return;\n    }\n\n    await this.stop();\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<unknown> {\n      return this.session.close() // DELETE /api/v1/sessions/me\n      .then(async () => {\n        // Clear all local tokens\n        this.clearStorage();\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 null;\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.storageProvider) {\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;\n\nvar _util = require(\"./util.js\");\n\nvar _methodChooser = require(\"./method-chooser.js\");\n\nvar _options = require(\"./options.js\");\n\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;\n\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\n  if (ENFORCED_OPTIONS) {\n    options = ENFORCED_OPTIONS;\n  }\n\n  this.options = (0, _options.fillOptionsWithDefaults)(options);\n  this.method = (0, _methodChooser.chooseMethod)(this.options); // isListening\n\n  this._iL = false;\n  /**\n   * _onMessageListener\n   * setting onmessage twice,\n   * will overwrite the first listener\n   */\n\n  this._onML = null;\n  /**\n   * _addEventListeners\n   */\n\n  this._addEL = {\n    message: [],\n    internal: []\n  };\n  /**\n   * Unsend message promises\n   * where the sending is still in progress\n   * @type {Set<Promise>}\n   */\n\n  this._uMP = new Set();\n  /**\n   * _beforeClose\n   * array of promises that will be awaited\n   * before the channel is closed\n   */\n\n  this._befC = [];\n  /**\n   * _preparePromise\n   */\n\n  this._prepP = null;\n\n  _prepareChannel(this);\n}; // STATICS\n\n/**\n * used to identify if someone overwrites\n * window.BroadcastChannel with this\n * See methods/native.js\n */\n\n\nexports.BroadcastChannel = BroadcastChannel;\nBroadcastChannel._pubkey = true;\n/**\n * clears the tmp-folder if is node\n * @return {Promise<boolean>} true if has run, false if not node\n */\n\nfunction clearNodeFolder(options) {\n  options = (0, _options.fillOptionsWithDefaults)(options);\n  var method = (0, _methodChooser.chooseMethod)(options);\n\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 * if set, this method is enforced,\n * no mather what the options are\n */\n\n\nvar ENFORCED_OPTIONS;\n\nfunction enforceOptions(options) {\n  ENFORCED_OPTIONS = options;\n} // PROTOTYPE\n\n\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 realy 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\n    return _post(this, 'message', msg);\n  },\n  postInternal: function postInternal(msg) {\n    return _post(this, 'internal', msg);\n  },\n\n  set onmessage(fn) {\n    var time = this.method.microSeconds();\n    var listenObj = {\n      time: time,\n      fn: fn\n    };\n\n    _removeListenerObject(this, 'message', this._onML);\n\n    if (fn && typeof fn === 'function') {\n      this._onML = listenObj;\n\n      _addListenerObject(this, 'message', listenObj);\n    } else {\n      this._onML = null;\n    }\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\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\n    _removeListenerObject(this, type, obj);\n  },\n  close: function close() {\n    var _this = this;\n\n    if (this.closed) {\n      return;\n    }\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 // wait until all current sending are processed\n    .then(function () {\n      return Promise.all(Array.from(_this._uMP));\n    }) // run before-close hooks\n    .then(function () {\n      return Promise.all(_this._befC.map(function (fn) {\n        return fn();\n      }));\n    }) // close the channel\n    .then(function () {\n      return _this.method.close(_this._state);\n    });\n  },\n\n  get type() {\n    return this.method.type;\n  },\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 */\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); // add/remove to unsend messages list\n\n    broadcastChannel._uMP.add(sendPromise);\n\n    sendPromise[\"catch\"]().then(function () {\n      return broadcastChannel._uMP[\"delete\"](sendPromise);\n    });\n    return sendPromise;\n  });\n}\n\nfunction _prepareChannel(channel) {\n  var maybePromise = channel.method.create(channel.name, channel.options);\n\n  if ((0, _util.isPromise)(maybePromise)) {\n    channel._prepP = maybePromise;\n    maybePromise.then(function (s) {\n      // used in tests to simulate slow runtime\n\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}\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}\n\nfunction _addListenerObject(channel, type, obj) {\n  channel._addEL[type].push(obj);\n\n  _startListening(channel);\n}\n\nfunction _removeListenerObject(channel, type, obj) {\n  channel._addEL[type] = channel._addEL[type].filter(function (o) {\n    return o !== obj;\n  });\n\n  _stopListening(channel);\n}\n\nfunction _startListening(channel) {\n  if (!channel._iL && _hasMessageListeners(channel)) {\n    // someone is listening, start subscribing\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 happend 'after' the listener\n         * was added, we also listen to events that happended 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\n        if (msgObj.time >= minMessageTime) {\n          listenerObject.fn(msgObj.data);\n        }\n      });\n    };\n\n    var time = channel.method.microSeconds();\n\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}\n\nfunction _stopListening(channel) {\n  if (channel._iL && !_hasMessageListeners(channel)) {\n    // noone 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/**\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 */\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 _leaderElection.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});\n\nvar _broadcastChannel = require(\"./broadcast-channel.js\");\n\nvar _leaderElection = require(\"./leader-election.js\");","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.beLeader = beLeader;\nexports.createLeaderElection = createLeaderElection;\n\nvar _util = require(\"./util.js\");\n\nvar _unload = require(\"unload\");\n\nvar LeaderElection = function LeaderElection(broadcastChannel, options) {\n  var _this = this;\n\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   * Apply Queue,\n   * used to ensure we do not run applyOnce()\n   * in parallel.\n   */\n\n  this._aplQ = _util.PROMISE_RESOLVED_VOID; // amount of unfinished applyOnce() calls\n\n  this._aplQC = 0; // things to clean up\n\n  this._unl = []; // _unloads\n\n  this._lstns = []; // _listeners\n\n  this._dpL = function () {}; // onduplicate listener\n\n\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\n  var hasLeaderListener = function hasLeaderListener(msg) {\n    if (msg.context === 'leader') {\n      if (msg.action === 'death') {\n        _this.hasLeader = false;\n      }\n\n      if (msg.action === 'tell') {\n        _this.hasLeader = true;\n      }\n    }\n  };\n\n  this.broadcastChannel.addEventListener('internal', hasLeaderListener);\n\n  this._lstns.push(hasLeaderListener);\n};\n\nLeaderElection.prototype = {\n  /**\n   * Returns true if the instance is leader,\n   * false if not.\n   * @async\n   */\n  applyOnce: function applyOnce( // true if the applyOnce() call came from the fallbackInterval cycle\n  isFromFallbackInterval) {\n    var _this2 = this;\n\n    if (this.isLeader) {\n      return (0, _util.sleep)(0, true);\n    }\n\n    if (this.isDead) {\n      return (0, _util.sleep)(0, false);\n    }\n    /**\n     * Already applying more then once,\n     * -> wait for the apply queue to be finished.\n     */\n\n\n    if (this._aplQC > 1) {\n      return this._aplQ;\n    }\n    /**\n     * Add a new apply-run\n     */\n\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\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\n      var stopCriteriaPromise = new Promise(function (res) {\n        stopCriteriaPromiseResolve = function stopCriteriaPromiseResolve() {\n          stopCriteria = true;\n          res();\n        };\n      });\n      var recieved = [];\n\n      var handleMessage = function handleMessage(msg) {\n        if (msg.context === 'leader' && msg.token != _this2.token) {\n          recieved.push(msg);\n\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\n          if (msg.action === 'tell') {\n            // other is already leader\n            stopCriteriaPromiseResolve();\n            _this2.hasLeader = true;\n          }\n        }\n      };\n\n      _this2.broadcastChannel.addEventListener('internal', handleMessage);\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 intances\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\n\n      var waitForAnswerTime = isFromFallbackInterval ? _this2._options.responseTime * 4 : _this2._options.responseTime;\n\n      var applyPromise = _sendMessage(_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      }) // send again in case another instance was just created\n      .then(function () {\n        return _sendMessage(_this2, 'apply');\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\n        if (!stopCriteria) {\n          // no stop criteria -> own is leader\n          return beLeader(_this2).then(function () {\n            return true;\n          });\n        } else {\n          // other is leader\n          return false;\n        }\n      });\n\n      return applyPromise;\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 (\n    /* _awaitLeadershipPromise */\n    !this._aLP) {\n      this._aLP = _awaitLeadershipOnce(this);\n    }\n\n    return this._aLP;\n  },\n\n  set onduplicate(fn) {\n    this._dpL = fn;\n  },\n\n  die: function die() {\n    var _this3 = this;\n\n    this._lstns.forEach(function (listener) {\n      return _this3.broadcastChannel.removeEventListener('internal', listener);\n    });\n\n    this._lstns = [];\n\n    this._unl.forEach(function (uFn) {\n      return uFn.remove();\n    });\n\n    this._unl = [];\n\n    if (this.isLeader) {\n      this.hasLeader = false;\n      this.isLeader = false;\n    }\n\n    this.isDead = true;\n    return _sendMessage(this, 'death');\n  }\n};\n/**\n * @param leaderElector {LeaderElector}\n */\n\nfunction _awaitLeadershipOnce(leaderElector) {\n  if (leaderElector.isLeader) {\n    return _util.PROMISE_RESOLVED_VOID;\n  }\n\n  return new Promise(function (res) {\n    var resolved = false;\n\n    function finish() {\n      if (resolved) {\n        return;\n      }\n\n      resolved = true;\n      leaderElector.broadcastChannel.removeEventListener('internal', whenDeathListener);\n      res(true);\n    } // try once now\n\n\n    leaderElector.applyOnce().then(function () {\n      if (leaderElector.isLeader) {\n        finish();\n      }\n    });\n    /**\n     * Try on fallbackInterval\n     * @recursive\n     */\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\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\n    tryOnFallBack(); // try when other leader dies\n\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\n    leaderElector.broadcastChannel.addEventListener('internal', whenDeathListener);\n\n    leaderElector._lstns.push(whenDeathListener);\n  });\n}\n/**\n * sends and internal message over the broadcast-channel\n */\n\n\nfunction _sendMessage(leaderElector, action) {\n  var msgJson = {\n    context: 'leader',\n    action: action,\n    token: leaderElector.token\n  };\n  return leaderElector.broadcastChannel.postInternal(msgJson);\n}\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\n  leaderElector._unl.push(unloadFn);\n\n  var isLeaderListener = function isLeaderListener(msg) {\n    if (msg.context === 'leader' && msg.action === 'apply') {\n      _sendMessage(leaderElector, 'tell');\n    }\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\n      leaderElector._dpL(); // message the lib user so the app can handle the problem\n\n\n      _sendMessage(leaderElector, 'tell'); // ensure other leader also knows the problem\n\n    }\n  };\n\n  leaderElector.broadcastChannel.addEventListener('internal', isLeaderListener);\n\n  leaderElector._lstns.push(isLeaderListener);\n\n  return _sendMessage(leaderElector, 'tell');\n}\n\nfunction fillOptionsWithDefaults(options, channel) {\n  if (!options) options = {};\n  options = JSON.parse(JSON.stringify(options));\n\n  if (!options.fallbackInterval) {\n    options.fallbackInterval = 3000;\n  }\n\n  if (!options.responseTime) {\n    options.responseTime = channel.method.averageResponseTime(channel.options);\n  }\n\n  return options;\n}\n\nfunction createLeaderElection(channel, options) {\n  if (channel._leaderElector) {\n    throw new Error('BroadcastChannel already has a leader-elector');\n  }\n\n  options = fillOptionsWithDefaults(options, channel);\n  var elector = new LeaderElection(channel, options);\n\n  channel._befC.push(function () {\n    return elector.die();\n  });\n\n  channel._leaderElector = elector;\n  return elector;\n}","\"use strict\";\n\nvar _interopRequireDefault = require(\"@babel/runtime/helpers/interopRequireDefault\");\n\nvar _typeof = require(\"@babel/runtime/helpers/typeof\");\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.chooseMethod = chooseMethod;\n\nvar _native = _interopRequireDefault(require(\"./methods/native.js\"));\n\nvar _indexedDb = _interopRequireDefault(require(\"./methods/indexed-db.js\"));\n\nvar _localstorage = _interopRequireDefault(require(\"./methods/localstorage.js\"));\n\nvar _simulate = _interopRequireDefault(require(\"./methods/simulate.js\"));\n\n\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); }\n\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\n// the line below will be removed from es5/browser builds\n// order is important\nvar METHODS = [_native[\"default\"], // fastest\n_indexedDb[\"default\"], _localstorage[\"default\"]];\n\nfunction chooseMethod(options) {\n  var chooseMethods = [].concat(options.methods, METHODS).filter(Boolean); // the line below will be removed from es5/browser builds\n\n\n  if (options.type) {\n    if (options.type === 'simulate') {\n      // only use simulate-method if directly chosen\n      return _simulate[\"default\"];\n    }\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   * if no webworker support is needed,\n   * remove idb from the list so that localstorage is been chosen\n   */\n\n\n  if (!options.webWorkerSupport) {\n    chooseMethods = chooseMethods.filter(function (m) {\n      return m.type !== 'idb';\n    });\n  }\n\n  var useMethod = chooseMethods.find(function (method) {\n    return method.canBeUsed();\n  });\n  if (!useMethod) throw new Error(\"No useable method found in \" + JSON.stringify(METHODS.map(function (m) {\n    return m.type;\n  })));else return useMethod;\n}","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.TRANSACTION_SETTINGS = void 0;\nexports.averageResponseTime = averageResponseTime;\nexports.canBeUsed = canBeUsed;\nexports.cleanOldMessages = cleanOldMessages;\nexports.close = close;\nexports.commitIndexedDBTransaction = commitIndexedDBTransaction;\nexports.create = create;\nexports.createDatabase = createDatabase;\nexports[\"default\"] = void 0;\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;\n\nvar _util = require(\"../util.js\");\n\nvar _obliviousSet = require(\"oblivious-set\");\n\nvar _options = require(\"../options.js\");\n\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 */\nvar microSeconds = _util.microSeconds;\nexports.microSeconds = microSeconds;\nvar DB_PREFIX = 'pubkey.broadcast-channel-0-';\nvar OBJECT_STORE_ID = 'messages';\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 */\n\nvar TRANSACTION_SETTINGS = {\n  durability: 'relaxed'\n};\nexports.TRANSACTION_SETTINGS = TRANSACTION_SETTINGS;\nvar type = 'idb';\nexports.type = type;\n\nfunction getIdb() {\n  if (typeof indexedDB !== 'undefined') return indexedDB;\n\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\n  return false;\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 */\n\n\nfunction commitIndexedDBTransaction(tx) {\n  if (tx.commit) {\n    tx.commit();\n  }\n}\n\nfunction createDatabase(channelName) {\n  var IndexedDB = getIdb(); // create table\n\n  var dbName = DB_PREFIX + channelName;\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\n  var openRequest = IndexedDB.open(dbName);\n\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\n  var dbPromise = new Promise(function (res, rej) {\n    openRequest.onerror = function (ev) {\n      return rej(ev);\n    };\n\n    openRequest.onsuccess = function () {\n      res(openRequest.result);\n    };\n  });\n  return dbPromise;\n}\n/**\n * writes the new message to the database\n * so other readers can find it\n */\n\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\n    tx.onerror = function (ev) {\n      return rej(ev);\n    };\n\n    var objectStore = tx.objectStore(OBJECT_STORE_ID);\n    objectStore.add(writeObject);\n    commitIndexedDBTransaction(tx);\n  });\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\n      if (cursor) {\n        ret.push(cursor.value); //alert(\"Name for SSN \" + cursor.key + \" is \" + cursor.value.name);\n\n        cursor[\"continue\"]();\n      } else {\n        commitIndexedDBTransaction(tx);\n        res(ret);\n      }\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   * Optimization shortcut,\n   * if getAll() can be used, do not use a cursor.\n   * @link https://rxdb.info/slow-indexeddb.html\n   */\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\n      getAllRequest.onsuccess = function (e) {\n        res(e.target.result);\n      };\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\n  return new Promise(function (res, rej) {\n    var openCursorRequest = openCursor();\n\n    openCursorRequest.onerror = function (err) {\n      return rej(err);\n    };\n\n    openCursorRequest.onsuccess = function (ev) {\n      var cursor = ev.target.result;\n\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}\n\nfunction removeMessagesById(db, ids) {\n  var tx = 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}\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\n      if (cursor) {\n        var msgObk = cursor.value;\n\n        if (msgObk.time < olderThen) {\n          ret.push(msgObk); //alert(\"Name for SSN \" + cursor.key + \" is \" + cursor.value.name);\n\n          cursor[\"continue\"]();\n        } else {\n          // no more old messages,\n          commitIndexedDBTransaction(tx);\n          res(ret);\n          return;\n        }\n      } else {\n        res(ret);\n      }\n    };\n  });\n}\n\nfunction cleanOldMessages(db, ttl) {\n  return getOldMessages(db, ttl).then(function (tooOld) {\n    return removeMessagesById(db, tooOld.map(function (msg) {\n      return msg.id;\n    }));\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      /**\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 parrallel\n      writeBlockPromise: _util.PROMISE_RESOLVED_VOID,\n      messagesCallback: null,\n      readQueuePromises: [],\n      db: db\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\n    db.onclose = function () {\n      state.closed = true;\n      if (options.idb.onclose) options.idb.onclose();\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\n\n    _readLoop(state);\n\n    return state;\n  });\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}\n\nfunction _filterMessage(msgObj, state) {\n  if (msgObj.uuid === state.uuid) return false; // send by own\n\n  if (state.eMIs.has(msgObj.id)) return false; // already emitted\n\n  if (msgObj.data.time < state.messagesCallbackTime) return false; // older then onMessageCallback\n\n  return true;\n}\n/**\n * reads all new messages from the database and emits them\n */\n\n\nfunction readNewMessages(state) {\n  // channel already closed\n  if (state.closed) return _util.PROMISE_RESOLVED_VOID; // if no one is listening, we do not need to scan for new messages\n\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 some times\n     * so we filter them out\n     * @link https://github.com/pubkey/broadcast-channel/issues/19\n     */\n    .filter(function (msgObj) {\n      return !!msgObj;\n    }).map(function (msgObj) {\n      if (msgObj.id > state.lastCursorId) {\n        state.lastCursorId = msgObj.id;\n      }\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\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}\n\nfunction close(channelState) {\n  channelState.closed = true;\n  channelState.db.close();\n}\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.db, channelState.options.idb.ttl);\n    }\n  });\n  return channelState.writeBlockPromise;\n}\n\nfunction onMessage(channelState, fn, time) {\n  channelState.messagesCallbackTime = time;\n  channelState.messagesCallback = fn;\n  readNewMessages(channelState);\n}\n\nfunction canBeUsed() {\n  var idb = getIdb();\n\n  if (!idb) {\n    return false;\n  }\n\n  return true;\n}\n\nfunction averageResponseTime(options) {\n  return options.idb.fallbackInterval * 2;\n}\n\nvar _default = {\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[\"default\"] = _default;","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.addStorageEventListener = addStorageEventListener;\nexports.averageResponseTime = averageResponseTime;\nexports.canBeUsed = canBeUsed;\nexports.close = close;\nexports.create = create;\nexports[\"default\"] = void 0;\nexports.getLocalStorage = getLocalStorage;\nexports.microSeconds = void 0;\nexports.onMessage = onMessage;\nexports.postMessage = postMessage;\nexports.removeStorageEventListener = removeStorageEventListener;\nexports.storageKey = storageKey;\nexports.type = void 0;\n\nvar _obliviousSet = require(\"oblivious-set\");\n\nvar _options = require(\"../options.js\");\n\nvar _util = require(\"../util.js\");\n\n/**\n * A localStorage-only method which uses localstorage and its 'storage'-event\n * This does not work inside of webworkers because they have no access to locastorage\n * This is basically implemented to support IE9 or your grandmothers toaster.\n * @link https://caniuse.com/#feat=namevalue-storage\n * @link https://caniuse.com/#feat=indexeddb\n */\nvar microSeconds = _util.microSeconds;\nexports.microSeconds = microSeconds;\nvar KEY_PREFIX = 'pubkey.broadcastChannel-';\nvar type = 'localstorage';\n/**\n * copied from crosstab\n * @link https://github.com/tejacques/crosstab/blob/master/src/crosstab.js#L32\n */\n\nexports.type = type;\n\nfunction getLocalStorage() {\n  var localStorage;\n  if (typeof window === 'undefined') return null;\n\n  try {\n    localStorage = window.localStorage;\n    localStorage = window['ie8-eventlistener/storage'] || window.localStorage;\n  } catch (e) {// 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\n  return localStorage;\n}\n\nfunction storageKey(channelName) {\n  return KEY_PREFIX + channelName;\n}\n/**\n* writes the new message to the storage\n* and fires the storage-event so other readers can find it\n*/\n\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       * 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\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}\n\nfunction addStorageEventListener(channelName, fn) {\n  var key = storageKey(channelName);\n\n  var listener = function listener(ev) {\n    if (ev.key === key) {\n      fn(JSON.parse(ev.newValue));\n    }\n  };\n\n  window.addEventListener('storage', listener);\n  return listener;\n}\n\nfunction removeStorageEventListener(listener) {\n  window.removeEventListener('storage', listener);\n}\n\nfunction create(channelName, options) {\n  options = (0, _options.fillOptionsWithDefaults)(options);\n\n  if (!canBeUsed()) {\n    throw new Error('BroadcastChannel: localstorage cannot be used');\n  }\n\n  var uuid = (0, _util.randomToken)();\n  /**\n   * eMIs\n   * contains all messages that have been emitted before\n   * @type {ObliviousSet}\n   */\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\n    if (msgObj.uuid === uuid) return; // own message\n\n    if (!msgObj.token || eMIs.has(msgObj.token)) return; // already emitted\n\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}\n\nfunction close(channelState) {\n  removeStorageEventListener(channelState.listener);\n}\n\nfunction onMessage(channelState, fn, time) {\n  channelState.messagesCallbackTime = time;\n  channelState.messagesCallback = fn;\n}\n\nfunction canBeUsed() {\n  var ls = getLocalStorage();\n  if (!ls) return false;\n\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\n  return true;\n}\n\nfunction averageResponseTime() {\n  var defaultTime = 120;\n  var userAgent = navigator.userAgent.toLowerCase();\n\n  if (userAgent.includes('safari') && !userAgent.includes('chrome')) {\n    // safari is much slower so this time is higher\n    return defaultTime * 2;\n  }\n\n  return defaultTime;\n}\n\nvar _default = {\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[\"default\"] = _default;","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.averageResponseTime = averageResponseTime;\nexports.canBeUsed = canBeUsed;\nexports.close = close;\nexports.create = create;\nexports.microSeconds = exports[\"default\"] = void 0;\nexports.onMessage = onMessage;\nexports.postMessage = postMessage;\nexports.type = void 0;\n\nvar _util = require(\"../util.js\");\n\nvar microSeconds = _util.microSeconds;\nexports.microSeconds = microSeconds;\nvar type = 'native';\nexports.type = type;\n\nfunction create(channelName) {\n  var state = {\n    messagesCallback: null,\n    bc: new BroadcastChannel(channelName),\n    subFns: [] // subscriberFunctions\n\n  };\n\n  state.bc.onmessage = function (msg) {\n    if (state.messagesCallback) {\n      state.messagesCallback(msg.data);\n    }\n  };\n\n  return state;\n}\n\nfunction close(channelState) {\n  channelState.bc.close();\n  channelState.subFns = [];\n}\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}\n\nfunction onMessage(channelState, fn) {\n  channelState.messagesCallback = fn;\n}\n\nfunction canBeUsed() {\n  if (typeof window === 'undefined') {\n    return false;\n  }\n\n  if (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\n    return true;\n  } else {\n    return false;\n  }\n}\n\nfunction averageResponseTime() {\n  return 150;\n}\n\nvar _default = {\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[\"default\"] = _default;","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.averageResponseTime = averageResponseTime;\nexports.canBeUsed = canBeUsed;\nexports.close = close;\nexports.create = create;\nexports.microSeconds = exports[\"default\"] = void 0;\nexports.onMessage = onMessage;\nexports.postMessage = postMessage;\nexports.type = void 0;\n\nvar _util = require(\"../util.js\");\n\nvar microSeconds = _util.microSeconds;\nexports.microSeconds = microSeconds;\nvar type = 'simulate';\nexports.type = type;\nvar SIMULATE_CHANNELS = new Set();\n\nfunction create(channelName) {\n  var state = {\n    name: channelName,\n    messagesCallback: null\n  };\n  SIMULATE_CHANNELS.add(state);\n  return state;\n}\n\nfunction close(channelState) {\n  SIMULATE_CHANNELS[\"delete\"](channelState);\n}\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}\n\nfunction onMessage(channelState, fn) {\n  channelState.messagesCallback = fn;\n}\n\nfunction canBeUsed() {\n  return true;\n}\n\nfunction averageResponseTime() {\n  return 5;\n}\n\nvar _default = {\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[\"default\"] = _default;","\"use strict\";\n\nObject.defineProperty(exports, \"__esModule\", {\n  value: true\n});\nexports.fillOptionsWithDefaults = fillOptionsWithDefaults;\n\nfunction fillOptionsWithDefaults() {\n  var originalOptions = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};\n  var options = JSON.parse(JSON.stringify(originalOptions)); // main\n\n  if (typeof options.webWorkerSupport === 'undefined') options.webWorkerSupport = true; // indexed-db\n\n  if (!options.idb) options.idb = {}; //  after this time the messages get deleted\n\n  if (!options.idb.ttl) options.idb.ttl = 1000 * 45;\n  if (!options.idb.fallbackInterval) options.idb.fallbackInterval = 150; //  handles abrupt db onclose events.\n\n  if (originalOptions.idb && typeof originalOptions.idb.onclose === 'function') options.idb.onclose = originalOptions.idb.onclose; // localstorage\n\n  if (!options.localstorage) options.localstorage = {};\n  if (!options.localstorage.removeTimeout) options.localstorage.removeTimeout = 1000 * 60; // custom methods\n\n  if (originalOptions.methods) options.methods = originalOptions.methods; // node\n\n  if (!options.node) options.node = {};\n  if (!options.node.ttl) options.node.ttl = 1000 * 60 * 2; // 2 minutes;\n\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\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;\n\n/**\n * returns true if the given object is a promise\n */\nfunction isPromise(obj) {\n  if (obj && typeof obj.then === 'function') {\n    return true;\n  } else {\n    return false;\n  }\n}\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;\n\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}\n\nfunction randomInt(min, max) {\n  return Math.floor(Math.random() * (max - min + 1) + min);\n}\n/**\n * https://stackoverflow.com/a/8084248\n */\n\n\nfunction randomToken() {\n  return Math.random().toString(36).substring(2);\n}\n\nvar lastMs = 0;\nvar additional = 0;\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 */\n\nfunction microSeconds() {\n  var ms = new Date().getTime();\n\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}","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","module.exports = false;\n\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","/* global WorkerGlobalScope */\nfunction add(fn) {\n  if (typeof WorkerGlobalScope === 'function' && self instanceof WorkerGlobalScope) {// this is run inside of a webworker\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') return;\n    /**\n     * for normal browser-windows, we use the beforeunload-event\n     */\n\n    window.addEventListener('beforeunload', function () {\n      fn();\n    }, true);\n    /**\n     * for iframes, we have to use the unload-event\n     * @link https://stackoverflow.com/q/47533670/3443137\n     */\n\n    window.addEventListener('unload', function () {\n      fn();\n    }, true);\n  }\n  /**\n   * TODO add fallback for safari-mobile\n   * @link https://stackoverflow.com/a/26193516/3443137\n   */\n\n}\n\nexport default {\n  add: add\n};","import isNode from 'detect-node';\nimport BrowserMethod from './browser.js';\nimport NodeMethod from './node.js';\nvar USE_METHOD = isNode ? NodeMethod : BrowserMethod;\nvar LISTENERS = new Set();\nvar startedListening = false;\n\nfunction startListening() {\n  if (startedListening) return;\n  startedListening = true;\n  USE_METHOD.add(runAll);\n}\n\nexport function add(fn) {\n  startListening();\n  if (typeof fn !== 'function') throw new Error('Listener is no function');\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}","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  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","// getDefaultExport function for compatibility with non-harmony modules\n__webpack_require__.n = function(module) {\n\tvar getter = module && module.__esModule ?\n\t\tfunction() { return module['default']; } :\n\t\tfunction() { return module; };\n\t__webpack_require__.d(getter, { a: getter });\n\treturn getter;\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","env","maybeAddNodeEnvironment","process","versions","version","node","authClient","headerName","headerValue","_oktaUserAgent","http","setRequestHeader","issuer","transformErrorXHR","httpRequestClient","fetchRequest","httpRequestInterceptors","createStorageOptionsConstructor","isAbsoluteUrl","httpRequest","postOptions","interceptor","httpCache","storageManager","getHttpCache","cookies","cacheResponse","cachedResponse","getStorage","getHttpHeader","isString","ajaxOptions","resp","item","updateStorage","floor","DEFAULT_CACHE_DURATION","serverErr","header","part","trim","acc","curr","parseInsufficientAuthenticationError","max_age","acr_values","formatError","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","Core","createOktaAuthCore","mixinIdx","boundStartTransaction","startTransaction","interact","makeIdxResponse","makeIdxState","authenticate","register","recoverPassword","handleInteractionCodeRedirect","isInteractionRequired","isInteractionRequiredError","handleEmailVerifyCallback","isEmailVerifyCallbackError","getSavedTransactionMeta","createTransactionMeta","getTransactionMeta","saveTransactionMeta","clearTransactionMeta","isTransactionMetaValid","setFlow","getFlow","unlockAccount","AccountUnlockFlow","Identify","SelectAuthenticatorUnlockAccount","SelectAuthenticatorAuthenticate","ChallengeAuthenticator","ChallengePoll","AuthenticatorVerificationData","AuthenticationFlow","SelectAuthenticatorEnroll","AuthenticatorEnrollmentData","EnrollAuthenticator","ReEnrollAuthenticator","EnrollPoll","SelectEnrollmentChannel","EnrollmentChannelData","RedirectIdp","Skip","oktaAuth","remediators","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","fromEntries","parseNonRemediations","context","filter","rel","generateIdxAction","fieldValue","info","subField","expandRelatesTo","query","jsonpath","innerValue","convertRemediationAction","actionFn","generateRemediationFunctions","remediationData","remediations","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","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","findMatchedOption","selectedAuthenticator","selectedOption","VerifyAuthenticator","authenticatorEnrollments","canVerify","mapCredentials","common","currentAuthenticator","getCredentialsFromRemediation","userProfileFromValues","userProfile","attributeValues","attributeName","errorRemediation","errors","Boolean","email","GenericRemediator","endsWith","produces","rest","unwrapFormValue","requiredTracker","isRequired","optionSchema","formKeys","unwrappedForm","identifier","newPassword","idp","isRecoveryFlow","hasPasswordInOptions","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","remediatorClass","T","getRemediatorClass","stepObj","startsWith","split2","part1","part2","actionObj","PASSWORD_RECOVERY","SOCIAL_IDP","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","transactionClassName","getEmail","addEmail","deleteEmail","sendEmailChallenge","getEmailChallenge","emailId","challengeId","verifyEmailChallenge","myaccount","MyAccountMethods","getPassword","enrollPassword","updatePassword","deletePassword","getPhones","getPhone","addPhone","deletePhone","sendPhoneChallenge","verifyPhoneChallenge","getProfile","updateProfile","getProfileSchema","methodName","links","self","accessTokenObj","requestUrl","EmailTransaction","EmailStatusTransaction","EmailChallengeTransaction","ProfileTransaction","ProfileSchemaTransaction","PhoneTransaction","PasswordTransaction","TransactionClass","BaseTransaction","generateRequestFnFromLinks","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","renewTokens","tokenKey","emitError","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","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","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","reload","clearTokensBeforeRedirect","addPendingRemoveFlags","provideOriginalUri","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","token_type_hint","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","plus2space","paramSplit","fragment","exec","aud","iss","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","randomCharset","random","cl","parts","isoTime","UTC","toUTCString","delim","splice","ctx","additionalArgs","concat","obj1","objArray","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","_leaderElection","_leaderElector","fallbackInterval","responseTime","averageResponseTime","LeaderElection","_unload","isDead","randomToken","_aplQ","_aplQC","_unl","_lstns","_dpL","_dpLC","hasLeaderListener","_sendMessage","leaderElector","msgJson","unloadFn","isLeaderListener","applyOnce","isFromFallbackInterval","_this2","sleep","PROMISE_RESOLVED_TRUE","stopCriteriaPromiseResolve","stopCriteria","stopCriteriaPromise","recieved","handleMessage","waitForAnswerTime","race","applyRun","_aLP","resolved","finish","whenDeathListener","tryOnFallBack","_this3","uFn","_interopRequireDefault","chooseMethods","methods","METHODS","_simulate","ret","m","webWorkerSupport","useMethod","canBeUsed","_native","_indexedDb","_localstorage","TRANSACTION_SETTINGS","cleanOldMessages","commitIndexedDBTransaction","createDatabase","getAllMessages","db","OBJECT_STORE_ID","objectStore","openCursor","onsuccess","ev","cursor","getIdb","getMessagesHigherThan","getOldMessages","removeMessagesById","writeMessage","_obliviousSet","durability","indexedDB","mozIndexedDB","webkitIndexedDB","msIndexedDB","commit","channelName","dbName","openRequest","onupgradeneeded","createObjectStore","keyPath","autoIncrement","rej","onerror","readerUuid","messageJson","writeObject","uuid","getTime","oncomplete","lastCursorId","keyRangeValue","IDBKeyRange","bound","Infinity","getAll","getAllRequest","openCursorRequest","ids","deleteRequest","ttl","olderThen","msgObk","tooOld","eMIs","ObliviousSet","idb","writeBlockPromise","messagesCallback","readQueuePromises","onclose","_readLoop","readNewMessages","newerMessages","useMessages","has","messagesCallbackTime","_filterMessage","sort","msgObjA","msgObjB","channelState","randomInt","_default","addStorageEventListener","removeStorageEventListener","writeObj","createEvent","initEvent","newValue","dispatchEvent","localstorage","removeTimeout","ls","defaultTime","bc","subFns","SIMULATE_CHANNELS","originalOptions","maxParallelWrites","useFastPath","lastMs","additional","min","resolveWith","__self__","F","DOMException","support","Symbol","Blob","viewClasses","isArrayBufferView","ArrayBuffer","isView","normalizeName","TypeError","normalizeValue","iteratorFor","items","iterator","next","done","Headers","append","getOwnPropertyNames","consumed","bodyUsed","fileReaderReady","reader","onload","readBlobAsArrayBuffer","blob","FileReader","promise","readAsArrayBuffer","bufferClone","buf","view","byteLength","Body","_initBody","_bodyInit","_bodyText","isPrototypeOf","_bodyBlob","FormData","_bodyFormData","URLSearchParams","DataView","_bodyArrayBuffer","rejected","readAsText","chars","readArrayBufferAsText","formData","oldValue","callback","thisArg","Request","upcased","mode","signal","referrer","bytes","Response","bodyInit","statusText","redirectStatuses","redirect","RangeError","stack","constructor","init","request","aborted","XMLHttpRequest","abortXhr","abort","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","WorkerGlobalScope","USE_METHOD","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","iterable","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","_possibleConstructorReturn","_assertThisInitialized","_toConsumableArray","_arrayLikeToArray","_arrayWithoutHoles","_iterableToArray","_unsupportedIterableToArray","_nonIterableSpread","hasOwnProp","unshift","NewError","_Error","_inherits","Derived","hasNativeReflectConstruct","_super","Super","NewTarget","_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__","getter","d","definition","g","__webpack_exports__"],"sourceRoot":""}