{"version":3,"sources":["../../../src/model/enum_maps.ts","../../../src/core/errors.ts","../../../src/core/util/log.ts","../../../src/core/util/assert.ts","../../../src/core/util/instantiator.ts","../../../src/core/auth/initialize.ts","../../../src/core/util/location.ts","../../../src/core/util/navigator.ts","../../../src/core/util/delay.ts","../../../src/core/util/emulator.ts","../../../src/core/util/fetch_provider.ts","../../../src/api/errors.ts","../../../src/api/index.ts","../../../src/api/account_management/account.ts","../../../src/core/util/time.ts","../../../src/core/user/id_token_result.ts","../../../src/core/user/invalidation.ts","../../../src/core/user/proactive_refresh.ts","../../../src/core/user/user_metadata.ts","../../../src/core/user/reload.ts","../../../src/api/authentication/token.ts","../../../src/core/user/token_manager.ts","../../../src/core/user/user_impl.ts","../../../src/core/persistence/in_memory.ts","../../../src/core/persistence/persistence_user_manager.ts","../../../src/core/util/browser.ts","../../../src/core/util/version.ts","../../../src/core/auth/middleware.ts","../../../src/core/auth/auth_impl.ts","../../../src/core/auth/emulator.ts","../../../src/core/credentials/auth_credential.ts","../../../src/api/account_management/email_and_password.ts","../../../src/api/authentication/email_and_password.ts","../../../src/api/authentication/email_link.ts","../../../src/core/credentials/email.ts","../../../src/api/authentication/idp.ts","../../../src/core/credentials/oauth.ts","../../../src/api/authentication/sms.ts","../../../src/core/credentials/phone.ts","../../../src/core/action_code_url.ts","../../../src/core/providers/email.ts","../../../src/core/providers/federated.ts","../../../src/core/providers/oauth.ts","../../../src/core/providers/facebook.ts","../../../src/core/providers/google.ts","../../../src/core/providers/github.ts","../../../src/core/credentials/saml.ts","../../../src/core/providers/saml.ts","../../../src/core/providers/twitter.ts","../../../src/api/authentication/sign_up.ts","../../../src/core/user/user_credential_impl.ts","../../../src/core/strategies/anonymous.ts","../../../src/mfa/mfa_error.ts","../../../src/core/util/providers.ts","../../../src/core/user/link_unlink.ts","../../../src/core/user/reauthenticate.ts","../../../src/core/strategies/credential.ts","../../../src/api/authentication/custom_token.ts","../../../src/core/strategies/custom_token.ts","../../../src/mfa/mfa_info.ts","../../../src/core/strategies/action_code_settings.ts","../../../src/core/strategies/email_and_password.ts","../../../src/core/strategies/email_link.ts","../../../src/api/authentication/create_auth_uri.ts","../../../src/core/strategies/email.ts","../../../src/api/account_management/profile.ts","../../../src/core/user/account_info.ts","../../../src/core/user/additional_user_info.ts","../../../src/core/index.ts","../../../src/mfa/mfa_session.ts","../../../src/mfa/mfa_resolver.ts","../../../src/api/account_management/mfa.ts","../../../src/mfa/mfa_user.ts","../../../src/core/persistence/index.ts","../../../src/platform_browser/persistence/browser.ts","../../../src/platform_browser/persistence/local_storage.ts","../../../src/platform_browser/persistence/session_storage.ts","../../../src/platform_browser/messagechannel/promise.ts","../../../src/platform_browser/messagechannel/receiver.ts","../../../src/core/util/event_id.ts","../../../src/platform_browser/messagechannel/sender.ts","../../../src/platform_browser/auth_window.ts","../../../src/platform_browser/util/worker.ts","../../../src/platform_browser/persistence/indexed_db.ts","../../../src/api/authentication/mfa.ts","../../../src/api/authentication/recaptcha.ts","../../../src/platform_browser/load_js.ts","../../../src/platform_browser/recaptcha/recaptcha_mock.ts","../../../src/platform_browser/recaptcha/recaptcha_loader.ts","../../../src/platform_browser/recaptcha/recaptcha_verifier.ts","../../../src/platform_browser/strategies/phone.ts","../../../src/platform_browser/providers/phone.ts","../../../src/core/util/resolver.ts","../../../src/core/strategies/idp.ts","../../../src/core/strategies/abstract_popup_redirect_operation.ts","../../../src/platform_browser/strategies/popup.ts","../../../src/core/strategies/redirect.ts","../../../src/platform_browser/strategies/redirect.ts","../../../src/core/auth/auth_event_manager.ts","../../../src/api/project_config/get_project_config.ts","../../../src/core/util/validate_origin.ts","../../../src/platform_browser/iframe/gapi.ts","../../../src/platform_browser/iframe/iframe.ts","../../../src/platform_browser/util/popup.ts","../../../src/core/util/handler.ts","../../../src/platform_browser/popup_redirect.ts","../../../src/mfa/mfa_assertion.ts","../../../src/platform_browser/mfa/assertions/phone.ts","../../../src/core/auth/firebase_internal.ts","../../../src/core/auth/register.ts","../../../src/platform_browser/index.ts"],"names":["applyActionCode","sendEmailVerification","sendPasswordResetEmail","sendSignInLinkToEmail","signInWithEmailLink","IDP_REQUEST_URI","signInWithPhoneNumber","linkWithPhoneNumber","_link","signInWithCustomToken","getIdTokenResponse","authentication.sendPasswordResetEmail","account.resetPassword","account.applyActionCode","api.sendSignInLinkToEmail","api.sendEmailVerification","api.verifyAndChangeEmail","updateProfile","apiUpdateProfile","apiUpdateEmailPassword","_POLLING_INTERVAL_MS","jsHelpers._generateCallbackName","jsHelpers._loadJS","_linkUser","js._generateCallbackName","js._loadJS","gapiLoader._loadGapi"],"mappings":"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","file":"static/js/vendors~main~6515efb7.3a703ffd.chunk.js","sourcesContent":["/**\n * @license\n * Copyright 2021 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n/**\n * An enum of factors that may be used for multifactor authentication.\n *\n * @public\n */\nexport const FactorId = {\n  /** Phone as second factor */\n  PHONE: 'phone'\n} as const;\n\n/**\n * Enumeration of supported providers.\n *\n * @public\n */\nexport const ProviderId = {\n  /** Facebook provider ID */\n  FACEBOOK: 'facebook.com',\n  /** GitHub provider ID */\n  GITHUB: 'github.com',\n  /** Google provider ID */\n  GOOGLE: 'google.com',\n  /** Password provider */\n  PASSWORD: 'password',\n  /** Phone provider */\n  PHONE: 'phone',\n  /** Twitter provider ID */\n  TWITTER: 'twitter.com'\n} as const;\n\n/**\n * Enumeration of supported sign-in methods.\n *\n * @public\n */\nexport const SignInMethod = {\n  /** Email link sign in method */\n  EMAIL_LINK: 'emailLink',\n  /** Email/password sign in method */\n  EMAIL_PASSWORD: 'password',\n  /** Facebook sign in method */\n  FACEBOOK: 'facebook.com',\n  /** GitHub sign in method */\n  GITHUB: 'github.com',\n  /** Google sign in method */\n  GOOGLE: 'google.com',\n  /** Phone sign in method */\n  PHONE: 'phone',\n  /** Twitter sign in method */\n  TWITTER: 'twitter.com'\n} as const;\n\n/**\n * Enumeration of supported operation types.\n *\n * @public\n */\nexport const OperationType = {\n  /** Operation involving linking an additional provider to an already signed-in user. */\n  LINK: 'link',\n  /** Operation involving using a provider to reauthenticate an already signed-in user. */\n  REAUTHENTICATE: 'reauthenticate',\n  /** Operation involving signing in a user. */\n  SIGN_IN: 'signIn'\n} as const;\n\n/**\n * An enumeration of the possible email action types.\n *\n * @public\n */\nexport const ActionCodeOperation = {\n  /** The email link sign-in action. */\n  EMAIL_SIGNIN: 'EMAIL_SIGNIN',\n  /** The password reset action. */\n  PASSWORD_RESET: 'PASSWORD_RESET',\n  /** The email revocation action. */\n  RECOVER_EMAIL: 'RECOVER_EMAIL',\n  /** The revert second factor addition email action. */\n  REVERT_SECOND_FACTOR_ADDITION: 'REVERT_SECOND_FACTOR_ADDITION',\n  /** The revert second factor addition email action. */\n  VERIFY_AND_CHANGE_EMAIL: 'VERIFY_AND_CHANGE_EMAIL',\n  /** The email verification action. */\n  VERIFY_EMAIL: 'VERIFY_EMAIL'\n} as const;\n","/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { AuthErrorMap, User } from '../model/public_types';\nimport { ErrorFactory, ErrorMap } from '@firebase/util';\n\nimport { IdTokenMfaResponse } from '../api/authentication/mfa';\nimport { AppName } from '../model/auth';\nimport { AuthCredential } from './credentials';\n\n/**\n * Enumeration of Firebase Auth error codes.\n * \n * @internal\n */\nexport const enum AuthErrorCode {\n  ADMIN_ONLY_OPERATION = 'admin-restricted-operation',\n  ARGUMENT_ERROR = 'argument-error',\n  APP_NOT_AUTHORIZED = 'app-not-authorized',\n  APP_NOT_INSTALLED = 'app-not-installed',\n  CAPTCHA_CHECK_FAILED = 'captcha-check-failed',\n  CODE_EXPIRED = 'code-expired',\n  CORDOVA_NOT_READY = 'cordova-not-ready',\n  CORS_UNSUPPORTED = 'cors-unsupported',\n  CREDENTIAL_ALREADY_IN_USE = 'credential-already-in-use',\n  CREDENTIAL_MISMATCH = 'custom-token-mismatch',\n  CREDENTIAL_TOO_OLD_LOGIN_AGAIN = 'requires-recent-login',\n  DEPENDENT_SDK_INIT_BEFORE_AUTH = 'dependent-sdk-initialized-before-auth',\n  DYNAMIC_LINK_NOT_ACTIVATED = 'dynamic-link-not-activated',\n  EMAIL_CHANGE_NEEDS_VERIFICATION = 'email-change-needs-verification',\n  EMAIL_EXISTS = 'email-already-in-use',\n  EMULATOR_CONFIG_FAILED = 'emulator-config-failed',\n  EXPIRED_OOB_CODE = 'expired-action-code',\n  EXPIRED_POPUP_REQUEST = 'cancelled-popup-request',\n  INTERNAL_ERROR = 'internal-error',\n  INVALID_API_KEY = 'invalid-api-key',\n  INVALID_APP_CREDENTIAL = 'invalid-app-credential',\n  INVALID_APP_ID = 'invalid-app-id',\n  INVALID_AUTH = 'invalid-user-token',\n  INVALID_AUTH_EVENT = 'invalid-auth-event',\n  INVALID_CERT_HASH = 'invalid-cert-hash',\n  INVALID_CODE = 'invalid-verification-code',\n  INVALID_CONTINUE_URI = 'invalid-continue-uri',\n  INVALID_CORDOVA_CONFIGURATION = 'invalid-cordova-configuration',\n  INVALID_CUSTOM_TOKEN = 'invalid-custom-token',\n  INVALID_DYNAMIC_LINK_DOMAIN = 'invalid-dynamic-link-domain',\n  INVALID_EMAIL = 'invalid-email',\n  INVALID_EMULATOR_SCHEME = 'invalid-emulator-scheme',\n  INVALID_IDP_RESPONSE = 'invalid-credential',\n  INVALID_MESSAGE_PAYLOAD = 'invalid-message-payload',\n  INVALID_MFA_SESSION = 'invalid-multi-factor-session',\n  INVALID_OAUTH_CLIENT_ID = 'invalid-oauth-client-id',\n  INVALID_OAUTH_PROVIDER = 'invalid-oauth-provider',\n  INVALID_OOB_CODE = 'invalid-action-code',\n  INVALID_ORIGIN = 'unauthorized-domain',\n  INVALID_PASSWORD = 'wrong-password',\n  INVALID_PERSISTENCE = 'invalid-persistence-type',\n  INVALID_PHONE_NUMBER = 'invalid-phone-number',\n  INVALID_PROVIDER_ID = 'invalid-provider-id',\n  INVALID_RECIPIENT_EMAIL = 'invalid-recipient-email',\n  INVALID_SENDER = 'invalid-sender',\n  INVALID_SESSION_INFO = 'invalid-verification-id',\n  INVALID_TENANT_ID = 'invalid-tenant-id',\n  LOGIN_BLOCKED = 'login-blocked',\n  MFA_INFO_NOT_FOUND = 'multi-factor-info-not-found',\n  MFA_REQUIRED = 'multi-factor-auth-required',\n  MISSING_ANDROID_PACKAGE_NAME = 'missing-android-pkg-name',\n  MISSING_APP_CREDENTIAL = 'missing-app-credential',\n  MISSING_AUTH_DOMAIN = 'auth-domain-config-required',\n  MISSING_CODE = 'missing-verification-code',\n  MISSING_CONTINUE_URI = 'missing-continue-uri',\n  MISSING_IFRAME_START = 'missing-iframe-start',\n  MISSING_IOS_BUNDLE_ID = 'missing-ios-bundle-id',\n  MISSING_OR_INVALID_NONCE = 'missing-or-invalid-nonce',\n  MISSING_MFA_INFO = 'missing-multi-factor-info',\n  MISSING_MFA_SESSION = 'missing-multi-factor-session',\n  MISSING_PHONE_NUMBER = 'missing-phone-number',\n  MISSING_SESSION_INFO = 'missing-verification-id',\n  MODULE_DESTROYED = 'app-deleted',\n  NEED_CONFIRMATION = 'account-exists-with-different-credential',\n  NETWORK_REQUEST_FAILED = 'network-request-failed',\n  NULL_USER = 'null-user',\n  NO_AUTH_EVENT = 'no-auth-event',\n  NO_SUCH_PROVIDER = 'no-such-provider',\n  OPERATION_NOT_ALLOWED = 'operation-not-allowed',\n  OPERATION_NOT_SUPPORTED = 'operation-not-supported-in-this-environment',\n  POPUP_BLOCKED = 'popup-blocked',\n  POPUP_CLOSED_BY_USER = 'popup-closed-by-user',\n  PROVIDER_ALREADY_LINKED = 'provider-already-linked',\n  QUOTA_EXCEEDED = 'quota-exceeded',\n  REDIRECT_CANCELLED_BY_USER = 'redirect-cancelled-by-user',\n  REDIRECT_OPERATION_PENDING = 'redirect-operation-pending',\n  REJECTED_CREDENTIAL = 'rejected-credential',\n  SECOND_FACTOR_ALREADY_ENROLLED = 'second-factor-already-in-use',\n  SECOND_FACTOR_LIMIT_EXCEEDED = 'maximum-second-factor-count-exceeded',\n  TENANT_ID_MISMATCH = 'tenant-id-mismatch',\n  TIMEOUT = 'timeout',\n  TOKEN_EXPIRED = 'user-token-expired',\n  TOO_MANY_ATTEMPTS_TRY_LATER = 'too-many-requests',\n  UNAUTHORIZED_DOMAIN = 'unauthorized-continue-uri',\n  UNSUPPORTED_FIRST_FACTOR = 'unsupported-first-factor',\n  UNSUPPORTED_PERSISTENCE = 'unsupported-persistence-type',\n  UNSUPPORTED_TENANT_OPERATION = 'unsupported-tenant-operation',\n  UNVERIFIED_EMAIL = 'unverified-email',\n  USER_CANCELLED = 'user-cancelled',\n  USER_DELETED = 'user-not-found',\n  USER_DISABLED = 'user-disabled',\n  USER_MISMATCH = 'user-mismatch',\n  USER_SIGNED_OUT = 'user-signed-out',\n  WEAK_PASSWORD = 'weak-password',\n  WEB_STORAGE_UNSUPPORTED = 'web-storage-unsupported',\n  ALREADY_INITIALIZED = 'already-initialized'\n}\n\nfunction _debugErrorMap(): ErrorMap<AuthErrorCode> {\n  return {\n    [AuthErrorCode.ADMIN_ONLY_OPERATION]:\n      'This operation is restricted to administrators only.',\n    [AuthErrorCode.ARGUMENT_ERROR]: '',\n    [AuthErrorCode.APP_NOT_AUTHORIZED]:\n      \"This app, identified by the domain where it's hosted, is not \" +\n      'authorized to use Firebase Authentication with the provided API key. ' +\n      'Review your key configuration in the Google API console.',\n    [AuthErrorCode.APP_NOT_INSTALLED]:\n      'The requested mobile application corresponding to the identifier (' +\n      'Android package name or iOS bundle ID) provided is not installed on ' +\n      'this device.',\n    [AuthErrorCode.CAPTCHA_CHECK_FAILED]:\n      'The reCAPTCHA response token provided is either invalid, expired, ' +\n      'already used or the domain associated with it does not match the list ' +\n      'of whitelisted domains.',\n    [AuthErrorCode.CODE_EXPIRED]:\n      'The SMS code has expired. Please re-send the verification code to try ' +\n      'again.',\n    [AuthErrorCode.CORDOVA_NOT_READY]: 'Cordova framework is not ready.',\n    [AuthErrorCode.CORS_UNSUPPORTED]: 'This browser is not supported.',\n    [AuthErrorCode.CREDENTIAL_ALREADY_IN_USE]:\n      'This credential is already associated with a different user account.',\n    [AuthErrorCode.CREDENTIAL_MISMATCH]:\n      'The custom token corresponds to a different audience.',\n    [AuthErrorCode.CREDENTIAL_TOO_OLD_LOGIN_AGAIN]:\n      'This operation is sensitive and requires recent authentication. Log in ' +\n      'again before retrying this request.',\n    [AuthErrorCode.DEPENDENT_SDK_INIT_BEFORE_AUTH]:\n      'Another Firebase SDK was initialized and is trying to use Auth before Auth is ' +\n      'initialized. Please be sure to call `initializeAuth` or `getAuth` before ' +\n      'starting any other Firebase SDK.',\n    [AuthErrorCode.DYNAMIC_LINK_NOT_ACTIVATED]:\n      'Please activate Dynamic Links in the Firebase Console and agree to the terms and ' +\n      'conditions.',\n    [AuthErrorCode.EMAIL_CHANGE_NEEDS_VERIFICATION]:\n      'Multi-factor users must always have a verified email.',\n    [AuthErrorCode.EMAIL_EXISTS]:\n      'The email address is already in use by another account.',\n    [AuthErrorCode.EMULATOR_CONFIG_FAILED]:\n      'Auth instance has already been used to make a network call. Auth can ' +\n      'no longer be configured to use the emulator. Try calling ' +\n      '\"connectAuthEmulator()\" sooner.',\n    [AuthErrorCode.EXPIRED_OOB_CODE]: 'The action code has expired.',\n    [AuthErrorCode.EXPIRED_POPUP_REQUEST]:\n      'This operation has been cancelled due to another conflicting popup being opened.',\n    [AuthErrorCode.INTERNAL_ERROR]: 'An internal AuthError has occurred.',\n    [AuthErrorCode.INVALID_APP_CREDENTIAL]:\n      'The phone verification request contains an invalid application verifier.' +\n      ' The reCAPTCHA token response is either invalid or expired.',\n    [AuthErrorCode.INVALID_APP_ID]:\n      'The mobile app identifier is not registed for the current project.',\n    [AuthErrorCode.INVALID_AUTH]:\n      \"This user's credential isn't valid for this project. This can happen \" +\n      \"if the user's token has been tampered with, or if the user isn't for \" +\n      'the project associated with this API key.',\n    [AuthErrorCode.INVALID_AUTH_EVENT]: 'An internal AuthError has occurred.',\n    [AuthErrorCode.INVALID_CODE]:\n      'The SMS verification code used to create the phone auth credential is ' +\n      'invalid. Please resend the verification code sms and be sure to use the ' +\n      'verification code provided by the user.',\n    [AuthErrorCode.INVALID_CONTINUE_URI]:\n      'The continue URL provided in the request is invalid.',\n    [AuthErrorCode.INVALID_CORDOVA_CONFIGURATION]:\n      'The following Cordova plugins must be installed to enable OAuth sign-in: ' +\n      'cordova-plugin-buildinfo, cordova-universal-links-plugin, ' +\n      'cordova-plugin-browsertab, cordova-plugin-inappbrowser and ' +\n      'cordova-plugin-customurlscheme.',\n    [AuthErrorCode.INVALID_CUSTOM_TOKEN]:\n      'The custom token format is incorrect. Please check the documentation.',\n    [AuthErrorCode.INVALID_DYNAMIC_LINK_DOMAIN]:\n      'The provided dynamic link domain is not configured or authorized for the current project.',\n    [AuthErrorCode.INVALID_EMAIL]: 'The email address is badly formatted.',\n    [AuthErrorCode.INVALID_EMULATOR_SCHEME]:\n      'Emulator URL must start with a valid scheme (http:// or https://).',\n    [AuthErrorCode.INVALID_API_KEY]:\n      'Your API key is invalid, please check you have copied it correctly.',\n    [AuthErrorCode.INVALID_CERT_HASH]:\n      'The SHA-1 certificate hash provided is invalid.',\n    [AuthErrorCode.INVALID_IDP_RESPONSE]:\n      'The supplied auth credential is malformed or has expired.',\n    [AuthErrorCode.INVALID_MESSAGE_PAYLOAD]:\n      'The email template corresponding to this action contains invalid characters in its message. ' +\n      'Please fix by going to the Auth email templates section in the Firebase Console.',\n    [AuthErrorCode.INVALID_MFA_SESSION]:\n      'The request does not contain a valid proof of first factor successful sign-in.',\n    [AuthErrorCode.INVALID_OAUTH_PROVIDER]:\n      'EmailAuthProvider is not supported for this operation. This operation ' +\n      'only supports OAuth providers.',\n    [AuthErrorCode.INVALID_OAUTH_CLIENT_ID]:\n      'The OAuth client ID provided is either invalid or does not match the ' +\n      'specified API key.',\n    [AuthErrorCode.INVALID_ORIGIN]:\n      'This domain is not authorized for OAuth operations for your Firebase ' +\n      'project. Edit the list of authorized domains from the Firebase console.',\n    [AuthErrorCode.INVALID_OOB_CODE]:\n      'The action code is invalid. This can happen if the code is malformed, ' +\n      'expired, or has already been used.',\n    [AuthErrorCode.INVALID_PASSWORD]:\n      'The password is invalid or the user does not have a password.',\n    [AuthErrorCode.INVALID_PERSISTENCE]:\n      'The specified persistence type is invalid. It can only be local, session or none.',\n    [AuthErrorCode.INVALID_PHONE_NUMBER]:\n      'The format of the phone number provided is incorrect. Please enter the ' +\n      'phone number in a format that can be parsed into E.164 format. E.164 ' +\n      'phone numbers are written in the format [+][country code][subscriber ' +\n      'number including area code].',\n    [AuthErrorCode.INVALID_PROVIDER_ID]:\n      'The specified provider ID is invalid.',\n    [AuthErrorCode.INVALID_RECIPIENT_EMAIL]:\n      'The email corresponding to this action failed to send as the provided ' +\n      'recipient email address is invalid.',\n    [AuthErrorCode.INVALID_SENDER]:\n      'The email template corresponding to this action contains an invalid sender email or name. ' +\n      'Please fix by going to the Auth email templates section in the Firebase Console.',\n    [AuthErrorCode.INVALID_SESSION_INFO]:\n      'The verification ID used to create the phone auth credential is invalid.',\n    [AuthErrorCode.INVALID_TENANT_ID]:\n      \"The Auth instance's tenant ID is invalid.\",\n    [AuthErrorCode.LOGIN_BLOCKED]: \"Login blocked by user-provided method: {$originalMessage}\",\n    [AuthErrorCode.MISSING_ANDROID_PACKAGE_NAME]:\n      'An Android Package Name must be provided if the Android App is required to be installed.',\n    [AuthErrorCode.MISSING_AUTH_DOMAIN]:\n      'Be sure to include authDomain when calling firebase.initializeApp(), ' +\n      'by following the instructions in the Firebase console.',\n    [AuthErrorCode.MISSING_APP_CREDENTIAL]:\n      'The phone verification request is missing an application verifier ' +\n      'assertion. A reCAPTCHA response token needs to be provided.',\n    [AuthErrorCode.MISSING_CODE]:\n      'The phone auth credential was created with an empty SMS verification code.',\n    [AuthErrorCode.MISSING_CONTINUE_URI]:\n      'A continue URL must be provided in the request.',\n    [AuthErrorCode.MISSING_IFRAME_START]: 'An internal AuthError has occurred.',\n    [AuthErrorCode.MISSING_IOS_BUNDLE_ID]:\n      'An iOS Bundle ID must be provided if an App Store ID is provided.',\n    [AuthErrorCode.MISSING_OR_INVALID_NONCE]:\n      'The request does not contain a valid nonce. This can occur if the ' +\n      'SHA-256 hash of the provided raw nonce does not match the hashed nonce ' +\n      'in the ID token payload.',\n    [AuthErrorCode.MISSING_MFA_INFO]:\n      'No second factor identifier is provided.',\n    [AuthErrorCode.MISSING_MFA_SESSION]:\n      'The request is missing proof of first factor successful sign-in.',\n    [AuthErrorCode.MISSING_PHONE_NUMBER]:\n      'To send verification codes, provide a phone number for the recipient.',\n    [AuthErrorCode.MISSING_SESSION_INFO]:\n      'The phone auth credential was created with an empty verification ID.',\n    [AuthErrorCode.MODULE_DESTROYED]:\n      'This instance of FirebaseApp has been deleted.',\n    [AuthErrorCode.MFA_INFO_NOT_FOUND]:\n      'The user does not have a second factor matching the identifier provided.',\n    [AuthErrorCode.MFA_REQUIRED]:\n      'Proof of ownership of a second factor is required to complete sign-in.',\n    [AuthErrorCode.NEED_CONFIRMATION]:\n      'An account already exists with the same email address but different ' +\n      'sign-in credentials. Sign in using a provider associated with this ' +\n      'email address.',\n    [AuthErrorCode.NETWORK_REQUEST_FAILED]:\n      'A network AuthError (such as timeout, interrupted connection or unreachable host) has occurred.',\n    [AuthErrorCode.NO_AUTH_EVENT]: 'An internal AuthError has occurred.',\n    [AuthErrorCode.NO_SUCH_PROVIDER]:\n      'User was not linked to an account with the given provider.',\n    [AuthErrorCode.NULL_USER]:\n      'A null user object was provided as the argument for an operation which ' +\n      'requires a non-null user object.',\n    [AuthErrorCode.OPERATION_NOT_ALLOWED]:\n      'The given sign-in provider is disabled for this Firebase project. ' +\n      'Enable it in the Firebase console, under the sign-in method tab of the ' +\n      'Auth section.',\n    [AuthErrorCode.OPERATION_NOT_SUPPORTED]:\n      'This operation is not supported in the environment this application is ' +\n      'running on. \"location.protocol\" must be http, https or chrome-extension' +\n      ' and web storage must be enabled.',\n    [AuthErrorCode.POPUP_BLOCKED]:\n      'Unable to establish a connection with the popup. It may have been blocked by the browser.',\n    [AuthErrorCode.POPUP_CLOSED_BY_USER]:\n      'The popup has been closed by the user before finalizing the operation.',\n    [AuthErrorCode.PROVIDER_ALREADY_LINKED]:\n      'User can only be linked to one identity for the given provider.',\n    [AuthErrorCode.QUOTA_EXCEEDED]:\n      \"The project's quota for this operation has been exceeded.\",\n    [AuthErrorCode.REDIRECT_CANCELLED_BY_USER]:\n      'The redirect operation has been cancelled by the user before finalizing.',\n    [AuthErrorCode.REDIRECT_OPERATION_PENDING]:\n      'A redirect sign-in operation is already pending.',\n    [AuthErrorCode.REJECTED_CREDENTIAL]:\n      'The request contains malformed or mismatching credentials.',\n    [AuthErrorCode.SECOND_FACTOR_ALREADY_ENROLLED]:\n      'The second factor is already enrolled on this account.',\n    [AuthErrorCode.SECOND_FACTOR_LIMIT_EXCEEDED]:\n      'The maximum allowed number of second factors on a user has been exceeded.',\n    [AuthErrorCode.TENANT_ID_MISMATCH]:\n      \"The provided tenant ID does not match the Auth instance's tenant ID\",\n    [AuthErrorCode.TIMEOUT]: 'The operation has timed out.',\n    [AuthErrorCode.TOKEN_EXPIRED]:\n      \"The user's credential is no longer valid. The user must sign in again.\",\n    [AuthErrorCode.TOO_MANY_ATTEMPTS_TRY_LATER]:\n      'We have blocked all requests from this device due to unusual activity. ' +\n      'Try again later.',\n    [AuthErrorCode.UNAUTHORIZED_DOMAIN]:\n      'The domain of the continue URL is not whitelisted.  Please whitelist ' +\n      'the domain in the Firebase console.',\n    [AuthErrorCode.UNSUPPORTED_FIRST_FACTOR]:\n      'Enrolling a second factor or signing in with a multi-factor account requires sign-in with a supported first factor.',\n    [AuthErrorCode.UNSUPPORTED_PERSISTENCE]:\n      'The current environment does not support the specified persistence type.',\n    [AuthErrorCode.UNSUPPORTED_TENANT_OPERATION]:\n      'This operation is not supported in a multi-tenant context.',\n    [AuthErrorCode.UNVERIFIED_EMAIL]:\n      'The operation requires a verified email.',\n    [AuthErrorCode.USER_CANCELLED]:\n      'The user did not grant your application the permissions it requested.',\n    [AuthErrorCode.USER_DELETED]:\n      'There is no user record corresponding to this identifier. The user may ' +\n      'have been deleted.',\n    [AuthErrorCode.USER_DISABLED]:\n      'The user account has been disabled by an administrator.',\n    [AuthErrorCode.USER_MISMATCH]:\n      'The supplied credentials do not correspond to the previously signed in user.',\n    [AuthErrorCode.USER_SIGNED_OUT]: '',\n    [AuthErrorCode.WEAK_PASSWORD]:\n      'The password must be 6 characters long or more.',\n    [AuthErrorCode.WEB_STORAGE_UNSUPPORTED]:\n      'This browser is not supported or 3rd party cookies and data may be disabled.',\n    [AuthErrorCode.ALREADY_INITIALIZED]:\n      'initializeAuth() has already been called with ' +\n      'different options. To avoid this error, call initializeAuth() with the ' +\n      'same options as when it was originally called, or call getAuth() to return the' +\n      ' already initialized instance.'\n  };\n}\n\nexport interface ErrorMapRetriever extends AuthErrorMap {\n  (): ErrorMap<AuthErrorCode>;\n}\n\nfunction _prodErrorMap(): ErrorMap<AuthErrorCode> {\n  // We will include this one message in the prod error map since by the very\n  // nature of this error, developers will never be able to see the message\n  // using the debugErrorMap (which is installed during auth initialization).\n  return {\n    [AuthErrorCode.DEPENDENT_SDK_INIT_BEFORE_AUTH]:\n      'Another Firebase SDK was initialized and is trying to use Auth before Auth is ' +\n      'initialized. Please be sure to call `initializeAuth` or `getAuth` before ' +\n      'starting any other Firebase SDK.'\n  } as ErrorMap<AuthErrorCode>;\n}\n\n/**\n * A verbose error map with detailed descriptions for most error codes.\n *\n * See discussion at {@link AuthErrorMap}\n *\n * @public\n */\nexport const debugErrorMap: AuthErrorMap = _debugErrorMap;\n\n/**\n * A minimal error map with all verbose error messages stripped.\n *\n * See discussion at {@link AuthErrorMap}\n *\n * @public\n */\nexport const prodErrorMap: AuthErrorMap = _prodErrorMap;\n\nexport interface NamedErrorParams {\n  appName: AppName;\n  credential?: AuthCredential;\n  email?: string;\n  phoneNumber?: string;\n  tenantId?: string;\n  user?: User;\n  _serverResponse?: object;\n}\n\n/**\n * @internal\n */\ntype GenericAuthErrorParams = {\n  [key in Exclude<\n    AuthErrorCode,\n    | AuthErrorCode.ARGUMENT_ERROR\n    | AuthErrorCode.DEPENDENT_SDK_INIT_BEFORE_AUTH\n    | AuthErrorCode.INTERNAL_ERROR\n    | AuthErrorCode.MFA_REQUIRED\n    | AuthErrorCode.NO_AUTH_EVENT\n    | AuthErrorCode.OPERATION_NOT_SUPPORTED\n  >]: {\n    appName?: AppName;\n    email?: string;\n    phoneNumber?: string;\n    message?: string;\n  };\n};\n\n/**\n * @internal\n */\nexport interface AuthErrorParams extends GenericAuthErrorParams {\n  [AuthErrorCode.ARGUMENT_ERROR]: { appName?: AppName };\n  [AuthErrorCode.DEPENDENT_SDK_INIT_BEFORE_AUTH]: { appName?: AppName };\n  [AuthErrorCode.INTERNAL_ERROR]: { appName?: AppName };\n  [AuthErrorCode.LOGIN_BLOCKED]: { appName?: AppName, originalMessage?: string };\n  [AuthErrorCode.OPERATION_NOT_SUPPORTED]: { appName?: AppName };\n  [AuthErrorCode.NO_AUTH_EVENT]: { appName?: AppName };\n  [AuthErrorCode.MFA_REQUIRED]: {\n    appName: AppName;\n    _serverResponse: IdTokenMfaResponse;\n  };\n  [AuthErrorCode.INVALID_CORDOVA_CONFIGURATION]: {\n    appName: AppName;\n    missingPlugin?: string;\n  };\n}\n\nexport const _DEFAULT_AUTH_ERROR_FACTORY = new ErrorFactory<\n  AuthErrorCode,\n  AuthErrorParams\n>('auth', 'Firebase', _prodErrorMap());\n\n/**\n * A map of potential `Auth` error codes, for easier comparison with errors\n * thrown by the SDK.\n *\n * @remarks\n * Note that you can't tree-shake individual keys\n * in the map, so by using the map you might substantially increase your\n * bundle size.\n *\n * @public\n */\nexport const AUTH_ERROR_CODES_MAP_DO_NOT_USE_INTERNALLY = {\n  ADMIN_ONLY_OPERATION: 'auth/admin-restricted-operation',\n  ARGUMENT_ERROR: 'auth/argument-error',\n  APP_NOT_AUTHORIZED: 'auth/app-not-authorized',\n  APP_NOT_INSTALLED: 'auth/app-not-installed',\n  CAPTCHA_CHECK_FAILED: 'auth/captcha-check-failed',\n  CODE_EXPIRED: 'auth/code-expired',\n  CORDOVA_NOT_READY: 'auth/cordova-not-ready',\n  CORS_UNSUPPORTED: 'auth/cors-unsupported',\n  CREDENTIAL_ALREADY_IN_USE: 'auth/credential-already-in-use',\n  CREDENTIAL_MISMATCH: 'auth/custom-token-mismatch',\n  CREDENTIAL_TOO_OLD_LOGIN_AGAIN: 'auth/requires-recent-login',\n  DEPENDENT_SDK_INIT_BEFORE_AUTH: 'auth/dependent-sdk-initialized-before-auth',\n  DYNAMIC_LINK_NOT_ACTIVATED: 'auth/dynamic-link-not-activated',\n  EMAIL_CHANGE_NEEDS_VERIFICATION: 'auth/email-change-needs-verification',\n  EMAIL_EXISTS: 'auth/email-already-in-use',\n  EMULATOR_CONFIG_FAILED: 'auth/emulator-config-failed',\n  EXPIRED_OOB_CODE: 'auth/expired-action-code',\n  EXPIRED_POPUP_REQUEST: 'auth/cancelled-popup-request',\n  INTERNAL_ERROR: 'auth/internal-error',\n  INVALID_API_KEY: 'auth/invalid-api-key',\n  INVALID_APP_CREDENTIAL: 'auth/invalid-app-credential',\n  INVALID_APP_ID: 'auth/invalid-app-id',\n  INVALID_AUTH: 'auth/invalid-user-token',\n  INVALID_AUTH_EVENT: 'auth/invalid-auth-event',\n  INVALID_CERT_HASH: 'auth/invalid-cert-hash',\n  INVALID_CODE: 'auth/invalid-verification-code',\n  INVALID_CONTINUE_URI: 'auth/invalid-continue-uri',\n  INVALID_CORDOVA_CONFIGURATION: 'auth/invalid-cordova-configuration',\n  INVALID_CUSTOM_TOKEN: 'auth/invalid-custom-token',\n  INVALID_DYNAMIC_LINK_DOMAIN: 'auth/invalid-dynamic-link-domain',\n  INVALID_EMAIL: 'auth/invalid-email',\n  INVALID_EMULATOR_SCHEME: 'auth/invalid-emulator-scheme',\n  INVALID_IDP_RESPONSE: 'auth/invalid-credential',\n  INVALID_MESSAGE_PAYLOAD: 'auth/invalid-message-payload',\n  INVALID_MFA_SESSION: 'auth/invalid-multi-factor-session',\n  INVALID_OAUTH_CLIENT_ID: 'auth/invalid-oauth-client-id',\n  INVALID_OAUTH_PROVIDER: 'auth/invalid-oauth-provider',\n  INVALID_OOB_CODE: 'auth/invalid-action-code',\n  INVALID_ORIGIN: 'auth/unauthorized-domain',\n  INVALID_PASSWORD: 'auth/wrong-password',\n  INVALID_PERSISTENCE: 'auth/invalid-persistence-type',\n  INVALID_PHONE_NUMBER: 'auth/invalid-phone-number',\n  INVALID_PROVIDER_ID: 'auth/invalid-provider-id',\n  INVALID_RECIPIENT_EMAIL: 'auth/invalid-recipient-email',\n  INVALID_SENDER: 'auth/invalid-sender',\n  INVALID_SESSION_INFO: 'auth/invalid-verification-id',\n  INVALID_TENANT_ID: 'auth/invalid-tenant-id',\n  MFA_INFO_NOT_FOUND: 'auth/multi-factor-info-not-found',\n  MFA_REQUIRED: 'auth/multi-factor-auth-required',\n  MISSING_ANDROID_PACKAGE_NAME: 'auth/missing-android-pkg-name',\n  MISSING_APP_CREDENTIAL: 'auth/missing-app-credential',\n  MISSING_AUTH_DOMAIN: 'auth/auth-domain-config-required',\n  MISSING_CODE: 'auth/missing-verification-code',\n  MISSING_CONTINUE_URI: 'auth/missing-continue-uri',\n  MISSING_IFRAME_START: 'auth/missing-iframe-start',\n  MISSING_IOS_BUNDLE_ID: 'auth/missing-ios-bundle-id',\n  MISSING_OR_INVALID_NONCE: 'auth/missing-or-invalid-nonce',\n  MISSING_MFA_INFO: 'auth/missing-multi-factor-info',\n  MISSING_MFA_SESSION: 'auth/missing-multi-factor-session',\n  MISSING_PHONE_NUMBER: 'auth/missing-phone-number',\n  MISSING_SESSION_INFO: 'auth/missing-verification-id',\n  MODULE_DESTROYED: 'auth/app-deleted',\n  NEED_CONFIRMATION: 'auth/account-exists-with-different-credential',\n  NETWORK_REQUEST_FAILED: 'auth/network-request-failed',\n  NULL_USER: 'auth/null-user',\n  NO_AUTH_EVENT: 'auth/no-auth-event',\n  NO_SUCH_PROVIDER: 'auth/no-such-provider',\n  OPERATION_NOT_ALLOWED: 'auth/operation-not-allowed',\n  OPERATION_NOT_SUPPORTED: 'auth/operation-not-supported-in-this-environment',\n  POPUP_BLOCKED: 'auth/popup-blocked',\n  POPUP_CLOSED_BY_USER: 'auth/popup-closed-by-user',\n  PROVIDER_ALREADY_LINKED: 'auth/provider-already-linked',\n  QUOTA_EXCEEDED: 'auth/quota-exceeded',\n  REDIRECT_CANCELLED_BY_USER: 'auth/redirect-cancelled-by-user',\n  REDIRECT_OPERATION_PENDING: 'auth/redirect-operation-pending',\n  REJECTED_CREDENTIAL: 'auth/rejected-credential',\n  SECOND_FACTOR_ALREADY_ENROLLED: 'auth/second-factor-already-in-use',\n  SECOND_FACTOR_LIMIT_EXCEEDED: 'auth/maximum-second-factor-count-exceeded',\n  TENANT_ID_MISMATCH: 'auth/tenant-id-mismatch',\n  TIMEOUT: 'auth/timeout',\n  TOKEN_EXPIRED: 'auth/user-token-expired',\n  TOO_MANY_ATTEMPTS_TRY_LATER: 'auth/too-many-requests',\n  UNAUTHORIZED_DOMAIN: 'auth/unauthorized-continue-uri',\n  UNSUPPORTED_FIRST_FACTOR: 'auth/unsupported-first-factor',\n  UNSUPPORTED_PERSISTENCE: 'auth/unsupported-persistence-type',\n  UNSUPPORTED_TENANT_OPERATION: 'auth/unsupported-tenant-operation',\n  UNVERIFIED_EMAIL: 'auth/unverified-email',\n  USER_CANCELLED: 'auth/user-cancelled',\n  USER_DELETED: 'auth/user-not-found',\n  USER_DISABLED: 'auth/user-disabled',\n  USER_MISMATCH: 'auth/user-mismatch',\n  USER_SIGNED_OUT: 'auth/user-signed-out',\n  WEAK_PASSWORD: 'auth/weak-password',\n  WEB_STORAGE_UNSUPPORTED: 'auth/web-storage-unsupported',\n  ALREADY_INITIALIZED: 'auth/already-initialized'\n} as const;\n","/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { Logger, LogLevel } from '@firebase/logger';\nimport { SDK_VERSION } from '@firebase/app';\n\nexport { LogLevel };\n\nconst logClient = new Logger('@firebase/auth');\n\n// Helper methods are needed because variables can't be exported as read/write\nexport function _getLogLevel(): LogLevel {\n  return logClient.logLevel;\n}\n\nexport function _setLogLevel(newLevel: LogLevel): void {\n  logClient.logLevel = newLevel;\n}\n\nexport function _logDebug(msg: string, ...args: string[]): void {\n  if (logClient.logLevel <= LogLevel.DEBUG) {\n    logClient.debug(`Auth (${SDK_VERSION}): ${msg}`, ...args);\n  }\n}\n\nexport function _logError(msg: string, ...args: string[]): void {\n  if (logClient.logLevel <= LogLevel.ERROR) {\n    logClient.error(`Auth (${SDK_VERSION}): ${msg}`, ...args);\n  }\n}\n","/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { Auth } from '../../model/public_types';\nimport { ErrorFactory, FirebaseError } from '@firebase/util';\nimport { AuthInternal } from '../../model/auth';\nimport {\n  _DEFAULT_AUTH_ERROR_FACTORY,\n  AuthErrorCode,\n  AuthErrorParams,\n  prodErrorMap,\n  ErrorMapRetriever\n} from '../errors';\nimport { _logError } from './log';\n\ntype AuthErrorListParams<K> = K extends keyof AuthErrorParams\n  ? [AuthErrorParams[K]]\n  : [];\ntype LessAppName<K extends AuthErrorCode> = Omit<AuthErrorParams[K], 'appName'>;\n\n/**\n * Unconditionally fails, throwing a developer facing INTERNAL_ERROR\n *\n * @example\n * ```javascript\n * fail(auth, AuthErrorCode.MFA_REQUIRED);  // Error: the MFA_REQUIRED error needs more params than appName\n * fail(auth, AuthErrorCode.MFA_REQUIRED, {serverResponse});  // Compiles\n * fail(AuthErrorCode.INTERNAL_ERROR);  // Compiles; internal error does not need appName\n * fail(AuthErrorCode.USER_DELETED);  // Error: USER_DELETED requires app name\n * fail(auth, AuthErrorCode.USER_DELETED);  // Compiles; USER_DELETED _only_ needs app name\n * ```\n *\n * @param appName App name for tagging the error\n * @throws FirebaseError\n */\nexport function _fail<K extends AuthErrorCode>(\n  code: K,\n  ...data: {} extends AuthErrorParams[K]\n    ? [AuthErrorParams[K]?]\n    : [AuthErrorParams[K]]\n): never;\nexport function _fail<K extends AuthErrorCode>(\n  auth: Auth,\n  code: K,\n  ...data: {} extends LessAppName<K> ? [LessAppName<K>?] : [LessAppName<K>]\n): never;\nexport function _fail<K extends AuthErrorCode>(\n  authOrCode: Auth | K,\n  ...rest: unknown[]\n): never {\n  throw createErrorInternal(authOrCode, ...rest);\n}\n\nexport function _createError<K extends AuthErrorCode>(\n  code: K,\n  ...data: {} extends AuthErrorParams[K]\n    ? [AuthErrorParams[K]?]\n    : [AuthErrorParams[K]]\n): FirebaseError;\nexport function _createError<K extends AuthErrorCode>(\n  auth: Auth,\n  code: K,\n  ...data: {} extends LessAppName<K> ? [LessAppName<K>?] : [LessAppName<K>]\n): FirebaseError;\nexport function _createError<K extends AuthErrorCode>(\n  authOrCode: Auth | K,\n  ...rest: unknown[]\n): FirebaseError {\n  return createErrorInternal(authOrCode, ...rest);\n}\n\nexport function _errorWithCustomMessage(auth: Auth, code: AuthErrorCode, message: string): FirebaseError {\n  const errorMap = {...(prodErrorMap as ErrorMapRetriever)(), [code]: message};\n  const factory = new ErrorFactory<AuthErrorCode, AuthErrorParams>(\n    'auth',\n    'Firebase',\n    errorMap\n  );\n  return factory.create(code, {\n    appName: auth.name,\n  });\n}\n\nexport function _assertInstanceOf(auth: Auth, object: object, instance: unknown): void {\n  const constructorInstance =  (instance as { new (...args: unknown[]): unknown });\n  if (!(object instanceof constructorInstance)) {\n    if (constructorInstance.name !== object.constructor.name) {\n      _fail(auth, AuthErrorCode.ARGUMENT_ERROR);\n    }\n\n    throw _errorWithCustomMessage(auth, AuthErrorCode.ARGUMENT_ERROR,\n      `Type of ${object.constructor.name} does not match expected instance.` +\n      `Did you pass a reference from a different Auth SDK?`);\n  }\n}\n\nfunction createErrorInternal<K extends AuthErrorCode>(\n  authOrCode: Auth | K,\n  ...rest: unknown[]\n): FirebaseError {\n  if (typeof authOrCode !== 'string') {\n    const code = rest[0] as K;\n    const fullParams = [...rest.slice(1)] as AuthErrorListParams<K>;\n    if (fullParams[0]) {\n      fullParams[0].appName = authOrCode.name;\n    }\n\n    return (authOrCode as AuthInternal)._errorFactory.create(\n      code,\n      ...fullParams\n    );\n  }\n\n  return _DEFAULT_AUTH_ERROR_FACTORY.create(\n    authOrCode,\n    ...(rest as AuthErrorListParams<K>)\n  );\n}\n\nexport function _assert<K extends AuthErrorCode>(\n  assertion: unknown,\n  code: K,\n  ...data: {} extends AuthErrorParams[K]\n    ? [AuthErrorParams[K]?]\n    : [AuthErrorParams[K]]\n): asserts assertion;\nexport function _assert<K extends AuthErrorCode>(\n  assertion: unknown,\n  auth: Auth,\n  code: K,\n  ...data: {} extends LessAppName<K> ? [LessAppName<K>?] : [LessAppName<K>]\n): asserts assertion;\nexport function _assert<K extends AuthErrorCode>(\n  assertion: unknown,\n  authOrCode: Auth | K,\n  ...rest: unknown[]\n): asserts assertion {\n  if (!assertion) {\n    throw createErrorInternal(authOrCode, ...rest);\n  }\n}\n\n// We really do want to accept literally any function type here\n// eslint-disable-next-line @typescript-eslint/ban-types\ntype TypeExpectation = Function | string | MapType;\n\ninterface MapType extends Record<string, TypeExpectation | Optional> {}\n\nclass Optional {\n  constructor(readonly type: TypeExpectation) {}\n}\n\nexport function opt(type: TypeExpectation): Optional {\n  return new Optional(type);\n}\n\n/**\n * Asserts the runtime types of arguments. The 'expected' field can be one of\n * a class, a string (representing a \"typeof\" call), or a record map of name\n * to type. Furthermore, the opt() function can be used to mark a field as\n * optional. For example:\n *\n * function foo(auth: Auth, profile: {displayName?: string}, update = false) {\n *   assertTypes(arguments, [AuthImpl, {displayName: opt('string')}, opt('boolean')]);\n * }\n *\n * opt() can be used for any type:\n * function foo(auth?: Auth) {\n *   assertTypes(arguments, [opt(AuthImpl)]);\n * }\n *\n * The string types can be or'd together, and you can use \"null\" as well (note\n * that typeof null === 'object'; this is an edge case). For example:\n *\n * function foo(profile: {displayName?: string | null}) {\n *   assertTypes(arguments, [{displayName: opt('string|null')}]);\n * }\n *\n * @param args\n * @param expected\n */\nexport function assertTypes(\n  args: Omit<IArguments, 'callee'>,\n  ...expected: Array<TypeExpectation | Optional>\n): void {\n  if (args.length > expected.length) {\n    _fail(AuthErrorCode.ARGUMENT_ERROR, {});\n  }\n\n  for (let i = 0; i < expected.length; i++) {\n    let expect = expected[i];\n    const arg = args[i];\n\n    if (expect instanceof Optional) {\n      // If the arg is undefined, then it matches \"optional\" and we can move to\n      // the next arg\n      if (typeof arg === 'undefined') {\n        continue;\n      }\n      expect = expect.type;\n    }\n\n    if (typeof expect === 'string') {\n      // Handle the edge case for null because typeof null === 'object'\n      if (expect.includes('null') && arg === null) {\n        continue;\n      }\n\n      const required = expect.split('|');\n      _assert(required.includes(typeof arg), AuthErrorCode.ARGUMENT_ERROR, {});\n    } else if (typeof expect === 'object') {\n      // Recursively check record arguments\n      const record = arg as Record<string, unknown>;\n      const map = expect as MapType;\n      const keys = Object.keys(expect);\n\n      assertTypes(\n        keys.map(k => record[k]),\n        ...keys.map(k => map[k])\n      );\n    } else {\n      _assert(arg instanceof expect, AuthErrorCode.ARGUMENT_ERROR, {});\n    }\n  }\n}\n\n/**\n * Unconditionally fails, throwing an internal error with the given message.\n *\n * @param failure type of failure encountered\n * @throws Error\n */\nexport function debugFail(failure: string): never {\n  // Log the failure in addition to throw an exception, just in case the\n  // exception is swallowed.\n  const message = `INTERNAL ASSERTION FAILED: ` + failure;\n  _logError(message);\n\n  // NOTE: We don't use FirebaseError here because these are internal failures\n  // that cannot be handled by the user. (Also it would create a circular\n  // dependency between the error and assert modules which doesn't work.)\n  throw new Error(message);\n}\n\n/**\n * Fails if the given assertion condition is false, throwing an Error with the\n * given message if it did.\n *\n * @param assertion\n * @param message\n */\nexport function debugAssert(\n  assertion: unknown,\n  message: string\n): asserts assertion {\n  if (!assertion) {\n    debugFail(message);\n  }\n}\n\n","/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { debugAssert } from './assert';\n\n/**\n * Our API has a lot of one-off constants that are used to do things.\n * Unfortunately we can't export these as classes instantiated directly since\n * the constructor may side effect and therefore can't be proven to be safely\n * culled. Instead, we export these classes themselves as a lowerCamelCase\n * constant, and instantiate them under the hood.\n */\nexport interface SingletonInstantiator<T> {\n  new (): T;\n}\n\nconst instanceCache: Map<unknown, unknown> = new Map();\n\nexport function _getInstance<T>(cls: unknown): T {\n  debugAssert(cls instanceof Function, 'Expected a class definition');\n  let instance = instanceCache.get(cls) as T | undefined;\n\n  if (instance) {\n    debugAssert(\n      instance instanceof cls,\n      'Instance stored in cache mismatched with class'\n    );\n    return instance;\n  }\n\n  instance = new (cls as SingletonInstantiator<T>)();\n  instanceCache.set(cls, instance);\n  return instance;\n}\n\nexport function _clearInstanceMap(): void {\n  instanceCache.clear();\n}\n","/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { _getProvider, FirebaseApp } from '@firebase/app';\nimport { deepEqual } from '@firebase/util';\nimport { Auth, Dependencies } from '../../model/public_types';\n\nimport { AuthErrorCode } from '../errors';\nimport { PersistenceInternal } from '../persistence';\nimport { _fail } from '../util/assert';\nimport { _getInstance } from '../util/instantiator';\nimport { AuthImpl } from './auth_impl';\n\n/**\n * Initializes an {@link Auth} instance with fine-grained control over\n * {@link Dependencies}.\n *\n * @remarks\n *\n * This function allows more control over the {@link Auth} instance than\n * {@link getAuth}. `getAuth` uses platform-specific defaults to supply\n * the {@link Dependencies}. In general, `getAuth` is the easiest way to\n * initialize Auth and works for most use cases. Use `initializeAuth` if you\n * need control over which persistence layer is used, or to minimize bundle\n * size if you're not using either `signInWithPopup` or `signInWithRedirect`.\n *\n * For example, if your app only uses anonymous accounts and you only want\n * accounts saved for the current session, initialize `Auth` with:\n *\n * ```js\n * const auth = initializeAuth(app, {\n *   persistence: browserSessionPersistence,\n *   popupRedirectResolver: undefined,\n * });\n * ```\n *\n * @public\n */\nexport function initializeAuth(app: FirebaseApp, deps?: Dependencies): Auth {\n  const provider = _getProvider(app, 'auth');\n\n  if (provider.isInitialized()) {\n    const auth = provider.getImmediate() as AuthImpl;\n    const initialOptions = provider.getOptions() as Dependencies;\n    if (deepEqual(initialOptions, deps ?? {})) {\n      return auth;\n    } else {\n      _fail(auth, AuthErrorCode.ALREADY_INITIALIZED);\n    }\n  }\n\n  const auth = provider.initialize({ options: deps }) as AuthImpl;\n\n  return auth;\n}\n\nexport function _initializeAuthInstance(\n  auth: AuthImpl,\n  deps?: Dependencies\n): void {\n  const persistence = deps?.persistence || [];\n  const hierarchy = (\n    Array.isArray(persistence) ? persistence : [persistence]\n  ).map<PersistenceInternal>(_getInstance);\n  if (deps?.errorMap) {\n    auth._updateErrorMap(deps.errorMap);\n  }\n\n  // This promise is intended to float; auth initialization happens in the\n  // background, meanwhile the auth object may be used by the app.\n  // eslint-disable-next-line @typescript-eslint/no-floating-promises\n  auth._initializeWithPersistence(hierarchy, deps?.popupRedirectResolver);\n}\n","/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nexport function _getCurrentUrl(): string {\n  return (typeof self !== 'undefined' && self.location?.href) || '';\n}\n\nexport function _isHttpOrHttps(): boolean {\n  return _getCurrentScheme() === 'http:' || _getCurrentScheme() === 'https:';\n}\n\nexport function _getCurrentScheme(): string | null {\n  return (typeof self !== 'undefined' && self.location?.protocol) || null;\n}\n","/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { isBrowserExtension } from '@firebase/util';\nimport { _isHttpOrHttps } from './location';\n\n/**\n * Determine whether the browser is working online\n */\nexport function _isOnline(): boolean {\n  if (\n    typeof navigator !== 'undefined' &&\n    navigator &&\n    'onLine' in navigator &&\n    typeof navigator.onLine === 'boolean' &&\n    // Apply only for traditional web apps and Chrome extensions.\n    // This is especially true for Cordova apps which have unreliable\n    // navigator.onLine behavior unless cordova-plugin-network-information is\n    // installed which overwrites the native navigator.onLine value and\n    // defines navigator.connection.\n    (_isHttpOrHttps() || isBrowserExtension() || 'connection' in navigator)\n  ) {\n    return navigator.onLine;\n  }\n  // If we can't determine the state, assume it is online.\n  return true;\n}\n\nexport function _getUserLanguage(): string | null {\n  if (typeof navigator === 'undefined') {\n    return null;\n  }\n  const navigatorLanguage: NavigatorLanguage = navigator;\n  return (\n    // Most reliable, but only supported in Chrome/Firefox.\n    (navigatorLanguage.languages && navigatorLanguage.languages[0]) ||\n    // Supported in most browsers, but returns the language of the browser\n    // UI, not the language set in browser settings.\n    navigatorLanguage.language ||\n    // Couldn't determine language.\n    null\n  );\n}\n","/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { isMobileCordova, isReactNative } from '@firebase/util';\nimport { _isOnline } from './navigator';\nimport { debugAssert } from './assert';\n\nexport const enum DelayMin {\n  OFFLINE = 5000\n}\n\n/**\n * A structure to help pick between a range of long and short delay durations\n * depending on the current environment. In general, the long delay is used for\n * mobile environments whereas short delays are used for desktop environments.\n */\nexport class Delay {\n  // The default value for the offline delay timeout in ms.\n\n  private readonly isMobile: boolean;\n  constructor(\n    private readonly shortDelay: number,\n    private readonly longDelay: number\n  ) {\n    // Internal error when improperly initialized.\n    debugAssert(\n      longDelay > shortDelay,\n      'Short delay should be less than long delay!'\n    );\n    this.isMobile = isMobileCordova() || isReactNative();\n  }\n\n  get(): number {\n    if (!_isOnline()) {\n      // Pick the shorter timeout.\n      return Math.min(DelayMin.OFFLINE, this.shortDelay);\n    }\n    // If running in a mobile environment, return the long delay, otherwise\n    // return the short delay.\n    // This could be improved in the future to dynamically change based on other\n    // variables instead of just reading the current environment.\n    return this.isMobile ? this.longDelay : this.shortDelay;\n  }\n}\n","/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { ConfigInternal } from '../../model/auth';\nimport { debugAssert } from './assert';\n\nexport function _emulatorUrl(config: ConfigInternal, path?: string): string {\n  debugAssert(config.emulator, 'Emulator should always be set here');\n  const { url } = config.emulator;\n\n  if (!path) {\n    return url;\n  }\n\n  return `${url}${path.startsWith('/') ? path.slice(1) : path}`;\n}\n","/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { debugFail } from './assert';\n\nexport class FetchProvider {\n  private static fetchImpl: typeof fetch | null;\n  private static headersImpl: typeof Headers | null;\n  private static responseImpl: typeof Response | null;\n\n  static initialize(\n    fetchImpl: typeof fetch,\n    headersImpl?: typeof Headers,\n    responseImpl?: typeof Response\n  ): void {\n    this.fetchImpl = fetchImpl;\n    if (headersImpl) {\n      this.headersImpl = headersImpl;\n    }\n    if (responseImpl) {\n      this.responseImpl = responseImpl;\n    }\n  }\n\n  static fetch(): typeof fetch {\n    if (this.fetchImpl) {\n      return this.fetchImpl;\n    }\n    if (typeof self !== 'undefined' && 'fetch' in self) {\n      return self.fetch;\n    }\n    debugFail(\n      'Could not find fetch implementation, make sure you call FetchProvider.initialize() with an appropriate polyfill'\n    );\n  }\n\n  static headers(): typeof Headers {\n    if (this.headersImpl) {\n      return this.headersImpl;\n    }\n    if (typeof self !== 'undefined' && 'Headers' in self) {\n      return self.Headers;\n    }\n    debugFail(\n      'Could not find Headers implementation, make sure you call FetchProvider.initialize() with an appropriate polyfill'\n    );\n  }\n\n  static response(): typeof Response {\n    if (this.responseImpl) {\n      return this.responseImpl;\n    }\n    if (typeof self !== 'undefined' && 'Response' in self) {\n      return self.Response;\n    }\n    debugFail(\n      'Could not find Response implementation, make sure you call FetchProvider.initialize() with an appropriate polyfill'\n    );\n  }\n}\n","/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { AuthErrorCode } from '../core/errors';\n\n/**\n * Errors that can be returned by the backend\n */\nexport const enum ServerError {\n  ADMIN_ONLY_OPERATION = 'ADMIN_ONLY_OPERATION',\n  BLOCKING_FUNCTION_ERROR_RESPONSE = 'BLOCKING_FUNCTION_ERROR_RESPONSE',\n  CAPTCHA_CHECK_FAILED = 'CAPTCHA_CHECK_FAILED',\n  CORS_UNSUPPORTED = 'CORS_UNSUPPORTED',\n  CREDENTIAL_MISMATCH = 'CREDENTIAL_MISMATCH',\n  CREDENTIAL_TOO_OLD_LOGIN_AGAIN = 'CREDENTIAL_TOO_OLD_LOGIN_AGAIN',\n  DYNAMIC_LINK_NOT_ACTIVATED = 'DYNAMIC_LINK_NOT_ACTIVATED',\n  EMAIL_CHANGE_NEEDS_VERIFICATION = 'EMAIL_CHANGE_NEEDS_VERIFICATION',\n  EMAIL_EXISTS = 'EMAIL_EXISTS',\n  EMAIL_NOT_FOUND = 'EMAIL_NOT_FOUND',\n  EXPIRED_OOB_CODE = 'EXPIRED_OOB_CODE',\n  FEDERATED_USER_ID_ALREADY_LINKED = 'FEDERATED_USER_ID_ALREADY_LINKED',\n  INVALID_APP_CREDENTIAL = 'INVALID_APP_CREDENTIAL',\n  INVALID_APP_ID = 'INVALID_APP_ID',\n  INVALID_CERT_HASH = 'INVALID_CERT_HASH',\n  INVALID_CODE = 'INVALID_CODE',\n  INVALID_CONTINUE_URI = 'INVALID_CONTINUE_URI',\n  INVALID_CUSTOM_TOKEN = 'INVALID_CUSTOM_TOKEN',\n  INVALID_DYNAMIC_LINK_DOMAIN = 'INVALID_DYNAMIC_LINK_DOMAIN',\n  INVALID_EMAIL = 'INVALID_EMAIL',\n  INVALID_ID_TOKEN = 'INVALID_ID_TOKEN',\n  INVALID_IDP_RESPONSE = 'INVALID_IDP_RESPONSE',\n  INVALID_IDENTIFIER = 'INVALID_IDENTIFIER',\n  INVALID_MESSAGE_PAYLOAD = 'INVALID_MESSAGE_PAYLOAD',\n  INVALID_MFA_PENDING_CREDENTIAL = 'INVALID_MFA_PENDING_CREDENTIAL',\n  INVALID_OAUTH_CLIENT_ID = 'INVALID_OAUTH_CLIENT_ID',\n  INVALID_OOB_CODE = 'INVALID_OOB_CODE',\n  INVALID_PASSWORD = 'INVALID_PASSWORD',\n  INVALID_PENDING_TOKEN = 'INVALID_PENDING_TOKEN',\n  INVALID_PHONE_NUMBER = 'INVALID_PHONE_NUMBER',\n  INVALID_PROVIDER_ID = 'INVALID_PROVIDER_ID',\n  INVALID_RECIPIENT_EMAIL = 'INVALID_RECIPIENT_EMAIL',\n  INVALID_SENDER = 'INVALID_SENDER',\n  INVALID_SESSION_INFO = 'INVALID_SESSION_INFO',\n  INVALID_TEMPORARY_PROOF = 'INVALID_TEMPORARY_PROOF',\n  INVALID_TENANT_ID = 'INVALID_TENANT_ID',\n  MFA_ENROLLMENT_NOT_FOUND = 'MFA_ENROLLMENT_NOT_FOUND',\n  MISSING_ANDROID_PACKAGE_NAME = 'MISSING_ANDROID_PACKAGE_NAME',\n  MISSING_APP_CREDENTIAL = 'MISSING_APP_CREDENTIAL',\n  MISSING_CODE = 'MISSING_CODE',\n  MISSING_CONTINUE_URI = 'MISSING_CONTINUE_URI',\n  MISSING_CUSTOM_TOKEN = 'MISSING_CUSTOM_TOKEN',\n  MISSING_IOS_BUNDLE_ID = 'MISSING_IOS_BUNDLE_ID',\n  MISSING_MFA_ENROLLMENT_ID = 'MISSING_MFA_ENROLLMENT_ID',\n  MISSING_MFA_PENDING_CREDENTIAL = 'MISSING_MFA_PENDING_CREDENTIAL',\n  MISSING_OOB_CODE = 'MISSING_OOB_CODE',\n  MISSING_OR_INVALID_NONCE = 'MISSING_OR_INVALID_NONCE',\n  MISSING_PASSWORD = 'MISSING_PASSWORD',\n  MISSING_REQ_TYPE = 'MISSING_REQ_TYPE',\n  MISSING_PHONE_NUMBER = 'MISSING_PHONE_NUMBER',\n  MISSING_SESSION_INFO = 'MISSING_SESSION_INFO',\n  OPERATION_NOT_ALLOWED = 'OPERATION_NOT_ALLOWED',\n  PASSWORD_LOGIN_DISABLED = 'PASSWORD_LOGIN_DISABLED',\n  QUOTA_EXCEEDED = 'QUOTA_EXCEEDED',\n  RESET_PASSWORD_EXCEED_LIMIT = 'RESET_PASSWORD_EXCEED_LIMIT',\n  REJECTED_CREDENTIAL = 'REJECTED_CREDENTIAL',\n  SECOND_FACTOR_EXISTS = 'SECOND_FACTOR_EXISTS',\n  SECOND_FACTOR_LIMIT_EXCEEDED = 'SECOND_FACTOR_LIMIT_EXCEEDED',\n  SESSION_EXPIRED = 'SESSION_EXPIRED',\n  TENANT_ID_MISMATCH = 'TENANT_ID_MISMATCH',\n  TOKEN_EXPIRED = 'TOKEN_EXPIRED',\n  TOO_MANY_ATTEMPTS_TRY_LATER = 'TOO_MANY_ATTEMPTS_TRY_LATER',\n  UNSUPPORTED_FIRST_FACTOR = 'UNSUPPORTED_FIRST_FACTOR',\n  UNSUPPORTED_TENANT_OPERATION = 'UNSUPPORTED_TENANT_OPERATION',\n  UNAUTHORIZED_DOMAIN = 'UNAUTHORIZED_DOMAIN',\n  UNVERIFIED_EMAIL = 'UNVERIFIED_EMAIL',\n  USER_CANCELLED = 'USER_CANCELLED',\n  USER_DISABLED = 'USER_DISABLED',\n  USER_NOT_FOUND = 'USER_NOT_FOUND',\n  WEAK_PASSWORD = 'WEAK_PASSWORD'\n}\n\n/**\n * API Response in the event of an error\n */\nexport interface JsonError {\n  error: {\n    code: number;\n    message: string;\n    errors?: [\n      {\n        message: ServerError;\n        domain: string;\n        reason: string;\n      }\n    ];\n  };\n}\n\n/**\n * Type definition for a map from server errors to developer visible errors\n */\nexport declare type ServerErrorMap<ApiError extends string> = {\n  readonly [K in ApiError]: AuthErrorCode;\n};\n\n/**\n * Map from errors returned by the server to errors to developer visible errors\n */\nexport const SERVER_ERROR_MAP: Partial<ServerErrorMap<ServerError>> = {\n  // Custom token errors.\n  [ServerError.CREDENTIAL_MISMATCH]: AuthErrorCode.CREDENTIAL_MISMATCH,\n  // This can only happen if the SDK sends a bad request.\n  [ServerError.MISSING_CUSTOM_TOKEN]: AuthErrorCode.INTERNAL_ERROR,\n\n  // Create Auth URI errors.\n  [ServerError.INVALID_IDENTIFIER]: AuthErrorCode.INVALID_EMAIL,\n  // This can only happen if the SDK sends a bad request.\n  [ServerError.MISSING_CONTINUE_URI]: AuthErrorCode.INTERNAL_ERROR,\n\n  // Sign in with email and password errors (some apply to sign up too).\n  [ServerError.INVALID_PASSWORD]: AuthErrorCode.INVALID_PASSWORD,\n  // This can only happen if the SDK sends a bad request.\n  [ServerError.MISSING_PASSWORD]: AuthErrorCode.INTERNAL_ERROR,\n\n  // Sign up with email and password errors.\n  [ServerError.EMAIL_EXISTS]: AuthErrorCode.EMAIL_EXISTS,\n  [ServerError.PASSWORD_LOGIN_DISABLED]: AuthErrorCode.OPERATION_NOT_ALLOWED,\n\n  // Verify assertion for sign in with credential errors:\n  [ServerError.INVALID_IDP_RESPONSE]: AuthErrorCode.INVALID_IDP_RESPONSE,\n  [ServerError.INVALID_PENDING_TOKEN]: AuthErrorCode.INVALID_IDP_RESPONSE,\n  [ServerError.FEDERATED_USER_ID_ALREADY_LINKED]:\n    AuthErrorCode.CREDENTIAL_ALREADY_IN_USE,\n\n  // This can only happen if the SDK sends a bad request.\n  [ServerError.MISSING_REQ_TYPE]: AuthErrorCode.INTERNAL_ERROR,\n\n  // Send Password reset email errors:\n  [ServerError.EMAIL_NOT_FOUND]: AuthErrorCode.USER_DELETED,\n  [ServerError.RESET_PASSWORD_EXCEED_LIMIT]:\n    AuthErrorCode.TOO_MANY_ATTEMPTS_TRY_LATER,\n\n  [ServerError.EXPIRED_OOB_CODE]: AuthErrorCode.EXPIRED_OOB_CODE,\n  [ServerError.INVALID_OOB_CODE]: AuthErrorCode.INVALID_OOB_CODE,\n  // This can only happen if the SDK sends a bad request.\n  [ServerError.MISSING_OOB_CODE]: AuthErrorCode.INTERNAL_ERROR,\n\n  // Operations that require ID token in request:\n  [ServerError.CREDENTIAL_TOO_OLD_LOGIN_AGAIN]:\n    AuthErrorCode.CREDENTIAL_TOO_OLD_LOGIN_AGAIN,\n  [ServerError.INVALID_ID_TOKEN]: AuthErrorCode.INVALID_AUTH,\n  [ServerError.TOKEN_EXPIRED]: AuthErrorCode.TOKEN_EXPIRED,\n  [ServerError.USER_NOT_FOUND]: AuthErrorCode.TOKEN_EXPIRED,\n\n  // Other errors.\n  [ServerError.TOO_MANY_ATTEMPTS_TRY_LATER]:\n    AuthErrorCode.TOO_MANY_ATTEMPTS_TRY_LATER,\n\n  // Phone Auth related errors.\n  [ServerError.INVALID_CODE]: AuthErrorCode.INVALID_CODE,\n  [ServerError.INVALID_SESSION_INFO]: AuthErrorCode.INVALID_SESSION_INFO,\n  [ServerError.INVALID_TEMPORARY_PROOF]: AuthErrorCode.INVALID_IDP_RESPONSE,\n  [ServerError.MISSING_SESSION_INFO]: AuthErrorCode.MISSING_SESSION_INFO,\n  [ServerError.SESSION_EXPIRED]: AuthErrorCode.CODE_EXPIRED,\n\n  // Other action code errors when additional settings passed.\n  // MISSING_CONTINUE_URI is getting mapped to INTERNAL_ERROR above.\n  // This is OK as this error will be caught by client side validation.\n  [ServerError.MISSING_ANDROID_PACKAGE_NAME]:\n    AuthErrorCode.MISSING_ANDROID_PACKAGE_NAME,\n  [ServerError.UNAUTHORIZED_DOMAIN]: AuthErrorCode.UNAUTHORIZED_DOMAIN,\n\n  // getProjectConfig errors when clientId is passed.\n  [ServerError.INVALID_OAUTH_CLIENT_ID]: AuthErrorCode.INVALID_OAUTH_CLIENT_ID,\n\n  // User actions (sign-up or deletion) disabled errors.\n  [ServerError.ADMIN_ONLY_OPERATION]: AuthErrorCode.ADMIN_ONLY_OPERATION,\n\n  // Multi factor related errors.\n  [ServerError.INVALID_MFA_PENDING_CREDENTIAL]:\n    AuthErrorCode.INVALID_MFA_SESSION,\n  [ServerError.MFA_ENROLLMENT_NOT_FOUND]: AuthErrorCode.MFA_INFO_NOT_FOUND,\n  [ServerError.MISSING_MFA_ENROLLMENT_ID]: AuthErrorCode.MISSING_MFA_INFO,\n  [ServerError.MISSING_MFA_PENDING_CREDENTIAL]:\n    AuthErrorCode.MISSING_MFA_SESSION,\n  [ServerError.SECOND_FACTOR_EXISTS]:\n    AuthErrorCode.SECOND_FACTOR_ALREADY_ENROLLED,\n  [ServerError.SECOND_FACTOR_LIMIT_EXCEEDED]:\n    AuthErrorCode.SECOND_FACTOR_LIMIT_EXCEEDED,\n\n  // Blocking functions related errors.\n  [ServerError.BLOCKING_FUNCTION_ERROR_RESPONSE]: AuthErrorCode.INTERNAL_ERROR,\n};\n","/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { FirebaseError, querystring } from '@firebase/util';\n\nimport { AuthErrorCode, NamedErrorParams } from '../core/errors';\nimport { _createError, _errorWithCustomMessage, _fail } from '../core/util/assert';\nimport { Delay } from '../core/util/delay';\nimport { _emulatorUrl } from '../core/util/emulator';\nimport { FetchProvider } from '../core/util/fetch_provider';\nimport { Auth } from '../model/public_types';\nimport { AuthInternal, ConfigInternal } from '../model/auth';\nimport { IdTokenResponse, TaggedWithTokenResponse } from '../model/id_token';\nimport { IdTokenMfaResponse } from './authentication/mfa';\nimport { SERVER_ERROR_MAP, ServerError, ServerErrorMap } from './errors';\n\nexport const enum HttpMethod {\n  POST = 'POST',\n  GET = 'GET'\n}\n\nexport const enum HttpHeader {\n  CONTENT_TYPE = 'Content-Type',\n  X_FIREBASE_LOCALE = 'X-Firebase-Locale',\n  X_CLIENT_VERSION = 'X-Client-Version',\n  X_FIREBASE_GMPID = 'X-Firebase-gmpid',\n  X_FIREBASE_CLIENT = 'X-Firebase-Client',\n}\n\nexport const enum Endpoint {\n  CREATE_AUTH_URI = '/v1/accounts:createAuthUri',\n  DELETE_ACCOUNT = '/v1/accounts:delete',\n  RESET_PASSWORD = '/v1/accounts:resetPassword',\n  SIGN_UP = '/v1/accounts:signUp',\n  SIGN_IN_WITH_CUSTOM_TOKEN = '/v1/accounts:signInWithCustomToken',\n  SIGN_IN_WITH_EMAIL_LINK = '/v1/accounts:signInWithEmailLink',\n  SIGN_IN_WITH_IDP = '/v1/accounts:signInWithIdp',\n  SIGN_IN_WITH_PASSWORD = '/v1/accounts:signInWithPassword',\n  SIGN_IN_WITH_PHONE_NUMBER = '/v1/accounts:signInWithPhoneNumber',\n  SEND_VERIFICATION_CODE = '/v1/accounts:sendVerificationCode',\n  SEND_OOB_CODE = '/v1/accounts:sendOobCode',\n  SET_ACCOUNT_INFO = '/v1/accounts:update',\n  GET_ACCOUNT_INFO = '/v1/accounts:lookup',\n  GET_RECAPTCHA_PARAM = '/v1/recaptchaParams',\n  START_PHONE_MFA_ENROLLMENT = '/v2/accounts/mfaEnrollment:start',\n  FINALIZE_PHONE_MFA_ENROLLMENT = '/v2/accounts/mfaEnrollment:finalize',\n  START_PHONE_MFA_SIGN_IN = '/v2/accounts/mfaSignIn:start',\n  FINALIZE_PHONE_MFA_SIGN_IN = '/v2/accounts/mfaSignIn:finalize',\n  WITHDRAW_MFA = '/v2/accounts/mfaEnrollment:withdraw',\n  GET_PROJECT_CONFIG = '/v1/projects'\n}\n\nexport const DEFAULT_API_TIMEOUT_MS = new Delay(30_000, 60_000);\n\nexport function _addTidIfNecessary<T extends { tenantId?: string }>(\n  auth: Auth,\n  request: T\n): T {\n  if (auth.tenantId && !request.tenantId) {\n    return {\n      ...request,\n      tenantId: auth.tenantId\n    };\n  }\n  return request;\n}\n\nexport async function _performApiRequest<T, V>(\n  auth: Auth,\n  method: HttpMethod,\n  path: Endpoint,\n  request?: T,\n  customErrorMap: Partial<ServerErrorMap<ServerError>> = {}\n): Promise<V> {\n  return _performFetchWithErrorHandling(auth, customErrorMap, async () => {\n    let body = {};\n    let params = {};\n    if (request) {\n      if (method === HttpMethod.GET) {\n        params = request;\n      } else {\n        body = {\n          body: JSON.stringify(request)\n        };\n      }\n    }\n\n    const query = querystring({\n      key: auth.config.apiKey,\n      ...params\n    }).slice(1);\n\n    const headers = await (auth as AuthInternal)._getAdditionalHeaders();\n    headers[HttpHeader.CONTENT_TYPE] = 'application/json';\n\n    if (auth.languageCode) {\n      headers[HttpHeader.X_FIREBASE_LOCALE] = auth.languageCode;\n    }\n\n    return FetchProvider.fetch()(\n      _getFinalTarget(auth, auth.config.apiHost, path, query),\n      {\n        method,\n        headers,\n        referrerPolicy: 'no-referrer',\n        ...body\n      }\n    );\n  });\n}\n\nexport async function _performFetchWithErrorHandling<V>(\n  auth: Auth,\n  customErrorMap: Partial<ServerErrorMap<ServerError>>,\n  fetchFn: () => Promise<Response>\n): Promise<V> {\n  (auth as AuthInternal)._canInitEmulator = false;\n  const errorMap = { ...SERVER_ERROR_MAP, ...customErrorMap };\n  try {\n    const networkTimeout = new NetworkTimeout<Response>(auth);\n    const response: Response = await Promise.race<Promise<Response>>([\n      fetchFn(),\n      networkTimeout.promise\n    ]);\n\n    // If we've reached this point, the fetch succeeded and the networkTimeout\n    // didn't throw; clear the network timeout delay so that Node won't hang\n    networkTimeout.clearNetworkTimeout();\n\n    const json = await response.json();\n    if ('needConfirmation' in json) {\n      throw _makeTaggedError(auth, AuthErrorCode.NEED_CONFIRMATION, json);\n    }\n\n    if (response.ok && !('errorMessage' in json)) {\n      return json;\n    } else {\n      const errorMessage = response.ok ? json.errorMessage : json.error.message;\n      const [serverErrorCode, serverErrorMessage] = errorMessage.split(' : ');\n      if (serverErrorCode === ServerError.FEDERATED_USER_ID_ALREADY_LINKED) {\n        throw _makeTaggedError(\n          auth,\n          AuthErrorCode.CREDENTIAL_ALREADY_IN_USE,\n          json\n        );\n      } else if (serverErrorCode === ServerError.EMAIL_EXISTS) {\n        throw _makeTaggedError(auth, AuthErrorCode.EMAIL_EXISTS, json);\n      } else if (serverErrorCode === ServerError.USER_DISABLED) {\n        throw _makeTaggedError(auth, AuthErrorCode.USER_DISABLED, json);\n      }\n      const authError =\n        errorMap[serverErrorCode as ServerError] ||\n        ((serverErrorCode\n          .toLowerCase()\n          .replace(/[_\\s]+/g, '-') as unknown) as AuthErrorCode);\n      if (serverErrorMessage) {\n        throw _errorWithCustomMessage(auth, authError, serverErrorMessage);\n      } else {\n        _fail(auth, authError);\n      }\n    }\n  } catch (e) {\n    if (e instanceof FirebaseError) {\n      throw e;\n    }\n    _fail(auth, AuthErrorCode.NETWORK_REQUEST_FAILED);\n  }\n}\n\nexport async function _performSignInRequest<T, V extends IdTokenResponse>(\n  auth: Auth,\n  method: HttpMethod,\n  path: Endpoint,\n  request?: T,\n  customErrorMap: Partial<ServerErrorMap<ServerError>> = {}\n): Promise<V> {\n  const serverResponse = (await _performApiRequest<T, V | IdTokenMfaResponse>(\n    auth,\n    method,\n    path,\n    request,\n    customErrorMap\n  )) as V;\n  if ('mfaPendingCredential' in serverResponse) {\n    _fail(auth, AuthErrorCode.MFA_REQUIRED, {\n      _serverResponse: serverResponse\n    });\n  }\n\n  return serverResponse;\n}\n\nexport function _getFinalTarget(\n  auth: Auth,\n  host: string,\n  path: string,\n  query: string\n): string {\n  const base = `${host}${path}?${query}`;\n\n  if (!(auth as AuthInternal).config.emulator) {\n    return `${auth.config.apiScheme}://${base}`;\n  }\n\n  return _emulatorUrl(auth.config as ConfigInternal, base);\n}\n\nclass NetworkTimeout<T> {\n  // Node timers and browser timers are fundamentally incompatible, but we\n  // don't care about the value here\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  private timer: any | null = null;\n  readonly promise = new Promise<T>((_, reject) => {\n    this.timer = setTimeout(() => {\n      return reject(_createError(this.auth, AuthErrorCode.NETWORK_REQUEST_FAILED));\n    }, DEFAULT_API_TIMEOUT_MS.get());\n  });\n\n  clearNetworkTimeout(): void {\n    clearTimeout(this.timer);\n  }\n\n  constructor(private readonly auth: Auth) {}\n}\n\ninterface PotentialResponse extends IdTokenResponse {\n  email?: string;\n  phoneNumber?: string;\n}\n\nexport function _makeTaggedError(\n  auth: Auth,\n  code: AuthErrorCode,\n  response: PotentialResponse\n): FirebaseError {\n  const errorParams: NamedErrorParams = {\n    appName: auth.name\n  };\n\n  if (response.email) {\n    errorParams.email = response.email;\n  }\n  if (response.phoneNumber) {\n    errorParams.phoneNumber = response.phoneNumber;\n  }\n\n  const error = _createError(auth, code, errorParams);\n\n  // We know customData is defined on error because errorParams is defined\n  (error.customData! as TaggedWithTokenResponse)._tokenResponse = response;\n  return error;\n}\n","/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { Endpoint, HttpMethod, _performApiRequest } from '../index';\nimport { MfaEnrollment } from './mfa';\nimport { Auth } from '../../model/public_types';\n\nexport interface DeleteAccountRequest {\n  idToken: string;\n}\n\nexport async function deleteAccount(\n  auth: Auth,\n  request: DeleteAccountRequest\n): Promise<void> {\n  return _performApiRequest<DeleteAccountRequest, void>(\n    auth,\n    HttpMethod.POST,\n    Endpoint.DELETE_ACCOUNT,\n    request\n  );\n}\n\nexport interface ProviderUserInfo {\n  providerId: string;\n  rawId?: string;\n  email?: string;\n  displayName?: string;\n  photoUrl?: string;\n  phoneNumber?: string;\n}\n\nexport interface DeleteLinkedAccountsRequest {\n  idToken: string;\n  deleteProvider: string[];\n}\n\nexport interface DeleteLinkedAccountsResponse {\n  providerUserInfo: ProviderUserInfo[];\n}\n\nexport async function deleteLinkedAccounts(\n  auth: Auth,\n  request: DeleteLinkedAccountsRequest\n): Promise<DeleteLinkedAccountsResponse> {\n  return _performApiRequest<\n    DeleteLinkedAccountsRequest,\n    DeleteLinkedAccountsResponse\n  >(auth, HttpMethod.POST, Endpoint.SET_ACCOUNT_INFO, request);\n}\n\nexport interface APIUserInfo {\n  localId?: string;\n  displayName?: string;\n  photoUrl?: string;\n  email?: string;\n  emailVerified?: boolean;\n  phoneNumber?: string;\n  lastLoginAt?: number;\n  createdAt?: number;\n  tenantId?: string;\n  passwordHash?: string;\n  providerUserInfo?: ProviderUserInfo[];\n  mfaInfo?: MfaEnrollment[];\n}\n\nexport interface GetAccountInfoRequest {\n  idToken: string;\n}\n\nexport interface GetAccountInfoResponse {\n  users: APIUserInfo[];\n}\n\nexport async function getAccountInfo(\n  auth: Auth,\n  request: GetAccountInfoRequest\n): Promise<GetAccountInfoResponse> {\n  return _performApiRequest<GetAccountInfoRequest, GetAccountInfoResponse>(\n    auth,\n    HttpMethod.POST,\n    Endpoint.GET_ACCOUNT_INFO,\n    request\n  );\n}\n","/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nexport function utcTimestampToDateString(\n  utcTimestamp?: string | number\n): string | undefined {\n  if (!utcTimestamp) {\n    return undefined;\n  }\n  try {\n    // Convert to date object.\n    const date = new Date(Number(utcTimestamp));\n    // Test date is valid.\n    if (!isNaN(date.getTime())) {\n      // Convert to UTC date string.\n      return date.toUTCString();\n    }\n  } catch (e) {\n    // Do nothing. undefined will be returned.\n  }\n  return undefined;\n}\n","/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { IdTokenResult, ParsedToken, User } from '../../model/public_types';\nimport { base64Decode, getModularInstance } from '@firebase/util';\n\nimport { UserInternal } from '../../model/user';\nimport { _assert } from '../util/assert';\nimport { _logError } from '../util/log';\nimport { utcTimestampToDateString } from '../util/time';\nimport { AuthErrorCode } from '../errors';\n\n/**\n * Returns a JSON Web Token (JWT) used to identify the user to a Firebase service.\n *\n * @remarks\n * Returns the current token if it has not expired or if it will not expire in the next five\n * minutes. Otherwise, this will refresh the token and return a new one.\n *\n * @param user - The user.\n * @param forceRefresh - Force refresh regardless of token expiration.\n *\n * @public\n */\nexport function getIdToken(user: User, forceRefresh = false): Promise<string> {\n  return getModularInstance(user).getIdToken(forceRefresh);\n}\n\n/**\n * Returns a deserialized JSON Web Token (JWT) used to identitfy the user to a Firebase service.\n *\n * @remarks\n * Returns the current token if it has not expired or if it will not expire in the next five\n * minutes. Otherwise, this will refresh the token and return a new one.\n *\n * @param user - The user.\n * @param forceRefresh - Force refresh regardless of token expiration.\n *\n * @public\n */\nexport async function getIdTokenResult(\n  user: User,\n  forceRefresh = false\n): Promise<IdTokenResult> {\n  const userInternal = getModularInstance(user) as UserInternal;\n  const token = await userInternal.getIdToken(forceRefresh);\n  const claims = _parseToken(token);\n\n  _assert(\n    claims && claims.exp && claims.auth_time && claims.iat,\n    userInternal.auth,\n    AuthErrorCode.INTERNAL_ERROR\n  );\n  const firebase =\n    typeof claims.firebase === 'object' ? claims.firebase : undefined;\n\n  const signInProvider: string | undefined = firebase?.['sign_in_provider'];\n\n  return {\n    claims,\n    token,\n    authTime: utcTimestampToDateString(\n      secondsStringToMilliseconds(claims.auth_time)\n    )!,\n    issuedAtTime: utcTimestampToDateString(\n      secondsStringToMilliseconds(claims.iat)\n    )!,\n    expirationTime: utcTimestampToDateString(\n      secondsStringToMilliseconds(claims.exp)\n    )!,\n    signInProvider: signInProvider || null,\n    signInSecondFactor: firebase?.['sign_in_second_factor'] || null\n  };\n}\n\nfunction secondsStringToMilliseconds(seconds: string): number {\n  return Number(seconds) * 1000;\n}\n\nexport function _parseToken(token: string): ParsedToken | null {\n  const [algorithm, payload, signature] = token.split('.');\n  if (\n    algorithm === undefined ||\n    payload === undefined ||\n    signature === undefined\n  ) {\n    _logError('JWT malformed, contained fewer than 3 sections');\n    return null;\n  }\n\n  try {\n    const decoded = base64Decode(payload);\n    if (!decoded) {\n      _logError('Failed to decode base64 JWT payload');\n      return null;\n    }\n    return JSON.parse(decoded);\n  } catch (e) {\n    _logError('Caught error parsing JWT payload as JSON', e);\n    return null;\n  }\n}\n\n/**\n * Extract expiresIn TTL from a token by subtracting the expiration from the issuance.\n */\nexport function _tokenExpiresIn(token: string): number {\n  const parsedToken = _parseToken(token);\n  _assert(parsedToken, AuthErrorCode.INTERNAL_ERROR);\n  _assert(typeof parsedToken.exp !== 'undefined', AuthErrorCode.INTERNAL_ERROR);\n  _assert(typeof parsedToken.iat !== 'undefined', AuthErrorCode.INTERNAL_ERROR);\n  return Number(parsedToken.exp) - Number(parsedToken.iat);\n}\n","/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { FirebaseError } from '@firebase/util';\n\nimport { UserInternal } from '../../model/user';\nimport { AuthErrorCode } from '../errors';\n\nexport async function _logoutIfInvalidated<T>(\n  user: UserInternal,\n  promise: Promise<T>,\n  bypassAuthState = false\n): Promise<T> {\n  if (bypassAuthState) {\n    return promise;\n  }\n  try {\n    return await promise;\n  } catch (e) {\n    if (e instanceof FirebaseError && isUserInvalidated(e)) {\n      if (user.auth.currentUser === user) {\n        await user.auth.signOut();\n      }\n    }\n\n    throw e;\n  }\n}\n\nfunction isUserInvalidated({ code }: FirebaseError): boolean {\n  return (\n    code === `auth/${AuthErrorCode.USER_DISABLED}` ||\n    code === `auth/${AuthErrorCode.TOKEN_EXPIRED}`\n  );\n}\n","/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { UserInternal } from '../../model/user';\nimport { AuthErrorCode } from '../errors';\n\n// Refresh the token five minutes before expiration\nexport const enum Duration {\n  OFFSET = 5 * 1000 * 60,\n  RETRY_BACKOFF_MIN = 30 * 1000,\n  RETRY_BACKOFF_MAX = 16 * 60 * 1000\n}\n\nexport class ProactiveRefresh {\n  private isRunning = false;\n\n  // Node timers and browser timers return fundamentally different types.\n  // We don't actually care what the value is but TS won't accept unknown and\n  // we can't cast properly in both environments.\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  private timerId: any | null = null;\n  private errorBackoff = Duration.RETRY_BACKOFF_MIN;\n\n  constructor(private readonly user: UserInternal) {}\n\n  _start(): void {\n    if (this.isRunning) {\n      return;\n    }\n\n    this.isRunning = true;\n    this.schedule();\n  }\n\n  _stop(): void {\n    if (!this.isRunning) {\n      return;\n    }\n\n    this.isRunning = false;\n    if (this.timerId !== null) {\n      clearTimeout(this.timerId);\n    }\n  }\n\n  private getInterval(wasError: boolean): number {\n    if (wasError) {\n      const interval = this.errorBackoff;\n      this.errorBackoff = Math.min(\n        this.errorBackoff * 2,\n        Duration.RETRY_BACKOFF_MAX\n      );\n      return interval;\n    } else {\n      // Reset the error backoff\n      this.errorBackoff = Duration.RETRY_BACKOFF_MIN;\n      const expTime = this.user.stsTokenManager.expirationTime ?? 0;\n      const interval = expTime - Date.now() - Duration.OFFSET;\n\n      return Math.max(0, interval);\n    }\n  }\n\n  private schedule(wasError = false): void {\n    if (!this.isRunning) {\n      // Just in case...\n      return;\n    }\n\n    const interval = this.getInterval(wasError);\n    this.timerId = setTimeout(async () => {\n      await this.iteration();\n    }, interval);\n  }\n\n  private async iteration(): Promise<void> {\n    try {\n      await this.user.getIdToken(true);\n    } catch (e) {\n      // Only retry on network errors\n      if (e.code === `auth/${AuthErrorCode.NETWORK_REQUEST_FAILED}`) {\n        this.schedule(/* wasError */ true);\n      }\n\n      return;\n    }\n    this.schedule();\n  }\n}\n","/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { UserMetadata as UserMetadataType } from '../../model/public_types';\n\nimport { utcTimestampToDateString } from '../util/time';\n\nexport class UserMetadata implements UserMetadataType {\n  creationTime?: string;\n  lastSignInTime?: string;\n\n  constructor(\n    private createdAt?: string | number,\n    private lastLoginAt?: string | number\n  ) {\n    this._initializeTime();\n  }\n\n  private _initializeTime(): void {\n    this.lastSignInTime = utcTimestampToDateString(this.lastLoginAt);\n    this.creationTime = utcTimestampToDateString(this.createdAt);\n  }\n\n  _copy(metadata: UserMetadata): void {\n    this.createdAt = metadata.createdAt;\n    this.lastLoginAt = metadata.lastLoginAt;\n    this._initializeTime();\n  }\n\n  toJSON(): object {\n    return {\n      createdAt: this.createdAt,\n      lastLoginAt: this.lastLoginAt\n    };\n  }\n}\n","/**\n * @license\n * Copyright 2019 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { User, UserInfo } from '../../model/public_types';\n\nimport {\n  getAccountInfo,\n  ProviderUserInfo\n} from '../../api/account_management/account';\nimport { UserInternal } from '../../model/user';\nimport { AuthErrorCode } from '../errors';\nimport { _assert } from '../util/assert';\nimport { _logoutIfInvalidated } from './invalidation';\nimport { UserMetadata } from './user_metadata';\nimport { getModularInstance } from '@firebase/util';\n\nexport async function _reloadWithoutSaving(user: UserInternal): Promise<void> {\n  const auth = user.auth;\n  const idToken = await user.getIdToken();\n  const response = await _logoutIfInvalidated(\n    user,\n    getAccountInfo(auth, { idToken })\n  );\n\n  _assert(response?.users.length, auth, AuthErrorCode.INTERNAL_ERROR);\n\n  const coreAccount = response.users[0];\n\n  user._notifyReloadListener(coreAccount);\n\n  const newProviderData = coreAccount.providerUserInfo?.length\n    ? extractProviderData(coreAccount.providerUserInfo)\n    : [];\n\n  const providerData = mergeProviderData(user.providerData, newProviderData);\n\n  // Preserves the non-nonymous status of the stored user, even if no more\n  // credentials (federated or email/password) are linked to the user. If\n  // the user was previously anonymous, then use provider data to update.\n  // On the other hand, if it was not anonymous before, it should never be\n  // considered anonymous now.\n  const oldIsAnonymous = user.isAnonymous;\n  const newIsAnonymous =\n    !(user.email && coreAccount.passwordHash) && !providerData?.length;\n  const isAnonymous = !oldIsAnonymous ? false : newIsAnonymous;\n\n  const updates: Partial<UserInternal> = {\n    uid: coreAccount.localId,\n    displayName: coreAccount.displayName || null,\n    photoURL: coreAccount.photoUrl || null,\n    email: coreAccount.email || null,\n    emailVerified: coreAccount.emailVerified || false,\n    phoneNumber: coreAccount.phoneNumber || null,\n    tenantId: coreAccount.tenantId || null,\n    providerData,\n    metadata: new UserMetadata(coreAccount.createdAt, coreAccount.lastLoginAt),\n    isAnonymous\n  };\n\n  Object.assign(user, updates);\n}\n\n/**\n * Reloads user account data, if signed in.\n *\n * @param user - The user.\n *\n * @public\n */\nexport async function reload(user: User): Promise<void> {\n  const userInternal: UserInternal = getModularInstance(user) as UserInternal;\n  await _reloadWithoutSaving(userInternal);\n\n  // Even though the current user hasn't changed, update\n  // current user will trigger a persistence update w/ the\n  // new info.\n  await userInternal.auth._persistUserIfCurrent(userInternal);\n  userInternal.auth._notifyListenersIfCurrent(userInternal);\n}\n\nfunction mergeProviderData(\n  original: UserInfo[],\n  newData: UserInfo[]\n): UserInfo[] {\n  const deduped = original.filter(\n    o => !newData.some(n => n.providerId === o.providerId)\n  );\n  return [...deduped, ...newData];\n}\n\nfunction extractProviderData(providers: ProviderUserInfo[]): UserInfo[] {\n  return providers.map(({ providerId, ...provider }) => {\n    return {\n      providerId,\n      uid: provider.rawId || '',\n      displayName: provider.displayName || null,\n      email: provider.email || null,\n      phoneNumber: provider.phoneNumber || null,\n      photoURL: provider.photoUrl || null\n    };\n  });\n}\n","/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n/* eslint-disable camelcase */\n\nimport { querystring } from '@firebase/util';\n\nimport {\n  _getFinalTarget,\n  _performFetchWithErrorHandling,\n  HttpMethod,\n  HttpHeader\n} from '../index';\nimport { FetchProvider } from '../../core/util/fetch_provider';\nimport { Auth } from '../../model/public_types';\nimport { AuthInternal } from '../../model/auth';\n\nexport const enum Endpoint {\n  TOKEN = '/v1/token'\n}\n\n/** The server responses with snake_case; we convert to camelCase */\ninterface RequestStsTokenServerResponse {\n  access_token: string;\n  expires_in: string;\n  refresh_token: string;\n}\n\nexport interface RequestStsTokenResponse {\n  accessToken: string;\n  expiresIn: string;\n  refreshToken: string;\n}\n\nexport async function requestStsToken(\n  auth: Auth,\n  refreshToken: string\n): Promise<RequestStsTokenResponse> {\n  const response = await _performFetchWithErrorHandling<RequestStsTokenServerResponse>(\n    auth,\n    {},\n    async () => {\n      const body = querystring({\n        'grant_type': 'refresh_token',\n        'refresh_token': refreshToken\n      }).slice(1);\n      const { tokenApiHost, apiKey } = auth.config;\n      const url = _getFinalTarget(\n        auth,\n        tokenApiHost,\n        Endpoint.TOKEN,\n        `key=${apiKey}`\n      );\n\n      const headers = await (auth as AuthInternal)._getAdditionalHeaders();\n      headers[HttpHeader.CONTENT_TYPE] = 'application/x-www-form-urlencoded';\n\n      return FetchProvider.fetch()(url, {\n        method: HttpMethod.POST,\n        headers,\n        body\n      });\n    }\n  );\n\n  // The response comes back in snake_case. Convert to camel:\n  return {\n    accessToken: response.access_token,\n    expiresIn: response.expires_in,\n    refreshToken: response.refresh_token\n  };\n}\n","/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { FinalizeMfaResponse } from '../../api/authentication/mfa';\nimport { requestStsToken } from '../../api/authentication/token';\nimport { AuthInternal } from '../../model/auth';\nimport { IdTokenResponse } from '../../model/id_token';\nimport { AuthErrorCode } from '../errors';\nimport { PersistedBlob } from '../persistence';\nimport { _assert, debugFail } from '../util/assert';\nimport { _tokenExpiresIn } from './id_token_result';\n\n/**\n * The number of milliseconds before the official expiration time of a token\n * to refresh that token, to provide a buffer for RPCs to complete.\n */\nexport const enum Buffer {\n  TOKEN_REFRESH = 30_000\n}\n\n/**\n * We need to mark this class as internal explicitly to exclude it in the public typings, because\n * it references AuthInternal which has a circular dependency with UserInternal.\n *\n * @internal\n */\nexport class StsTokenManager {\n  refreshToken: string | null = null;\n  accessToken: string | null = null;\n  expirationTime: number | null = null;\n\n  get isExpired(): boolean {\n    return (\n      !this.expirationTime ||\n      Date.now() > this.expirationTime - Buffer.TOKEN_REFRESH\n    );\n  }\n\n  updateFromServerResponse(\n    response: IdTokenResponse | FinalizeMfaResponse\n  ): void {\n    _assert(response.idToken, AuthErrorCode.INTERNAL_ERROR);\n    _assert(\n      typeof response.idToken !== 'undefined',\n      AuthErrorCode.INTERNAL_ERROR\n    );\n    _assert(\n      typeof response.refreshToken !== 'undefined',\n      AuthErrorCode.INTERNAL_ERROR\n    );\n    const expiresIn =\n      'expiresIn' in response && typeof response.expiresIn !== 'undefined'\n        ? Number(response.expiresIn)\n        : _tokenExpiresIn(response.idToken);\n    this.updateTokensAndExpiration(\n      response.idToken,\n      response.refreshToken,\n      expiresIn\n    );\n  }\n\n  async getToken(\n    auth: AuthInternal,\n    forceRefresh = false\n  ): Promise<string | null> {\n    _assert(\n      !this.accessToken || this.refreshToken,\n      auth,\n      AuthErrorCode.TOKEN_EXPIRED\n    );\n\n    if (!forceRefresh && this.accessToken && !this.isExpired) {\n      return this.accessToken;\n    }\n\n    if (this.refreshToken) {\n      await this.refresh(auth, this.refreshToken!);\n      return this.accessToken;\n    }\n\n    return null;\n  }\n\n  clearRefreshToken(): void {\n    this.refreshToken = null;\n  }\n\n  private async refresh(auth: AuthInternal, oldToken: string): Promise<void> {\n    const { accessToken, refreshToken, expiresIn } = await requestStsToken(\n      auth,\n      oldToken\n    );\n    this.updateTokensAndExpiration(\n      accessToken,\n      refreshToken,\n      Number(expiresIn)\n    );\n  }\n\n  private updateTokensAndExpiration(\n    accessToken: string,\n    refreshToken: string,\n    expiresInSec: number\n  ): void {\n    this.refreshToken = refreshToken || null;\n    this.accessToken = accessToken || null;\n    this.expirationTime = Date.now() + expiresInSec * 1000;\n  }\n\n  static fromJSON(appName: string, object: PersistedBlob): StsTokenManager {\n    const { refreshToken, accessToken, expirationTime } = object;\n\n    const manager = new StsTokenManager();\n    if (refreshToken) {\n      _assert(typeof refreshToken === 'string', AuthErrorCode.INTERNAL_ERROR, {\n        appName\n      });\n      manager.refreshToken = refreshToken;\n    }\n    if (accessToken) {\n      _assert(typeof accessToken === 'string', AuthErrorCode.INTERNAL_ERROR, {\n        appName\n      });\n      manager.accessToken = accessToken;\n    }\n    if (expirationTime) {\n      _assert(\n        typeof expirationTime === 'number',\n        AuthErrorCode.INTERNAL_ERROR,\n        {\n          appName\n        }\n      );\n      manager.expirationTime = expirationTime;\n    }\n    return manager;\n  }\n\n  toJSON(): object {\n    return {\n      refreshToken: this.refreshToken,\n      accessToken: this.accessToken,\n      expirationTime: this.expirationTime\n    };\n  }\n\n  _assign(stsTokenManager: StsTokenManager): void {\n    this.accessToken = stsTokenManager.accessToken;\n    this.refreshToken = stsTokenManager.refreshToken;\n    this.expirationTime = stsTokenManager.expirationTime;\n  }\n\n  _clone(): StsTokenManager {\n    return Object.assign(new StsTokenManager(), this.toJSON());\n  }\n\n  _performRefresh(): never {\n    return debugFail('not implemented');\n  }\n}\n","/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { IdTokenResult } from '../../model/public_types';\nimport { NextFn } from '@firebase/util';\n\nimport {\n  APIUserInfo,\n  deleteAccount\n} from '../../api/account_management/account';\nimport { FinalizeMfaResponse } from '../../api/authentication/mfa';\nimport { AuthInternal } from '../../model/auth';\nimport { IdTokenResponse } from '../../model/id_token';\nimport {\n  MutableUserInfo,\n  UserInternal,\n  UserParameters\n} from '../../model/user';\nimport { AuthErrorCode } from '../errors';\nimport { PersistedBlob } from '../persistence';\nimport { _assert } from '../util/assert';\nimport { getIdTokenResult } from './id_token_result';\nimport { _logoutIfInvalidated } from './invalidation';\nimport { ProactiveRefresh } from './proactive_refresh';\nimport { _reloadWithoutSaving, reload } from './reload';\nimport { StsTokenManager } from './token_manager';\nimport { UserMetadata } from './user_metadata';\nimport { ProviderId } from '../../model/enums';\n\nfunction assertStringOrUndefined(\n  assertion: unknown,\n  appName: string\n): asserts assertion is string | undefined {\n  _assert(\n    typeof assertion === 'string' || typeof assertion === 'undefined',\n    AuthErrorCode.INTERNAL_ERROR,\n    { appName }\n  );\n}\n\nexport class UserImpl implements UserInternal {\n  // For the user object, provider is always Firebase.\n  readonly providerId = ProviderId.FIREBASE;\n  stsTokenManager: StsTokenManager;\n  // Last known accessToken so we know when it changes\n  private accessToken: string | null;\n\n  uid: string;\n  auth: AuthInternal;\n  emailVerified: boolean;\n  isAnonymous: boolean;\n  tenantId: string | null;\n  readonly metadata: UserMetadata;\n  providerData: MutableUserInfo[];\n\n  // Optional fields from UserInfo\n  displayName: string | null;\n  email: string | null;\n  phoneNumber: string | null;\n  photoURL: string | null;\n\n  _redirectEventId?: string;\n  private readonly proactiveRefresh = new ProactiveRefresh(this);\n\n  constructor({ uid, auth, stsTokenManager, ...opt }: UserParameters) {\n    this.uid = uid;\n    this.auth = auth;\n    this.stsTokenManager = stsTokenManager;\n    this.accessToken = stsTokenManager.accessToken;\n    this.displayName = opt.displayName || null;\n    this.email = opt.email || null;\n    this.emailVerified = opt.emailVerified || false;\n    this.phoneNumber = opt.phoneNumber || null;\n    this.photoURL = opt.photoURL || null;\n    this.isAnonymous = opt.isAnonymous || false;\n    this.tenantId = opt.tenantId || null;\n    this.providerData = opt.providerData ? [...opt.providerData] : [];\n    this.metadata = new UserMetadata(\n      opt.createdAt || undefined,\n      opt.lastLoginAt || undefined\n    );\n  }\n\n  async getIdToken(forceRefresh?: boolean): Promise<string> {\n    const accessToken = await _logoutIfInvalidated(\n      this,\n      this.stsTokenManager.getToken(this.auth, forceRefresh)\n    );\n    _assert(accessToken, this.auth, AuthErrorCode.INTERNAL_ERROR);\n\n    if (this.accessToken !== accessToken) {\n      this.accessToken = accessToken;\n      await this.auth._persistUserIfCurrent(this);\n      this.auth._notifyListenersIfCurrent(this);\n    }\n\n    return accessToken;\n  }\n\n  getIdTokenResult(forceRefresh?: boolean): Promise<IdTokenResult> {\n    return getIdTokenResult(this, forceRefresh);\n  }\n\n  reload(): Promise<void> {\n    return reload(this);\n  }\n\n  private reloadUserInfo: APIUserInfo | null = null;\n  private reloadListener: NextFn<APIUserInfo> | null = null;\n\n  _assign(user: UserInternal): void {\n    if (this === user) {\n      return;\n    }\n    _assert(this.uid === user.uid, this.auth, AuthErrorCode.INTERNAL_ERROR);\n    this.displayName = user.displayName;\n    this.photoURL = user.photoURL;\n    this.email = user.email;\n    this.emailVerified = user.emailVerified;\n    this.phoneNumber = user.phoneNumber;\n    this.isAnonymous = user.isAnonymous;\n    this.tenantId = user.tenantId;\n    this.providerData = user.providerData.map(userInfo => ({ ...userInfo }));\n    this.metadata._copy(user.metadata);\n    this.stsTokenManager._assign(user.stsTokenManager);\n  }\n\n  _clone(auth: AuthInternal): UserInternal {\n    return new UserImpl({\n      ...this,\n      auth,\n      stsTokenManager: this.stsTokenManager._clone()\n    });\n  }\n\n  _onReload(callback: NextFn<APIUserInfo>): void {\n    // There should only ever be one listener, and that is a single instance of MultiFactorUser\n    _assert(!this.reloadListener, this.auth, AuthErrorCode.INTERNAL_ERROR);\n    this.reloadListener = callback;\n    if (this.reloadUserInfo) {\n      this._notifyReloadListener(this.reloadUserInfo);\n      this.reloadUserInfo = null;\n    }\n  }\n\n  _notifyReloadListener(userInfo: APIUserInfo): void {\n    if (this.reloadListener) {\n      this.reloadListener(userInfo);\n    } else {\n      // If no listener is subscribed yet, save the result so it's available when they do subscribe\n      this.reloadUserInfo = userInfo;\n    }\n  }\n\n  _startProactiveRefresh(): void {\n    this.proactiveRefresh._start();\n  }\n\n  _stopProactiveRefresh(): void {\n    this.proactiveRefresh._stop();\n  }\n\n  async _updateTokensIfNecessary(\n    response: IdTokenResponse | FinalizeMfaResponse,\n    reload = false\n  ): Promise<void> {\n    let tokensRefreshed = false;\n    if (\n      response.idToken &&\n      response.idToken !== this.stsTokenManager.accessToken\n    ) {\n      this.stsTokenManager.updateFromServerResponse(response);\n      tokensRefreshed = true;\n    }\n\n    if (reload) {\n      await _reloadWithoutSaving(this);\n    }\n\n    await this.auth._persistUserIfCurrent(this);\n    if (tokensRefreshed) {\n      this.auth._notifyListenersIfCurrent(this);\n    }\n  }\n\n  async delete(): Promise<void> {\n    const idToken = await this.getIdToken();\n    await _logoutIfInvalidated(this, deleteAccount(this.auth, { idToken }));\n    this.stsTokenManager.clearRefreshToken();\n\n    // TODO: Determine if cancellable-promises are necessary to use in this class so that delete()\n    //       cancels pending actions...\n\n    return this.auth.signOut();\n  }\n\n  toJSON(): PersistedBlob {\n    return {\n      uid: this.uid,\n      email: this.email || undefined,\n      emailVerified: this.emailVerified,\n      displayName: this.displayName || undefined,\n      isAnonymous: this.isAnonymous,\n      photoURL: this.photoURL || undefined,\n      phoneNumber: this.phoneNumber || undefined,\n      tenantId: this.tenantId || undefined,\n      providerData: this.providerData.map(userInfo => ({ ...userInfo })),\n      stsTokenManager: this.stsTokenManager.toJSON(),\n      // Redirect event ID must be maintained in case there is a pending\n      // redirect event.\n      _redirectEventId: this._redirectEventId,\n      ...this.metadata.toJSON(),\n\n      // Required for compatibility with the legacy SDK (go/firebase-auth-sdk-persistence-parsing):\n      apiKey: this.auth.config.apiKey,\n      appName: this.auth.name\n      // Missing authDomain will be tolerated by the legacy SDK.\n      // stsTokenManager.apiKey isn't actually required (despite the legacy SDK persisting it).\n    };\n  }\n\n  get refreshToken(): string {\n    return this.stsTokenManager.refreshToken || '';\n  }\n\n  static _fromJSON(auth: AuthInternal, object: PersistedBlob): UserInternal {\n    const displayName = object.displayName ?? undefined;\n    const email = object.email ?? undefined;\n    const phoneNumber = object.phoneNumber ?? undefined;\n    const photoURL = object.photoURL ?? undefined;\n    const tenantId = object.tenantId ?? undefined;\n    const _redirectEventId = object._redirectEventId ?? undefined;\n    const createdAt = object.createdAt ?? undefined;\n    const lastLoginAt = object.lastLoginAt ?? undefined;\n    const {\n      uid,\n      emailVerified,\n      isAnonymous,\n      providerData,\n      stsTokenManager: plainObjectTokenManager\n    } = object;\n\n    _assert(uid && plainObjectTokenManager, auth, AuthErrorCode.INTERNAL_ERROR);\n\n    const stsTokenManager = StsTokenManager.fromJSON(\n      this.name,\n      plainObjectTokenManager as PersistedBlob\n    );\n\n    _assert(typeof uid === 'string', auth, AuthErrorCode.INTERNAL_ERROR);\n    assertStringOrUndefined(displayName, auth.name);\n    assertStringOrUndefined(email, auth.name);\n    _assert(\n      typeof emailVerified === 'boolean',\n      auth,\n      AuthErrorCode.INTERNAL_ERROR\n    );\n    _assert(\n      typeof isAnonymous === 'boolean',\n      auth,\n      AuthErrorCode.INTERNAL_ERROR\n    );\n    assertStringOrUndefined(phoneNumber, auth.name);\n    assertStringOrUndefined(photoURL, auth.name);\n    assertStringOrUndefined(tenantId, auth.name);\n    assertStringOrUndefined(_redirectEventId, auth.name);\n    assertStringOrUndefined(createdAt, auth.name);\n    assertStringOrUndefined(lastLoginAt, auth.name);\n    const user = new UserImpl({\n      uid,\n      auth,\n      email,\n      emailVerified,\n      displayName,\n      isAnonymous,\n      photoURL,\n      phoneNumber,\n      tenantId,\n      stsTokenManager,\n      createdAt,\n      lastLoginAt\n    });\n\n    if (providerData && Array.isArray(providerData)) {\n      user.providerData = providerData.map(userInfo => ({ ...userInfo }));\n    }\n\n    if (_redirectEventId) {\n      user._redirectEventId = _redirectEventId;\n    }\n\n    return user;\n  }\n\n  /**\n   * Initialize a User from an idToken server response\n   * @param auth\n   * @param idTokenResponse\n   */\n  static async _fromIdTokenResponse(\n    auth: AuthInternal,\n    idTokenResponse: IdTokenResponse,\n    isAnonymous: boolean = false\n  ): Promise<UserInternal> {\n    const stsTokenManager = new StsTokenManager();\n    stsTokenManager.updateFromServerResponse(idTokenResponse);\n\n    // Initialize the Firebase Auth user.\n    const user = new UserImpl({\n      uid: idTokenResponse.localId,\n      auth,\n      stsTokenManager,\n      isAnonymous\n    });\n\n    // Updates the user info and data and resolves with a user instance.\n    await _reloadWithoutSaving(user);\n    return user;\n  }\n}\n","/**\n * @license\n * Copyright 2019 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { Persistence } from '../../model/public_types';\n\nimport {\n  PersistenceInternal,\n  PersistenceType,\n  PersistenceValue,\n  StorageEventListener\n} from '../persistence';\n\nexport class InMemoryPersistence implements PersistenceInternal {\n  static type: 'NONE' = 'NONE';\n  readonly type = PersistenceType.NONE;\n  storage: Record<string, PersistenceValue> = {};\n\n  async _isAvailable(): Promise<boolean> {\n    return true;\n  }\n\n  async _set(key: string, value: PersistenceValue): Promise<void> {\n    this.storage[key] = value;\n  }\n\n  async _get<T extends PersistenceValue>(key: string): Promise<T | null> {\n    const value = this.storage[key];\n    return value === undefined ? null : (value as T);\n  }\n\n  async _remove(key: string): Promise<void> {\n    delete this.storage[key];\n  }\n\n  _addListener(_key: string, _listener: StorageEventListener): void {\n    // Listeners are not supported for in-memory storage since it cannot be shared across windows/workers\n    return;\n  }\n\n  _removeListener(_key: string, _listener: StorageEventListener): void {\n    // Listeners are not supported for in-memory storage since it cannot be shared across windows/workers\n    return;\n  }\n}\n\n/**\n * An implementation of {@link Persistence} of type 'NONE'.\n *\n * @public\n */\nexport const inMemoryPersistence: Persistence = InMemoryPersistence;\n","/**\n * @license\n * Copyright 2019 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { ApiKey, AppName, AuthInternal } from '../../model/auth';\nimport { UserInternal } from '../../model/user';\nimport { PersistedBlob, PersistenceInternal } from '../persistence';\nimport { UserImpl } from '../user/user_impl';\nimport { _getInstance } from '../util/instantiator';\nimport { inMemoryPersistence } from './in_memory';\n\nexport const enum KeyName {\n  AUTH_USER = 'authUser',\n  AUTH_EVENT = 'authEvent',\n  REDIRECT_USER = 'redirectUser',\n  PERSISTENCE_USER = 'persistence'\n}\nexport const enum Namespace {\n  PERSISTENCE = 'firebase'\n}\n\nexport function _persistenceKeyName(\n  key: string,\n  apiKey: ApiKey,\n  appName: AppName\n): string {\n  return `${Namespace.PERSISTENCE}:${key}:${apiKey}:${appName}`;\n}\n\nexport class PersistenceUserManager {\n  private readonly fullUserKey: string;\n  private readonly fullPersistenceKey: string;\n  private readonly boundEventHandler: () => void;\n\n  private constructor(\n    public persistence: PersistenceInternal,\n    private readonly auth: AuthInternal,\n    private readonly userKey: string\n  ) {\n    const { config, name } = this.auth;\n    this.fullUserKey = _persistenceKeyName(this.userKey, config.apiKey, name);\n    this.fullPersistenceKey = _persistenceKeyName(\n      KeyName.PERSISTENCE_USER,\n      config.apiKey,\n      name\n    );\n    this.boundEventHandler = auth._onStorageEvent.bind(auth);\n    this.persistence._addListener(this.fullUserKey, this.boundEventHandler);\n  }\n\n  setCurrentUser(user: UserInternal): Promise<void> {\n    return this.persistence._set(this.fullUserKey, user.toJSON());\n  }\n\n  async getCurrentUser(): Promise<UserInternal | null> {\n    const blob = await this.persistence._get<PersistedBlob>(this.fullUserKey);\n    return blob ? UserImpl._fromJSON(this.auth, blob) : null;\n  }\n\n  removeCurrentUser(): Promise<void> {\n    return this.persistence._remove(this.fullUserKey);\n  }\n\n  savePersistenceForRedirect(): Promise<void> {\n    return this.persistence._set(\n      this.fullPersistenceKey,\n      this.persistence.type\n    );\n  }\n\n  async setPersistence(newPersistence: PersistenceInternal): Promise<void> {\n    if (this.persistence === newPersistence) {\n      return;\n    }\n\n    const currentUser = await this.getCurrentUser();\n    await this.removeCurrentUser();\n\n    this.persistence = newPersistence;\n\n    if (currentUser) {\n      return this.setCurrentUser(currentUser);\n    }\n  }\n\n  delete(): void {\n    this.persistence._removeListener(this.fullUserKey, this.boundEventHandler);\n  }\n\n  static async create(\n    auth: AuthInternal,\n    persistenceHierarchy: PersistenceInternal[],\n    userKey = KeyName.AUTH_USER\n  ): Promise<PersistenceUserManager> {\n    if (!persistenceHierarchy.length) {\n      return new PersistenceUserManager(\n        _getInstance(inMemoryPersistence),\n        auth,\n        userKey\n      );\n    }\n\n    // Eliminate any persistences that are not available\n    const availablePersistences = (\n      await Promise.all(\n        persistenceHierarchy.map(async persistence => {\n          if (await persistence._isAvailable()) {\n            return persistence;\n          }\n          return undefined;\n        })\n      )\n    ).filter(persistence => persistence) as PersistenceInternal[];\n\n    // Fall back to the first persistence listed, or in memory if none available\n    let selectedPersistence =\n      availablePersistences[0] ||\n      _getInstance<PersistenceInternal>(inMemoryPersistence);\n\n    const key = _persistenceKeyName(userKey, auth.config.apiKey, auth.name);\n\n    // Pull out the existing user, setting the chosen persistence to that\n    // persistence if the user exists.\n    let userToMigrate: UserInternal | null = null;\n    // Note, here we check for a user in _all_ persistences, not just the\n    // ones deemed available. If we can migrate a user out of a broken\n    // persistence, we will (but only if that persistence supports migration).\n    for (const persistence of persistenceHierarchy) {\n      try {\n        const blob = await persistence._get<PersistedBlob>(key);\n        if (blob) {\n          const user = UserImpl._fromJSON(auth, blob); // throws for unparsable blob (wrong format)\n          if (persistence !== selectedPersistence) {\n            userToMigrate = user;\n          }\n          selectedPersistence = persistence;\n          break;\n        }\n      } catch {}\n    }\n\n    // If we find the user in a persistence that does support migration, use\n    // that migration path (of only persistences that support migration)\n    const migrationHierarchy = availablePersistences.filter(\n      p => p._shouldAllowMigration\n    );\n\n    // If the persistence does _not_ allow migration, just finish off here\n    if (\n      !selectedPersistence._shouldAllowMigration ||\n      !migrationHierarchy.length\n    ) {\n      return new PersistenceUserManager(selectedPersistence, auth, userKey);\n    }\n\n    selectedPersistence = migrationHierarchy[0];\n    if (userToMigrate) {\n      // This normally shouldn't throw since chosenPersistence.isAvailable() is true, but if it does\n      // we'll just let it bubble to surface the error.\n      await selectedPersistence._set(key, userToMigrate.toJSON());\n    }\n\n    // Attempt to clear the key in other persistences but ignore errors. This helps prevent issues\n    // such as users getting stuck with a previous account after signing out and refreshing the tab.\n    await Promise.all(\n      persistenceHierarchy.map(async persistence => {\n        if (persistence !== selectedPersistence) {\n          try {\n            await persistence._remove(key);\n          } catch {}\n        }\n      })\n    );\n    return new PersistenceUserManager(selectedPersistence, auth, userKey);\n  }\n}\n","/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { isIE, getUA } from '@firebase/util';\n\ninterface NavigatorStandalone extends Navigator {\n  standalone?: unknown;\n}\n\ninterface Document {\n  documentMode?: number;\n}\n\n/**\n * Enums for Browser name.\n */\nexport const enum BrowserName {\n  ANDROID = 'Android',\n  BLACKBERRY = 'Blackberry',\n  EDGE = 'Edge',\n  FIREFOX = 'Firefox',\n  IE = 'IE',\n  IEMOBILE = 'IEMobile',\n  OPERA = 'Opera',\n  OTHER = 'Other',\n  CHROME = 'Chrome',\n  SAFARI = 'Safari',\n  SILK = 'Silk',\n  WEBOS = 'Webos'\n}\n\n/**\n * Determine the browser for the purposes of reporting usage to the API\n */\nexport function _getBrowserName(userAgent: string): BrowserName | string {\n  const ua = userAgent.toLowerCase();\n  if (ua.includes('opera/') || ua.includes('opr/') || ua.includes('opios/')) {\n    return BrowserName.OPERA;\n  } else if (_isIEMobile(ua)) {\n    // Windows phone IEMobile browser.\n    return BrowserName.IEMOBILE;\n  } else if (ua.includes('msie') || ua.includes('trident/')) {\n    return BrowserName.IE;\n  } else if (ua.includes('edge/')) {\n    return BrowserName.EDGE;\n  } else if (_isFirefox(ua)) {\n    return BrowserName.FIREFOX;\n  } else if (ua.includes('silk/')) {\n    return BrowserName.SILK;\n  } else if (_isBlackBerry(ua)) {\n    // Blackberry browser.\n    return BrowserName.BLACKBERRY;\n  } else if (_isWebOS(ua)) {\n    // WebOS default browser.\n    return BrowserName.WEBOS;\n  } else if (_isSafari(ua)) {\n    return BrowserName.SAFARI;\n  } else if (\n    (ua.includes('chrome/') || _isChromeIOS(ua)) &&\n    !ua.includes('edge/')\n  ) {\n    return BrowserName.CHROME;\n  } else if (_isAndroid(ua)) {\n    // Android stock browser.\n    return BrowserName.ANDROID;\n  } else {\n    // Most modern browsers have name/version at end of user agent string.\n    const re = /([a-zA-Z\\d\\.]+)\\/[a-zA-Z\\d\\.]*$/;\n    const matches = userAgent.match(re);\n    if (matches?.length === 2) {\n      return matches[1];\n    }\n  }\n  return BrowserName.OTHER;\n}\n\nexport function _isFirefox(ua = getUA()): boolean {\n  return /firefox\\//i.test(ua);\n}\n\nexport function _isSafari(userAgent = getUA()): boolean {\n  const ua = userAgent.toLowerCase();\n  return (\n    ua.includes('safari/') &&\n    !ua.includes('chrome/') &&\n    !ua.includes('crios/') &&\n    !ua.includes('android')\n  );\n}\n\nexport function _isChromeIOS(ua = getUA()): boolean {\n  return /crios\\//i.test(ua);\n}\n\nexport function _isIEMobile(ua = getUA()): boolean {\n  return /iemobile/i.test(ua);\n}\n\nexport function _isAndroid(ua = getUA()): boolean {\n  return /android/i.test(ua);\n}\n\nexport function _isBlackBerry(ua = getUA()): boolean {\n  return /blackberry/i.test(ua);\n}\n\nexport function _isWebOS(ua = getUA()): boolean {\n  return /webos/i.test(ua);\n}\n\nexport function _isIOS(ua = getUA()): boolean {\n  return /iphone|ipad|ipod/i.test(ua);\n}\n\nexport function _isIOS7Or8(ua = getUA()): boolean {\n  return (\n    /(iPad|iPhone|iPod).*OS 7_\\d/i.test(ua) ||\n    /(iPad|iPhone|iPod).*OS 8_\\d/i.test(ua)\n  );\n}\n\nexport function _isIOSStandalone(ua = getUA()): boolean {\n  return _isIOS(ua) && !!(window.navigator as NavigatorStandalone)?.standalone;\n}\n\nexport function _isIE10(): boolean {\n  return isIE() && (document as Document).documentMode === 10;\n}\n\nexport function _isMobileBrowser(ua: string = getUA()): boolean {\n  // TODO: implement getBrowserName equivalent for OS.\n  return (\n    _isIOS(ua) ||\n    _isAndroid(ua) ||\n    _isWebOS(ua) ||\n    _isBlackBerry(ua) ||\n    /windows phone/i.test(ua) ||\n    _isIEMobile(ua)\n  );\n}\n\nexport function _isIframe(): boolean {\n  try {\n    // Check that the current window is not the top window.\n    // If so, return true.\n    return !!(window && window !== window.top);\n  } catch (e) {\n    return false;\n  }\n}\n","/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { SDK_VERSION } from '@firebase/app';\nimport { _getBrowserName } from './browser';\nimport { getUA } from '@firebase/util';\n\nexport const enum ClientImplementation {\n  CORE = 'JsCore'\n}\n\n/**\n * @internal\n */\nexport const enum ClientPlatform {\n  BROWSER = 'Browser',\n  NODE = 'Node',\n  REACT_NATIVE = 'ReactNative',\n  CORDOVA = 'Cordova',\n  WORKER = 'Worker'\n}\n\n/*\n * Determine the SDK version string\n */\nexport function _getClientVersion(\n  clientPlatform: ClientPlatform,\n  frameworks: readonly string[] = []\n): string {\n  let reportedPlatform: string;\n  switch (clientPlatform) {\n    case ClientPlatform.BROWSER:\n      // In a browser environment, report the browser name.\n      reportedPlatform = _getBrowserName(getUA());\n      break;\n    case ClientPlatform.WORKER:\n      // Technically a worker runs from a browser but we need to differentiate a\n      // worker from a browser.\n      // For example: Chrome-Worker/JsCore/4.9.1/FirebaseCore-web.\n      reportedPlatform = `${_getBrowserName(getUA())}-${clientPlatform}`;\n      break;\n    default:\n      reportedPlatform = clientPlatform;\n  }\n  const reportedFrameworks = frameworks.length\n    ? frameworks.join(',')\n    : 'FirebaseCore-web'; /* default value if no other framework is used */\n  return `${reportedPlatform}/${ClientImplementation.CORE}/${SDK_VERSION}/${reportedFrameworks}`;\n}\n","/**\n * @license\n * Copyright 2022 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { AuthInternal } from '../../model/auth';\nimport { Unsubscribe, User } from '../../model/public_types';\nimport { AuthErrorCode } from '../errors';\n\ninterface MiddlewareEntry {\n  (user: User | null): Promise<void>;\n  onAbort?: () => void;\n}\n\nexport class AuthMiddlewareQueue {\n  private readonly queue: MiddlewareEntry[] = [];\n\n  constructor(private readonly auth: AuthInternal) {}\n\n  pushCallback(\n      callback: (user: User | null) => void | Promise<void>,\n      onAbort?: () => void): Unsubscribe {\n    // The callback could be sync or async. Wrap it into a\n    // function that is always async.\n    const wrappedCallback: MiddlewareEntry =\n      (user: User | null): Promise<void> => new Promise((resolve, reject) => {\n        try {\n          const result = callback(user);\n          // Either resolve with existing promise or wrap a non-promise\n          // return value into a promise.\n          resolve(result);\n        } catch (e) {\n          // Sync callback throws.\n          reject(e);\n        }\n      });\n    // Attach the onAbort if present\n    wrappedCallback.onAbort = onAbort;\n    this.queue.push(wrappedCallback);\n\n    const index = this.queue.length - 1;\n    return () => {\n      // Unsubscribe. Replace with no-op. Do not remove from array, or it will disturb\n      // indexing of other elements.\n      this.queue[index] = () => Promise.resolve();\n    };\n  }\n\n  async runMiddleware(nextUser: User | null): Promise<void> {\n    if (this.auth.currentUser === nextUser) {\n      return;\n    }\n\n    // While running the middleware, build a temporary stack of onAbort\n    // callbacks to call if one middleware callback rejects.\n\n    const onAbortStack: Array<() => void> = [];\n    try {\n      for (const beforeStateCallback of this.queue) {\n        await beforeStateCallback(nextUser);\n\n        // Only push the onAbort if the callback succeeds\n        if (beforeStateCallback.onAbort) {\n          onAbortStack.push(beforeStateCallback.onAbort);\n        }\n      }\n    } catch (e) {\n      // Run all onAbort, with separate try/catch to ignore any errors and\n      // continue\n      onAbortStack.reverse();\n      for (const onAbort of onAbortStack) {\n        try {\n          onAbort();\n        } catch (_) { /* swallow error */}\n      }\n\n      throw this.auth._errorFactory.create(\n        AuthErrorCode.LOGIN_BLOCKED, { originalMessage: (e as Error)?.message });\n    }\n  }\n}\n","/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { _FirebaseService, FirebaseApp } from '@firebase/app';\nimport { Provider } from '@firebase/component';\nimport {\n  Auth,\n  AuthErrorMap,\n  AuthSettings,\n  EmulatorConfig,\n  NextOrObserver,\n  Persistence,\n  PopupRedirectResolver,\n  User,\n  UserCredential,\n  CompleteFn,\n  ErrorFn,\n  NextFn,\n  Unsubscribe\n} from '../../model/public_types';\nimport {\n  createSubscribe,\n  ErrorFactory,\n  getModularInstance,\n  Observer,\n  Subscribe\n} from '@firebase/util';\n\nimport { AuthInternal, ConfigInternal } from '../../model/auth';\nimport { PopupRedirectResolverInternal } from '../../model/popup_redirect';\nimport { UserInternal } from '../../model/user';\nimport {\n  AuthErrorCode,\n  AuthErrorParams,\n  ErrorMapRetriever,\n  _DEFAULT_AUTH_ERROR_FACTORY\n} from '../errors';\nimport { PersistenceInternal } from '../persistence';\nimport {\n  KeyName,\n  PersistenceUserManager\n} from '../persistence/persistence_user_manager';\nimport { _reloadWithoutSaving } from '../user/reload';\nimport { _assert } from '../util/assert';\nimport { _getInstance } from '../util/instantiator';\nimport { _getUserLanguage } from '../util/navigator';\nimport { _getClientVersion } from '../util/version';\nimport { HttpHeader } from '../../api';\nimport { AuthMiddlewareQueue } from './middleware';\n\ninterface AsyncAction {\n  (): Promise<void>;\n}\n\nexport const enum DefaultConfig {\n  TOKEN_API_HOST = 'securetoken.googleapis.com',\n  API_HOST = 'identitytoolkit.googleapis.com',\n  API_SCHEME = 'https'\n}\n\nexport class AuthImpl implements AuthInternal, _FirebaseService {\n  currentUser: User | null = null;\n  emulatorConfig: EmulatorConfig | null = null;\n  private operations = Promise.resolve();\n  private persistenceManager?: PersistenceUserManager;\n  private redirectPersistenceManager?: PersistenceUserManager;\n  private authStateSubscription = new Subscription<User>(this);\n  private idTokenSubscription = new Subscription<User>(this);\n  private readonly beforeStateQueue = new AuthMiddlewareQueue(this);\n  private redirectUser: UserInternal | null = null;\n  private isProactiveRefreshEnabled = false;\n\n  // Any network calls will set this to true and prevent subsequent emulator\n  // initialization\n  _canInitEmulator = true;\n  _isInitialized = false;\n  _deleted = false;\n  _initializationPromise: Promise<void> | null = null;\n  _popupRedirectResolver: PopupRedirectResolverInternal | null = null;\n  _errorFactory: ErrorFactory<AuthErrorCode, AuthErrorParams> =\n    _DEFAULT_AUTH_ERROR_FACTORY;\n  readonly name: string;\n\n  // Tracks the last notified UID for state change listeners to prevent\n  // repeated calls to the callbacks. Undefined means it's never been\n  // called, whereas null means it's been called with a signed out user\n  private lastNotifiedUid: string | null | undefined = undefined;\n\n  languageCode: string | null = null;\n  tenantId: string | null = null;\n  settings: AuthSettings = { appVerificationDisabledForTesting: false };\n\n  constructor(\n    public readonly app: FirebaseApp,\n    private readonly heartbeatServiceProvider: Provider<'heartbeat'>,\n    public readonly config: ConfigInternal\n  ) {\n    this.name = app.name;\n    this.clientVersion = config.sdkClientVersion;\n  }\n\n  _initializeWithPersistence(\n    persistenceHierarchy: PersistenceInternal[],\n    popupRedirectResolver?: PopupRedirectResolver\n  ): Promise<void> {\n    if (popupRedirectResolver) {\n      this._popupRedirectResolver = _getInstance(popupRedirectResolver);\n    }\n\n    // Have to check for app deletion throughout initialization (after each\n    // promise resolution)\n    this._initializationPromise = this.queue(async () => {\n      if (this._deleted) {\n        return;\n      }\n\n      this.persistenceManager = await PersistenceUserManager.create(\n        this,\n        persistenceHierarchy\n      );\n\n      if (this._deleted) {\n        return;\n      }\n\n      // Initialize the resolver early if necessary (only applicable to web:\n      // this will cause the iframe to load immediately in certain cases)\n      if (this._popupRedirectResolver?._shouldInitProactively) {\n        // If this fails, don't halt auth loading\n        try {\n          await this._popupRedirectResolver._initialize(this);\n        } catch (e) { /* Ignore the error */ }\n      }\n\n      await this.initializeCurrentUser(popupRedirectResolver);\n      this.lastNotifiedUid = this.currentUser?.uid || null;\n\n      if (this._deleted) {\n        return;\n      }\n\n      this._isInitialized = true;\n    });\n\n    return this._initializationPromise;\n  }\n\n  /**\n   * If the persistence is changed in another window, the user manager will let us know\n   */\n  async _onStorageEvent(): Promise<void> {\n    if (this._deleted) {\n      return;\n    }\n\n    const user = await this.assertedPersistence.getCurrentUser();\n\n    if (!this.currentUser && !user) {\n      // No change, do nothing (was signed out and remained signed out).\n      return;\n    }\n\n    // If the same user is to be synchronized.\n    if (this.currentUser && user && this.currentUser.uid === user.uid) {\n      // Data update, simply copy data changes.\n      this._currentUser._assign(user);\n      // If tokens changed from previous user tokens, this will trigger\n      // notifyAuthListeners_.\n      await this.currentUser.getIdToken();\n      return;\n    }\n\n    // Update current Auth state. Either a new login or logout.\n    // Skip blocking callbacks, they should not apply to a change in another tab.\n    await this._updateCurrentUser(user, /* skipBeforeStateCallbacks */ true);\n  }\n\n  private async initializeCurrentUser(\n    popupRedirectResolver?: PopupRedirectResolver\n  ): Promise<void> {\n    // First check to see if we have a pending redirect event.\n    const previouslyStoredUser =\n      (await this.assertedPersistence.getCurrentUser()) as UserInternal | null;\n    let futureCurrentUser = previouslyStoredUser;\n    let needsTocheckMiddleware = false;\n    if (popupRedirectResolver && this.config.authDomain) {\n      await this.getOrInitRedirectPersistenceManager();\n      const redirectUserEventId = this.redirectUser?._redirectEventId;\n      const storedUserEventId = futureCurrentUser?._redirectEventId;\n      const result = await this.tryRedirectSignIn(popupRedirectResolver);\n\n      // If the stored user (i.e. the old \"currentUser\") has a redirectId that\n      // matches the redirect user, then we want to initially sign in with the\n      // new user object from result.\n      // TODO(samgho): More thoroughly test all of this\n      if (\n        (!redirectUserEventId || redirectUserEventId === storedUserEventId) &&\n        result?.user\n      ) {\n        futureCurrentUser = result.user as UserInternal;\n        needsTocheckMiddleware = true;\n      }\n    }\n\n    // If no user in persistence, there is no current user. Set to null.\n    if (!futureCurrentUser) {\n      return this.directlySetCurrentUser(null);\n    }\n\n    if (!futureCurrentUser._redirectEventId) {\n      // This isn't a redirect link operation, we can reload and bail.\n      // First though, ensure that we check the middleware is happy.\n      if (needsTocheckMiddleware) {\n        try {\n          await this.beforeStateQueue.runMiddleware(futureCurrentUser);\n        } catch(e) {\n          futureCurrentUser = previouslyStoredUser;\n          // We know this is available since the bit is only set when the\n          // resolver is available\n          this._popupRedirectResolver!._overrideRedirectResult(this, () => Promise.reject(e));\n        }\n      }\n  \n      if (futureCurrentUser) {\n        return this.reloadAndSetCurrentUserOrClear(futureCurrentUser);\n      } else {\n        return this.directlySetCurrentUser(null);\n      }\n    }\n\n    _assert(this._popupRedirectResolver, this, AuthErrorCode.ARGUMENT_ERROR);\n    await this.getOrInitRedirectPersistenceManager();\n\n    // If the redirect user's event ID matches the current user's event ID,\n    // DO NOT reload the current user, otherwise they'll be cleared from storage.\n    // This is important for the reauthenticateWithRedirect() flow.\n    if (\n      this.redirectUser &&\n      this.redirectUser._redirectEventId === futureCurrentUser._redirectEventId\n    ) {\n      return this.directlySetCurrentUser(futureCurrentUser);\n    }\n\n    return this.reloadAndSetCurrentUserOrClear(futureCurrentUser);\n  }\n\n  private async tryRedirectSignIn(\n    redirectResolver: PopupRedirectResolver\n  ): Promise<UserCredential | null> {\n    // The redirect user needs to be checked (and signed in if available)\n    // during auth initialization. All of the normal sign in and link/reauth\n    // flows call back into auth and push things onto the promise queue. We\n    // need to await the result of the redirect sign in *inside the promise\n    // queue*. This presents a problem: we run into deadlock. See:\n    //    ┌> [Initialization] ─────┐\n    //    ┌> [<other queue tasks>] │\n    //    └─ [getRedirectResult] <─┘\n    //    where [] are tasks on the queue and arrows denote awaits\n    // Initialization will never complete because it's waiting on something\n    // that's waiting for initialization to complete!\n    //\n    // Instead, this method calls getRedirectResult() (stored in\n    // _completeRedirectFn) with an optional parameter that instructs all of\n    // the underlying auth operations to skip anything that mutates auth state.\n\n    let result: UserCredential | null = null;\n    try {\n      // We know this._popupRedirectResolver is set since redirectResolver\n      // is passed in. The _completeRedirectFn expects the unwrapped extern.\n      result = await this._popupRedirectResolver!._completeRedirectFn(\n        this,\n        redirectResolver,\n        true\n      );\n    } catch (e) {\n      // Swallow any errors here; the code can retrieve them in\n      // getRedirectResult().\n      await this._setRedirectUser(null);\n    }\n\n    return result;\n  }\n\n  private async reloadAndSetCurrentUserOrClear(\n    user: UserInternal\n  ): Promise<void> {\n    try {\n      await _reloadWithoutSaving(user);\n    } catch (e) {\n      if (e.code !== `auth/${AuthErrorCode.NETWORK_REQUEST_FAILED}`) {\n        // Something's wrong with the user's token. Log them out and remove\n        // them from storage\n        return this.directlySetCurrentUser(null);\n      }\n    }\n\n    return this.directlySetCurrentUser(user);\n  }\n\n  useDeviceLanguage(): void {\n    this.languageCode = _getUserLanguage();\n  }\n\n  async _delete(): Promise<void> {\n    this._deleted = true;\n  }\n\n  async updateCurrentUser(userExtern: User | null): Promise<void> {\n    // The public updateCurrentUser method needs to make a copy of the user,\n    // and also check that the project matches\n    const user = userExtern\n      ? (getModularInstance(userExtern) as UserInternal)\n      : null;\n    if (user) {\n      _assert(\n        user.auth.config.apiKey === this.config.apiKey,\n        this,\n        AuthErrorCode.INVALID_AUTH\n      );\n    }\n    return this._updateCurrentUser(user && user._clone(this));\n  }\n\n  async _updateCurrentUser(user: User | null, skipBeforeStateCallbacks: boolean = false): Promise<void> {\n    if (this._deleted) {\n      return;\n    }\n    if (user) {\n      _assert(\n        this.tenantId === user.tenantId,\n        this,\n        AuthErrorCode.TENANT_ID_MISMATCH\n      );\n    }\n\n    if (!skipBeforeStateCallbacks) {\n      await this.beforeStateQueue.runMiddleware(user);\n    }\n\n    return this.queue(async () => {\n      await this.directlySetCurrentUser(user as UserInternal | null);\n      this.notifyAuthListeners();\n    });\n  }\n\n  async signOut(): Promise<void> {\n    // Run first, to block _setRedirectUser() if any callbacks fail.\n    await this.beforeStateQueue.runMiddleware(null);\n    // Clear the redirect user when signOut is called\n    if (this.redirectPersistenceManager || this._popupRedirectResolver) {\n      await this._setRedirectUser(null);\n    }\n\n    // Prevent callbacks from being called again in _updateCurrentUser, as\n    // they were already called in the first line.\n    return this._updateCurrentUser(null, /* skipBeforeStateCallbacks */ true);\n  }\n\n  setPersistence(persistence: Persistence): Promise<void> {\n    return this.queue(async () => {\n      await this.assertedPersistence.setPersistence(_getInstance(persistence));\n    });\n  }\n\n  _getPersistence(): string {\n    return this.assertedPersistence.persistence.type;\n  }\n\n  _updateErrorMap(errorMap: AuthErrorMap): void {\n    this._errorFactory = new ErrorFactory<AuthErrorCode, AuthErrorParams>(\n      'auth',\n      'Firebase',\n      (errorMap as ErrorMapRetriever)()\n    );\n  }\n\n  onAuthStateChanged(\n    nextOrObserver: NextOrObserver<User>,\n    error?: ErrorFn,\n    completed?: CompleteFn\n  ): Unsubscribe {\n    return this.registerStateListener(\n      this.authStateSubscription,\n      nextOrObserver,\n      error,\n      completed\n    );\n  }\n\n  beforeAuthStateChanged(\n    callback: (user: User | null) => void | Promise<void>,\n    onAbort?: () => void,\n  ): Unsubscribe {\n    return this.beforeStateQueue.pushCallback(callback, onAbort);\n  }\n\n  onIdTokenChanged(\n    nextOrObserver: NextOrObserver<User>,\n    error?: ErrorFn,\n    completed?: CompleteFn\n  ): Unsubscribe {\n    return this.registerStateListener(\n      this.idTokenSubscription,\n      nextOrObserver,\n      error,\n      completed\n    );\n  }\n\n  toJSON(): object {\n    return {\n      apiKey: this.config.apiKey,\n      authDomain: this.config.authDomain,\n      appName: this.name,\n      currentUser: this._currentUser?.toJSON()\n    };\n  }\n\n  async _setRedirectUser(\n    user: UserInternal | null,\n    popupRedirectResolver?: PopupRedirectResolver\n  ): Promise<void> {\n    const redirectManager = await this.getOrInitRedirectPersistenceManager(\n      popupRedirectResolver\n    );\n    return user === null\n      ? redirectManager.removeCurrentUser()\n      : redirectManager.setCurrentUser(user);\n  }\n\n  private async getOrInitRedirectPersistenceManager(\n    popupRedirectResolver?: PopupRedirectResolver\n  ): Promise<PersistenceUserManager> {\n    if (!this.redirectPersistenceManager) {\n      const resolver: PopupRedirectResolverInternal | null =\n        (popupRedirectResolver && _getInstance(popupRedirectResolver)) ||\n        this._popupRedirectResolver;\n      _assert(resolver, this, AuthErrorCode.ARGUMENT_ERROR);\n      this.redirectPersistenceManager = await PersistenceUserManager.create(\n        this,\n        [_getInstance(resolver._redirectPersistence)],\n        KeyName.REDIRECT_USER\n      );\n      this.redirectUser =\n        await this.redirectPersistenceManager.getCurrentUser();\n    }\n\n    return this.redirectPersistenceManager;\n  }\n\n  async _redirectUserForId(id: string): Promise<UserInternal | null> {\n    // Make sure we've cleared any pending persistence actions if we're not in\n    // the initializer\n    if (this._isInitialized) {\n      await this.queue(async () => { });\n    }\n\n    if (this._currentUser?._redirectEventId === id) {\n      return this._currentUser;\n    }\n\n    if (this.redirectUser?._redirectEventId === id) {\n      return this.redirectUser;\n    }\n\n    return null;\n  }\n\n  async _persistUserIfCurrent(user: UserInternal): Promise<void> {\n    if (user === this.currentUser) {\n      return this.queue(async () => this.directlySetCurrentUser(user));\n    }\n  }\n\n  /** Notifies listeners only if the user is current */\n  _notifyListenersIfCurrent(user: UserInternal): void {\n    if (user === this.currentUser) {\n      this.notifyAuthListeners();\n    }\n  }\n\n  _key(): string {\n    return `${this.config.authDomain}:${this.config.apiKey}:${this.name}`;\n  }\n\n  _startProactiveRefresh(): void {\n    this.isProactiveRefreshEnabled = true;\n    if (this.currentUser) {\n      this._currentUser._startProactiveRefresh();\n    }\n  }\n\n  _stopProactiveRefresh(): void {\n    this.isProactiveRefreshEnabled = false;\n    if (this.currentUser) {\n      this._currentUser._stopProactiveRefresh();\n    }\n  }\n\n  /** Returns the current user cast as the internal type */\n  get _currentUser(): UserInternal {\n    return this.currentUser as UserInternal;\n  }\n\n  private notifyAuthListeners(): void {\n    if (!this._isInitialized) {\n      return;\n    }\n\n    this.idTokenSubscription.next(this.currentUser);\n\n    const currentUid = this.currentUser?.uid ?? null;\n    if (this.lastNotifiedUid !== currentUid) {\n      this.lastNotifiedUid = currentUid;\n      this.authStateSubscription.next(this.currentUser);\n    }\n  }\n\n  private registerStateListener(\n    subscription: Subscription<User>,\n    nextOrObserver: NextOrObserver<User>,\n    error?: ErrorFn,\n    completed?: CompleteFn\n  ): Unsubscribe {\n    if (this._deleted) {\n      return () => { };\n    }\n\n    const cb =\n      typeof nextOrObserver === 'function'\n        ? nextOrObserver\n        : nextOrObserver.next.bind(nextOrObserver);\n\n    const promise = this._isInitialized\n      ? Promise.resolve()\n      : this._initializationPromise;\n    _assert(promise, this, AuthErrorCode.INTERNAL_ERROR);\n    // The callback needs to be called asynchronously per the spec.\n    // eslint-disable-next-line @typescript-eslint/no-floating-promises\n    promise.then(() => cb(this.currentUser));\n\n    if (typeof nextOrObserver === 'function') {\n      return subscription.addObserver(nextOrObserver, error, completed);\n    } else {\n      return subscription.addObserver(nextOrObserver);\n    }\n  }\n\n  /**\n   * Unprotected (from race conditions) method to set the current user. This\n   * should only be called from within a queued callback. This is necessary\n   * because the queue shouldn't rely on another queued callback.\n   */\n  private async directlySetCurrentUser(\n    user: UserInternal | null\n  ): Promise<void> {\n    if (this.currentUser && this.currentUser !== user) {\n      this._currentUser._stopProactiveRefresh();\n      if (user && this.isProactiveRefreshEnabled) {\n        user._startProactiveRefresh();\n      }\n    }\n\n    this.currentUser = user;\n\n    if (user) {\n      await this.assertedPersistence.setCurrentUser(user);\n    } else {\n      await this.assertedPersistence.removeCurrentUser();\n    }\n  }\n\n  private queue(action: AsyncAction): Promise<void> {\n    // In case something errors, the callback still should be called in order\n    // to keep the promise chain alive\n    this.operations = this.operations.then(action, action);\n    return this.operations;\n  }\n\n  private get assertedPersistence(): PersistenceUserManager {\n    _assert(this.persistenceManager, this, AuthErrorCode.INTERNAL_ERROR);\n    return this.persistenceManager;\n  }\n\n  private frameworks: string[] = [];\n  private clientVersion: string;\n  _logFramework(framework: string): void {\n    if (!framework || this.frameworks.includes(framework)) {\n      return;\n    }\n    this.frameworks.push(framework);\n\n    // Sort alphabetically so that \"FirebaseCore-web,FirebaseUI-web\" and\n    // \"FirebaseUI-web,FirebaseCore-web\" aren't viewed as different.\n    this.frameworks.sort();\n    this.clientVersion = _getClientVersion(\n      this.config.clientPlatform,\n      this._getFrameworks()\n    );\n  }\n  _getFrameworks(): readonly string[] {\n    return this.frameworks;\n  }\n  async _getAdditionalHeaders(): Promise<Record<string, string>> {\n    // Additional headers on every request\n    const headers: Record<string, string> = {\n      [HttpHeader.X_CLIENT_VERSION]: this.clientVersion,\n    };\n\n    if (this.app.options.appId) {\n      headers[HttpHeader.X_FIREBASE_GMPID] = this.app.options.appId;\n    }\n\n    // If the heartbeat service exists, add the heartbeat string\n    const heartbeatsHeader = await this.heartbeatServiceProvider.getImmediate({\n      optional: true,\n    })?.getHeartbeatsHeader();\n    if (heartbeatsHeader) {\n      headers[HttpHeader.X_FIREBASE_CLIENT] = heartbeatsHeader;\n    }\n    return headers;\n  }\n}\n\n/**\n * Method to be used to cast down to our private implmentation of Auth.\n * It will also handle unwrapping from the compat type if necessary\n *\n * @param auth Auth object passed in from developer\n */\nexport function _castAuth(auth: Auth): AuthInternal {\n  return getModularInstance(auth) as AuthInternal;\n}\n\n/** Helper class to wrap subscriber logic */\nclass Subscription<T> {\n  private observer: Observer<T | null> | null = null;\n  readonly addObserver: Subscribe<T | null> = createSubscribe(\n    observer => (this.observer = observer)\n  );\n\n  constructor(readonly auth: AuthInternal) { }\n\n  get next(): NextFn<T | null> {\n    _assert(this.observer, this.auth, AuthErrorCode.INTERNAL_ERROR);\n    return this.observer.next.bind(this.observer);\n  }\n}\n","/**\n * @license\n * Copyright 2021 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nimport { Auth } from '../../model/public_types';\nimport { AuthErrorCode } from '../errors';\nimport { _assert } from '../util/assert';\nimport { _castAuth } from './auth_impl';\n\n/**\n * Changes the {@link Auth} instance to communicate with the Firebase Auth Emulator, instead of production\n * Firebase Auth services.\n *\n * @remarks\n * This must be called synchronously immediately following the first call to\n * {@link initializeAuth}.  Do not use with production credentials as emulator\n * traffic is not encrypted.\n *\n *\n * @example\n * ```javascript\n * connectAuthEmulator(auth, 'http://127.0.0.1:9099', { disableWarnings: true });\n * ```\n *\n * @param auth - The {@link Auth} instance.\n * @param url - The URL at which the emulator is running (eg, 'http://localhost:9099').\n * @param options - Optional. `options.disableWarnings` defaults to `false`. Set it to\n * `true` to disable the warning banner attached to the DOM.\n *\n * @public\n */\nexport function connectAuthEmulator(\n  auth: Auth,\n  url: string,\n  options?: { disableWarnings: boolean }\n): void {\n  const authInternal = _castAuth(auth);\n  _assert(\n    authInternal._canInitEmulator,\n    authInternal,\n    AuthErrorCode.EMULATOR_CONFIG_FAILED\n  );\n\n  _assert(\n    /^https?:\\/\\//.test(url),\n    authInternal,\n    AuthErrorCode.INVALID_EMULATOR_SCHEME\n  );\n\n  const disableWarnings = !!options?.disableWarnings;\n\n  const protocol = extractProtocol(url);\n  const { host, port } = extractHostAndPort(url);\n  const portStr = port === null ? '' : `:${port}`;\n\n  // Always replace path with \"/\" (even if input url had no path at all, or had a different one).\n  authInternal.config.emulator = { url: `${protocol}//${host}${portStr}/` };\n  authInternal.settings.appVerificationDisabledForTesting = true;\n  authInternal.emulatorConfig = Object.freeze({\n    host,\n    port,\n    protocol: protocol.replace(':', ''),\n    options: Object.freeze({ disableWarnings })\n  });\n\n  if (!disableWarnings) {\n    emitEmulatorWarning();\n  }\n}\n\nfunction extractProtocol(url: string): string {\n  const protocolEnd = url.indexOf(':');\n  return protocolEnd < 0 ? '' : url.substr(0, protocolEnd + 1);\n}\n\nfunction extractHostAndPort(url: string): {\n  host: string;\n  port: number | null;\n} {\n  const protocol = extractProtocol(url);\n  const authority = /(\\/\\/)?([^?#/]+)/.exec(url.substr(protocol.length)); // Between // and /, ? or #.\n  if (!authority) {\n    return { host: '', port: null };\n  }\n  const hostAndPort = authority[2].split('@').pop() || ''; // Strip out \"username:password@\".\n  const bracketedIPv6 = /^(\\[[^\\]]+\\])(:|$)/.exec(hostAndPort);\n  if (bracketedIPv6) {\n    const host = bracketedIPv6[1];\n    return { host, port: parsePort(hostAndPort.substr(host.length + 1)) };\n  } else {\n    const [host, port] = hostAndPort.split(':');\n    return { host, port: parsePort(port) };\n  }\n}\n\nfunction parsePort(portStr: string): number | null {\n  if (!portStr) {\n    return null;\n  }\n  const port = Number(portStr);\n  if (isNaN(port)) {\n    return null;\n  }\n  return port;\n}\n\nfunction emitEmulatorWarning(): void {\n  function attachBanner(): void {\n    const el = document.createElement('p');\n    const sty = el.style;\n    el.innerText =\n      'Running in emulator mode. Do not use with production credentials.';\n    sty.position = 'fixed';\n    sty.width = '100%';\n    sty.backgroundColor = '#ffffff';\n    sty.border = '.1em solid #000000';\n    sty.color = '#b50000';\n    sty.bottom = '0px';\n    sty.left = '0px';\n    sty.margin = '0px';\n    sty.zIndex = '10000';\n    sty.textAlign = 'center';\n    el.classList.add('firebase-emulator-warning');\n    document.body.appendChild(el);\n  }\n\n  if (typeof console !== 'undefined' && typeof console.info === 'function') {\n    console.info(\n      'WARNING: You are using the Auth Emulator,' +\n        ' which is intended for local testing only.  Do not use with' +\n        ' production credentials.'\n    );\n  }\n  if (\n    typeof window !== 'undefined' &&\n    typeof document !== 'undefined'\n  ) {\n    if (document.readyState === 'loading') {\n      window.addEventListener('DOMContentLoaded', attachBanner);\n    } else {\n      attachBanner();\n    }\n  }\n}\n","/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { PhoneOrOauthTokenResponse } from '../../api/authentication/mfa';\nimport { AuthInternal } from '../../model/auth';\nimport { IdTokenResponse } from '../../model/id_token';\nimport { debugFail } from '../util/assert';\n\n/**\n * Interface that represents the credentials returned by an {@link AuthProvider}.\n *\n * @remarks\n * Implementations specify the details about each auth provider's credential requirements.\n *\n * @public\n */\nexport class AuthCredential {\n  /** @internal */\n  protected constructor(\n    /**\n     * The authentication provider ID for the credential.\n     *\n     * @remarks\n     * For example, 'facebook.com', or 'google.com'.\n     */\n    readonly providerId: string,\n    /**\n     * The authentication sign in method for the credential.\n     *\n     * @remarks\n     * For example, {@link SignInMethod}.EMAIL_PASSWORD, or\n     * {@link SignInMethod}.EMAIL_LINK. This corresponds to the sign-in method\n     * identifier as returned in {@link fetchSignInMethodsForEmail}.\n     */\n    readonly signInMethod: string\n  ) {}\n\n  /**\n   * Returns a JSON-serializable representation of this object.\n   *\n   * @returns a JSON-serializable representation of this object.\n   */\n  toJSON(): object {\n    return debugFail('not implemented');\n  }\n\n  /** @internal */\n  _getIdTokenResponse(_auth: AuthInternal): Promise<PhoneOrOauthTokenResponse> {\n    return debugFail('not implemented');\n  }\n  /** @internal */\n  _linkToIdToken(\n    _auth: AuthInternal,\n    _idToken: string\n  ): Promise<IdTokenResponse> {\n    return debugFail('not implemented');\n  }\n  /** @internal */\n  _getReauthenticationResolver(_auth: AuthInternal): Promise<IdTokenResponse> {\n    return debugFail('not implemented');\n  }\n}\n","/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { ActionCodeOperation, Auth } from '../../model/public_types';\n\nimport {\n  Endpoint,\n  HttpMethod,\n  _addTidIfNecessary,\n  _performApiRequest\n} from '../index';\nimport { IdTokenResponse } from '../../model/id_token';\nimport { MfaEnrollment } from './mfa';\n\nexport interface ResetPasswordRequest {\n  oobCode: string;\n  newPassword?: string;\n  tenantId?: string;\n}\n\nexport interface ResetPasswordResponse {\n  email: string;\n  newEmail?: string;\n  requestType?: ActionCodeOperation;\n  mfaInfo?: MfaEnrollment;\n}\n\nexport async function resetPassword(\n  auth: Auth,\n  request: ResetPasswordRequest\n): Promise<ResetPasswordResponse> {\n  return _performApiRequest<ResetPasswordRequest, ResetPasswordResponse>(\n    auth,\n    HttpMethod.POST,\n    Endpoint.RESET_PASSWORD,\n    _addTidIfNecessary(auth, request)\n  );\n}\nexport interface UpdateEmailPasswordRequest {\n  idToken: string;\n  returnSecureToken?: boolean;\n  email?: string;\n  password?: string;\n}\n\nexport interface UpdateEmailPasswordResponse extends IdTokenResponse {}\n\nexport async function updateEmailPassword(\n  auth: Auth,\n  request: UpdateEmailPasswordRequest\n): Promise<UpdateEmailPasswordResponse> {\n  return _performApiRequest<\n    UpdateEmailPasswordRequest,\n    UpdateEmailPasswordResponse\n  >(auth, HttpMethod.POST, Endpoint.SET_ACCOUNT_INFO, request);\n}\n\nexport interface ApplyActionCodeRequest {\n  oobCode: string;\n  tenantId?: string;\n}\n\nexport interface ApplyActionCodeResponse {}\n\nexport async function applyActionCode(\n  auth: Auth,\n  request: ApplyActionCodeRequest\n): Promise<ApplyActionCodeResponse> {\n  return _performApiRequest<ApplyActionCodeRequest, ApplyActionCodeResponse>(\n    auth,\n    HttpMethod.POST,\n    Endpoint.SET_ACCOUNT_INFO,\n    _addTidIfNecessary(auth, request)\n  );\n}\n","/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { ActionCodeOperation, Auth } from '../../model/public_types';\n\nimport {\n  Endpoint,\n  HttpMethod,\n  _addTidIfNecessary,\n  _performApiRequest,\n  _performSignInRequest\n} from '../index';\nimport { IdToken, IdTokenResponse } from '../../model/id_token';\n\nexport interface SignInWithPasswordRequest {\n  returnSecureToken?: boolean;\n  email: string;\n  password: string;\n  tenantId?: string;\n}\n\nexport interface SignInWithPasswordResponse extends IdTokenResponse {\n  email: string;\n  displayName: string;\n}\n\nexport async function signInWithPassword(\n  auth: Auth,\n  request: SignInWithPasswordRequest\n): Promise<SignInWithPasswordResponse> {\n  return _performSignInRequest<\n    SignInWithPasswordRequest,\n    SignInWithPasswordResponse\n  >(\n    auth,\n    HttpMethod.POST,\n    Endpoint.SIGN_IN_WITH_PASSWORD,\n    _addTidIfNecessary(auth, request)\n  );\n}\n\nexport interface GetOobCodeRequest {\n  email?: string; // Everything except VERIFY_AND_CHANGE_EMAIL\n  continueUrl?: string;\n  iOSBundleId?: string;\n  iosAppStoreId?: string;\n  androidPackageName?: string;\n  androidInstallApp?: boolean;\n  androidMinimumVersionCode?: string;\n  canHandleCodeInApp?: boolean;\n  dynamicLinkDomain?: string;\n  tenantId?: string;\n  targetProjectid?: string;\n}\n\nexport interface VerifyEmailRequest extends GetOobCodeRequest {\n  requestType: ActionCodeOperation.VERIFY_EMAIL;\n  idToken: IdToken;\n}\n\nexport interface PasswordResetRequest extends GetOobCodeRequest {\n  requestType: ActionCodeOperation.PASSWORD_RESET;\n  email: string;\n  captchaResp?: string;\n}\n\nexport interface EmailSignInRequest extends GetOobCodeRequest {\n  requestType: ActionCodeOperation.EMAIL_SIGNIN;\n  email: string;\n}\n\nexport interface VerifyAndChangeEmailRequest extends GetOobCodeRequest {\n  requestType: ActionCodeOperation.VERIFY_AND_CHANGE_EMAIL;\n  idToken: IdToken;\n  newEmail: string;\n}\n\ninterface GetOobCodeResponse {\n  email: string;\n}\n\nexport interface VerifyEmailResponse extends GetOobCodeResponse {}\nexport interface PasswordResetResponse extends GetOobCodeResponse {}\nexport interface EmailSignInResponse extends GetOobCodeResponse {}\nexport interface VerifyAndChangeEmailResponse extends GetOobCodeRequest {}\n\nasync function sendOobCode(\n  auth: Auth,\n  request: GetOobCodeRequest\n): Promise<GetOobCodeResponse> {\n  return _performApiRequest<GetOobCodeRequest, GetOobCodeResponse>(\n    auth,\n    HttpMethod.POST,\n    Endpoint.SEND_OOB_CODE,\n    _addTidIfNecessary(auth, request)\n  );\n}\n\nexport async function sendEmailVerification(\n  auth: Auth,\n  request: VerifyEmailRequest\n): Promise<VerifyEmailResponse> {\n  return sendOobCode(auth, request);\n}\n\nexport async function sendPasswordResetEmail(\n  auth: Auth,\n  request: PasswordResetRequest\n): Promise<PasswordResetResponse> {\n  return sendOobCode(auth, request);\n}\n\nexport async function sendSignInLinkToEmail(\n  auth: Auth,\n  request: EmailSignInRequest\n): Promise<EmailSignInResponse> {\n  return sendOobCode(auth, request);\n}\n\nexport async function verifyAndChangeEmail(\n  auth: Auth,\n  request: VerifyAndChangeEmailRequest\n): Promise<VerifyAndChangeEmailResponse> {\n  return sendOobCode(auth, request);\n}\n","/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport {\n  _performSignInRequest,\n  Endpoint,\n  HttpMethod,\n  _addTidIfNecessary\n} from '../index';\nimport { IdTokenResponse } from '../../model/id_token';\nimport { Auth } from '../../model/public_types';\n\nexport interface SignInWithEmailLinkRequest {\n  email: string;\n  oobCode: string;\n  tenantId?: string;\n}\n\nexport interface SignInWithEmailLinkResponse extends IdTokenResponse {\n  email: string;\n  isNewUser: boolean;\n}\n\nexport async function signInWithEmailLink(\n  auth: Auth,\n  request: SignInWithEmailLinkRequest\n): Promise<SignInWithEmailLinkResponse> {\n  return _performSignInRequest<\n    SignInWithEmailLinkRequest,\n    SignInWithEmailLinkResponse\n  >(\n    auth,\n    HttpMethod.POST,\n    Endpoint.SIGN_IN_WITH_EMAIL_LINK,\n    _addTidIfNecessary(auth, request)\n  );\n}\n\nexport interface SignInWithEmailLinkForLinkingRequest\n  extends SignInWithEmailLinkRequest {\n  idToken: string;\n}\n\nexport async function signInWithEmailLinkForLinking(\n  auth: Auth,\n  request: SignInWithEmailLinkForLinkingRequest\n): Promise<SignInWithEmailLinkResponse> {\n  return _performSignInRequest<\n    SignInWithEmailLinkForLinkingRequest,\n    SignInWithEmailLinkResponse\n  >(\n    auth,\n    HttpMethod.POST,\n    Endpoint.SIGN_IN_WITH_EMAIL_LINK,\n    _addTidIfNecessary(auth, request)\n  );\n}\n","/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { ProviderId, SignInMethod } from '../../model/enums';\n\nimport { updateEmailPassword } from '../../api/account_management/email_and_password';\nimport { signInWithPassword } from '../../api/authentication/email_and_password';\nimport {\n  signInWithEmailLink,\n  signInWithEmailLinkForLinking\n} from '../../api/authentication/email_link';\nimport { AuthInternal } from '../../model/auth';\nimport { IdTokenResponse } from '../../model/id_token';\nimport { AuthErrorCode } from '../errors';\nimport { _fail } from '../util/assert';\nimport { AuthCredential } from './auth_credential';\n\n/**\n * Interface that represents the credentials returned by {@link EmailAuthProvider} for\n * {@link ProviderId}.PASSWORD\n *\n * @remarks\n * Covers both {@link SignInMethod}.EMAIL_PASSWORD and\n * {@link SignInMethod}.EMAIL_LINK.\n *\n * @public\n */\nexport class EmailAuthCredential extends AuthCredential {\n  /** @internal */\n  private constructor(\n    /** @internal */\n    readonly _email: string,\n    /** @internal */\n    readonly _password: string,\n    signInMethod: SignInMethod,\n    /** @internal */\n    readonly _tenantId: string | null = null\n  ) {\n    super(ProviderId.PASSWORD, signInMethod);\n  }\n\n  /** @internal */\n  static _fromEmailAndPassword(\n    email: string,\n    password: string\n  ): EmailAuthCredential {\n    return new EmailAuthCredential(\n      email,\n      password,\n      SignInMethod.EMAIL_PASSWORD\n    );\n  }\n\n  /** @internal */\n  static _fromEmailAndCode(\n    email: string,\n    oobCode: string,\n    tenantId: string | null = null\n  ): EmailAuthCredential {\n    return new EmailAuthCredential(\n      email,\n      oobCode,\n      SignInMethod.EMAIL_LINK,\n      tenantId\n    );\n  }\n\n  /** {@inheritdoc AuthCredential.toJSON} */\n  toJSON(): object {\n    return {\n      email: this._email,\n      password: this._password,\n      signInMethod: this.signInMethod,\n      tenantId: this._tenantId\n    };\n  }\n\n  /**\n   * Static method to deserialize a JSON representation of an object into an {@link  AuthCredential}.\n   *\n   * @param json - Either `object` or the stringified representation of the object. When string is\n   * provided, `JSON.parse` would be called first.\n   *\n   * @returns If the JSON input does not represent an {@link AuthCredential}, null is returned.\n   */\n  static fromJSON(json: object | string): EmailAuthCredential | null {\n    const obj = typeof json === 'string' ? JSON.parse(json) : json;\n    if (obj?.email && obj?.password) {\n      if (obj.signInMethod === SignInMethod.EMAIL_PASSWORD) {\n        return this._fromEmailAndPassword(obj.email, obj.password);\n      } else if (obj.signInMethod === SignInMethod.EMAIL_LINK) {\n        return this._fromEmailAndCode(obj.email, obj.password, obj.tenantId);\n      }\n    }\n    return null;\n  }\n\n  /** @internal */\n  async _getIdTokenResponse(auth: AuthInternal): Promise<IdTokenResponse> {\n    switch (this.signInMethod) {\n      case SignInMethod.EMAIL_PASSWORD:\n        return signInWithPassword(auth, {\n          returnSecureToken: true,\n          email: this._email,\n          password: this._password\n        });\n      case SignInMethod.EMAIL_LINK:\n        return signInWithEmailLink(auth, {\n          email: this._email,\n          oobCode: this._password\n        });\n      default:\n        _fail(auth, AuthErrorCode.INTERNAL_ERROR);\n    }\n  }\n\n  /** @internal */\n  async _linkToIdToken(\n    auth: AuthInternal,\n    idToken: string\n  ): Promise<IdTokenResponse> {\n    switch (this.signInMethod) {\n      case SignInMethod.EMAIL_PASSWORD:\n        return updateEmailPassword(auth, {\n          idToken,\n          returnSecureToken: true,\n          email: this._email,\n          password: this._password\n        });\n      case SignInMethod.EMAIL_LINK:\n        return signInWithEmailLinkForLinking(auth, {\n          idToken,\n          email: this._email,\n          oobCode: this._password\n        });\n      default:\n        _fail(auth, AuthErrorCode.INTERNAL_ERROR);\n    }\n  }\n\n  /** @internal */\n  _getReauthenticationResolver(auth: AuthInternal): Promise<IdTokenResponse> {\n    return this._getIdTokenResponse(auth);\n  }\n}\n","/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport {\n  Endpoint,\n  HttpMethod,\n  _addTidIfNecessary,\n  _performSignInRequest\n} from '../index';\nimport { IdToken, IdTokenResponse } from '../../model/id_token';\nimport { Auth } from '../../model/public_types';\n\nexport interface SignInWithIdpRequest {\n  requestUri: string;\n  postBody?: string;\n  sessionId?: string;\n  tenantId?: string;\n  returnSecureToken: boolean;\n  returnIdpCredential?: boolean;\n  idToken?: IdToken;\n  autoCreate?: boolean;\n  pendingToken?: string;\n}\n\n/**\n * @internal\n */\nexport interface SignInWithIdpResponse extends IdTokenResponse {\n  oauthAccessToken?: string;\n  oauthTokenSecret?: string;\n  nonce?: string;\n  oauthIdToken?: string;\n  pendingToken?: string;\n}\n\nexport async function signInWithIdp(\n  auth: Auth,\n  request: SignInWithIdpRequest\n): Promise<SignInWithIdpResponse> {\n  return _performSignInRequest<SignInWithIdpRequest, SignInWithIdpResponse>(\n    auth,\n    HttpMethod.POST,\n    Endpoint.SIGN_IN_WITH_IDP,\n    _addTidIfNecessary(auth, request)\n  );\n}\n","/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { querystring } from '@firebase/util';\n\nimport {\n  signInWithIdp,\n  SignInWithIdpRequest\n} from '../../api/authentication/idp';\nimport { AuthInternal } from '../../model/auth';\nimport { IdTokenResponse } from '../../model/id_token';\nimport { AuthErrorCode } from '../errors';\nimport { _fail } from '../util/assert';\nimport { AuthCredential } from './auth_credential';\n\nconst IDP_REQUEST_URI = 'http://localhost';\n\nexport interface OAuthCredentialParams {\n  // OAuth 2 uses either id token or access token\n  idToken?: string | null;\n  accessToken?: string | null;\n\n  // These fields are used with OAuth 1\n  oauthToken?: string;\n  secret?: string;\n  oauthTokenSecret?: string;\n\n  // Nonce is only set if pendingToken is not present\n  nonce?: string;\n  pendingToken?: string;\n\n  // Utilities\n  providerId: string;\n  signInMethod: string;\n}\n\n/**\n * Represents the OAuth credentials returned by an {@link OAuthProvider}.\n *\n * @remarks\n * Implementations specify the details about each auth provider's credential requirements.\n *\n * @public\n */\nexport class OAuthCredential extends AuthCredential {\n  /**\n   * The OAuth ID token associated with the credential if it belongs to an OIDC provider,\n   * such as `google.com`.\n   * @readonly\n   */\n  idToken?: string;\n  /**\n   * The OAuth access token associated with the credential if it belongs to an\n   * {@link OAuthProvider}, such as `facebook.com`, `twitter.com`, etc.\n   * @readonly\n   */\n  accessToken?: string;\n  /**\n   * The OAuth access token secret associated with the credential if it belongs to an OAuth 1.0\n   * provider, such as `twitter.com`.\n   * @readonly\n   */\n  secret?: string;\n  \n  private nonce?: string;\n  private pendingToken: string | null = null;\n\n  /** @internal */\n  static _fromParams(params: OAuthCredentialParams): OAuthCredential {\n    const cred = new OAuthCredential(params.providerId, params.signInMethod);\n\n    if (params.idToken || params.accessToken) {\n      // OAuth 2 and either ID token or access token.\n      if (params.idToken) {\n        cred.idToken = params.idToken;\n      }\n\n      if (params.accessToken) {\n        cred.accessToken = params.accessToken;\n      }\n\n      // Add nonce if available and no pendingToken is present.\n      if (params.nonce && !params.pendingToken) {\n        cred.nonce = params.nonce;\n      }\n\n      if (params.pendingToken) {\n        cred.pendingToken = params.pendingToken;\n      }\n    } else if (params.oauthToken && params.oauthTokenSecret) {\n      // OAuth 1 and OAuth token with token secret\n      cred.accessToken = params.oauthToken;\n      cred.secret = params.oauthTokenSecret;\n    } else {\n      _fail(AuthErrorCode.ARGUMENT_ERROR);\n    }\n\n    return cred;\n  }\n\n  /** {@inheritdoc AuthCredential.toJSON}  */\n  toJSON(): object {\n    return {\n      idToken: this.idToken,\n      accessToken: this.accessToken,\n      secret: this.secret,\n      nonce: this.nonce,\n      pendingToken: this.pendingToken,\n      providerId: this.providerId,\n      signInMethod: this.signInMethod\n    };\n  }\n\n  /**\n   * Static method to deserialize a JSON representation of an object into an\n   * {@link  AuthCredential}.\n   *\n   * @param json - Input can be either Object or the stringified representation of the object.\n   * When string is provided, JSON.parse would be called first.\n   *\n   * @returns If the JSON input does not represent an {@link  AuthCredential}, null is returned.\n   */\n  static fromJSON(json: string | object): OAuthCredential | null {\n    const obj = typeof json === 'string' ? JSON.parse(json) : json;\n    const { providerId, signInMethod, ...rest }: OAuthCredentialParams = obj;\n    if (!providerId || !signInMethod) {\n      return null;\n    }\n\n    const cred = new OAuthCredential(providerId, signInMethod);\n    cred.idToken = rest.idToken || undefined;\n    cred.accessToken = rest.accessToken || undefined;\n    cred.secret = rest.secret;\n    cred.nonce = rest.nonce;\n    cred.pendingToken = rest.pendingToken || null;\n    return cred;\n  }\n\n  /** @internal */\n  _getIdTokenResponse(auth: AuthInternal): Promise<IdTokenResponse> {\n    const request = this.buildRequest();\n    return signInWithIdp(auth, request);\n  }\n\n  /** @internal */\n  _linkToIdToken(\n    auth: AuthInternal,\n    idToken: string\n  ): Promise<IdTokenResponse> {\n    const request = this.buildRequest();\n    request.idToken = idToken;\n    return signInWithIdp(auth, request);\n  }\n\n  /** @internal */\n  _getReauthenticationResolver(auth: AuthInternal): Promise<IdTokenResponse> {\n    const request = this.buildRequest();\n    request.autoCreate = false;\n    return signInWithIdp(auth, request);\n  }\n\n  private buildRequest(): SignInWithIdpRequest {\n    const request: SignInWithIdpRequest = {\n      requestUri: IDP_REQUEST_URI,\n      returnSecureToken: true\n    };\n\n    if (this.pendingToken) {\n      request.pendingToken = this.pendingToken;\n    } else {\n      const postBody: Record<string, string> = {};\n      if (this.idToken) {\n        postBody['id_token'] = this.idToken;\n      }\n      if (this.accessToken) {\n        postBody['access_token'] = this.accessToken;\n      }\n      if (this.secret) {\n        postBody['oauth_token_secret'] = this.secret;\n      }\n\n      postBody['providerId'] = this.providerId;\n      if (this.nonce && !this.pendingToken) {\n        postBody['nonce'] = this.nonce;\n      }\n\n      request.postBody = querystring(postBody);\n    }\n\n    return request;\n  }\n}\n","/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport {\n  Endpoint,\n  HttpMethod,\n  _addTidIfNecessary,\n  _makeTaggedError,\n  _performApiRequest,\n  _performSignInRequest\n} from '../index';\nimport { AuthErrorCode } from '../../core/errors';\nimport { IdTokenResponse } from '../../model/id_token';\nimport { ServerError, ServerErrorMap } from '../errors';\nimport { Auth } from '../../model/public_types';\n\nexport interface SendPhoneVerificationCodeRequest {\n  phoneNumber: string;\n  recaptchaToken: string;\n  tenantId?: string;\n}\n\nexport interface SendPhoneVerificationCodeResponse {\n  sessionInfo: string;\n}\n\nexport async function sendPhoneVerificationCode(\n  auth: Auth,\n  request: SendPhoneVerificationCodeRequest\n): Promise<SendPhoneVerificationCodeResponse> {\n  return _performApiRequest<\n    SendPhoneVerificationCodeRequest,\n    SendPhoneVerificationCodeResponse\n  >(\n    auth,\n    HttpMethod.POST,\n    Endpoint.SEND_VERIFICATION_CODE,\n    _addTidIfNecessary(auth, request)\n  );\n}\n\n/**\n * @internal\n */\nexport interface SignInWithPhoneNumberRequest {\n  temporaryProof?: string;\n  phoneNumber?: string;\n  sessionInfo?: string;\n  code?: string;\n  tenantId?: string;\n}\n\nexport interface LinkWithPhoneNumberRequest\n  extends SignInWithPhoneNumberRequest {\n  idToken: string;\n}\n\n/**\n * @internal\n */\nexport interface SignInWithPhoneNumberResponse extends IdTokenResponse {\n  temporaryProof?: string;\n  phoneNumber?: string;\n}\n\nexport async function signInWithPhoneNumber(\n  auth: Auth,\n  request: SignInWithPhoneNumberRequest\n): Promise<SignInWithPhoneNumberResponse> {\n  return _performSignInRequest<\n    SignInWithPhoneNumberRequest,\n    SignInWithPhoneNumberResponse\n  >(\n    auth,\n    HttpMethod.POST,\n    Endpoint.SIGN_IN_WITH_PHONE_NUMBER,\n    _addTidIfNecessary(auth, request)\n  );\n}\n\nexport async function linkWithPhoneNumber(\n  auth: Auth,\n  request: LinkWithPhoneNumberRequest\n): Promise<SignInWithPhoneNumberResponse> {\n  const response = await _performSignInRequest<\n    LinkWithPhoneNumberRequest,\n    SignInWithPhoneNumberResponse\n  >(\n    auth,\n    HttpMethod.POST,\n    Endpoint.SIGN_IN_WITH_PHONE_NUMBER,\n    _addTidIfNecessary(auth, request)\n  );\n  if (response.temporaryProof) {\n    throw _makeTaggedError(auth, AuthErrorCode.NEED_CONFIRMATION, response);\n  }\n  return response;\n}\n\ninterface VerifyPhoneNumberForExistingRequest\n  extends SignInWithPhoneNumberRequest {\n  operation: 'REAUTH';\n}\n\nconst VERIFY_PHONE_NUMBER_FOR_EXISTING_ERROR_MAP_: Partial<\n  ServerErrorMap<ServerError>\n> = {\n  [ServerError.USER_NOT_FOUND]: AuthErrorCode.USER_DELETED\n};\n\nexport async function verifyPhoneNumberForExisting(\n  auth: Auth,\n  request: SignInWithPhoneNumberRequest\n): Promise<SignInWithPhoneNumberResponse> {\n  const apiRequest: VerifyPhoneNumberForExistingRequest = {\n    ...request,\n    operation: 'REAUTH'\n  };\n  return _performSignInRequest<\n    VerifyPhoneNumberForExistingRequest,\n    SignInWithPhoneNumberResponse\n  >(\n    auth,\n    HttpMethod.POST,\n    Endpoint.SIGN_IN_WITH_PHONE_NUMBER,\n    _addTidIfNecessary(auth, apiRequest),\n    VERIFY_PHONE_NUMBER_FOR_EXISTING_ERROR_MAP_\n  );\n}\n","/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { ProviderId, SignInMethod } from '../../model/enums';\n\nimport { PhoneOrOauthTokenResponse } from '../../api/authentication/mfa';\nimport {\n  linkWithPhoneNumber,\n  signInWithPhoneNumber,\n  SignInWithPhoneNumberRequest,\n  verifyPhoneNumberForExisting\n} from '../../api/authentication/sms';\nimport { AuthInternal } from '../../model/auth';\nimport { IdTokenResponse } from '../../model/id_token';\nimport { AuthCredential } from './auth_credential';\n\nexport interface PhoneAuthCredentialParameters {\n  verificationId?: string;\n  verificationCode?: string;\n  phoneNumber?: string;\n  temporaryProof?: string;\n}\n\n/**\n * Represents the credentials returned by {@link PhoneAuthProvider}.\n *\n * @public\n */\nexport class PhoneAuthCredential extends AuthCredential {\n  private constructor(private readonly params: PhoneAuthCredentialParameters) {\n    super(ProviderId.PHONE, SignInMethod.PHONE);\n  }\n\n  /** @internal */\n  static _fromVerification(\n    verificationId: string,\n    verificationCode: string\n  ): PhoneAuthCredential {\n    return new PhoneAuthCredential({ verificationId, verificationCode });\n  }\n\n  /** @internal */\n  static _fromTokenResponse(\n    phoneNumber: string,\n    temporaryProof: string\n  ): PhoneAuthCredential {\n    return new PhoneAuthCredential({ phoneNumber, temporaryProof });\n  }\n\n  /** @internal */\n  _getIdTokenResponse(auth: AuthInternal): Promise<PhoneOrOauthTokenResponse> {\n    return signInWithPhoneNumber(auth, this._makeVerificationRequest());\n  }\n\n  /** @internal */\n  _linkToIdToken(\n    auth: AuthInternal,\n    idToken: string\n  ): Promise<IdTokenResponse> {\n    return linkWithPhoneNumber(auth, {\n      idToken,\n      ...this._makeVerificationRequest()\n    });\n  }\n\n  /** @internal */\n  _getReauthenticationResolver(auth: AuthInternal): Promise<IdTokenResponse> {\n    return verifyPhoneNumberForExisting(auth, this._makeVerificationRequest());\n  }\n\n  /** @internal */\n  _makeVerificationRequest(): SignInWithPhoneNumberRequest {\n    const { temporaryProof, phoneNumber, verificationId, verificationCode } =\n      this.params;\n    if (temporaryProof && phoneNumber) {\n      return { temporaryProof, phoneNumber };\n    }\n\n    return {\n      sessionInfo: verificationId,\n      code: verificationCode\n    };\n  }\n\n  /** {@inheritdoc AuthCredential.toJSON} */\n  toJSON(): object {\n    const obj: Record<string, string> = {\n      providerId: this.providerId\n    };\n    if (this.params.phoneNumber) {\n      obj.phoneNumber = this.params.phoneNumber;\n    }\n    if (this.params.temporaryProof) {\n      obj.temporaryProof = this.params.temporaryProof;\n    }\n    if (this.params.verificationCode) {\n      obj.verificationCode = this.params.verificationCode;\n    }\n    if (this.params.verificationId) {\n      obj.verificationId = this.params.verificationId;\n    }\n\n    return obj;\n  }\n\n  /** Generates a phone credential based on a plain object or a JSON string. */\n  static fromJSON(json: object | string): PhoneAuthCredential | null {\n    if (typeof json === 'string') {\n      json = JSON.parse(json);\n    }\n\n    const { verificationId, verificationCode, phoneNumber, temporaryProof } =\n      json as { [key: string]: string };\n    if (\n      !verificationCode &&\n      !verificationId &&\n      !phoneNumber &&\n      !temporaryProof\n    ) {\n      return null;\n    }\n\n    return new PhoneAuthCredential({\n      verificationId,\n      verificationCode,\n      phoneNumber,\n      temporaryProof\n    });\n  }\n}\n","/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { extractQuerystring, querystringDecode } from '@firebase/util';\nimport { ActionCodeOperation } from '../model/public_types';\nimport { AuthErrorCode } from './errors';\nimport { _assert } from './util/assert';\n\n/**\n * Enums for fields in URL query string.\n *\n * @enum {string}\n */\nconst enum QueryField {\n  API_KEY = 'apiKey',\n  CODE = 'oobCode',\n  CONTINUE_URL = 'continueUrl',\n  LANGUAGE_CODE = 'languageCode',\n  MODE = 'mode',\n  TENANT_ID = 'tenantId'\n}\n\n/**\n * Maps the mode string in action code URL to Action Code Info operation.\n *\n * @param mode\n */\nfunction parseMode(mode: string | null): ActionCodeOperation | null {\n  switch (mode) {\n    case 'recoverEmail':\n      return ActionCodeOperation.RECOVER_EMAIL;\n    case 'resetPassword':\n      return ActionCodeOperation.PASSWORD_RESET;\n    case 'signIn':\n      return ActionCodeOperation.EMAIL_SIGNIN;\n    case 'verifyEmail':\n      return ActionCodeOperation.VERIFY_EMAIL;\n    case 'verifyAndChangeEmail':\n      return ActionCodeOperation.VERIFY_AND_CHANGE_EMAIL;\n    case 'revertSecondFactorAddition':\n      return ActionCodeOperation.REVERT_SECOND_FACTOR_ADDITION;\n    default:\n      return null;\n  }\n}\n\n/**\n * Helper to parse FDL links\n *\n * @param url\n */\nfunction parseDeepLink(url: string): string {\n  const link = querystringDecode(extractQuerystring(url))['link'];\n\n  // Double link case (automatic redirect).\n  const doubleDeepLink = link\n    ? querystringDecode(extractQuerystring(link))['deep_link_id']\n    : null;\n  // iOS custom scheme links.\n  const iOSDeepLink = querystringDecode(extractQuerystring(url))[\n    'deep_link_id'\n  ];\n  const iOSDoubleDeepLink = iOSDeepLink\n    ? querystringDecode(extractQuerystring(iOSDeepLink))['link']\n    : null;\n  return iOSDoubleDeepLink || iOSDeepLink || doubleDeepLink || link || url;\n}\n\n/**\n * A utility class to parse email action URLs such as password reset, email verification,\n * email link sign in, etc.\n *\n * @public\n */\nexport class ActionCodeURL {\n  /**\n   * The API key of the email action link.\n   */\n  readonly apiKey: string;\n  /**\n   * The action code of the email action link.\n   */\n  readonly code: string;\n  /**\n   * The continue URL of the email action link. Null if not provided.\n   */\n  readonly continueUrl: string | null;\n  /**\n   * The language code of the email action link. Null if not provided.\n   */\n  readonly languageCode: string | null;\n  /**\n   * The action performed by the email action link. It returns from one of the types from\n   * {@link ActionCodeInfo}\n   */\n  readonly operation: string;\n  /**\n   * The tenant ID of the email action link. Null if the email action is from the parent project.\n   */\n  readonly tenantId: string | null;\n\n  /**\n   * @param actionLink - The link from which to extract the URL.\n   * @returns The {@link ActionCodeURL} object, or null if the link is invalid.\n   *\n   * @internal\n   */\n  constructor(actionLink: string) {\n    const searchParams = querystringDecode(extractQuerystring(actionLink));\n    const apiKey = searchParams[QueryField.API_KEY] ?? null;\n    const code = searchParams[QueryField.CODE] ?? null;\n    const operation = parseMode(searchParams[QueryField.MODE] ?? null);\n    // Validate API key, code and mode.\n    _assert(apiKey && code && operation, AuthErrorCode.ARGUMENT_ERROR);\n    this.apiKey = apiKey;\n    this.operation = operation;\n    this.code = code;\n    this.continueUrl = searchParams[QueryField.CONTINUE_URL] ?? null;\n    this.languageCode = searchParams[QueryField.LANGUAGE_CODE] ?? null;\n    this.tenantId = searchParams[QueryField.TENANT_ID] ?? null;\n  }\n\n  /**\n   * Parses the email action link string and returns an {@link ActionCodeURL} if the link is valid,\n   * otherwise returns null.\n   *\n   * @param link  - The email action link string.\n   * @returns The {@link ActionCodeURL} object, or null if the link is invalid.\n   *\n   * @public\n   */\n  static parseLink(link: string): ActionCodeURL | null {\n    const actionLink = parseDeepLink(link);\n    try {\n      return new ActionCodeURL(actionLink);\n    } catch {\n      return null;\n    }\n  }\n}\n\n/**\n * Parses the email action link string and returns an {@link ActionCodeURL} if\n * the link is valid, otherwise returns null.\n *\n * @public\n */\nexport function parseActionCodeURL(link: string): ActionCodeURL | null {\n  return ActionCodeURL.parseLink(link);\n}\n","/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { ProviderId, SignInMethod } from '../../model/enums';\nimport { AuthProvider } from '../../model/public_types';\n\nimport { ActionCodeURL } from '../action_code_url';\nimport { EmailAuthCredential } from '../credentials/email';\nimport { AuthErrorCode } from '../errors';\nimport { _assert } from '../util/assert';\n\n/**\n * Provider for generating {@link EmailAuthCredential}.\n *\n * @public\n */\nexport class EmailAuthProvider implements AuthProvider {\n  /**\n   * Always set to {@link ProviderId}.PASSWORD, even for email link.\n   */\n  static readonly PROVIDER_ID: 'password' = ProviderId.PASSWORD;\n  /**\n   * Always set to {@link SignInMethod}.EMAIL_PASSWORD.\n   */\n  static readonly EMAIL_PASSWORD_SIGN_IN_METHOD: 'password' =\n    SignInMethod.EMAIL_PASSWORD;\n  /**\n   * Always set to {@link SignInMethod}.EMAIL_LINK.\n   */\n  static readonly EMAIL_LINK_SIGN_IN_METHOD: 'emailLink' =\n    SignInMethod.EMAIL_LINK;\n  /**\n   * Always set to {@link ProviderId}.PASSWORD, even for email link.\n   */\n  readonly providerId = EmailAuthProvider.PROVIDER_ID;\n\n  /**\n   * Initialize an {@link AuthCredential} using an email and password.\n   *\n   * @example\n   * ```javascript\n   * const authCredential = EmailAuthProvider.credential(email, password);\n   * const userCredential = await signInWithCredential(auth, authCredential);\n   * ```\n   *\n   * @example\n   * ```javascript\n   * const userCredential = await signInWithEmailAndPassword(auth, email, password);\n   * ```\n   *\n   * @param email - Email address.\n   * @param password - User account password.\n   * @returns The auth provider credential.\n   */\n  static credential(email: string, password: string): EmailAuthCredential {\n    return EmailAuthCredential._fromEmailAndPassword(email, password);\n  }\n\n  /**\n   * Initialize an {@link AuthCredential} using an email and an email link after a sign in with\n   * email link operation.\n   *\n   * @example\n   * ```javascript\n   * const authCredential = EmailAuthProvider.credentialWithLink(auth, email, emailLink);\n   * const userCredential = await signInWithCredential(auth, authCredential);\n   * ```\n   *\n   * @example\n   * ```javascript\n   * await sendSignInLinkToEmail(auth, email);\n   * // Obtain emailLink from user.\n   * const userCredential = await signInWithEmailLink(auth, email, emailLink);\n   * ```\n   *\n   * @param auth - The {@link Auth} instance used to verify the link.\n   * @param email - Email address.\n   * @param emailLink - Sign-in email link.\n   * @returns - The auth provider credential.\n   */\n  static credentialWithLink(\n    email: string,\n    emailLink: string\n  ): EmailAuthCredential {\n    const actionCodeUrl = ActionCodeURL.parseLink(emailLink);\n    _assert(actionCodeUrl, AuthErrorCode.ARGUMENT_ERROR);\n\n    return EmailAuthCredential._fromEmailAndCode(\n      email,\n      actionCodeUrl.code,\n      actionCodeUrl.tenantId\n    );\n  }\n}\n","/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { AuthProvider } from '../../model/public_types';\n\n/**\n * Map of OAuth Custom Parameters.\n *\n * @public\n */\nexport type CustomParameters = Record<string, string>;\n\n/**\n * The base class for all Federated providers (OAuth (including OIDC), SAML).\n *\n * This class is not meant to be instantiated directly.\n *\n * @public\n */\nexport abstract class FederatedAuthProvider implements AuthProvider {\n  /** @internal */\n  defaultLanguageCode: string | null = null;\n  /** @internal */\n  private customParameters: CustomParameters = {};\n\n  /**\n   * Constructor for generic OAuth providers.\n   *\n   * @param providerId - Provider for which credentials should be generated.\n   */\n  constructor(readonly providerId: string) {}\n\n  /**\n   * Set the language gode.\n   *\n   * @param languageCode - language code\n   */\n  setDefaultLanguage(languageCode: string | null): void {\n    this.defaultLanguageCode = languageCode;\n  }\n\n  /**\n   * Sets the OAuth custom parameters to pass in an OAuth request for popup and redirect sign-in\n   * operations.\n   *\n   * @remarks\n   * For a detailed list, check the reserved required OAuth 2.0 parameters such as `client_id`,\n   * `redirect_uri`, `scope`, `response_type`, and `state` are not allowed and will be ignored.\n   *\n   * @param customOAuthParameters - The custom OAuth parameters to pass in the OAuth request.\n   */\n  setCustomParameters(customOAuthParameters: CustomParameters): AuthProvider {\n    this.customParameters = customOAuthParameters;\n    return this;\n  }\n\n  /**\n   * Retrieve the current list of {@link CustomParameters}.\n   */\n  getCustomParameters(): CustomParameters {\n    return this.customParameters;\n  }\n}\n","/**\n * @license\n * Copyright 2019 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { AuthProvider, UserCredential } from '../../model/public_types';\n\nimport { _assert } from '../util/assert';\nimport { AuthErrorCode } from '../errors';\n\nimport { OAuthCredential, OAuthCredentialParams } from '../credentials/oauth';\nimport { UserCredentialInternal } from '../../model/user';\nimport { FirebaseError } from '@firebase/util';\nimport { TaggedWithTokenResponse } from '../../model/id_token';\nimport { SignInWithIdpResponse } from '../../../internal';\nimport { FederatedAuthProvider } from './federated';\n\n/**\n * Defines the options for initializing an {@link OAuthCredential}.\n *\n * @remarks\n * For ID tokens with nonce claim, the raw nonce has to also be provided.\n *\n * @public\n */\nexport interface OAuthCredentialOptions {\n  /**\n   * The OAuth ID token used to initialize the {@link OAuthCredential}.\n   */\n  idToken?: string;\n  /**\n   * The OAuth access token used to initialize the {@link OAuthCredential}.\n   */\n  accessToken?: string;\n  /**\n   * The raw nonce associated with the ID token.\n   *\n   * @remarks\n   * It is required when an ID token with a nonce field is provided. The SHA-256 hash of the\n   * raw nonce must match the nonce field in the ID token.\n   */\n  rawNonce?: string;\n}\n\n/**\n * Common code to all OAuth providers. This is separate from the\n * {@link OAuthProvider} so that child providers (like\n * {@link GoogleAuthProvider}) don't inherit the `credential` instance method.\n * Instead, they rely on a static `credential` method.\n */\nexport abstract class BaseOAuthProvider\n  extends FederatedAuthProvider\n  implements AuthProvider\n{\n  /** @internal */\n  private scopes: string[] = [];\n\n  /**\n   * Add an OAuth scope to the credential.\n   *\n   * @param scope - Provider OAuth scope to add.\n   */\n  addScope(scope: string): AuthProvider {\n    // If not already added, add scope to list.\n    if (!this.scopes.includes(scope)) {\n      this.scopes.push(scope);\n    }\n    return this;\n  }\n\n  /**\n   * Retrieve the current list of OAuth scopes.\n   */\n  getScopes(): string[] {\n    return [...this.scopes];\n  }\n}\n\n/**\n * Provider for generating generic {@link OAuthCredential}.\n *\n * @example\n * ```javascript\n * // Sign in using a redirect.\n * const provider = new OAuthProvider('google.com');\n * // Start a sign in process for an unauthenticated user.\n * provider.addScope('profile');\n * provider.addScope('email');\n * await signInWithRedirect(auth, provider);\n * // This will trigger a full page redirect away from your app\n *\n * // After returning from the redirect when your app initializes you can obtain the result\n * const result = await getRedirectResult(auth);\n * if (result) {\n *   // This is the signed-in user\n *   const user = result.user;\n *   // This gives you a OAuth Access Token for the provider.\n *   const credential = provider.credentialFromResult(auth, result);\n *   const token = credential.accessToken;\n * }\n * ```\n *\n * @example\n * ```javascript\n * // Sign in using a popup.\n * const provider = new OAuthProvider('google.com');\n * provider.addScope('profile');\n * provider.addScope('email');\n * const result = await signInWithPopup(auth, provider);\n *\n * // The signed-in user info.\n * const user = result.user;\n * // This gives you a OAuth Access Token for the provider.\n * const credential = provider.credentialFromResult(auth, result);\n * const token = credential.accessToken;\n * ```\n * @public\n */\nexport class OAuthProvider extends BaseOAuthProvider {\n  /**\n   * Creates an {@link OAuthCredential} from a JSON string or a plain object.\n   * @param json - A plain object or a JSON string\n   */\n  static credentialFromJSON(json: object | string): OAuthCredential {\n    const obj = typeof json === 'string' ? JSON.parse(json) : json;\n    _assert(\n      'providerId' in obj && 'signInMethod' in obj,\n      AuthErrorCode.ARGUMENT_ERROR\n    );\n    return OAuthCredential._fromParams(obj);\n  }\n\n  /**\n   * Creates a {@link OAuthCredential} from a generic OAuth provider's access token or ID token.\n   *\n   * @remarks\n   * The raw nonce is required when an ID token with a nonce field is provided. The SHA-256 hash of\n   * the raw nonce must match the nonce field in the ID token.\n   *\n   * @example\n   * ```javascript\n   * // `googleUser` from the onsuccess Google Sign In callback.\n   * // Initialize a generate OAuth provider with a `google.com` providerId.\n   * const provider = new OAuthProvider('google.com');\n   * const credential = provider.credential({\n   *   idToken: googleUser.getAuthResponse().id_token,\n   * });\n   * const result = await signInWithCredential(credential);\n   * ```\n   *\n   * @param params - Either the options object containing the ID token, access token and raw nonce\n   * or the ID token string.\n   */\n  credential(params: OAuthCredentialOptions): OAuthCredential {\n    return this._credential({...params, nonce: params.rawNonce});\n  }\n\n  /** An internal credential method that accepts more permissive options */\n  private _credential(\n    params: Omit<OAuthCredentialParams, 'signInMethod' | 'providerId'>\n  ): OAuthCredential {\n    _assert(params.idToken || params.accessToken, AuthErrorCode.ARGUMENT_ERROR);\n    // For OAuthCredential, sign in method is same as providerId.\n    return OAuthCredential._fromParams({\n      ...params,\n      providerId: this.providerId,\n      signInMethod: this.providerId\n    });\n  }\n\n  /**\n   * Used to extract the underlying {@link OAuthCredential} from a {@link UserCredential}.\n   *\n   * @param userCredential - The user credential.\n   */\n  static credentialFromResult(\n    userCredential: UserCredential\n  ): OAuthCredential | null {\n    return OAuthProvider.oauthCredentialFromTaggedObject(\n      userCredential as UserCredentialInternal\n    );\n  }\n  /**\n   * Used to extract the underlying {@link OAuthCredential} from a {@link AuthError} which was\n   * thrown during a sign-in, link, or reauthenticate operation.\n   *\n   * @param userCredential - The user credential.\n   */\n  static credentialFromError(error: FirebaseError): OAuthCredential | null {\n    return OAuthProvider.oauthCredentialFromTaggedObject(\n      (error.customData || {}) as TaggedWithTokenResponse\n    );\n  }\n\n  private static oauthCredentialFromTaggedObject({\n    _tokenResponse: tokenResponse\n  }: TaggedWithTokenResponse): OAuthCredential | null {\n    if (!tokenResponse) {\n      return null;\n    }\n\n    const {\n      oauthIdToken,\n      oauthAccessToken,\n      oauthTokenSecret,\n      pendingToken,\n      nonce,\n      providerId\n    } = tokenResponse as SignInWithIdpResponse;\n    if (\n      !oauthAccessToken &&\n      !oauthTokenSecret &&\n      !oauthIdToken &&\n      !pendingToken\n    ) {\n      return null;\n    }\n\n    if (!providerId) {\n      return null;\n    }\n\n    try {\n      return new OAuthProvider(providerId)._credential({\n        idToken: oauthIdToken,\n        accessToken: oauthAccessToken,\n        nonce,\n        pendingToken\n      });\n    } catch (e) {\n      return null;\n    }\n  }\n}\n","/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { UserCredential } from '../../model/public_types';\nimport { FirebaseError } from '@firebase/util';\n\nimport { TaggedWithTokenResponse } from '../../model/id_token';\nimport { UserCredentialInternal } from '../../model/user';\nimport { OAuthCredential } from '../credentials/oauth';\nimport { BaseOAuthProvider } from './oauth';\nimport { ProviderId, SignInMethod } from '../../model/enums';\n\n/**\n * Provider for generating an {@link OAuthCredential} for {@link ProviderId}.FACEBOOK.\n *\n * @example\n * ```javascript\n * // Sign in using a redirect.\n * const provider = new FacebookAuthProvider();\n * // Start a sign in process for an unauthenticated user.\n * provider.addScope('user_birthday');\n * await signInWithRedirect(auth, provider);\n * // This will trigger a full page redirect away from your app\n *\n * // After returning from the redirect when your app initializes you can obtain the result\n * const result = await getRedirectResult(auth);\n * if (result) {\n *   // This is the signed-in user\n *   const user = result.user;\n *   // This gives you a Facebook Access Token.\n *   const credential = FacebookAuthProvider.credentialFromResult(result);\n *   const token = credential.accessToken;\n * }\n * ```\n *\n * @example\n * ```javascript\n * // Sign in using a popup.\n * const provider = new FacebookAuthProvider();\n * provider.addScope('user_birthday');\n * const result = await signInWithPopup(auth, provider);\n *\n * // The signed-in user info.\n * const user = result.user;\n * // This gives you a Facebook Access Token.\n * const credential = FacebookAuthProvider.credentialFromResult(result);\n * const token = credential.accessToken;\n * ```\n *\n * @public\n */\nexport class FacebookAuthProvider extends BaseOAuthProvider {\n  /** Always set to {@link SignInMethod}.FACEBOOK. */\n  static readonly FACEBOOK_SIGN_IN_METHOD: 'facebook.com' =\n    SignInMethod.FACEBOOK;\n  /** Always set to {@link ProviderId}.FACEBOOK. */\n  static readonly PROVIDER_ID: 'facebook.com' = ProviderId.FACEBOOK;\n\n  constructor() {\n    super(ProviderId.FACEBOOK);\n  }\n\n  /**\n   * Creates a credential for Facebook.\n   *\n   * @example\n   * ```javascript\n   * // `event` from the Facebook auth.authResponseChange callback.\n   * const credential = FacebookAuthProvider.credential(event.authResponse.accessToken);\n   * const result = await signInWithCredential(credential);\n   * ```\n   *\n   * @param accessToken - Facebook access token.\n   */\n  static credential(accessToken: string): OAuthCredential {\n    return OAuthCredential._fromParams({\n      providerId: FacebookAuthProvider.PROVIDER_ID,\n      signInMethod: FacebookAuthProvider.FACEBOOK_SIGN_IN_METHOD,\n      accessToken\n    });\n  }\n\n  /**\n   * Used to extract the underlying {@link OAuthCredential} from a {@link UserCredential}.\n   *\n   * @param userCredential - The user credential.\n   */\n  static credentialFromResult(\n    userCredential: UserCredential\n  ): OAuthCredential | null {\n    return FacebookAuthProvider.credentialFromTaggedObject(\n      userCredential as UserCredentialInternal\n    );\n  }\n\n  /**\n   * Used to extract the underlying {@link OAuthCredential} from a {@link AuthError} which was\n   * thrown during a sign-in, link, or reauthenticate operation.\n   *\n   * @param userCredential - The user credential.\n   */\n  static credentialFromError(error: FirebaseError): OAuthCredential | null {\n    return FacebookAuthProvider.credentialFromTaggedObject(\n      (error.customData || {}) as TaggedWithTokenResponse\n    );\n  }\n\n  private static credentialFromTaggedObject({\n    _tokenResponse: tokenResponse\n  }: TaggedWithTokenResponse): OAuthCredential | null {\n    if (!tokenResponse || !('oauthAccessToken' in tokenResponse)) {\n      return null;\n    }\n\n    if (!tokenResponse.oauthAccessToken) {\n      return null;\n    }\n\n    try {\n      return FacebookAuthProvider.credential(tokenResponse.oauthAccessToken);\n    } catch {\n      return null;\n    }\n  }\n}\n","/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { UserCredential } from '../../model/public_types';\nimport { FirebaseError } from '@firebase/util';\n\nimport { SignInWithIdpResponse } from '../../api/authentication/idp';\nimport { TaggedWithTokenResponse } from '../../model/id_token';\nimport { UserCredentialInternal } from '../../model/user';\nimport { OAuthCredential } from '../credentials/oauth';\nimport { BaseOAuthProvider } from './oauth';\nimport { ProviderId, SignInMethod } from '../../model/enums';\n\n/**\n * Provider for generating an an {@link OAuthCredential} for {@link ProviderId}.GOOGLE.\n *\n * @example\n * ```javascript\n * // Sign in using a redirect.\n * const provider = new GoogleAuthProvider();\n * // Start a sign in process for an unauthenticated user.\n * provider.addScope('profile');\n * provider.addScope('email');\n * await signInWithRedirect(auth, provider);\n * // This will trigger a full page redirect away from your app\n *\n * // After returning from the redirect when your app initializes you can obtain the result\n * const result = await getRedirectResult(auth);\n * if (result) {\n *   // This is the signed-in user\n *   const user = result.user;\n *   // This gives you a Google Access Token.\n *   const credential = GoogleAuthProvider.credentialFromResult(result);\n *   const token = credential.accessToken;\n * }\n * ```\n *\n * @example\n * ```javascript\n * // Sign in using a popup.\n * const provider = new GoogleAuthProvider();\n * provider.addScope('profile');\n * provider.addScope('email');\n * const result = await signInWithPopup(auth, provider);\n *\n * // The signed-in user info.\n * const user = result.user;\n * // This gives you a Google Access Token.\n * const credential = GoogleAuthProvider.credentialFromResult(result);\n * const token = credential.accessToken;\n * ```\n *\n * @public\n */\nexport class GoogleAuthProvider extends BaseOAuthProvider {\n  /** Always set to {@link SignInMethod}.GOOGLE. */\n  static readonly GOOGLE_SIGN_IN_METHOD: 'google.com' = SignInMethod.GOOGLE;\n  /** Always set to {@link ProviderId}.GOOGLE. */\n  static readonly PROVIDER_ID: 'google.com' = ProviderId.GOOGLE;\n\n  constructor() {\n    super(ProviderId.GOOGLE);\n    this.addScope('profile');\n  }\n\n  /**\n   * Creates a credential for Google. At least one of ID token and access token is required.\n   *\n   * @example\n   * ```javascript\n   * // \\`googleUser\\` from the onsuccess Google Sign In callback.\n   * const credential = GoogleAuthProvider.credential(googleUser.getAuthResponse().id_token);\n   * const result = await signInWithCredential(credential);\n   * ```\n   *\n   * @param idToken - Google ID token.\n   * @param accessToken - Google access token.\n   */\n  static credential(\n    idToken?: string | null,\n    accessToken?: string | null\n  ): OAuthCredential {\n    return OAuthCredential._fromParams({\n      providerId: GoogleAuthProvider.PROVIDER_ID,\n      signInMethod: GoogleAuthProvider.GOOGLE_SIGN_IN_METHOD,\n      idToken,\n      accessToken\n    });\n  }\n\n  /**\n   * Used to extract the underlying {@link OAuthCredential} from a {@link UserCredential}.\n   *\n   * @param userCredential - The user credential.\n   */\n  static credentialFromResult(\n    userCredential: UserCredential\n  ): OAuthCredential | null {\n    return GoogleAuthProvider.credentialFromTaggedObject(\n      userCredential as UserCredentialInternal\n    );\n  }\n  /**\n   * Used to extract the underlying {@link OAuthCredential} from a {@link AuthError} which was\n   * thrown during a sign-in, link, or reauthenticate operation.\n   *\n   * @param userCredential - The user credential.\n   */\n  static credentialFromError(error: FirebaseError): OAuthCredential | null {\n    return GoogleAuthProvider.credentialFromTaggedObject(\n      (error.customData || {}) as TaggedWithTokenResponse\n    );\n  }\n\n  private static credentialFromTaggedObject({\n    _tokenResponse: tokenResponse\n  }: TaggedWithTokenResponse): OAuthCredential | null {\n    if (!tokenResponse) {\n      return null;\n    }\n\n    const { oauthIdToken, oauthAccessToken } =\n      tokenResponse as SignInWithIdpResponse;\n    if (!oauthIdToken && !oauthAccessToken) {\n      // This could be an oauth 1 credential or a phone credential\n      return null;\n    }\n\n    try {\n      return GoogleAuthProvider.credential(oauthIdToken, oauthAccessToken);\n    } catch {\n      return null;\n    }\n  }\n}\n","/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { UserCredential } from '../../model/public_types';\nimport { FirebaseError } from '@firebase/util';\n\nimport { TaggedWithTokenResponse } from '../../model/id_token';\nimport { UserCredentialInternal } from '../../model/user';\nimport { OAuthCredential } from '../credentials/oauth';\nimport { BaseOAuthProvider } from './oauth';\nimport { ProviderId, SignInMethod } from '../../model/enums';\n\n/**\n * Provider for generating an {@link OAuthCredential} for {@link ProviderId}.GITHUB.\n *\n * @remarks\n * GitHub requires an OAuth 2.0 redirect, so you can either handle the redirect directly, or use\n * the {@link signInWithPopup} handler:\n *\n * @example\n * ```javascript\n * // Sign in using a redirect.\n * const provider = new GithubAuthProvider();\n * // Start a sign in process for an unauthenticated user.\n * provider.addScope('repo');\n * await signInWithRedirect(auth, provider);\n * // This will trigger a full page redirect away from your app\n *\n * // After returning from the redirect when your app initializes you can obtain the result\n * const result = await getRedirectResult(auth);\n * if (result) {\n *   // This is the signed-in user\n *   const user = result.user;\n *   // This gives you a Github Access Token.\n *   const credential = GithubAuthProvider.credentialFromResult(result);\n *   const token = credential.accessToken;\n * }\n * ```\n *\n * @example\n * ```javascript\n * // Sign in using a popup.\n * const provider = new GithubAuthProvider();\n * provider.addScope('repo');\n * const result = await signInWithPopup(auth, provider);\n *\n * // The signed-in user info.\n * const user = result.user;\n * // This gives you a Github Access Token.\n * const credential = GithubAuthProvider.credentialFromResult(result);\n * const token = credential.accessToken;\n * ```\n * @public\n */\nexport class GithubAuthProvider extends BaseOAuthProvider {\n  /** Always set to {@link SignInMethod}.GITHUB. */\n  static readonly GITHUB_SIGN_IN_METHOD: 'github.com' = SignInMethod.GITHUB;\n  /** Always set to {@link ProviderId}.GITHUB. */\n  static readonly PROVIDER_ID: 'github.com' = ProviderId.GITHUB;\n\n  constructor() {\n    super(ProviderId.GITHUB);\n  }\n\n  /**\n   * Creates a credential for Github.\n   *\n   * @param accessToken - Github access token.\n   */\n  static credential(accessToken: string): OAuthCredential {\n    return OAuthCredential._fromParams({\n      providerId: GithubAuthProvider.PROVIDER_ID,\n      signInMethod: GithubAuthProvider.GITHUB_SIGN_IN_METHOD,\n      accessToken\n    });\n  }\n\n  /**\n   * Used to extract the underlying {@link OAuthCredential} from a {@link UserCredential}.\n   *\n   * @param userCredential - The user credential.\n   */\n  static credentialFromResult(\n    userCredential: UserCredential\n  ): OAuthCredential | null {\n    return GithubAuthProvider.credentialFromTaggedObject(\n      userCredential as UserCredentialInternal\n    );\n  }\n\n  /**\n   * Used to extract the underlying {@link OAuthCredential} from a {@link AuthError} which was\n   * thrown during a sign-in, link, or reauthenticate operation.\n   *\n   * @param userCredential - The user credential.\n   */\n  static credentialFromError(error: FirebaseError): OAuthCredential | null {\n    return GithubAuthProvider.credentialFromTaggedObject(\n      (error.customData || {}) as TaggedWithTokenResponse\n    );\n  }\n\n  private static credentialFromTaggedObject({\n    _tokenResponse: tokenResponse\n  }: TaggedWithTokenResponse): OAuthCredential | null {\n    if (!tokenResponse || !('oauthAccessToken' in tokenResponse)) {\n      return null;\n    }\n\n    if (!tokenResponse.oauthAccessToken) {\n      return null;\n    }\n\n    try {\n      return GithubAuthProvider.credential(tokenResponse.oauthAccessToken);\n    } catch {\n      return null;\n    }\n  }\n}\n","/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n/**\n * Represents the SAML credentials returned by an {@link SAMLAuthProvider}.\n *\n * @public\n */\n\nimport {\n  signInWithIdp,\n  SignInWithIdpRequest\n} from '../../api/authentication/idp';\nimport { AuthInternal } from '../../model/auth';\nimport { IdTokenResponse } from '../../model/id_token';\nimport { AuthCredential } from './auth_credential';\n\nconst IDP_REQUEST_URI = 'http://localhost';\n\n/**\n * @public\n */\nexport class SAMLAuthCredential extends AuthCredential {\n  /** @internal */\n  private constructor(\n    providerId: string,\n    private readonly pendingToken: string\n  ) {\n    super(providerId, providerId);\n  }\n\n  /** @internal */\n  _getIdTokenResponse(auth: AuthInternal): Promise<IdTokenResponse> {\n    const request = this.buildRequest();\n    return signInWithIdp(auth, request);\n  }\n\n  /** @internal */\n  _linkToIdToken(\n    auth: AuthInternal,\n    idToken: string\n  ): Promise<IdTokenResponse> {\n    const request = this.buildRequest();\n    request.idToken = idToken;\n    return signInWithIdp(auth, request);\n  }\n\n  /** @internal */\n  _getReauthenticationResolver(auth: AuthInternal): Promise<IdTokenResponse> {\n    const request = this.buildRequest();\n    request.autoCreate = false;\n    return signInWithIdp(auth, request);\n  }\n\n  /** {@inheritdoc AuthCredential.toJSON}  */\n  toJSON(): object {\n    return {\n      signInMethod: this.signInMethod,\n      providerId: this.providerId,\n      pendingToken: this.pendingToken\n    };\n  }\n\n  /**\n   * Static method to deserialize a JSON representation of an object into an\n   * {@link  AuthCredential}.\n   *\n   * @param json - Input can be either Object or the stringified representation of the object.\n   * When string is provided, JSON.parse would be called first.\n   *\n   * @returns If the JSON input does not represent an {@link  AuthCredential}, null is returned.\n   */\n  static fromJSON(json: string | object): SAMLAuthCredential | null {\n    const obj = typeof json === 'string' ? JSON.parse(json) : json;\n    const {\n      providerId,\n      signInMethod,\n      pendingToken\n    }: Record<string, string> = obj;\n    if (\n      !providerId ||\n      !signInMethod ||\n      !pendingToken ||\n      providerId !== signInMethod\n    ) {\n      return null;\n    }\n\n    return new SAMLAuthCredential(providerId, pendingToken);\n  }\n\n  /**\n   * Helper static method to avoid exposing the constructor to end users.\n   *\n   * @internal\n   */\n  static _create(providerId: string, pendingToken: string): SAMLAuthCredential {\n    return new SAMLAuthCredential(providerId, pendingToken);\n  }\n\n  private buildRequest(): SignInWithIdpRequest {\n    return {\n      requestUri: IDP_REQUEST_URI,\n      returnSecureToken: true,\n      pendingToken: this.pendingToken\n    };\n  }\n}\n","/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { FirebaseError } from '@firebase/util';\nimport { SignInWithIdpResponse } from '../../api/authentication/idp';\nimport { TaggedWithTokenResponse } from '../../model/id_token';\nimport { UserCredential } from '../../model/public_types';\nimport { UserCredentialInternal } from '../../model/user';\nimport { AuthCredential } from '../credentials';\nimport { SAMLAuthCredential } from '../credentials/saml';\nimport { AuthErrorCode } from '../errors';\nimport { _assert } from '../util/assert';\nimport { FederatedAuthProvider } from './federated';\n\nconst SAML_PROVIDER_PREFIX = 'saml.';\n\n/**\n * An {@link AuthProvider} for SAML.\n *\n * @public\n */\nexport class SAMLAuthProvider extends FederatedAuthProvider {\n  /**\n   * Constructor. The providerId must start with \"saml.\"\n   * @param providerId - SAML provider ID.\n   */\n  constructor(providerId: string) {\n    _assert(\n      providerId.startsWith(SAML_PROVIDER_PREFIX),\n      AuthErrorCode.ARGUMENT_ERROR\n    );\n    super(providerId);\n  }\n\n  /**\n   * Generates an {@link AuthCredential} from a {@link UserCredential} after a\n   * successful SAML flow completes.\n   *\n   * @remarks\n   *\n   * For example, to get an {@link AuthCredential}, you could write the\n   * following code:\n   *\n   * ```js\n   * const userCredential = await signInWithPopup(auth, samlProvider);\n   * const credential = SAMLAuthProvider.credentialFromResult(userCredential);\n   * ```\n   *\n   * @param userCredential - The user credential.\n   */\n  static credentialFromResult(\n    userCredential: UserCredential\n  ): AuthCredential | null {\n    return SAMLAuthProvider.samlCredentialFromTaggedObject(\n      userCredential as UserCredentialInternal\n    );\n  }\n\n  /**\n   * Used to extract the underlying {@link OAuthCredential} from a {@link AuthError} which was\n   * thrown during a sign-in, link, or reauthenticate operation.\n   *\n   * @param userCredential - The user credential.\n   */\n  static credentialFromError(error: FirebaseError): AuthCredential | null {\n    return SAMLAuthProvider.samlCredentialFromTaggedObject(\n      (error.customData || {}) as TaggedWithTokenResponse\n    );\n  }\n\n  /**\n   * Creates an {@link AuthCredential} from a JSON string or a plain object.\n   * @param json - A plain object or a JSON string\n   */\n  static credentialFromJSON(json: string | object): AuthCredential {\n    const credential = SAMLAuthCredential.fromJSON(json);\n    _assert(credential, AuthErrorCode.ARGUMENT_ERROR);\n    return credential;\n  }\n\n  private static samlCredentialFromTaggedObject({\n    _tokenResponse: tokenResponse\n  }: TaggedWithTokenResponse): SAMLAuthCredential | null {\n    if (!tokenResponse) {\n      return null;\n    }\n\n    const { pendingToken, providerId } = tokenResponse as SignInWithIdpResponse;\n\n    if (!pendingToken || !providerId) {\n      return null;\n    }\n\n    try {\n      return SAMLAuthCredential._create(providerId, pendingToken);\n    } catch (e) {\n      return null;\n    }\n  }\n}\n","/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n/**\n * @license\n * Copyright 2020 Twitter LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { UserCredential } from '../../model/public_types';\nimport { FirebaseError } from '@firebase/util';\n\nimport { SignInWithIdpResponse } from '../../api/authentication/idp';\nimport { TaggedWithTokenResponse } from '../../model/id_token';\nimport { UserCredentialInternal } from '../../model/user';\nimport { OAuthCredential } from '../credentials/oauth';\nimport { BaseOAuthProvider } from './oauth';\nimport { ProviderId, SignInMethod } from '../../model/enums';\n\n/**\n * Provider for generating an {@link OAuthCredential} for {@link ProviderId}.TWITTER.\n *\n * @example\n * ```javascript\n * // Sign in using a redirect.\n * const provider = new TwitterAuthProvider();\n * // Start a sign in process for an unauthenticated user.\n * await signInWithRedirect(auth, provider);\n * // This will trigger a full page redirect away from your app\n *\n * // After returning from the redirect when your app initializes you can obtain the result\n * const result = await getRedirectResult(auth);\n * if (result) {\n *   // This is the signed-in user\n *   const user = result.user;\n *   // This gives you a Twitter Access Token and Secret.\n *   const credential = TwitterAuthProvider.credentialFromResult(result);\n *   const token = credential.accessToken;\n *   const secret = credential.secret;\n * }\n * ```\n *\n * @example\n * ```javascript\n * // Sign in using a popup.\n * const provider = new TwitterAuthProvider();\n * const result = await signInWithPopup(auth, provider);\n *\n * // The signed-in user info.\n * const user = result.user;\n * // This gives you a Twitter Access Token and Secret.\n * const credential = TwitterAuthProvider.credentialFromResult(result);\n * const token = credential.accessToken;\n * const secret = credential.secret;\n * ```\n *\n * @public\n */\nexport class TwitterAuthProvider extends BaseOAuthProvider {\n  /** Always set to {@link SignInMethod}.TWITTER. */\n  static readonly TWITTER_SIGN_IN_METHOD: 'twitter.com' = SignInMethod.TWITTER;\n  /** Always set to {@link ProviderId}.TWITTER. */\n  static readonly PROVIDER_ID: 'twitter.com' = ProviderId.TWITTER;\n\n  constructor() {\n    super(ProviderId.TWITTER);\n  }\n\n  /**\n   * Creates a credential for Twitter.\n   *\n   * @param token - Twitter access token.\n   * @param secret - Twitter secret.\n   */\n  static credential(token: string, secret: string): OAuthCredential {\n    return OAuthCredential._fromParams({\n      providerId: TwitterAuthProvider.PROVIDER_ID,\n      signInMethod: TwitterAuthProvider.TWITTER_SIGN_IN_METHOD,\n      oauthToken: token,\n      oauthTokenSecret: secret\n    });\n  }\n\n  /**\n   * Used to extract the underlying {@link OAuthCredential} from a {@link UserCredential}.\n   *\n   * @param userCredential - The user credential.\n   */\n  static credentialFromResult(\n    userCredential: UserCredential\n  ): OAuthCredential | null {\n    return TwitterAuthProvider.credentialFromTaggedObject(\n      userCredential as UserCredentialInternal\n    );\n  }\n\n  /**\n   * Used to extract the underlying {@link OAuthCredential} from a {@link AuthError} which was\n   * thrown during a sign-in, link, or reauthenticate operation.\n   *\n   * @param userCredential - The user credential.\n   */\n  static credentialFromError(error: FirebaseError): OAuthCredential | null {\n    return TwitterAuthProvider.credentialFromTaggedObject(\n      (error.customData || {}) as TaggedWithTokenResponse\n    );\n  }\n\n  private static credentialFromTaggedObject({\n    _tokenResponse: tokenResponse\n  }: TaggedWithTokenResponse): OAuthCredential | null {\n    if (!tokenResponse) {\n      return null;\n    }\n    const { oauthAccessToken, oauthTokenSecret } =\n      tokenResponse as SignInWithIdpResponse;\n    if (!oauthAccessToken || !oauthTokenSecret) {\n      return null;\n    }\n\n    try {\n      return TwitterAuthProvider.credential(oauthAccessToken, oauthTokenSecret);\n    } catch {\n      return null;\n    }\n  }\n}\n","/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport {\n  Endpoint,\n  HttpMethod,\n  _addTidIfNecessary,\n  _performSignInRequest\n} from '../index';\nimport { IdTokenResponse } from '../../model/id_token';\nimport { Auth } from '../../model/public_types';\n\nexport interface SignUpRequest {\n  returnSecureToken?: boolean;\n  email?: string;\n  password?: string;\n  tenantId?: string;\n}\n\nexport interface SignUpResponse extends IdTokenResponse {\n  displayName?: string;\n  email?: string;\n}\n\nexport async function signUp(\n  auth: Auth,\n  request: SignUpRequest\n): Promise<SignUpResponse> {\n  return _performSignInRequest<SignUpRequest, SignUpResponse>(\n    auth,\n    HttpMethod.POST,\n    Endpoint.SIGN_UP,\n    _addTidIfNecessary(auth, request)\n  );\n}\n","/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { PhoneOrOauthTokenResponse } from '../../api/authentication/mfa';\nimport { IdTokenResponse } from '../../model/id_token';\nimport { UserInternal, UserCredentialInternal } from '../../model/user';\nimport { UserImpl } from './user_impl';\nimport { AuthInternal } from '../../model/auth';\nimport { OperationType, ProviderId } from '../../model/enums';\n\ninterface UserCredentialParams {\n  readonly user: UserInternal;\n  readonly providerId: ProviderId | string | null;\n  readonly _tokenResponse?: PhoneOrOauthTokenResponse;\n  readonly operationType: OperationType;\n}\n\nexport class UserCredentialImpl\n  implements UserCredentialInternal, UserCredentialParams\n{\n  readonly user: UserInternal;\n  readonly providerId: ProviderId | string | null;\n  readonly _tokenResponse: PhoneOrOauthTokenResponse | undefined;\n  readonly operationType: OperationType;\n\n  constructor(params: UserCredentialParams) {\n    this.user = params.user;\n    this.providerId = params.providerId;\n    this._tokenResponse = params._tokenResponse;\n    this.operationType = params.operationType;\n  }\n\n  static async _fromIdTokenResponse(\n    auth: AuthInternal,\n    operationType: OperationType,\n    idTokenResponse: IdTokenResponse,\n    isAnonymous: boolean = false\n  ): Promise<UserCredentialInternal> {\n    const user = await UserImpl._fromIdTokenResponse(\n      auth,\n      idTokenResponse,\n      isAnonymous\n    );\n    const providerId = providerIdForResponse(idTokenResponse);\n    const userCred = new UserCredentialImpl({\n      user,\n      providerId,\n      _tokenResponse: idTokenResponse,\n      operationType\n    });\n    return userCred;\n  }\n\n  static async _forOperation(\n    user: UserInternal,\n    operationType: OperationType,\n    response: PhoneOrOauthTokenResponse\n  ): Promise<UserCredentialImpl> {\n    await user._updateTokensIfNecessary(response, /* reload */ true);\n    const providerId = providerIdForResponse(response);\n    return new UserCredentialImpl({\n      user,\n      providerId,\n      _tokenResponse: response,\n      operationType\n    });\n  }\n}\n\nfunction providerIdForResponse(\n  response: IdTokenResponse\n): ProviderId | string | null {\n  if (response.providerId) {\n    return response.providerId;\n  }\n\n  if ('phoneNumber' in response) {\n    return ProviderId.PHONE;\n  }\n\n  return null;\n}\n","/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { Auth, UserCredential } from '../../model/public_types';\nimport { signUp } from '../../api/authentication/sign_up';\nimport { UserInternal } from '../../model/user';\nimport { UserCredentialImpl } from '../user/user_credential_impl';\nimport { _castAuth } from '../auth/auth_impl';\nimport { OperationType } from '../../model/enums';\n\n/**\n * Asynchronously signs in as an anonymous user.\n *\n * @remarks\n * If there is already an anonymous user signed in, that user will be returned; otherwise, a\n * new anonymous user identity will be created and returned.\n *\n * @param auth - The {@link Auth} instance.\n *\n * @public\n */\nexport async function signInAnonymously(auth: Auth): Promise<UserCredential> {\n  const authInternal = _castAuth(auth);\n  await authInternal._initializationPromise;\n  if (authInternal.currentUser?.isAnonymous) {\n    // If an anonymous user is already signed in, no need to sign them in again.\n    return new UserCredentialImpl({\n      user: authInternal.currentUser as UserInternal,\n      providerId: null,\n      operationType: OperationType.SIGN_IN\n    });\n  }\n  const response = await signUp(authInternal, {\n    returnSecureToken: true\n  });\n  const userCredential = await UserCredentialImpl._fromIdTokenResponse(\n    authInternal,\n    OperationType.SIGN_IN,\n    response,\n    true\n  );\n  await authInternal._updateCurrentUser(userCredential.user);\n  return userCredential;\n}\n","/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { MultiFactorError as MultiFactorErrorPublic } from '../model/public_types';\nimport { FirebaseError } from '@firebase/util';\nimport { AuthInternal } from '../model/auth';\nimport { IdTokenResponse } from '../model/id_token';\nimport { AuthErrorCode } from '../core/errors';\nimport { UserInternal } from '../model/user';\nimport { AuthCredential } from '../core/credentials';\nimport { IdTokenMfaResponse } from '../api/authentication/mfa';\nimport { OperationType } from '../model/enums';\n\nexport type MultiFactorErrorData = MultiFactorErrorPublic['customData'] & {\n  _serverResponse: IdTokenMfaResponse;\n};\n\nexport class MultiFactorError\n  extends FirebaseError\n  implements MultiFactorErrorPublic\n{\n  readonly customData: MultiFactorErrorData;\n\n  private constructor(\n    auth: AuthInternal,\n    error: FirebaseError,\n    readonly operationType: OperationType,\n    readonly user?: UserInternal\n  ) {\n    super(error.code, error.message);\n    // https://github.com/Microsoft/TypeScript-wiki/blob/master/Breaking-Changes.md#extending-built-ins-like-error-array-and-map-may-no-longer-work\n    Object.setPrototypeOf(this, MultiFactorError.prototype);\n    this.customData = {\n      appName: auth.name,\n      tenantId: auth.tenantId ?? undefined,\n      _serverResponse: error.customData!._serverResponse as IdTokenMfaResponse,\n      operationType,\n    };\n  }\n\n  static _fromErrorAndOperation(\n    auth: AuthInternal,\n    error: FirebaseError,\n    operationType: OperationType,\n    user?: UserInternal\n  ): MultiFactorError {\n    return new MultiFactorError(auth, error, operationType, user);\n  }\n}\n\nexport function _processCredentialSavingMfaContextIfNecessary(\n  auth: AuthInternal,\n  operationType: OperationType,\n  credential: AuthCredential,\n  user?: UserInternal\n): Promise<IdTokenResponse> {\n  const idTokenProvider =\n    operationType === OperationType.REAUTHENTICATE\n      ? credential._getReauthenticationResolver(auth)\n      : credential._getIdTokenResponse(auth);\n\n  return idTokenProvider.catch(error => {\n    if (error.code === `auth/${AuthErrorCode.MFA_REQUIRED}`) {\n      throw MultiFactorError._fromErrorAndOperation(\n        auth,\n        error,\n        operationType,\n        user\n      );\n    }\n\n    throw error;\n  });\n}\n","/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nexport interface ProviderAssociatedObject {\n  providerId?: string;\n}\n\n/**\n * Takes a set of UserInfo provider data and converts it to a set of names\n */\nexport function providerDataAsNames<T extends ProviderAssociatedObject>(\n  providerData: T[]\n): Set<string> {\n  return new Set(\n    providerData\n      .map(({ providerId }) => providerId)\n      .filter(pid => !!pid) as string[]\n  );\n}\n","/**\n * @license\n * Copyright 2019 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { User } from '../../model/public_types';\n\nimport { deleteLinkedAccounts } from '../../api/account_management/account';\nimport { UserInternal, UserCredentialInternal } from '../../model/user';\nimport { AuthCredential } from '../credentials';\nimport { AuthErrorCode } from '../errors';\nimport { _assert } from '../util/assert';\nimport { providerDataAsNames } from '../util/providers';\nimport { _logoutIfInvalidated } from './invalidation';\nimport { _reloadWithoutSaving } from './reload';\nimport { UserCredentialImpl } from './user_credential_impl';\nimport { getModularInstance } from '@firebase/util';\nimport { OperationType, ProviderId } from '../../model/enums';\n\n/**\n * Unlinks a provider from a user account.\n *\n * @param user - The user.\n * @param providerId - The provider to unlink.\n *\n * @public\n */\nexport async function unlink(user: User, providerId: string): Promise<User> {\n  const userInternal = getModularInstance(user) as UserInternal;\n  await _assertLinkedStatus(true, userInternal, providerId);\n  const { providerUserInfo } = await deleteLinkedAccounts(userInternal.auth, {\n    idToken: await userInternal.getIdToken(),\n    deleteProvider: [providerId]\n  });\n\n  const providersLeft = providerDataAsNames(providerUserInfo || []);\n\n  userInternal.providerData = userInternal.providerData.filter(pd =>\n    providersLeft.has(pd.providerId)\n  );\n  if (!providersLeft.has(ProviderId.PHONE)) {\n    userInternal.phoneNumber = null;\n  }\n\n  await userInternal.auth._persistUserIfCurrent(userInternal);\n  return userInternal;\n}\n\nexport async function _link(\n  user: UserInternal,\n  credential: AuthCredential,\n  bypassAuthState = false\n): Promise<UserCredentialInternal> {\n  const response = await _logoutIfInvalidated(\n    user,\n    credential._linkToIdToken(user.auth, await user.getIdToken()),\n    bypassAuthState\n  );\n  return UserCredentialImpl._forOperation(user, OperationType.LINK, response);\n}\n\nexport async function _assertLinkedStatus(\n  expected: boolean,\n  user: UserInternal,\n  provider: string\n): Promise<void> {\n  await _reloadWithoutSaving(user);\n  const providerIds = providerDataAsNames(user.providerData);\n\n  const code =\n    expected === false\n      ? AuthErrorCode.PROVIDER_ALREADY_LINKED\n      : AuthErrorCode.NO_SUCH_PROVIDER;\n  _assert(providerIds.has(provider) === expected, user.auth, code);\n}\n","/**\n * @license\n * Copyright 2019 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { _processCredentialSavingMfaContextIfNecessary } from '../../mfa/mfa_error';\nimport { OperationType } from '../../model/enums';\nimport { UserInternal } from '../../model/user';\nimport { AuthCredential } from '../credentials';\nimport { AuthErrorCode } from '../errors';\nimport { _assert, _fail } from '../util/assert';\nimport { _parseToken } from './id_token_result';\nimport { _logoutIfInvalidated } from './invalidation';\nimport { UserCredentialImpl } from './user_credential_impl';\n\nexport async function _reauthenticate(\n  user: UserInternal,\n  credential: AuthCredential,\n  bypassAuthState = false\n): Promise<UserCredentialImpl> {\n  const { auth } = user;\n  const operationType = OperationType.REAUTHENTICATE;\n\n  try {\n    const response = await _logoutIfInvalidated(\n      user,\n      _processCredentialSavingMfaContextIfNecessary(\n        auth,\n        operationType,\n        credential,\n        user\n      ),\n      bypassAuthState\n    );\n    _assert(response.idToken, auth, AuthErrorCode.INTERNAL_ERROR);\n    const parsed = _parseToken(response.idToken);\n    _assert(parsed, auth, AuthErrorCode.INTERNAL_ERROR);\n\n    const { sub: localId } = parsed;\n    _assert(user.uid === localId, auth, AuthErrorCode.USER_MISMATCH);\n\n    return UserCredentialImpl._forOperation(user, operationType, response);\n  } catch (e) {\n    // Convert user deleted error into user mismatch\n    if (e?.code === `auth/${AuthErrorCode.USER_DELETED}`) {\n      _fail(auth, AuthErrorCode.USER_MISMATCH);\n    }\n    throw e;\n  }\n}\n","/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { UserCredential, Auth, User } from '../../model/public_types';\n\nimport { _processCredentialSavingMfaContextIfNecessary } from '../../mfa/mfa_error';\nimport { AuthInternal } from '../../model/auth';\nimport { UserInternal } from '../../model/user';\nimport { AuthCredential } from '../credentials';\nimport { _assertLinkedStatus, _link } from '../user/link_unlink';\nimport { _reauthenticate } from '../user/reauthenticate';\nimport { UserCredentialImpl } from '../user/user_credential_impl';\nimport { _castAuth } from '../auth/auth_impl';\nimport { getModularInstance } from '@firebase/util';\nimport { OperationType } from '../../model/enums';\n\nexport async function _signInWithCredential(\n  auth: AuthInternal,\n  credential: AuthCredential,\n  bypassAuthState = false\n): Promise<UserCredential> {\n  const operationType = OperationType.SIGN_IN;\n  const response = await _processCredentialSavingMfaContextIfNecessary(\n    auth,\n    operationType,\n    credential\n  );\n  const userCredential = await UserCredentialImpl._fromIdTokenResponse(\n    auth,\n    operationType,\n    response\n  );\n\n  if (!bypassAuthState) {\n    await auth._updateCurrentUser(userCredential.user);\n  }\n  return userCredential;\n}\n\n/**\n * Asynchronously signs in with the given credentials.\n *\n * @remarks\n * An {@link AuthProvider} can be used to generate the credential.\n *\n * @param auth - The {@link Auth} instance.\n * @param credential - The auth credential.\n *\n * @public\n */\nexport async function signInWithCredential(\n  auth: Auth,\n  credential: AuthCredential\n): Promise<UserCredential> {\n  return _signInWithCredential(_castAuth(auth), credential);\n}\n\n/**\n * Links the user account with the given credentials.\n *\n * @remarks\n * An {@link AuthProvider} can be used to generate the credential.\n *\n * @param user - The user.\n * @param credential - The auth credential.\n *\n * @public\n */\nexport async function linkWithCredential(\n  user: User,\n  credential: AuthCredential\n): Promise<UserCredential> {\n  const userInternal = getModularInstance(user) as UserInternal;\n\n  await _assertLinkedStatus(false, userInternal, credential.providerId);\n\n  return _link(userInternal, credential);\n}\n\n/**\n * Re-authenticates a user using a fresh credential.\n *\n * @remarks\n * Use before operations such as {@link updatePassword} that require tokens from recent sign-in\n * attempts. This method can be used to recover from a `CREDENTIAL_TOO_OLD_LOGIN_AGAIN` error.\n *\n * @param user - The user.\n * @param credential - The auth credential.\n *\n * @public\n */\nexport async function reauthenticateWithCredential(\n  user: User,\n  credential: AuthCredential\n): Promise<UserCredential> {\n  return _reauthenticate(getModularInstance(user) as UserInternal, credential);\n}\n","/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport {\n  Endpoint,\n  HttpMethod,\n  _addTidIfNecessary,\n  _performSignInRequest\n} from '../index';\nimport { IdTokenResponse } from '../../model/id_token';\nimport { Auth } from '../../model/public_types';\n\nexport interface SignInWithCustomTokenRequest {\n  token: string;\n  returnSecureToken: boolean;\n  tenantId?: string;\n}\n\nexport interface SignInWithCustomTokenResponse extends IdTokenResponse {}\n\nexport async function signInWithCustomToken(\n  auth: Auth,\n  request: SignInWithCustomTokenRequest\n): Promise<SignInWithCustomTokenResponse> {\n  return _performSignInRequest<\n    SignInWithCustomTokenRequest,\n    SignInWithCustomTokenResponse\n  >(\n    auth,\n    HttpMethod.POST,\n    Endpoint.SIGN_IN_WITH_CUSTOM_TOKEN,\n    _addTidIfNecessary(auth, request)\n  );\n}\n","/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { Auth, UserCredential } from '../../model/public_types';\n\nimport { signInWithCustomToken as getIdTokenResponse } from '../../api/authentication/custom_token';\nimport { IdTokenResponse } from '../../model/id_token';\nimport { UserCredentialImpl } from '../user/user_credential_impl';\nimport { _castAuth } from '../auth/auth_impl';\nimport { OperationType } from '../../model/enums';\n\n/**\n * Asynchronously signs in using a custom token.\n *\n * @remarks\n * Custom tokens are used to integrate Firebase Auth with existing auth systems, and must\n * be generated by an auth backend using the\n * {@link https://firebase.google.com/docs/reference/admin/node/admin.auth.Auth#createcustomtoken | createCustomToken}\n * method in the {@link https://firebase.google.com/docs/auth/admin | Admin SDK} .\n *\n * Fails with an error if the token is invalid, expired, or not accepted by the Firebase Auth service.\n *\n * @param auth - The {@link Auth} instance.\n * @param customToken - The custom token to sign in with.\n *\n * @public\n */\nexport async function signInWithCustomToken(\n  auth: Auth,\n  customToken: string\n): Promise<UserCredential> {\n  const authInternal = _castAuth(auth);\n  const response: IdTokenResponse = await getIdTokenResponse(authInternal, {\n    token: customToken,\n    returnSecureToken: true\n  });\n  const cred = await UserCredentialImpl._fromIdTokenResponse(\n    authInternal,\n    OperationType.SIGN_IN,\n    response\n  );\n  await authInternal._updateCurrentUser(cred.user);\n  return cred;\n}\n","/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { FactorId, MultiFactorInfo, PhoneMultiFactorInfo } from '../model/public_types';\nimport {\n  PhoneMfaEnrollment,\n  MfaEnrollment\n} from '../api/account_management/mfa';\nimport { AuthErrorCode } from '../core/errors';\nimport { _fail } from '../core/util/assert';\nimport { AuthInternal } from '../model/auth';\n\nexport abstract class MultiFactorInfoImpl implements MultiFactorInfo {\n  readonly uid: string;\n  readonly displayName?: string | null;\n  readonly enrollmentTime: string;\n\n  protected constructor(readonly factorId: FactorId, response: MfaEnrollment) {\n    this.uid = response.mfaEnrollmentId;\n    this.enrollmentTime = new Date(response.enrolledAt).toUTCString();\n    this.displayName = response.displayName;\n  }\n\n  static _fromServerResponse(\n    auth: AuthInternal,\n    enrollment: MfaEnrollment\n  ): MultiFactorInfoImpl {\n    if ('phoneInfo' in enrollment) {\n      return PhoneMultiFactorInfoImpl._fromServerResponse(auth, enrollment);\n    }\n    return _fail(auth, AuthErrorCode.INTERNAL_ERROR);\n  }\n}\n\nexport class PhoneMultiFactorInfoImpl extends MultiFactorInfoImpl implements PhoneMultiFactorInfo {\n  readonly phoneNumber: string;\n\n  private constructor(response: PhoneMfaEnrollment) {\n    super(FactorId.PHONE, response);\n    this.phoneNumber = response.phoneInfo;\n  }\n\n  static _fromServerResponse(\n    _auth: AuthInternal,\n    enrollment: MfaEnrollment\n  ): PhoneMultiFactorInfoImpl {\n    return new PhoneMultiFactorInfoImpl(enrollment);\n  }\n}\n","/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { ActionCodeSettings, Auth } from '../../model/public_types';\n\nimport { GetOobCodeRequest } from '../../api/authentication/email_and_password';\nimport { AuthErrorCode } from '../errors';\nimport { _assert } from '../util/assert';\n\nexport function _setActionCodeSettingsOnRequest(\n  auth: Auth,\n  request: GetOobCodeRequest,\n  actionCodeSettings: ActionCodeSettings\n): void {\n  _assert(\n    actionCodeSettings.url?.length > 0,\n    auth,\n    AuthErrorCode.INVALID_CONTINUE_URI\n  );\n  _assert(\n    typeof actionCodeSettings.dynamicLinkDomain === 'undefined' ||\n      actionCodeSettings.dynamicLinkDomain.length > 0,\n    auth,\n    AuthErrorCode.INVALID_DYNAMIC_LINK_DOMAIN\n  );\n\n  request.continueUrl = actionCodeSettings.url;\n  request.dynamicLinkDomain = actionCodeSettings.dynamicLinkDomain;\n  request.canHandleCodeInApp = actionCodeSettings.handleCodeInApp;\n\n  if (actionCodeSettings.iOS) {\n    _assert(\n      actionCodeSettings.iOS.bundleId.length > 0,\n      auth,\n      AuthErrorCode.MISSING_IOS_BUNDLE_ID\n    );\n    request.iOSBundleId = actionCodeSettings.iOS.bundleId;\n  }\n\n  if (actionCodeSettings.android) {\n    _assert(\n      actionCodeSettings.android.packageName.length > 0,\n      auth,\n      AuthErrorCode.MISSING_ANDROID_PACKAGE_NAME\n    );\n    request.androidInstallApp = actionCodeSettings.android.installApp;\n    request.androidMinimumVersionCode =\n      actionCodeSettings.android.minimumVersion;\n    request.androidPackageName = actionCodeSettings.android.packageName;\n  }\n}\n","/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport {\n  ActionCodeInfo,\n  ActionCodeOperation,\n  ActionCodeSettings,\n  Auth,\n  UserCredential\n} from '../../model/public_types';\n\nimport * as account from '../../api/account_management/email_and_password';\nimport * as authentication from '../../api/authentication/email_and_password';\nimport { signUp } from '../../api/authentication/sign_up';\nimport { MultiFactorInfoImpl } from '../../mfa/mfa_info';\nimport { EmailAuthProvider } from '../providers/email';\nimport { UserCredentialImpl } from '../user/user_credential_impl';\nimport { _assert } from '../util/assert';\nimport { _setActionCodeSettingsOnRequest } from './action_code_settings';\nimport { signInWithCredential } from './credential';\nimport { _castAuth } from '../auth/auth_impl';\nimport { AuthErrorCode } from '../errors';\nimport { getModularInstance } from '@firebase/util';\nimport { OperationType } from '../../model/enums';\n\n/**\n * Sends a password reset email to the given email address.\n *\n * @remarks\n * To complete the password reset, call {@link confirmPasswordReset} with the code supplied in\n * the email sent to the user, along with the new password specified by the user.\n *\n * @example\n * ```javascript\n * const actionCodeSettings = {\n *   url: 'https://www.example.com/?email=user@example.com',\n *   iOS: {\n *      bundleId: 'com.example.ios'\n *   },\n *   android: {\n *     packageName: 'com.example.android',\n *     installApp: true,\n *     minimumVersion: '12'\n *   },\n *   handleCodeInApp: true\n * };\n * await sendPasswordResetEmail(auth, 'user@example.com', actionCodeSettings);\n * // Obtain code from user.\n * await confirmPasswordReset('user@example.com', code);\n * ```\n *\n * @param auth - The {@link Auth} instance.\n * @param email - The user's email address.\n * @param actionCodeSettings - The {@link ActionCodeSettings}.\n *\n * @public\n */\nexport async function sendPasswordResetEmail(\n  auth: Auth,\n  email: string,\n  actionCodeSettings?: ActionCodeSettings\n): Promise<void> {\n  const authModular = getModularInstance(auth);\n  const request: authentication.PasswordResetRequest = {\n    requestType: ActionCodeOperation.PASSWORD_RESET,\n    email\n  };\n  if (actionCodeSettings) {\n    _setActionCodeSettingsOnRequest(authModular, request, actionCodeSettings);\n  }\n\n  await authentication.sendPasswordResetEmail(authModular, request);\n}\n\n/**\n * Completes the password reset process, given a confirmation code and new password.\n *\n * @param auth - The {@link Auth} instance.\n * @param oobCode - A confirmation code sent to the user.\n * @param newPassword - The new password.\n *\n * @public\n */\nexport async function confirmPasswordReset(\n  auth: Auth,\n  oobCode: string,\n  newPassword: string\n): Promise<void> {\n  await account.resetPassword(getModularInstance(auth), {\n    oobCode,\n    newPassword\n  });\n  // Do not return the email.\n}\n\n/**\n * Applies a verification code sent to the user by email or other out-of-band mechanism.\n *\n * @param auth - The {@link Auth} instance.\n * @param oobCode - A verification code sent to the user.\n *\n * @public\n */\nexport async function applyActionCode(\n  auth: Auth,\n  oobCode: string\n): Promise<void> {\n  await account.applyActionCode(getModularInstance(auth), { oobCode });\n}\n\n/**\n * Checks a verification code sent to the user by email or other out-of-band mechanism.\n *\n * @returns metadata about the code.\n *\n * @param auth - The {@link Auth} instance.\n * @param oobCode - A verification code sent to the user.\n *\n * @public\n */\nexport async function checkActionCode(\n  auth: Auth,\n  oobCode: string\n): Promise<ActionCodeInfo> {\n  const authModular = getModularInstance(auth);\n  const response = await account.resetPassword(authModular, { oobCode });\n\n  // Email could be empty only if the request type is EMAIL_SIGNIN or\n  // VERIFY_AND_CHANGE_EMAIL.\n  // New email should not be empty if the request type is\n  // VERIFY_AND_CHANGE_EMAIL.\n  // Multi-factor info could not be empty if the request type is\n  // REVERT_SECOND_FACTOR_ADDITION.\n  const operation = response.requestType;\n  _assert(operation, authModular, AuthErrorCode.INTERNAL_ERROR);\n  switch (operation) {\n    case ActionCodeOperation.EMAIL_SIGNIN:\n      break;\n    case ActionCodeOperation.VERIFY_AND_CHANGE_EMAIL:\n      _assert(response.newEmail, authModular, AuthErrorCode.INTERNAL_ERROR);\n      break;\n    case ActionCodeOperation.REVERT_SECOND_FACTOR_ADDITION:\n      _assert(response.mfaInfo, authModular, AuthErrorCode.INTERNAL_ERROR);\n    // fall through\n    default:\n      _assert(response.email, authModular, AuthErrorCode.INTERNAL_ERROR);\n  }\n\n  // The multi-factor info for revert second factor addition\n  let multiFactorInfo: MultiFactorInfoImpl | null = null;\n  if (response.mfaInfo) {\n    multiFactorInfo = MultiFactorInfoImpl._fromServerResponse(\n      _castAuth(authModular),\n      response.mfaInfo\n    );\n  }\n\n  return {\n    data: {\n      email:\n        (response.requestType === ActionCodeOperation.VERIFY_AND_CHANGE_EMAIL\n          ? response.newEmail\n          : response.email) || null,\n      previousEmail:\n        (response.requestType === ActionCodeOperation.VERIFY_AND_CHANGE_EMAIL\n          ? response.email\n          : response.newEmail) || null,\n      multiFactorInfo\n    },\n    operation\n  };\n}\n\n/**\n * Checks a password reset code sent to the user by email or other out-of-band mechanism.\n *\n * @returns the user's email address if valid.\n *\n * @param auth - The {@link Auth} instance.\n * @param code - A verification code sent to the user.\n *\n * @public\n */\nexport async function verifyPasswordResetCode(\n  auth: Auth,\n  code: string\n): Promise<string> {\n  const { data } = await checkActionCode(getModularInstance(auth), code);\n  // Email should always be present since a code was sent to it\n  return data.email!;\n}\n\n/**\n * Creates a new user account associated with the specified email address and password.\n *\n * @remarks\n * On successful creation of the user account, this user will also be signed in to your application.\n *\n * User account creation can fail if the account already exists or the password is invalid.\n *\n * Note: The email address acts as a unique identifier for the user and enables an email-based\n * password reset. This function will create a new user account and set the initial user password.\n *\n * @param auth - The {@link Auth} instance.\n * @param email - The user's email address.\n * @param password - The user's chosen password.\n *\n * @public\n */\nexport async function createUserWithEmailAndPassword(\n  auth: Auth,\n  email: string,\n  password: string\n): Promise<UserCredential> {\n  const authInternal = _castAuth(auth);\n  const response = await signUp(authInternal, {\n    returnSecureToken: true,\n    email,\n    password\n  });\n\n  const userCredential = await UserCredentialImpl._fromIdTokenResponse(\n    authInternal,\n    OperationType.SIGN_IN,\n    response\n  );\n  await authInternal._updateCurrentUser(userCredential.user);\n\n  return userCredential;\n}\n\n/**\n * Asynchronously signs in using an email and password.\n *\n * @remarks\n * Fails with an error if the email address and password do not match.\n *\n * Note: The user's password is NOT the password used to access the user's email account. The\n * email address serves as a unique identifier for the user, and the password is used to access\n * the user's account in your Firebase project. See also: {@link createUserWithEmailAndPassword}.\n *\n * @param auth - The {@link Auth} instance.\n * @param email - The users email address.\n * @param password - The users password.\n *\n * @public\n */\nexport function signInWithEmailAndPassword(\n  auth: Auth,\n  email: string,\n  password: string\n): Promise<UserCredential> {\n  return signInWithCredential(\n    getModularInstance(auth),\n    EmailAuthProvider.credential(email, password)\n  );\n}\n","/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport {\n  ActionCodeOperation,\n  ActionCodeSettings,\n  Auth,\n  UserCredential\n} from '../../model/public_types';\n\nimport * as api from '../../api/authentication/email_and_password';\nimport { ActionCodeURL } from '../action_code_url';\nimport { EmailAuthProvider } from '../providers/email';\nimport { _getCurrentUrl } from '../util/location';\nimport { _setActionCodeSettingsOnRequest } from './action_code_settings';\nimport { signInWithCredential } from './credential';\nimport { AuthErrorCode } from '../errors';\nimport { _assert } from '../util/assert';\nimport { getModularInstance } from '@firebase/util';\n\n/**\n * Sends a sign-in email link to the user with the specified email.\n *\n * @remarks\n * The sign-in operation has to always be completed in the app unlike other out of band email\n * actions (password reset and email verifications). This is because, at the end of the flow,\n * the user is expected to be signed in and their Auth state persisted within the app.\n *\n * To complete sign in with the email link, call {@link signInWithEmailLink} with the email\n * address and the email link supplied in the email sent to the user.\n *\n * @example\n * ```javascript\n * const actionCodeSettings = {\n *   url: 'https://www.example.com/?email=user@example.com',\n *   iOS: {\n *      bundleId: 'com.example.ios'\n *   },\n *   android: {\n *     packageName: 'com.example.android',\n *     installApp: true,\n *     minimumVersion: '12'\n *   },\n *   handleCodeInApp: true\n * };\n * await sendSignInLinkToEmail(auth, 'user@example.com', actionCodeSettings);\n * // Obtain emailLink from the user.\n * if(isSignInWithEmailLink(auth, emailLink)) {\n *   await signInWithEmailLink(auth, 'user@example.com', emailLink);\n * }\n * ```\n *\n * @param authInternal - The {@link Auth} instance.\n * @param email - The user's email address.\n * @param actionCodeSettings - The {@link ActionCodeSettings}.\n *\n * @public\n */\nexport async function sendSignInLinkToEmail(\n  auth: Auth,\n  email: string,\n  actionCodeSettings: ActionCodeSettings\n): Promise<void> {\n  const authModular = getModularInstance(auth);\n  const request: api.EmailSignInRequest = {\n    requestType: ActionCodeOperation.EMAIL_SIGNIN,\n    email\n  };\n  _assert(\n    actionCodeSettings.handleCodeInApp,\n    authModular,\n    AuthErrorCode.ARGUMENT_ERROR\n  );\n  if (actionCodeSettings) {\n    _setActionCodeSettingsOnRequest(authModular, request, actionCodeSettings);\n  }\n\n  await api.sendSignInLinkToEmail(authModular, request);\n}\n\n/**\n * Checks if an incoming link is a sign-in with email link suitable for {@link signInWithEmailLink}.\n *\n * @param auth - The {@link Auth} instance.\n * @param emailLink - The link sent to the user's email address.\n *\n * @public\n */\nexport function isSignInWithEmailLink(auth: Auth, emailLink: string): boolean {\n  const actionCodeUrl = ActionCodeURL.parseLink(emailLink);\n  return actionCodeUrl?.operation === ActionCodeOperation.EMAIL_SIGNIN;\n}\n\n/**\n * Asynchronously signs in using an email and sign-in email link.\n *\n * @remarks\n * If no link is passed, the link is inferred from the current URL.\n *\n * Fails with an error if the email address is invalid or OTP in email link expires.\n *\n * Note: Confirm the link is a sign-in email link before calling this method firebase.auth.Auth.isSignInWithEmailLink.\n *\n * @example\n * ```javascript\n * const actionCodeSettings = {\n *   url: 'https://www.example.com/?email=user@example.com',\n *   iOS: {\n *      bundleId: 'com.example.ios'\n *   },\n *   android: {\n *     packageName: 'com.example.android',\n *     installApp: true,\n *     minimumVersion: '12'\n *   },\n *   handleCodeInApp: true\n * };\n * await sendSignInLinkToEmail(auth, 'user@example.com', actionCodeSettings);\n * // Obtain emailLink from the user.\n * if(isSignInWithEmailLink(auth, emailLink)) {\n *   await signInWithEmailLink(auth, 'user@example.com', emailLink);\n * }\n * ```\n *\n * @param auth - The {@link Auth} instance.\n * @param email - The user's email address.\n * @param emailLink - The link sent to the user's email address.\n *\n * @public\n */\nexport async function signInWithEmailLink(\n  auth: Auth,\n  email: string,\n  emailLink?: string\n): Promise<UserCredential> {\n  const authModular = getModularInstance(auth);\n  const credential = EmailAuthProvider.credentialWithLink(\n    email,\n    emailLink || _getCurrentUrl()\n  );\n  // Check if the tenant ID in the email link matches the tenant ID on Auth\n  // instance.\n  _assert(\n    credential._tenantId === (authModular.tenantId || null),\n    authModular,\n    AuthErrorCode.TENANT_ID_MISMATCH\n  );\n  return signInWithCredential(authModular, credential);\n}\n","/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport {\n  Endpoint,\n  HttpMethod,\n  _addTidIfNecessary,\n  _performApiRequest\n} from '../index';\nimport { Auth } from '../../model/public_types';\n\nexport interface CreateAuthUriRequest {\n  identifier: string;\n  continueUri: string;\n  tenantId?: string;\n}\n\nexport interface CreateAuthUriResponse {\n  signinMethods: string[];\n}\n\nexport async function createAuthUri(\n  auth: Auth,\n  request: CreateAuthUriRequest\n): Promise<CreateAuthUriResponse> {\n  return _performApiRequest<CreateAuthUriRequest, CreateAuthUriResponse>(\n    auth,\n    HttpMethod.POST,\n    Endpoint.CREATE_AUTH_URI,\n    _addTidIfNecessary(auth, request)\n  );\n}\n","/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport {\n  ActionCodeOperation,\n  ActionCodeSettings,\n  Auth,\n  User\n} from '../../model/public_types';\n\nimport {\n  createAuthUri,\n  CreateAuthUriRequest\n} from '../../api/authentication/create_auth_uri';\nimport * as api from '../../api/authentication/email_and_password';\nimport { UserInternal } from '../../model/user';\nimport { _getCurrentUrl, _isHttpOrHttps } from '../util/location';\nimport { _setActionCodeSettingsOnRequest } from './action_code_settings';\nimport { getModularInstance } from '@firebase/util';\n\n/**\n * Gets the list of possible sign in methods for the given email address.\n *\n * @remarks\n * This is useful to differentiate methods of sign-in for the same provider, eg.\n * {@link EmailAuthProvider} which has 2 methods of sign-in,\n * {@link SignInMethod}.EMAIL_PASSWORD and\n * {@link SignInMethod}.EMAIL_LINK.\n *\n * @param auth - The {@link Auth} instance.\n * @param email - The user's email address.\n *\n * @public\n */\nexport async function fetchSignInMethodsForEmail(\n  auth: Auth,\n  email: string\n): Promise<string[]> {\n  // createAuthUri returns an error if continue URI is not http or https.\n  // For environments like Cordova, Chrome extensions, native frameworks, file\n  // systems, etc, use http://localhost as continue URL.\n  const continueUri = _isHttpOrHttps() ? _getCurrentUrl() : 'http://localhost';\n  const request: CreateAuthUriRequest = {\n    identifier: email,\n    continueUri\n  };\n\n  const { signinMethods } = await createAuthUri(\n    getModularInstance(auth),\n    request\n  );\n\n  return signinMethods || [];\n}\n\n/**\n * Sends a verification email to a user.\n *\n * @remarks\n * The verification process is completed by calling {@link applyActionCode}.\n *\n * @example\n * ```javascript\n * const actionCodeSettings = {\n *   url: 'https://www.example.com/?email=user@example.com',\n *   iOS: {\n *      bundleId: 'com.example.ios'\n *   },\n *   android: {\n *     packageName: 'com.example.android',\n *     installApp: true,\n *     minimumVersion: '12'\n *   },\n *   handleCodeInApp: true\n * };\n * await sendEmailVerification(user, actionCodeSettings);\n * // Obtain code from the user.\n * await applyActionCode(auth, code);\n * ```\n *\n * @param user - The user.\n * @param actionCodeSettings - The {@link ActionCodeSettings}.\n *\n * @public\n */\nexport async function sendEmailVerification(\n  user: User,\n  actionCodeSettings?: ActionCodeSettings | null\n): Promise<void> {\n  const userInternal = getModularInstance(user) as UserInternal;\n  const idToken = await user.getIdToken();\n  const request: api.VerifyEmailRequest = {\n    requestType: ActionCodeOperation.VERIFY_EMAIL,\n    idToken\n  };\n  if (actionCodeSettings) {\n    _setActionCodeSettingsOnRequest(\n      userInternal.auth,\n      request,\n      actionCodeSettings\n    );\n  }\n\n  const { email } = await api.sendEmailVerification(userInternal.auth, request);\n\n  if (email !== user.email) {\n    await user.reload();\n  }\n}\n\n/**\n * Sends a verification email to a new email address.\n *\n * @remarks\n * The user's email will be updated to the new one after being verified.\n *\n * If you have a custom email action handler, you can complete the verification process by calling\n * {@link applyActionCode}.\n *\n * @example\n * ```javascript\n * const actionCodeSettings = {\n *   url: 'https://www.example.com/?email=user@example.com',\n *   iOS: {\n *      bundleId: 'com.example.ios'\n *   },\n *   android: {\n *     packageName: 'com.example.android',\n *     installApp: true,\n *     minimumVersion: '12'\n *   },\n *   handleCodeInApp: true\n * };\n * await verifyBeforeUpdateEmail(user, 'newemail@example.com', actionCodeSettings);\n * // Obtain code from the user.\n * await applyActionCode(auth, code);\n * ```\n *\n * @param user - The user.\n * @param newEmail - The new email address to be verified before update.\n * @param actionCodeSettings - The {@link ActionCodeSettings}.\n *\n * @public\n */\nexport async function verifyBeforeUpdateEmail(\n  user: User,\n  newEmail: string,\n  actionCodeSettings?: ActionCodeSettings | null\n): Promise<void> {\n  const userInternal = getModularInstance(user) as UserInternal;\n  const idToken = await user.getIdToken();\n  const request: api.VerifyAndChangeEmailRequest = {\n    requestType: ActionCodeOperation.VERIFY_AND_CHANGE_EMAIL,\n    idToken,\n    newEmail\n  };\n  if (actionCodeSettings) {\n    _setActionCodeSettingsOnRequest(\n      userInternal.auth,\n      request,\n      actionCodeSettings\n    );\n  }\n\n  const { email } = await api.verifyAndChangeEmail(userInternal.auth, request);\n\n  if (email !== user.email) {\n    // If the local copy of the email on user is outdated, reload the\n    // user.\n    await user.reload();\n  }\n}\n","/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { Endpoint, HttpMethod, _performApiRequest } from '../index';\nimport { IdTokenResponse } from '../../model/id_token';\nimport { Auth } from '../../model/public_types';\n\nexport interface UpdateProfileRequest {\n  idToken: string;\n  displayName?: string | null;\n  photoUrl?: string | null;\n  returnSecureToken: boolean;\n}\n\nexport interface UpdateProfileResponse extends IdTokenResponse {\n  displayName?: string | null;\n  photoUrl?: string | null;\n}\n\nexport async function updateProfile(\n  auth: Auth,\n  request: UpdateProfileRequest\n): Promise<UpdateProfileResponse> {\n  return _performApiRequest<UpdateProfileRequest, UpdateProfileResponse>(\n    auth,\n    HttpMethod.POST,\n    Endpoint.SET_ACCOUNT_INFO,\n    request\n  );\n}\n","/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { User } from '../../model/public_types';\n\nimport {\n  updateEmailPassword as apiUpdateEmailPassword,\n  UpdateEmailPasswordRequest\n} from '../../api/account_management/email_and_password';\nimport { updateProfile as apiUpdateProfile } from '../../api/account_management/profile';\nimport { UserInternal } from '../../model/user';\nimport { _logoutIfInvalidated } from './invalidation';\nimport { getModularInstance } from '@firebase/util';\nimport { ProviderId } from '../../model/enums';\n\n/**\n * Updates a user's profile data.\n *\n * @param user - The user.\n * @param profile - The profile's `displayName` and `photoURL` to update.\n *\n * @public\n */\nexport async function updateProfile(\n  user: User,\n  {\n    displayName,\n    photoURL: photoUrl\n  }: { displayName?: string | null; photoURL?: string | null }\n): Promise<void> {\n  if (displayName === undefined && photoUrl === undefined) {\n    return;\n  }\n\n  const userInternal = getModularInstance(user) as UserInternal;\n  const idToken = await userInternal.getIdToken();\n  const profileRequest = {\n    idToken,\n    displayName,\n    photoUrl,\n    returnSecureToken: true\n  };\n  const response = await _logoutIfInvalidated(\n    userInternal,\n    apiUpdateProfile(userInternal.auth, profileRequest)\n  );\n\n  userInternal.displayName = response.displayName || null;\n  userInternal.photoURL = response.photoUrl || null;\n\n  // Update the password provider as well\n  const passwordProvider = userInternal.providerData.find(\n    ({ providerId }) => providerId === ProviderId.PASSWORD\n  );\n  if (passwordProvider) {\n    passwordProvider.displayName = userInternal.displayName;\n    passwordProvider.photoURL = userInternal.photoURL;\n  }\n\n  await userInternal._updateTokensIfNecessary(response);\n}\n\n/**\n * Updates the user's email address.\n *\n * @remarks\n * An email will be sent to the original email address (if it was set) that allows to revoke the\n * email address change, in order to protect them from account hijacking.\n *\n * Important: this is a security sensitive operation that requires the user to have recently signed\n * in. If this requirement isn't met, ask the user to authenticate again and then call\n * {@link reauthenticateWithCredential}.\n *\n * @param user - The user.\n * @param newEmail - The new email address.\n *\n * @public\n */\nexport function updateEmail(user: User, newEmail: string): Promise<void> {\n  return updateEmailOrPassword(\n    getModularInstance(user) as UserInternal,\n    newEmail,\n    null\n  );\n}\n\n/**\n * Updates the user's password.\n *\n * @remarks\n * Important: this is a security sensitive operation that requires the user to have recently signed\n * in. If this requirement isn't met, ask the user to authenticate again and then call\n * {@link reauthenticateWithCredential}.\n *\n * @param user - The user.\n * @param newPassword - The new password.\n *\n * @public\n */\nexport function updatePassword(user: User, newPassword: string): Promise<void> {\n  return updateEmailOrPassword(\n    getModularInstance(user) as UserInternal,\n    null,\n    newPassword\n  );\n}\n\nasync function updateEmailOrPassword(\n  user: UserInternal,\n  email: string | null,\n  password: string | null\n): Promise<void> {\n  const { auth } = user;\n  const idToken = await user.getIdToken();\n  const request: UpdateEmailPasswordRequest = {\n    idToken,\n    returnSecureToken: true\n  };\n\n  if (email) {\n    request.email = email;\n  }\n\n  if (password) {\n    request.password = password;\n  }\n\n  const response = await _logoutIfInvalidated(\n    user,\n    apiUpdateEmailPassword(auth, request)\n  );\n  await user._updateTokensIfNecessary(response, /* reload */ true);\n}\n","/**\n * @license\n * Copyright 2019 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { AdditionalUserInfo, UserCredential } from '../../model/public_types';\nimport { IdTokenResponse, IdTokenResponseKind } from '../../model/id_token';\nimport { _parseToken } from './id_token_result';\nimport { UserCredentialInternal } from '../../model/user';\nimport { ProviderId } from '../../model/enums';\n\n/**\n * Parse the `AdditionalUserInfo` from the ID token response.\n *\n */\nexport function _fromIdTokenResponse(\n  idTokenResponse?: IdTokenResponse\n): AdditionalUserInfo | null {\n  if (!idTokenResponse) {\n    return null;\n  }\n  const { providerId } = idTokenResponse;\n  const profile = idTokenResponse.rawUserInfo\n    ? JSON.parse(idTokenResponse.rawUserInfo)\n    : {};\n  const isNewUser =\n    idTokenResponse.isNewUser ||\n    idTokenResponse.kind === IdTokenResponseKind.SignupNewUser;\n  if (!providerId && idTokenResponse?.idToken) {\n    const signInProvider = _parseToken(idTokenResponse.idToken)?.firebase?.[\n      'sign_in_provider'\n    ];\n    if (signInProvider) {\n      const filteredProviderId =\n        signInProvider !== ProviderId.ANONYMOUS &&\n        signInProvider !== ProviderId.CUSTOM\n          ? (signInProvider as ProviderId)\n          : null;\n      // Uses generic class in accordance with the legacy SDK.\n      return new GenericAdditionalUserInfo(isNewUser, filteredProviderId);\n    }\n  }\n  if (!providerId) {\n    return null;\n  }\n  switch (providerId) {\n    case ProviderId.FACEBOOK:\n      return new FacebookAdditionalUserInfo(isNewUser, profile);\n    case ProviderId.GITHUB:\n      return new GithubAdditionalUserInfo(isNewUser, profile);\n    case ProviderId.GOOGLE:\n      return new GoogleAdditionalUserInfo(isNewUser, profile);\n    case ProviderId.TWITTER:\n      return new TwitterAdditionalUserInfo(\n        isNewUser,\n        profile,\n        idTokenResponse.screenName || null\n      );\n    case ProviderId.CUSTOM:\n    case ProviderId.ANONYMOUS:\n      return new GenericAdditionalUserInfo(isNewUser, null);\n    default:\n      return new GenericAdditionalUserInfo(isNewUser, providerId, profile);\n  }\n}\n\nclass GenericAdditionalUserInfo implements AdditionalUserInfo {\n  constructor(\n    readonly isNewUser: boolean,\n    readonly providerId: ProviderId | string | null,\n    readonly profile: Record<string, unknown> = {}\n  ) {}\n}\n\nclass FederatedAdditionalUserInfoWithUsername extends GenericAdditionalUserInfo {\n  constructor(\n    isNewUser: boolean,\n    providerId: ProviderId,\n    profile: Record<string, unknown>,\n    readonly username: string | null\n  ) {\n    super(isNewUser, providerId, profile);\n  }\n}\n\nclass FacebookAdditionalUserInfo extends GenericAdditionalUserInfo {\n  constructor(isNewUser: boolean, profile: Record<string, unknown>) {\n    super(isNewUser, ProviderId.FACEBOOK, profile);\n  }\n}\n\nclass GithubAdditionalUserInfo extends FederatedAdditionalUserInfoWithUsername {\n  constructor(isNewUser: boolean, profile: Record<string, unknown>) {\n    super(\n      isNewUser,\n      ProviderId.GITHUB,\n      profile,\n      typeof profile?.login === 'string' ? profile?.login : null\n    );\n  }\n}\n\nclass GoogleAdditionalUserInfo extends GenericAdditionalUserInfo {\n  constructor(isNewUser: boolean, profile: Record<string, unknown>) {\n    super(isNewUser, ProviderId.GOOGLE, profile);\n  }\n}\n\nclass TwitterAdditionalUserInfo extends FederatedAdditionalUserInfoWithUsername {\n  constructor(\n    isNewUser: boolean,\n    profile: Record<string, unknown>,\n    screenName: string | null\n  ) {\n    super(isNewUser, ProviderId.TWITTER, profile, screenName);\n  }\n}\n\n/**\n * Extracts provider specific {@link AdditionalUserInfo} for the given credential.\n *\n * @param userCredential - The user credential.\n *\n * @public\n */\nexport function getAdditionalUserInfo(\n  userCredential: UserCredential\n): AdditionalUserInfo | null {\n  const { user, _tokenResponse } = userCredential as UserCredentialInternal;\n  if (user.isAnonymous && !_tokenResponse) {\n    // Handle the special case where signInAnonymously() gets called twice.\n    // No network call is made so there's nothing to actually fill this in\n    return {\n      providerId: null,\n      isNewUser: false,\n      profile: null\n    };\n  }\n\n  return _fromIdTokenResponse(_tokenResponse);\n}\n","/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { getModularInstance } from '@firebase/util';\nimport {\n  Auth,\n  NextOrObserver,\n  Persistence,\n  User,\n  CompleteFn,\n  ErrorFn,\n  Unsubscribe\n} from '../model/public_types';\n\nexport {\n  debugErrorMap,\n  prodErrorMap,\n  AUTH_ERROR_CODES_MAP_DO_NOT_USE_INTERNALLY as AuthErrorCodes\n} from './errors';\n\n// Non-optional auth methods.\n/**\n * Changes the type of persistence on the {@link Auth} instance for the currently saved\n * `Auth` session and applies this type of persistence for future sign-in requests, including\n * sign-in with redirect requests.\n *\n * @remarks\n * This makes it easy for a user signing in to specify whether their session should be\n * remembered or not. It also makes it easier to never persist the `Auth` state for applications\n * that are shared by other users or have sensitive data.\n *\n * @example\n * ```javascript\n * setPersistence(auth, browserSessionPersistence);\n * ```\n *\n * @param auth - The {@link Auth} instance.\n * @param persistence - The {@link Persistence} to use.\n * @returns A `Promise` that resolves once the persistence change has completed\n *\n * @public\n */\nexport function setPersistence(\n  auth: Auth,\n  persistence: Persistence\n): Promise<void> {\n  return getModularInstance(auth).setPersistence(persistence);\n}\n/**\n * Adds an observer for changes to the signed-in user's ID token.\n *\n * @remarks\n * This includes sign-in, sign-out, and token refresh events.\n *\n * @param auth - The {@link Auth} instance.\n * @param nextOrObserver - callback triggered on change.\n * @param error - Deprecated. This callback is never triggered. Errors\n * on signing in/out can be caught in promises returned from\n * sign-in/sign-out functions.\n * @param completed - Deprecated. This callback is never triggered.\n *\n * @public\n */\nexport function onIdTokenChanged(\n  auth: Auth,\n  nextOrObserver: NextOrObserver<User>,\n  error?: ErrorFn,\n  completed?: CompleteFn\n): Unsubscribe {\n  return getModularInstance(auth).onIdTokenChanged(\n    nextOrObserver,\n    error,\n    completed\n  );\n}\n/**\n * Adds a blocking callback that runs before an auth state change\n * sets a new user.\n *\n * @param auth - The {@link Auth} instance.\n * @param callback - callback triggered before new user value is set.\n *   If this throws, it blocks the user from being set.\n * @param onAbort - callback triggered if a later `beforeAuthStateChanged()`\n *   callback throws, allowing you to undo any side effects.\n */\n export function beforeAuthStateChanged(\n  auth: Auth,\n  callback: (user: User|null) => void | Promise<void>,\n  onAbort?: () => void,\n): Unsubscribe {\n  return getModularInstance(auth).beforeAuthStateChanged(\n    callback,\n    onAbort\n  );\n}\n/**\n * Adds an observer for changes to the user's sign-in state.\n *\n * @remarks\n * To keep the old behavior, see {@link onIdTokenChanged}.\n *\n * @param auth - The {@link Auth} instance.\n * @param nextOrObserver - callback triggered on change.\n * @param error - Deprecated. This callback is never triggered. Errors\n * on signing in/out can be caught in promises returned from\n * sign-in/sign-out functions.\n * @param completed - Deprecated. This callback is never triggered.\n *\n * @public\n */\nexport function onAuthStateChanged(\n  auth: Auth,\n  nextOrObserver: NextOrObserver<User>,\n  error?: ErrorFn,\n  completed?: CompleteFn\n): Unsubscribe {\n  return getModularInstance(auth).onAuthStateChanged(\n    nextOrObserver,\n    error,\n    completed\n  );\n}\n/**\n * Sets the current language to the default device/browser preference.\n *\n * @param auth - The {@link Auth} instance.\n *\n * @public\n */\nexport function useDeviceLanguage(auth: Auth): void {\n  getModularInstance(auth).useDeviceLanguage();\n}\n/**\n * Asynchronously sets the provided user as {@link Auth.currentUser} on the\n * {@link Auth} instance.\n *\n * @remarks\n * A new instance copy of the user provided will be made and set as currentUser.\n *\n * This will trigger {@link onAuthStateChanged} and {@link onIdTokenChanged} listeners\n * like other sign in methods.\n *\n * The operation fails with an error if the user to be updated belongs to a different Firebase\n * project.\n *\n * @param auth - The {@link Auth} instance.\n * @param user - The new {@link User}.\n *\n * @public\n */\nexport function updateCurrentUser(\n  auth: Auth,\n  user: User | null\n): Promise<void> {\n  return getModularInstance(auth).updateCurrentUser(user);\n}\n/**\n * Signs out the current user.\n *\n * @param auth - The {@link Auth} instance.\n *\n * @public\n */\nexport function signOut(auth: Auth): Promise<void> {\n  return getModularInstance(auth).signOut();\n}\n\nexport { initializeAuth } from './auth/initialize';\nexport { connectAuthEmulator } from './auth/emulator';\n\n// credentials\nexport { AuthCredential } from './credentials';\nexport { EmailAuthCredential } from './credentials/email';\nexport { OAuthCredential } from './credentials/oauth';\nexport { PhoneAuthCredential } from './credentials/phone';\n\n// persistence\nexport { inMemoryPersistence } from './persistence/in_memory';\n\n// providers\nexport { EmailAuthProvider } from './providers/email';\nexport { FacebookAuthProvider } from './providers/facebook';\nexport { CustomParameters } from './providers/federated';\nexport { GoogleAuthProvider } from './providers/google';\nexport { GithubAuthProvider } from './providers/github';\nexport { OAuthProvider, OAuthCredentialOptions } from './providers/oauth';\nexport { SAMLAuthProvider } from './providers/saml';\nexport { TwitterAuthProvider } from './providers/twitter';\n\n// strategies\nexport { signInAnonymously } from './strategies/anonymous';\nexport {\n  signInWithCredential,\n  linkWithCredential,\n  reauthenticateWithCredential\n} from './strategies/credential';\nexport { signInWithCustomToken } from './strategies/custom_token';\nexport {\n  sendPasswordResetEmail,\n  confirmPasswordReset,\n  applyActionCode,\n  checkActionCode,\n  verifyPasswordResetCode,\n  createUserWithEmailAndPassword,\n  signInWithEmailAndPassword\n} from './strategies/email_and_password';\nexport {\n  sendSignInLinkToEmail,\n  isSignInWithEmailLink,\n  signInWithEmailLink\n} from './strategies/email_link';\nexport {\n  fetchSignInMethodsForEmail,\n  sendEmailVerification,\n  verifyBeforeUpdateEmail\n} from './strategies/email';\n\n// core\nexport { ActionCodeURL, parseActionCodeURL } from './action_code_url';\n\n// user\nexport {\n  updateProfile,\n  updateEmail,\n  updatePassword\n} from './user/account_info';\nexport { getIdToken, getIdTokenResult } from './user/id_token_result';\nexport { unlink } from './user/link_unlink';\nexport { getAdditionalUserInfo } from './user/additional_user_info';\n\n// Non-optional user methods.\nexport { reload } from './user/reload';\n/**\n * Deletes and signs out the user.\n *\n * @remarks\n * Important: this is a security-sensitive operation that requires the user to have recently\n * signed in. If this requirement isn't met, ask the user to authenticate again and then call\n * {@link reauthenticateWithCredential}.\n *\n * @param user - The user.\n *\n * @public\n */\nexport async function deleteUser(user: User): Promise<void> {\n  return getModularInstance(user).delete();\n}\n","/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nimport { MultiFactorSession } from '../model/public_types';\n\nexport const enum MultiFactorSessionType {\n  ENROLL = 'enroll',\n  SIGN_IN = 'signin'\n}\n\ninterface SerializedMultiFactorSession {\n  multiFactorSession: {\n    idToken?: string;\n    pendingCredential?: string;\n  };\n}\n\nexport class MultiFactorSessionImpl implements MultiFactorSession {\n  private constructor(\n    readonly type: MultiFactorSessionType,\n    readonly credential: string\n  ) {}\n\n  static _fromIdtoken(idToken: string): MultiFactorSessionImpl {\n    return new MultiFactorSessionImpl(MultiFactorSessionType.ENROLL, idToken);\n  }\n\n  static _fromMfaPendingCredential(\n    mfaPendingCredential: string\n  ): MultiFactorSessionImpl {\n    return new MultiFactorSessionImpl(\n      MultiFactorSessionType.SIGN_IN,\n      mfaPendingCredential\n    );\n  }\n\n  toJSON(): SerializedMultiFactorSession {\n    const key =\n      this.type === MultiFactorSessionType.ENROLL\n        ? 'idToken'\n        : 'pendingCredential';\n    return {\n      multiFactorSession: {\n        [key]: this.credential\n      }\n    };\n  }\n\n  static fromJSON(\n    obj: Partial<SerializedMultiFactorSession>\n  ): MultiFactorSessionImpl | null {\n    if (obj?.multiFactorSession) {\n      if (obj.multiFactorSession?.pendingCredential) {\n        return MultiFactorSessionImpl._fromMfaPendingCredential(\n          obj.multiFactorSession.pendingCredential\n        );\n      } else if (obj.multiFactorSession?.idToken) {\n        return MultiFactorSessionImpl._fromIdtoken(\n          obj.multiFactorSession.idToken\n        );\n      }\n    }\n    return null;\n  }\n}\n","/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport {\n  Auth,\n  MultiFactorResolver,\n  UserCredential,\n  MultiFactorError\n} from '../model/public_types';\n\nimport { _castAuth } from '../core/auth/auth_impl';\nimport { AuthErrorCode } from '../core/errors';\nimport { UserCredentialImpl } from '../core/user/user_credential_impl';\nimport { _assert, _fail } from '../core/util/assert';\nimport { UserCredentialInternal } from '../model/user';\nimport { MultiFactorAssertionImpl } from './mfa_assertion';\nimport { MultiFactorError as MultiFactorErrorInternal } from './mfa_error';\nimport { MultiFactorInfoImpl } from './mfa_info';\nimport { MultiFactorSessionImpl } from './mfa_session';\nimport { getModularInstance } from '@firebase/util';\nimport { OperationType } from '../model/enums';\n\nexport class MultiFactorResolverImpl implements MultiFactorResolver {\n  private constructor(\n    readonly session: MultiFactorSessionImpl,\n    readonly hints: MultiFactorInfoImpl[],\n    private readonly signInResolver: (\n      assertion: MultiFactorAssertionImpl\n    ) => Promise<UserCredentialInternal>\n  ) {}\n\n  /** @internal */\n  static _fromError(\n    authExtern: Auth,\n    error: MultiFactorErrorInternal\n  ): MultiFactorResolverImpl {\n    const auth = _castAuth(authExtern);\n    const serverResponse = error.customData._serverResponse;\n    const hints = (serverResponse.mfaInfo || []).map(enrollment =>\n      MultiFactorInfoImpl._fromServerResponse(auth, enrollment)\n    );\n\n    _assert(\n      serverResponse.mfaPendingCredential,\n      auth,\n      AuthErrorCode.INTERNAL_ERROR\n    );\n    const session = MultiFactorSessionImpl._fromMfaPendingCredential(\n      serverResponse.mfaPendingCredential\n    );\n\n    return new MultiFactorResolverImpl(\n      session,\n      hints,\n      async (\n        assertion: MultiFactorAssertionImpl\n      ): Promise<UserCredentialInternal> => {\n        const mfaResponse = await assertion._process(auth, session);\n        // Clear out the unneeded fields from the old login response\n        delete serverResponse.mfaInfo;\n        delete serverResponse.mfaPendingCredential;\n\n        // Use in the new token & refresh token in the old response\n        const idTokenResponse = {\n          ...serverResponse,\n          idToken: mfaResponse.idToken,\n          refreshToken: mfaResponse.refreshToken\n        };\n\n        // TODO: we should collapse this switch statement into UserCredentialImpl._forOperation and have it support the SIGN_IN case\n        switch (error.operationType) {\n          case OperationType.SIGN_IN:\n            const userCredential =\n              await UserCredentialImpl._fromIdTokenResponse(\n                auth,\n                error.operationType,\n                idTokenResponse\n              );\n            await auth._updateCurrentUser(userCredential.user);\n            return userCredential;\n          case OperationType.REAUTHENTICATE:\n            _assert(error.user, auth, AuthErrorCode.INTERNAL_ERROR);\n            return UserCredentialImpl._forOperation(\n              error.user,\n              error.operationType,\n              idTokenResponse\n            );\n          default:\n            _fail(auth, AuthErrorCode.INTERNAL_ERROR);\n        }\n      }\n    );\n  }\n\n  async resolveSignIn(\n    assertionExtern: MultiFactorAssertionImpl\n  ): Promise<UserCredential> {\n    const assertion = assertionExtern as MultiFactorAssertionImpl;\n    return this.signInResolver(assertion);\n  }\n}\n\n/**\n * Provides a {@link MultiFactorResolver} suitable for completion of a\n * multi-factor flow.\n *\n * @param auth - The {@link Auth} instance.\n * @param error - The {@link MultiFactorError} raised during a sign-in, or\n * reauthentication operation.\n *\n * @public\n */\nexport function getMultiFactorResolver(\n  auth: Auth,\n  error: MultiFactorError\n): MultiFactorResolver {\n  const authModular = getModularInstance(auth);\n  const errorInternal = error as MultiFactorErrorInternal;\n  _assert(error.customData.operationType, authModular, AuthErrorCode.ARGUMENT_ERROR);\n  _assert(\n    errorInternal.customData._serverResponse?.mfaPendingCredential,\n    authModular,\n    AuthErrorCode.ARGUMENT_ERROR\n  );\n\n  return MultiFactorResolverImpl._fromError(authModular, errorInternal);\n}\n","/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { Endpoint, HttpMethod, _addTidIfNecessary, _performApiRequest } from '../index';\nimport { SignInWithPhoneNumberRequest } from '../authentication/sms';\nimport { FinalizeMfaResponse } from '../authentication/mfa';\nimport { AuthInternal } from '../../model/auth';\n\n/**\n * MFA Info as returned by the API\n */\ninterface BaseMfaEnrollment {\n  mfaEnrollmentId: string;\n  enrolledAt: number;\n  displayName?: string;\n}\n\n/**\n * An MFA provided by SMS verification\n */\nexport interface PhoneMfaEnrollment extends BaseMfaEnrollment {\n  phoneInfo: string;\n}\n\n/**\n * MfaEnrollment can be any subtype of BaseMfaEnrollment, currently only PhoneMfaEnrollment is supported\n */\nexport type MfaEnrollment = PhoneMfaEnrollment;\n\nexport interface StartPhoneMfaEnrollmentRequest {\n  idToken: string;\n  phoneEnrollmentInfo: {\n    phoneNumber: string;\n    recaptchaToken: string;\n  };\n  tenantId?: string;\n}\n\nexport interface StartPhoneMfaEnrollmentResponse {\n  phoneSessionInfo: {\n    sessionInfo: string;\n  };\n}\n\nexport function startEnrollPhoneMfa(\n  auth: AuthInternal,\n  request: StartPhoneMfaEnrollmentRequest\n): Promise<StartPhoneMfaEnrollmentResponse> {\n  return _performApiRequest<\n    StartPhoneMfaEnrollmentRequest,\n    StartPhoneMfaEnrollmentResponse\n  >(auth, HttpMethod.POST, Endpoint.START_PHONE_MFA_ENROLLMENT, _addTidIfNecessary(auth, request));\n}\n\nexport interface FinalizePhoneMfaEnrollmentRequest {\n  idToken: string;\n  phoneVerificationInfo: SignInWithPhoneNumberRequest;\n  displayName?: string | null;\n  tenantId?: string;\n}\n\nexport interface FinalizePhoneMfaEnrollmentResponse\n  extends FinalizeMfaResponse {}\n\nexport function finalizeEnrollPhoneMfa(\n  auth: AuthInternal,\n  request: FinalizePhoneMfaEnrollmentRequest\n): Promise<FinalizePhoneMfaEnrollmentResponse> {\n  return _performApiRequest<\n    FinalizePhoneMfaEnrollmentRequest,\n    FinalizePhoneMfaEnrollmentResponse\n  >(auth, HttpMethod.POST, Endpoint.FINALIZE_PHONE_MFA_ENROLLMENT, _addTidIfNecessary(auth, request));\n}\n\nexport interface WithdrawMfaRequest {\n  idToken: string;\n  mfaEnrollmentId: string;\n  tenantId?: string;\n}\n\nexport interface WithdrawMfaResponse extends FinalizeMfaResponse {}\n\nexport function withdrawMfa(\n  auth: AuthInternal,\n  request: WithdrawMfaRequest\n): Promise<WithdrawMfaResponse> {\n  return _performApiRequest<WithdrawMfaRequest, WithdrawMfaResponse>(\n    auth,\n    HttpMethod.POST,\n    Endpoint.WITHDRAW_MFA,\n    _addTidIfNecessary(auth, request)\n  );\n}\n","/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nimport {\n  MultiFactorAssertion,\n  MultiFactorInfo,\n  MultiFactorSession,\n  MultiFactorUser,\n  User\n} from '../model/public_types';\n\nimport { withdrawMfa } from '../api/account_management/mfa';\nimport { AuthErrorCode } from '../core/errors';\nimport { _logoutIfInvalidated } from '../core/user/invalidation';\nimport { UserInternal } from '../model/user';\nimport { MultiFactorAssertionImpl } from './mfa_assertion';\nimport { MultiFactorInfoImpl } from './mfa_info';\nimport { MultiFactorSessionImpl } from './mfa_session';\nimport { getModularInstance } from '@firebase/util';\n\nexport class MultiFactorUserImpl implements MultiFactorUser {\n  enrolledFactors: MultiFactorInfo[] = [];\n\n  private constructor(readonly user: UserInternal) {\n    user._onReload(userInfo => {\n      if (userInfo.mfaInfo) {\n        this.enrolledFactors = userInfo.mfaInfo.map(enrollment =>\n          MultiFactorInfoImpl._fromServerResponse(user.auth, enrollment)\n        );\n      }\n    });\n  }\n\n  static _fromUser(user: UserInternal): MultiFactorUserImpl {\n    return new MultiFactorUserImpl(user);\n  }\n\n  async getSession(): Promise<MultiFactorSession> {\n    return MultiFactorSessionImpl._fromIdtoken(await this.user.getIdToken());\n  }\n\n  async enroll(\n    assertionExtern: MultiFactorAssertion,\n    displayName?: string | null\n  ): Promise<void> {\n    const assertion = assertionExtern as MultiFactorAssertionImpl;\n    const session = (await this.getSession()) as MultiFactorSessionImpl;\n    const finalizeMfaResponse = await _logoutIfInvalidated(\n      this.user,\n      assertion._process(this.user.auth, session, displayName)\n    );\n    // New tokens will be issued after enrollment of the new second factors.\n    // They need to be updated on the user.\n    await this.user._updateTokensIfNecessary(finalizeMfaResponse);\n    // The user needs to be reloaded to get the new multi-factor information\n    // from server. USER_RELOADED event will be triggered and `enrolledFactors`\n    // will be updated.\n    return this.user.reload();\n  }\n\n  async unenroll(infoOrUid: MultiFactorInfo | string): Promise<void> {\n    const mfaEnrollmentId =\n      typeof infoOrUid === 'string' ? infoOrUid : infoOrUid.uid;\n    const idToken = await this.user.getIdToken();\n    const idTokenResponse = await _logoutIfInvalidated(\n      this.user,\n      withdrawMfa(this.user.auth, {\n        idToken,\n        mfaEnrollmentId\n      })\n    );\n    // Remove the second factor from the user's list.\n    this.enrolledFactors = this.enrolledFactors.filter(\n      ({ uid }) => uid !== mfaEnrollmentId\n    );\n    // Depending on whether the backend decided to revoke the user's session,\n    // the tokenResponse may be empty. If the tokens were not updated (and they\n    // are now invalid), reloading the user will discover this and invalidate\n    // the user's state accordingly.\n    await this.user._updateTokensIfNecessary(idTokenResponse);\n    try {\n      await this.user.reload();\n    } catch (e) {\n      if (e.code !== `auth/${AuthErrorCode.TOKEN_EXPIRED}`) {\n        throw e;\n      }\n    }\n  }\n}\n\nconst multiFactorUserCache = new WeakMap<User, MultiFactorUser>();\n\n/**\n * The {@link MultiFactorUser} corresponding to the user.\n *\n * @remarks\n * This is used to access all multi-factor properties and operations related to the user.\n *\n * @param user - The user.\n *\n * @public\n */\nexport function multiFactor(user: User): MultiFactorUser {\n  const userModular = getModularInstance(user);\n  if (!multiFactorUserCache.has(userModular)) {\n    multiFactorUserCache.set(\n      userModular,\n      MultiFactorUserImpl._fromUser(userModular as UserInternal)\n    );\n  }\n  return multiFactorUserCache.get(userModular)!;\n}\n","/**\n * @license\n * Copyright 2019 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nimport { Persistence } from '../../model/public_types';\n\nexport const enum PersistenceType {\n  SESSION = 'SESSION',\n  LOCAL = 'LOCAL',\n  NONE = 'NONE'\n}\n\nexport type PersistedBlob = Record<string, unknown>;\n\nexport interface Instantiator<T> {\n  (blob: PersistedBlob): T;\n}\n\nexport type PersistenceValue = PersistedBlob | string;\n\nexport const STORAGE_AVAILABLE_KEY = '__sak';\n\nexport interface StorageEventListener {\n  (value: PersistenceValue | null): void;\n}\n\nexport interface PersistenceInternal extends Persistence {\n  type: PersistenceType;\n  _isAvailable(): Promise<boolean>;\n  _set(key: string, value: PersistenceValue): Promise<void>;\n  _get<T extends PersistenceValue>(key: string): Promise<T | null>;\n  _remove(key: string): Promise<void>;\n  _addListener(key: string, listener: StorageEventListener): void;\n  _removeListener(key: string, listener: StorageEventListener): void;\n  // Should this persistence allow migration up the chosen hierarchy?\n  _shouldAllowMigration?: boolean;\n}\n","/**\n * @license\n * Copyright 2019 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport {\n  PersistenceValue,\n  STORAGE_AVAILABLE_KEY,\n  PersistenceType\n} from '../../core/persistence';\n\n// There are two different browser persistence types: local and session.\n// Both have the same implementation but use a different underlying storage\n// object.\n\nexport abstract class BrowserPersistenceClass {\n  protected constructor(\n    protected readonly storageRetriever: () => Storage,\n    readonly type: PersistenceType\n  ) {}\n\n  _isAvailable(): Promise<boolean> {\n    try {\n      if (!this.storage) {\n        return Promise.resolve(false);\n      }\n      this.storage.setItem(STORAGE_AVAILABLE_KEY, '1');\n      this.storage.removeItem(STORAGE_AVAILABLE_KEY);\n      return Promise.resolve(true);\n    } catch {\n      return Promise.resolve(false);\n    }\n  }\n\n  _set(key: string, value: PersistenceValue): Promise<void> {\n    this.storage.setItem(key, JSON.stringify(value));\n    return Promise.resolve();\n  }\n\n  _get<T extends PersistenceValue>(key: string): Promise<T | null> {\n    const json = this.storage.getItem(key);\n    return Promise.resolve(json ? JSON.parse(json) : null);\n  }\n\n  _remove(key: string): Promise<void> {\n    this.storage.removeItem(key);\n    return Promise.resolve();\n  }\n\n  protected get storage(): Storage {\n    return this.storageRetriever();\n  }\n}\n","/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { Persistence } from '../../model/public_types';\n\nimport { getUA } from '@firebase/util';\nimport {\n  _isSafari,\n  _isIOS,\n  _isIframe,\n  _isMobileBrowser,\n  _isIE10\n} from '../../core/util/browser';\nimport {\n  PersistenceInternal as InternalPersistence,\n  PersistenceType,\n  PersistenceValue,\n  StorageEventListener\n} from '../../core/persistence';\nimport { BrowserPersistenceClass } from './browser';\n\nfunction _iframeCannotSyncWebStorage(): boolean {\n  const ua = getUA();\n  return _isSafari(ua) || _isIOS(ua);\n}\n\n// The polling period in case events are not supported\nexport const _POLLING_INTERVAL_MS = 1000;\n\n// The IE 10 localStorage cross tab synchronization delay in milliseconds\nconst IE10_LOCAL_STORAGE_SYNC_DELAY = 10;\n\nclass BrowserLocalPersistence\n  extends BrowserPersistenceClass\n  implements InternalPersistence\n{\n  static type: 'LOCAL' = 'LOCAL';\n\n  constructor() {\n    super(() => window.localStorage, PersistenceType.LOCAL);\n  }\n\n  private readonly boundEventHandler = (event: StorageEvent, poll?: boolean): void => this.onStorageEvent(event, poll);\n  private readonly listeners: Record<string, Set<StorageEventListener>> = {};\n  private readonly localCache: Record<string, string | null> = {};\n  // setTimeout return value is platform specific\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  private pollTimer: any | null = null;\n\n  // Safari or iOS browser and embedded in an iframe.\n  private readonly safariLocalStorageNotSynced =\n    _iframeCannotSyncWebStorage() && _isIframe();\n  // Whether to use polling instead of depending on window events\n  private readonly fallbackToPolling = _isMobileBrowser();\n  readonly _shouldAllowMigration = true;\n\n  private forAllChangedKeys(\n    cb: (key: string, oldValue: string | null, newValue: string | null) => void\n  ): void {\n    // Check all keys with listeners on them.\n    for (const key of Object.keys(this.listeners)) {\n      // Get value from localStorage.\n      const newValue = this.storage.getItem(key);\n      const oldValue = this.localCache[key];\n      // If local map value does not match, trigger listener with storage event.\n      // Differentiate this simulated event from the real storage event.\n      if (newValue !== oldValue) {\n        cb(key, oldValue, newValue);\n      }\n    }\n  }\n\n  private onStorageEvent(event: StorageEvent, poll = false): void {\n    // Key would be null in some situations, like when localStorage is cleared\n    if (!event.key) {\n      this.forAllChangedKeys(\n        (key: string, _oldValue: string | null, newValue: string | null) => {\n          this.notifyListeners(key, newValue);\n        }\n      );\n      return;\n    }\n\n    const key = event.key;\n\n    // Check the mechanism how this event was detected.\n    // The first event will dictate the mechanism to be used.\n    if (poll) {\n      // Environment detects storage changes via polling.\n      // Remove storage event listener to prevent possible event duplication.\n      this.detachListener();\n    } else {\n      // Environment detects storage changes via storage event listener.\n      // Remove polling listener to prevent possible event duplication.\n      this.stopPolling();\n    }\n\n    // Safari embedded iframe. Storage event will trigger with the delta\n    // changes but no changes will be applied to the iframe localStorage.\n    if (this.safariLocalStorageNotSynced) {\n      // Get current iframe page value.\n      const storedValue = this.storage.getItem(key);\n      // Value not synchronized, synchronize manually.\n      if (event.newValue !== storedValue) {\n        if (event.newValue !== null) {\n          // Value changed from current value.\n          this.storage.setItem(key, event.newValue);\n        } else {\n          // Current value deleted.\n          this.storage.removeItem(key);\n        }\n      } else if (this.localCache[key] === event.newValue && !poll) {\n        // Already detected and processed, do not trigger listeners again.\n        return;\n      }\n    }\n\n    const triggerListeners = (): void => {\n      // Keep local map up to date in case storage event is triggered before\n      // poll.\n      const storedValue = this.storage.getItem(key);\n      if (!poll && this.localCache[key] === storedValue) {\n        // Real storage event which has already been detected, do nothing.\n        // This seems to trigger in some IE browsers for some reason.\n        return;\n      }\n      this.notifyListeners(key, storedValue);\n    };\n\n    const storedValue = this.storage.getItem(key);\n    if (\n      _isIE10() &&\n      storedValue !== event.newValue &&\n      event.newValue !== event.oldValue\n    ) {\n      // IE 10 has this weird bug where a storage event would trigger with the\n      // correct key, oldValue and newValue but localStorage.getItem(key) does\n      // not yield the updated value until a few milliseconds. This ensures\n      // this recovers from that situation.\n      setTimeout(triggerListeners, IE10_LOCAL_STORAGE_SYNC_DELAY);\n    } else {\n      triggerListeners();\n    }\n  }\n\n  private notifyListeners(key: string, value: string | null): void {\n    this.localCache[key] = value;\n    const listeners = this.listeners[key];\n    if (listeners) {\n      for (const listener of Array.from(listeners)) {\n        listener(value ? JSON.parse(value) : value);\n      }\n    }\n  }\n\n  private startPolling(): void {\n    this.stopPolling();\n\n    this.pollTimer = setInterval(() => {\n      this.forAllChangedKeys(\n        (key: string, oldValue: string | null, newValue: string | null) => {\n          this.onStorageEvent(\n            new StorageEvent('storage', {\n              key,\n              oldValue,\n              newValue\n            }),\n            /* poll */ true\n          );\n        }\n      );\n    }, _POLLING_INTERVAL_MS);\n  }\n\n  private stopPolling(): void {\n    if (this.pollTimer) {\n      clearInterval(this.pollTimer);\n      this.pollTimer = null;\n    }\n  }\n\n  private attachListener(): void {\n    window.addEventListener('storage', this.boundEventHandler);\n  }\n\n  private detachListener(): void {\n    window.removeEventListener('storage', this.boundEventHandler);\n  }\n\n  _addListener(key: string, listener: StorageEventListener): void {\n    if (Object.keys(this.listeners).length === 0) {\n      // Whether browser can detect storage event when it had already been pushed to the background.\n      // This may happen in some mobile browsers. A localStorage change in the foreground window\n      // will not be detected in the background window via the storage event.\n      // This was detected in iOS 7.x mobile browsers\n      if (this.fallbackToPolling) {\n        this.startPolling();\n      } else {\n        this.attachListener();\n      }\n    }\n    if (!this.listeners[key]) {\n      this.listeners[key] = new Set();\n      // Populate the cache to avoid spuriously triggering on first poll.\n      this.localCache[key] = this.storage.getItem(key);\n    }\n    this.listeners[key].add(listener);\n  }\n\n  _removeListener(key: string, listener: StorageEventListener): void {\n    if (this.listeners[key]) {\n      this.listeners[key].delete(listener);\n\n      if (this.listeners[key].size === 0) {\n        delete this.listeners[key];\n      }\n    }\n\n    if (Object.keys(this.listeners).length === 0) {\n      this.detachListener();\n      this.stopPolling();\n    }\n  }\n\n  // Update local cache on base operations:\n\n  async _set(key: string, value: PersistenceValue): Promise<void> {\n    await super._set(key, value);\n    this.localCache[key] = JSON.stringify(value);\n  }\n\n  async _get<T extends PersistenceValue>(key: string): Promise<T | null> {\n    const value = await super._get<T>(key);\n    this.localCache[key] = JSON.stringify(value);\n    return value;\n  }\n\n  async _remove(key: string): Promise<void> {\n    await super._remove(key);\n    delete this.localCache[key];\n  }\n}\n\n/**\n * An implementation of {@link Persistence} of type `LOCAL` using `localStorage`\n * for the underlying storage.\n *\n * @public\n */\nexport const browserLocalPersistence: Persistence = BrowserLocalPersistence;\n","/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { Persistence } from '../../model/public_types';\n\nimport {\n  PersistenceInternal as InternalPersistence,\n  PersistenceType,\n  StorageEventListener\n} from '../../core/persistence';\nimport { BrowserPersistenceClass } from './browser';\n\nclass BrowserSessionPersistence\n  extends BrowserPersistenceClass\n  implements InternalPersistence\n{\n  static type: 'SESSION' = 'SESSION';\n\n  constructor() {\n    super(() => window.sessionStorage, PersistenceType.SESSION);\n  }\n\n  _addListener(_key: string, _listener: StorageEventListener): void {\n    // Listeners are not supported for session storage since it cannot be shared across windows\n    return;\n  }\n\n  _removeListener(_key: string, _listener: StorageEventListener): void {\n    // Listeners are not supported for session storage since it cannot be shared across windows\n    return;\n  }\n}\n\n/**\n * An implementation of {@link Persistence} of `SESSION` using `sessionStorage`\n * for the underlying storage.\n *\n * @public\n */\nexport const browserSessionPersistence: Persistence = BrowserSessionPersistence;\n","/**\n * @license\n * Copyright 2019 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\n/** TODO: remove this once tslib has a polyfill for Promise.allSettled */\ninterface PromiseFulfilledResult<T> {\n  fulfilled: true;\n  value: T;\n}\n\ninterface PromiseRejectedResult {\n  fulfilled: false;\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  reason: any;\n}\n\nexport type PromiseSettledResult<T> =\n  | PromiseFulfilledResult<T>\n  | PromiseRejectedResult;\n\n/**\n * Shim for Promise.allSettled, note the slightly different format of `fulfilled` vs `status`.\n *\n * @param promises - Array of promises to wait on.\n */\nexport function _allSettled<T>(\n  promises: Array<Promise<T>>\n): Promise<Array<PromiseSettledResult<T>>> {\n  return Promise.all(\n    promises.map(async promise => {\n      try {\n        const value = await promise;\n        return {\n          fulfilled: true,\n          value\n        } as PromiseFulfilledResult<T>;\n      } catch (reason) {\n        return {\n          fulfilled: false,\n          reason\n        } as PromiseRejectedResult;\n      }\n    })\n  );\n}\n","/**\n * @license\n * Copyright 2019 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport {\n  ReceiverHandler,\n  _EventType,\n  _ReceiverResponse,\n  SenderMessageEvent,\n  _Status,\n  _SenderRequest\n} from './index';\nimport { _allSettled } from './promise';\n\n/**\n * Interface class for receiving messages.\n *\n */\nexport class Receiver {\n  private static readonly receivers: Receiver[] = [];\n  private readonly boundEventHandler: EventListener;\n\n  private readonly handlersMap: {\n    // Typescript doesn't have existential types :(\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    [eventType: string]: Set<ReceiverHandler<any, any>>;\n  } = {};\n\n  constructor(private readonly eventTarget: EventTarget) {\n    this.boundEventHandler = this.handleEvent.bind(this);\n  }\n\n  /**\n   * Obtain an instance of a Receiver for a given event target, if none exists it will be created.\n   *\n   * @param eventTarget - An event target (such as window or self) through which the underlying\n   * messages will be received.\n   */\n  static _getInstance(eventTarget: EventTarget): Receiver {\n    // The results are stored in an array since objects can't be keys for other\n    // objects. In addition, setting a unique property on an event target as a\n    // hash map key may not be allowed due to CORS restrictions.\n    const existingInstance = this.receivers.find(receiver =>\n      receiver.isListeningto(eventTarget)\n    );\n    if (existingInstance) {\n      return existingInstance;\n    }\n    const newInstance = new Receiver(eventTarget);\n    this.receivers.push(newInstance);\n    return newInstance;\n  }\n\n  private isListeningto(eventTarget: EventTarget): boolean {\n    return this.eventTarget === eventTarget;\n  }\n\n  /**\n   * Fans out a MessageEvent to the appropriate listeners.\n   *\n   * @remarks\n   * Sends an {@link Status.ACK} upon receipt and a {@link Status.DONE} once all handlers have\n   * finished processing.\n   *\n   * @param event - The MessageEvent.\n   *\n   */\n  private async handleEvent<\n    T extends _ReceiverResponse,\n    S extends _SenderRequest\n  >(event: Event): Promise<void> {\n    const messageEvent = event as MessageEvent<SenderMessageEvent<S>>;\n    const { eventId, eventType, data } = messageEvent.data;\n\n    const handlers: Set<ReceiverHandler<T, S>> | undefined = this.handlersMap[\n      eventType\n    ];\n    if (!handlers?.size) {\n      return;\n    }\n\n    messageEvent.ports[0].postMessage({\n      status: _Status.ACK,\n      eventId,\n      eventType\n    });\n\n    const promises = Array.from(handlers).map(async handler =>\n      handler(messageEvent.origin, data)\n    );\n    const response = await _allSettled(promises);\n    messageEvent.ports[0].postMessage({\n      status: _Status.DONE,\n      eventId,\n      eventType,\n      response\n    });\n  }\n\n  /**\n   * Subscribe an event handler for a particular event.\n   *\n   * @param eventType - Event name to subscribe to.\n   * @param eventHandler - The event handler which should receive the events.\n   *\n   */\n  _subscribe<T extends _ReceiverResponse, S extends _SenderRequest>(\n    eventType: _EventType,\n    eventHandler: ReceiverHandler<T, S>\n  ): void {\n    if (Object.keys(this.handlersMap).length === 0) {\n      this.eventTarget.addEventListener('message', this.boundEventHandler);\n    }\n\n    if (!this.handlersMap[eventType]) {\n      this.handlersMap[eventType] = new Set();\n    }\n\n    this.handlersMap[eventType].add(eventHandler);\n  }\n\n  /**\n   * Unsubscribe an event handler from a particular event.\n   *\n   * @param eventType - Event name to unsubscribe from.\n   * @param eventHandler - Optinoal event handler, if none provided, unsubscribe all handlers on this event.\n   *\n   */\n  _unsubscribe<T extends _ReceiverResponse, S extends _SenderRequest>(\n    eventType: _EventType,\n    eventHandler?: ReceiverHandler<T, S>\n  ): void {\n    if (this.handlersMap[eventType] && eventHandler) {\n      this.handlersMap[eventType].delete(eventHandler);\n    }\n    if (!eventHandler || this.handlersMap[eventType].size === 0) {\n      delete this.handlersMap[eventType];\n    }\n\n    if (Object.keys(this.handlersMap).length === 0) {\n      this.eventTarget.removeEventListener('message', this.boundEventHandler);\n    }\n  }\n}\n","/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nexport function _generateEventId(prefix = '', digits = 10): string {\n  let random = '';\n  for (let i = 0; i < digits; i++) {\n    random += Math.floor(Math.random() * 10);\n  }\n  return prefix + random;\n}\n","/**\n * @license\n * Copyright 2019 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { _generateEventId } from '../../core/util/event_id';\nimport {\n  _SenderRequest,\n  _EventType,\n  ReceiverMessageEvent,\n  _MessageError,\n  SenderMessageEvent,\n  _Status,\n  _ReceiverMessageResponse,\n  _ReceiverResponse,\n  _TimeoutDuration\n} from './index';\n\ninterface MessageHandler {\n  messageChannel: MessageChannel;\n  onMessage: EventListenerOrEventListenerObject;\n}\n\n/**\n * Interface for sending messages and waiting for a completion response.\n *\n */\nexport class Sender {\n  private readonly handlers = new Set<MessageHandler>();\n\n  constructor(private readonly target: ServiceWorker) {}\n\n  /**\n   * Unsubscribe the handler and remove it from our tracking Set.\n   *\n   * @param handler - The handler to unsubscribe.\n   */\n  private removeMessageHandler(handler: MessageHandler): void {\n    if (handler.messageChannel) {\n      handler.messageChannel.port1.removeEventListener(\n        'message',\n        handler.onMessage\n      );\n      handler.messageChannel.port1.close();\n    }\n    this.handlers.delete(handler);\n  }\n\n  /**\n   * Send a message to the Receiver located at {@link target}.\n   *\n   * @remarks\n   * We'll first wait a bit for an ACK , if we get one we will wait significantly longer until the\n   * receiver has had a chance to fully process the event.\n   *\n   * @param eventType - Type of event to send.\n   * @param data - The payload of the event.\n   * @param timeout - Timeout for waiting on an ACK from the receiver.\n   *\n   * @returns An array of settled promises from all the handlers that were listening on the receiver.\n   */\n  async _send<T extends _ReceiverResponse, S extends _SenderRequest>(\n    eventType: _EventType,\n    data: S,\n    timeout = _TimeoutDuration.ACK\n  ): Promise<_ReceiverMessageResponse<T>> {\n    const messageChannel =\n      typeof MessageChannel !== 'undefined' ? new MessageChannel() : null;\n    if (!messageChannel) {\n      throw new Error(_MessageError.CONNECTION_UNAVAILABLE);\n    }\n    // Node timers and browser timers return fundamentally different types.\n    // We don't actually care what the value is but TS won't accept unknown and\n    // we can't cast properly in both environments.\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    let completionTimer: any;\n    let handler: MessageHandler;\n    return new Promise<_ReceiverMessageResponse<T>>((resolve, reject) => {\n      const eventId = _generateEventId('', 20);\n      messageChannel.port1.start();\n      const ackTimer = setTimeout(() => {\n        reject(new Error(_MessageError.UNSUPPORTED_EVENT));\n      }, timeout);\n      handler = {\n        messageChannel,\n        onMessage(event: Event): void {\n          const messageEvent = event as MessageEvent<ReceiverMessageEvent<T>>;\n          if (messageEvent.data.eventId !== eventId) {\n            return;\n          }\n          switch (messageEvent.data.status) {\n            case _Status.ACK:\n              // The receiver should ACK first.\n              clearTimeout(ackTimer);\n              completionTimer = setTimeout(() => {\n                reject(new Error(_MessageError.TIMEOUT));\n              }, _TimeoutDuration.COMPLETION);\n              break;\n            case _Status.DONE:\n              // Once the receiver's handlers are finished we will get the results.\n              clearTimeout(completionTimer);\n              resolve(messageEvent.data.response);\n              break;\n            default:\n              clearTimeout(ackTimer);\n              clearTimeout(completionTimer);\n              reject(new Error(_MessageError.INVALID_RESPONSE));\n              break;\n          }\n        }\n      };\n      this.handlers.add(handler);\n      messageChannel.port1.addEventListener('message', handler.onMessage);\n      this.target.postMessage(\n        {\n          eventType,\n          eventId,\n          data\n        } as SenderMessageEvent<S>,\n        [messageChannel.port2]\n      );\n    }).finally(() => {\n      if (handler) {\n        this.removeMessageHandler(handler);\n      }\n    });\n  }\n}\n","/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { Recaptcha } from './recaptcha/recaptcha';\n\n/**\n * A specialized window type that melds the normal window type plus the\n * various bits we need. The three different blocks that are &'d together\n * cant be defined in the same block together.\n */\nexport type AuthWindow = {\n  // Standard window types\n  [T in keyof Window]: Window[T];\n} & {\n  // Any known / named properties we want to add\n  grecaptcha?: Recaptcha;\n  /* eslint-disable-next-line @typescript-eslint/no-explicit-any */\n  ___jsl?: Record<string, any>;\n  gapi?: typeof gapi;\n} & {\n  // A final catch-all for callbacks (which will have random names) that\n  // we will stick on the window.\n  [callback: string]: (...args: unknown[]) => void;\n};\n\n/**\n * Lazy accessor for window, since the compat layer won't tree shake this out,\n * we need to make sure not to mess with window unless we have to\n */\nexport function _window(): AuthWindow {\n  return (window as unknown) as AuthWindow;\n}\n\nexport function _setWindowLocation(url: string): void {\n  _window().location.href = url;\n}\n","/**\n * @license\n * Copyright 2020 Google LLC.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { _window } from '../auth_window';\n\nexport function _isWorker(): boolean {\n  return (\n    typeof _window()['WorkerGlobalScope'] !== 'undefined' &&\n    typeof _window()['importScripts'] === 'function'\n  );\n}\n\nexport async function _getActiveServiceWorker(): Promise<ServiceWorker | null> {\n  if (!navigator?.serviceWorker) {\n    return null;\n  }\n  try {\n    const registration = await navigator.serviceWorker.ready;\n    return registration.active;\n  } catch {\n    return null;\n  }\n}\n\nexport function _getServiceWorkerController(): ServiceWorker | null {\n  return navigator?.serviceWorker?.controller || null;\n}\n\nexport function _getWorkerGlobalScope(): ServiceWorker | null {\n  return _isWorker() ? ((self as unknown) as ServiceWorker) : null;\n}\n","/**\n * @license\n * Copyright 2019 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { Persistence } from '../../model/public_types';\nimport {\n  PersistedBlob,\n  PersistenceInternal as InternalPersistence,\n  PersistenceType,\n  PersistenceValue,\n  StorageEventListener,\n  STORAGE_AVAILABLE_KEY\n} from '../../core/persistence/';\nimport {\n  _EventType,\n  _PingResponse,\n  KeyChangedResponse,\n  KeyChangedRequest,\n  PingRequest,\n  _TimeoutDuration\n} from '../messagechannel/index';\nimport { Receiver } from '../messagechannel/receiver';\nimport { Sender } from '../messagechannel/sender';\nimport {\n  _isWorker,\n  _getActiveServiceWorker,\n  _getServiceWorkerController,\n  _getWorkerGlobalScope\n} from '../util/worker';\n\nexport const DB_NAME = 'firebaseLocalStorageDb';\nconst DB_VERSION = 1;\nconst DB_OBJECTSTORE_NAME = 'firebaseLocalStorage';\nconst DB_DATA_KEYPATH = 'fbase_key';\n\ninterface DBObject {\n  [DB_DATA_KEYPATH]: string;\n  value: PersistedBlob;\n}\n\n/**\n * Promise wrapper for IDBRequest\n *\n * Unfortunately we can't cleanly extend Promise<T> since promises are not callable in ES6\n *\n */\nclass DBPromise<T> {\n  constructor(private readonly request: IDBRequest) {}\n\n  toPromise(): Promise<T> {\n    return new Promise<T>((resolve, reject) => {\n      this.request.addEventListener('success', () => {\n        resolve(this.request.result);\n      });\n      this.request.addEventListener('error', () => {\n        reject(this.request.error);\n      });\n    });\n  }\n}\n\nfunction getObjectStore(db: IDBDatabase, isReadWrite: boolean): IDBObjectStore {\n  return db\n    .transaction([DB_OBJECTSTORE_NAME], isReadWrite ? 'readwrite' : 'readonly')\n    .objectStore(DB_OBJECTSTORE_NAME);\n}\n\nexport async function _clearDatabase(db: IDBDatabase): Promise<void> {\n  const objectStore = getObjectStore(db, true);\n  return new DBPromise<void>(objectStore.clear()).toPromise();\n}\n\nexport function _deleteDatabase(): Promise<void> {\n  const request = indexedDB.deleteDatabase(DB_NAME);\n  return new DBPromise<void>(request).toPromise();\n}\n\nexport function _openDatabase(): Promise<IDBDatabase> {\n  const request = indexedDB.open(DB_NAME, DB_VERSION);\n  return new Promise((resolve, reject) => {\n    request.addEventListener('error', () => {\n      reject(request.error);\n    });\n\n    request.addEventListener('upgradeneeded', () => {\n      const db = request.result;\n\n      try {\n        db.createObjectStore(DB_OBJECTSTORE_NAME, { keyPath: DB_DATA_KEYPATH });\n      } catch (e) {\n        reject(e);\n      }\n    });\n\n    request.addEventListener('success', async () => {\n      const db: IDBDatabase = request.result;\n      // Strange bug that occurs in Firefox when multiple tabs are opened at the\n      // same time. The only way to recover seems to be deleting the database\n      // and re-initializing it.\n      // https://github.com/firebase/firebase-js-sdk/issues/634\n\n      if (!db.objectStoreNames.contains(DB_OBJECTSTORE_NAME)) {\n        // Need to close the database or else you get a `blocked` event\n        db.close();\n        await _deleteDatabase();\n        resolve(await _openDatabase());\n      } else {\n        resolve(db);\n      }\n    });\n  });\n}\n\nexport async function _putObject(\n  db: IDBDatabase,\n  key: string,\n  value: PersistenceValue | string\n): Promise<void> {\n  const request = getObjectStore(db, true).put({\n    [DB_DATA_KEYPATH]: key,\n    value\n  });\n  return new DBPromise<void>(request).toPromise();\n}\n\nasync function getObject(\n  db: IDBDatabase,\n  key: string\n): Promise<PersistedBlob | null> {\n  const request = getObjectStore(db, false).get(key);\n  const data = await new DBPromise<DBObject | undefined>(request).toPromise();\n  return data === undefined ? null : data.value;\n}\n\nexport function _deleteObject(db: IDBDatabase, key: string): Promise<void> {\n  const request = getObjectStore(db, true).delete(key);\n  return new DBPromise<void>(request).toPromise();\n}\n\nexport const _POLLING_INTERVAL_MS = 800;\nexport const _TRANSACTION_RETRY_COUNT = 3;\n\nclass IndexedDBLocalPersistence implements InternalPersistence {\n  static type: 'LOCAL' = 'LOCAL';\n\n  type = PersistenceType.LOCAL;\n  db?: IDBDatabase;\n  readonly _shouldAllowMigration = true;\n\n  private readonly listeners: Record<string, Set<StorageEventListener>> = {};\n  private readonly localCache: Record<string, PersistenceValue | null> = {};\n  // setTimeout return value is platform specific\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  private pollTimer: any | null = null;\n  private pendingWrites = 0;\n\n  private receiver: Receiver | null = null;\n  private sender: Sender | null = null;\n  private serviceWorkerReceiverAvailable = false;\n  private activeServiceWorker: ServiceWorker | null = null;\n  // Visible for testing only\n  readonly _workerInitializationPromise: Promise<void>;\n\n  constructor() {\n    // Fire & forget the service worker registration as it may never resolve\n    this._workerInitializationPromise =\n      this.initializeServiceWorkerMessaging().then(\n        () => {},\n        () => {}\n      );\n  }\n\n  async _openDb(): Promise<IDBDatabase> {\n    if (this.db) {\n      return this.db;\n    }\n    this.db = await _openDatabase();\n    return this.db;\n  }\n\n  async _withRetries<T>(op: (db: IDBDatabase) => Promise<T>): Promise<T> {\n    let numAttempts = 0;\n\n    while (true) {\n      try {\n        const db = await this._openDb();\n        return await op(db);\n      } catch (e) {\n        if (numAttempts++ > _TRANSACTION_RETRY_COUNT) {\n          throw e;\n        }\n        if (this.db) {\n          this.db.close();\n          this.db = undefined;\n        }\n        // TODO: consider adding exponential backoff\n      }\n    }\n  }\n\n  /**\n   * IndexedDB events do not propagate from the main window to the worker context.  We rely on a\n   * postMessage interface to send these events to the worker ourselves.\n   */\n  private async initializeServiceWorkerMessaging(): Promise<void> {\n    return _isWorker() ? this.initializeReceiver() : this.initializeSender();\n  }\n\n  /**\n   * As the worker we should listen to events from the main window.\n   */\n  private async initializeReceiver(): Promise<void> {\n    this.receiver = Receiver._getInstance(_getWorkerGlobalScope()!);\n    // Refresh from persistence if we receive a KeyChanged message.\n    this.receiver._subscribe(\n      _EventType.KEY_CHANGED,\n      async (_origin: string, data: KeyChangedRequest) => {\n        const keys = await this._poll();\n        return {\n          keyProcessed: keys.includes(data.key)\n        };\n      }\n    );\n    // Let the sender know that we are listening so they give us more timeout.\n    this.receiver._subscribe(\n      _EventType.PING,\n      async (_origin: string, _data: PingRequest) => {\n        return [_EventType.KEY_CHANGED];\n      }\n    );\n  }\n\n  /**\n   * As the main window, we should let the worker know when keys change (set and remove).\n   *\n   * @remarks\n   * {@link https://developer.mozilla.org/en-US/docs/Web/API/ServiceWorkerContainer/ready | ServiceWorkerContainer.ready}\n   * may not resolve.\n   */\n  private async initializeSender(): Promise<void> {\n    // Check to see if there's an active service worker.\n    this.activeServiceWorker = await _getActiveServiceWorker();\n    if (!this.activeServiceWorker) {\n      return;\n    }\n    this.sender = new Sender(this.activeServiceWorker);\n    // Ping the service worker to check what events they can handle.\n    const results = await this.sender._send<_PingResponse, PingRequest>(\n      _EventType.PING,\n      {},\n      _TimeoutDuration.LONG_ACK\n    );\n    if (!results) {\n      return;\n    }\n    if (\n      results[0]?.fulfilled &&\n      results[0]?.value.includes(_EventType.KEY_CHANGED)\n    ) {\n      this.serviceWorkerReceiverAvailable = true;\n    }\n  }\n\n  /**\n   * Let the worker know about a changed key, the exact key doesn't technically matter since the\n   * worker will just trigger a full sync anyway.\n   *\n   * @remarks\n   * For now, we only support one service worker per page.\n   *\n   * @param key - Storage key which changed.\n   */\n  private async notifyServiceWorker(key: string): Promise<void> {\n    if (\n      !this.sender ||\n      !this.activeServiceWorker ||\n      _getServiceWorkerController() !== this.activeServiceWorker\n    ) {\n      return;\n    }\n    try {\n      await this.sender._send<KeyChangedResponse, KeyChangedRequest>(\n        _EventType.KEY_CHANGED,\n        { key },\n        // Use long timeout if receiver has previously responded to a ping from us.\n        this.serviceWorkerReceiverAvailable\n          ? _TimeoutDuration.LONG_ACK\n          : _TimeoutDuration.ACK\n      );\n    } catch {\n      // This is a best effort approach. Ignore errors.\n    }\n  }\n\n  async _isAvailable(): Promise<boolean> {\n    try {\n      if (!indexedDB) {\n        return false;\n      }\n      const db = await _openDatabase();\n      await _putObject(db, STORAGE_AVAILABLE_KEY, '1');\n      await _deleteObject(db, STORAGE_AVAILABLE_KEY);\n      return true;\n    } catch {}\n    return false;\n  }\n\n  private async _withPendingWrite(write: () => Promise<void>): Promise<void> {\n    this.pendingWrites++;\n    try {\n      await write();\n    } finally {\n      this.pendingWrites--;\n    }\n  }\n\n  async _set(key: string, value: PersistenceValue): Promise<void> {\n    return this._withPendingWrite(async () => {\n      await this._withRetries((db: IDBDatabase) => _putObject(db, key, value));\n      this.localCache[key] = value;\n      return this.notifyServiceWorker(key);\n    });\n  }\n\n  async _get<T extends PersistenceValue>(key: string): Promise<T | null> {\n    const obj = (await this._withRetries((db: IDBDatabase) =>\n      getObject(db, key)\n    )) as T;\n    this.localCache[key] = obj;\n    return obj;\n  }\n\n  async _remove(key: string): Promise<void> {\n    return this._withPendingWrite(async () => {\n      await this._withRetries((db: IDBDatabase) => _deleteObject(db, key));\n      delete this.localCache[key];\n      return this.notifyServiceWorker(key);\n    });\n  }\n\n  private async _poll(): Promise<string[]> {\n    // TODO: check if we need to fallback if getAll is not supported\n    const result = await this._withRetries((db: IDBDatabase) => {\n      const getAllRequest = getObjectStore(db, false).getAll();\n      return new DBPromise<DBObject[] | null>(getAllRequest).toPromise();\n    });\n\n    if (!result) {\n      return [];\n    }\n\n    // If we have pending writes in progress abort, we'll get picked up on the next poll\n    if (this.pendingWrites !== 0) {\n      return [];\n    }\n\n    const keys = [];\n    const keysInResult = new Set();\n    for (const { fbase_key: key, value } of result) {\n      keysInResult.add(key);\n      if (JSON.stringify(this.localCache[key]) !== JSON.stringify(value)) {\n        this.notifyListeners(key, value as PersistenceValue);\n        keys.push(key);\n      }\n    }\n    for (const localKey of Object.keys(this.localCache)) {\n      if (this.localCache[localKey] && !keysInResult.has(localKey)) {\n        // Deleted\n        this.notifyListeners(localKey, null);\n        keys.push(localKey);\n      }\n    }\n    return keys;\n  }\n\n  private notifyListeners(\n    key: string,\n    newValue: PersistenceValue | null\n  ): void {\n    this.localCache[key] = newValue;\n    const listeners = this.listeners[key];\n    if (listeners) {\n      for (const listener of Array.from(listeners)) {\n        listener(newValue);\n      }\n    }\n  }\n\n  private startPolling(): void {\n    this.stopPolling();\n\n    this.pollTimer = setInterval(\n      async () => this._poll(),\n      _POLLING_INTERVAL_MS\n    );\n  }\n\n  private stopPolling(): void {\n    if (this.pollTimer) {\n      clearInterval(this.pollTimer);\n      this.pollTimer = null;\n    }\n  }\n\n  _addListener(key: string, listener: StorageEventListener): void {\n    if (Object.keys(this.listeners).length === 0) {\n      this.startPolling();\n    }\n    if (!this.listeners[key]) {\n      this.listeners[key] = new Set();\n      // Populate the cache to avoid spuriously triggering on first poll.\n      void this._get(key); // This can happen in the background async and we can return immediately.\n    }\n    this.listeners[key].add(listener);\n  }\n\n  _removeListener(key: string, listener: StorageEventListener): void {\n    if (this.listeners[key]) {\n      this.listeners[key].delete(listener);\n\n      if (this.listeners[key].size === 0) {\n        delete this.listeners[key];\n      }\n    }\n\n    if (Object.keys(this.listeners).length === 0) {\n      this.stopPolling();\n    }\n  }\n}\n\n/**\n * An implementation of {@link Persistence} of type `LOCAL` using `indexedDB`\n * for the underlying storage.\n *\n * @public\n */\nexport const indexedDBLocalPersistence: Persistence = IndexedDBLocalPersistence;\n","/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { _performApiRequest, Endpoint, HttpMethod, _addTidIfNecessary } from '../index';\nimport { Auth } from '../../model/public_types';\nimport { IdTokenResponse } from '../../model/id_token';\nimport { MfaEnrollment } from '../account_management/mfa';\nimport { SignInWithIdpResponse } from './idp';\nimport {\n  SignInWithPhoneNumberRequest,\n  SignInWithPhoneNumberResponse\n} from './sms';\n\nexport interface FinalizeMfaResponse {\n  idToken: string;\n  refreshToken: string;\n}\n\n/**\n * @internal\n */\nexport interface IdTokenMfaResponse extends IdTokenResponse {\n  mfaPendingCredential?: string;\n  mfaInfo?: MfaEnrollment[];\n}\n\nexport interface StartPhoneMfaSignInRequest {\n  mfaPendingCredential: string;\n  mfaEnrollmentId: string;\n  phoneSignInInfo: {\n    recaptchaToken: string;\n  };\n  tenantId?: string;\n}\n\nexport interface StartPhoneMfaSignInResponse {\n  phoneResponseInfo: {\n    sessionInfo: string;\n  };\n}\n\nexport function startSignInPhoneMfa(\n  auth: Auth,\n  request: StartPhoneMfaSignInRequest\n): Promise<StartPhoneMfaSignInResponse> {\n  return _performApiRequest<\n    StartPhoneMfaSignInRequest,\n    StartPhoneMfaSignInResponse\n  >(auth, HttpMethod.POST, Endpoint.START_PHONE_MFA_SIGN_IN, _addTidIfNecessary(auth, request));\n}\n\nexport interface FinalizePhoneMfaSignInRequest {\n  mfaPendingCredential: string;\n  phoneVerificationInfo: SignInWithPhoneNumberRequest;\n  tenantId?: string;\n}\n\nexport interface FinalizePhoneMfaSignInResponse extends FinalizeMfaResponse {}\n\nexport function finalizeSignInPhoneMfa(\n  auth: Auth,\n  request: FinalizePhoneMfaSignInRequest,\n): Promise<FinalizePhoneMfaSignInResponse> {\n  return _performApiRequest<\n    FinalizePhoneMfaSignInRequest,\n    FinalizePhoneMfaSignInResponse\n  >(auth, HttpMethod.POST, Endpoint.FINALIZE_PHONE_MFA_SIGN_IN, _addTidIfNecessary(auth, request));\n}\n\n/**\n * @internal\n */\nexport type PhoneOrOauthTokenResponse =\n  | SignInWithPhoneNumberResponse\n  | SignInWithIdpResponse\n  | IdTokenResponse;\n","/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { Endpoint, HttpMethod, _performApiRequest } from '../index';\nimport { Auth } from '../../model/public_types';\n\ninterface GetRecaptchaParamResponse {\n  recaptchaSiteKey?: string;\n}\n\nexport async function getRecaptchaParams(auth: Auth): Promise<string> {\n  return (\n    (\n      await _performApiRequest<void, GetRecaptchaParamResponse>(\n        auth,\n        HttpMethod.GET,\n        Endpoint.GET_RECAPTCHA_PARAM\n      )\n    ).recaptchaSiteKey || ''\n  );\n}\n","/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { AuthErrorCode } from '../core/errors';\nimport { _createError } from '../core/util/assert';\n\nfunction getScriptParentElement(): HTMLDocument | HTMLHeadElement {\n  return document.getElementsByTagName('head')?.[0] ?? document;\n}\n\nexport function _loadJS(url: string): Promise<Event> {\n  // TODO: consider adding timeout support & cancellation\n  return new Promise((resolve, reject) => {\n    const el = document.createElement('script');\n    el.setAttribute('src', url);\n    el.onload = resolve;\n    el.onerror = e => {\n      const error = _createError(AuthErrorCode.INTERNAL_ERROR);\n      error.customData = e as unknown as Record<string, unknown>;\n      reject(error);\n    };\n    el.type = 'text/javascript';\n    el.charset = 'UTF-8';\n    getScriptParentElement().appendChild(el);\n  });\n}\n\nexport function _generateCallbackName(prefix: string): string {\n  return `__${prefix}${Math.floor(Math.random() * 1000000)}`;\n}\n","/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { AuthErrorCode } from '../../core/errors';\nimport { _assert } from '../../core/util/assert';\nimport { AuthInternal } from '../../model/auth';\nimport { RecaptchaParameters } from '../../model/public_types';\nimport { Recaptcha } from './recaptcha';\n\nexport const _SOLVE_TIME_MS = 500;\nexport const _EXPIRATION_TIME_MS = 60_000;\nexport const _WIDGET_ID_START = 1_000_000_000_000;\n\nexport interface Widget {\n  getResponse: () => string | null;\n  delete: () => void;\n  execute: () => void;\n}\n\nexport class MockReCaptcha implements Recaptcha {\n  private counter = _WIDGET_ID_START;\n  _widgets = new Map<number, Widget>();\n\n  constructor(private readonly auth: AuthInternal) {}\n\n  render(\n    container: string | HTMLElement,\n    parameters?: RecaptchaParameters\n  ): number {\n    const id = this.counter;\n    this._widgets.set(\n      id,\n      new MockWidget(container, this.auth.name, parameters || {})\n    );\n    this.counter++;\n    return id;\n  }\n\n  reset(optWidgetId?: number): void {\n    const id = optWidgetId || _WIDGET_ID_START;\n    void this._widgets.get(id)?.delete();\n    this._widgets.delete(id);\n  }\n\n  getResponse(optWidgetId?: number): string {\n    const id = optWidgetId || _WIDGET_ID_START;\n    return this._widgets.get(id)?.getResponse() || '';\n  }\n\n  async execute(optWidgetId?: number | string): Promise<string> {\n    const id: number = (optWidgetId as number) || _WIDGET_ID_START;\n    void this._widgets.get(id)?.execute();\n    return '';\n  }\n}\n\nexport class MockWidget {\n  private readonly container: HTMLElement;\n  private readonly isVisible: boolean;\n  private timerId: number | null = null;\n  private deleted = false;\n  private responseToken: string | null = null;\n  private readonly clickHandler = (): void => {\n    this.execute();\n  };\n\n  constructor(\n    containerOrId: string | HTMLElement,\n    appName: string,\n    private readonly params: RecaptchaParameters\n  ) {\n    const container =\n      typeof containerOrId === 'string'\n        ? document.getElementById(containerOrId)\n        : containerOrId;\n    _assert(container, AuthErrorCode.ARGUMENT_ERROR, { appName });\n\n    this.container = container;\n    this.isVisible = this.params.size !== 'invisible';\n    if (this.isVisible) {\n      this.execute();\n    } else {\n      this.container.addEventListener('click', this.clickHandler);\n    }\n  }\n\n  getResponse(): string | null {\n    this.checkIfDeleted();\n    return this.responseToken;\n  }\n\n  delete(): void {\n    this.checkIfDeleted();\n    this.deleted = true;\n    if (this.timerId) {\n      clearTimeout(this.timerId);\n      this.timerId = null;\n    }\n    this.container.removeEventListener('click', this.clickHandler);\n  }\n\n  execute(): void {\n    this.checkIfDeleted();\n    if (this.timerId) {\n      return;\n    }\n\n    this.timerId = window.setTimeout(() => {\n      this.responseToken = generateRandomAlphaNumericString(50);\n      const { callback, 'expired-callback': expiredCallback } = this.params;\n      if (callback) {\n        try {\n          callback(this.responseToken);\n        } catch (e) {}\n      }\n\n      this.timerId = window.setTimeout(() => {\n        this.timerId = null;\n        this.responseToken = null;\n        if (expiredCallback) {\n          try {\n            expiredCallback();\n          } catch (e) {}\n        }\n\n        if (this.isVisible) {\n          this.execute();\n        }\n      }, _EXPIRATION_TIME_MS);\n    }, _SOLVE_TIME_MS);\n  }\n\n  private checkIfDeleted(): void {\n    if (this.deleted) {\n      throw new Error('reCAPTCHA mock was already deleted!');\n    }\n  }\n}\n\nfunction generateRandomAlphaNumericString(len: number): string {\n  const chars = [];\n  const allowedChars =\n    '1234567890abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';\n  for (let i = 0; i < len; i++) {\n    chars.push(\n      allowedChars.charAt(Math.floor(Math.random() * allowedChars.length))\n    );\n  }\n  return chars.join('');\n}\n","/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { querystring } from '@firebase/util';\n\nimport { AuthErrorCode } from '../../core/errors';\nimport { _assert, _createError } from '../../core/util/assert';\nimport { Delay } from '../../core/util/delay';\nimport { AuthInternal } from '../../model/auth';\nimport { _window } from '../auth_window';\nimport * as jsHelpers from '../load_js';\nimport { Recaptcha } from './recaptcha';\nimport { MockReCaptcha } from './recaptcha_mock';\n\n// ReCaptcha will load using the same callback, so the callback function needs\n// to be kept around\nexport const _JSLOAD_CALLBACK = jsHelpers._generateCallbackName('rcb');\nconst NETWORK_TIMEOUT_DELAY = new Delay(30000, 60000);\nconst RECAPTCHA_BASE = 'https://www.google.com/recaptcha/api.js?';\n\n/**\n * We need to mark this interface as internal explicitly to exclude it in the public typings, because\n * it references AuthInternal which has a circular dependency with UserInternal.\n *\n * @internal\n */\nexport interface ReCaptchaLoader {\n  load(auth: AuthInternal, hl?: string): Promise<Recaptcha>;\n  clearedOneInstance(): void;\n}\n\n/**\n * Loader for the GReCaptcha library. There should only ever be one of this.\n */\nexport class ReCaptchaLoaderImpl implements ReCaptchaLoader {\n  private hostLanguage = '';\n  private counter = 0;\n  private readonly librarySeparatelyLoaded = !!_window().grecaptcha;\n\n  load(auth: AuthInternal, hl = ''): Promise<Recaptcha> {\n    _assert(isHostLanguageValid(hl), auth, AuthErrorCode.ARGUMENT_ERROR);\n\n    if (this.shouldResolveImmediately(hl)) {\n      return Promise.resolve(_window().grecaptcha!);\n    }\n    return new Promise<Recaptcha>((resolve, reject) => {\n      const networkTimeout = _window().setTimeout(() => {\n        reject(_createError(auth, AuthErrorCode.NETWORK_REQUEST_FAILED));\n      }, NETWORK_TIMEOUT_DELAY.get());\n\n      _window()[_JSLOAD_CALLBACK] = () => {\n        _window().clearTimeout(networkTimeout);\n        delete _window()[_JSLOAD_CALLBACK];\n\n        const recaptcha = _window().grecaptcha;\n\n        if (!recaptcha) {\n          reject(_createError(auth, AuthErrorCode.INTERNAL_ERROR));\n          return;\n        }\n\n        // Wrap the greptcha render function so that we know if the developer has\n        // called it separately\n        const render = recaptcha.render;\n        recaptcha.render = (container, params) => {\n          const widgetId = render(container, params);\n          this.counter++;\n          return widgetId;\n        };\n\n        this.hostLanguage = hl;\n        resolve(recaptcha);\n      };\n\n      const url = `${RECAPTCHA_BASE}?${querystring({\n        onload: _JSLOAD_CALLBACK,\n        render: 'explicit',\n        hl\n      })}`;\n\n      jsHelpers._loadJS(url).catch(() => {\n        clearTimeout(networkTimeout);\n        reject(_createError(auth, AuthErrorCode.INTERNAL_ERROR));\n      });\n    });\n  }\n\n  clearedOneInstance(): void {\n    this.counter--;\n  }\n\n  private shouldResolveImmediately(hl: string): boolean {\n    // We can resolve immediately if:\n    //   • grecaptcha is already defined AND (\n    //     1. the requested language codes are the same OR\n    //     2. there exists already a ReCaptcha on the page\n    //     3. the library was already loaded by the app\n    // In cases (2) and (3), we _can't_ reload as it would break the recaptchas\n    // that are already in the page\n    return (\n      !!_window().grecaptcha &&\n      (hl === this.hostLanguage ||\n        this.counter > 0 ||\n        this.librarySeparatelyLoaded)\n    );\n  }\n}\n\nfunction isHostLanguageValid(hl: string): boolean {\n  return hl.length <= 6 && /^\\s*[a-zA-Z0-9\\-]*\\s*$/.test(hl);\n}\n\nexport class MockReCaptchaLoaderImpl implements ReCaptchaLoader {\n  async load(auth: AuthInternal): Promise<Recaptcha> {\n    return new MockReCaptcha(auth);\n  }\n\n  clearedOneInstance(): void {}\n}\n","/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { Auth, RecaptchaParameters } from '../../model/public_types';\nimport { getRecaptchaParams } from '../../api/authentication/recaptcha';\nimport { _castAuth } from '../../core/auth/auth_impl';\nimport { AuthErrorCode } from '../../core/errors';\nimport { _assert } from '../../core/util/assert';\nimport { _isHttpOrHttps } from '../../core/util/location';\nimport { ApplicationVerifierInternal } from '../../model/application_verifier';\nimport { AuthInternal } from '../../model/auth';\nimport { _window } from '../auth_window';\nimport { _isWorker } from '../util/worker';\nimport { Recaptcha } from './recaptcha';\nimport {\n  MockReCaptchaLoaderImpl,\n  ReCaptchaLoader,\n  ReCaptchaLoaderImpl\n} from './recaptcha_loader';\n\nexport const RECAPTCHA_VERIFIER_TYPE = 'recaptcha';\n\nconst DEFAULT_PARAMS: RecaptchaParameters = {\n  theme: 'light',\n  type: 'image'\n};\n\ntype TokenCallback = (token: string) => void;\n\n/**\n * An {@link https://www.google.com/recaptcha/ | reCAPTCHA}-based application verifier.\n *\n * @public\n */\nexport class RecaptchaVerifier implements ApplicationVerifierInternal {\n  /**\n   * The application verifier type.\n   *\n   * @remarks\n   * For a reCAPTCHA verifier, this is 'recaptcha'.\n   */\n  readonly type = RECAPTCHA_VERIFIER_TYPE;\n  private destroyed = false;\n  private widgetId: number | null = null;\n  private readonly container: HTMLElement;\n  private readonly isInvisible: boolean;\n  private readonly tokenChangeListeners = new Set<TokenCallback>();\n  private renderPromise: Promise<number> | null = null;\n  private readonly auth: AuthInternal;\n\n  /** @internal */\n  readonly _recaptchaLoader: ReCaptchaLoader;\n  private recaptcha: Recaptcha | null = null;\n\n  /**\n   *\n   * @param containerOrId - The reCAPTCHA container parameter.\n   *\n   * @remarks\n   * This has different meaning depending on whether the reCAPTCHA is hidden or visible. For a\n   * visible reCAPTCHA the container must be empty. If a string is used, it has to correspond to\n   * an element ID. The corresponding element must also must be in the DOM at the time of\n   * initialization.\n   *\n   * @param parameters - The optional reCAPTCHA parameters.\n   *\n   * @remarks\n   * Check the reCAPTCHA docs for a comprehensive list. All parameters are accepted except for\n   * the sitekey. Firebase Auth backend provisions a reCAPTCHA for each project and will\n   * configure this upon rendering. For an invisible reCAPTCHA, a size key must have the value\n   * 'invisible'.\n   *\n   * @param authExtern - The corresponding Firebase {@link Auth} instance.\n   *\n   * @remarks\n   * If none is provided, the default Firebase {@link Auth} instance is used. A Firebase {@link Auth} instance\n   * must be initialized with an API key, otherwise an error will be thrown.\n   */\n  constructor(\n    containerOrId: HTMLElement | string,\n    private readonly parameters: RecaptchaParameters = {\n      ...DEFAULT_PARAMS\n    },\n    authExtern: Auth\n  ) {\n    this.auth = _castAuth(authExtern);\n    this.isInvisible = this.parameters.size === 'invisible';\n    _assert(\n      typeof document !== 'undefined',\n      this.auth,\n      AuthErrorCode.OPERATION_NOT_SUPPORTED\n    );\n    const container =\n      typeof containerOrId === 'string'\n        ? document.getElementById(containerOrId)\n        : containerOrId;\n    _assert(container, this.auth, AuthErrorCode.ARGUMENT_ERROR);\n\n    this.container = container;\n    this.parameters.callback = this.makeTokenCallback(this.parameters.callback);\n\n    this._recaptchaLoader = this.auth.settings.appVerificationDisabledForTesting\n      ? new MockReCaptchaLoaderImpl()\n      : new ReCaptchaLoaderImpl();\n\n    this.validateStartingState();\n    // TODO: Figure out if sdk version is needed\n  }\n\n  /**\n   * Waits for the user to solve the reCAPTCHA and resolves with the reCAPTCHA token.\n   *\n   * @returns A Promise for the reCAPTCHA token.\n   */\n  async verify(): Promise<string> {\n    this.assertNotDestroyed();\n    const id = await this.render();\n    const recaptcha = this.getAssertedRecaptcha();\n\n    const response = recaptcha.getResponse(id);\n    if (response) {\n      return response;\n    }\n\n    return new Promise<string>(resolve => {\n      const tokenChange = (token: string): void => {\n        if (!token) {\n          return; // Ignore token expirations.\n        }\n        this.tokenChangeListeners.delete(tokenChange);\n        resolve(token);\n      };\n\n      this.tokenChangeListeners.add(tokenChange);\n      if (this.isInvisible) {\n        recaptcha.execute(id);\n      }\n    });\n  }\n\n  /**\n   * Renders the reCAPTCHA widget on the page.\n   *\n   * @returns A Promise that resolves with the reCAPTCHA widget ID.\n   */\n  render(): Promise<number> {\n    try {\n      this.assertNotDestroyed();\n    } catch (e) {\n      // This method returns a promise. Since it's not async (we want to return the\n      // _same_ promise if rendering is still occurring), the API surface should\n      // reject with the error rather than just throw\n      return Promise.reject(e);\n    }\n\n    if (this.renderPromise) {\n      return this.renderPromise;\n    }\n\n    this.renderPromise = this.makeRenderPromise().catch(e => {\n      this.renderPromise = null;\n      throw e;\n    });\n\n    return this.renderPromise;\n  }\n\n  /** @internal */\n  _reset(): void {\n    this.assertNotDestroyed();\n    if (this.widgetId !== null) {\n      this.getAssertedRecaptcha().reset(this.widgetId);\n    }\n  }\n\n  /**\n   * Clears the reCAPTCHA widget from the page and destroys the instance.\n   */\n  clear(): void {\n    this.assertNotDestroyed();\n    this.destroyed = true;\n    this._recaptchaLoader.clearedOneInstance();\n    if (!this.isInvisible) {\n      this.container.childNodes.forEach(node => {\n        this.container.removeChild(node);\n      });\n    }\n  }\n\n  private validateStartingState(): void {\n    _assert(!this.parameters.sitekey, this.auth, AuthErrorCode.ARGUMENT_ERROR);\n    _assert(\n      this.isInvisible || !this.container.hasChildNodes(),\n      this.auth,\n      AuthErrorCode.ARGUMENT_ERROR\n    );\n    _assert(\n      typeof document !== 'undefined',\n      this.auth,\n      AuthErrorCode.OPERATION_NOT_SUPPORTED\n    );\n  }\n\n  private makeTokenCallback(\n    existing: TokenCallback | string | undefined\n  ): TokenCallback {\n    return token => {\n      this.tokenChangeListeners.forEach(listener => listener(token));\n      if (typeof existing === 'function') {\n        existing(token);\n      } else if (typeof existing === 'string') {\n        const globalFunc = _window()[existing];\n        if (typeof globalFunc === 'function') {\n          globalFunc(token);\n        }\n      }\n    };\n  }\n\n  private assertNotDestroyed(): void {\n    _assert(!this.destroyed, this.auth, AuthErrorCode.INTERNAL_ERROR);\n  }\n\n  private async makeRenderPromise(): Promise<number> {\n    await this.init();\n    if (!this.widgetId) {\n      let container = this.container;\n      if (!this.isInvisible) {\n        const guaranteedEmpty = document.createElement('div');\n        container.appendChild(guaranteedEmpty);\n        container = guaranteedEmpty;\n      }\n\n      this.widgetId = this.getAssertedRecaptcha().render(\n        container,\n        this.parameters\n      );\n    }\n\n    return this.widgetId;\n  }\n\n  private async init(): Promise<void> {\n    _assert(\n      _isHttpOrHttps() && !_isWorker(),\n      this.auth,\n      AuthErrorCode.INTERNAL_ERROR\n    );\n\n    await domReady();\n    this.recaptcha = await this._recaptchaLoader.load(\n      this.auth,\n      this.auth.languageCode || undefined\n    );\n\n    const siteKey = await getRecaptchaParams(this.auth);\n    _assert(siteKey, this.auth, AuthErrorCode.INTERNAL_ERROR);\n    this.parameters.sitekey = siteKey;\n  }\n\n  private getAssertedRecaptcha(): Recaptcha {\n    _assert(this.recaptcha, this.auth, AuthErrorCode.INTERNAL_ERROR);\n    return this.recaptcha;\n  }\n}\n\nfunction domReady(): Promise<void> {\n  let resolver: (() => void) | null = null;\n  return new Promise<void>(resolve => {\n    if (document.readyState === 'complete') {\n      resolve();\n      return;\n    }\n\n    // Document not ready, wait for load before resolving.\n    // Save resolver, so we can remove listener in case it was externally\n    // cancelled.\n    resolver = () => resolve();\n    window.addEventListener('load', resolver);\n  }).catch(e => {\n    if (resolver) {\n      window.removeEventListener('load', resolver);\n    }\n\n    throw e;\n  });\n}\n","/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport {\n  ApplicationVerifier,\n  Auth,\n  ConfirmationResult,\n  PhoneInfoOptions,\n  User,\n  UserCredential\n} from '../../model/public_types';\n\nimport { startEnrollPhoneMfa } from '../../api/account_management/mfa';\nimport { startSignInPhoneMfa } from '../../api/authentication/mfa';\nimport { sendPhoneVerificationCode } from '../../api/authentication/sms';\nimport { ApplicationVerifierInternal } from '../../model/application_verifier';\nimport { PhoneAuthCredential } from '../../core/credentials/phone';\nimport { AuthErrorCode } from '../../core/errors';\nimport { _assertLinkedStatus, _link } from '../../core/user/link_unlink';\nimport { _assert } from '../../core/util/assert';\nimport { AuthInternal } from '../../model/auth';\nimport {\n  linkWithCredential,\n  reauthenticateWithCredential,\n  signInWithCredential\n} from '../../core/strategies/credential';\nimport {\n  MultiFactorSessionImpl,\n  MultiFactorSessionType\n} from '../../mfa/mfa_session';\nimport { UserInternal } from '../../model/user';\nimport { RECAPTCHA_VERIFIER_TYPE } from '../recaptcha/recaptcha_verifier';\nimport { _castAuth } from '../../core/auth/auth_impl';\nimport { getModularInstance } from '@firebase/util';\nimport { ProviderId } from '../../model/enums';\n\ninterface OnConfirmationCallback {\n  (credential: PhoneAuthCredential): Promise<UserCredential>;\n}\n\nclass ConfirmationResultImpl implements ConfirmationResult {\n  constructor(\n    readonly verificationId: string,\n    private readonly onConfirmation: OnConfirmationCallback\n  ) {}\n\n  confirm(verificationCode: string): Promise<UserCredential> {\n    const authCredential = PhoneAuthCredential._fromVerification(\n      this.verificationId,\n      verificationCode\n    );\n    return this.onConfirmation(authCredential);\n  }\n}\n\n/**\n * Asynchronously signs in using a phone number.\n *\n * @remarks\n * This method sends a code via SMS to the given\n * phone number, and returns a {@link ConfirmationResult}. After the user\n * provides the code sent to their phone, call {@link ConfirmationResult.confirm}\n * with the code to sign the user in.\n *\n * For abuse prevention, this method also requires a {@link ApplicationVerifier}.\n * This SDK includes a reCAPTCHA-based implementation, {@link RecaptchaVerifier}.\n * This function can work on other platforms that do not support the\n * {@link RecaptchaVerifier} (like React Native), but you need to use a\n * third-party {@link ApplicationVerifier} implementation.\n *\n * @example\n * ```javascript\n * // 'recaptcha-container' is the ID of an element in the DOM.\n * const applicationVerifier = new firebase.auth.RecaptchaVerifier('recaptcha-container');\n * const confirmationResult = await signInWithPhoneNumber(auth, phoneNumber, applicationVerifier);\n * // Obtain a verificationCode from the user.\n * const credential = await confirmationResult.confirm(verificationCode);\n * ```\n *\n * @param auth - The {@link Auth} instance.\n * @param phoneNumber - The user's phone number in E.164 format (e.g. +16505550101).\n * @param appVerifier - The {@link ApplicationVerifier}.\n *\n * @public\n */\nexport async function signInWithPhoneNumber(\n  auth: Auth,\n  phoneNumber: string,\n  appVerifier: ApplicationVerifier\n): Promise<ConfirmationResult> {\n  const authInternal = _castAuth(auth);\n  const verificationId = await _verifyPhoneNumber(\n    authInternal,\n    phoneNumber,\n    getModularInstance(appVerifier as ApplicationVerifierInternal)\n  );\n  return new ConfirmationResultImpl(verificationId, cred =>\n    signInWithCredential(authInternal, cred)\n  );\n}\n\n/**\n * Links the user account with the given phone number.\n *\n * @param user - The user.\n * @param phoneNumber - The user's phone number in E.164 format (e.g. +16505550101).\n * @param appVerifier - The {@link ApplicationVerifier}.\n *\n * @public\n */\nexport async function linkWithPhoneNumber(\n  user: User,\n  phoneNumber: string,\n  appVerifier: ApplicationVerifier\n): Promise<ConfirmationResult> {\n  const userInternal = getModularInstance(user) as UserInternal;\n  await _assertLinkedStatus(false, userInternal, ProviderId.PHONE);\n  const verificationId = await _verifyPhoneNumber(\n    userInternal.auth,\n    phoneNumber,\n    getModularInstance(appVerifier as ApplicationVerifierInternal)\n  );\n  return new ConfirmationResultImpl(verificationId, cred =>\n    linkWithCredential(userInternal, cred)\n  );\n}\n\n/**\n * Re-authenticates a user using a fresh phone credential.\n *\n * @remarks Use before operations such as {@link updatePassword} that require tokens from recent sign-in attempts.\n *\n * @param user - The user.\n * @param phoneNumber - The user's phone number in E.164 format (e.g. +16505550101).\n * @param appVerifier - The {@link ApplicationVerifier}.\n *\n * @public\n */\nexport async function reauthenticateWithPhoneNumber(\n  user: User,\n  phoneNumber: string,\n  appVerifier: ApplicationVerifier\n): Promise<ConfirmationResult> {\n  const userInternal = getModularInstance(user) as UserInternal;\n  const verificationId = await _verifyPhoneNumber(\n    userInternal.auth,\n    phoneNumber,\n    getModularInstance(appVerifier as ApplicationVerifierInternal)\n  );\n  return new ConfirmationResultImpl(verificationId, cred =>\n    reauthenticateWithCredential(userInternal, cred)\n  );\n}\n\n/**\n * Returns a verification ID to be used in conjunction with the SMS code that is sent.\n *\n */\nexport async function _verifyPhoneNumber(\n  auth: AuthInternal,\n  options: PhoneInfoOptions | string,\n  verifier: ApplicationVerifierInternal\n): Promise<string> {\n  const recaptchaToken = await verifier.verify();\n\n  try {\n    _assert(\n      typeof recaptchaToken === 'string',\n      auth,\n      AuthErrorCode.ARGUMENT_ERROR\n    );\n    _assert(\n      verifier.type === RECAPTCHA_VERIFIER_TYPE,\n      auth,\n      AuthErrorCode.ARGUMENT_ERROR\n    );\n\n    let phoneInfoOptions: PhoneInfoOptions;\n\n    if (typeof options === 'string') {\n      phoneInfoOptions = {\n        phoneNumber: options\n      };\n    } else {\n      phoneInfoOptions = options;\n    }\n\n    if ('session' in phoneInfoOptions) {\n      const session = phoneInfoOptions.session as MultiFactorSessionImpl;\n\n      if ('phoneNumber' in phoneInfoOptions) {\n        _assert(\n          session.type === MultiFactorSessionType.ENROLL,\n          auth,\n          AuthErrorCode.INTERNAL_ERROR\n        );\n        const response = await startEnrollPhoneMfa(auth, {\n          idToken: session.credential,\n          phoneEnrollmentInfo: {\n            phoneNumber: phoneInfoOptions.phoneNumber,\n            recaptchaToken\n          }\n        });\n        return response.phoneSessionInfo.sessionInfo;\n      } else {\n        _assert(\n          session.type === MultiFactorSessionType.SIGN_IN,\n          auth,\n          AuthErrorCode.INTERNAL_ERROR\n        );\n        const mfaEnrollmentId =\n          phoneInfoOptions.multiFactorHint?.uid ||\n          phoneInfoOptions.multiFactorUid;\n        _assert(mfaEnrollmentId, auth, AuthErrorCode.MISSING_MFA_INFO);\n        const response = await startSignInPhoneMfa(auth, {\n          mfaPendingCredential: session.credential,\n          mfaEnrollmentId,\n          phoneSignInInfo: {\n            recaptchaToken\n          }\n        });\n        return response.phoneResponseInfo.sessionInfo;\n      }\n    } else {\n      const { sessionInfo } = await sendPhoneVerificationCode(auth, {\n        phoneNumber: phoneInfoOptions.phoneNumber,\n        recaptchaToken\n      });\n      return sessionInfo;\n    }\n  } finally {\n    verifier._reset();\n  }\n}\n\n/**\n * Updates the user's phone number.\n *\n * @example\n * ```\n * // 'recaptcha-container' is the ID of an element in the DOM.\n * const applicationVerifier = new RecaptchaVerifier('recaptcha-container');\n * const provider = new PhoneAuthProvider(auth);\n * const verificationId = await provider.verifyPhoneNumber('+16505550101', applicationVerifier);\n * // Obtain the verificationCode from the user.\n * const phoneCredential = PhoneAuthProvider.credential(verificationId, verificationCode);\n * await updatePhoneNumber(user, phoneCredential);\n * ```\n *\n * @param user - The user.\n * @param credential - A credential authenticating the new phone number.\n *\n * @public\n */\nexport async function updatePhoneNumber(\n  user: User,\n  credential: PhoneAuthCredential\n): Promise<void> {\n  await _link(getModularInstance(user) as UserInternal, credential);\n}\n","/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport {\n  Auth,\n  PhoneInfoOptions,\n  ApplicationVerifier,\n  UserCredential\n} from '../../model/public_types';\n\nimport { SignInWithPhoneNumberResponse } from '../../api/authentication/sms';\nimport { ApplicationVerifierInternal as ApplicationVerifierInternal } from '../../model/application_verifier';\nimport { AuthInternal as AuthInternal } from '../../model/auth';\nimport { UserCredentialInternal as UserCredentialInternal } from '../../model/user';\nimport { PhoneAuthCredential } from '../../core/credentials/phone';\nimport { _verifyPhoneNumber } from '../strategies/phone';\nimport { _castAuth } from '../../core/auth/auth_impl';\nimport { AuthCredential } from '../../core';\nimport { FirebaseError, getModularInstance } from '@firebase/util';\nimport { TaggedWithTokenResponse } from '../../model/id_token';\nimport { ProviderId, SignInMethod } from '../../model/enums';\n\n/**\n * Provider for generating an {@link PhoneAuthCredential}.\n *\n * @example\n * ```javascript\n * // 'recaptcha-container' is the ID of an element in the DOM.\n * const applicationVerifier = new RecaptchaVerifier('recaptcha-container');\n * const provider = new PhoneAuthProvider(auth);\n * const verificationId = await provider.verifyPhoneNumber('+16505550101', applicationVerifier);\n * // Obtain the verificationCode from the user.\n * const phoneCredential = PhoneAuthProvider.credential(verificationId, verificationCode);\n * const userCredential = await signInWithCredential(auth, phoneCredential);\n * ```\n *\n * @public\n */\nexport class PhoneAuthProvider {\n  /** Always set to {@link ProviderId}.PHONE. */\n  static readonly PROVIDER_ID: 'phone' = ProviderId.PHONE;\n  /** Always set to {@link SignInMethod}.PHONE. */\n  static readonly PHONE_SIGN_IN_METHOD: 'phone' = SignInMethod.PHONE;\n\n  /** Always set to {@link ProviderId}.PHONE. */\n  readonly providerId = PhoneAuthProvider.PROVIDER_ID;\n  private readonly auth: AuthInternal;\n\n  /**\n   * @param auth - The Firebase {@link Auth} instance in which sign-ins should occur.\n   *\n   */\n  constructor(auth: Auth) {\n    this.auth = _castAuth(auth);\n  }\n\n  /**\n   *\n   * Starts a phone number authentication flow by sending a verification code to the given phone\n   * number.\n   *\n   * @example\n   * ```javascript\n   * const provider = new PhoneAuthProvider(auth);\n   * const verificationId = await provider.verifyPhoneNumber(phoneNumber, applicationVerifier);\n   * // Obtain verificationCode from the user.\n   * const authCredential = PhoneAuthProvider.credential(verificationId, verificationCode);\n   * const userCredential = await signInWithCredential(auth, authCredential);\n   * ```\n   *\n   * @example\n   * An alternative flow is provided using the `signInWithPhoneNumber` method.\n   * ```javascript\n   * const confirmationResult = signInWithPhoneNumber(auth, phoneNumber, applicationVerifier);\n   * // Obtain verificationCode from the user.\n   * const userCredential = confirmationResult.confirm(verificationCode);\n   * ```\n   *\n   * @param phoneInfoOptions - The user's {@link PhoneInfoOptions}. The phone number should be in\n   * E.164 format (e.g. +16505550101).\n   * @param applicationVerifier - For abuse prevention, this method also requires a\n   * {@link ApplicationVerifier}. This SDK includes a reCAPTCHA-based implementation,\n   * {@link RecaptchaVerifier}.\n   *\n   * @returns A Promise for a verification ID that can be passed to\n   * {@link PhoneAuthProvider.credential} to identify this flow..\n   */\n  verifyPhoneNumber(\n    phoneOptions: PhoneInfoOptions | string,\n    applicationVerifier: ApplicationVerifier\n  ): Promise<string> {\n    return _verifyPhoneNumber(\n      this.auth,\n      phoneOptions,\n      getModularInstance(applicationVerifier as ApplicationVerifierInternal)\n    );\n  }\n\n  /**\n   * Creates a phone auth credential, given the verification ID from\n   * {@link PhoneAuthProvider.verifyPhoneNumber} and the code that was sent to the user's\n   * mobile device.\n   *\n   * @example\n   * ```javascript\n   * const provider = new PhoneAuthProvider(auth);\n   * const verificationId = provider.verifyPhoneNumber(phoneNumber, applicationVerifier);\n   * // Obtain verificationCode from the user.\n   * const authCredential = PhoneAuthProvider.credential(verificationId, verificationCode);\n   * const userCredential = signInWithCredential(auth, authCredential);\n   * ```\n   *\n   * @example\n   * An alternative flow is provided using the `signInWithPhoneNumber` method.\n   * ```javascript\n   * const confirmationResult = await signInWithPhoneNumber(auth, phoneNumber, applicationVerifier);\n   * // Obtain verificationCode from the user.\n   * const userCredential = await confirmationResult.confirm(verificationCode);\n   * ```\n   *\n   * @param verificationId - The verification ID returned from {@link PhoneAuthProvider.verifyPhoneNumber}.\n   * @param verificationCode - The verification code sent to the user's mobile device.\n   *\n   * @returns The auth provider credential.\n   */\n  static credential(\n    verificationId: string,\n    verificationCode: string\n  ): PhoneAuthCredential {\n    return PhoneAuthCredential._fromVerification(\n      verificationId,\n      verificationCode\n    );\n  }\n\n  /**\n   * Generates an {@link AuthCredential} from a {@link UserCredential}.\n   * @param userCredential - The user credential.\n   */\n  static credentialFromResult(\n    userCredential: UserCredential\n  ): AuthCredential | null {\n    const credential = userCredential as UserCredentialInternal;\n    return PhoneAuthProvider.credentialFromTaggedObject(credential);\n  }\n\n  /**\n   * Returns an {@link AuthCredential} when passed an error.\n   *\n   * @remarks\n   *\n   * This method works for errors like\n   * `auth/account-exists-with-different-credentials`. This is useful for\n   * recovering when attempting to set a user's phone number but the number\n   * in question is already tied to another account. For example, the following\n   * code tries to update the current user's phone number, and if that\n   * fails, links the user with the account associated with that number:\n   *\n   * ```js\n   * const provider = new PhoneAuthProvider(auth);\n   * const verificationId = await provider.verifyPhoneNumber(number, verifier);\n   * try {\n   *   const code = ''; // Prompt the user for the verification code\n   *   await updatePhoneNumber(\n   *       auth.currentUser,\n   *       PhoneAuthProvider.credential(verificationId, code));\n   * } catch (e) {\n   *   if (e.code === 'auth/account-exists-with-different-credential') {\n   *     const cred = PhoneAuthProvider.credentialFromError(e);\n   *     await linkWithCredential(auth.currentUser, cred);\n   *   }\n   * }\n   *\n   * // At this point, auth.currentUser.phoneNumber === number.\n   * ```\n   *\n   * @param error - The error to generate a credential from.\n   */\n  static credentialFromError(error: FirebaseError): AuthCredential | null {\n    return PhoneAuthProvider.credentialFromTaggedObject(\n      (error.customData || {}) as TaggedWithTokenResponse\n    );\n  }\n\n  private static credentialFromTaggedObject({\n    _tokenResponse: tokenResponse\n  }: TaggedWithTokenResponse): AuthCredential | null {\n    if (!tokenResponse) {\n      return null;\n    }\n    const { phoneNumber, temporaryProof } =\n      tokenResponse as SignInWithPhoneNumberResponse;\n    if (phoneNumber && temporaryProof) {\n      return PhoneAuthCredential._fromTokenResponse(\n        phoneNumber,\n        temporaryProof\n      );\n    }\n    return null;\n  }\n}\n","/**\n * @license\n * Copyright 2021 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { PopupRedirectResolver } from '../../model/public_types';\nimport { AuthInternal } from '../../model/auth';\nimport { PopupRedirectResolverInternal } from '../../model/popup_redirect';\nimport { AuthErrorCode } from '../errors';\nimport { _assert } from './assert';\nimport { _getInstance } from './instantiator';\n\n/**\n * Chooses a popup/redirect resolver to use. This prefers the override (which\n * is directly passed in), and falls back to the property set on the auth\n * object. If neither are available, this function errors w/ an argument error.\n */\nexport function _withDefaultResolver(\n  auth: AuthInternal,\n  resolverOverride: PopupRedirectResolver | undefined\n): PopupRedirectResolverInternal {\n  if (resolverOverride) {\n    return _getInstance(resolverOverride);\n  }\n\n  _assert(auth._popupRedirectResolver, auth, AuthErrorCode.ARGUMENT_ERROR);\n\n  return auth._popupRedirectResolver;\n}\n","/**\n * @license\n * Copyright 2019 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport {\n  signInWithIdp,\n  SignInWithIdpRequest\n} from '../../api/authentication/idp';\nimport { PhoneOrOauthTokenResponse } from '../../api/authentication/mfa';\nimport { AuthInternal } from '../../model/auth';\nimport { IdTokenResponse } from '../../model/id_token';\nimport { UserInternal, UserCredentialInternal } from '../../model/user';\nimport { AuthCredential } from '../credentials';\nimport { _link as _linkUser } from '../user/link_unlink';\nimport { _reauthenticate } from '../user/reauthenticate';\nimport { _assert } from '../util/assert';\nimport { _signInWithCredential } from './credential';\nimport { AuthErrorCode } from '../errors';\nimport { ProviderId } from '../../model/enums';\n\nexport interface IdpTaskParams {\n  auth: AuthInternal;\n  requestUri: string;\n  sessionId?: string;\n  tenantId?: string;\n  postBody?: string;\n  pendingToken?: string;\n  user?: UserInternal;\n  bypassAuthState?: boolean;\n}\n\nexport type IdpTask = (\n  params: IdpTaskParams\n) => Promise<UserCredentialInternal>;\n\nclass IdpCredential extends AuthCredential {\n  constructor(readonly params: IdpTaskParams) {\n    super(ProviderId.CUSTOM, ProviderId.CUSTOM);\n  }\n\n  _getIdTokenResponse(auth: AuthInternal): Promise<PhoneOrOauthTokenResponse> {\n    return signInWithIdp(auth, this._buildIdpRequest());\n  }\n\n  _linkToIdToken(\n    auth: AuthInternal,\n    idToken: string\n  ): Promise<IdTokenResponse> {\n    return signInWithIdp(auth, this._buildIdpRequest(idToken));\n  }\n\n  _getReauthenticationResolver(auth: AuthInternal): Promise<IdTokenResponse> {\n    return signInWithIdp(auth, this._buildIdpRequest());\n  }\n\n  private _buildIdpRequest(idToken?: string): SignInWithIdpRequest {\n    const request: SignInWithIdpRequest = {\n      requestUri: this.params.requestUri,\n      sessionId: this.params.sessionId,\n      postBody: this.params.postBody,\n      tenantId: this.params.tenantId,\n      pendingToken: this.params.pendingToken,\n      returnSecureToken: true,\n      returnIdpCredential: true\n    };\n\n    if (idToken) {\n      request.idToken = idToken;\n    }\n\n    return request;\n  }\n}\n\nexport function _signIn(\n  params: IdpTaskParams\n): Promise<UserCredentialInternal> {\n  return _signInWithCredential(\n    params.auth,\n    new IdpCredential(params),\n    params.bypassAuthState\n  ) as Promise<UserCredentialInternal>;\n}\n\nexport function _reauth(\n  params: IdpTaskParams\n): Promise<UserCredentialInternal> {\n  const { auth, user } = params;\n  _assert(user, auth, AuthErrorCode.INTERNAL_ERROR);\n  return _reauthenticate(\n    user,\n    new IdpCredential(params),\n    params.bypassAuthState\n  );\n}\n\nexport async function _link(\n  params: IdpTaskParams\n): Promise<UserCredentialInternal> {\n  const { auth, user } = params;\n  _assert(user, auth, AuthErrorCode.INTERNAL_ERROR);\n  return _linkUser(user, new IdpCredential(params), params.bypassAuthState);\n}\n","/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { FirebaseError } from '@firebase/util';\n\nimport {\n  AuthEvent,\n  AuthEventConsumer,\n  AuthEventType,\n  EventManager,\n  PopupRedirectResolverInternal\n} from '../../model/popup_redirect';\nimport { UserInternal, UserCredentialInternal } from '../../model/user';\nimport { AuthErrorCode } from '../errors';\nimport { debugAssert, _fail } from '../util/assert';\nimport {\n  _link,\n  _reauth,\n  _signIn,\n  IdpTask,\n  IdpTaskParams\n} from '../strategies/idp';\nimport { AuthInternal } from '../../model/auth';\n\ninterface PendingPromise {\n  resolve: (cred: UserCredentialInternal | null) => void;\n  reject: (error: Error) => void;\n}\n\n/**\n * Popup event manager. Handles the popup's entire lifecycle; listens to auth\n * events\n */\nexport abstract class AbstractPopupRedirectOperation\n  implements AuthEventConsumer {\n  private pendingPromise: PendingPromise | null = null;\n  private eventManager: EventManager | null = null;\n  readonly filter: AuthEventType[];\n\n  abstract eventId: string | null;\n\n  constructor(\n    protected readonly auth: AuthInternal,\n    filter: AuthEventType | AuthEventType[],\n    protected readonly resolver: PopupRedirectResolverInternal,\n    protected user?: UserInternal,\n    protected readonly bypassAuthState = false\n  ) {\n    this.filter = Array.isArray(filter) ? filter : [filter];\n  }\n\n  abstract onExecution(): Promise<void>;\n\n  execute(): Promise<UserCredentialInternal | null> {\n    return new Promise<UserCredentialInternal | null>(\n      async (resolve, reject) => {\n        this.pendingPromise = { resolve, reject };\n\n        try {\n          this.eventManager = await this.resolver._initialize(this.auth);\n          await this.onExecution();\n          this.eventManager.registerConsumer(this);\n        } catch (e) {\n          this.reject(e);\n        }\n      }\n    );\n  }\n\n  async onAuthEvent(event: AuthEvent): Promise<void> {\n    const { urlResponse, sessionId, postBody, tenantId, error, type } = event;\n    if (error) {\n      this.reject(error);\n      return;\n    }\n\n    const params: IdpTaskParams = {\n      auth: this.auth,\n      requestUri: urlResponse!,\n      sessionId: sessionId!,\n      tenantId: tenantId || undefined,\n      postBody: postBody || undefined,\n      user: this.user,\n      bypassAuthState: this.bypassAuthState\n    };\n\n    try {\n      this.resolve(await this.getIdpTask(type)(params));\n    } catch (e) {\n      this.reject(e);\n    }\n  }\n\n  onError(error: FirebaseError): void {\n    this.reject(error);\n  }\n\n  private getIdpTask(type: AuthEventType): IdpTask {\n    switch (type) {\n      case AuthEventType.SIGN_IN_VIA_POPUP:\n      case AuthEventType.SIGN_IN_VIA_REDIRECT:\n        return _signIn;\n      case AuthEventType.LINK_VIA_POPUP:\n      case AuthEventType.LINK_VIA_REDIRECT:\n        return _link;\n      case AuthEventType.REAUTH_VIA_POPUP:\n      case AuthEventType.REAUTH_VIA_REDIRECT:\n        return _reauth;\n      default:\n        _fail(this.auth, AuthErrorCode.INTERNAL_ERROR);\n    }\n  }\n\n  protected resolve(cred: UserCredentialInternal | null): void {\n    debugAssert(this.pendingPromise, 'Pending promise was never set');\n    this.pendingPromise.resolve(cred);\n    this.unregisterAndCleanUp();\n  }\n\n  protected reject(error: Error): void {\n    debugAssert(this.pendingPromise, 'Pending promise was never set');\n    this.pendingPromise.reject(error);\n    this.unregisterAndCleanUp();\n  }\n\n  private unregisterAndCleanUp(): void {\n    if (this.eventManager) {\n      this.eventManager.unregisterConsumer(this);\n    }\n\n    this.pendingPromise = null;\n    this.cleanUp();\n  }\n\n  abstract cleanUp(): void;\n}\n","/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport {\n  Auth,\n  AuthProvider,\n  PopupRedirectResolver,\n  User,\n  UserCredential\n} from '../../model/public_types';\n\nimport { _castAuth } from '../../core/auth/auth_impl';\nimport { AuthErrorCode } from '../../core/errors';\nimport { _assert, debugAssert, _createError, _assertInstanceOf } from '../../core/util/assert';\nimport { Delay } from '../../core/util/delay';\nimport { _generateEventId } from '../../core/util/event_id';\nimport { AuthInternal } from '../../model/auth';\nimport {\n  AuthEventType,\n  PopupRedirectResolverInternal\n} from '../../model/popup_redirect';\nimport { UserInternal } from '../../model/user';\nimport { _withDefaultResolver } from '../../core/util/resolver';\nimport { AuthPopup } from '../util/popup';\nimport { AbstractPopupRedirectOperation } from '../../core/strategies/abstract_popup_redirect_operation';\nimport { FederatedAuthProvider } from '../../core/providers/federated';\nimport { getModularInstance } from '@firebase/util';\n\n/*\n * The event timeout is the same on mobile and desktop, no need for Delay.\n */\nexport const enum _Timeout {\n  AUTH_EVENT = 2000\n}\nexport const _POLL_WINDOW_CLOSE_TIMEOUT = new Delay(2000, 10000);\n\n/**\n * Authenticates a Firebase client using a popup-based OAuth authentication flow.\n *\n * @remarks\n * If succeeds, returns the signed in user along with the provider's credential. If sign in was\n * unsuccessful, returns an error object containing additional information about the error.\n *\n * @example\n * ```javascript\n * // Sign in using a popup.\n * const provider = new FacebookAuthProvider();\n * const result = await signInWithPopup(auth, provider);\n *\n * // The signed-in user info.\n * const user = result.user;\n * // This gives you a Facebook Access Token.\n * const credential = provider.credentialFromResult(auth, result);\n * const token = credential.accessToken;\n * ```\n *\n * @param auth - The {@link Auth} instance.\n * @param provider - The provider to authenticate. The provider has to be an {@link OAuthProvider}.\n * Non-OAuth providers like {@link EmailAuthProvider} will throw an error.\n * @param resolver - An instance of {@link PopupRedirectResolver}, optional\n * if already supplied to {@link initializeAuth} or provided by {@link getAuth}.\n *\n *\n * @public\n */\nexport async function signInWithPopup(\n  auth: Auth,\n  provider: AuthProvider,\n  resolver?: PopupRedirectResolver\n): Promise<UserCredential> {\n  const authInternal = _castAuth(auth);\n  _assertInstanceOf(auth, provider, FederatedAuthProvider);\n  const resolverInternal = _withDefaultResolver(authInternal, resolver);\n  const action = new PopupOperation(\n    authInternal,\n    AuthEventType.SIGN_IN_VIA_POPUP,\n    provider,\n    resolverInternal\n  );\n  return action.executeNotNull();\n}\n\n/**\n * Reauthenticates the current user with the specified {@link OAuthProvider} using a pop-up based\n * OAuth flow.\n *\n * @remarks\n * If the reauthentication is successful, the returned result will contain the user and the\n * provider's credential.\n *\n * @example\n * ```javascript\n * // Sign in using a popup.\n * const provider = new FacebookAuthProvider();\n * const result = await signInWithPopup(auth, provider);\n * // Reauthenticate using a popup.\n * await reauthenticateWithPopup(result.user, provider);\n * ```\n *\n * @param user - The user.\n * @param provider - The provider to authenticate. The provider has to be an {@link OAuthProvider}.\n * Non-OAuth providers like {@link EmailAuthProvider} will throw an error.\n * @param resolver - An instance of {@link PopupRedirectResolver}, optional\n * if already supplied to {@link initializeAuth} or provided by {@link getAuth}.\n *\n * @public\n */\nexport async function reauthenticateWithPopup(\n  user: User,\n  provider: AuthProvider,\n  resolver?: PopupRedirectResolver\n): Promise<UserCredential> {\n  const userInternal = getModularInstance(user) as UserInternal;\n  _assertInstanceOf(userInternal.auth, provider, FederatedAuthProvider);\n  const resolverInternal = _withDefaultResolver(userInternal.auth, resolver);\n  const action = new PopupOperation(\n    userInternal.auth,\n    AuthEventType.REAUTH_VIA_POPUP,\n    provider,\n    resolverInternal,\n    userInternal\n  );\n  return action.executeNotNull();\n}\n\n/**\n * Links the authenticated provider to the user account using a pop-up based OAuth flow.\n *\n * @remarks\n * If the linking is successful, the returned result will contain the user and the provider's credential.\n *\n *\n * @example\n * ```javascript\n * // Sign in using some other provider.\n * const result = await signInWithEmailAndPassword(auth, email, password);\n * // Link using a popup.\n * const provider = new FacebookAuthProvider();\n * await linkWithPopup(result.user, provider);\n * ```\n *\n * @param user - The user.\n * @param provider - The provider to authenticate. The provider has to be an {@link OAuthProvider}.\n * Non-OAuth providers like {@link EmailAuthProvider} will throw an error.\n * @param resolver - An instance of {@link PopupRedirectResolver}, optional\n * if already supplied to {@link initializeAuth} or provided by {@link getAuth}.\n *\n * @public\n */\nexport async function linkWithPopup(\n  user: User,\n  provider: AuthProvider,\n  resolver?: PopupRedirectResolver\n): Promise<UserCredential> {\n  const userInternal = getModularInstance(user) as UserInternal;\n  _assertInstanceOf(userInternal.auth, provider, FederatedAuthProvider);\n  const resolverInternal = _withDefaultResolver(userInternal.auth, resolver);\n\n  const action = new PopupOperation(\n    userInternal.auth,\n    AuthEventType.LINK_VIA_POPUP,\n    provider,\n    resolverInternal,\n    userInternal\n  );\n  return action.executeNotNull();\n}\n\n/**\n * Popup event manager. Handles the popup's entire lifecycle; listens to auth\n * events\n *\n */\nclass PopupOperation extends AbstractPopupRedirectOperation {\n  // Only one popup is ever shown at once. The lifecycle of the current popup\n  // can be managed / cancelled by the constructor.\n  private static currentPopupAction: PopupOperation | null = null;\n  private authWindow: AuthPopup | null = null;\n  private pollId: number | null = null;\n\n  constructor(\n    auth: AuthInternal,\n    filter: AuthEventType,\n    private readonly provider: AuthProvider,\n    resolver: PopupRedirectResolverInternal,\n    user?: UserInternal\n  ) {\n    super(auth, filter, resolver, user);\n    if (PopupOperation.currentPopupAction) {\n      PopupOperation.currentPopupAction.cancel();\n    }\n\n    PopupOperation.currentPopupAction = this;\n  }\n\n  async executeNotNull(): Promise<UserCredential> {\n    const result = await this.execute();\n    _assert(result, this.auth, AuthErrorCode.INTERNAL_ERROR);\n    return result;\n  }\n\n  async onExecution(): Promise<void> {\n    debugAssert(\n      this.filter.length === 1,\n      'Popup operations only handle one event'\n    );\n    const eventId = _generateEventId();\n    this.authWindow = await this.resolver._openPopup(\n      this.auth,\n      this.provider,\n      this.filter[0], // There's always one, see constructor\n      eventId\n    );\n    this.authWindow.associatedEvent = eventId;\n\n    // Check for web storage support and origin validation _after_ the popup is\n    // loaded. These operations are slow (~1 second or so) Rather than\n    // waiting on them before opening the window, optimistically open the popup\n    // and check for storage support at the same time. If storage support is\n    // not available, this will cause the whole thing to reject properly. It\n    // will also close the popup, but since the promise has already rejected,\n    // the popup closed by user poll will reject into the void.\n    this.resolver._originValidation(this.auth).catch(e => {\n      this.reject(e);\n    });\n\n    this.resolver._isIframeWebStorageSupported(this.auth, isSupported => {\n      if (!isSupported) {\n        this.reject(\n          _createError(this.auth, AuthErrorCode.WEB_STORAGE_UNSUPPORTED)\n        );\n      }\n    });\n\n    // Handle user closure. Notice this does *not* use await\n    this.pollUserCancellation();\n  }\n\n  get eventId(): string | null {\n    return this.authWindow?.associatedEvent || null;\n  }\n\n  cancel(): void {\n    this.reject(_createError(this.auth, AuthErrorCode.EXPIRED_POPUP_REQUEST));\n  }\n\n  cleanUp(): void {\n    if (this.authWindow) {\n      this.authWindow.close();\n    }\n\n    if (this.pollId) {\n      window.clearTimeout(this.pollId);\n    }\n\n    this.authWindow = null;\n    this.pollId = null;\n    PopupOperation.currentPopupAction = null;\n  }\n\n  private pollUserCancellation(): void {\n    const poll = (): void => {\n      if (this.authWindow?.window?.closed) {\n        // Make sure that there is sufficient time for whatever action to\n        // complete. The window could have closed but the sign in network\n        // call could still be in flight.\n        this.pollId = window.setTimeout(() => {\n          this.pollId = null;\n          this.reject(\n            _createError(this.auth, AuthErrorCode.POPUP_CLOSED_BY_USER)\n          );\n        }, _Timeout.AUTH_EVENT);\n        return;\n      }\n\n      this.pollId = window.setTimeout(poll, _POLL_WINDOW_CLOSE_TIMEOUT.get());\n    };\n\n    poll();\n  }\n}\n","/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { AuthInternal } from '../../model/auth';\nimport {\n  AuthEvent,\n  AuthEventType,\n  PopupRedirectResolverInternal\n} from '../../model/popup_redirect';\nimport { UserCredentialInternal } from '../../model/user';\nimport { PersistenceInternal } from '../persistence';\nimport { _persistenceKeyName } from '../persistence/persistence_user_manager';\nimport { _getInstance } from '../util/instantiator';\nimport { AbstractPopupRedirectOperation } from './abstract_popup_redirect_operation';\n\nconst PENDING_REDIRECT_KEY = 'pendingRedirect';\n\n// We only get one redirect outcome for any one auth, so just store it\n// in here.\nconst redirectOutcomeMap: Map<\n  string,\n  () => Promise<UserCredentialInternal | null>\n> = new Map();\n\nexport class RedirectAction extends AbstractPopupRedirectOperation {\n  eventId = null;\n\n  constructor(\n    auth: AuthInternal,\n    resolver: PopupRedirectResolverInternal,\n    bypassAuthState = false\n  ) {\n    super(\n      auth,\n      [\n        AuthEventType.SIGN_IN_VIA_REDIRECT,\n        AuthEventType.LINK_VIA_REDIRECT,\n        AuthEventType.REAUTH_VIA_REDIRECT,\n        AuthEventType.UNKNOWN\n      ],\n      resolver,\n      undefined,\n      bypassAuthState\n    );\n  }\n\n  /**\n   * Override the execute function; if we already have a redirect result, then\n   * just return it.\n   */\n  async execute(): Promise<UserCredentialInternal | null> {\n    let readyOutcome = redirectOutcomeMap.get(this.auth._key());\n    if (!readyOutcome) {\n      try {\n        const hasPendingRedirect = await _getAndClearPendingRedirectStatus(\n          this.resolver,\n          this.auth\n        );\n        const result = hasPendingRedirect ? await super.execute() : null;\n        readyOutcome = () => Promise.resolve(result);\n      } catch (e) {\n        readyOutcome = () => Promise.reject(e);\n      }\n\n      redirectOutcomeMap.set(this.auth._key(), readyOutcome);\n    }\n\n    // If we're not bypassing auth state, the ready outcome should be set to\n    // null.\n    if (!this.bypassAuthState) {\n      redirectOutcomeMap.set(this.auth._key(), () => Promise.resolve(null));\n    }\n\n    return readyOutcome();\n  }\n\n  async onAuthEvent(event: AuthEvent): Promise<void> {\n    if (event.type === AuthEventType.SIGN_IN_VIA_REDIRECT) {\n      return super.onAuthEvent(event);\n    } else if (event.type === AuthEventType.UNKNOWN) {\n      // This is a sentinel value indicating there's no pending redirect\n      this.resolve(null);\n      return;\n    }\n\n    if (event.eventId) {\n      const user = await this.auth._redirectUserForId(event.eventId);\n      if (user) {\n        this.user = user;\n        return super.onAuthEvent(event);\n      } else {\n        this.resolve(null);\n      }\n    }\n  }\n\n  async onExecution(): Promise<void> {}\n\n  cleanUp(): void {}\n}\n\nexport async function _getAndClearPendingRedirectStatus(\n  resolver: PopupRedirectResolverInternal,\n  auth: AuthInternal\n): Promise<boolean> {\n  const key = pendingRedirectKey(auth);\n  const persistence = resolverPersistence(resolver);\n  if (!(await persistence._isAvailable())) {\n    return false;\n  }\n  const hasPendingRedirect =\n    (await persistence._get(key)) === 'true';\n  await persistence._remove(key);\n  return hasPendingRedirect;\n}\n\nexport async function _setPendingRedirectStatus(\n  resolver: PopupRedirectResolverInternal,\n  auth: AuthInternal\n): Promise<void> {\n  return resolverPersistence(resolver)._set(pendingRedirectKey(auth), 'true');\n}\n\nexport function _clearRedirectOutcomes(): void {\n  redirectOutcomeMap.clear();\n}\n\nexport function _overrideRedirectResult(auth: AuthInternal, result: () => Promise<UserCredentialInternal | null>): void {\n  redirectOutcomeMap.set(auth._key(), result);\n}\n\nfunction resolverPersistence(\n  resolver: PopupRedirectResolverInternal\n): PersistenceInternal {\n  return _getInstance(resolver._redirectPersistence);\n}\n\nfunction pendingRedirectKey(auth: AuthInternal): string {\n  return _persistenceKeyName(\n    PENDING_REDIRECT_KEY,\n    auth.config.apiKey,\n    auth.name\n  );\n}\n","/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport {\n  Auth,\n  AuthProvider,\n  PopupRedirectResolver,\n  User,\n  UserCredential\n} from '../../model/public_types';\n\nimport { _castAuth } from '../../core/auth/auth_impl';\nimport { _assertLinkedStatus } from '../../core/user/link_unlink';\nimport { _assertInstanceOf } from '../../core/util/assert';\nimport { _generateEventId } from '../../core/util/event_id';\nimport { AuthEventType } from '../../model/popup_redirect';\nimport { UserInternal } from '../../model/user';\nimport { _withDefaultResolver } from '../../core/util/resolver';\nimport {\n  RedirectAction,\n  _setPendingRedirectStatus\n} from '../../core/strategies/redirect';\nimport { FederatedAuthProvider } from '../../core/providers/federated';\nimport { getModularInstance } from '@firebase/util';\n\n/**\n * Authenticates a Firebase client using a full-page redirect flow.\n *\n * @remarks\n * To handle the results and errors for this operation, refer to {@link getRedirectResult}.\n *\n * @example\n * ```javascript\n * // Sign in using a redirect.\n * const provider = new FacebookAuthProvider();\n * // You can add additional scopes to the provider:\n * provider.addScope('user_birthday');\n * // Start a sign in process for an unauthenticated user.\n * await signInWithRedirect(auth, provider);\n * // This will trigger a full page redirect away from your app\n *\n * // After returning from the redirect when your app initializes you can obtain the result\n * const result = await getRedirectResult(auth);\n * if (result) {\n *   // This is the signed-in user\n *   const user = result.user;\n *   // This gives you a Facebook Access Token.\n *   const credential = provider.credentialFromResult(auth, result);\n *   const token = credential.accessToken;\n * }\n * // As this API can be used for sign-in, linking and reauthentication,\n * // check the operationType to determine what triggered this redirect\n * // operation.\n * const operationType = result.operationType;\n * ```\n *\n * @param auth - The {@link Auth} instance.\n * @param provider - The provider to authenticate. The provider has to be an {@link OAuthProvider}.\n * Non-OAuth providers like {@link EmailAuthProvider} will throw an error.\n * @param resolver - An instance of {@link PopupRedirectResolver}, optional\n * if already supplied to {@link initializeAuth} or provided by {@link getAuth}.\n *\n * @public\n */\nexport function signInWithRedirect(\n  auth: Auth,\n  provider: AuthProvider,\n  resolver?: PopupRedirectResolver\n): Promise<never> {\n  return _signInWithRedirect(auth, provider, resolver) as Promise<never>;\n}\n\nexport async function _signInWithRedirect(\n  auth: Auth,\n  provider: AuthProvider,\n  resolver?: PopupRedirectResolver\n): Promise<void | never> {\n  const authInternal = _castAuth(auth);\n  _assertInstanceOf(auth, provider, FederatedAuthProvider);\n  const resolverInternal = _withDefaultResolver(authInternal, resolver);\n  await _setPendingRedirectStatus(resolverInternal, authInternal);\n\n  return resolverInternal._openRedirect(\n    authInternal,\n    provider,\n    AuthEventType.SIGN_IN_VIA_REDIRECT\n  );\n}\n\n/**\n * Reauthenticates the current user with the specified {@link OAuthProvider} using a full-page redirect flow.\n *\n * @example\n * ```javascript\n * // Sign in using a redirect.\n * const provider = new FacebookAuthProvider();\n * const result = await signInWithRedirect(auth, provider);\n * // This will trigger a full page redirect away from your app\n *\n * // After returning from the redirect when your app initializes you can obtain the result\n * const result = await getRedirectResult(auth);\n * // Link using a redirect.\n * await linkWithRedirect(result.user, provider);\n * // This will again trigger a full page redirect away from your app\n *\n * // After returning from the redirect when your app initializes you can obtain the result\n * const result = await getRedirectResult(auth);\n * ```\n *\n * @param user - The user.\n * @param provider - The provider to authenticate. The provider has to be an {@link OAuthProvider}.\n * Non-OAuth providers like {@link EmailAuthProvider} will throw an error.\n * @param resolver - An instance of {@link PopupRedirectResolver}, optional\n * if already supplied to {@link initializeAuth} or provided by {@link getAuth}.\n *\n * @public\n */\nexport function reauthenticateWithRedirect(\n  user: User,\n  provider: AuthProvider,\n  resolver?: PopupRedirectResolver\n): Promise<never> {\n  return _reauthenticateWithRedirect(\n    user,\n    provider,\n    resolver\n  ) as Promise<never>;\n}\nexport async function _reauthenticateWithRedirect(\n  user: User,\n  provider: AuthProvider,\n  resolver?: PopupRedirectResolver\n): Promise<void | never> {\n  const userInternal = getModularInstance(user) as UserInternal;\n  _assertInstanceOf(userInternal.auth, provider, FederatedAuthProvider);\n  // Allow the resolver to error before persisting the redirect user\n  const resolverInternal = _withDefaultResolver(userInternal.auth, resolver);\n  await _setPendingRedirectStatus(resolverInternal, userInternal.auth);\n\n  const eventId = await prepareUserForRedirect(userInternal);\n  return resolverInternal._openRedirect(\n    userInternal.auth,\n    provider,\n    AuthEventType.REAUTH_VIA_REDIRECT,\n    eventId\n  );\n}\n\n/**\n * Links the {@link OAuthProvider} to the user account using a full-page redirect flow.\n *\n * @example\n * ```javascript\n * // Sign in using some other provider.\n * const result = await signInWithEmailAndPassword(auth, email, password);\n * // Link using a redirect.\n * const provider = new FacebookAuthProvider();\n * await linkWithRedirect(result.user, provider);\n * // This will trigger a full page redirect away from your app\n *\n * // After returning from the redirect when your app initializes you can obtain the result\n * const result = await getRedirectResult(auth);\n * ```\n *\n * @param user - The user.\n * @param provider - The provider to authenticate. The provider has to be an {@link OAuthProvider}.\n * Non-OAuth providers like {@link EmailAuthProvider} will throw an error.\n * @param resolver - An instance of {@link PopupRedirectResolver}, optional\n * if already supplied to {@link initializeAuth} or provided by {@link getAuth}.\n *\n *\n * @public\n */\nexport function linkWithRedirect(\n  user: User,\n  provider: AuthProvider,\n  resolver?: PopupRedirectResolver\n): Promise<never> {\n  return _linkWithRedirect(user, provider, resolver) as Promise<never>;\n}\nexport async function _linkWithRedirect(\n  user: User,\n  provider: AuthProvider,\n  resolver?: PopupRedirectResolver\n): Promise<void | never> {\n  const userInternal = getModularInstance(user) as UserInternal;\n  _assertInstanceOf(userInternal.auth, provider, FederatedAuthProvider);\n  // Allow the resolver to error before persisting the redirect user\n  const resolverInternal = _withDefaultResolver(userInternal.auth, resolver);\n  await _assertLinkedStatus(false, userInternal, provider.providerId);\n  await _setPendingRedirectStatus(resolverInternal, userInternal.auth);\n\n  const eventId = await prepareUserForRedirect(userInternal);\n  return resolverInternal._openRedirect(\n    userInternal.auth,\n    provider,\n    AuthEventType.LINK_VIA_REDIRECT,\n    eventId\n  );\n}\n\n/**\n * Returns a {@link UserCredential} from the redirect-based sign-in flow.\n *\n * @remarks\n * If sign-in succeeded, returns the signed in user. If sign-in was unsuccessful, fails with an\n * error. If no redirect operation was called, returns a {@link UserCredential}\n * with a null `user`.\n *\n * @example\n * ```javascript\n * // Sign in using a redirect.\n * const provider = new FacebookAuthProvider();\n * // You can add additional scopes to the provider:\n * provider.addScope('user_birthday');\n * // Start a sign in process for an unauthenticated user.\n * await signInWithRedirect(auth, provider);\n * // This will trigger a full page redirect away from your app\n *\n * // After returning from the redirect when your app initializes you can obtain the result\n * const result = await getRedirectResult(auth);\n * if (result) {\n *   // This is the signed-in user\n *   const user = result.user;\n *   // This gives you a Facebook Access Token.\n *   const credential = provider.credentialFromResult(auth, result);\n *   const token = credential.accessToken;\n * }\n * // As this API can be used for sign-in, linking and reauthentication,\n * // check the operationType to determine what triggered this redirect\n * // operation.\n * const operationType = result.operationType;\n * ```\n *\n * @param auth - The {@link Auth} instance.\n * @param resolver - An instance of {@link PopupRedirectResolver}, optional\n * if already supplied to {@link initializeAuth} or provided by {@link getAuth}.\n *\n * @public\n */\nexport async function getRedirectResult(\n  auth: Auth,\n  resolver?: PopupRedirectResolver\n): Promise<UserCredential | null> {\n  await _castAuth(auth)._initializationPromise;\n  return _getRedirectResult(auth, resolver, false);\n}\n\nexport async function _getRedirectResult(\n  auth: Auth,\n  resolverExtern?: PopupRedirectResolver,\n  bypassAuthState = false\n): Promise<UserCredential | null> {\n  const authInternal = _castAuth(auth);\n  const resolver = _withDefaultResolver(authInternal, resolverExtern);\n  const action = new RedirectAction(authInternal, resolver, bypassAuthState);\n  const result = await action.execute();\n\n  if (result && !bypassAuthState) {\n    delete result.user._redirectEventId;\n    await authInternal._persistUserIfCurrent(result.user as UserInternal);\n    await authInternal._setRedirectUser(null, resolverExtern);\n  }\n\n  return result;\n}\n\nasync function prepareUserForRedirect(user: UserInternal): Promise<string> {\n  const eventId = _generateEventId(`${user.uid}:::`);\n  user._redirectEventId = eventId;\n  await user.auth._setRedirectUser(user);\n  await user.auth._persistUserIfCurrent(user);\n  return eventId;\n}\n","/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport {\n  AuthEvent,\n  AuthEventConsumer,\n  AuthEventType,\n  EventManager\n} from '../../model/popup_redirect';\nimport { AuthErrorCode } from '../errors';\nimport { AuthInternal } from '../../model/auth';\nimport { _createError } from '../util/assert';\n\n// The amount of time to store the UIDs of seen events; this is\n// set to 10 min by default\nconst EVENT_DUPLICATION_CACHE_DURATION_MS = 10 * 60 * 1000;\n\nexport class AuthEventManager implements EventManager {\n  private readonly cachedEventUids: Set<string> = new Set();\n  private readonly consumers: Set<AuthEventConsumer> = new Set();\n  protected queuedRedirectEvent: AuthEvent | null = null;\n  protected hasHandledPotentialRedirect = false;\n  private lastProcessedEventTime = Date.now();\n\n  constructor(private readonly auth: AuthInternal) {}\n\n  registerConsumer(authEventConsumer: AuthEventConsumer): void {\n    this.consumers.add(authEventConsumer);\n\n    if (\n      this.queuedRedirectEvent &&\n      this.isEventForConsumer(this.queuedRedirectEvent, authEventConsumer)\n    ) {\n      this.sendToConsumer(this.queuedRedirectEvent, authEventConsumer);\n      this.saveEventToCache(this.queuedRedirectEvent);\n      this.queuedRedirectEvent = null;\n    }\n  }\n\n  unregisterConsumer(authEventConsumer: AuthEventConsumer): void {\n    this.consumers.delete(authEventConsumer);\n  }\n\n  onEvent(event: AuthEvent): boolean {\n    // Check if the event has already been handled\n    if (this.hasEventBeenHandled(event)) {\n      return false;\n    }\n\n    let handled = false;\n    this.consumers.forEach(consumer => {\n      if (this.isEventForConsumer(event, consumer)) {\n        handled = true;\n        this.sendToConsumer(event, consumer);\n        this.saveEventToCache(event);\n      }\n    });\n\n    if (this.hasHandledPotentialRedirect || !isRedirectEvent(event)) {\n      // If we've already seen a redirect before, or this is a popup event,\n      // bail now\n      return handled;\n    }\n\n    this.hasHandledPotentialRedirect = true;\n\n    // If the redirect wasn't handled, hang on to it\n    if (!handled) {\n      this.queuedRedirectEvent = event;\n      handled = true;\n    }\n\n    return handled;\n  }\n\n  private sendToConsumer(event: AuthEvent, consumer: AuthEventConsumer): void {\n    if (event.error && !isNullRedirectEvent(event)) {\n      const code =\n        (event.error.code?.split('auth/')[1] as AuthErrorCode) ||\n        AuthErrorCode.INTERNAL_ERROR;\n      consumer.onError(_createError(this.auth, code));\n    } else {\n      consumer.onAuthEvent(event);\n    }\n  }\n\n  private isEventForConsumer(\n    event: AuthEvent,\n    consumer: AuthEventConsumer\n  ): boolean {\n    const eventIdMatches =\n      consumer.eventId === null ||\n      (!!event.eventId && event.eventId === consumer.eventId);\n    return consumer.filter.includes(event.type) && eventIdMatches;\n  }\n\n  private hasEventBeenHandled(event: AuthEvent): boolean {\n    if (\n      Date.now() - this.lastProcessedEventTime >=\n      EVENT_DUPLICATION_CACHE_DURATION_MS\n    ) {\n      this.cachedEventUids.clear();\n    }\n\n    return this.cachedEventUids.has(eventUid(event));\n  }\n\n  private saveEventToCache(event: AuthEvent): void {\n    this.cachedEventUids.add(eventUid(event));\n    this.lastProcessedEventTime = Date.now();\n  }\n}\n\nfunction eventUid(e: AuthEvent): string {\n  return [e.type, e.eventId, e.sessionId, e.tenantId].filter(v => v).join('-');\n}\n\nfunction isNullRedirectEvent({ type, error }: AuthEvent): boolean {\n  return (\n    type === AuthEventType.UNKNOWN &&\n    error?.code === `auth/${AuthErrorCode.NO_AUTH_EVENT}`\n  );\n}\n\nfunction isRedirectEvent(event: AuthEvent): boolean {\n  switch (event.type) {\n    case AuthEventType.SIGN_IN_VIA_REDIRECT:\n    case AuthEventType.LINK_VIA_REDIRECT:\n    case AuthEventType.REAUTH_VIA_REDIRECT:\n      return true;\n    case AuthEventType.UNKNOWN:\n      return isNullRedirectEvent(event);\n    default:\n      return false;\n  }\n}\n","/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { _performApiRequest, Endpoint, HttpMethod } from '../index';\nimport { Auth } from '../../model/public_types';\n\nexport interface GetProjectConfigRequest {\n  androidPackageName?: string;\n  iosBundleId?: string;\n}\n\nexport interface GetProjectConfigResponse {\n  authorizedDomains: string[];\n}\n\nexport async function _getProjectConfig(\n  auth: Auth,\n  request: GetProjectConfigRequest = {}\n): Promise<GetProjectConfigResponse> {\n  return _performApiRequest<GetProjectConfigRequest, GetProjectConfigResponse>(\n    auth,\n    HttpMethod.GET,\n    Endpoint.GET_PROJECT_CONFIG,\n    request\n  );\n}\n","/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { _getProjectConfig } from '../../api/project_config/get_project_config';\nimport { AuthInternal } from '../../model/auth';\nimport { AuthErrorCode } from '../errors';\nimport { _fail } from './assert';\nimport { _getCurrentUrl } from './location';\n\nconst IP_ADDRESS_REGEX = /^\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}$/;\nconst HTTP_REGEX = /^https?/;\n\nexport async function _validateOrigin(auth: AuthInternal): Promise<void> {\n  // Skip origin validation if we are in an emulated environment\n  if (auth.config.emulator) {\n    return;\n  }\n\n  const { authorizedDomains } = await _getProjectConfig(auth);\n\n  for (const domain of authorizedDomains) {\n    try {\n      if (matchDomain(domain)) {\n        return;\n      }\n    } catch {\n      // Do nothing if there's a URL error; just continue searching\n    }\n  }\n\n  // In the old SDK, this error also provides helpful messages.\n  _fail(auth, AuthErrorCode.INVALID_ORIGIN);\n}\n\nfunction matchDomain(expected: string): boolean {\n  const currentUrl = _getCurrentUrl();\n  const { protocol, hostname } = new URL(currentUrl);\n  if (expected.startsWith('chrome-extension://')) {\n    const ceUrl = new URL(expected);\n\n    if (ceUrl.hostname === '' && hostname === '') {\n      // For some reason we're not parsing chrome URLs properly\n      return (\n        protocol === 'chrome-extension:' &&\n        expected.replace('chrome-extension://', '') ===\n          currentUrl.replace('chrome-extension://', '')\n      );\n    }\n\n    return protocol === 'chrome-extension:' && ceUrl.hostname === hostname;\n  }\n\n  if (!HTTP_REGEX.test(protocol)) {\n    return false;\n  }\n\n  if (IP_ADDRESS_REGEX.test(expected)) {\n    // The domain has to be exactly equal to the pattern, as an IP domain will\n    // only contain the IP, no extra character.\n    return hostname === expected;\n  }\n\n  // Dots in pattern should be escaped.\n  const escapedDomainPattern = expected.replace(/\\./g, '\\\\.');\n  // Non ip address domains.\n  // domain.com = *.domain.com OR domain.com\n  const re = new RegExp(\n    '^(.+\\\\.' + escapedDomainPattern + '|' + escapedDomainPattern + ')$',\n    'i'\n  );\n  return re.test(hostname);\n}\n","/**\n * @license\n * Copyright 2020 Google LLC.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { AuthErrorCode } from '../../core/errors';\nimport { _createError } from '../../core/util/assert';\nimport { Delay } from '../../core/util/delay';\nimport { AuthInternal } from '../../model/auth';\nimport { _window } from '../auth_window';\nimport * as js from '../load_js';\n\nconst NETWORK_TIMEOUT = new Delay(30000, 60000);\n\n/**\n * Reset unlaoded GApi modules. If gapi.load fails due to a network error,\n * it will stop working after a retrial. This is a hack to fix this issue.\n */\nfunction resetUnloadedGapiModules(): void {\n  // Clear last failed gapi.load state to force next gapi.load to first\n  // load the failed gapi.iframes module.\n  // Get gapix.beacon context.\n  const beacon = _window().___jsl;\n  // Get current hint.\n  if (beacon?.H) {\n    // Get gapi hint.\n    for (const hint of Object.keys(beacon.H)) {\n      // Requested modules.\n      beacon.H[hint].r = beacon.H[hint].r || [];\n      // Loaded modules.\n      beacon.H[hint].L = beacon.H[hint].L || [];\n      // Set requested modules to a copy of the loaded modules.\n      beacon.H[hint].r = [...beacon.H[hint].L];\n      // Clear pending callbacks.\n      if (beacon.CP) {\n        for (let i = 0; i < beacon.CP.length; i++) {\n          // Remove all failed pending callbacks.\n          beacon.CP[i] = null;\n        }\n      }\n    }\n  }\n}\n\nfunction loadGapi(auth: AuthInternal): Promise<gapi.iframes.Context> {\n  return new Promise<gapi.iframes.Context>((resolve, reject) => {\n    // Function to run when gapi.load is ready.\n    function loadGapiIframe(): void {\n      // The developer may have tried to previously run gapi.load and failed.\n      // Run this to fix that.\n      resetUnloadedGapiModules();\n      gapi.load('gapi.iframes', {\n        callback: () => {\n          resolve(gapi.iframes.getContext());\n        },\n        ontimeout: () => {\n          // The above reset may be sufficient, but having this reset after\n          // failure ensures that if the developer calls gapi.load after the\n          // connection is re-established and before another attempt to embed\n          // the iframe, it would work and would not be broken because of our\n          // failed attempt.\n          // Timeout when gapi.iframes.Iframe not loaded.\n          resetUnloadedGapiModules();\n          reject(_createError(auth, AuthErrorCode.NETWORK_REQUEST_FAILED));\n        },\n        timeout: NETWORK_TIMEOUT.get()\n      });\n    }\n\n    if (_window().gapi?.iframes?.Iframe) {\n      // If gapi.iframes.Iframe available, resolve.\n      resolve(gapi.iframes.getContext());\n    } else if (!!_window().gapi?.load) {\n      // Gapi loader ready, load gapi.iframes.\n      loadGapiIframe();\n    } else {\n      // Create a new iframe callback when this is called so as not to overwrite\n      // any previous defined callback. This happens if this method is called\n      // multiple times in parallel and could result in the later callback\n      // overwriting the previous one. This would end up with a iframe\n      // timeout.\n      const cbName = js._generateCallbackName('iframefcb');\n      // GApi loader not available, dynamically load platform.js.\n      _window()[cbName] = () => {\n        // GApi loader should be ready.\n        if (!!gapi.load) {\n          loadGapiIframe();\n        } else {\n          // Gapi loader failed, throw error.\n          reject(_createError(auth, AuthErrorCode.NETWORK_REQUEST_FAILED));\n        }\n      };\n      // Load GApi loader.\n      return js._loadJS(`https://apis.google.com/js/api.js?onload=${cbName}`).catch(e => reject(e));\n    }\n  }).catch(error => {\n    // Reset cached promise to allow for retrial.\n    cachedGApiLoader = null;\n    throw error;\n  });\n}\n\nlet cachedGApiLoader: Promise<gapi.iframes.Context> | null = null;\nexport function _loadGapi(auth: AuthInternal): Promise<gapi.iframes.Context> {\n  cachedGApiLoader = cachedGApiLoader || loadGapi(auth);\n  return cachedGApiLoader;\n}\n\nexport function _resetLoader(): void {\n  cachedGApiLoader = null;\n}\n","/**\n * @license\n * Copyright 2020 Google LLC.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { SDK_VERSION } from '@firebase/app';\nimport { querystring } from '@firebase/util';\nimport { DefaultConfig } from '../../../internal';\n\nimport { AuthErrorCode } from '../../core/errors';\nimport { _assert, _createError } from '../../core/util/assert';\nimport { Delay } from '../../core/util/delay';\nimport { _emulatorUrl } from '../../core/util/emulator';\nimport { AuthInternal } from '../../model/auth';\nimport { _window } from '../auth_window';\nimport * as gapiLoader from './gapi';\n\nconst PING_TIMEOUT = new Delay(5000, 15000);\nconst IFRAME_PATH = '__/auth/iframe';\nconst EMULATED_IFRAME_PATH = 'emulator/auth/iframe';\n\nconst IFRAME_ATTRIBUTES = {\n  style: {\n    position: 'absolute',\n    top: '-100px',\n    width: '1px',\n    height: '1px'\n  },\n  'aria-hidden': 'true',\n  tabindex: '-1'\n};\n\n// Map from apiHost to endpoint ID for passing into iframe. In current SDK, apiHost can be set to\n// anything (not from a list of endpoints with IDs as in legacy), so this is the closest we can get.\nconst EID_FROM_APIHOST = new Map([\n  [DefaultConfig.API_HOST, 'p'], // production\n  ['staging-identitytoolkit.sandbox.googleapis.com', 's'], // staging\n  ['test-identitytoolkit.sandbox.googleapis.com', 't'] // test\n]);\n\nfunction getIframeUrl(auth: AuthInternal): string {\n  const config = auth.config;\n  _assert(config.authDomain, auth, AuthErrorCode.MISSING_AUTH_DOMAIN);\n  const url = config.emulator\n    ? _emulatorUrl(config, EMULATED_IFRAME_PATH)\n    : `https://${auth.config.authDomain}/${IFRAME_PATH}`;\n\n  const params: Record<string, string> = {\n    apiKey: config.apiKey,\n    appName: auth.name,\n    v: SDK_VERSION\n  };\n  const eid = EID_FROM_APIHOST.get(auth.config.apiHost);\n  if (eid) {\n    params.eid = eid;\n  }\n  const frameworks = auth._getFrameworks();\n  if (frameworks.length) {\n    params.fw = frameworks.join(',');\n  }\n  return `${url}?${querystring(params).slice(1)}`;\n}\n\nexport async function _openIframe(\n  auth: AuthInternal\n): Promise<gapi.iframes.Iframe> {\n  const context = await gapiLoader._loadGapi(auth);\n  const gapi = _window().gapi;\n  _assert(gapi, auth, AuthErrorCode.INTERNAL_ERROR);\n  return context.open(\n    {\n      where: document.body,\n      url: getIframeUrl(auth),\n      messageHandlersFilter: gapi.iframes.CROSS_ORIGIN_IFRAMES_FILTER,\n      attributes: IFRAME_ATTRIBUTES,\n      dontclear: true\n    },\n    (iframe: gapi.iframes.Iframe) =>\n      new Promise(async (resolve, reject) => {\n        await iframe.restyle({\n          // Prevent iframe from closing on mouse out.\n          setHideOnLeave: false\n        });\n\n        const networkError = _createError(\n          auth,\n          AuthErrorCode.NETWORK_REQUEST_FAILED\n        );\n        // Confirm iframe is correctly loaded.\n        // To fallback on failure, set a timeout.\n        const networkErrorTimer = _window().setTimeout(() => {\n          reject(networkError);\n        }, PING_TIMEOUT.get());\n        // Clear timer and resolve pending iframe ready promise.\n        function clearTimerAndResolve(): void {\n          _window().clearTimeout(networkErrorTimer);\n          resolve(iframe);\n        }\n        // This returns an IThenable. However the reject part does not call\n        // when the iframe is not loaded.\n        iframe.ping(clearTimerAndResolve).then(clearTimerAndResolve, () => {\n          reject(networkError);\n        });\n      })\n  );\n}\n","/**\n * @license\n * Copyright 2020 Google LLC.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { getUA } from '@firebase/util';\n\nimport { AuthErrorCode } from '../../core/errors';\nimport { _assert } from '../../core/util/assert';\nimport {\n  _isChromeIOS,\n  _isFirefox,\n  _isIOSStandalone\n} from '../../core/util/browser';\nimport { AuthInternal } from '../../model/auth';\n\nconst BASE_POPUP_OPTIONS = {\n  location: 'yes',\n  resizable: 'yes',\n  statusbar: 'yes',\n  toolbar: 'no'\n};\n\nconst DEFAULT_WIDTH = 500;\nconst DEFAULT_HEIGHT = 600;\nconst TARGET_BLANK = '_blank';\n\nconst FIREFOX_EMPTY_URL = 'http://localhost';\n\nexport class AuthPopup {\n  associatedEvent: string | null = null;\n\n  constructor(readonly window: Window | null) {}\n\n  close(): void {\n    if (this.window) {\n      try {\n        this.window.close();\n      } catch (e) {}\n    }\n  }\n}\n\nexport function _open(\n  auth: AuthInternal,\n  url?: string,\n  name?: string,\n  width = DEFAULT_WIDTH,\n  height = DEFAULT_HEIGHT\n): AuthPopup {\n  const top = Math.max((window.screen.availHeight - height) / 2, 0).toString();\n  const left = Math.max((window.screen.availWidth - width) / 2, 0).toString();\n  let target = '';\n\n  const options: { [key: string]: string } = {\n    ...BASE_POPUP_OPTIONS,\n    width: width.toString(),\n    height: height.toString(),\n    top,\n    left\n  };\n\n  // Chrome iOS 7 and 8 is returning an undefined popup win when target is\n  // specified, even though the popup is not necessarily blocked.\n  const ua = getUA().toLowerCase();\n\n  if (name) {\n    target = _isChromeIOS(ua) ? TARGET_BLANK : name;\n  }\n\n  if (_isFirefox(ua)) {\n    // Firefox complains when invalid URLs are popped out. Hacky way to bypass.\n    url = url || FIREFOX_EMPTY_URL;\n    // Firefox disables by default scrolling on popup windows, which can create\n    // issues when the user has many Google accounts, for instance.\n    options.scrollbars = 'yes';\n  }\n\n  const optionsString = Object.entries(options).reduce(\n    (accum, [key, value]) => `${accum}${key}=${value},`,\n    ''\n  );\n\n  if (_isIOSStandalone(ua) && target !== '_self') {\n    openAsNewWindowIOS(url || '', target);\n    return new AuthPopup(null);\n  }\n\n  // about:blank getting sanitized causing browsers like IE/Edge to display\n  // brief error message before redirecting to handler.\n  const newWin = window.open(url || '', target, optionsString);\n  _assert(newWin, auth, AuthErrorCode.POPUP_BLOCKED);\n\n  // Flaky on IE edge, encapsulate with a try and catch.\n  try {\n    newWin.focus();\n  } catch (e) {}\n\n  return new AuthPopup(newWin);\n}\n\nfunction openAsNewWindowIOS(url: string, target: string): void {\n  const el = document.createElement('a');\n  el.href = url;\n  el.target = target;\n  const click = document.createEvent('MouseEvent');\n  click.initMouseEvent(\n    'click',\n    true,\n    true,\n    window,\n    1,\n    0,\n    0,\n    0,\n    0,\n    false,\n    false,\n    false,\n    false,\n    1,\n    null\n  );\n  el.dispatchEvent(click);\n}\n","/**\n * @license\n * Copyright 2021 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { SDK_VERSION } from '@firebase/app';\nimport { AuthProvider } from '../../model/public_types';\nimport { ApiKey, AppName, AuthInternal } from '../../model/auth';\nimport { AuthEventType } from '../../model/popup_redirect';\nimport { AuthErrorCode } from '../errors';\nimport { _assert } from './assert';\nimport { isEmpty, querystring } from '@firebase/util';\nimport { _emulatorUrl } from './emulator';\nimport { FederatedAuthProvider } from '../providers/federated';\nimport { BaseOAuthProvider } from '../providers/oauth';\n\n/**\n * URL for Authentication widget which will initiate the OAuth handshake\n *\n * @internal\n */\nconst WIDGET_PATH = '__/auth/handler';\n\n/**\n * URL for emulated environment\n *\n * @internal\n */\nconst EMULATOR_WIDGET_PATH = 'emulator/auth/handler';\n\n// eslint-disable-next-line @typescript-eslint/consistent-type-definitions\ntype WidgetParams = {\n  apiKey: ApiKey;\n  appName: AppName;\n  authType: AuthEventType;\n  redirectUrl?: string;\n  v: string;\n  providerId?: string;\n  scopes?: string;\n  customParameters?: string;\n  eventId?: string;\n  tid?: string;\n} & { [key: string]: string | undefined };\n\nexport function _getRedirectUrl(\n  auth: AuthInternal,\n  provider: AuthProvider,\n  authType: AuthEventType,\n  redirectUrl?: string,\n  eventId?: string,\n  additionalParams?: Record<string, string>\n): string {\n  _assert(auth.config.authDomain, auth, AuthErrorCode.MISSING_AUTH_DOMAIN);\n  _assert(auth.config.apiKey, auth, AuthErrorCode.INVALID_API_KEY);\n\n  const params: WidgetParams = {\n    apiKey: auth.config.apiKey,\n    appName: auth.name,\n    authType,\n    redirectUrl,\n    v: SDK_VERSION,\n    eventId\n  };\n\n  if (provider instanceof FederatedAuthProvider) {\n    provider.setDefaultLanguage(auth.languageCode);\n    params.providerId = provider.providerId || '';\n    if (!isEmpty(provider.getCustomParameters())) {\n      params.customParameters = JSON.stringify(provider.getCustomParameters());\n    }\n\n    // TODO set additionalParams from the provider as well?\n    for (const [key, value] of Object.entries(additionalParams || {})) {\n      params[key] = value;\n    }\n  }\n\n  if (provider instanceof BaseOAuthProvider) {\n    const scopes = provider.getScopes().filter(scope => scope !== '');\n    if (scopes.length > 0) {\n      params.scopes = scopes.join(',');\n    }\n  }\n\n  if (auth.tenantId) {\n    params.tid = auth.tenantId;\n  }\n\n  // TODO: maybe set eid as endipointId\n  // TODO: maybe set fw as Frameworks.join(\",\")\n\n  const paramsDict = params as Record<string, string | number>;\n  for (const key of Object.keys(paramsDict)) {\n    if (paramsDict[key] === undefined) {\n      delete paramsDict[key];\n    }\n  }\n  return `${getHandlerBase(auth)}?${querystring(paramsDict).slice(1)}`;\n}\n\nfunction getHandlerBase({ config }: AuthInternal): string {\n  if (!config.emulator) {\n    return `https://${config.authDomain}/${WIDGET_PATH}`;\n  }\n\n  return _emulatorUrl(config, EMULATOR_WIDGET_PATH);\n}\n","/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { AuthProvider, PopupRedirectResolver } from '../model/public_types';\n\nimport { AuthEventManager } from '../core/auth/auth_event_manager';\nimport { AuthErrorCode } from '../core/errors';\nimport { _assert, debugAssert, _fail } from '../core/util/assert';\nimport { _generateEventId } from '../core/util/event_id';\nimport { _getCurrentUrl } from '../core/util/location';\nimport { _validateOrigin } from '../core/util/validate_origin';\nimport { AuthInternal } from '../model/auth';\nimport {\n  AuthEventType,\n  EventManager,\n  GapiAuthEvent,\n  GapiOutcome,\n  PopupRedirectResolverInternal\n} from '../model/popup_redirect';\nimport { _setWindowLocation } from './auth_window';\nimport { _openIframe } from './iframe/iframe';\nimport { browserSessionPersistence } from './persistence/session_storage';\nimport { _open, AuthPopup } from './util/popup';\nimport { _getRedirectResult } from './strategies/redirect';\nimport { _getRedirectUrl } from '../core/util/handler';\nimport { _isIOS, _isMobileBrowser, _isSafari } from '../core/util/browser';\nimport { _overrideRedirectResult } from '../core/strategies/redirect';\n\n/**\n * The special web storage event\n *\n */\nconst WEB_STORAGE_SUPPORT_KEY = 'webStorageSupport';\n\ninterface WebStorageSupportMessage extends gapi.iframes.Message {\n  [index: number]: Record<string, boolean>;\n}\n\ninterface ManagerOrPromise {\n  manager?: EventManager;\n  promise?: Promise<EventManager>;\n}\n\nclass BrowserPopupRedirectResolver implements PopupRedirectResolverInternal {\n  private readonly eventManagers: Record<string, ManagerOrPromise> = {};\n  private readonly iframes: Record<string, gapi.iframes.Iframe> = {};\n  private readonly originValidationPromises: Record<string, Promise<void>> = {};\n\n  readonly _redirectPersistence = browserSessionPersistence;\n\n  // Wrapping in async even though we don't await anywhere in order\n  // to make sure errors are raised as promise rejections\n  async _openPopup(\n    auth: AuthInternal,\n    provider: AuthProvider,\n    authType: AuthEventType,\n    eventId?: string\n  ): Promise<AuthPopup> {\n    debugAssert(\n      this.eventManagers[auth._key()]?.manager,\n      '_initialize() not called before _openPopup()'\n    );\n\n    const url = _getRedirectUrl(\n      auth,\n      provider,\n      authType,\n      _getCurrentUrl(),\n      eventId\n    );\n    return _open(auth, url, _generateEventId());\n  }\n\n  async _openRedirect(\n    auth: AuthInternal,\n    provider: AuthProvider,\n    authType: AuthEventType,\n    eventId?: string\n  ): Promise<never> {\n    await this._originValidation(auth);\n    _setWindowLocation(\n      _getRedirectUrl(auth, provider, authType, _getCurrentUrl(), eventId)\n    );\n    return new Promise(() => {});\n  }\n\n  _initialize(auth: AuthInternal): Promise<EventManager> {\n    const key = auth._key();\n    if (this.eventManagers[key]) {\n      const { manager, promise } = this.eventManagers[key];\n      if (manager) {\n        return Promise.resolve(manager);\n      } else {\n        debugAssert(promise, 'If manager is not set, promise should be');\n        return promise;\n      }\n    }\n\n    const promise = this.initAndGetManager(auth);\n    this.eventManagers[key] = { promise };\n\n    // If the promise is rejected, the key should be removed so that the\n    // operation can be retried later.\n    promise.catch(() => {\n      delete this.eventManagers[key];\n    });\n\n    return promise;\n  }\n\n  private async initAndGetManager(auth: AuthInternal): Promise<EventManager> {\n    const iframe = await _openIframe(auth);\n    const manager = new AuthEventManager(auth);\n    iframe.register<GapiAuthEvent>(\n      'authEvent',\n      (iframeEvent: GapiAuthEvent | null) => {\n        _assert(iframeEvent?.authEvent, auth, AuthErrorCode.INVALID_AUTH_EVENT);\n        // TODO: Consider splitting redirect and popup events earlier on\n\n        const handled = manager.onEvent(iframeEvent.authEvent);\n        return { status: handled ? GapiOutcome.ACK : GapiOutcome.ERROR };\n      },\n      gapi.iframes.CROSS_ORIGIN_IFRAMES_FILTER\n    );\n\n    this.eventManagers[auth._key()] = { manager };\n    this.iframes[auth._key()] = iframe;\n    return manager;\n  }\n\n  _isIframeWebStorageSupported(\n    auth: AuthInternal,\n    cb: (supported: boolean) => unknown\n  ): void {\n    const iframe = this.iframes[auth._key()];\n    iframe.send<gapi.iframes.Message, WebStorageSupportMessage>(\n      WEB_STORAGE_SUPPORT_KEY,\n      { type: WEB_STORAGE_SUPPORT_KEY },\n      result => {\n        const isSupported = result?.[0]?.[WEB_STORAGE_SUPPORT_KEY];\n        if (isSupported !== undefined) {\n          cb(!!isSupported);\n        }\n\n        _fail(auth, AuthErrorCode.INTERNAL_ERROR);\n      },\n      gapi.iframes.CROSS_ORIGIN_IFRAMES_FILTER\n    );\n  }\n\n  _originValidation(auth: AuthInternal): Promise<void> {\n    const key = auth._key();\n    if (!this.originValidationPromises[key]) {\n      this.originValidationPromises[key] = _validateOrigin(auth);\n    }\n\n    return this.originValidationPromises[key];\n  }\n\n  get _shouldInitProactively(): boolean {\n    // Mobile browsers and Safari need to optimistically initialize\n    return _isMobileBrowser() || _isSafari() || _isIOS();\n  }\n\n  _completeRedirectFn = _getRedirectResult;\n\n  _overrideRedirectResult = _overrideRedirectResult;\n}\n\n/**\n * An implementation of {@link PopupRedirectResolver} suitable for browser\n * based applications.\n *\n * @public\n */\nexport const browserPopupRedirectResolver: PopupRedirectResolver = BrowserPopupRedirectResolver;\n","/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nimport { FactorId, MultiFactorAssertion } from '../model/public_types';\nimport { debugFail } from '../core/util/assert';\nimport { MultiFactorSessionImpl, MultiFactorSessionType } from './mfa_session';\nimport { FinalizeMfaResponse } from '../api/authentication/mfa';\nimport { AuthInternal } from '../model/auth';\n\nexport abstract class MultiFactorAssertionImpl implements MultiFactorAssertion {\n  protected constructor(readonly factorId: FactorId) {}\n\n  _process(\n    auth: AuthInternal,\n    session: MultiFactorSessionImpl,\n    displayName?: string | null\n  ): Promise<FinalizeMfaResponse> {\n    switch (session.type) {\n      case MultiFactorSessionType.ENROLL:\n        return this._finalizeEnroll(auth, session.credential, displayName);\n      case MultiFactorSessionType.SIGN_IN:\n        return this._finalizeSignIn(auth, session.credential);\n      default:\n        return debugFail('unexpected MultiFactorSessionType');\n    }\n  }\n\n  abstract _finalizeEnroll(\n    auth: AuthInternal,\n    idToken: string,\n    displayName?: string | null\n  ): Promise<FinalizeMfaResponse>;\n  abstract _finalizeSignIn(\n    auth: AuthInternal,\n    mfaPendingCredential: string\n  ): Promise<FinalizeMfaResponse>;\n}\n","/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\nimport {\n  FactorId,\n  PhoneMultiFactorAssertion\n} from '../../../model/public_types';\n\nimport { MultiFactorAssertionImpl } from '../../../mfa/mfa_assertion';\nimport { AuthInternal } from '../../../model/auth';\nimport { finalizeEnrollPhoneMfa } from '../../../api/account_management/mfa';\nimport { PhoneAuthCredential } from '../../../core/credentials/phone';\nimport {\n  finalizeSignInPhoneMfa,\n  FinalizeMfaResponse\n} from '../../../api/authentication/mfa';\n\n/**\n * {@inheritdoc PhoneMultiFactorAssertion}\n *\n * @public\n */\nexport class PhoneMultiFactorAssertionImpl\n  extends MultiFactorAssertionImpl\n  implements PhoneMultiFactorAssertion {\n  private constructor(private readonly credential: PhoneAuthCredential) {\n    super(FactorId.PHONE);\n  }\n\n  /** @internal */\n  static _fromCredential(\n    credential: PhoneAuthCredential\n  ): PhoneMultiFactorAssertionImpl {\n    return new PhoneMultiFactorAssertionImpl(credential);\n  }\n\n  /** @internal */\n  _finalizeEnroll(\n    auth: AuthInternal,\n    idToken: string,\n    displayName?: string | null\n  ): Promise<FinalizeMfaResponse> {\n    return finalizeEnrollPhoneMfa(auth, {\n      idToken,\n      displayName,\n      phoneVerificationInfo: this.credential._makeVerificationRequest()\n    });\n  }\n\n  /** @internal */\n  _finalizeSignIn(\n    auth: AuthInternal,\n    mfaPendingCredential: string\n  ): Promise<FinalizeMfaResponse> {\n    return finalizeSignInPhoneMfa(auth, {\n      mfaPendingCredential,\n      phoneVerificationInfo: this.credential._makeVerificationRequest()\n    });\n  }\n}\n\n/**\n * Provider for generating a {@link PhoneMultiFactorAssertion}.\n *\n * @public\n */\nexport class PhoneMultiFactorGenerator {\n  private constructor() {}\n\n  /**\n   * Provides a {@link PhoneMultiFactorAssertion} to confirm ownership of the phone second factor.\n   *\n   * @param phoneAuthCredential - A credential provided by {@link PhoneAuthProvider.credential}.\n   * @returns A {@link PhoneMultiFactorAssertion} which can be used with\n   * {@link MultiFactorResolver.resolveSignIn}\n   */\n  static assertion(credential: PhoneAuthCredential): PhoneMultiFactorAssertion {\n    return PhoneMultiFactorAssertionImpl._fromCredential(credential);\n  }\n\n  /**\n   * The identifier of the phone second factor: `phone`.\n   */\n  static FACTOR_ID = 'phone';\n}\n","/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { Unsubscribe } from '@firebase/util';\nimport { FirebaseAuthInternal } from '@firebase/auth-interop-types';\n\nimport { AuthInternal } from '../../model/auth';\nimport { UserInternal } from '../../model/user';\nimport { _assert } from '../util/assert';\nimport { AuthErrorCode } from '../errors';\n\ninterface TokenListener {\n  (tok: string | null): unknown;\n}\n\nexport class AuthInterop implements FirebaseAuthInternal {\n  private readonly internalListeners: Map<\n    TokenListener,\n    Unsubscribe\n  > = new Map();\n\n  constructor(private readonly auth: AuthInternal) {}\n\n  getUid(): string | null {\n    this.assertAuthConfigured();\n    return this.auth.currentUser?.uid || null;\n  }\n\n  async getToken(\n    forceRefresh?: boolean\n  ): Promise<{ accessToken: string } | null> {\n    this.assertAuthConfigured();\n    await this.auth._initializationPromise;\n    if (!this.auth.currentUser) {\n      return null;\n    }\n\n    const accessToken = await this.auth.currentUser.getIdToken(forceRefresh);\n    return { accessToken };\n  }\n\n  addAuthTokenListener(listener: TokenListener): void {\n    this.assertAuthConfigured();\n    if (this.internalListeners.has(listener)) {\n      return;\n    }\n\n    const unsubscribe = this.auth.onIdTokenChanged(user => {\n      listener(\n        (user as UserInternal | null)?.stsTokenManager.accessToken || null\n      );\n    });\n    this.internalListeners.set(listener, unsubscribe);\n    this.updateProactiveRefresh();\n  }\n\n  removeAuthTokenListener(listener: TokenListener): void {\n    this.assertAuthConfigured();\n    const unsubscribe = this.internalListeners.get(listener);\n    if (!unsubscribe) {\n      return;\n    }\n\n    this.internalListeners.delete(listener);\n    unsubscribe();\n    this.updateProactiveRefresh();\n  }\n\n  private assertAuthConfigured(): void {\n    _assert(\n      this.auth._initializationPromise,\n      AuthErrorCode.DEPENDENT_SDK_INIT_BEFORE_AUTH\n    );\n  }\n\n  private updateProactiveRefresh(): void {\n    if (this.internalListeners.size > 0) {\n      this.auth._startProactiveRefresh();\n    } else {\n      this.auth._stopProactiveRefresh();\n    }\n  }\n}\n","/**\n * @license\n * Copyright 2020 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { _registerComponent, registerVersion } from '@firebase/app';\nimport {\n  Component,\n  ComponentType,\n  InstantiationMode,\n} from '@firebase/component';\n\nimport { name, version } from '../../../package.json';\nimport { AuthErrorCode } from '../errors';\nimport { _assert } from '../util/assert';\nimport { _getClientVersion, ClientPlatform } from '../util/version';\nimport { _castAuth, AuthImpl, DefaultConfig } from './auth_impl';\nimport { AuthInterop } from './firebase_internal';\nimport { ConfigInternal } from '../../model/auth';\nimport { Dependencies } from '../../model/public_types';\nimport { _initializeAuthInstance } from './initialize';\n\nexport const enum _ComponentName {\n  AUTH = 'auth',\n  AUTH_INTERNAL = 'auth-internal'\n}\n\nfunction getVersionForPlatform(\n  clientPlatform: ClientPlatform\n): string | undefined {\n  switch (clientPlatform) {\n    case ClientPlatform.NODE:\n      return 'node';\n    case ClientPlatform.REACT_NATIVE:\n      return 'rn';\n    case ClientPlatform.WORKER:\n      return 'webworker';\n    case ClientPlatform.CORDOVA:\n      return 'cordova';\n    default:\n      return undefined;\n  }\n}\n\n/** @internal */\nexport function registerAuth(clientPlatform: ClientPlatform): void {\n  _registerComponent(\n    new Component(\n      _ComponentName.AUTH,\n      (container, { options: deps }: { options?: Dependencies }) => {\n        const app = container.getProvider('app').getImmediate()!;\n        const heartbeatServiceProvider = container.getProvider<'heartbeat'>('heartbeat');\n        const { apiKey, authDomain } = app.options;\n        return ((app, heartbeatServiceProvider) => {\n          _assert(\n            apiKey && !apiKey.includes(':'),\n            AuthErrorCode.INVALID_API_KEY,\n            { appName: app.name }\n          );\n          // Auth domain is optional if IdP sign in isn't being used\n          _assert(!authDomain?.includes(':'), AuthErrorCode.ARGUMENT_ERROR, {\n            appName: app.name\n          });\n          const config: ConfigInternal = {\n            apiKey,\n            authDomain,\n            clientPlatform,\n            apiHost: DefaultConfig.API_HOST,\n            tokenApiHost: DefaultConfig.TOKEN_API_HOST,\n            apiScheme: DefaultConfig.API_SCHEME,\n            sdkClientVersion: _getClientVersion(clientPlatform)\n          };\n\n          const authInstance = new AuthImpl(app, heartbeatServiceProvider, config);\n          _initializeAuthInstance(authInstance, deps);\n\n          return authInstance;\n        })(app, heartbeatServiceProvider);\n      },\n      ComponentType.PUBLIC\n    )\n      /**\n       * Auth can only be initialized by explicitly calling getAuth() or initializeAuth()\n       * For why we do this, See go/firebase-next-auth-init\n       */\n      .setInstantiationMode(InstantiationMode.EXPLICIT)\n      /**\n       * Because all firebase products that depend on auth depend on auth-internal directly,\n       * we need to initialize auth-internal after auth is initialized to make it available to other firebase products.\n       */\n      .setInstanceCreatedCallback(\n        (container, _instanceIdentifier, _instance) => {\n          const authInternalProvider = container.getProvider(\n            _ComponentName.AUTH_INTERNAL\n          );\n          authInternalProvider.initialize();\n        }\n      )\n  );\n\n  _registerComponent(\n    new Component(\n      _ComponentName.AUTH_INTERNAL,\n      container => {\n        const auth = _castAuth(\n          container.getProvider(_ComponentName.AUTH).getImmediate()!\n        );\n        return (auth => new AuthInterop(auth))(auth);\n      },\n      ComponentType.PRIVATE\n    ).setInstantiationMode(InstantiationMode.EXPLICIT)\n  );\n\n  registerVersion(name, version, getVersionForPlatform(clientPlatform));\n  // BUILD_TARGET will be replaced by values like esm5, esm2017, cjs5, etc during the compilation\n  registerVersion(name, version, '__BUILD_TARGET__');\n}\n","/**\n * @license\n * Copyright 2021 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *   http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { FirebaseApp, getApp, _getProvider } from '@firebase/app';\n\nimport { initializeAuth } from '..';\nimport { registerAuth } from '../core/auth/register';\nimport { ClientPlatform } from '../core/util/version';\nimport { browserLocalPersistence } from './persistence/local_storage';\nimport { browserSessionPersistence } from './persistence/session_storage';\nimport { indexedDBLocalPersistence } from './persistence/indexed_db';\nimport { browserPopupRedirectResolver } from './popup_redirect';\nimport { Auth } from '../model/public_types';\n\n/**\n * Returns the Auth instance associated with the provided {@link @firebase/app#FirebaseApp}.\n * If no instance exists, initializes an Auth instance with platform-specific default dependencies.\n *\n * @param app - The Firebase App.\n *\n * @public\n */\nexport function getAuth(app: FirebaseApp = getApp()): Auth {\n  const provider = _getProvider(app, 'auth');\n\n  if (provider.isInitialized()) {\n    return provider.getImmediate();\n  }\n\n  return initializeAuth(app, {\n    popupRedirectResolver: browserPopupRedirectResolver,\n    persistence: [\n      indexedDBLocalPersistence,\n      browserLocalPersistence,\n      browserSessionPersistence\n    ]\n  });\n}\n\nregisterAuth(ClientPlatform.BROWSER);\n"],"sourceRoot":""}