@vardario/cognito-client 4.0.4 → 4.0.6

package/lib/browser.js

@@ -0,0 +1,1208 @@
+// src/error.ts
+var CommonException = /* @__PURE__ */ ((CommonException3) => {
+  CommonException3["AccessDeniedException"] = "AccessDeniedException";
+  CommonException3["IncompleteSignature"] = "IncompleteSignature";
+  CommonException3["InternalFailure"] = "InternalFailure";
+  CommonException3["InvalidAction"] = "InvalidAction";
+  CommonException3["InvalidClientTokenId"] = "InvalidClientTokenId";
+  CommonException3["NotAuthorized"] = "NotAuthorized";
+  CommonException3["OptInRequired"] = "OptInRequired";
+  CommonException3["RequestExpired"] = "RequestExpired";
+  CommonException3["ServiceUnavailable"] = "ServiceUnavailable";
+  CommonException3["ThrottlingException"] = "ThrottlingException";
+  CommonException3["ValidationError"] = "ValidationError";
+  return CommonException3;
+})(CommonException || {});
+var COMMON_EXCEPTIONS = [
+  "AccessDeniedException" /* AccessDeniedException */,
+  "IncompleteSignature" /* IncompleteSignature */,
+  "InternalFailure" /* InternalFailure */,
+  "InvalidAction" /* InvalidAction */,
+  "InvalidClientTokenId" /* InvalidClientTokenId */,
+  "NotAuthorized" /* NotAuthorized */,
+  "OptInRequired" /* OptInRequired */,
+  "RequestExpired" /* RequestExpired */,
+  "ServiceUnavailable" /* ServiceUnavailable */,
+  "ThrottlingException" /* ThrottlingException */,
+  "ValidationError" /* ValidationError */
+];
+var AssociateSoftwareTokenException = /* @__PURE__ */ ((AssociateSoftwareTokenException2) => {
+  AssociateSoftwareTokenException2["ConcurrentModificationException"] = "ConcurrentModificationException";
+  AssociateSoftwareTokenException2["ForbiddenException"] = "ForbiddenException";
+  AssociateSoftwareTokenException2["InternalErrorException"] = "InternalErrorException";
+  AssociateSoftwareTokenException2["InvalidParameterException"] = "InvalidParameterException";
+  AssociateSoftwareTokenException2["NotAuthorizedException"] = "NotAuthorizedException";
+  AssociateSoftwareTokenException2["ResourceNotFoundException"] = "ResourceNotFoundException";
+  AssociateSoftwareTokenException2["SoftwareTokenMFANotFoundException"] = "SoftwareTokenMFANotFoundException";
+  return AssociateSoftwareTokenException2;
+})(AssociateSoftwareTokenException || {});
+var ChangePasswordException = /* @__PURE__ */ ((ChangePasswordException3) => {
+  ChangePasswordException3["ForbiddenException"] = "ForbiddenException";
+  ChangePasswordException3["InternalErrorException"] = "InternalErrorException";
+  ChangePasswordException3["InvalidParameterException"] = "InvalidParameterException";
+  ChangePasswordException3["InvalidPasswordException"] = "InvalidPasswordException";
+  ChangePasswordException3["LimitExceededException"] = "LimitExceededException";
+  ChangePasswordException3["NotAuthorizedException"] = "NotAuthorizedException";
+  ChangePasswordException3["PasswordResetRequiredException"] = "PasswordResetRequiredException";
+  ChangePasswordException3["ResourceNotFoundException"] = "ResourceNotFoundException";
+  ChangePasswordException3["TooManyRequestsException"] = "TooManyRequestsException";
+  ChangePasswordException3["UserNotConfirmedException"] = "UserNotConfirmedException";
+  ChangePasswordException3["UserNotFoundException"] = "UserNotFoundException";
+  return ChangePasswordException3;
+})(ChangePasswordException || {});
+var ConfirmDeviceException = /* @__PURE__ */ ((ConfirmDeviceException2) => {
+  ConfirmDeviceException2["ForbiddenException"] = "ForbiddenException";
+  ConfirmDeviceException2["InternalErrorException"] = "InternalErrorException";
+  ConfirmDeviceException2["InvalidLambdaResponseException"] = "InvalidLambdaResponseException";
+  ConfirmDeviceException2["InvalidParameterException"] = "InvalidParameterException";
+  ConfirmDeviceException2["InvalidPasswordException"] = "InvalidPasswordException";
+  ConfirmDeviceException2["InvalidUserPoolConfigurationException"] = "InvalidUserPoolConfigurationException";
+  ConfirmDeviceException2["NotAuthorizedException"] = "NotAuthorizedException";
+  ConfirmDeviceException2["PasswordResetRequiredException"] = "PasswordResetRequiredException";
+  ConfirmDeviceException2["ResourceNotFoundException"] = "ResourceNotFoundException";
+  ConfirmDeviceException2["TooManyRequestsException"] = "TooManyRequestsException";
+  ConfirmDeviceException2["UsernameExistsException"] = "UsernameExistsException";
+  ConfirmDeviceException2["UserNotConfirmedException"] = "UserNotConfirmedException";
+  ConfirmDeviceException2["UserNotFoundException"] = "UserNotFoundException";
+  return ConfirmDeviceException2;
+})(ConfirmDeviceException || {});
+var ConfirmForgotPasswordException = /* @__PURE__ */ ((ConfirmForgotPasswordException3) => {
+  ConfirmForgotPasswordException3["CodeMismatchException"] = "CodeMismatchException";
+  ConfirmForgotPasswordException3["ExpiredCodeException"] = "ExpiredCodeException";
+  ConfirmForgotPasswordException3["ForbiddenException"] = "ForbiddenException";
+  ConfirmForgotPasswordException3["InternalErrorException"] = "InternalErrorException";
+  ConfirmForgotPasswordException3["InvalidLambdaResponseException"] = "InvalidLambdaResponseException";
+  ConfirmForgotPasswordException3["InvalidParameterException"] = "InvalidParameterException";
+  ConfirmForgotPasswordException3["InvalidPasswordException"] = "InvalidPasswordException";
+  ConfirmForgotPasswordException3["LimitExceededException"] = "LimitExceededException";
+  ConfirmForgotPasswordException3["NotAuthorizedException"] = "NotAuthorizedException";
+  ConfirmForgotPasswordException3["ResourceNotFoundException"] = "ResourceNotFoundException";
+  ConfirmForgotPasswordException3["TooManyFailedAttemptsException"] = "TooManyFailedAttemptsException";
+  ConfirmForgotPasswordException3["TooManyRequestsException"] = "TooManyRequestsException";
+  ConfirmForgotPasswordException3["UnexpectedLambdaException"] = "UnexpectedLambdaException";
+  ConfirmForgotPasswordException3["UserLambdaValidationException"] = "UserLambdaValidationException";
+  ConfirmForgotPasswordException3["UserNotConfirmedException"] = "UserNotConfirmedException";
+  ConfirmForgotPasswordException3["UserNotFoundException"] = "UserNotFoundException";
+  return ConfirmForgotPasswordException3;
+})(ConfirmForgotPasswordException || {});
+var ConfirmSignUpException = /* @__PURE__ */ ((ConfirmSignUpException3) => {
+  ConfirmSignUpException3["AliasExistsException"] = "AliasExistsException";
+  ConfirmSignUpException3["CodeMismatchException"] = "CodeMismatchException";
+  ConfirmSignUpException3["ExpiredCodeException"] = "ExpiredCodeException";
+  ConfirmSignUpException3["ForbiddenException"] = "ForbiddenException";
+  ConfirmSignUpException3["InternalErrorException"] = "InternalErrorException";
+  ConfirmSignUpException3["InvalidLambdaResponseException"] = "InvalidLambdaResponseException";
+  ConfirmSignUpException3["InvalidParameterException"] = "InvalidParameterException";
+  ConfirmSignUpException3["LimitExceededException"] = "LimitExceededException";
+  ConfirmSignUpException3["NotAuthorizedException"] = "NotAuthorizedException";
+  ConfirmSignUpException3["ResourceNotFoundException"] = "ResourceNotFoundException";
+  ConfirmSignUpException3["TooManyFailedAttemptsException"] = "TooManyFailedAttemptsException";
+  ConfirmSignUpException3["TooManyRequestsException"] = "TooManyRequestsException";
+  ConfirmSignUpException3["UnexpectedLambdaException"] = "UnexpectedLambdaException";
+  ConfirmSignUpException3["UserLambdaValidationException"] = "UserLambdaValidationException";
+  ConfirmSignUpException3["UserNotFoundException"] = "UserNotFoundException";
+  return ConfirmSignUpException3;
+})(ConfirmSignUpException || {});
+var DeleteUserAttributesException = /* @__PURE__ */ ((DeleteUserAttributesException2) => {
+  DeleteUserAttributesException2["ForbiddenException"] = "ForbiddenException";
+  DeleteUserAttributesException2["InternalErrorException"] = "InternalErrorException";
+  DeleteUserAttributesException2["InvalidParameterException"] = "InvalidParameterException";
+  DeleteUserAttributesException2["NotAuthorizedException"] = "NotAuthorizedException";
+  DeleteUserAttributesException2["PasswordResetRequiredException"] = "PasswordResetRequiredException";
+  DeleteUserAttributesException2["ResourceNotFoundException"] = "ResourceNotFoundException";
+  DeleteUserAttributesException2["TooManyRequestsException"] = "TooManyRequestsException";
+  DeleteUserAttributesException2["UserNotConfirmedException"] = "UserNotConfirmedException";
+  DeleteUserAttributesException2["UserNotFoundException"] = "UserNotFoundException";
+  return DeleteUserAttributesException2;
+})(DeleteUserAttributesException || {});
+var DeleteUserException = /* @__PURE__ */ ((DeleteUserException2) => {
+  DeleteUserException2["ForbiddenException"] = "ForbiddenException";
+  DeleteUserException2["InternalErrorException"] = "InternalErrorException";
+  DeleteUserException2["InvalidParameterException"] = "InvalidParameterException";
+  DeleteUserException2["NotAuthorizedException"] = "NotAuthorizedException";
+  DeleteUserException2["PasswordResetRequiredException"] = "PasswordResetRequiredException";
+  DeleteUserException2["ResourceNotFoundException"] = "ResourceNotFoundException";
+  DeleteUserException2["TooManyRequestsException"] = "TooManyRequestsException";
+  DeleteUserException2["UserNotConfirmedException"] = "UserNotConfirmedException";
+  DeleteUserException2["UserNotFoundException"] = "UserNotFoundException";
+  return DeleteUserException2;
+})(DeleteUserException || {});
+var ForgetDeviceException = /* @__PURE__ */ ((ForgetDeviceException2) => {
+  ForgetDeviceException2["ForbiddenException"] = "ForbiddenException";
+  ForgetDeviceException2["InternalErrorException"] = "InternalErrorException";
+  ForgetDeviceException2["InvalidParameterException"] = "InvalidParameterException";
+  ForgetDeviceException2["InvalidUserPoolConfigurationException"] = "InvalidUserPoolConfigurationException";
+  ForgetDeviceException2["NotAuthorizedException"] = "NotAuthorizedException";
+  ForgetDeviceException2["PasswordResetRequiredException"] = "PasswordResetRequiredException";
+  ForgetDeviceException2["ResourceNotFoundException"] = "ResourceNotFoundException";
+  ForgetDeviceException2["TooManyRequestsException"] = "TooManyRequestsException";
+  ForgetDeviceException2["UserNotConfirmedException"] = "UserNotConfirmedException";
+  ForgetDeviceException2["UserNotFoundException"] = "UserNotFoundException";
+  return ForgetDeviceException2;
+})(ForgetDeviceException || {});
+var ForgotPasswordException = /* @__PURE__ */ ((ForgotPasswordException3) => {
+  ForgotPasswordException3["CodeDeliveryFailureException"] = "CodeDeliveryFailureException";
+  ForgotPasswordException3["ForbiddenException"] = "ForbiddenException";
+  ForgotPasswordException3["InternalErrorException"] = "InternalErrorException";
+  ForgotPasswordException3["InvalidEmailRoleAccessPolicyException"] = "InvalidEmailRoleAccessPolicyException";
+  ForgotPasswordException3["InvalidLambdaResponseException"] = "InvalidLambdaResponseException";
+  ForgotPasswordException3["InvalidParameterException"] = "InvalidParameterException";
+  ForgotPasswordException3["InvalidSmsRoleAccessPolicyException"] = "InvalidSmsRoleAccessPolicyException";
+  ForgotPasswordException3["InvalidSmsRoleTrustRelationshipException"] = "InvalidSmsRoleTrustRelationshipException";
+  ForgotPasswordException3["LimitExceededException"] = "LimitExceededException";
+  ForgotPasswordException3["NotAuthorizedException"] = "NotAuthorizedException";
+  ForgotPasswordException3["ResourceNotFoundException"] = "ResourceNotFoundException";
+  ForgotPasswordException3["TooManyRequestsException"] = "TooManyRequestsException";
+  ForgotPasswordException3["UnexpectedLambdaException"] = "UnexpectedLambdaException";
+  ForgotPasswordException3["UserLambdaValidationException"] = "UserLambdaValidationException";
+  ForgotPasswordException3["UserNotFoundException"] = "UserNotFoundException";
+  return ForgotPasswordException3;
+})(ForgotPasswordException || {});
+var GetUserException = /* @__PURE__ */ ((GetUserException2) => {
+  GetUserException2["ForbiddenException"] = "ForbiddenException";
+  GetUserException2["InternalErrorException"] = "InternalErrorException";
+  GetUserException2["InvalidParameterException"] = "InvalidParameterException";
+  GetUserException2["NotAuthorizedException"] = "NotAuthorizedException";
+  GetUserException2["PasswordResetRequiredException"] = "PasswordResetRequiredException";
+  GetUserException2["ResourceNotFoundException"] = "ResourceNotFoundException";
+  GetUserException2["TooManyRequestsException"] = "TooManyRequestsException";
+  GetUserException2["UserNotConfirmedException"] = "UserNotConfirmedException";
+  GetUserException2["UserNotFoundException"] = "UserNotFoundException";
+  return GetUserException2;
+})(GetUserException || {});
+var GetIdException = /* @__PURE__ */ ((GetIdException2) => {
+  GetIdException2["ExternalServiceException"] = "ExternalServiceException";
+  GetIdException2["InternalErrorException"] = "InternalErrorException";
+  GetIdException2["InvalidParameterException"] = "InvalidParameterException";
+  GetIdException2["LimitExceededException"] = "LimitExceededException";
+  GetIdException2["NotAuthorizedException"] = "NotAuthorizedException";
+  GetIdException2["ResourceConflictException"] = "ResourceConflictException";
+  GetIdException2["ResourceNotFoundException"] = "ResourceNotFoundException";
+  GetIdException2["TooManyRequestsException"] = "TooManyRequestsException";
+  return GetIdException2;
+})(GetIdException || {});
+var GetCredentialsForIdentityException = /* @__PURE__ */ ((GetCredentialsForIdentityException2) => {
+  GetCredentialsForIdentityException2["ExternalServiceException"] = "ExternalServiceException";
+  GetCredentialsForIdentityException2["InternalErrorException"] = "InternalErrorException";
+  GetCredentialsForIdentityException2["InvalidIdentityPoolConfigurationException"] = "InvalidIdentityPoolConfigurationException";
+  GetCredentialsForIdentityException2["InvalidParameterException"] = "InvalidParameterException";
+  GetCredentialsForIdentityException2["NotAuthorizedException"] = "NotAuthorizedException";
+  GetCredentialsForIdentityException2["ResourceConflictException"] = "ResourceConflictException";
+  GetCredentialsForIdentityException2["ResourceNotFoundException"] = "ResourceNotFoundException";
+  GetCredentialsForIdentityException2["TooManyRequestsException"] = "TooManyRequestsException";
+  return GetCredentialsForIdentityException2;
+})(GetCredentialsForIdentityException || {});
+var GetUserAttributeVerificationException = /* @__PURE__ */ ((GetUserAttributeVerificationException2) => {
+  GetUserAttributeVerificationException2["CodeDeliveryFailureException"] = "CodeDeliveryFailureException";
+  GetUserAttributeVerificationException2["ForbiddenException"] = "ForbiddenException";
+  GetUserAttributeVerificationException2["InternalErrorException"] = "InternalErrorException";
+  GetUserAttributeVerificationException2["InvalidEmailRoleAccessPolicyException"] = "InvalidEmailRoleAccessPolicyException";
+  GetUserAttributeVerificationException2["InvalidLambdaResponseException"] = "InvalidLambdaResponseException";
+  GetUserAttributeVerificationException2["InvalidParameterException"] = "InvalidParameterException";
+  GetUserAttributeVerificationException2["InvalidSmsRoleAccessPolicyException"] = "InvalidSmsRoleAccessPolicyException";
+  GetUserAttributeVerificationException2["InvalidSmsRoleTrustRelationshipException"] = "InvalidSmsRoleTrustRelationshipException";
+  GetUserAttributeVerificationException2["LimitExceededException"] = "LimitExceededException";
+  GetUserAttributeVerificationException2["NotAuthorizedException"] = "NotAuthorizedException";
+  GetUserAttributeVerificationException2["PasswordResetRequiredException"] = "PasswordResetRequiredException";
+  GetUserAttributeVerificationException2["ResourceNotFoundException"] = "ResourceNotFoundException";
+  GetUserAttributeVerificationException2["TooManyRequestsException"] = "TooManyRequestsException";
+  GetUserAttributeVerificationException2["UnexpectedLambdaException"] = "UnexpectedLambdaException";
+  GetUserAttributeVerificationException2["UserLambdaValidationException"] = "UserLambdaValidationException";
+  GetUserAttributeVerificationException2["UserNotConfirmedException"] = "UserNotConfirmedException";
+  GetUserAttributeVerificationException2["UserNotFoundException"] = "UserNotFoundException";
+  return GetUserAttributeVerificationException2;
+})(GetUserAttributeVerificationException || {});
+var GlobalSignOutException = /* @__PURE__ */ ((GlobalSignOutException3) => {
+  GlobalSignOutException3["ForbiddenException"] = "ForbiddenException";
+  GlobalSignOutException3["InternalErrorException"] = "InternalErrorException";
+  GlobalSignOutException3["InvalidParameterException"] = "InvalidParameterException";
+  GlobalSignOutException3["NotAuthorizedException"] = "NotAuthorizedException";
+  GlobalSignOutException3["PasswordResetRequiredException"] = "PasswordResetRequiredException";
+  GlobalSignOutException3["ResourceNotFoundException"] = "ResourceNotFoundException";
+  GlobalSignOutException3["TooManyRequestsException"] = "TooManyRequestsException";
+  GlobalSignOutException3["UserNotConfirmedException"] = "UserNotConfirmedException";
+  return GlobalSignOutException3;
+})(GlobalSignOutException || {});
+var InitiateAuthException = /* @__PURE__ */ ((InitiateAuthException3) => {
+  InitiateAuthException3["PasswordResetRequiredException"] = "PasswordResetRequiredException";
+  InitiateAuthException3["ForbiddenException"] = "ForbiddenException";
+  InitiateAuthException3["InternalErrorException"] = "InternalErrorException";
+  InitiateAuthException3["InvalidLambdaResponseException"] = "InvalidLambdaResponseException";
+  InitiateAuthException3["InvalidParameterException"] = "InvalidParameterException";
+  InitiateAuthException3["InvalidSmsRoleAccessPolicyException"] = "InvalidSmsRoleAccessPolicyException";
+  InitiateAuthException3["InvalidSmsRoleTrustRelationshipException"] = "InvalidSmsRoleTrustRelationshipException";
+  InitiateAuthException3["InvalidUserPoolConfigurationException"] = "InvalidUserPoolConfigurationException";
+  InitiateAuthException3["NotAuthorizedException"] = "NotAuthorizedException";
+  InitiateAuthException3["ResourceNotFoundException"] = "ResourceNotFoundException";
+  InitiateAuthException3["TooManyRequestsException"] = "TooManyRequestsException";
+  InitiateAuthException3["UnexpectedLambdaException"] = "UnexpectedLambdaException";
+  InitiateAuthException3["UserLambdaValidationException"] = "UserLambdaValidationException";
+  InitiateAuthException3["UserNotConfirmedException"] = "UserNotConfirmedException";
+  InitiateAuthException3["UserNotFoundException"] = "UserNotFoundException";
+  return InitiateAuthException3;
+})(InitiateAuthException || {});
+var ResendConfirmationException = /* @__PURE__ */ ((ResendConfirmationException3) => {
+  ResendConfirmationException3["CodeDeliveryFailureException"] = "CodeDeliveryFailureException";
+  ResendConfirmationException3["ForbiddenException"] = "ForbiddenException";
+  ResendConfirmationException3["InternalErrorException"] = "InternalErrorException";
+  ResendConfirmationException3["InvalidEmailRoleAccessPolicyException"] = "InvalidEmailRoleAccessPolicyException";
+  ResendConfirmationException3["InvalidLambdaResponseException"] = "InvalidLambdaResponseException";
+  ResendConfirmationException3["InvalidParameterException"] = "InvalidParameterException";
+  ResendConfirmationException3["InvalidSmsRoleAccessPolicyException"] = "InvalidSmsRoleAccessPolicyException";
+  ResendConfirmationException3["InvalidSmsRoleTrustRelationshipException"] = "InvalidSmsRoleTrustRelationshipException";
+  ResendConfirmationException3["LimitExceededException"] = "LimitExceededException";
+  ResendConfirmationException3["NotAuthorizedException"] = "NotAuthorizedException";
+  ResendConfirmationException3["ResourceNotFoundException"] = "ResourceNotFoundException";
+  ResendConfirmationException3["TooManyRequestsException"] = "TooManyRequestsException";
+  ResendConfirmationException3["UnexpectedLambdaException"] = "UnexpectedLambdaException";
+  ResendConfirmationException3["UserLambdaValidationException"] = "UserLambdaValidationException";
+  ResendConfirmationException3["UserNotFoundException"] = "UserNotFoundException";
+  return ResendConfirmationException3;
+})(ResendConfirmationException || {});
+var RespondToAuthChallengeException = /* @__PURE__ */ ((RespondToAuthChallengeException3) => {
+  RespondToAuthChallengeException3["AliasExistsException"] = "AliasExistsException";
+  RespondToAuthChallengeException3["CodeMismatchException"] = "CodeMismatchException";
+  RespondToAuthChallengeException3["ExpiredCodeException"] = "ExpiredCodeException";
+  RespondToAuthChallengeException3["ForbiddenException"] = "ForbiddenException";
+  RespondToAuthChallengeException3["InternalErrorException"] = "InternalErrorException";
+  RespondToAuthChallengeException3["InvalidLambdaResponseException"] = "InvalidLambdaResponseException";
+  RespondToAuthChallengeException3["InvalidParameterException"] = "InvalidParameterException";
+  RespondToAuthChallengeException3["InvalidPasswordException"] = "InvalidPasswordException";
+  RespondToAuthChallengeException3["InvalidSmsRoleAccessPolicyException"] = "InvalidSmsRoleAccessPolicyException";
+  RespondToAuthChallengeException3["InvalidSmsRoleTrustRelationshipException"] = "InvalidSmsRoleTrustRelationshipException";
+  RespondToAuthChallengeException3["InvalidUserPoolConfigurationException"] = "InvalidUserPoolConfigurationException";
+  RespondToAuthChallengeException3["MFAMethodNotFoundException"] = "MFAMethodNotFoundException";
+  RespondToAuthChallengeException3["NotAuthorizedException"] = "NotAuthorizedException";
+  RespondToAuthChallengeException3["PasswordResetRequiredException"] = "PasswordResetRequiredException";
+  RespondToAuthChallengeException3["ResourceNotFoundException"] = "ResourceNotFoundException";
+  RespondToAuthChallengeException3["SoftwareTokenMFANotFoundException"] = "SoftwareTokenMFANotFoundException";
+  RespondToAuthChallengeException3["TooManyRequestsException"] = "TooManyRequestsException";
+  RespondToAuthChallengeException3["UnexpectedLambdaException"] = "UnexpectedLambdaException";
+  RespondToAuthChallengeException3["UserLambdaValidationException"] = "UserLambdaValidationException";
+  RespondToAuthChallengeException3["UserNotConfirmedException"] = "UserNotConfirmedException";
+  RespondToAuthChallengeException3["UserNotFoundException"] = "UserNotFoundException";
+  return RespondToAuthChallengeException3;
+})(RespondToAuthChallengeException || {});
+var SetUserMFAPreferenceException = /* @__PURE__ */ ((SetUserMFAPreferenceException2) => {
+  SetUserMFAPreferenceException2["ForbiddenException"] = "ForbiddenException";
+  SetUserMFAPreferenceException2["InternalErrorException"] = "InternalErrorException";
+  SetUserMFAPreferenceException2["InvalidParameterException"] = "InvalidParameterException";
+  SetUserMFAPreferenceException2["NotAuthorizedException"] = "NotAuthorizedException";
+  SetUserMFAPreferenceException2["PasswordResetRequiredException"] = "PasswordResetRequiredException";
+  SetUserMFAPreferenceException2["ResourceNotFoundException"] = "ResourceNotFoundException";
+  SetUserMFAPreferenceException2["UserNotConfirmedException"] = "UserNotConfirmedException";
+  SetUserMFAPreferenceException2["UserNotFoundException"] = "UserNotFoundException";
+  return SetUserMFAPreferenceException2;
+})(SetUserMFAPreferenceException || {});
+var SignUpException = /* @__PURE__ */ ((SignUpException3) => {
+  SignUpException3["CodeDeliveryFailureException"] = "CodeDeliveryFailureException";
+  SignUpException3["InternalErrorException"] = "InternalErrorException";
+  SignUpException3["InvalidEmailRoleAccessPolicyException"] = "InvalidEmailRoleAccessPolicyException";
+  SignUpException3["InvalidLambdaResponseException"] = "InvalidLambdaResponseException";
+  SignUpException3["InvalidParameterException"] = "InvalidParameterException";
+  SignUpException3["InvalidPasswordException"] = "InvalidPasswordException";
+  SignUpException3["InvalidSmsRoleAccessPolicyException"] = "InvalidSmsRoleAccessPolicyException";
+  SignUpException3["InvalidSmsRoleTrustRelationshipException"] = "InvalidSmsRoleTrustRelationshipException";
+  SignUpException3["NotAuthorizedException"] = "NotAuthorizedException";
+  SignUpException3["ResourceNotFoundException"] = "ResourceNotFoundException";
+  SignUpException3["TooManyRequestsException"] = "TooManyRequestsException";
+  SignUpException3["UnexpectedLambdaException"] = "UnexpectedLambdaException";
+  SignUpException3["UserLambdaValidationException"] = "UserLambdaValidationException";
+  SignUpException3["UsernameExistsException"] = "UsernameExistsException";
+  return SignUpException3;
+})(SignUpException || {});
+var UpdateUserAttributesException = /* @__PURE__ */ ((UpdateUserAttributesException3) => {
+  UpdateUserAttributesException3["AliasExistsException"] = "AliasExistsException";
+  UpdateUserAttributesException3["CodeDeliveryFailureException"] = "CodeDeliveryFailureException";
+  UpdateUserAttributesException3["CodeMismatchException"] = "CodeMismatchException";
+  UpdateUserAttributesException3["ExpiredCodeException"] = "ExpiredCodeException";
+  UpdateUserAttributesException3["ForbiddenException"] = "ForbiddenException";
+  UpdateUserAttributesException3["InternalErrorException"] = "InternalErrorException";
+  UpdateUserAttributesException3["InvalidEmailRoleAccessPolicyException"] = "InvalidEmailRoleAccessPolicyException";
+  UpdateUserAttributesException3["InvalidLambdaResponseException"] = "InvalidLambdaResponseException";
+  UpdateUserAttributesException3["InvalidParameterException"] = "InvalidParameterException";
+  UpdateUserAttributesException3["InvalidSmsRoleAccessPolicyException"] = "InvalidSmsRoleAccessPolicyException";
+  UpdateUserAttributesException3["InvalidSmsRoleTrustRelationshipException"] = "InvalidSmsRoleTrustRelationshipException";
+  UpdateUserAttributesException3["NotAuthorizedException"] = "NotAuthorizedException";
+  UpdateUserAttributesException3["PasswordResetRequiredException"] = "PasswordResetRequiredException";
+  UpdateUserAttributesException3["ResourceNotFoundException"] = "ResourceNotFoundException";
+  UpdateUserAttributesException3["TooManyRequestsException"] = "TooManyRequestsException";
+  UpdateUserAttributesException3["UnexpectedLambdaException"] = "UnexpectedLambdaException";
+  UpdateUserAttributesException3["UserLambdaValidationException"] = "UserLambdaValidationException";
+  UpdateUserAttributesException3["UserNotConfirmedException"] = "UserNotConfirmedException";
+  UpdateUserAttributesException3["UserNotFoundException"] = "UserNotFoundException";
+  return UpdateUserAttributesException3;
+})(UpdateUserAttributesException || {});
+var VerifySoftwareTokenException = /* @__PURE__ */ ((VerifySoftwareTokenException2) => {
+  VerifySoftwareTokenException2["CodeMismatchException"] = "CodeMismatchException";
+  VerifySoftwareTokenException2["EnableSoftwareTokenMFAException"] = "EnableSoftwareTokenMFAException";
+  VerifySoftwareTokenException2["ForbiddenException"] = "ForbiddenException";
+  VerifySoftwareTokenException2["InternalErrorException"] = "InternalErrorException";
+  VerifySoftwareTokenException2["InvalidParameterException"] = "InvalidParameterException";
+  VerifySoftwareTokenException2["InvalidUserPoolConfigurationException"] = "InvalidUserPoolConfigurationException";
+  VerifySoftwareTokenException2["NotAuthorizedException"] = "NotAuthorizedException";
+  VerifySoftwareTokenException2["PasswordResetRequiredException"] = "PasswordResetRequiredException";
+  VerifySoftwareTokenException2["ResourceNotFoundException"] = "ResourceNotFoundException";
+  VerifySoftwareTokenException2["SoftwareTokenMFANotFoundException"] = "SoftwareTokenMFANotFoundException";
+  VerifySoftwareTokenException2["TooManyRequestsException"] = "TooManyRequestsException";
+  VerifySoftwareTokenException2["UserNotConfirmedException"] = "UserNotConfirmedException";
+  VerifySoftwareTokenException2["UserNotFoundException"] = "UserNotFoundException";
+  return VerifySoftwareTokenException2;
+})(VerifySoftwareTokenException || {});
+var VerifyUserAttributeException = /* @__PURE__ */ ((VerifyUserAttributeException3) => {
+  VerifyUserAttributeException3["AliasExistsException"] = "AliasExistsException";
+  VerifyUserAttributeException3["CodeMismatchException"] = "CodeMismatchException";
+  VerifyUserAttributeException3["ExpiredCodeException"] = "ExpiredCodeException";
+  VerifyUserAttributeException3["ForbiddenException"] = "ForbiddenException";
+  VerifyUserAttributeException3["InternalErrorException"] = "InternalErrorException";
+  VerifyUserAttributeException3["InvalidParameterException"] = "InvalidParameterException";
+  VerifyUserAttributeException3["LimitExceededException"] = "LimitExceededException";
+  VerifyUserAttributeException3["NotAuthorizedException"] = "NotAuthorizedException";
+  VerifyUserAttributeException3["PasswordResetRequiredException"] = "PasswordResetRequiredException";
+  VerifyUserAttributeException3["ResourceNotFoundException"] = "ResourceNotFoundException";
+  VerifyUserAttributeException3["TooManyRequestsException"] = "TooManyRequestsException";
+  VerifyUserAttributeException3["UserNotConfirmedException"] = "UserNotConfirmedException";
+  VerifyUserAttributeException3["UserNotFoundException"] = "UserNotFoundException";
+  return VerifyUserAttributeException3;
+})(VerifyUserAttributeException || {});
+var UpdateDeviceStatusException = /* @__PURE__ */ ((UpdateDeviceStatusException2) => {
+  UpdateDeviceStatusException2["ForbiddenException"] = "ForbiddenException";
+  UpdateDeviceStatusException2["InternalErrorException"] = "InternalErrorException";
+  UpdateDeviceStatusException2["InvalidParameterException"] = "InvalidParameterException";
+  UpdateDeviceStatusException2["InvalidUserPoolConfigurationException"] = "InvalidUserPoolConfigurationException";
+  UpdateDeviceStatusException2["NotAuthorizedException"] = "NotAuthorizedException";
+  UpdateDeviceStatusException2["PasswordResetRequiredException"] = "PasswordResetRequiredException";
+  UpdateDeviceStatusException2["ResourceNotFoundException"] = "ResourceNotFoundException";
+  UpdateDeviceStatusException2["TooManyRequestsException"] = "TooManyRequestsException";
+  UpdateDeviceStatusException2["UserNotConfirmedException"] = "UserNotConfirmedException";
+  UpdateDeviceStatusException2["UserNotFoundException"] = "UserNotFoundException";
+  return UpdateDeviceStatusException2;
+})(UpdateDeviceStatusException || {});
+var ListDevicesException = /* @__PURE__ */ ((ListDevicesException2) => {
+  ListDevicesException2["ForbiddenException"] = "ForbiddenException";
+  ListDevicesException2["InternalErrorException"] = "InternalErrorException";
+  ListDevicesException2["InvalidParameterException"] = "InvalidParameterException";
+  ListDevicesException2["InvalidUserPoolConfigurationException"] = "InvalidUserPoolConfigurationException";
+  ListDevicesException2["NotAuthorizedException"] = "NotAuthorizedException";
+  ListDevicesException2["PasswordResetRequiredException"] = "PasswordResetRequiredException";
+  ListDevicesException2["ResourceNotFoundException"] = "ResourceNotFoundException";
+  ListDevicesException2["TooManyRequestsException"] = "TooManyRequestsException";
+  ListDevicesException2["UserNotConfirmedException"] = "UserNotConfirmedException";
+  ListDevicesException2["UserNotFoundException"] = "UserNotFoundException";
+  return ListDevicesException2;
+})(ListDevicesException || {});
+var RevokeTokenException = /* @__PURE__ */ ((RevokeTokenException3) => {
+  RevokeTokenException3["ForbiddenException"] = "ForbiddenException";
+  RevokeTokenException3["InternalErrorException"] = "InternalErrorException";
+  RevokeTokenException3["InvalidParameterException"] = "InvalidParameterException";
+  RevokeTokenException3["TooManyRequestsException"] = "TooManyRequestsException";
+  RevokeTokenException3["UnauthorizedException"] = "UnauthorizedException";
+  RevokeTokenException3["UnsupportedOperationException"] = "UnsupportedOperationException";
+  RevokeTokenException3["UnsupportedTokenTypeException"] = "UnsupportedTokenTypeException";
+  return RevokeTokenException3;
+})(RevokeTokenException || {});
+var CognitoError = class extends Error {
+  constructor(message, errorType, cognitoException) {
+    super(message);
+    this.errorType = errorType;
+    this.cognitoException = cognitoException;
+  }
+};
+var CommonError = class extends CognitoError {
+  constructor(message, cognitoException) {
+    super(message, "CommonError", cognitoException);
+    this.cognitoException = cognitoException;
+  }
+};
+var InitAuthError = class extends CognitoError {
+  constructor(message, cognitoException) {
+    super(message, "InitAuthError", cognitoException);
+    this.cognitoException = cognitoException;
+  }
+};
+var RespondToAuthChallengeError = class extends CognitoError {
+  constructor(message, cognitoException) {
+    super(message, "RespondToAuthChallengeError", cognitoException);
+    this.cognitoException = cognitoException;
+  }
+};
+var SignUpError = class extends CognitoError {
+  constructor(message, cognitoException) {
+    super(message, "SignUpError", cognitoException);
+    this.cognitoException = cognitoException;
+  }
+};
+var ConfirmSignUpError = class extends CognitoError {
+  constructor(message, cognitoException) {
+    super(message, "ConfirmSignUpError", cognitoException);
+    this.cognitoException = cognitoException;
+  }
+};
+var ChangePasswordError = class extends CognitoError {
+  constructor(message, cognitoException) {
+    super(message, "ChangePasswordError", cognitoException);
+    this.cognitoException = cognitoException;
+  }
+};
+var RevokeTokenError = class extends CognitoError {
+  constructor(message, cognitoException) {
+    super(message, "RevokeTokenError", cognitoException);
+    this.cognitoException = cognitoException;
+  }
+};
+var ForgotPasswordError = class extends CognitoError {
+  constructor(message, cognitoException) {
+    super(message, "ForgotPasswordError", cognitoException);
+    this.cognitoException = cognitoException;
+  }
+};
+var ConfirmForgotPasswordError = class extends CognitoError {
+  constructor(message, cognitoException) {
+    super(message, "ConfirmForgotPasswordError", cognitoException);
+    this.cognitoException = cognitoException;
+  }
+};
+var ResendConfirmationCodeError = class extends CognitoError {
+  constructor(message, cognitoException) {
+    super(message, "ResendConfirmationCodeError", cognitoException);
+    this.cognitoException = cognitoException;
+  }
+};
+var UpdateUserAttributesError = class extends CognitoError {
+  constructor(message, cognitoException) {
+    super(message, "UpdateUserAttributesError", cognitoException);
+    this.cognitoException = cognitoException;
+  }
+};
+var VerifyUserAttributeError = class extends CognitoError {
+  constructor(message, cognitoException) {
+    super(message, "VerifyUserAttributeError", cognitoException);
+    this.cognitoException = cognitoException;
+  }
+};
+var GlobalSignOutError = class extends CognitoError {
+  constructor(message, cognitoException) {
+    super(message, "GlobalSignOutError", cognitoException);
+    this.cognitoException = cognitoException;
+  }
+};
+
+// src/bigint-math.ts
+var abs = (n) => n < 0n ? -n : n;
+function eGcd(a, b) {
+  if (typeof a === "number")
+    a = BigInt(a);
+  if (typeof b === "number")
+    b = BigInt(b);
+  if (a <= 0n || b <= 0n)
+    throw new RangeError("a and b MUST be > 0");
+  let x = 0n;
+  let y = 1n;
+  let u = 1n;
+  let v = 0n;
+  while (a !== 0n) {
+    const q = b / a;
+    const r = b % a;
+    const m = x - u * q;
+    const n = y - v * q;
+    b = a;
+    a = r;
+    x = u;
+    y = v;
+    u = m;
+    v = n;
+  }
+  return {
+    g: b,
+    x,
+    y
+  };
+}
+function modInv(a, n) {
+  const egcd = eGcd(toZn(a, n), n);
+  if (egcd.g !== 1n) {
+    throw new RangeError(`${a.toString()} does not have inverse modulo ${n.toString()}`);
+  } else {
+    return toZn(egcd.x, n);
+  }
+}
+function toZn(a, n) {
+  if (n <= 0n) {
+    throw new RangeError("n must be > 0");
+  }
+  const aZn = a % n;
+  return aZn < 0n ? aZn + n : aZn;
+}
+function modPow(b, e, n) {
+  if (n <= 0n) {
+    throw new RangeError("n must be > 0");
+  } else if (n === 1n) {
+    return 0n;
+  }
+  b = toZn(b, n);
+  if (e < 0n) {
+    return modInv(modPow(b, abs(e), n), n);
+  }
+  let r = 1n;
+  while (e > 0) {
+    if (e % 2n === 1n) {
+      r = r * b % n;
+    }
+    e = e / 2n;
+    b = b ** 2n % n;
+  }
+  return r;
+}
+
+// src/utils.ts
+var WEEK_DAYS = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"];
+var MONTHS = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"];
+function uint8ArrayFromHexString(hexString) {
+  return Uint8Array.from(hexString.match(/.{1,2}/g).map((byte) => parseInt(byte, 16)));
+}
+function uint8ArrayFromString(str) {
+  const textEncoder = new TextEncoder();
+  return textEncoder.encode(str);
+}
+function uint8ArrayFromBase64String(str) {
+  const binaryString = atob(str);
+  const bytes = new Uint8Array(binaryString.length);
+  for (let i = 0; i < binaryString.length; i++) {
+    bytes[i] = binaryString.charCodeAt(i);
+  }
+  return bytes;
+}
+function uint8ArrayToHexString(bytes) {
+  return bytes.reduce((str, byte) => str + byte.toString(16).padStart(2, "0"), "");
+}
+function uint8ArrayToBase64String(bytes) {
+  return btoa(String.fromCharCode(...bytes));
+}
+var N = BigInt(
+  "0xFFFFFFFFFFFFFFFFC90FDAA22168C234C4C6628B80DC1CD129024E088A67CC74020BBEA63B139B22514A08798E3404DDEF9519B3CD3A431B302B0A6DF25F14374FE1356D6D51C245E485B576625E7EC6F44C42E9A637ED6B0BFF5CB6F406B7EDEE386BFB5A899FA5AE9F24117C4B1FE649286651ECE45B3DC2007CB8A163BF0598DA48361C55D39A69163FA8FD24CF5F83655D23DCA3AD961C62F356208552BB9ED529077096966D670C354E4ABC9804F1746C08CA18217C32905E462E36CE3BE39E772C180E86039B2783A2EC07A28FB5C55DF06F4C52C9DE2BCBF6955817183995497CEA956AE515D2261898FA051015728E5A8AAAC42DAD33170D04507A33A85521ABDF1CBA64ECFB850458DBEF0A8AEA71575D060C7DB3970F85A6E1E4C7ABF5AE8CDB0933D71E8C94E04A25619DCEE3D2261AD2EE6BF12FFA06D98A0864D87602733EC86A64521F2B18177B200CBBE117577A615D6C770988C0BAD946E208E24FA074E5AB3143DB5BFCE0FD108E4B82D120A93AD2CAFFFFFFFFFFFFFFFF"
+);
+var g = BigInt("0x2");
+var k = BigInt("0x538282c4354742d7cbbde2359fcf67f9f5b3a6b08791e5011b43b8a5b66d9ee6");
+function padHex(bigInt) {
+  const HEX_MSB_REGEX = /^[89a-f]/i;
+  const isNegative = bigInt < 0n;
+  let hexStr = abs(bigInt).toString(16);
+  hexStr = hexStr.length % 2 !== 0 ? `0${hexStr}` : hexStr;
+  hexStr = HEX_MSB_REGEX.test(hexStr) ? `00${hexStr}` : hexStr;
+  if (isNegative) {
+    const invertedNibbles = hexStr.split("").map((x) => {
+      const invertedNibble = ~parseInt(x, 16) & 15;
+      return "0123456789ABCDEF".charAt(invertedNibble);
+    }).join("");
+    const flippedBitsBI = BigInt("0x" + invertedNibbles) + 1n;
+    hexStr = flippedBitsBI.toString(16);
+    if (hexStr.toUpperCase().startsWith("FF8")) {
+      hexStr = hexStr.substring(2);
+    }
+  }
+  return hexStr;
+}
+async function hashHexString(str) {
+  return hashBuffer(uint8ArrayFromHexString(str));
+}
+async function hashBuffer(buffer) {
+  const hashArray = await digest("SHA-256", buffer);
+  return uint8ArrayToHexString(hashArray);
+}
+async function generateSmallA() {
+  return BigInt("0x" + (await randomBytes(128)).toString("hex"));
+}
+function generateA(smallA) {
+  const A = modPow(g, smallA, N);
+  return A;
+}
+async function calculateU(A, B) {
+  return BigInt("0x" + await hashHexString(padHex(A) + padHex(B)));
+}
+function calculateS(X, B, U, smallA) {
+  const gModPowXN = modPow(g, X, N);
+  const bMinusKMult = B - k * gModPowXN;
+  return modPow(bMinusKMult, smallA + U * X, N) % N;
+}
+async function calculateHKDF(ikm, salt) {
+  const infoBitsBuffer = new Uint8Array([
+    ...uint8ArrayFromString("Caldera Derived Key"),
+    ...uint8ArrayFromString(String.fromCharCode(1))
+  ]);
+  const prk = await hmac("SHA-256", salt, ikm);
+  const hmacResult = await hmac("SHA-256", prk, infoBitsBuffer);
+  return hmacResult.slice(0, 16);
+}
+async function getPasswordAuthenticationKey(poolName, username, password, B, U, smallA, salt) {
+  const usernamePassword = `${poolName}${username}:${password}`;
+  const usernamePasswordHash = await hashBuffer(uint8ArrayFromString(usernamePassword));
+  const X = BigInt("0x" + await hashHexString(padHex(salt) + usernamePasswordHash));
+  const S = calculateS(X, B, U, smallA);
+  return calculateHKDF(uint8ArrayFromHexString(padHex(S)), uint8ArrayFromHexString(padHex(U)));
+}
+async function calculateSignature(poolName, userId, secretBlock, hkdf, date = /* @__PURE__ */ new Date()) {
+  const timeStamp = formatTimestamp(date);
+  const concatBuffer = new Uint8Array([
+    ...uint8ArrayFromString(poolName),
+    ...uint8ArrayFromString(userId),
+    ...uint8ArrayFromBase64String(secretBlock),
+    ...uint8ArrayFromString(timeStamp)
+  ]);
+  const signature = uint8ArrayToBase64String(await hmac("SHA-256", hkdf, concatBuffer));
+  return {
+    signature,
+    timeStamp
+  };
+}
+function decodeJwt(jwt) {
+  const [header, payload, signature] = jwt.split(".");
+  return {
+    header: JSON.parse(Buffer.from(header, "base64").toString("utf-8")),
+    payload: JSON.parse(Buffer.from(payload, "base64").toString("utf-8")),
+    signature
+  };
+}
+async function randomBytes(num) {
+  return Buffer.from(crypto.getRandomValues(new Uint8Array(num)));
+}
+function formatTimestamp(date) {
+  return `${WEEK_DAYS[date.getUTCDay()]} ${MONTHS[date.getUTCMonth()]} ${date.getUTCDate()} ${date.getUTCHours().toString().padStart(2, "0")}:${date.getUTCMinutes().toString().padStart(2, "0")}:${date.getUTCSeconds().toString().padStart(2, "0")} UTC ${date.getUTCFullYear()}`;
+}
+async function calculateSecretHash(clientSecret, userPoolClientId, username) {
+  const message = `${username}${userPoolClientId}`;
+  const hash = uint8ArrayToBase64String(
+    await hmac("SHA-256", uint8ArrayFromString(clientSecret), uint8ArrayFromString(message))
+  );
+  return hash;
+}
+async function digest(algorithm, data) {
+  const hashBuffer2 = await crypto.subtle.digest(algorithm, data);
+  return new Uint8Array(hashBuffer2);
+}
+async function hmac(algorithm, key, data) {
+  const cryptoKey = await crypto.subtle.importKey(
+    "raw",
+    key,
+    {
+      name: "HMAC",
+      hash: algorithm
+    },
+    false,
+    ["sign"]
+  );
+  const signature = await crypto.subtle.sign("HMAC", cryptoKey, data);
+  return new Uint8Array(signature);
+}
+
+// src/cognito-client.ts
+var ServiceTarget = /* @__PURE__ */ ((ServiceTarget2) => {
+  ServiceTarget2["InitiateAuth"] = "InitiateAuth";
+  ServiceTarget2["RespondToAuthChallenge"] = "RespondToAuthChallenge";
+  ServiceTarget2["SignUp"] = "SignUp";
+  ServiceTarget2["ConfirmSignUp"] = "ConfirmSignUp";
+  ServiceTarget2["ChangePassword"] = "ChangePassword";
+  ServiceTarget2["RevokeToken"] = "RevokeToken";
+  ServiceTarget2["ForgotPassword"] = "ForgotPassword";
+  ServiceTarget2["ConfirmForgotPassword"] = "ConfirmForgotPassword";
+  ServiceTarget2["ResendConfirmationCode"] = "ResendConfirmationCode";
+  ServiceTarget2["UpdateUserAttributes"] = "UpdateUserAttributes";
+  ServiceTarget2["VerifyUserAttribute"] = "VerifyUserAttribute";
+  ServiceTarget2["GlobalSignOut"] = "GlobalSignOut";
+  return ServiceTarget2;
+})(ServiceTarget || {});
+var IdentityProvider = /* @__PURE__ */ ((IdentityProvider2) => {
+  IdentityProvider2["Cognito"] = "COGNITO";
+  IdentityProvider2["Google"] = "Google";
+  IdentityProvider2["Facebook"] = "Facebook";
+  IdentityProvider2["Amazon"] = "LoginWithAmazon";
+  IdentityProvider2["Apple"] = "SignInWithApple";
+  return IdentityProvider2;
+})(IdentityProvider || {});
+function authResultToSession(authenticationResult) {
+  return {
+    accessToken: authenticationResult.AccessToken,
+    idToken: authenticationResult.IdToken,
+    expiresIn: (/* @__PURE__ */ new Date()).getTime() + authenticationResult.ExpiresIn * 1e3,
+    refreshToken: authenticationResult.RefreshToken
+  };
+}
+async function cognitoRequest(body, serviceTarget, cognitoEndpoint) {
+  const cognitoResponse = await fetch(cognitoEndpoint, {
+    headers: {
+      "x-amz-target": `AWSCognitoIdentityProviderService.${serviceTarget}`,
+      "content-type": "application/x-amz-json-1.1"
+    },
+    method: "POST",
+    body: JSON.stringify(body)
+  });
+  if (cognitoResponse && cognitoResponse.status < 300) {
+    return cognitoResponse.json();
+  }
+  const cognitoResponseBody = await cognitoResponse.json();
+  const sanitizeErrorType = (rawValue) => {
+    const [cleanValue] = rawValue.toString().split(/[,:]+/);
+    if (cleanValue.includes("#")) {
+      return cleanValue.split("#")[1];
+    }
+    return cleanValue;
+  };
+  const errorMessage = cognitoResponse.headers.get("X-Amzn-ErrorMessage") ?? cognitoResponseBody.message ?? cognitoResponseBody.Message ?? "Unknown error";
+  const cognitoException = sanitizeErrorType(
+    cognitoResponse.headers.get("X-Amzn-ErrorType") ?? cognitoResponseBody.code ?? cognitoResponseBody.__type ?? "Unknown"
+  );
+  if (COMMON_EXCEPTIONS.includes(cognitoException)) {
+    throw new CommonError(errorMessage, cognitoException);
+  }
+  switch (serviceTarget) {
+    case "InitiateAuth" /* InitiateAuth */:
+      throw new InitAuthError(errorMessage, cognitoException);
+    case "RespondToAuthChallenge" /* RespondToAuthChallenge */:
+      throw new RespondToAuthChallengeError(errorMessage, cognitoException);
+    case "SignUp" /* SignUp */:
+      throw new SignUpError(errorMessage, cognitoException);
+    case "ConfirmSignUp" /* ConfirmSignUp */:
+      throw new ConfirmSignUpError(errorMessage, cognitoException);
+    case "ChangePassword" /* ChangePassword */:
+      throw new ChangePasswordError(errorMessage, cognitoException);
+    case "RevokeToken" /* RevokeToken */:
+      throw new RevokeTokenError(errorMessage, cognitoException);
+    case "ForgotPassword" /* ForgotPassword */:
+      throw new ForgotPasswordError(errorMessage, cognitoException);
+    case "ConfirmForgotPassword" /* ConfirmForgotPassword */:
+      throw new ConfirmForgotPasswordError(errorMessage, cognitoException);
+    case "ResendConfirmationCode" /* ResendConfirmationCode */:
+      throw new ResendConfirmationCodeError(errorMessage, cognitoException);
+    case "UpdateUserAttributes" /* UpdateUserAttributes */:
+      throw new UpdateUserAttributesError(errorMessage, cognitoException);
+    case "VerifyUserAttribute" /* VerifyUserAttribute */:
+      throw new VerifyUserAttributeError(errorMessage, cognitoException);
+    case "GlobalSignOut" /* GlobalSignOut */:
+      throw new GlobalSignOutError(errorMessage, cognitoException);
+  }
+}
+var CognitoClient = class {
+  constructor({ userPoolId, userPoolClientId, endpoint, oAuth2: oAuth, clientSecret }) {
+    const [cognitoPoolRegion, cognitoPoolName] = userPoolId.split("_");
+    this.cognitoEndpoint = (endpoint || `https://cognito-idp.${cognitoPoolRegion}.amazonaws.com`).replace(/\/$/, "");
+    this.cognitoPoolName = cognitoPoolName;
+    this.userPoolClientId = userPoolClientId;
+    this.oAuth = oAuth;
+    this.clientSecret = clientSecret;
+  }
+  static getDecodedTokenFromSession(session) {
+    const { payload: idToken } = decodeJwt(session.idToken);
+    const { payload: accessToken } = decodeJwt(session.accessToken);
+    return {
+      idToken,
+      accessToken
+    };
+  }
+  /**
+   *
+   * Performs user authentication with username and password through ALLOW_USER_SRP_AUTH .
+   * @see https://docs.aws.amazon.com/cognito/latest/developerguide/amazon-cognito-user-pools-authentication-flow.html for more details
+   *
+   * @param username Username
+   * @param password Password
+   *
+   * @throws {InitAuthError, CognitoRespondToAuthChallengeError}
+   */
+  async authenticateUserSrp(username, password) {
+    const smallA = await generateSmallA();
+    const A = generateA(smallA);
+    const initiateAuthPayload = {
+      AuthFlow: "USER_SRP_AUTH",
+      ClientId: this.userPoolClientId,
+      AuthParameters: {
+        USERNAME: username,
+        SRP_A: A.toString(16),
+        SECRET_HASH: this.clientSecret && await calculateSecretHash(this.clientSecret, this.userPoolClientId, username)
+      },
+      ClientMetadata: {}
+    };
+    const challenge = await cognitoRequest(
+      initiateAuthPayload,
+      "InitiateAuth" /* InitiateAuth */,
+      this.cognitoEndpoint
+    );
+    const B = BigInt("0x" + challenge.ChallengeParameters.SRP_B);
+    const salt = BigInt("0x" + challenge.ChallengeParameters.SALT);
+    const U = await calculateU(A, B);
+    const hkdf = await getPasswordAuthenticationKey(
+      this.cognitoPoolName,
+      challenge.ChallengeParameters.USER_ID_FOR_SRP,
+      password,
+      B,
+      U,
+      smallA,
+      salt
+    );
+    const { signature, timeStamp } = await calculateSignature(
+      this.cognitoPoolName,
+      challenge.ChallengeParameters.USER_ID_FOR_SRP,
+      challenge.ChallengeParameters.SECRET_BLOCK,
+      hkdf
+    );
+    const respondToAuthChallengeRequest = {
+      ChallengeName: "PASSWORD_VERIFIER",
+      ClientId: this.userPoolClientId,
+      ChallengeResponses: {
+        PASSWORD_CLAIM_SECRET_BLOCK: challenge.ChallengeParameters.SECRET_BLOCK,
+        PASSWORD_CLAIM_SIGNATURE: signature,
+        USERNAME: challenge.ChallengeParameters.USER_ID_FOR_SRP,
+        TIMESTAMP: timeStamp,
+        SECRET_HASH: this.clientSecret && await calculateSecretHash(
+          this.clientSecret,
+          this.userPoolClientId,
+          challenge.ChallengeParameters.USER_ID_FOR_SRP
+        )
+      },
+      ClientMetadata: {}
+    };
+    const { AuthenticationResult } = await cognitoRequest(
+      respondToAuthChallengeRequest,
+      "RespondToAuthChallenge" /* RespondToAuthChallenge */,
+      this.cognitoEndpoint
+    );
+    return authResultToSession(AuthenticationResult);
+  }
+  /**
+   *
+   * Performs user authentication with username and password through USER_PASSWORD_AUTH .
+   * @see https://docs.aws.amazon.com/cognito/latest/developerguide/amazon-cognito-user-pools-authentication-flow.html for more details
+   *
+   * @param username Username
+   * @param password Password
+   * @throws {InitAuthError}
+   */
+  async authenticateUser(username, password) {
+    const initiateAuthPayload = {
+      AuthFlow: "USER_PASSWORD_AUTH",
+      ClientId: this.userPoolClientId,
+      AuthParameters: {
+        USERNAME: username,
+        PASSWORD: password,
+        SECRET_HASH: this.clientSecret && await calculateSecretHash(this.clientSecret, this.userPoolClientId, username)
+      },
+      ClientMetadata: {}
+    };
+    const { AuthenticationResult } = await cognitoRequest(
+      initiateAuthPayload,
+      "InitiateAuth" /* InitiateAuth */,
+      this.cognitoEndpoint
+    );
+    const session = authResultToSession(AuthenticationResult);
+    return session;
+  }
+  /**
+   * Returns a new session based on the given refresh token.
+   *
+   * @param refreshToken  Refresh token from a previous session.
+   * @param username Username is required when using a client secret and needs to be the cognito user id.
+   * @returns @see Session
+   * @throws {InitAuthError}
+   */
+  async refreshSession(refreshToken, username) {
+    const refreshTokenPayload = {
+      AuthFlow: "REFRESH_TOKEN_AUTH",
+      ClientId: this.userPoolClientId,
+      AuthParameters: {
+        REFRESH_TOKEN: refreshToken,
+        SECRET_HASH: this.clientSecret && username && await calculateSecretHash(this.clientSecret, this.userPoolClientId, username)
+      },
+      ClientMetadata: {}
+    };
+    const { AuthenticationResult } = await cognitoRequest(
+      refreshTokenPayload,
+      "InitiateAuth" /* InitiateAuth */,
+      this.cognitoEndpoint
+    );
+    if (!AuthenticationResult.RefreshToken) {
+      AuthenticationResult.RefreshToken = refreshToken;
+    }
+    return authResultToSession(AuthenticationResult);
+  }
+  /**
+   *
+   * @param username Username
+   * @param password Password
+   *
+   * @throws {SignUpError}
+   */
+  async signUp(username, password, userAttributes) {
+    const signUpRequest = {
+      ClientId: this.userPoolClientId,
+      Username: username,
+      Password: password,
+      UserAttributes: userAttributes,
+      SecretHash: this.clientSecret && await calculateSecretHash(this.clientSecret, this.userPoolClientId, username)
+    };
+    const data = await cognitoRequest(signUpRequest, "SignUp" /* SignUp */, this.cognitoEndpoint);
+    return {
+      id: data.UserSub,
+      confirmed: data.UserConfirmed
+    };
+  }
+  /**
+   * Confirms the user registration via verification code.
+   *
+   * @param username Username
+   * @param code Confirmation code the user gets through the registration E-Mail
+   *
+   * @throws {ConfirmSignUpError}
+   */
+  async confirmSignUp(username, code) {
+    const confirmSignUpRequest = {
+      ClientId: this.userPoolClientId,
+      ConfirmationCode: code,
+      Username: username,
+      SecretHash: this.clientSecret && await calculateSecretHash(this.clientSecret, this.userPoolClientId, username)
+    };
+    await cognitoRequest(confirmSignUpRequest, "ConfirmSignUp" /* ConfirmSignUp */, this.cognitoEndpoint);
+  }
+  /**
+   *
+   * @param currentPassword Current user password.
+   * @param newPassword  New user password.
+   *
+   * @throws {ChangePasswordError}
+   */
+  async changePassword(currentPassword, newPassword, accessToken) {
+    const changePasswordPayload = {
+      PreviousPassword: currentPassword,
+      ProposedPassword: newPassword,
+      AccessToken: accessToken
+    };
+    await cognitoRequest(changePasswordPayload, "ChangePassword" /* ChangePassword */, this.cognitoEndpoint);
+  }
+  /**
+   * Updates the user attributes.
+   *
+   * @param userAttributes List of user attributes to update.
+   * @param accessToken Access token of the current user.
+   *
+   * @throws {UpdateUserAttributesError}
+   */
+  async updateUserAttributes(userAttributes, accessToken) {
+    const updateUserAttributesPayload = {
+      UserAttributes: userAttributes,
+      AccessToken: accessToken
+    };
+    await cognitoRequest(updateUserAttributesPayload, "UpdateUserAttributes" /* UpdateUserAttributes */, this.cognitoEndpoint);
+  }
+  /**
+   * Verifies a given user attribute
+   *
+   * @param attributeName Name of the attribute to verify
+   * @param code  Verification code
+   * @param accessToken Access token of the current user.
+   *
+   * @throws {VerifyUserAttributeError}
+   */
+  async verifyUserAttribute(attributeName, code, accessToken) {
+    const verifyUserAttributePayload = {
+      AttributeName: attributeName,
+      Code: code,
+      AccessToken: accessToken
+    };
+    await cognitoRequest(verifyUserAttributePayload, "VerifyUserAttribute" /* VerifyUserAttribute */, this.cognitoEndpoint);
+  }
+  /**
+   * Revokes all of the access tokens generated by, and at the same time as, the specified refresh token. After a token is revoked, you can't use the revoked token to access Amazon Cognito user APIs, or to authorize access to your resource server.
+   *
+   * @param refreshToken Refresh token from a previous session.
+   * @param username Username is required when using a client secret and needs to be the cognito user id.
+   * @throws {RevokeTokenError}
+   */
+  async revokeToken(refreshToken) {
+    const revokeTokenPayload = {
+      Token: refreshToken,
+      ClientId: this.userPoolClientId,
+      ClientSecret: this.clientSecret
+    };
+    await cognitoRequest(revokeTokenPayload, "RevokeToken" /* RevokeToken */, this.cognitoEndpoint);
+  }
+  /**
+   * Request forgot password.
+   * @param username Username
+   *
+   * @throws {ForgotPasswordError}
+   */
+  async forgotPassword(username) {
+    const forgotPasswordRequest = {
+      ClientId: this.userPoolClientId,
+      Username: username,
+      SecretHash: this.clientSecret && await calculateSecretHash(this.clientSecret, this.userPoolClientId, username)
+    };
+    await cognitoRequest(forgotPasswordRequest, "ForgotPassword" /* ForgotPassword */, this.cognitoEndpoint);
+  }
+  /**
+   * Confirms the new password via the given code send via cognito triggered by @see forgotPassword .
+   *
+   * @param username Username
+   * @param newPassword New password
+   * @param confirmationCode Confirmation code which the user got through E-mail
+   *
+   * @throws {ConfirmForgotPasswordError}
+   */
+  async confirmForgotPassword(username, newPassword, confirmationCode) {
+    const confirmForgotPasswordRequest = {
+      ClientId: this.userPoolClientId,
+      Username: username,
+      ConfirmationCode: confirmationCode,
+      Password: newPassword,
+      SecretHash: this.clientSecret && await calculateSecretHash(this.clientSecret, this.userPoolClientId, username)
+    };
+    await cognitoRequest(confirmForgotPasswordRequest, "ConfirmForgotPassword" /* ConfirmForgotPassword */, this.cognitoEndpoint);
+  }
+  /**
+   * Triggers cognito to resend the confirmation code
+   * @param username Username
+   *
+   * @throws {ResendConfirmationCodeError}
+   */
+  async resendConfirmationCode(username) {
+    const resendConfirmationCodeRequest = {
+      ClientId: this.userPoolClientId,
+      Username: username,
+      SecretHash: this.clientSecret && await calculateSecretHash(this.clientSecret, this.userPoolClientId, username)
+    };
+    await cognitoRequest(resendConfirmationCodeRequest, "ResendConfirmationCode" /* ResendConfirmationCode */, this.cognitoEndpoint);
+  }
+  /**
+   * Returns a link to Cognito`s Hosted UI for OAuth2 authentication.
+   * This method works in conjunction with @see handleCodeFlow .
+   *
+   * @param identityProvider When provided, this will generate a link which
+   * tells Cognito`s Hosted UI to redirect to the given federated identity provider.
+   *
+   * @throws {Error}
+   */
+  async generateOAuthSignInUrl(identityProvider) {
+    if (this.oAuth === void 0) {
+      throw Error("You have to define oAuth options to use generateFederatedSignUrl");
+    }
+    const state = (await randomBytes(32)).toString("hex");
+    const pkce = (await randomBytes(128)).toString("hex");
+    const code_challenge = uint8ArrayToBase64String(await digest("SHA-256", uint8ArrayFromString(pkce))).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+    const queryParams = new URLSearchParams();
+    queryParams.append("redirect_uri", this.oAuth.redirectUrl);
+    queryParams.append("response_type", this.oAuth.responseType);
+    queryParams.append("client_id", this.userPoolClientId);
+    identityProvider && queryParams.append("identity_provider", identityProvider);
+    queryParams.append("scope", this.oAuth.scopes.join(" "));
+    queryParams.append("state", state);
+    queryParams.append("code_challenge", code_challenge);
+    queryParams.append("code_challenge_method", "S256");
+    return {
+      url: `${this.oAuth.cognitoDomain}/oauth2/authorize?${queryParams.toString()}`,
+      state,
+      pkce
+    };
+  }
+  /**
+   *
+   * Handles Cognito`s OAuth2 code flow after redirection from Cognito`s Hosted UI.
+   * The method call assumes that @see generateOAuthSignInUrl was used to
+   * generated the link to the Hosted UI.
+   *
+   * @param returnUrl The full return URL from redirection after a successful OAuth2
+   * authentication.
+   *
+   * @throws {Error}
+   */
+  async handleCodeFlow(returnUrl, pkce) {
+    if (this.oAuth === void 0) {
+      throw Error("You have to define oAuth options to use handleCodeFlow");
+    }
+    const url = new URL(returnUrl);
+    const code = url.searchParams.get("code");
+    const state = url.searchParams.get("state");
+    if (code === null || state === null) {
+      throw Error("code or state parameter is missing from return url.");
+    }
+    const urlParams = new URLSearchParams();
+    urlParams.append("grant_type", "authorization_code");
+    urlParams.append("code", code);
+    urlParams.append("client_id", this.userPoolClientId);
+    urlParams.append("redirect_uri", this.oAuth.redirectUrl);
+    urlParams.append("code_verifier", pkce);
+    const tokenEndpoint = `${this.oAuth.cognitoDomain}/oauth2/token`;
+    const response = await fetch(tokenEndpoint, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/x-www-form-urlencoded"
+      },
+      body: urlParams.toString()
+    });
+    const { access_token, refresh_token, id_token, expires_in, error } = await response.json();
+    if (error) {
+      throw new Error(error);
+    }
+    const session = authResultToSession({
+      AccessToken: access_token,
+      RefreshToken: refresh_token,
+      IdToken: id_token,
+      ExpiresIn: expires_in
+    });
+    return session;
+  }
+  /**
+   * Invalidates the identity, access, and refresh tokens that Amazon Cognito issued to a user. Call this operation when your user signs out of your app. This results in the following behavior.
+   * @param accessToken Access token of the current user.
+   */
+  async globalSignOut(accessToken) {
+    const globalSignOutPayload = {
+      AccessToken: accessToken
+    };
+    await cognitoRequest(globalSignOutPayload, "GlobalSignOut" /* GlobalSignOut */, this.cognitoEndpoint);
+  }
+};
+export {
+  AssociateSoftwareTokenException,
+  COMMON_EXCEPTIONS,
+  ChangePasswordError,
+  ChangePasswordException,
+  CognitoClient,
+  CognitoError,
+  CommonError,
+  CommonException,
+  ConfirmDeviceException,
+  ConfirmForgotPasswordError,
+  ConfirmForgotPasswordException,
+  ConfirmSignUpError,
+  ConfirmSignUpException,
+  DeleteUserAttributesException,
+  DeleteUserException,
+  ForgetDeviceException,
+  ForgotPasswordError,
+  ForgotPasswordException,
+  GetCredentialsForIdentityException,
+  GetIdException,
+  GetUserAttributeVerificationException,
+  GetUserException,
+  GlobalSignOutError,
+  GlobalSignOutException,
+  IdentityProvider,
+  InitAuthError,
+  InitiateAuthException,
+  ListDevicesException,
+  ResendConfirmationCodeError,
+  ResendConfirmationException,
+  RespondToAuthChallengeError,
+  RespondToAuthChallengeException,
+  RevokeTokenError,
+  RevokeTokenException,
+  ServiceTarget,
+  SetUserMFAPreferenceException,
+  SignUpError,
+  SignUpException,
+  UpdateDeviceStatusException,
+  UpdateUserAttributesError,
+  UpdateUserAttributesException,
+  VerifySoftwareTokenException,
+  VerifyUserAttributeError,
+  VerifyUserAttributeException,
+  authResultToSession,
+  cognitoRequest
+};