{"version":3,"sources":["../../logger.ts","../../firebaseApp.ts","../../errors.ts","../../firebaseNamespace.ts","../../firebaseNamespaceCore.ts","webpack:///../../src/index.ts?0e3e","../../registerCoreComponents.ts","../../util/constants.ts","../../util/errors.ts","../../functions/common.ts","../../util/sleep.ts","../../helpers/generate-fid.ts","../../helpers/buffer-to-base64-url-safe.ts","../../util/get-key.ts","../../helpers/fid-changed.ts","../../helpers/idb-manager.ts","../../helpers/get-installation-entry.ts","../../functions/create-installation-request.ts","../../functions/generate-auth-token-request.ts","../../helpers/refresh-auth-token.ts","../../api/get-token.ts","../../helpers/extract-app-config.ts","../../functions/config.ts","../../api/get-id.ts","../../interfaces/internal-message-payload.ts","../../helpers/array-base64-translator.ts","../../helpers/migrate-old-database.ts","../../internals/idb-manager.ts","../../internals/requests.ts","../../internals/token-manager.ts","../../helpers/externalizePayload.ts","../../helpers/logToFirelog.ts","../../messaging-service.ts","../../helpers/registerDefaultSw.ts","../../api/getToken.ts","../../helpers/updateVapidKey.ts","../../helpers/updateSwReg.ts","../../helpers/logToScion.ts","../../listeners/window-listener.ts","../../helpers/is-console-message.ts","../../helpers/register.ts","../../api/isSupported.ts","../../api.ts","../../api/onMessage.ts","../../src/constants.ts","../../src/crypt.ts","../../src/deepCopy.ts","../../src/defaults.ts","../../src/global.ts","../../src/deferred.ts","../../src/environment.ts","../../src/errors.ts","../../src/obj.ts","../../src/query.ts","../../src/subscribe.ts","../../src/compat.ts","../../model/enum_maps.ts","../../core/errors.ts","../../core/util/log.ts","../../core/util/assert.ts","../../core/util/location.ts","../../core/util/delay.ts","../../core/util/navigator.ts","../../core/util/emulator.ts","../../core/util/fetch_provider.ts","../../api/errors.ts","../../api/index.ts","../../core/util/time.ts","../../core/user/id_token_result.ts","../../core/user/invalidation.ts","../../core/user/proactive_refresh.ts","../../core/user/user_metadata.ts","../../core/user/reload.ts","../../api/account_management/account.ts","../../core/user/token_manager.ts","../../api/authentication/token.ts","../../core/user/user_impl.ts","../../core/util/instantiator.ts","../../core/persistence/in_memory.ts","../../core/persistence/persistence_user_manager.ts","../../core/util/browser.ts","../../core/util/version.ts","../../api/authentication/recaptcha.ts","../../platform_browser/recaptcha/recaptcha.ts","../../platform_browser/load_js.ts","../../platform_browser/recaptcha/recaptcha_enterprise_verifier.ts","../../core/auth/middleware.ts","../../core/auth/auth_impl.ts","../../core/auth/emulator.ts","../../core/credentials/auth_credential.ts","../../api/account_management/email_and_password.ts","../../api/authentication/email_and_password.ts","../../core/credentials/email.ts","../../api/authentication/email_link.ts","../../api/authentication/idp.ts","../../core/credentials/oauth.ts","../../api/authentication/sms.ts","../../core/credentials/phone.ts","../../core/action_code_url.ts","../../core/providers/email.ts","../../core/providers/federated.ts","../../core/providers/oauth.ts","../../core/providers/facebook.ts","../../core/providers/google.ts","../../core/providers/github.ts","../../core/credentials/saml.ts","../../core/providers/saml.ts","../../core/providers/twitter.ts","../../api/authentication/sign_up.ts","../../core/user/user_credential_impl.ts","../../core/strategies/anonymous.ts","../../mfa/mfa_error.ts","../../core/util/providers.ts","../../core/user/link_unlink.ts","../../core/user/reauthenticate.ts","../../core/strategies/credential.ts","../../core/strategies/custom_token.ts","../../api/authentication/custom_token.ts","../../mfa/mfa_info.ts","../../core/strategies/action_code_settings.ts","../../core/strategies/email_and_password.ts","../../core/strategies/email_link.ts","../../core/strategies/email.ts","../../api/authentication/create_auth_uri.ts","../../core/user/account_info.ts","../../api/account_management/profile.ts","../../core/user/additional_user_info.ts","../../mfa/mfa_session.ts","../../mfa/mfa_resolver.ts","../../mfa/mfa_user.ts","../../api/account_management/mfa.ts","../../core/persistence/index.ts","../../platform_browser/persistence/browser.ts","../../platform_browser/persistence/local_storage.ts","../../platform_browser/persistence/session_storage.ts","../../platform_browser/messagechannel/receiver.ts","../../platform_browser/messagechannel/promise.ts","../../core/util/event_id.ts","../../platform_browser/messagechannel/sender.ts","../../platform_browser/auth_window.ts","../../platform_browser/util/worker.ts","../../platform_browser/persistence/indexed_db.ts","../../platform_browser/recaptcha/recaptcha_mock.ts","../../platform_browser/recaptcha/recaptcha_loader.ts","../../platform_browser/recaptcha/recaptcha_verifier.ts","../../platform_browser/strategies/phone.ts","../../api/authentication/mfa.ts","../../platform_browser/providers/phone.ts","../../core/util/resolver.ts","../../core/strategies/idp.ts","../../core/strategies/abstract_popup_redirect_operation.ts","../../platform_browser/strategies/popup.ts","../../core/strategies/redirect.ts","../../platform_browser/strategies/redirect.ts","../../core/auth/auth_event_manager.ts","../../api/project_config/get_project_config.ts","../../core/util/validate_origin.ts","../../platform_browser/iframe/gapi.ts","../../platform_browser/iframe/iframe.ts","../../platform_browser/util/popup.ts","../../core/util/handler.ts","../../platform_browser/popup_redirect.ts","../../mfa/mfa_assertion.ts","../../platform_browser/mfa/assertions/phone.ts","../../core/auth/firebase_internal.ts","../../platform_browser/index.ts","../../core/auth/register.ts","../../platform_cordova/plugins.ts","../../core/auth/initialize.ts","../../platform_cordova/popup_redirect/utils.ts","../../platform_cordova/popup_redirect/events.ts","../../platform_cordova/popup_redirect/popup_redirect.ts","../../../internal/index.ts","../node_modules/@firebase/app/node_modules/idb/build/wrap-idb-value.js","../node_modules/@firebase/app/node_modules/idb/build/index.js","../../platformLoggerService.ts","../../constants.ts","../../internal.ts","../../indexeddb.ts","../../heartbeatService.ts","../../src/platform.ts","../../src/persistence.ts","../../src/popup_redirect.ts","../../src/wrap.ts","../../src/user_credential.ts","../../src/user.ts","../../src/auth.ts","../../src/phone_auth_provider.ts","../../src/recaptcha_verifier.ts","../../index.ts","../../component.ts","../../provider.ts","../../component_container.ts","../../../index.ts"],"names":["firebase","createFirebaseNamespace","namespace","firebaseAppImpl","apps","__esModule","initializeApp","options","rawConfig","app","name","appCompat","registerVersion","setLogLevel","onLog","SDK_VERSION","INTERNAL","registerComponent","component","componentName","componentNameWithoutCompat","replace","type","serviceNamespace","appArg","ERROR_FACTORY","create","appName","undefined","serviceProps","prototype","serviceFxn","this","_getService","bind","args","apply","multipleInstances","removeApp","useAsService","modularAPIs","Object","defineProperty","get","keys","map","createFirebaseNamespaceCore","FirebaseAppImpl","extendNamespace","props","createSubscribe","ErrorFactory","deepExtend","logger","firebaseNamespace","getInstallationsEndpoint","projectId","extractAuthTokenInfoFromResponse","response","token","requestStatus","expiresIn","responseExpiresIn","Number","creationTime","Date","now","async","getErrorFromResponse","requestName","errorData","json","error","serverCode","code","serverMessage","message","serverStatus","status","getHeaders","apiKey","Headers","Accept","getHeadersWithAuth","appConfig","refreshToken","headers","append","INTERNAL_AUTH_VERSION","getAuthorizationHeader","retryIfServerError","fn","result","sleep","ms","Promise","resolve","setTimeout","VALID_FID_PATTERN","generateFid","fidByteArray","Uint8Array","self","crypto","msCrypto","getRandomValues","fid","b64String","array","btoa","String","fromCharCode","substr","encode","test","getKey","appId","fidChangeCallbacks","Map","fidChanged","key","callFidChangeCallbacks","channel","getBroadcastChannel","postMessage","closeBroadcastChannel","broadcastFidChange","callbacks","callback","broadcastChannel","BroadcastChannel","onmessage","e","data","size","close","OBJECT_STORE_NAME","dbPromise","getDbPromise","upgrade","db","oldVersion","createObjectStore","set","value","tx","transaction","objectStore","oldValue","put","done","remove","delete","update","updateFn","store","newValue","getInstallationEntry","installations","registrationPromise","installationEntry","oldEntry","entry","registrationStatus","clearTimedOutRequest","updateOrCreateInstallationEntry","entryWithPromise","navigator","onLine","reject","inProgressEntry","registrationTime","registeredInstallationEntry","heartbeatServiceProvider","endpoint","heartbeatService","getImmediate","optional","heartbeatsHeader","getHeartbeatsHeader","body","authVersion","sdkVersion","PACKAGE_VERSION","request","method","JSON","stringify","fetch","ok","responseValue","authToken","createInstallationRequest","isServerError","customData","registerInstallation","waitUntilFidRegistration","triggerRegistrationIfNecessary","updateInstallationRequest","PENDING_TIMEOUT_MS","generateAuthTokenRequest","getGenerateAuthTokenEndpoint","installation","refreshAuthToken","tokenPromise","forceRefresh","isEntryRegistered","oldAuthToken","TOKEN_EXPIRATION_BUFFER","isAuthTokenExpired","isAuthTokenValid","updateAuthTokenRequest","waitUntilAuthTokenRequest","inProgressAuthToken","requestTime","makeAuthTokenRequestInProgressEntry","updatedInstallationEntry","fetchAuthTokenFromServer","getToken","installationsImpl","completeInstallationRegistration","INSTALLATIONS_NAME","publicFactory","container","getProvider","extractAppConfig","_delete","internalFactory","getId","catch","console","DEFAULT_SW_PATH","DEFAULT_SW_SCOPE","DEFAULT_VAPID_KEY","ENDPOINT","CONSOLE_CAMPAIGN_ID","MessageType","arrayToBase64","uint8Array","base64ToArray","base64String","base64","repeat","length","rawData","atob","outputArray","i","charCodeAt","OLD_DB_NAME","OLD_DB_VERSION","OLD_OBJECT_STORE_NAME","upgradeDb","dbGet","firebaseDependencies","tokenDetails","oldTokenDetails","senderId","indexedDB","dbNames","databases","includes","newVersion","upgradeTransaction","objectStoreNames","contains","index","clear","oldDetails","auth","p256dh","fcmToken","createTime","subscriptionOptions","swScope","vapidKey","checkTokenDetails","migrateOldDatabase","dbSet","ERROR_MAP","requestDeleteToken","unsubscribeOptions","getEndpoint","responseData","errorInfo","err","toString","getBody","web","applicationPubKey","TOKEN_EXPIRATION_MS","getTokenInternal","messaging","pushSubscription","swRegistration","subscription","pushManager","getSubscription","subscribe","userVisibleOnly","applicationServerKey","getPushSubscription","scope","dbOptions","currentOptions","isVapidKeyEqual","isEndpointEqual","isAuthEqual","isP256dhEqual","isTokenValid","updatedToken","updateOptions","requestUpdateToken","updatedTokenDetails","deleteTokenInternal","updateToken","warn","getNewToken","dbRemove","unsubscribe","subscribeOptions","requestGetToken","externalizePayload","internalPayload","payload","from","collapseKey","collapse_key","messageId","fcmMessageId","messagePayloadInternal","notification","title","image","icon","propagateNotificationPayload","propagateDataPayload","fcmOptions","click_action","link","analyticsLabel","analytics_label","propagateFcmOptions","_mergeStrings","s1","s2","resultArray","push","charAt","join","valueName","MessagingService","constructor","analyticsProvider","configKeys","keyName","messagingSenderId","registerDefaultSw","serviceWorker","register","browserErrorMessage","Notification","permission","requestPermission","updateVapidKey","ServiceWorkerRegistration","updateSwReg","serviceWorkerRegistration","logToScion","messageType","eventType","NOTIFICATION_CLICKED","PUSH_RECEIVED","Error","getEventType","logEvent","message_id","message_name","message_time","message_device_time","Math","floor","messageEventListener","event","isFirebaseMessaging","onMessageHandler","next","dataPayload","WindowMessagingFactory","addEventListener","WindowMessagingInternalFactory","isWindowSupported","window","hasOwnProperty","PushSubscription","_getToken","nextOrObserver","_onMessage","stringToByteArray","str","out","p","c","byteToCharMap_","charToByteMap_","byteToCharMapWebSafe_","charToByteMapWebSafe_","ENCODED_VALS_BASE","ENCODED_VALS","ENCODED_VALS_WEBSAFE","HAS_NATIVE_SUPPORT","encodeByteArray","input","webSafe","Array","isArray","init_","byteToCharMap","output","byte1","haveByte2","byte2","haveByte3","byte3","outByte1","outByte2","outByte3","outByte4","encodeString","decodeString","bytes","pos","c1","c2","u","c3","byteArrayToString","decodeStringToByteArray","charToByteMap","byte4","DecodeBase64StringError","base64urlEncodeWithoutPadding","utf8Bytes","base64Encode","base64Decode","target","source","getTime","prop","getDefaultsFromGlobal","global","getGlobal","__FIREBASE_DEFAULTS__","getDefaults","process","defaultsJsonString","parse","getDefaultsFromEnvVariable","document","match","cookie","decoded","getDefaultsFromCookie","info","getDefaultEmulatorHost","productName","emulatorHosts","getDefaultAppConfig","config","getExperimentalSetting","Deferred","promise","wrapCallback","getUA","isMobileCordova","isNode","forceEnvironment","call","isBrowser","isBrowserExtension","runtime","chrome","browser","id","isReactNative","isIE","ua","indexOf","isIndexedDBAvailable","validateIndexedDBOpenable","preExist","DB_CHECK_NAME","open","onsuccess","deleteDatabase","onupgradeneeded","onerror","areCookiesEnabled","cookieEnabled","FirebaseError","super","setPrototypeOf","captureStackTrace","service","serviceName","errors","fullCode","template","PATTERN","_","replaceTemplate","fullMessage","obj","isEmpty","deepEqual","a","b","aKeys","bKeys","k","aProp","bProp","isObject","thing","querystring","querystringParams","params","entries","forEach","arrayVal","encodeURIComponent","querystringDecode","split","decodeURIComponent","extractQuerystring","url","queryStart","fragmentStart","substring","executor","onNoObservers","proxy","ObserverProxy","task","then","forEachObserver","observer","complete","methods","implementsAnyMethods","noop","unsub","unsubscribeOne","observers","finalized","finalError","observerCount","sendOne","getModularInstance","_delegate","ProviderId","FACEBOOK","GITHUB","GOOGLE","PASSWORD","PHONE","TWITTER","ActionCodeOperation","EMAIL_SIGNIN","PASSWORD_RESET","RECOVER_EMAIL","REVERT_SECOND_FACTOR_ADDITION","VERIFY_AND_CHANGE_EMAIL","VERIFY_EMAIL","_prodErrorMap","debugErrorMap","prodErrorMap","_DEFAULT_AUTH_ERROR_FACTORY","logClient","_logError","msg","logLevel","ERROR","_fail","authOrCode","rest","createErrorInternal","_createError","_errorWithCustomMessage","errorMap","_assertInstanceOf","object","instance","fullParams","slice","_errorFactory","_assert","assertion","debugFail","failure","debugAssert","_getCurrentUrl","location","href","_isHttpOrHttps","_getCurrentScheme","protocol","shortDelay","longDelay","isMobile","min","_emulatorUrl","path","emulator","startsWith","FetchProvider","initialize","fetchImpl","headersImpl","responseImpl","Response","SERVER_ERROR_MAP","DEFAULT_API_TIMEOUT_MS","_addTidIfNecessary","tenantId","_performApiRequest","_performFetchWithErrorHandling","query","_getAdditionalHeaders","languageCode","_getFinalTarget","apiHost","referrerPolicy","customErrorMap","fetchFn","_canInitEmulator","networkTimeout","NetworkTimeout","race","clearNetworkTimeout","_makeTaggedError","errorMessage","serverErrorCode","serverErrorMessage","authError","toLowerCase","_performSignInRequest","serverResponse","_serverResponse","host","base","apiScheme","timer","clearTimeout","errorParams","email","phoneNumber","_tokenResponse","utcTimestampToDateString","utcTimestamp","date","isNaN","toUTCString","secondsStringToMilliseconds","seconds","_parseToken","algorithm","signature","_logoutIfInvalidated","user","isUserInvalidated","currentUser","signOut","ProactiveRefresh","errorBackoff","_start","isRunning","schedule","_stop","timerId","getInterval","wasError","interval","stsTokenManager","expirationTime","max","iteration","getIdToken","UserMetadata","createdAt","lastLoginAt","_initializeTime","lastSignInTime","_copy","metadata","toJSON","_reloadWithoutSaving","idToken","getAccountInfo","users","coreAccount","_notifyReloadListener","newProviderData","providerUserInfo","providerId","provider","uid","rawId","displayName","photoURL","photoUrl","providerData","original","newData","filter","o","some","n","oldIsAnonymous","isAnonymous","newIsAnonymous","passwordHash","updates","localId","emailVerified","assign","StsTokenManager","isExpired","updateFromServerResponse","parsedToken","exp","iat","_tokenExpiresIn","updateTokensAndExpiration","accessToken","refresh","clearRefreshToken","oldToken","tokenApiHost","access_token","expires_in","refresh_token","requestStsToken","expiresInSec","fromJSON","manager","_assign","_clone","_performRefresh","assertStringOrUndefined","opt","proactiveRefresh","_persistUserIfCurrent","_notifyListenersIfCurrent","getIdTokenResult","userInternal","claims","auth_time","signInProvider","authTime","issuedAtTime","signInSecondFactor","reload","userInfo","newUser","_onReload","reloadListener","reloadUserInfo","_startProactiveRefresh","_stopProactiveRefresh","_updateTokensIfNecessary","tokensRefreshed","deleteAccount","_redirectEventId","_fromJSON","plainObjectTokenManager","_fromIdTokenResponse","idTokenResponse","instanceCache","_getInstance","cls","Function","InMemoryPersistence","_isAvailable","_set","storage","_get","_remove","_addListener","_key","_listener","_removeListener","inMemoryPersistence","_persistenceKeyName","PersistenceUserManager","persistence","userKey","fullUserKey","fullPersistenceKey","boundEventHandler","_onStorageEvent","setCurrentUser","getCurrentUser","blob","removeCurrentUser","savePersistenceForRedirect","setPersistence","newPersistence","persistenceHierarchy","availablePersistences","all","selectedPersistence","userToMigrate","migrationHierarchy","_shouldAllowMigration","_getBrowserName","userAgent","_isIEMobile","_isFirefox","_isBlackBerry","_isWebOS","_isSafari","_isChromeIOS","_isAndroid","re","matches","_isIOS","_isMobileBrowser","_getClientVersion","clientPlatform","reportedPlatform","frameworks","reportedFrameworks","getRecaptchaConfig","isV2","grecaptcha","getResponse","isEnterprise","enterprise","RecaptchaConfig","recaptchaKey","siteKey","emailPasswordEnabled","recaptchaEnforcementState","enforcementState","_loadJS","el","createElement","setAttribute","onload","charset","getElementsByTagName","getScriptParentElement","appendChild","_generateCallbackName","prefix","random","RecaptchaEnterpriseVerifier","authExtern","_castAuth","verify","action","retrieveRecaptchaToken","ready","execute","_agentRecaptchaConfig","_tenantRecaptchaConfigs","clientType","version","retrieveSiteKey","jsHelpers\r\n                        ._loadJS","injectRecaptchaFields","captchaResp","verifier","captchaResponse","newRequest","AuthMiddlewareQueue","pushCallback","onAbort","wrappedCallback","queue","runMiddleware","nextUser","onAbortStack","beforeStateCallback","reverse","originalMessage","appCheckServiceProvider","operations","authStateSubscription","idTokenSubscription","beforeStateQueue","settings","appVerificationDisabledForTesting","clientVersion","sdkClientVersion","_initializeWithPersistence","popupRedirectResolver","_popupRedirectResolver","_initializationPromise","_deleted","persistenceManager","_shouldInitProactively","_initialize","initializeCurrentUser","lastNotifiedUid","_isInitialized","assertedPersistence","_currentUser","_updateCurrentUser","previouslyStoredUser","futureCurrentUser","needsTocheckMiddleware","authDomain","getOrInitRedirectPersistenceManager","redirectUserEventId","redirectUser","storedUserEventId","tryRedirectSignIn","directlySetCurrentUser","_overrideRedirectResult","reloadAndSetCurrentUserOrClear","redirectResolver","_completeRedirectFn","_setRedirectUser","useDeviceLanguage","navigatorLanguage","languages","language","_getUserLanguage","updateCurrentUser","userExtern","skipBeforeStateCallbacks","notifyAuthListeners","redirectPersistenceManager","initializeRecaptchaConfig","_getRecaptchaConfig","_getPersistence","_updateErrorMap","onAuthStateChanged","completed","registerStateListener","beforeAuthStateChanged","onIdTokenChanged","redirectManager","resolver","_redirectPersistence","_redirectUserForId","isProactiveRefreshEnabled","currentUid","cb","addObserver","_logFramework","framework","sort","_getFrameworks","appCheckToken","_getAppCheckToken","appCheckTokenResult","WARN","_logWarn","connectAuthEmulator","authInternal","disableWarnings","extractProtocol","port","authority","exec","hostAndPort","pop","bracketedIPv6","parsePort","extractHostAndPort","portStr","emulatorConfig","freeze","attachBanner","sty","style","innerText","position","width","backgroundColor","border","color","bottom","left","margin","zIndex","textAlign","classList","add","readyState","emitEmulatorWarning","protocolEnd","AuthCredential","signInMethod","_getIdTokenResponse","_auth","_linkToIdToken","_idToken","_getReauthenticationResolver","resetPassword","updateEmailPassword","signInWithPassword","sendOobCode","sendPasswordResetEmail","sendSignInLinkToEmail","EmailAuthCredential","_email","_password","_tenantId","_fromEmailAndPassword","password","_fromEmailAndCode","oobCode","returnSecureToken","requestWithRecaptcha","log","signInWithEmailLink","signInWithEmailLinkForLinking","signInWithIdp","_fromParams","cred","nonce","pendingToken","oauthToken","oauthTokenSecret","secret","buildRequest","autoCreate","requestUri","postBody","VERIFY_PHONE_NUMBER_FOR_EXISTING_ERROR_MAP_","PhoneAuthCredential","_fromVerification","verificationId","verificationCode","_fromTokenResponse","temporaryProof","signInWithPhoneNumber","_makeVerificationRequest","linkWithPhoneNumber","operation","verifyPhoneNumberForExisting","sessionInfo","actionLink","searchParams","mode","parseMode","continueUrl","parseLink","doubleDeepLink","iOSDeepLink","parseDeepLink","EmailAuthProvider","PROVIDER_ID","credential","credentialWithLink","emailLink","actionCodeUrl","EMAIL_PASSWORD_SIGN_IN_METHOD","EMAIL_LINK_SIGN_IN_METHOD","FederatedAuthProvider","setDefaultLanguage","defaultLanguageCode","setCustomParameters","customOAuthParameters","customParameters","getCustomParameters","BaseOAuthProvider","addScope","scopes","getScopes","OAuthProvider","credentialFromJSON","_credential","rawNonce","credentialFromResult","userCredential","oauthCredentialFromTaggedObject","credentialFromError","tokenResponse","oauthIdToken","oauthAccessToken","FacebookAuthProvider","FACEBOOK_SIGN_IN_METHOD","credentialFromTaggedObject","GoogleAuthProvider","GOOGLE_SIGN_IN_METHOD","GithubAuthProvider","GITHUB_SIGN_IN_METHOD","SAMLAuthCredential","_create","SAMLAuthProvider","samlCredentialFromTaggedObject","TwitterAuthProvider","TWITTER_SIGN_IN_METHOD","signUp","UserCredentialImpl","operationType","providerIdForResponse","_forOperation","signInAnonymously","_fromErrorAndOperation","_processCredentialSavingMfaContextIfNecessary","providerDataAsNames","Set","pid","unlink","_assertLinkedStatus","deleteLinkedAccounts","deleteProvider","providersLeft","pd","has","_link","bypassAuthState","expected","_reauthenticate","parsed","sub","_signInWithCredential","signInWithCredential","linkWithCredential","reauthenticateWithCredential","signInWithCustomToken","customToken","getIdTokenResponse","MultiFactorInfoImpl","factorId","mfaEnrollmentId","enrollmentTime","enrolledAt","_fromServerResponse","enrollment","PhoneMultiFactorInfoImpl","TotpMultiFactorInfoImpl","phoneInfo","_setActionCodeSettingsOnRequest","actionCodeSettings","dynamicLinkDomain","canHandleCodeInApp","handleCodeInApp","iOS","bundleId","iOSBundleId","android","packageName","androidInstallApp","installApp","androidMinimumVersionCode","minimumVersion","androidPackageName","requestType","authentication.sendPasswordResetEmail","authentication\r\n            .sendPasswordResetEmail","confirmPasswordReset","newPassword","account.resetPassword","applyActionCode","account.applyActionCode","checkActionCode","authModular","newEmail","mfaInfo","multiFactorInfo","previousEmail","verifyPasswordResetCode","createUserWithEmailAndPassword","signUpResponse","signInWithEmailAndPassword","setActionCodeSettings","api.sendSignInLinkToEmail","api\r\n            .sendSignInLinkToEmail","isSignInWithEmailLink","fetchSignInMethodsForEmail","identifier","continueUri","signinMethods","createAuthUri","sendEmailVerification","api.sendEmailVerification","verifyBeforeUpdateEmail","api.verifyAndChangeEmail","updateProfile","profileRequest","apiUpdateProfile","passwordProvider","find","updateEmail","updateEmailOrPassword","updatePassword","apiUpdateEmailPassword","GenericAdditionalUserInfo","isNewUser","profile","FederatedAdditionalUserInfoWithUsername","username","FacebookAdditionalUserInfo","GithubAdditionalUserInfo","login","GoogleAdditionalUserInfo","TwitterAdditionalUserInfo","screenName","getAdditionalUserInfo","rawUserInfo","kind","MultiFactorSessionImpl","_fromIdtoken","_fromMfaPendingCredential","mfaPendingCredential","multiFactorSession","pendingCredential","MultiFactorResolverImpl","session","hints","signInResolver","_fromError","mfaResponse","_process","resolveSignIn","assertionExtern","getMultiFactorResolver","errorInternal","MultiFactorUserImpl","enrolledFactors","_fromUser","getSession","enroll","finalizeMfaResponse","unenroll","infoOrUid","multiFactorUserCache","WeakMap","multiFactor","userModular","STORAGE_AVAILABLE_KEY","BrowserPersistenceClass","storageRetriever","setItem","removeItem","getItem","BrowserLocalPersistence","localStorage","poll","onStorageEvent","safariLocalStorageNotSynced","_iframeCannotSyncWebStorage","top","_isIframe","forAllChangedKeys","listeners","localCache","_oldValue","notifyListeners","detachListener","stopPolling","storedValue","triggerListeners","documentMode","listener","startPolling","pollTimer","setInterval","StorageEvent","clearInterval","attachListener","removeEventListener","fallbackToPolling","browserLocalPersistence","BrowserSessionPersistence","sessionStorage","browserSessionPersistence","Receiver","eventTarget","handleEvent","existingInstance","receivers","receiver","isListeningto","newInstance","messageEvent","eventId","handlers","handlersMap","ports","promises","handler","origin","fulfilled","reason","_allSettled","_subscribe","eventHandler","_unsubscribe","_generateEventId","digits","Sender","removeMessageHandler","messageChannel","port1","onMessage","_send","timeout","MessageChannel","completionTimer","start","ackTimer","port2","finally","_window","_isWorker","DB_NAME","DB_OBJECTSTORE_NAME","DB_DATA_KEYPATH","DBPromise","toPromise","getObjectStore","isReadWrite","_openDatabase","keyPath","_deleteDatabase","_putObject","_deleteObject","IndexedDBLocalPersistence","_workerInitializationPromise","initializeServiceWorkerMessaging","_openDb","_withRetries","op","numAttempts","initializeReceiver","initializeSender","_origin","keyProcessed","_poll","_data","activeServiceWorker","active","_getActiveServiceWorker","sender","results","serviceWorkerReceiverAvailable","notifyServiceWorker","controller","_getServiceWorkerController","_withPendingWrite","write","pendingWrites","getObject","getAllRequest","getAll","keysInResult","fbase_key","localKey","indexedDBLocalPersistence","_WIDGET_ID_START","MockReCaptcha","_widgets","render","parameters","counter","MockWidget","reset","optWidgetId","containerOrId","getElementById","isVisible","clickHandler","checkIfDeleted","responseToken","deleted","len","chars","allowedChars","generateRandomAlphaNumericString","expiredCallback","_JSLOAD_CALLBACK","jsHelpers._generateCallbackName","NETWORK_TIMEOUT_DELAY","librarySeparatelyLoaded","load","hl","isHostLanguageValid","shouldResolveImmediately","recaptcha","widgetId","hostLanguage","jsHelpers._loadJS","clearedOneInstance","MockReCaptchaLoaderImpl","RECAPTCHA_VERIFIER_TYPE","DEFAULT_PARAMS","theme","RecaptchaVerifier","tokenChangeListeners","isInvisible","makeTokenCallback","_recaptchaLoader","validateStartingState","assertNotDestroyed","getAssertedRecaptcha","tokenChange","renderPromise","makeRenderPromise","_reset","destroyed","childNodes","node","removeChild","sitekey","hasChildNodes","existing","globalFunc","init","guaranteedEmpty","domReady","recaptchaSiteKey","getRecaptchaParams","ConfirmationResultImpl","onConfirmation","confirm","authCredential","appVerifier","_verifyPhoneNumber","reauthenticateWithPhoneNumber","recaptchaToken","phoneInfoOptions","startEnrollPhoneMfa","phoneEnrollmentInfo","phoneSessionInfo","multiFactorHint","multiFactorUid","startSignInPhoneMfa","phoneSignInInfo","phoneResponseInfo","sendPhoneVerificationCode","updatePhoneNumber","verifyPhoneNumber","phoneOptions","applicationVerifier","_withDefaultResolver","resolverOverride","PHONE_SIGN_IN_METHOD","IdpCredential","_buildIdpRequest","sessionId","returnIdpCredential","_signIn","_reauth","_linkUser","AbstractPopupRedirectOperation","pendingPromise","eventManager","onExecution","registerConsumer","onAuthEvent","urlResponse","getIdpTask","onError","unregisterAndCleanUp","unregisterConsumer","cleanUp","_POLL_WINDOW_CLOSE_TIMEOUT","signInWithPopup","resolverInternal","PopupOperation","executeNotNull","reauthenticateWithPopup","linkWithPopup","currentPopupAction","cancel","authWindow","_openPopup","associatedEvent","_originValidation","_isIframeWebStorageSupported","isSupported","pollUserCancellation","pollId","closed","PENDING_REDIRECT_KEY","redirectOutcomeMap","RedirectAction","readyOutcome","pendingRedirectKey","resolverPersistence","hasPendingRedirect","_getAndClearPendingRedirectStatus","_setPendingRedirectStatus","signInWithRedirect","_openRedirect","_signInWithRedirect","reauthenticateWithRedirect","prepareUserForRedirect","_reauthenticateWithRedirect","linkWithRedirect","_linkWithRedirect","getRedirectResult","_getRedirectResult","resolverExtern","AuthEventManager","cachedEventUids","consumers","lastProcessedEventTime","authEventConsumer","queuedRedirectEvent","isEventForConsumer","sendToConsumer","saveEventToCache","onEvent","hasEventBeenHandled","handled","consumer","hasHandledPotentialRedirect","isNullRedirectEvent","isRedirectEvent","eventIdMatches","eventUid","v","_getProjectConfig","IP_ADDRESS_REGEX","HTTP_REGEX","matchDomain","currentUrl","hostname","URL","ceUrl","escapedDomainPattern","RegExp","NETWORK_TIMEOUT","resetUnloadedGapiModules","beacon","___jsl","H","hint","r","L","CP","cachedGApiLoader","_loadGapi","loadGapiIframe","gapi","iframes","getContext","ontimeout","Iframe","cbName","js._generateCallbackName","js\r\n                ._loadJS","loadGapi","PING_TIMEOUT","IFRAME_ATTRIBUTES","height","tabindex","EID_FROM_APIHOST","getIframeUrl","eid","fw","BASE_POPUP_OPTIONS","resizable","statusbar","toolbar","AuthPopup","_open","screen","availHeight","availWidth","scrollbars","optionsString","reduce","accum","standalone","_isIOSStandalone","click","createEvent","initMouseEvent","dispatchEvent","openAsNewWindowIOS","newWin","focus","WIDGET_PATH","EMULATOR_WIDGET_PATH","FIREBASE_APP_CHECK_FRAGMENT_ID","_getRedirectUrl","authType","redirectUrl","additionalParams","tid","paramsDict","appCheckTokenFragment","getHandlerBase","WEB_STORAGE_SUPPORT_KEY","browserPopupRedirectResolver","eventManagers","_setWindowLocation","initAndGetManager","iframe","context","gapiLoader._loadGapi","where","messageHandlersFilter","CROSS_ORIGIN_IFRAMES_FILTER","attributes","dontclear","restyle","setHideOnLeave","networkError","networkErrorTimer","clearTimerAndResolve","ping","_openIframe","iframeEvent","authEvent","send","originValidationPromises","authorizedDomains","domain","_validateOrigin","MultiFactorAssertionImpl","_finalizeEnroll","_finalizeSignIn","PhoneMultiFactorAssertionImpl","_fromCredential","finalizeEnrollPhoneMfa","phoneVerificationInfo","finalizeSignInPhoneMfa","PhoneMultiFactorGenerator","AuthInterop","internalListeners","getUid","assertAuthConfigured","addAuthTokenListener","updateProactiveRefresh","removeAuthTokenListener","_cordovaWindow","deps","authInstance","hierarchy","_initializeAuthInstance","setInstantiationMode","setInstanceCreatedCallback","_instanceIdentifier","_instance","getVersionForPlatform","_generateHandlerUrl","BuildInfo","sessionDigest","TextEncoder","buff","ArrayBuffer","view","stringToArrayBuffer","buf","subtle","digest","num","padStart","computeSha256","_performRedirect","handlerUrl","cordova","plugins","browsertab","isAvailable","browserTabIsAvailable","iabRef","openUrl","InAppBrowser","_isIOS7Or8","passiveListeners","initPromise","resolveInialized","addPassiveListener","removePassiveListener","resetRedirect","initialized","_getAndRemoveEvent","persistenceKey","_eventFromPartialAndUrl","partialEvent","callbackUrl","searchParamsOrEmpty","_getDeepLinkFromCallback","errorObject","parseJsonOrNull","generateSessionId","idx","cordovaPopupRedirectResolver","attachCallbackListeners","win","universalLinks","missingPlugin","_checkCordovaConfiguration","_generateNewEvent","_savePartialEvent","eventListener","cleanup","onCloseTimer","authEventSeen","closeBrowserTab","resumed","visibilityChanged","visibilityState","_waitForAppResume","_cb","iosBundleId","handleOpenURL","noEventTimeout","generateNoEvent","universalLinksCb","finalEvent","eventData","existingHandleOpenURL","packagePrefix","addFrameworkForLogging","idbProxyableTypes","cursorAdvanceMethods","cursorRequestMap","transactionDoneMap","transactionStoreNamesMap","transformCache","reverseTransformCache","idbProxyTraps","IDBTransaction","wrap","wrapFunction","func","IDBDatabase","IDBCursor","advance","continue","continuePrimaryKey","_len2","arguments","_key2","unwrap","_len3","_key3","storeNames","_len","transformCachableValue","unlisten","DOMException","cacheDonePromiseForTransaction","IDBObjectStore","IDBIndex","Proxy","instanceOfAny","IDBRequest","success","promisifyRequest","readMethods","writeMethods","cachedMethods","getMethod","targetFuncName","useIndex","isWrite","storeName","shift","oldTraps","PlatformLoggerServiceImpl","getPlatformInfoString","getProviders","getComponent","isVersionServiceProvider","library","logString","appCompatName","analyticsName","analyticsCompatName","appCheckName","appCheckCompatName","authName","authCompatName","databaseName","databaseCompatName","functionsName","functionsCompatName","installationsName","installationsCompatName","messagingName","messagingCompatName","performanceName","performanceCompatName","remoteConfigName","remoteConfigCompatName","storageName","storageCompatName","firestoreName","firestoreCompatName","_apps","_components","_addComponent","addComponent","debug","_addOrOverwriteComponent","addOrOverwriteComponent","_registerComponent","values","_getProvider","heartbeatController","triggerHeartbeat","_removeServiceInstance","instanceIdentifier","DEFAULT_ENTRY_NAME","clearInstance","_clearComponents","ERRORS","_options","_config","_name","_automaticDataCollectionEnabled","automaticDataCollectionEnabled","_container","checkDestroyed","val","isDeleted","_isDeleted","existingApp","newApp","getApp","getApps","deleteApp","libraryKeyOrName","variant","PLATFORM_LOG_STRING","libraryMismatch","versionMismatch","warning","logCallback","setLogLevelImpl","STORE_NAME","blocked","blocking","terminated","openPromise","openDB","originalErrorMessage","writeHeartbeatsToIndexedDB","heartbeatObject","computeKey","idbGetError","_storage","_heartbeatsCachePromise","read","_heartbeatsCache","agent","getUTCDateString","lastSentHeartbeatDate","heartbeats","singleDateHeartbeat","hbTimestamp","valueOf","overwrite","heartbeatsToSend","unsentEntries","heartbeatsCache","maxSize","heartbeatEntry","hb","dates","countBytes","extractHeartbeatsForHeader","headerString","toISOString","_canUseIndexedDBPromise","runIndexedDBEnvironmentCheck","readHeartbeatsFromIndexedDB","heartbeatsObject","existingHeartbeatsObject","_isAndroidOrIosCordovaScheme","_isLocalStorageNotSynchronized","_isEdge","_isWebStorageSupported","impl","_isPopupRedirectSupported","_isLikelyCordova","Persistence","LOCAL","NONE","SESSION","PERSISTENCE_KEY","_savePersistenceForRedirect","getSessionStorageIfAvailable","CompatPopupRedirectResolver","selectUnderlyingResolver","assertedUnderlyingResolver","browserResolver","underlyingResolver","isCordova","timeoutId","_isCordova","cordovaResolver","credentialFromObject","convertCredential","credentialPromise","MultiFactorResolver","credErr","attachExtraErrorFields","additionalUserInfo","User","getOrCreate","convertConfirmationResult","confirmationResultPromise","confirmationResultExp","wrapped","USER_MAP","linkAndRetrieveDataWithCredential","reauthenticateAndRetrieveDataWithCredential","phoneCredential","Auth","isInitialized","linkUnderlyingAuth","buildPersistenceHierarchy","useEmulator","fetchProvidersForEmail","errorFn","wrapObservers","converted","_validatePersistenceArgument","signInAndRetrieveDataWithCredential","oldNext","persistences","_getPersistencesFromRedirect","PhoneAuthProvider","authProvider","setServiceProps","ActionCodeInfo","Operation","CompatAuthProvider","CompatRecaptchaVerifier","setMultipleInstances","Component","instanceFactory","instantiationMode","onInstanceCreated","Provider","instances","instancesDeferred","instancesOptions","onInitCallbacks","normalizedIdentifier","normalizeInstanceIdentifier","deferred","shouldAutoInitialize","getOrInitializeService","setComponent","isComponentEager","instanceDeferred","services","isComponentSet","getOptions","opts","onInit","existingCallbacks","invokeOnInitCallbacks","ComponentContainer","providers"],"mappings":";wHAAA,wIAyCO,MAAM,EAAsB,G,IAavB,GAAZ,SAAY,GACV,qBACA,yBACA,mBACA,mBACA,qBACA,sBACD,CAPD,CAAY,MAOX,KAED,MAAM,EAA2D,CAC/D,MAAS,EAAS,MAClB,QAAW,EAAS,QACpB,KAAQ,EAAS,KACjB,KAAQ,EAAS,KACjB,MAAS,EAAS,MAClB,OAAU,EAAS,QAMf,EAA4B,EAAS,KAmBrC,EAAgB,CACpB,CAAC,EAAS,OAAQ,MAClB,CAAC,EAAS,SAAU,MACpB,CAAC,EAAS,MAAO,OACjB,CAAC,EAAS,MAAO,OACjB,CAAC,EAAS,OAAQ,SAQd,EAAgC,SAAC,EAAU,GAC/C,GAAI,EAAU,EAAS,SACrB,OAEF,MAAM,GAAM,IAAI,MAAO,cACjB,EAAS,EAAc,GAC7B,IAAI,EAMF,MAAM,IAAI,MACR,8DAA8D,MAPtD,2BAN+C,EAAI,iCAAJ,EAAI,kBAO7D,QAAQ,GACN,IAAI,OAAS,EAAS,WACnB,EAOT,E,MAEa,EAOX,YAAmB,QAAI,KAAJ,EAUX,KAAS,UAAG,EAsBZ,KAAW,YAAe,EAc1B,KAAe,gBAAsB,KA1C3C,EAAU,KAAK,KAChB,CAOD,YAAI,GACF,OAAO,KAAK,SACb,CAED,YAAI,CAAS,GACX,KAAM,KAAO,GACX,MAAM,IAAI,UAAU,kBAAkB,+BAExC,KAAK,UAAY,CAClB,CAGD,YAAY,GACV,KAAK,UAA2B,kBAAR,EAAmB,EAAkB,GAAO,CACrE,CAOD,cAAI,GACF,OAAO,KAAK,WACb,CACD,cAAI,CAAW,GACb,GAAmB,oBAAR,EACT,MAAM,IAAI,UAAU,qDAEtB,KAAK,YAAc,CACpB,CAMD,kBAAI,GACF,OAAO,KAAK,eACb,CACD,kBAAI,CAAe,GACjB,KAAK,gBAAkB,CACxB,CAMD,QAAwB,2BAAf,EAAe,yBAAf,EAAe,gBACtB,KAAK,iBAAmB,KAAK,gBAAgB,KAAM,EAAS,SAAU,GACtE,KAAK,YAAY,KAAM,EAAS,SAAU,EAC3C,CACD,MAAsB,2BAAf,EAAe,yBAAf,EAAe,gBACpB,KAAK,iBACH,KAAK,gBAAgB,KAAM,EAAS,WAAY,GAClD,KAAK,YAAY,KAAM,EAAS,WAAY,EAC7C,CACD,OAAuB,2BAAf,EAAe,yBAAf,EAAe,gBACrB,KAAK,iBAAmB,KAAK,gBAAgB,KAAM,EAAS,QAAS,GACrE,KAAK,YAAY,KAAM,EAAS,QAAS,EAC1C,CACD,OAAuB,2BAAf,EAAe,yBAAf,EAAe,gBACrB,KAAK,iBAAmB,KAAK,gBAAgB,KAAM,EAAS,QAAS,GACrE,KAAK,YAAY,KAAM,EAAS,QAAS,EAC1C,CACD,QAAwB,2BAAf,EAAe,yBAAf,EAAe,gBACtB,KAAK,iBAAmB,KAAK,gBAAgB,KAAM,EAAS,SAAU,GACtE,KAAK,YAAY,KAAM,EAAS,SAAU,EAC3C,EAGG,SAAU,EAAY,GAC1B,EAAU,SAAQ,IAChB,EAAK,YAAY,EAAM,GAE3B,CAEgB,WACd,EACA,GAEA,IAAK,MAAM,KAAY,EAAW,CAChC,IAAI,EAAkC,KAClC,GAAW,EAAQ,QACrB,EAAiB,EAAkB,EAAQ,QAG3C,EAAS,eADS,OAAhB,EACwB,KAEA,SACxB,EACA,GAEE,2BADC,EAAe,iCAAf,EAAe,kBAElB,MAAM,EAAU,EACb,KAAI,IACH,GAAW,MAAP,EACF,OAAO,KACF,GAAmB,kBAAR,EAChB,OAAO,EACF,GAAmB,kBAAR,GAAmC,mBAAR,EAC3C,OAAO,EAAI,WACN,GAAI,aAAe,MACxB,OAAO,EAAI,QAEX,IACE,OAAO,KAAK,UAAU,EACvB,CAAC,MAAO,GACP,OAAO,IACR,CACF,IAEF,QAAO,GAAO,IACd,KAAK,KACJ,IAAU,uBAAkB,EAAS,WACvC,EAAY,CACV,MAAO,EAAS,GAAO,cACvB,UACA,OACA,KAAM,EAAS,MAGrB,CAEH,CACH,C,gHC1Ma,EAGX,YACW,EACQ,GADR,KAAS,UAAT,EACQ,KAAQ,SAAR,EAGjB,wBACE,EACA,IAAI,IAAU,cAAc,IAAM,MAAI,WAGxC,KAAK,UAAY,EAAU,SAC5B,CAED,kCAAI,GACF,OAAO,KAAK,UAAU,8BACvB,CAED,kCAAI,CAA+B,GACjC,KAAK,UAAU,+BAAiC,CACjD,CAED,QAAI,GACF,OAAO,KAAK,UAAU,IACvB,CAED,WAAI,GACF,OAAO,KAAK,UAAU,OACvB,CAED,SACE,OAAO,IAAI,SAAc,IACvB,KAAK,UAAU,iBACf,GAAS,IACR,MAAK,KACN,KAAK,SAAS,SAAS,UAAU,KAAK,MAC/B,oBAAU,KAAK,aAEzB,CAgBD,YACE,GACgD,IAAhD,yDAA6B,sB,MAE7B,KAAK,UAAU,iBAGf,MAAM,EAAW,KAAK,UAAU,UAAU,YAAY,GAStD,OAPG,EAAS,iBACgC,cAAjB,QAAzB,IAAS,sBAAgB,mCAEzB,EAAS,aAIJ,EAAS,aAAa,CAC3B,WAAY,GAEf,CAYD,uBACE,GACgD,IAAhD,yDAA6B,sBAE7B,KAAK,UAAU,UAEZ,YAAY,GACZ,cAAc,EAClB,CAMD,cAAc,GACZ,wBAAc,KAAK,UAAW,EAC/B,CAED,yBAAyB,GACvB,mCAAyB,KAAK,UAAW,EAC1C,CAED,SACE,MAAO,CACL,KAAM,KAAK,KACX,+BAAgC,KAAK,+BACrC,QAAS,KAAK,QAEjB,EC5JH,MAAM,EAA6B,CACjC,SACE,oFAEF,uBACE,8EAMS,EAAgB,IAAI,IAC/B,aACA,WACA,GCcK,MAAMA,E,SAvBGC,IACd,MAAMC,ECSF,SACJC,GAEA,MAAMC,EAAwC,CAAC,EAKzCF,EAAgC,CAIpCG,YAAY,EACZC,cA8DF,SACEC,GACc,IAAdC,EAAY,UAAH,6CAAG,CAAC,EAEb,MAAMC,EAAM,gBACVF,EACAC,GAGF,GAAI,YAASJ,EAAMK,EAAIC,MACrB,OAAON,EAAKK,EAAIC,MAGlB,MAAMC,EAAY,IAAIR,EAAgBM,EAAKP,GAE3C,OADAE,EAAKK,EAAIC,MAAQC,EACVA,CACR,EA5ECF,MACAG,gBAAiB,kBACjBC,YAAa,cACbC,MAAO,QAEPV,KAAM,KACNW,YAAa,cACbC,SAAU,CACRC,kBA8EJ,SACEC,GAEA,MAAMC,EAAgBD,EAAUR,KAC1BU,EAA6BD,EAAcE,QAAQ,UAAW,IACpE,GACE,qBAA+BH,IACZ,WAAnBA,EAAUI,KACV,CAGA,MAAMC,EAAmB,WAEH,IADpBC,EAAA,uDAAsBf,IAGtB,GAA2D,oBAA/Ce,EAAeJ,GAGzB,MAAMK,EAAcC,OAAsC,wBACxDC,QAASR,IAMb,OAAQK,EAAeJ,IACzB,OAG+BQ,IAA3BV,EAAUW,cACZ,YAAWN,EAAkBL,EAAUW,cAIxC3B,EAAkBkB,GAA8BG,EAIhDpB,EAAgB2B,UAAkBV,GAIjC,WACE,MAAMW,EAAaC,KAAKC,YAAYC,KAAKF,KAAMb,GAAe,2BADnDgB,EAAS,yBAATA,EAAS,gBAEpB,OAAOJ,EAAWK,MAChBJ,KACAd,EAAUmB,kBAAoBF,EAAO,GAEzC,CACH,CAED,MAA8C,WAAvCjB,EAAUI,KAEZpB,EAAkBkB,GACnB,IACL,EApIGkB,UA4BJ,SAAmB5B,UACVN,EAAKM,EACb,EA7BG6B,aAuIJ,SAAsB9B,EAAkBC,GACtC,GAAa,eAATA,EACF,OAAO,KAKT,OAFmBA,CAGpB,EA9IG8B,YAAA,IAiCJ,SAAS/B,EAAIC,GAEX,GADAA,EAAOA,GAAQ,uBACV,YAASN,EAAMM,GAClB,MAAMe,EAAcC,OAAwB,UAAEC,QAASjB,IAEzD,OAAON,EAAKM,EACb,CAyGD,OAjICR,EAA2B,QAAIA,EAGhCuC,OAAOC,eAAexC,EAAW,OAAQ,CACvCyC,IAmDF,WAEE,OAAOF,OAAOG,KAAKxC,GAAMyC,KAAInC,GAAQN,EAAKM,IAC3C,IA/BDD,EAAS,IAAIN,EAsGND,CACT,CDpLoB4C,CAA4BC,GAmB9C,OAlBA7C,EAAUc,SAAW,OAAH,wBACbd,EAAUc,UAAQ,CACrBf,0BACA+C,gBAWF,SAAyBC,GACvB,YAAW/C,EAAW+C,EACvB,EAZCC,gBAAA,IACAC,aAAA,IACAC,WAAA,MAYKlD,CACT,CAEwBD,GHjCXoD,EAAS,IAAI,IAAO,wBKMjC,GAAI,oBAA0C,IAA1B,KAAa,SAAwB,CACvD,EAAO,KAAK,mIAMZ,MAAM,EAAe,KAAa,SAA+B,YAC7D,GAAc,EAAW,QAAQ,SAAW,GAC9C,EAAO,KAAK,qNAKf,CAEK,QAAWC,ECpBX,IAAiC,EAErC,0B,gCAA+B,E,gQCJpB,EAAqB,IAErB,EAAkB,KAAK,IACvB,EAAwB,SAKxB,EAA0B,KCEjC,EAAiE,CACrE,4BACE,kDACF,iBAA4B,2CAC5B,yBAAoC,mCACpC,iBACE,6FACF,cAAyB,kDACzB,8BACE,4EAaS,EAAgB,IAAI,IDtBV,gBACK,gBCwB1B,GAYI,SAAU,EAAc,GAC5B,OACE,aAAiB,KACjB,EAAM,KAAK,SAAQ,iBAEvB,CCxCgB,SAAAC,EAAyB,GAAwB,IAAxB,UAAEC,GAAsB,EAC/D,MAAO,4DAAqCA,iBAC9C,CAEM,SAAUC,EACdC,GAEA,MAAO,CACLC,MAAOD,EAASC,MAChBC,cAAsC,EACtCC,WA8DuCC,EA9DMJ,EAASG,UAgEjDE,OAAOD,EAAkBzC,QAAQ,IAAK,SA/D3C2C,aAAcC,KAAKC,OA6DvB,IAA2CJ,CA3D3C,CAEOK,eAAeC,EACpBC,EACAX,GAEA,MACMY,SADoCZ,EAASa,QACpBC,MAC/B,OAAO/C,EAAcC,OAAiC,kBACpD2C,cACAI,WAAYH,EAAUI,KACtBC,cAAeL,EAAUM,QACzBC,aAAcP,EAAUQ,QAE5B,CAEgB,SAAAC,EAAW,GAAqB,IAArB,OAAEC,GAAmB,EAC9C,OAAO,IAAIC,QAAQ,CACjB,eAAgB,mBAChBC,OAAQ,mBACR,iBAAkBF,GAEtB,C,SAEgBG,EACdC,EAAoB,GACyB,IAA7C,aAAEC,GAA2C,EAE7C,MAAMC,EAAUP,EAAWK,GAE3B,OADAE,EAAQC,OAAO,gBAmCjB,SAAgCF,GAC9B,MAAO,GAAGG,KAAyBH,GACrC,CArCkCI,CAAuBJ,IAChDC,CACT,CAeOnB,eAAeuB,EACpBC,GAEA,MAAMC,QAAeD,IAErB,OAAIC,EAAOd,QAAU,KAAOc,EAAOd,OAAS,IAEnCa,IAGFC,CACT,CCnFM,SAAUC,EAAMC,GACpB,OAAO,IAAIC,SAAcC,IACvBC,WAAWD,EAASF,EAAG,GAE3B,CCHO,MAAMI,EAAoB,oB,SAOjBC,IACd,IAGE,MAAMC,EAAe,IAAIC,WAAW,KAElCC,KAAKC,QAAWD,KAAyCE,UACpDC,gBAAgBL,GAGvBA,EAAa,GAAK,IAAcA,EAAa,GAAK,GAElD,MAAMM,EAUV,SAAgBN,GACd,MAAMO,GChC8BC,EDgCIR,EC/B5BS,KAAKC,OAAOC,gBAAgBH,IAC7BvF,QAAQ,MAAO,KAAKA,QAAQ,MAAO,MAF1C,IAAgCuF,EDoCpC,OAAOD,EAAUK,OAAO,EAAG,GAC7B,CAhBgBC,CAAOb,GAEnB,OAAOF,EAAkBgB,KAAKR,GAAOA,EApBd,EAqBxB,CAAC,MAAM,GAEN,MAvBuB,EAwBxB,CACH,CEzBM,SAAUS,EAAO/B,GACrB,MAAO,GAAGA,EAAUzD,WAAWyD,EAAUgC,OAC3C,CCDA,MAAMC,EAA2D,IAAIC,IAMrD,SAAAC,EAAWnC,EAAsBsB,GAC/C,MAAMc,EAAML,EAAO/B,GAEnBqC,EAAuBD,EAAKd,GAsD9B,SAA4Bc,EAAad,GACvC,MAAMgB,EAAUC,IACZD,GACFA,EAAQE,YAAY,CAAEJ,MAAKd,QAE7BmB,GACF,CA3DEC,CAAmBN,EAAKd,EAC1B,CAyCA,SAASe,EAAuBD,EAAad,GAC3C,MAAMqB,EAAYV,EAAmB1E,IAAI6E,GACzC,GAAKO,EAIL,IAAK,MAAMC,KAAYD,EACrBC,EAAStB,EAEb,CAUA,IAAIuB,EAA4C,KAEhD,SAASN,IAOP,OANKM,GAAoB,qBAAsB3B,OAC7C2B,EAAmB,IAAIC,iBAAiB,yBACxCD,EAAiBE,UAAYC,IAC3BX,EAAuBW,EAAEC,KAAKb,IAAKY,EAAEC,KAAK3B,IAAI,GAG3CuB,CACT,CAEA,SAASJ,IACyB,IAA5BR,EAAmBiB,MAAcL,IACnCA,EAAiBM,QACjBN,EAAmB,KAEvB,CCtFA,MAEMO,EAAoB,+BAS1B,IAAIC,EAA2D,KAC/D,SAASC,IAgBP,OAfKD,IACHA,EAAY,YAdM,kCACG,EAa+B,CAClDE,QAAS,CAACC,EAAIC,KAMZ,GACO,IADCA,EAEJD,EAAGE,kBAAkBN,EACxB,KAIAC,CACT,CAeOtE,eAAe4E,EACpB3D,EACA4D,GAEA,MAAMxB,EAAML,EAAO/B,GAEb6D,SADWP,KACHQ,YAAYV,EAAmB,aACvCW,EAAcF,EAAGE,YAAYX,GAC7BY,QAAkBD,EAAYxG,IAAI6E,GAQxC,aAPM2B,EAAYE,IAAIL,EAAOxB,SACvByB,EAAGK,KAEJF,GAAYA,EAAS1C,MAAQsC,EAAMtC,KACtCa,EAAWnC,EAAW4D,EAAMtC,KAGvBsC,CACT,CAGO7E,eAAeoF,EAAOnE,GAC3B,MAAMoC,EAAML,EAAO/B,GAEb6D,SADWP,KACHQ,YAAYV,EAAmB,mBACvCS,EAAGE,YAAYX,GAAmBgB,OAAOhC,SACzCyB,EAAGK,IACX,CAQOnF,eAAesF,EACpBrE,EACAsE,GAEA,MAAMlC,EAAML,EAAO/B,GAEb6D,SADWP,KACHQ,YAAYV,EAAmB,aACvCmB,EAAQV,EAAGE,YAAYX,GACvBY,QAAiDO,EAAMhH,IAC3D6E,GAEIoC,EAAWF,EAASN,GAa1B,YAXiBxH,IAAbgI,QACID,EAAMH,OAAOhC,SAEbmC,EAAMN,IAAIO,EAAUpC,SAEtByB,EAAGK,MAELM,GAAcR,GAAYA,EAAS1C,MAAQkD,EAASlD,KACtDa,EAAWnC,EAAWwE,EAASlD,KAG1BkD,CACT,CClFOzF,eAAe0F,EACpBC,GAEA,IAAIC,EAEJ,MAAMC,QAA0BP,EAAOK,EAAc1E,WAAW6E,IAC9D,MAAMD,EAwBV,SACEC,GAEA,MAAMC,EAA2BD,GAAY,CAC3CvD,IAAKP,IACLgE,mBAA6C,GAG/C,OAAOC,EAAqBF,EAC9B,CAjC8BG,CAAgCJ,GACpDK,EAyCV,SACER,EACAE,GAEA,GAA6C,IAAzCA,EAAkBG,mBAAkD,CACtE,IAAKI,UAAUC,OAAQ,CAKrB,MAAO,CACLR,oBACAD,oBALmChE,QAAQ0E,OAC3ChJ,EAAcC,OAA6B,gBAM9C,CAGD,MAAMgJ,EAA+C,CACnDhE,IAAKsD,EAAkBtD,IACvByD,mBAA6C,EAC7CQ,iBAAkB1G,KAAKC,OAEnB6F,EAkBV5F,eACE2F,EACAE,GAEA,IACE,MAAMY,QCxGHzG,eAAyC,EAAD,GAET,IADpC,UAAEiB,EAAS,yBAAEyF,GAAqD,GAClE,IAAEnE,GAAkC,EAEpC,MAAMoE,EAAWvH,EAAyB6B,GAEpCE,EAAUP,EAAWK,GAGrB2F,EAAmBF,EAAyBG,aAAa,CAC7DC,UAAU,IAEZ,GAAIF,EAAkB,CACpB,MAAMG,QAAyBH,EAAiBI,sBAC5CD,GACF5F,EAAQC,OAAO,oBAAqB2F,EAEvC,CAED,MAAME,EAAO,CACX1E,MACA2E,YAAa7F,EACb4B,MAAOhC,EAAUgC,MACjBkE,WAAYC,GAGRC,EAAuB,CAC3BC,OAAQ,OACRnG,UACA8F,KAAMM,KAAKC,UAAUP,IAGjB1H,QAAiBgC,GAAmB,IAAMkG,MAAMd,EAAUU,KAChE,GAAI9H,EAASmI,GAAI,CACf,MAAMC,QAAkDpI,EAASa,OAOjE,MANiE,CAC/DmC,IAAKoF,EAAcpF,KAAOA,EAC1ByD,mBAA2C,EAC3C9E,aAAcyG,EAAczG,aAC5B0G,UAAWtI,EAAiCqI,EAAcC,WAG7D,CACC,YAAY3H,EAAqB,sBAAuBV,EAE5D,CD2D8CsI,CACxClC,EACAE,GAEF,OAAOjB,EAAIe,EAAc1E,UAAWwF,EACrC,CAAC,MAAOxC,GAYP,MAXI6D,EAAc7D,IAAkC,MAA5BA,EAAE8D,WAAWzH,iBAG7B8E,EAAOO,EAAc1E,iBAGrB2D,EAAIe,EAAc1E,UAAW,CACjCsB,IAAKsD,EAAkBtD,IACvByD,mBAA6C,IAG3C/B,CACP,CACH,CA1CgC+D,CAC1BrC,EACAY,GAEF,MAAO,CAAEV,kBAAmBU,EAAiBX,sBAC9C,CAAM,OACoC,IAAzCC,EAAkBG,mBAEX,CACLH,oBACAD,oBAAqBqC,EAAyBtC,IAGzC,CAAEE,oBAEb,CA9E6BqC,CACvBvC,EACAE,GAGF,OADAD,EAAsBO,EAAiBP,oBAChCO,EAAiBN,iBAAiB,IAG3C,MLvCyB,KKuCrBA,EAAkBtD,IAEb,CAAEsD,wBAAyBD,GAG7B,CACLC,oBACAD,sBAEJ,CA2FA5F,eAAeiI,EACbtC,GAMA,IAAII,QAAiCoC,EACnCxC,EAAc1E,WAEhB,KAAoC,IAA7B8E,EAAMC,0BAELtE,EAAM,KAEZqE,QAAcoC,EAA0BxC,EAAc1E,WAGxD,GAAiC,IAA7B8E,EAAMC,mBAAkD,CAE1D,MAAM,kBAAEH,EAAiB,oBAAED,SACnBF,EAAqBC,GAE7B,OAAIC,GAIKC,CAEV,CAED,OAAOE,CACT,CAUA,SAASoC,EACPlH,GAEA,OAAOqE,EAAOrE,GAAW6E,IACvB,IAAKA,EACH,MAAMxI,EAAcC,OAAO,0BAE7B,OAAO0I,EAAqBH,EAAS,GAEzC,CAEA,SAASG,EAAqBF,GAC5B,OAcoE,KAHpEF,EAXmCE,GAcfC,oBAClBH,EAAkBW,iBAAmB4B,EAAqBtI,KAAKC,MAdxD,CACLwC,IAAKwD,EAAMxD,IACXyD,mBAA6C,GAI1CD,EAGT,IACEF,CAHF,CEzLO7F,eAAeqI,EAAyB,EAE7CxC,GAA8C,IAD9C,UAAE5E,EAAS,yBAAEyF,GAAqD,EAGlE,MAAMC,EAuCR,SACE1F,EAAoB,GACgB,IAApC,IAAEsB,GAAkC,EAEpC,MAAO,GAAGnD,EAAyB6B,MAAcsB,uBACnD,CA5CmB+F,CAA6BrH,EAAW4E,GAEnD1E,EAAUH,EAAmBC,EAAW4E,GAGxCe,EAAmBF,EAAyBG,aAAa,CAC7DC,UAAU,IAEZ,GAAIF,EAAkB,CACpB,MAAMG,QAAyBH,EAAiBI,sBAC5CD,GACF5F,EAAQC,OAAO,oBAAqB2F,EAEvC,CAED,MAAME,EAAO,CACXsB,aAAc,CACZpB,WAAYC,EACZnE,MAAOhC,EAAUgC,QAIfoE,EAAuB,CAC3BC,OAAQ,OACRnG,UACA8F,KAAMM,KAAKC,UAAUP,IAGjB1H,QAAiBgC,GAAmB,IAAMkG,MAAMd,EAAUU,KAChE,GAAI9H,EAASmI,GAAI,CAIf,OADEpI,QAFqDC,EAASa,OAIjE,CACC,YAAYH,EAAqB,sBAAuBV,EAE5D,CCnCOS,eAAewI,EACpB7C,GACoB,IAEhB8C,EAFJC,EAAe,UAAH,8CAGZ,MAAM3C,QAAcT,EAAOK,EAAc1E,WAAW6E,IAClD,IAAK6C,EAAkB7C,GACrB,MAAMxI,EAAcC,OAAO,kBAG7B,MAAMqL,EAAe9C,EAAS8B,UAC9B,IAAKc,GA+HT,SAA0Bd,GACxB,OACqD,IAAnDA,EAAUnI,gBAKd,SAA4BmI,GAC1B,MAAM7H,EAAMD,KAAKC,MACjB,OACEA,EAAM6H,EAAU/H,cAChB+H,EAAU/H,aAAe+H,EAAUlI,UAAYK,EAAM8I,CAEzD,CAVKC,CAAmBlB,EAExB,CApIyBmB,CAAiBH,GAEpC,OAAO9C,EACF,GAAmC,IAA/B8C,EAAanJ,cAGtB,OADAgJ,EA0BNzI,eACE2F,EACA+C,GAMA,IAAI3C,QAAciD,EAAuBrD,EAAc1E,WACvD,KAAyC,IAAlC8E,EAAM6B,UAAUnI,qBAEfiC,EAAM,KAEZqE,QAAciD,EAAuBrD,EAAc1E,WAGrD,MAAM2G,EAAY7B,EAAM6B,UACxB,OAAgC,IAA5BA,EAAUnI,cAEL+I,EAAiB7C,EAAe+C,GAEhCd,CAEX,CAjDqBqB,CAA0BtD,EAAe+C,GACjD5C,EACF,CAEL,IAAKM,UAAUC,OACb,MAAM/I,EAAcC,OAAO,eAG7B,MAAMgJ,EAkIZ,SACET,GAEA,MAAMoD,EAA2C,CAC/CzJ,cAAwC,EACxC0J,YAAarJ,KAAKC,OAEpB,OAAO,OAAP,wBACK+F,GAAQ,CACX8B,UAAWsB,GAEf,CA7I8BE,CAAoCtD,GAE5D,OADA2C,EAsENzI,eACE2F,EACAE,GAEA,IACE,MAAM+B,QAAkBS,EACtB1C,EACAE,GAEIwD,EACD,+BAAAxD,GACH,CAAA+B,cAGF,aADMhD,EAAIe,EAAc1E,UAAWoI,GAC5BzB,CACR,CAAC,MAAO3D,GACP,IACE6D,EAAc7D,IACe,MAA5BA,EAAE8D,WAAWzH,YAAkD,MAA5B2D,EAAE8D,WAAWzH,WAK5C,CACL,MAAM+I,EACD,+BAAAxD,GACH,CAAA+B,UAAW,CAAEnI,cAAe,WAExBmF,EAAIe,EAAc1E,UAAWoI,EACpC,YAPOjE,EAAOO,EAAc1E,WAQ7B,MAAMgD,CACP,CACH,CAtGqBqF,CAAyB3D,EAAeY,GAChDA,CACR,KAMH,OAHkBkC,QACRA,EACL1C,EAAM6B,SAEb,CAyCA,SAASoB,EACP/H,GAEA,OAAOqE,EAAOrE,GAAW6E,IACvB,IAAK6C,EAAkB7C,GACrB,MAAMxI,EAAcC,OAAO,kBAG7B,MAAMqL,EAAe9C,EAAS8B,UAC9B,OAqFqD,KAFpBA,EAnFDgB,GAqFtBnJ,eACVmI,EAAUuB,YAAcf,EAAqBtI,KAAKC,MApF3C,+BAAA+F,GAAQ,CACX8B,UAAW,CAAEnI,cAAe,KAIzBqG,EA4EX,IAAqC8B,CA5ElB,GAEnB,CAoCA,SAASe,EACP9C,GAEA,YACwBpI,IAAtBoI,GACgE,IAAhEA,EAAkBG,kBAEtB,CCnJOhG,eAAeuJ,EACpB5D,GACoB,IAApB+C,EAAe,UAAH,8CAEZ,MAAMc,EAAoB7D,QAS5B3F,eACE2F,GAEA,MAAM,oBAAEC,SAA8BF,EAAqBC,GAEvDC,SAEIA,CAEV,CAjBQ6D,CAAiCD,GAKvC,aADwBhB,EAAiBgB,EAAmBd,IAC3ClJ,KACnB,CCWA,SAAS,EAAqB,GAC5B,OAAO,EAAc,OAA4C,6BAC/D,aAEJ,CC3BA,MAAMkK,EAAqB,gBAGrBC,EACJC,IAEA,MAAMtN,EAAMsN,EAAUC,YAAY,OAAOhD,eAEnC5F,EDfF,SAA2B,GAC/B,IAAK,IAAQ,EAAI,QACf,MAAM,EAAqB,qBAG7B,IAAK,EAAI,KACP,MAAM,EAAqB,YAI7B,MAAM,EAA2C,CAC/C,YACA,SACA,SAGF,IAAK,MAAM,KAAW,EACpB,IAAK,EAAI,QAAQ,GACf,MAAM,EAAqB,GAI/B,MAAO,CACL,QAAS,EAAI,KACb,UAAW,EAAI,QAAQ,UACvB,OAAQ,EAAI,QAAQ,OACpB,MAAO,EAAI,QAAQ,MAEvB,CCboB6I,CAAiBxN,GASnC,MANqD,CACnDA,MACA2E,YACAyF,yBAL+B,uBAAapK,EAAK,aAMjDyN,QAAS,IAAMnI,QAAQC,UAED,EAGpBmI,EACJJ,IAEA,MAAMtN,EAAMsN,EAAUC,YAAY,OAAOhD,eAEnClB,EAAgB,uBAAarJ,EAAKoN,GAAoB7C,eAM5D,MAJ8D,CAC5DoD,MAAO,IC5BJjK,eAAqB2F,GAC1B,MAAM6D,EAAoB7D,GACpB,kBAAEE,EAAiB,oBAAED,SAA8BF,EACvD8D,GAWF,OARI5D,EACFA,EAAoBsE,MAAMC,QAAQ9J,OAIlCmI,EAAiBgB,GAAmBU,MAAMC,QAAQ9J,OAG7CwF,EAAkBtD,GAC3B,CDaiB0H,CAAMtE,GACnB4D,SAAWb,GAA2Ba,EAAS5D,EAAe+C,GAEpC,EAI5B,6BACE,IAAI,IAAUgB,EAAoBC,EAAoC,WAExE,6BACE,IAAI,IAtC4B,yBAwC9BK,EAED,YjBzCL,0BAAgB,EAAM,GAEtB,0BAAgB,EAAM,EAAS,WEhBxB,MAAMI,EAAkB,4BAClBC,EAAmB,uCAEnBC,EACX,0FAEWC,GAAW,6CAKXC,GAAsB,kBAmBnC,IAAYC,GiBOAA,GCrCN,SAAUC,GAAcjI,GAC5B,MAAMkI,EAAa,IAAIzI,WAAWO,GAElC,OADqBC,KAAKC,OAAOC,gBAAgB+H,IAC7BzN,QAAQ,KAAM,IAAIA,QAAQ,MAAO,KAAKA,QAAQ,MAAO,IAC3E,CAEM,SAAU0N,GAAcC,GAC5B,MACMC,GAAUD,EADA,IAAIE,QAAQ,EAAKF,EAAaG,OAAS,GAAM,IAE1D9N,QAAQ,MAAO,KACfA,QAAQ,KAAM,KAEX+N,EAAUC,KAAKJ,GACfK,EAAc,IAAIjJ,WAAW+I,EAAQD,QAE3C,IAAK,IAAII,EAAI,EAAGA,EAAIH,EAAQD,SAAUI,EACpCD,EAAYC,GAAKH,EAAQI,WAAWD,GAEtC,OAAOD,CACT,ElBWA,SAAYV,GACV,mCACA,kDACD,CAHD,CAAYA,QAGX,KiBID,SAAYA,GACV,gCACA,6CACD,CAHD,CAAYA,QAGX,KEID,MAAMa,GAAc,uBAKdC,GAAiB,EACjBC,GAAwB,yBC3CvB,MAAM,GAAgB,8BACvB,GAAmB,EACnB,GAAoB,2BAS1B,IAAI,GAAuD,KAC3D,SAAS,KAeP,OAdK,KACH,GAAY,YAAO,GAAe,GAAkB,CAClDhH,QAAS,CAACiH,EAAW/G,KAKnB,GACO,IADCA,EAEJ+G,EAAU9G,kBAAkB,GAC/B,KAIA,EACT,CAGO3E,eAAe0L,GACpBC,GAEA,MAAMtI,EAAM,GAAOsI,GACblH,QAAW,KACXmH,QAAsBnH,EACzBM,YAAY,IACZC,YAAY,IACZxG,IAAI6E,GAEP,GAAIuI,EACF,OAAOA,EACF,CAEL,MAAMC,QDAH7L,eACL8L,GAEA,GAAI,cAAeC,UAAW,CAG5B,MAKMC,SAJJD,UAGAE,aACwBvN,KAAI+F,GAAMA,EAAGlI,OAEvC,IAAKyP,EAAQE,SAASZ,IAEpB,OAAO,IAEV,CAED,IAAIM,EAAoC,KAkFxC,aAhFiB,YAAON,GAAaC,GAAgB,CACnD/G,QAASxE,MAAOyE,EAAIC,EAAYyH,EAAYC,K,MAC1C,GAAI1H,EAAa,EAEf,OAGF,IAAKD,EAAG4H,iBAAiBC,SAASd,IAEhC,OAGF,MAAMxG,EAAcoH,EAAmBpH,YAAYwG,IAC7C3G,QAAcG,EAAYuH,MAAM,eAAe/N,IAAIsN,GAGzD,SAFM9G,EAAYwH,QAEb3H,EAKL,GAAmB,IAAfH,EAAkB,CACpB,MAAM+H,EAAa5H,EAEnB,IAAK4H,EAAWC,OAASD,EAAWE,SAAWF,EAAW9F,SACxD,OAGFiF,EAAe,CACbpM,MAAOiN,EAAWG,SAClBC,WAAqC,QAAzB,EAAAJ,EAAWI,kBAAc,QAAA/M,KAAKC,MAC1C+M,oBAAqB,CACnBJ,KAAMD,EAAWC,KACjBC,OAAQF,EAAWE,OACnBhG,SAAU8F,EAAW9F,SACrBoG,QAASN,EAAWM,QACpBC,SACiC,kBAAxBP,EAAWO,SACdP,EAAWO,SACXtC,GAAc+B,EAAWO,WAGpC,MAAM,GAAmB,IAAftI,EAAkB,CAC3B,MAAM+H,EAAa5H,EAEnB+G,EAAe,CACbpM,MAAOiN,EAAWG,SAClBC,WAAYJ,EAAWI,WACvBC,oBAAqB,CACnBJ,KAAMhC,GAAc+B,EAAWC,MAC/BC,OAAQjC,GAAc+B,EAAWE,QACjChG,SAAU8F,EAAW9F,SACrBoG,QAASN,EAAWM,QACpBC,SAAUtC,GAAc+B,EAAWO,WAGxC,MAAM,GAAmB,IAAftI,EAAkB,CAC3B,MAAM+H,EAAa5H,EAEnB+G,EAAe,CACbpM,MAAOiN,EAAWG,SAClBC,WAAYJ,EAAWI,WACvBC,oBAAqB,CACnBJ,KAAMhC,GAAc+B,EAAWC,MAC/BC,OAAQjC,GAAc+B,EAAWE,QACjChG,SAAU8F,EAAW9F,SACrBoG,QAASN,EAAWM,QACpBC,SAAUtC,GAAc+B,EAAWO,WAGxC,MAGF5I,cAGG,YAASkH,UACT,YAAS,8BACT,YAAS,aAKjB,SACEM,GAEA,IAAKA,IAAiBA,EAAakB,oBACjC,OAAO,EAET,MAAM,oBAAEA,GAAwBlB,EAChC,MACqC,kBAA5BA,EAAaiB,YACpBjB,EAAaiB,WAAa,GACI,kBAAvBjB,EAAapM,OACpBoM,EAAapM,MAAMwL,OAAS,GACQ,kBAA7B8B,EAAoBJ,MAC3BI,EAAoBJ,KAAK1B,OAAS,GACI,kBAA/B8B,EAAoBH,QAC3BG,EAAoBH,OAAO3B,OAAS,GACI,kBAAjC8B,EAAoBnG,UAC3BmG,EAAoBnG,SAASqE,OAAS,GACC,kBAAhC8B,EAAoBC,SAC3BD,EAAoBC,QAAQ/B,OAAS,GACG,kBAAjC8B,EAAoBE,UAC3BF,EAAoBE,SAAShC,OAAS,CAE1C,CA1BSiC,CAAkBrB,GAAgBA,EAAe,IAC1D,CCtGkCsB,CAC5BvB,EAAqB1K,UAAU6K,UAEjC,GAAID,EAEF,aADMsB,GAAMxB,EAAsBE,GAC3BA,CAEV,CACH,CAGO7L,eAAemN,GACpBxB,EACAC,GAEA,MAAMvI,EAAM,GAAOsI,GAEb7G,SADW,MACHC,YAAY,GAAmB,aAG7C,aAFMD,EAAGE,YAAY,IAAmBE,IAAI0G,EAAcvI,SACpDyB,EAAGK,KACFyG,CACT,CAsBA,SAAS,GAAO,GAA2C,IAA3C,UAAE3K,GAAyC,EACzD,OAAOA,EAAUgC,KACnB,CnB1EO,MAAMmK,GAAiC,CAC5C,4BACE,kDACF,2BACE,gDACF,uBACE,wDACF,qBACE,qEACF,qBACE,mEACF,sBACE,2EACF,yBACE,mGACF,qCACE,+EACF,yBACE,qEACF,2BACE,2DACF,2BACE,yEAEF,sBACE,oEACF,wBACE,wDACF,yBACE,4IAEF,0BACE,uEACF,qBACE,iEACF,oBAA+B,yCAC/B,gCACE,yIAcS,GAAgB,IAAI,IAC/B,YACA,YACAA,IoBwBKpN,eAAeqN,GACpB1B,EACAnM,GAEA,MAEM8N,EAAqB,CACzBhG,OAAQ,SACRnG,cAJoB,GAAWwK,IAOjC,IACE,MAAMpM,QAAiBkI,MACrB,GAAG8F,GAAY5B,EAAqB1K,cAAczB,IAClD8N,GAEIE,QAAkCjO,EAASa,OACjD,GAAIoN,EAAanN,MAAO,CACtB,MAAMI,EAAU+M,EAAanN,MAAMI,QACnC,MAAM,GAAclD,OAA2C,4BAC7DkQ,UAAWhN,GAEd,CACF,CAAC,MAAOiN,GACP,MAAM,GAAcnQ,OAA2C,4BAC7DkQ,UAAY,OAAAC,QAAG,IAAHA,OAAG,EAAHA,EAAeC,YAE9B,CACH,CAEA,SAASJ,GAAY,GAAwB,IAAxB,UAAElO,GAAsB,EAC3C,MAAO,GAAGkL,eAAqBlL,iBACjC,CAEAW,eAAe,GAAW,GAGK,IAHL,UACxBiB,EAAS,cACT0E,GAC6B,EAC7B,MAAMiC,QAAkBjC,EAAc4D,WAEtC,OAAO,IAAIzI,QAAQ,CACjB,eAAgB,mBAChBC,OAAQ,mBACR,iBAAkBE,EAAUJ,OAC5B,qCAAsC,OAAO+G,KAEjD,CAEA,SAASgG,GAAQ,GAKK,IALL,OACfjB,EAAM,KACND,EAAI,SACJ/F,EAAQ,SACRqG,GACoB,EACpB,MAAM/F,EAAuB,CAC3B4G,IAAK,CACHlH,WACA+F,OACAC,WAQJ,OAJIK,IAAa1C,IACfrD,EAAK4G,IAAIC,kBAAoBd,GAGxB/F,CACT,CCxJA,MAAM8G,GAAsB,OAErB/N,eAAegO,GACpBC,GAEA,MAAMC,QAoHRlO,eACEmO,EACAnB,GAEA,MAAMoB,QAAqBD,EAAeE,YAAYC,kBACtD,GAAIF,EACF,OAAOA,EAGT,OAAOD,EAAeE,YAAYE,UAAU,CAC1CC,iBAAiB,EAGjBC,qBAAsB7D,GAAcoC,IAExC,CAnIiC0B,CAC7BT,EAAUE,eACVF,EAAUjB,UAGNF,EAA2C,CAC/CE,SAAUiB,EAAUjB,SACpBD,QAASkB,EAAUE,eAAgBQ,MACnChI,SAAUuH,EAAiBvH,SAC3B+F,KAAMhC,GAAcwD,EAAiBlL,OAAO,SAC5C2J,OAAQjC,GAAcwD,EAAiBlL,OAAO,YAG1C4I,QAAqBF,GAAMuC,EAAUtC,sBAC3C,GAAKC,EAGE,IAuHT,SACEgD,EACAC,GAEA,MAAMC,EAAkBD,EAAe7B,WAAa4B,EAAU5B,SACxD+B,EAAkBF,EAAelI,WAAaiI,EAAUjI,SACxDqI,EAAcH,EAAenC,OAASkC,EAAUlC,KAChDuC,EAAgBJ,EAAelC,SAAWiC,EAAUjC,OAE1D,OAAOmC,GAAmBC,GAAmBC,GAAeC,CAC9D,CAhIKC,CAAatD,EAAakB,oBAAsBA,GAc5C,OAAIhN,KAAKC,OAAS6L,EAAaiB,WAAakB,GAwCrD/N,eACEiO,EACArC,GAEA,IACE,MAAMuD,QDrCHnP,eACL2L,EACAC,GAEA,MAAMzK,QAAgB,GAAWwK,GAC3B1E,EAAO2G,GAAQhC,EAAakB,qBAE5BsC,EAAgB,CACpB9H,OAAQ,QACRnG,UACA8F,KAAMM,KAAKC,UAAUP,IAGvB,IAAIuG,EACJ,IACE,MAAMjO,QAAiBkI,MACrB,GAAG8F,GAAY5B,EAAqB1K,cAAc2K,EAAapM,QAC/D4P,GAEF5B,QAAqBjO,EAASa,MAC/B,CAAC,MAAOsN,GACP,MAAM,GAAcnQ,OAAsC,uBACxDkQ,UAAY,OAAAC,QAAG,IAAHA,OAAG,EAAHA,EAAeC,YAE9B,CAED,GAAIH,EAAanN,MAAO,CACtB,MAAMI,EAAU+M,EAAanN,MAAMI,QACnC,MAAM,GAAclD,OAAsC,uBACxDkQ,UAAWhN,GAEd,CAED,IAAK+M,EAAahO,MAChB,MAAM,GAAcjC,OAAO,yBAG7B,OAAOiQ,EAAahO,KACtB,CCD+B6P,CACzBpB,EAAUtC,qBACVC,GAGI0D,EAAmB,+BACpB1D,GAAY,CACfpM,MAAO2P,EACPtC,WAAY/M,KAAKC,QAInB,aADMoN,GAAMc,EAAUtC,qBAAsB2D,GACrCH,CACR,CAAC,MAAOlL,GAEP,YADMsL,GAAoBtB,GACpBhK,CACP,CACH,CA5DWuL,CAAYvB,EAAW,CAC5BzO,MAAOoM,EAAapM,MACpBqN,WAAY/M,KAAKC,MACjB+M,wBAIKlB,EAAapM,MApBpB,UACQ6N,GACJY,EAAUtC,qBACVC,EAAapM,MAEhB,CAAC,MAAOyE,GAEPkG,QAAQsF,KAAKxL,EACd,CAED,OAAOyL,GAAYzB,EAAUtC,qBAAuBmB,EAWrD,CA1BC,OAAO4C,GAAYzB,EAAUtC,qBAAsBmB,EA2BvD,CAMO9M,eAAeuP,GACpBtB,GAEA,MAAMrC,QAAqBF,GAAMuC,EAAUtC,sBACvCC,UACIyB,GACJY,EAAUtC,qBACVC,EAAapM,aFDZQ,eACL2L,GAEA,MAAMtI,EAAM,GAAOsI,GAEb7G,SADW,MACHC,YAAY,GAAmB,mBACvCD,EAAGE,YAAY,IAAmBK,OAAOhC,SACzCyB,EAAGK,IACX,CELUwK,CAAS1B,EAAUtC,uBAI3B,MAAMuC,QACED,EAAUE,eAAgBE,YAAYC,kBAC9C,OAAIJ,GACKA,EAAiB0B,aAK5B,CA0BA5P,eAAe0P,GACb/D,EACAmB,GAEA,MAAMtN,QDpGDQ,eACL2L,EACAmB,GAEA,MAAM3L,QAAgB,GAAWwK,GAC3B1E,EAAO2G,GAAQd,GAEf+C,EAAmB,CACvBvI,OAAQ,OACRnG,UACA8F,KAAMM,KAAKC,UAAUP,IAGvB,IAAIuG,EACJ,IACE,MAAMjO,QAAiBkI,MACrB8F,GAAY5B,EAAqB1K,WACjC4O,GAEFrC,QAAqBjO,EAASa,MAC/B,CAAC,MAAOsN,GACP,MAAM,GAAcnQ,OAAyC,0BAC3DkQ,UAAY,OAAAC,QAAG,IAAHA,OAAG,EAAHA,EAAeC,YAE9B,CAED,GAAIH,EAAanN,MAAO,CACtB,MAAMI,EAAU+M,EAAanN,MAAMI,QACnC,MAAM,GAAclD,OAAyC,0BAC3DkQ,UAAWhN,GAEd,CAED,IAAK+M,EAAahO,MAChB,MAAM,GAAcjC,OAAO,4BAG7B,OAAOiQ,EAAahO,KACtB,CC8DsBsQ,CAClBnE,EACAmB,GAEIlB,EAA6B,CACjCpM,QACAqN,WAAY/M,KAAKC,MACjB+M,uBAGF,aADMK,GAAMxB,EAAsBC,GAC3BA,EAAapM,KACtB,CCjIM,SAAUuQ,GACdC,GAEA,MAAMC,EAA0B,CAC9BC,KAAMF,EAAgBE,KAEtBC,YAAaH,EAAgBI,aAE7BC,UAAWL,EAAgBM,cAO7B,OAGF,SACEL,EACAM,GAEA,IAAKA,EAAuBC,aAC1B,OAGFP,EAAQO,aAAe,CAAC,EAExB,MAAMC,EAAQF,EAAuBC,aAAcC,MAC7CA,IACJR,EAAQO,aAAcC,MAAQA,GAGhC,MAAMxJ,EAAOsJ,EAAuBC,aAAcvJ,KAC5CA,IACJgJ,EAAQO,aAAcvJ,KAAOA,GAG/B,MAAMyJ,EAAQH,EAAuBC,aAAcE,MAC7CA,IACJT,EAAQO,aAAcE,MAAQA,GAGhC,MAAMC,EAAOJ,EAAuBC,aAAcG,KAC5CA,IACJV,EAAQO,aAAcG,KAAOA,EAEjC,CApCEC,CAA6BX,EAASD,GAsCxC,SACEC,EACAM,GAEA,IAAKA,EAAuBrM,KAC1B,OAGF+L,EAAQ/L,KAAOqM,EAAuBrM,IACxC,CA9CE2M,CAAqBZ,EAASD,GAgDhC,SACEC,EACAM,G,cAGA,IACGA,EAAuBO,cACc,QAArC,EAAAP,EAAuBC,oBAAc,eAAAO,cAEtC,OAGFd,EAAQa,WAAa,CAAC,EAEtB,MAAME,EACmC,QAAvC,EAAiC,QAAjC,EAAAT,EAAuBO,kBAAU,eAAEE,YAAI,QACJ,QAAnC,EAAAT,EAAuBC,oBAAY,eAAEO,aAEjCC,IACJf,EAAQa,WAAYE,KAAOA,GAI7B,MAAMC,EAAkD,QAAjC,EAAAV,EAAuBO,kBAAU,eAAEI,gBACpDD,IACJhB,EAAQa,WAAYG,eAAiBA,EAEzC,CA1EEE,CAAoBlB,EAASD,GAEtBC,CACT,CCqMgB,SAAAmB,GAAcC,EAAYC,GACxC,MAAMC,EAAc,GACpB,IAAK,IAAInG,EAAI,EAAGA,EAAIiG,EAAGrG,OAAQI,IAC7BmG,EAAYC,KAAKH,EAAGI,OAAOrG,IACvBA,EAAIkG,EAAGtG,QACTuG,EAAYC,KAAKF,EAAGG,OAAOrG,IAI/B,OAAOmG,EAAYG,KAAK,GAC1B,CV3LA,SAAS,GAAqBC,GAC5B,OAAO,GAAcpU,OAA4C,6BAC/DoU,aAEJ,CUvByBP,GACvB,mCACA,mCAGwBA,GACxB,uBACA,uB,MCjBWQ,GAoBX,WAAAC,CACEvV,EACAqJ,EACAmM,GAhBF,KAAwC,0CAAY,EAEpD,KAA0B,2BAGf,KAEX,KAAgB,iBACd,KAEF,KAAS,UAAe,GACxB,KAAmB,qBAAY,EAO7B,MAAM7Q,EX7BJ,SAA2B3E,GAC/B,IAAKA,IAAQA,EAAIF,QACf,MAAM,GAAqB,4BAG7B,IAAKE,EAAIC,KACP,MAAM,GAAqB,YAI7B,MAAMwV,EAAmD,CACvD,YACA,SACA,QACA,sBAGI,QAAE3V,GAAYE,EACpB,IAAK,MAAM0V,KAAWD,EACpB,IAAK3V,EAAQ4V,GACX,MAAM,GAAqBA,GAI/B,MAAO,CACLxU,QAASlB,EAAIC,KACb8C,UAAWjD,EAAQiD,UACnBwB,OAAQzE,EAAQyE,OAChBoC,MAAO7G,EAAQ6G,MACf6I,SAAU1P,EAAQ6V,kBAEtB,CWFsB,CAAiB3V,GAEnCuB,KAAK8N,qBAAuB,CAC1BrP,MACA2E,YACA0E,gBACAmM,oBAEH,CAED,OAAA/H,GACE,OAAOnI,QAAQC,SAChB,EC1CI7B,eAAekS,GACpBjE,GAEA,IACEA,EAAUE,qBAAuB/H,UAAU+L,cAAcC,SACvDhI,EACA,CACEuE,MAAOtE,IASX4D,EAAUE,eAAe7I,SAAS4E,OAAM,QAGzC,CAAC,MAAOjG,GACP,MAAM,GAAc1G,OAA8C,sCAChE8U,oBAAiC,OAAXpO,QAAA,IAAAA,OAAA,EAAAA,EAAaxD,SAEtC,CACH,CCrBOT,eAAeuJ,GACpB0E,EACA7R,GAEA,IAAKgK,UACH,MAAM,GAAc7I,OAAO,4BAO7B,GAJgC,YAA5B+U,aAAaC,kBACTD,aAAaE,oBAGW,YAA5BF,aAAaC,WACf,MAAM,GAAchV,OAAO,sBAM7B,aCxBKyC,eACLiO,EACAjB,GAEMA,EACJiB,EAAUjB,SAAWA,EACXiB,EAAUjB,WACpBiB,EAAUjB,SAAW1C,EAEzB,CDYQmI,CAAexE,EAAkB,OAAP7R,QAAO,IAAPA,OAAO,EAAPA,EAAS4Q,gBEnBpChN,eACLiO,EACAE,GAMA,GAJKA,GAAmBF,EAAUE,sBAC1B+D,GAAkBjE,GAGrBE,IAAoBF,EAAUE,eAAnC,CAIA,KAAMA,aAA0BuE,2BAC9B,MAAM,GAAcnV,OAAO,2BAG7B0Q,EAAUE,eAAiBA,CAN1B,CAOH,CFGQwE,CAAY1E,EAAkB,OAAP7R,QAAO,IAAPA,OAAO,EAAPA,EAASwW,2BAE/B5E,GAAiBC,EAC1B,CGhBOjO,eAAe6S,GACpB5E,EACA6E,EACA5O,GAEA,MAAM6O,EAaR,SAAsBD,GACpB,OAAQA,GACN,KAAKrI,GAAYuI,qBACf,MAAO,oBACT,KAAKvI,GAAYwI,cACf,MAAO,0BACT,QACE,MAAM,IAAIC,MAEhB,CAtBoBC,CAAaL,UAEvB7E,EAAUtC,qBAAqBmG,kBAAkBtT,OAC/C4U,SAASL,EAAW,CAE5BM,WAAYnP,EAAKsG,IACjB8I,aAAcpP,E9BXmB,kB8BYjCqP,aAAcrP,E9BXmB,iB8BYjCsP,oBAAqBC,KAAKC,MAAM5T,KAAKC,MAAQ,MAGjD,CCjBOC,eAAe2T,GACpB1F,EACA2F,GAEA,MAAM5D,EAAkB4D,EAAM1P,KAE9B,IAAK8L,EAAgB6D,oBACnB,OAIA5F,EAAU6F,kBACV9D,EAAgB8C,cAAgBrI,GAAYwI,gBAEF,oBAA/BhF,EAAU6F,iBACnB7F,EAAU6F,iBAAiB/D,GAAmBC,IAE9C/B,EAAU6F,iBAAiBC,KAAKhE,GAAmBC,KAKvD,MAAMgE,EAAchE,EAAgB9L,KC9BhC,IAA2BA,EAER,kBAFQA,EDgCZ8P,IC9BkB9P,GAAQsG,MAAuBtG,GD+Bd,MAApD8P,E/BrB8C,uB+BuBxCnB,GAAW5E,EAAW+B,EAAgB8C,YAAckB,EAE9D,C,2CElBMC,GACJrK,IAEA,MAAMqE,EAAY,IAAI2D,GACpBhI,EAAUC,YAAY,OAAOhD,eAC7B+C,EAAUC,YAAY,0BAA0BhD,eAChD+C,EAAUC,YAAY,uBAOxB,OAJAzD,UAAU+L,cAAc+B,iBAAiB,WAAWjQ,GAClD0P,GAAqB1F,EAA+BhK,KAG/CgK,CAAS,EAGZkG,GACJvK,IAEA,MAAMqE,EAAYrE,EACfC,YAAY,aACZhD,eAMH,MAJ6C,CAC3C0C,SAAWnN,GAA8BmN,GAAS0E,EAAW7R,GAGvC,ECrCnB4D,eAAeoU,KACpB,UAGQ,aACP,CAAC,MAAOnQ,GACP,OAAO,CACR,CAID,MACoB,qBAAXoQ,QACP,eACA,eACA,kBAAmBjO,WACnB,gBAAiBiO,QACjB,iBAAkBA,QAClB,UAAWA,QACX3B,0BAA0B/U,UAAU2W,eAAe,qBACnDC,iBAAiB5W,UAAU2W,eAAe,SAE9C,CCLgB,cAAgD,IAA3B,yDAAmB,mBAiBtD,OAZA,KAAoB,MAClB,IAEE,IAAK,EACH,MAAM,GAAc,OAAM,sBAC3B,IAEH,IAEE,MAAM,GAAc,OAAM,yBAAkC,IAGzD,uBAAa,YAAmB,GAAM,aAAa,cAC5D,CA4CO,eAAe,GACpB,EACA,GAGA,OAAOE,GADP,EAAY,YAAmB,GACiB,EAClD,CA8BgB,YACd,EACA,GAGA,OC1Hc,SACdvG,EACAwG,GAEA,IAAKrO,UACH,MAAM,GAAc7I,OAAO,4BAK7B,OAFA0Q,EAAU6F,iBAAmBW,EAEtB,KACLxG,EAAU6F,iBAAmB,IAAI,CAErC,CD6GSY,CADP,EAAY,YAAmB,GACkB,EACnD,CFzDE,6BACE,IAAI,IAAU,YAAaT,GAA6C,WAG1E,6BACE,IAAI,IACF,qBACAE,GAED,YAGH,0BAAgB,GAAM,IAEtB,0BAAgB,GAAM,GAAS,U,4EI3GjC,o6BAqBa,MCJPQ,EAAoB,SAAUC,GAElC,MAAMC,EAAgB,GACtB,IAAIC,EAAI,EACR,IAAK,IAAI1J,EAAI,EAAGA,EAAIwJ,EAAI5J,OAAQI,IAAK,CACnC,IAAI2J,EAAIH,EAAIvJ,WAAWD,GACnB2J,EAAI,IACNF,EAAIC,KAAOC,EACFA,EAAI,MACbF,EAAIC,KAAQC,GAAK,EAAK,IACtBF,EAAIC,KAAY,GAAJC,EAAU,KAEL,SAAZ,MAAJA,IACD3J,EAAI,EAAIwJ,EAAI5J,QACyB,SAAZ,MAAxB4J,EAAIvJ,WAAWD,EAAI,KAGpB2J,EAAI,QAAgB,KAAJA,IAAe,KAA6B,KAAtBH,EAAIvJ,aAAaD,IACvDyJ,EAAIC,KAAQC,GAAK,GAAM,IACvBF,EAAIC,KAASC,GAAK,GAAM,GAAM,IAC9BF,EAAIC,KAASC,GAAK,EAAK,GAAM,IAC7BF,EAAIC,KAAY,GAAJC,EAAU,MAEtBF,EAAIC,KAAQC,GAAK,GAAM,IACvBF,EAAIC,KAASC,GAAK,EAAK,GAAM,IAC7BF,EAAIC,KAAY,GAAJC,EAAU,IAEzB,CACD,OAAOF,CACT,EA4Da/J,EAAiB,CAI5BkK,eAAgB,KAKhBC,eAAgB,KAMhBC,sBAAuB,KAMvBC,sBAAuB,KAMvBC,kBACE,iEAKF,gBAAIC,GACF,OAAOxX,KAAKuX,kBAAoB,K,EAMlC,wBAAIE,GACF,OAAOzX,KAAKuX,kBAAoB,K,EAUlCG,mBAAoC,oBAATrK,KAW3B,eAAAsK,CAAgBC,EAA8BC,GAC5C,IAAKC,MAAMC,QAAQH,GACjB,MAAMvC,MAAM,iDAGdrV,KAAKgY,QAEL,MAAMC,EAAgBJ,EAClB7X,KAAKqX,sBACLrX,KAAKmX,eAEHe,EAAS,GAEf,IAAK,IAAI3K,EAAI,EAAGA,EAAIqK,EAAMzK,OAAQI,GAAK,EAAG,CACxC,MAAM4K,EAAQP,EAAMrK,GACd6K,EAAY7K,EAAI,EAAIqK,EAAMzK,OAC1BkL,EAAQD,EAAYR,EAAMrK,EAAI,GAAK,EACnC+K,EAAY/K,EAAI,EAAIqK,EAAMzK,OAC1BoL,EAAQD,EAAYV,EAAMrK,EAAI,GAAK,EAEnCiL,EAAWL,GAAS,EACpBM,GAAqB,EAARN,IAAiB,EAAME,GAAS,EACnD,IAAIK,GAAqB,GAARL,IAAiB,EAAME,GAAS,EAC7CI,EAAmB,GAARJ,EAEVD,IACHK,EAAW,GAENP,IACHM,EAAW,KAIfR,EAAOvE,KACLsE,EAAcO,GACdP,EAAcQ,GACdR,EAAcS,GACdT,EAAcU,GAEjB,CAED,OAAOT,EAAOrE,KAAK,G,EAWrB,YAAA+E,CAAahB,EAAeC,GAG1B,OAAI7X,KAAK0X,qBAAuBG,EACvBhT,KAAK+S,GAEP5X,KAAK2X,gBAAgBb,EAAkBc,GAAQC,E,EAWxD,YAAAgB,CAAajB,EAAeC,GAG1B,OAAI7X,KAAK0X,qBAAuBG,EACvBxK,KAAKuK,GA3LQ,SAAUkB,GAElC,MAAM9B,EAAgB,GACtB,IAAI+B,EAAM,EACR7B,EAAI,EACN,KAAO6B,EAAMD,EAAM3L,QAAQ,CACzB,MAAM6L,EAAKF,EAAMC,KACjB,GAAIC,EAAK,IACPhC,EAAIE,KAAOpS,OAAOC,aAAaiU,QAC1B,GAAIA,EAAK,KAAOA,EAAK,IAAK,CAC/B,MAAMC,EAAKH,EAAMC,KACjB/B,EAAIE,KAAOpS,OAAOC,cAAoB,GAALiU,IAAY,EAAW,GAALC,EACpD,MAAM,GAAID,EAAK,KAAOA,EAAK,IAAK,CAE/B,MAGME,IACI,EAALF,IAAW,IAAa,GAJlBF,EAAMC,OAImB,IAAa,GAHtCD,EAAMC,OAGuC,EAAW,GAFxDD,EAAMC,MAGf,MACF/B,EAAIE,KAAOpS,OAAOC,aAAa,OAAUmU,GAAK,KAC9ClC,EAAIE,KAAOpS,OAAOC,aAAa,OAAc,KAAJmU,GAC1C,KAAM,CACL,MAAMD,EAAKH,EAAMC,KACXI,EAAKL,EAAMC,KACjB/B,EAAIE,KAAOpS,OAAOC,cACT,GAALiU,IAAY,IAAa,GAALC,IAAY,EAAW,GAALE,EAE3C,CACF,CACD,OAAOnC,EAAInD,KAAK,GAClB,CA8JWuF,CAAkBpZ,KAAKqZ,wBAAwBzB,EAAOC,G,EAkB/D,uBAAAwB,CAAwBzB,EAAeC,GACrC7X,KAAKgY,QAEL,MAAMsB,EAAgBzB,EAClB7X,KAAKsX,sBACLtX,KAAKoX,eAEHc,EAAmB,GAEzB,IAAK,IAAI3K,EAAI,EAAGA,EAAIqK,EAAMzK,QAAU,CAClC,MAAMgL,EAAQmB,EAAc1B,EAAMhE,OAAOrG,MAGnC8K,EADY9K,EAAIqK,EAAMzK,OACFmM,EAAc1B,EAAMhE,OAAOrG,IAAM,IACzDA,EAEF,MACMgL,EADYhL,EAAIqK,EAAMzK,OACFmM,EAAc1B,EAAMhE,OAAOrG,IAAM,KACzDA,EAEF,MACMgM,EADYhM,EAAIqK,EAAMzK,OACFmM,EAAc1B,EAAMhE,OAAOrG,IAAM,GAG3D,KAFEA,EAEW,MAAT4K,GAA0B,MAATE,GAA0B,MAATE,GAA0B,MAATgB,EACrD,MAAM,IAAIC,EAGZ,MAAMhB,EAAYL,GAAS,EAAME,GAAS,EAG1C,GAFAH,EAAOvE,KAAK6E,GAEE,KAAVD,EAAc,CAChB,MAAME,EAAaJ,GAAS,EAAK,IAASE,GAAS,EAGnD,GAFAL,EAAOvE,KAAK8E,GAEE,KAAVc,EAAc,CAChB,MAAMb,EAAaH,GAAS,EAAK,IAAQgB,EACzCrB,EAAOvE,KAAK+E,EACb,CACF,CACF,CAED,OAAOR,C,EAQT,KAAAF,GACE,IAAKhY,KAAKmX,eAAgB,CACxBnX,KAAKmX,eAAiB,CAAC,EACvBnX,KAAKoX,eAAiB,CAAC,EACvBpX,KAAKqX,sBAAwB,CAAC,EAC9BrX,KAAKsX,sBAAwB,CAAC,EAG9B,IAAK,IAAI/J,EAAI,EAAGA,EAAIvN,KAAKwX,aAAarK,OAAQI,IAC5CvN,KAAKmX,eAAe5J,GAAKvN,KAAKwX,aAAa5D,OAAOrG,GAClDvN,KAAKoX,eAAepX,KAAKmX,eAAe5J,IAAMA,EAC9CvN,KAAKqX,sBAAsB9J,GAAKvN,KAAKyX,qBAAqB7D,OAAOrG,GACjEvN,KAAKsX,sBAAsBtX,KAAKqX,sBAAsB9J,IAAMA,EAGxDA,GAAKvN,KAAKuX,kBAAkBpK,SAC9BnN,KAAKoX,eAAepX,KAAKyX,qBAAqB7D,OAAOrG,IAAMA,EAC3DvN,KAAKsX,sBAAsBtX,KAAKwX,aAAa5D,OAAOrG,IAAMA,EAG/D,CACF,GAMG,MAAOiM,UAAgCnE,MAA7C,c,oBACW,KAAI,KAAG,yBACjB,EAKM,MASMoE,EAAgC,SAAU1C,GAErD,OAX0B,SAAUA,GACpC,MAAM2C,EAAY5C,EAAkBC,GACpC,OAAO9J,EAAO0K,gBAAgB+B,GAAW,EAC3C,CAQSC,CAAa5C,GAAK1X,QAAQ,MAAO,GAC1C,EAWaua,EAAe,SAAU7C,GACpC,IACE,OAAO9J,EAAO4L,aAAa9B,GAAK,EACjC,CAAC,MAAO3Q,GACPkG,QAAQ9J,MAAM,wBAAyB4D,EACxC,CACD,OAAO,IACT,ECjVgB,SAAAhF,EAAWyY,EAAiBC,GAC1C,KAAMA,aAAkBrZ,QACtB,OAAOqZ,EAGT,OAAQA,EAAO9F,aACb,KAAK/R,KAIH,OAAO,IAAIA,KADO6X,EACQC,WAE5B,KAAKtZ,YACYb,IAAXia,IACFA,EAAS,CAAC,GAEZ,MACF,KAAK/B,MAEH+B,EAAS,GACT,MAEF,QAEE,OAAOC,EAGX,IAAK,MAAME,KAAQF,EAEZA,EAAOrD,eAAeuD,IAad,cAbmCA,IAG/CH,EAAmCG,GAAQ5Y,EACzCyY,EAAmCG,GACnCF,EAAmCE,KAIxC,OAAOH,CACT,CCtBA,MAAMI,EAAwB,I,WChC5B,GAAoB,qBAAT3V,KACT,OAAOA,KAET,GAAsB,qBAAXkS,OACT,OAAOA,OAET,GAAsB,qBAAX0D,EACT,OAAOA,EAET,MAAM,IAAI7E,MAAM,kCAClB,CDuBE8E,GAAYC,sBA2CDC,EAAc,KACzB,IACE,OACEJ,KApC6B,MACjC,GAAuB,qBAAZK,EACT,OAEF,MAAMC,EAAqB,kXAAYH,sBACvC,OAAIG,EACK7Q,KAAK8Q,MAAMD,QADpB,CAEC,EA8BGE,IA3BwB,MAC5B,GAAwB,qBAAbC,SACT,OAEF,IAAIC,EACJ,IACEA,EAAQD,SAASE,OAAOD,MAAM,gCAC/B,CAAC,MAAOvU,GAGP,MACD,CACD,MAAMyU,EAAUF,GAASf,EAAae,EAAM,IAC5C,OAAOE,GAAWnR,KAAK8Q,MAAMK,EAAQ,EAejCC,EAEH,CAAC,MAAO1U,GAQP,YADAkG,QAAQyO,KAAK,+CAA+C3U,IAE7D,GASU4U,EACXC,IACuB,eAA4B,QAA5B,EAAe,QAAf,EAAAZ,WAAe,eAAAa,qBAAa,eAAGD,EAAY,EAiCvDE,EAAsB,KAAyC,MAC1E,OAAa,QAAb,EAAAd,WAAa,eAAEe,MAAM,EAOVC,EACX3c,IAEA,aAAa,QAAb,EAAA2b,WAAa,eAAG,IAAI3b,IAAoC,E,MEzJ7C4c,EAIX,WAAAtH,GAFA,KAAAvL,OAAoC,OACpC,KAAAzE,QAAqC,OAEnChE,KAAKub,QAAU,IAAIxX,SAAQ,CAACC,EAASyE,KACnCzI,KAAKgE,QAAUA,EACfhE,KAAKyI,OAASA,CAAmC,GAEpD,CAOD,YAAA+S,CACExV,GAEA,MAAO,CAACxD,EAAOwE,KACTxE,EACFxC,KAAKyI,OAAOjG,GAEZxC,KAAKgE,QAAQgD,GAES,oBAAbhB,IAGThG,KAAKub,QAAQlP,OAAM,SAIK,IAApBrG,EAASmH,OACXnH,EAASxD,GAETwD,EAASxD,EAAOwE,GAEnB,CAEJ,E,SChCayU,IACd,MACuB,qBAAdlT,WAC2B,kBAA3BA,UAAqB,UAErBA,UAAqB,UAErB,EAEX,C,SASgBmT,IACd,MACoB,qBAAXlF,WAGJA,OAAgB,SAAKA,OAAiB,UAAKA,OAAiB,WAC/D,oDAAoDtR,KAAKuW,IAE7D,C,SAQgBE,I,MACd,MAAMC,EAAgC,QAAb,EAAAvB,WAAa,eAAEuB,iBACxC,GAAyB,SAArBA,EACF,OAAO,EACF,GAAyB,YAArBA,EACT,OAAO,EAGT,IACE,MACqD,qBAAnDnb,OAAOX,UAAUgQ,SAAS+L,KAAK3B,EAAOI,QAEzC,CAAC,MAAOlU,GACP,OAAO,CACR,CACH,C,SAKgB0V,IACd,MAAuB,kBAATxX,MAAqBA,KAAKA,OAASA,IACnD,C,SAUgByX,IACd,MAAMC,EACc,kBAAXC,OACHA,OAAOD,QACY,kBAAZE,QACPA,QAAQF,aACRpc,EACN,MAA0B,kBAAZoc,QAAuCpc,IAAfoc,EAAQG,EAChD,C,SAOgBC,IACd,MACuB,kBAAd7T,WAAmD,gBAAzBA,UAAmB,OAExD,C,SAQgB8T,IACd,MAAMC,EAAKb,IACX,OAAOa,EAAGC,QAAQ,UAAY,GAAKD,EAAGC,QAAQ,aAAe,CAC/D,C,SA6BgBC,IACd,IACE,MAA4B,kBAAdtO,SACf,CAAC,MAAO9H,GACP,OAAO,CACR,CACH,C,SASgBqW,IACd,OAAO,IAAI1Y,SAAQ,CAACC,EAASyE,KAC3B,IACE,IAAIiU,GAAoB,EACxB,MAAMC,EACJ,0DACInT,EAAUlF,KAAK4J,UAAU0O,KAAKD,GACpCnT,EAAQqT,UAAY,KAClBrT,EAAQ5F,OAAO2C,QAEVmW,GACHpY,KAAK4J,UAAU4O,eAAeH,GAEhC3Y,GAAQ,EAAK,EAEfwF,EAAQuT,gBAAkB,KACxBL,GAAW,CAAK,EAGlBlT,EAAQwT,QAAU,K,MAChBvU,GAAoB,QAAb,EAAAe,EAAQhH,aAAK,eAAEI,UAAW,GAAG,CAEvC,CAAC,MAAOJ,GACPiG,EAAOjG,EACR,IAEL,C,SAOgBya,IACd,QAAyB,qBAAd1U,YAA8BA,UAAU2U,cAIrD,CCjIM,MAAOC,UAAsB9H,MAIjC,WAAArB,CAEWtR,EACTE,EAEOsH,GAEPkT,MAAMxa,GALG,KAAI,KAAJF,EAGF,KAAU,WAAVwH,EAPA,KAAI,KAdI,gBA2BfzJ,OAAO4c,eAAerd,KAAMmd,EAAcrd,WAItCuV,MAAMiI,mBACRjI,MAAMiI,kBAAkBtd,KAAMmB,EAAarB,UAAUJ,OAExD,E,MAGUyB,EAIX,WAAA6S,CACmBuJ,EACAC,EACAC,GAFA,KAAO,QAAPF,EACA,KAAW,YAAXC,EACA,KAAM,OAANC,CACf,CAEJ,MAAA/d,CACEgD,GAGA,MAAMwH,GAAc,0CAAyB,CAAC,EACxCwT,EAAW,GAAG1d,KAAKud,WAAW7a,IAC9Bib,EAAW3d,KAAKyd,OAAO/a,GAEvBE,EAAU+a,EAUpB,SAAyBA,EAAkBtX,GACzC,OAAOsX,EAASte,QAAQue,GAAS,CAACC,EAAGrY,KACnC,MAAMwB,EAAQX,EAAKb,GACnB,OAAgB,MAATwB,EAAgBlC,OAAOkC,GAAS,IAAIxB,KAAO,GAEtD,CAf+BsY,CAAgBH,EAAUzT,GAAc,QAE7D6T,EAAc,GAAG/d,KAAKwd,gBAAgB5a,MAAY8a,MAIxD,OAFc,IAAIP,EAAcO,EAAUK,EAAa7T,EAGxD,EAUH,MAAM0T,EAAU,gBCpHA,SAAAnP,EAA2BuP,EAAQxY,GACjD,OAAO/E,OAAOX,UAAU2W,eAAeoF,KAAKmC,EAAKxY,EACnD,CAaM,SAAUyY,EAAQD,GACtB,IAAK,MAAMxY,KAAOwY,EAChB,GAAIvd,OAAOX,UAAU2W,eAAeoF,KAAKmC,EAAKxY,GAC5C,OAAO,EAGX,OAAO,CACT,CAmBgB,SAAA0Y,EAAUC,EAAWC,GACnC,GAAID,IAAMC,EACR,OAAO,EAGT,MAAMC,EAAQ5d,OAAOG,KAAKud,GACpBG,EAAQ7d,OAAOG,KAAKwd,GAC1B,IAAK,MAAMG,KAAKF,EAAO,CACrB,IAAKC,EAAMjQ,SAASkQ,GAClB,OAAO,EAGT,MAAMC,EAASL,EAA8BI,GACvCE,EAASL,EAA8BG,GAC7C,GAAIG,EAASF,IAAUE,EAASD,IAC9B,IAAKP,EAAUM,EAAOC,GACpB,OAAO,OAEJ,GAAID,IAAUC,EACnB,OAAO,CAEV,CAED,IAAK,MAAMF,KAAKD,EACd,IAAKD,EAAMhQ,SAASkQ,GAClB,OAAO,EAGX,OAAO,CACT,CAEA,SAASG,EAASC,GAChB,OAAiB,OAAVA,GAAmC,kBAAVA,CAClC,CCrEM,SAAUC,EAAYC,GAG1B,MAAMC,EAAS,GACf,IAAK,MAAOtZ,EAAKwB,KAAUvG,OAAOse,QAAQF,GACpC/G,MAAMC,QAAQ/Q,GAChBA,EAAMgY,SAAQC,IACZH,EAAOnL,KACLuL,mBAAmB1Z,GAAO,IAAM0Z,mBAAmBD,GACpD,IAGHH,EAAOnL,KAAKuL,mBAAmB1Z,GAAO,IAAM0Z,mBAAmBlY,IAGnE,OAAO8X,EAAO3R,OAAS,IAAM2R,EAAOjL,KAAK,KAAO,EAClD,CAMM,SAAUsL,EAAkBP,GAChC,MAAMZ,EAA8B,CAAC,EASrC,OAReY,EAAYvf,QAAQ,MAAO,IAAI+f,MAAM,KAE7CJ,SAAQrd,IACb,GAAIA,EAAO,CACT,MAAO6D,EAAKwB,GAASrF,EAAMyd,MAAM,KACjCpB,EAAIqB,mBAAmB7Z,IAAQ6Z,mBAAmBrY,EACnD,KAEIgX,CACT,CAKM,SAAUsB,EAAmBC,GACjC,MAAMC,EAAaD,EAAIhD,QAAQ,KAC/B,IAAKiD,EACH,MAAO,GAET,MAAMC,EAAgBF,EAAIhD,QAAQ,IAAKiD,GACvC,OAAOD,EAAIG,UACTF,EACAC,EAAgB,EAAIA,OAAgB7f,EAExC,CCVgB,SAAAsB,EACdye,EACAC,GAEA,MAAMC,EAAQ,IAAIC,EAAiBH,EAAUC,GAC7C,OAAOC,EAAMnP,UAAUxQ,KAAK2f,EAC9B,CAMA,MAAMC,EAeJ,WAAA9L,CAAY2L,EAAuBC,GAd3B,KAAS,UAAmC,GAC5C,KAAY,aAAkB,GAE9B,KAAa,cAAG,EAEhB,KAAAG,KAAOhc,QAAQC,UACf,KAAS,WAAG,EASlBhE,KAAK4f,cAAgBA,EAIrB5f,KAAK+f,KACFC,MAAK,KACJL,EAAS3f,KAAK,IAEfqM,OAAMjG,IACLpG,KAAKwC,MAAM4D,EAAE,GAElB,CAED,IAAA8P,CAAKlP,GACHhH,KAAKigB,iBAAiBC,IACpBA,EAAShK,KAAKlP,EAAM,GAEvB,CAED,KAAAxE,CAAMA,GACJxC,KAAKigB,iBAAiBC,IACpBA,EAAS1d,MAAMA,EAAM,IAEvBxC,KAAKuG,MAAM/D,EACZ,CAED,QAAA2d,GACEngB,KAAKigB,iBAAiBC,IACpBA,EAASC,UAAU,IAErBngB,KAAKuG,OACN,CAQD,SAAAmK,CACEkG,EACApU,EACA2d,GAEA,IAAID,EAEJ,QACqBtgB,IAAnBgX,QACUhX,IAAV4C,QACa5C,IAAbugB,EAEA,MAAM,IAAI9K,MAAM,qBAahB6K,EAiIN,SACElC,EACAoC,GAEA,GAAmB,kBAARpC,GAA4B,OAARA,EAC7B,OAAO,EAGT,IAAK,MAAMvU,KAAU2W,EACnB,GAAI3W,KAAUuU,GAA8B,oBAAhBA,EAAIvU,GAC9B,OAAO,EAIX,OAAO,CACT,CAxJM4W,CAAqBzJ,EAA8C,CACjE,OACA,QACA,aAGSA,EAEA,CACTV,KAAMU,EACNpU,QACA2d,iBAIkBvgB,IAAlBsgB,EAAShK,OACXgK,EAAShK,KAAOoK,QAEK1gB,IAAnBsgB,EAAS1d,QACX0d,EAAS1d,MAAQ8d,QAEO1gB,IAAtBsgB,EAASC,WACXD,EAASC,SAAWG,GAGtB,MAAMC,EAAQvgB,KAAKwgB,eAAetgB,KAAKF,KAAMA,KAAKygB,UAAWtT,QAuB7D,OAlBInN,KAAK0gB,WAEP1gB,KAAK+f,KAAKC,MAAK,KACb,IACMhgB,KAAK2gB,WACPT,EAAS1d,MAAMxC,KAAK2gB,YAEpBT,EAASC,UAEZ,CAAC,MAAO/Z,G,CAGH,IAIVpG,KAAKygB,UAAW9M,KAAKuM,GAEdK,CACR,CAIO,cAAAC,CAAejT,QACE3N,IAAnBI,KAAKygB,gBAAiD7gB,IAAtBI,KAAKygB,UAAUlT,YAI5CvN,KAAKygB,UAAUlT,GAEtBvN,KAAK4gB,eAAiB,EACK,IAAvB5gB,KAAK4gB,oBAA8ChhB,IAAvBI,KAAK4f,eACnC5f,KAAK4f,cAAc5f,MAEtB,CAEO,eAAAigB,CAAgBtc,GACtB,IAAI3D,KAAK0gB,UAOT,IAAK,IAAInT,EAAI,EAAGA,EAAIvN,KAAKygB,UAAWtT,OAAQI,IAC1CvN,KAAK6gB,QAAQtT,EAAG5J,EAEnB,CAKO,OAAAkd,CAAQtT,EAAW5J,GAGzB3D,KAAK+f,KAAKC,MAAK,KACb,QAAuBpgB,IAAnBI,KAAKygB,gBAAiD7gB,IAAtBI,KAAKygB,UAAUlT,GACjD,IACE5J,EAAG3D,KAAKygB,UAAUlT,GACnB,CAAC,MAAOnH,GAIgB,qBAAZkG,SAA2BA,QAAQ9J,OAC5C8J,QAAQ9J,MAAM4D,EAEjB,CACF,GAEJ,CAEO,KAAAG,CAAMsJ,GACR7P,KAAK0gB,YAGT1gB,KAAK0gB,WAAY,OACL9gB,IAARiQ,IACF7P,KAAK2gB,WAAa9Q,GAIpB7P,KAAK+f,KAAKC,MAAK,KACbhgB,KAAKygB,eAAY7gB,EACjBI,KAAK4f,mBAAgBhgB,CAAS,IAEjC,EAuCH,SAAS0gB,I,CCrRH,SAAUQ,EACdvD,GAEA,OAAIA,GAAYA,EAA+BwD,UACrCxD,EAA+BwD,UAEhCxD,CAEX,C,+7ECPa,MAWAyD,EAAa,CAExBC,SAAU,eAEVC,OAAQ,aAERC,OAAQ,aAERC,SAAU,WAEVC,MAAO,QAEPC,QAAS,eA4CEC,EAAsB,CAEjCC,aAAc,eAEdC,eAAgB,iBAEhBC,cAAe,gBAEfC,8BAA+B,gCAE/BC,wBAAyB,0BAEzBC,aAAc,gBCkShB,SAASC,IAIP,MAAO,CACL,wCACE,0LAIN,CASO,MAAMC,EAjRb,WACE,MAAO,CACL,6BACE,uDACF,iBAAgC,GAChC,qBACE,6LAGF,oBACE,qJAGF,uBACE,kKAGF,eACE,+EAEF,oBAAmC,kCACnC,mBAAkC,iCAClC,4BACE,uEACF,wBACE,wDACF,wBACE,6GAEF,wCACE,0LAGF,6BACE,+FAEF,kCACE,wDACF,uBACE,0DACF,yBACE,gKAGF,sBAAkC,+BAClC,0BACE,mFACF,iBAAgC,sCAChC,yBACE,sIAEF,iBACE,qEACF,qBACE,sLAGF,qBAAoC,sCACpC,4BACE,wLAGF,uBACE,uDACF,gCACE,gOAIF,uBACE,wEACF,8BACE,4FACF,gBAA+B,wCAC/B,0BACE,qEACF,kBACE,sEACF,oBACE,kDACF,qBACE,4DACF,0BACE,+KAEF,+BACE,iFACF,yBACE,uGAEF,0BACE,0FAEF,sBACE,+IAEF,sBACE,2GAEF,iBACE,gEACF,2BACE,oFACF,uBACE,gPAIF,sBACE,wCACF,0BACE,4GAEF,iBACE,6KAEF,0BACE,2EACF,oBACE,4CACF,gBACE,4DACF,2BACE,2FACF,8BACE,8HAEF,yBACE,gIAEF,4BACE,6EACF,uBACE,kDACF,uBAAsC,sCACtC,wBACE,oEACF,2BACE,oKAGF,mBAAkC,wCAClC,4BACE,2CACF,+BACE,mEACF,uBACE,wEACF,0BACE,uEACF,cACE,iDACF,8BACE,2EACF,6BACE,yEACF,2CACE,wJAGF,yBACE,kGACF,gBAA+B,sCAC/B,mBACE,6DACF,YACE,0GAEF,wBACE,yJAGF,8CACE,kLAGF,gBACE,4FACF,uBACE,yEACF,0BACE,kEACF,iBACE,4DACF,6BACE,2EACF,6BACE,mDACF,sBACE,6DACF,+BACE,yDACF,uCACE,4EACF,qBACE,sEACF,QAAyB,+BACzB,qBACE,yEACF,oBACE,0FAEF,4BACE,2GAEF,2BACE,sHACF,+BACE,2EACF,+BACE,6DACF,mBACE,2CACF,iBACE,wEACF,iBACE,4FAEF,gBACE,0DACF,gBACE,+EACF,kBAAiC,GACjC,gBACE,kDACF,0BACE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","file":"static/js/vendor_firebase.86b028ee.chunk.js","sourcesContent":["/**\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 { Logger } from '@firebase/logger';\n\nexport const logger = new Logger('@firebase/app');\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  FirebaseApp,\n  FirebaseOptions,\n  FirebaseAppSettings\n} from './public-types';\nimport {\n  ComponentContainer,\n  Component,\n  ComponentType\n} from '@firebase/component';\nimport { ERROR_FACTORY, AppError } from './errors';\n\nexport class FirebaseAppImpl implements FirebaseApp {\n  private readonly _options: FirebaseOptions;\n  private readonly _name: string;\n  /**\n   * Original config values passed in as a constructor parameter.\n   * It is only used to compare with another config object to support idempotent initializeApp().\n   *\n   * Updating automaticDataCollectionEnabled on the App instance will not change its value in _config.\n   */\n  private readonly _config: Required<FirebaseAppSettings>;\n  private _automaticDataCollectionEnabled: boolean;\n  private _isDeleted = false;\n  private readonly _container: ComponentContainer;\n\n  constructor(\n    options: FirebaseOptions,\n    config: Required<FirebaseAppSettings>,\n    container: ComponentContainer\n  ) {\n    this._options = { ...options };\n    this._config = { ...config };\n    this._name = config.name;\n    this._automaticDataCollectionEnabled =\n      config.automaticDataCollectionEnabled;\n    this._container = container;\n    this.container.addComponent(\n      new Component('app', () => this, ComponentType.PUBLIC)\n    );\n  }\n\n  get automaticDataCollectionEnabled(): boolean {\n    this.checkDestroyed();\n    return this._automaticDataCollectionEnabled;\n  }\n\n  set automaticDataCollectionEnabled(val: boolean) {\n    this.checkDestroyed();\n    this._automaticDataCollectionEnabled = val;\n  }\n\n  get name(): string {\n    this.checkDestroyed();\n    return this._name;\n  }\n\n  get options(): FirebaseOptions {\n    this.checkDestroyed();\n    return this._options;\n  }\n\n  get config(): Required<FirebaseAppSettings> {\n    this.checkDestroyed();\n    return this._config;\n  }\n\n  get container(): ComponentContainer {\n    return this._container;\n  }\n\n  get isDeleted(): boolean {\n    return this._isDeleted;\n  }\n\n  set isDeleted(val: boolean) {\n    this._isDeleted = val;\n  }\n\n  /**\n   * This function will throw an Error if the App has already been deleted -\n   * use before performing API actions on the App.\n   */\n  private checkDestroyed(): void {\n    if (this.isDeleted) {\n      throw ERROR_FACTORY.create(AppError.APP_DELETED, { appName: this._name });\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 { ErrorFactory, ErrorMap } from '@firebase/util';\n\nexport const enum AppError {\n  NO_APP = 'no-app',\n  BAD_APP_NAME = 'bad-app-name',\n  DUPLICATE_APP = 'duplicate-app',\n  APP_DELETED = 'app-deleted',\n  NO_OPTIONS = 'no-options',\n  INVALID_APP_ARGUMENT = 'invalid-app-argument',\n  INVALID_LOG_ARGUMENT = 'invalid-log-argument',\n  IDB_OPEN = 'idb-open',\n  IDB_GET = 'idb-get',\n  IDB_WRITE = 'idb-set',\n  IDB_DELETE = 'idb-delete'\n}\n\nconst ERRORS: ErrorMap<AppError> = {\n  [AppError.NO_APP]:\n    \"No Firebase App '{$appName}' has been created - \" +\n    'call initializeApp() first',\n  [AppError.BAD_APP_NAME]: \"Illegal App name: '{$appName}\",\n  [AppError.DUPLICATE_APP]:\n    \"Firebase App named '{$appName}' already exists with different options or config\",\n  [AppError.APP_DELETED]: \"Firebase App named '{$appName}' already deleted\",\n  [AppError.NO_OPTIONS]:\n    'Need to provide options, when not being deployed to hosting via source.',\n  [AppError.INVALID_APP_ARGUMENT]:\n    'firebase.{$appName}() takes either no argument or a ' +\n    'Firebase App instance.',\n  [AppError.INVALID_LOG_ARGUMENT]:\n    'First argument to `onLog` must be null or a function.',\n  [AppError.IDB_OPEN]:\n    'Error thrown when opening IndexedDB. Original error: {$originalErrorMessage}.',\n  [AppError.IDB_GET]:\n    'Error thrown when reading from IndexedDB. Original error: {$originalErrorMessage}.',\n  [AppError.IDB_WRITE]:\n    'Error thrown when writing to IndexedDB. Original error: {$originalErrorMessage}.',\n  [AppError.IDB_DELETE]:\n    'Error thrown when deleting from IndexedDB. Original error: {$originalErrorMessage}.'\n};\n\ninterface ErrorParams {\n  [AppError.NO_APP]: { appName: string };\n  [AppError.BAD_APP_NAME]: { appName: string };\n  [AppError.DUPLICATE_APP]: { appName: string };\n  [AppError.APP_DELETED]: { appName: string };\n  [AppError.INVALID_APP_ARGUMENT]: { appName: string };\n  [AppError.IDB_OPEN]: { originalErrorMessage?: string };\n  [AppError.IDB_GET]: { originalErrorMessage?: string };\n  [AppError.IDB_WRITE]: { originalErrorMessage?: string };\n  [AppError.IDB_DELETE]: { originalErrorMessage?: string };\n}\n\nexport const ERROR_FACTORY = new ErrorFactory<AppError, ErrorParams>(\n  'app',\n  'Firebase',\n  ERRORS\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 { FirebaseNamespace } from './public-types';\nimport { createSubscribe, deepExtend, ErrorFactory } from '@firebase/util';\nimport { FirebaseAppImpl } from './firebaseApp';\nimport { createFirebaseNamespaceCore } from './firebaseNamespaceCore';\n\n/**\n * Return a firebase namespace object.\n *\n * In production, this will be called exactly once and the result\n * assigned to the 'firebase' global.  It may be called multiple times\n * in unit tests.\n */\nexport function createFirebaseNamespace(): FirebaseNamespace {\n  const namespace = createFirebaseNamespaceCore(FirebaseAppImpl);\n  namespace.INTERNAL = {\n    ...namespace.INTERNAL,\n    createFirebaseNamespace,\n    extendNamespace,\n    createSubscribe,\n    ErrorFactory,\n    deepExtend\n  };\n\n  /**\n   * Patch the top-level firebase namespace with additional properties.\n   *\n   * firebase.INTERNAL.extendNamespace()\n   */\n  function extendNamespace(props: { [prop: string]: unknown }): void {\n    deepExtend(namespace, props);\n  }\n\n  return namespace;\n}\n\nexport const firebase = createFirebaseNamespace();\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 { FirebaseApp, FirebaseOptions } from './public-types';\nimport {\n  _FirebaseNamespace,\n  _FirebaseService,\n  FirebaseServiceNamespace\n} from './types';\nimport * as modularAPIs from '@firebase/app';\nimport { _FirebaseAppInternal as _FirebaseAppExp } from '@firebase/app';\nimport { Component, ComponentType, Name } from '@firebase/component';\n\nimport { deepExtend, contains } from '@firebase/util';\nimport { FirebaseAppImpl } from './firebaseApp';\nimport { ERROR_FACTORY, AppError } from './errors';\nimport { FirebaseAppLiteImpl } from './lite/firebaseAppLite';\n\n/**\n * Because auth can't share code with other components, we attach the utility functions\n * in an internal namespace to share code.\n * This function return a firebase namespace object without\n * any utility functions, so it can be shared between the regular firebaseNamespace and\n * the lite version.\n */\nexport function createFirebaseNamespaceCore(\n  firebaseAppImpl: typeof FirebaseAppImpl | typeof FirebaseAppLiteImpl\n): _FirebaseNamespace {\n  const apps: { [name: string]: FirebaseApp } = {};\n  // // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  // const components = new Map<string, Component<any>>();\n\n  // A namespace is a plain JavaScript Object.\n  const namespace: _FirebaseNamespace = {\n    // Hack to prevent Babel from modifying the object returned\n    // as the firebase namespace.\n    // @ts-ignore\n    __esModule: true,\n    initializeApp: initializeAppCompat,\n    // @ts-ignore\n    app,\n    registerVersion: modularAPIs.registerVersion,\n    setLogLevel: modularAPIs.setLogLevel,\n    onLog: modularAPIs.onLog,\n    // @ts-ignore\n    apps: null,\n    SDK_VERSION: modularAPIs.SDK_VERSION,\n    INTERNAL: {\n      registerComponent: registerComponentCompat,\n      removeApp,\n      useAsService,\n      modularAPIs\n    }\n  };\n\n  // Inject a circular default export to allow Babel users who were previously\n  // using:\n  //\n  //   import firebase from 'firebase';\n  //   which becomes: var firebase = require('firebase').default;\n  //\n  // instead of\n  //\n  //   import * as firebase from 'firebase';\n  //   which becomes: var firebase = require('firebase');\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  (namespace as any)['default'] = namespace;\n\n  // firebase.apps is a read-only getter.\n  Object.defineProperty(namespace, 'apps', {\n    get: getApps\n  });\n\n  /**\n   * Called by App.delete() - but before any services associated with the App\n   * are deleted.\n   */\n  function removeApp(name: string): void {\n    delete apps[name];\n  }\n\n  /**\n   * Get the App object for a given name (or DEFAULT).\n   */\n  function app(name?: string): FirebaseApp {\n    name = name || modularAPIs._DEFAULT_ENTRY_NAME;\n    if (!contains(apps, name)) {\n      throw ERROR_FACTORY.create(AppError.NO_APP, { appName: name });\n    }\n    return apps[name];\n  }\n\n  // @ts-ignore\n  app['App'] = firebaseAppImpl;\n\n  /**\n   * Create a new App instance (name must be unique).\n   *\n   * This function is idempotent. It can be called more than once and return the same instance using the same options and config.\n   */\n  function initializeAppCompat(\n    options: FirebaseOptions,\n    rawConfig = {}\n  ): FirebaseApp {\n    const app = modularAPIs.initializeApp(\n      options,\n      rawConfig\n    ) as _FirebaseAppExp;\n\n    if (contains(apps, app.name)) {\n      return apps[app.name];\n    }\n\n    const appCompat = new firebaseAppImpl(app, namespace);\n    apps[app.name] = appCompat;\n    return appCompat;\n  }\n\n  /*\n   * Return an array of all the non-deleted FirebaseApps.\n   */\n  function getApps(): FirebaseApp[] {\n    // Make a copy so caller cannot mutate the apps list.\n    return Object.keys(apps).map(name => apps[name]);\n  }\n\n  function registerComponentCompat<T extends Name>(\n    component: Component<T>\n  ): FirebaseServiceNamespace<_FirebaseService> | null {\n    const componentName = component.name;\n    const componentNameWithoutCompat = componentName.replace('-compat', '');\n    if (\n      modularAPIs._registerComponent(component) &&\n      component.type === ComponentType.PUBLIC\n    ) {\n      // create service namespace for public components\n      // The Service namespace is an accessor function ...\n      const serviceNamespace = (\n        appArg: FirebaseApp = app()\n      ): _FirebaseService => {\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        if (typeof (appArg as any)[componentNameWithoutCompat] !== 'function') {\n          // Invalid argument.\n          // This happens in the following case: firebase.storage('gs:/')\n          throw ERROR_FACTORY.create(AppError.INVALID_APP_ARGUMENT, {\n            appName: componentName\n          });\n        }\n\n        // Forward service instance lookup to the FirebaseApp.\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        return (appArg as any)[componentNameWithoutCompat]();\n      };\n\n      // ... and a container for service-level properties.\n      if (component.serviceProps !== undefined) {\n        deepExtend(serviceNamespace, component.serviceProps);\n      }\n\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      (namespace as any)[componentNameWithoutCompat] = serviceNamespace;\n\n      // Patch the FirebaseAppImpl prototype\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      (firebaseAppImpl.prototype as any)[componentNameWithoutCompat] =\n        // TODO: The eslint disable can be removed and the 'ignoreRestArgs'\n        // option added to the no-explicit-any rule when ESlint releases it.\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        function (...args: any) {\n          const serviceFxn = this._getService.bind(this, componentName);\n          return serviceFxn.apply(\n            this,\n            component.multipleInstances ? args : []\n          );\n        };\n    }\n\n    return component.type === ComponentType.PUBLIC\n      ? // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        (namespace as any)[componentNameWithoutCompat]\n      : null;\n  }\n\n  // Map the requested service to a registered service name\n  // (used to map auth to serverAuth service when needed).\n  function useAsService(app: FirebaseApp, name: string): string | null {\n    if (name === 'serverAuth') {\n      return null;\n    }\n\n    const useService = name;\n\n    return useService;\n  }\n\n  return namespace;\n}\n","/**\n * Firebase App\n *\n * @remarks This package coordinates the communication between the different Firebase components\n * @packageDocumentation\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 { registerCoreComponents } from './registerCoreComponents';\n\nexport * from './api';\nexport * from './internal';\nexport * from './public-types';\n\nregisterCoreComponents('__RUNTIME_ENV__');\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 { Component, ComponentType } from '@firebase/component';\nimport { PlatformLoggerServiceImpl } from './platformLoggerService';\nimport { name, version } from '../package.json';\nimport { _registerComponent } from './internal';\nimport { registerVersion } from './api';\nimport { HeartbeatServiceImpl } from './heartbeatService';\n\nexport function registerCoreComponents(variant?: string): void {\n  _registerComponent(\n    new Component(\n      'platform-logger',\n      container => new PlatformLoggerServiceImpl(container),\n      ComponentType.PRIVATE\n    )\n  );\n  _registerComponent(\n    new Component(\n      'heartbeat',\n      container => new HeartbeatServiceImpl(container),\n      ComponentType.PRIVATE\n    )\n  );\n\n  // Register `app` package.\n  registerVersion(name, version, variant);\n  // BUILD_TARGET will be replaced by values like esm5, esm2017, cjs5, etc during the compilation\n  registerVersion(name, version, '__BUILD_TARGET__');\n  // Register platform SDK identifier (no version).\n  registerVersion('fire-js', '');\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\nexport const DEFAULT_SW_PATH = '/firebase-messaging-sw.js';\nexport const DEFAULT_SW_SCOPE = '/firebase-cloud-messaging-push-scope';\n\nexport const DEFAULT_VAPID_KEY =\n  'BDOU99-h67HcA6JeFXHbSNMu7e2yNNu3RzoMj8TM4W88jITfq7ZmPvIM1Iv-4_l2LxQcYwhqby2xGpWwzjfAnG4';\n\nexport const ENDPOINT = 'https://fcmregistrations.googleapis.com/v1';\n\n/** Key of FCM Payload in Notification's data field. */\nexport const FCM_MSG = 'FCM_MSG';\n\nexport const CONSOLE_CAMPAIGN_ID = 'google.c.a.c_id';\nexport const CONSOLE_CAMPAIGN_NAME = 'google.c.a.c_l';\nexport const CONSOLE_CAMPAIGN_TIME = 'google.c.a.ts';\n/** Set to '1' if Analytics is enabled for the campaign */\nexport const CONSOLE_CAMPAIGN_ANALYTICS_ENABLED = 'google.c.a.e';\nexport const TAG = 'FirebaseMessaging: ';\nexport const MAX_NUMBER_OF_EVENTS_PER_LOG_REQUEST = 1000;\nexport const MAX_RETRIES = 3;\nexport const LOG_INTERVAL_IN_MS = 86400000; //24 hour\nexport const DEFAULT_BACKOFF_TIME_MS = 5000;\n\n// FCM log source name registered at Firelog: 'FCM_CLIENT_EVENT_LOGGING'. It uniquely identifies\n// FCM's logging configuration.\nexport const FCM_LOG_SOURCE = 1249;\n\n// Defined as in proto/messaging_event.proto. Neglecting fields that are supported.\nexport const SDK_PLATFORM_WEB = 3;\nexport const EVENT_MESSAGE_DELIVERED = 1;\n\nexport enum MessageType {\n  DATA_MESSAGE = 1,\n  DISPLAY_NOTIFICATION = 3\n}\n","/**\n * @license\n * Copyright 2017 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 { ErrorFactory, ErrorMap } from '@firebase/util';\n\nexport const enum ErrorCode {\n  MISSING_APP_CONFIG_VALUES = 'missing-app-config-values',\n  AVAILABLE_IN_WINDOW = 'only-available-in-window',\n  AVAILABLE_IN_SW = 'only-available-in-sw',\n  PERMISSION_DEFAULT = 'permission-default',\n  PERMISSION_BLOCKED = 'permission-blocked',\n  UNSUPPORTED_BROWSER = 'unsupported-browser',\n  INDEXED_DB_UNSUPPORTED = 'indexed-db-unsupported',\n  FAILED_DEFAULT_REGISTRATION = 'failed-service-worker-registration',\n  TOKEN_SUBSCRIBE_FAILED = 'token-subscribe-failed',\n  TOKEN_SUBSCRIBE_NO_TOKEN = 'token-subscribe-no-token',\n  TOKEN_UNSUBSCRIBE_FAILED = 'token-unsubscribe-failed',\n  TOKEN_UPDATE_FAILED = 'token-update-failed',\n  TOKEN_UPDATE_NO_TOKEN = 'token-update-no-token',\n  INVALID_BG_HANDLER = 'invalid-bg-handler',\n  USE_SW_AFTER_GET_TOKEN = 'use-sw-after-get-token',\n  INVALID_SW_REGISTRATION = 'invalid-sw-registration',\n  USE_VAPID_KEY_AFTER_GET_TOKEN = 'use-vapid-key-after-get-token',\n  INVALID_VAPID_KEY = 'invalid-vapid-key'\n}\n\nexport const ERROR_MAP: ErrorMap<ErrorCode> = {\n  [ErrorCode.MISSING_APP_CONFIG_VALUES]:\n    'Missing App configuration value: \"{$valueName}\"',\n  [ErrorCode.AVAILABLE_IN_WINDOW]:\n    'This method is available in a Window context.',\n  [ErrorCode.AVAILABLE_IN_SW]:\n    'This method is available in a service worker context.',\n  [ErrorCode.PERMISSION_DEFAULT]:\n    'The notification permission was not granted and dismissed instead.',\n  [ErrorCode.PERMISSION_BLOCKED]:\n    'The notification permission was not granted and blocked instead.',\n  [ErrorCode.UNSUPPORTED_BROWSER]:\n    \"This browser doesn't support the API's required to use the Firebase SDK.\",\n  [ErrorCode.INDEXED_DB_UNSUPPORTED]:\n    \"This browser doesn't support indexedDb.open() (ex. Safari iFrame, Firefox Private Browsing, etc)\",\n  [ErrorCode.FAILED_DEFAULT_REGISTRATION]:\n    'We are unable to register the default service worker. {$browserErrorMessage}',\n  [ErrorCode.TOKEN_SUBSCRIBE_FAILED]:\n    'A problem occurred while subscribing the user to FCM: {$errorInfo}',\n  [ErrorCode.TOKEN_SUBSCRIBE_NO_TOKEN]:\n    'FCM returned no token when subscribing the user to push.',\n  [ErrorCode.TOKEN_UNSUBSCRIBE_FAILED]:\n    'A problem occurred while unsubscribing the ' +\n    'user from FCM: {$errorInfo}',\n  [ErrorCode.TOKEN_UPDATE_FAILED]:\n    'A problem occurred while updating the user from FCM: {$errorInfo}',\n  [ErrorCode.TOKEN_UPDATE_NO_TOKEN]:\n    'FCM returned no token when updating the user to push.',\n  [ErrorCode.USE_SW_AFTER_GET_TOKEN]:\n    'The useServiceWorker() method may only be called once and must be ' +\n    'called before calling getToken() to ensure your service worker is used.',\n  [ErrorCode.INVALID_SW_REGISTRATION]:\n    'The input to useServiceWorker() must be a ServiceWorkerRegistration.',\n  [ErrorCode.INVALID_BG_HANDLER]:\n    'The input to setBackgroundMessageHandler() must be a function.',\n  [ErrorCode.INVALID_VAPID_KEY]: 'The public VAPID key must be a string.',\n  [ErrorCode.USE_VAPID_KEY_AFTER_GET_TOKEN]:\n    'The usePublicVapidKey() method may only be called once and must be ' +\n    'called before calling getToken() to ensure your VAPID key is used.'\n};\n\ninterface ErrorParams {\n  [ErrorCode.MISSING_APP_CONFIG_VALUES]: {\n    valueName: string;\n  };\n  [ErrorCode.FAILED_DEFAULT_REGISTRATION]: { browserErrorMessage: string };\n  [ErrorCode.TOKEN_SUBSCRIBE_FAILED]: { errorInfo: string };\n  [ErrorCode.TOKEN_UNSUBSCRIBE_FAILED]: { errorInfo: string };\n  [ErrorCode.TOKEN_UPDATE_FAILED]: { errorInfo: string };\n}\n\nexport const ERROR_FACTORY = new ErrorFactory<ErrorCode, ErrorParams>(\n  'messaging',\n  'Messaging',\n  ERROR_MAP\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 { FirebaseError } from '@firebase/util';\nimport { GenerateAuthTokenResponse } from '../interfaces/api-response';\nimport {\n  CompletedAuthToken,\n  RegisteredInstallationEntry,\n  RequestStatus\n} from '../interfaces/installation-entry';\nimport {\n  INSTALLATIONS_API_URL,\n  INTERNAL_AUTH_VERSION\n} from '../util/constants';\nimport { ERROR_FACTORY, ErrorCode } from '../util/errors';\nimport { AppConfig } from '../interfaces/installation-impl';\n\nexport function getInstallationsEndpoint({ projectId }: AppConfig): string {\n  return `${INSTALLATIONS_API_URL}/projects/${projectId}/installations`;\n}\n\nexport function extractAuthTokenInfoFromResponse(\n  response: GenerateAuthTokenResponse\n): CompletedAuthToken {\n  return {\n    token: response.token,\n    requestStatus: RequestStatus.COMPLETED,\n    expiresIn: getExpiresInFromResponseExpiresIn(response.expiresIn),\n    creationTime: Date.now()\n  };\n}\n\nexport async function getErrorFromResponse(\n  requestName: string,\n  response: Response\n): Promise<FirebaseError> {\n  const responseJson: ErrorResponse = await response.json();\n  const errorData = responseJson.error;\n  return ERROR_FACTORY.create(ErrorCode.REQUEST_FAILED, {\n    requestName,\n    serverCode: errorData.code,\n    serverMessage: errorData.message,\n    serverStatus: errorData.status\n  });\n}\n\nexport function getHeaders({ apiKey }: AppConfig): Headers {\n  return new Headers({\n    'Content-Type': 'application/json',\n    Accept: 'application/json',\n    'x-goog-api-key': apiKey\n  });\n}\n\nexport function getHeadersWithAuth(\n  appConfig: AppConfig,\n  { refreshToken }: RegisteredInstallationEntry\n): Headers {\n  const headers = getHeaders(appConfig);\n  headers.append('Authorization', getAuthorizationHeader(refreshToken));\n  return headers;\n}\n\nexport interface ErrorResponse {\n  error: {\n    code: number;\n    message: string;\n    status: string;\n  };\n}\n\n/**\n * Calls the passed in fetch wrapper and returns the response.\n * If the returned response has a status of 5xx, re-runs the function once and\n * returns the response.\n */\nexport async function retryIfServerError(\n  fn: () => Promise<Response>\n): Promise<Response> {\n  const result = await fn();\n\n  if (result.status >= 500 && result.status < 600) {\n    // Internal Server Error. Retry request.\n    return fn();\n  }\n\n  return result;\n}\n\nfunction getExpiresInFromResponseExpiresIn(responseExpiresIn: string): number {\n  // This works because the server will never respond with fractions of a second.\n  return Number(responseExpiresIn.replace('s', '000'));\n}\n\nfunction getAuthorizationHeader(refreshToken: string): string {\n  return `${INTERNAL_AUTH_VERSION} ${refreshToken}`;\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\n/** Returns a promise that resolves after given time passes. */\nexport function sleep(ms: number): Promise<void> {\n  return new Promise<void>(resolve => {\n    setTimeout(resolve, ms);\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 { bufferToBase64UrlSafe } from './buffer-to-base64-url-safe';\n\nexport const VALID_FID_PATTERN = /^[cdef][\\w-]{21}$/;\nexport const INVALID_FID = '';\n\n/**\n * Generates a new FID using random values from Web Crypto API.\n * Returns an empty string if FID generation fails for any reason.\n */\nexport function generateFid(): string {\n  try {\n    // A valid FID has exactly 22 base64 characters, which is 132 bits, or 16.5\n    // bytes. our implementation generates a 17 byte array instead.\n    const fidByteArray = new Uint8Array(17);\n    const crypto =\n      self.crypto || (self as unknown as { msCrypto: Crypto }).msCrypto;\n    crypto.getRandomValues(fidByteArray);\n\n    // Replace the first 4 random bits with the constant FID header of 0b0111.\n    fidByteArray[0] = 0b01110000 + (fidByteArray[0] % 0b00010000);\n\n    const fid = encode(fidByteArray);\n\n    return VALID_FID_PATTERN.test(fid) ? fid : INVALID_FID;\n  } catch {\n    // FID generation errored\n    return INVALID_FID;\n  }\n}\n\n/** Converts a FID Uint8Array to a base64 string representation. */\nfunction encode(fidByteArray: Uint8Array): string {\n  const b64String = bufferToBase64UrlSafe(fidByteArray);\n\n  // Remove the 23rd character that was added because of the extra 4 bits at the\n  // end of our 17 byte array, and the '=' padding.\n  return b64String.substr(0, 22);\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\nexport function bufferToBase64UrlSafe(array: Uint8Array): string {\n  const b64 = btoa(String.fromCharCode(...array));\n  return b64.replace(/\\+/g, '-').replace(/\\//g, '_');\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 { AppConfig } from '../interfaces/installation-impl';\n\n/** Returns a string key that can be used to identify the app. */\nexport function getKey(appConfig: AppConfig): string {\n  return `${appConfig.appName}!${appConfig.appId}`;\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 { getKey } from '../util/get-key';\nimport { AppConfig } from '../interfaces/installation-impl';\nimport { IdChangeCallbackFn } from '../api';\n\nconst fidChangeCallbacks: Map<string, Set<IdChangeCallbackFn>> = new Map();\n\n/**\n * Calls the onIdChange callbacks with the new FID value, and broadcasts the\n * change to other tabs.\n */\nexport function fidChanged(appConfig: AppConfig, fid: string): void {\n  const key = getKey(appConfig);\n\n  callFidChangeCallbacks(key, fid);\n  broadcastFidChange(key, fid);\n}\n\nexport function addCallback(\n  appConfig: AppConfig,\n  callback: IdChangeCallbackFn\n): void {\n  // Open the broadcast channel if it's not already open,\n  // to be able to listen to change events from other tabs.\n  getBroadcastChannel();\n\n  const key = getKey(appConfig);\n\n  let callbackSet = fidChangeCallbacks.get(key);\n  if (!callbackSet) {\n    callbackSet = new Set();\n    fidChangeCallbacks.set(key, callbackSet);\n  }\n  callbackSet.add(callback);\n}\n\nexport function removeCallback(\n  appConfig: AppConfig,\n  callback: IdChangeCallbackFn\n): void {\n  const key = getKey(appConfig);\n\n  const callbackSet = fidChangeCallbacks.get(key);\n\n  if (!callbackSet) {\n    return;\n  }\n\n  callbackSet.delete(callback);\n  if (callbackSet.size === 0) {\n    fidChangeCallbacks.delete(key);\n  }\n\n  // Close broadcast channel if there are no more callbacks.\n  closeBroadcastChannel();\n}\n\nfunction callFidChangeCallbacks(key: string, fid: string): void {\n  const callbacks = fidChangeCallbacks.get(key);\n  if (!callbacks) {\n    return;\n  }\n\n  for (const callback of callbacks) {\n    callback(fid);\n  }\n}\n\nfunction broadcastFidChange(key: string, fid: string): void {\n  const channel = getBroadcastChannel();\n  if (channel) {\n    channel.postMessage({ key, fid });\n  }\n  closeBroadcastChannel();\n}\n\nlet broadcastChannel: BroadcastChannel | null = null;\n/** Opens and returns a BroadcastChannel if it is supported by the browser. */\nfunction getBroadcastChannel(): BroadcastChannel | null {\n  if (!broadcastChannel && 'BroadcastChannel' in self) {\n    broadcastChannel = new BroadcastChannel('[Firebase] FID Change');\n    broadcastChannel.onmessage = e => {\n      callFidChangeCallbacks(e.data.key, e.data.fid);\n    };\n  }\n  return broadcastChannel;\n}\n\nfunction closeBroadcastChannel(): void {\n  if (fidChangeCallbacks.size === 0 && broadcastChannel) {\n    broadcastChannel.close();\n    broadcastChannel = null;\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 { DBSchema, IDBPDatabase, openDB } from 'idb';\nimport { AppConfig } from '../interfaces/installation-impl';\nimport { InstallationEntry } from '../interfaces/installation-entry';\nimport { getKey } from '../util/get-key';\nimport { fidChanged } from './fid-changed';\n\nconst DATABASE_NAME = 'firebase-installations-database';\nconst DATABASE_VERSION = 1;\nconst OBJECT_STORE_NAME = 'firebase-installations-store';\n\ninterface InstallationsDB extends DBSchema {\n  'firebase-installations-store': {\n    key: string;\n    value: InstallationEntry | undefined;\n  };\n}\n\nlet dbPromise: Promise<IDBPDatabase<InstallationsDB>> | null = null;\nfunction getDbPromise(): Promise<IDBPDatabase<InstallationsDB>> {\n  if (!dbPromise) {\n    dbPromise = openDB(DATABASE_NAME, DATABASE_VERSION, {\n      upgrade: (db, oldVersion) => {\n        // We don't use 'break' in this switch statement, the fall-through\n        // behavior is what we want, because if there are multiple versions between\n        // the old version and the current version, we want ALL the migrations\n        // that correspond to those versions to run, not only the last one.\n        // eslint-disable-next-line default-case\n        switch (oldVersion) {\n          case 0:\n            db.createObjectStore(OBJECT_STORE_NAME);\n        }\n      }\n    });\n  }\n  return dbPromise;\n}\n\n/** Gets record(s) from the objectStore that match the given key. */\nexport async function get(\n  appConfig: AppConfig\n): Promise<InstallationEntry | undefined> {\n  const key = getKey(appConfig);\n  const db = await getDbPromise();\n  return db\n    .transaction(OBJECT_STORE_NAME)\n    .objectStore(OBJECT_STORE_NAME)\n    .get(key) as Promise<InstallationEntry>;\n}\n\n/** Assigns or overwrites the record for the given key with the given value. */\nexport async function set<ValueType extends InstallationEntry>(\n  appConfig: AppConfig,\n  value: ValueType\n): Promise<ValueType> {\n  const key = getKey(appConfig);\n  const db = await getDbPromise();\n  const tx = db.transaction(OBJECT_STORE_NAME, 'readwrite');\n  const objectStore = tx.objectStore(OBJECT_STORE_NAME);\n  const oldValue = (await objectStore.get(key)) as InstallationEntry;\n  await objectStore.put(value, key);\n  await tx.done;\n\n  if (!oldValue || oldValue.fid !== value.fid) {\n    fidChanged(appConfig, value.fid);\n  }\n\n  return value;\n}\n\n/** Removes record(s) from the objectStore that match the given key. */\nexport async function remove(appConfig: AppConfig): Promise<void> {\n  const key = getKey(appConfig);\n  const db = await getDbPromise();\n  const tx = db.transaction(OBJECT_STORE_NAME, 'readwrite');\n  await tx.objectStore(OBJECT_STORE_NAME).delete(key);\n  await tx.done;\n}\n\n/**\n * Atomically updates a record with the result of updateFn, which gets\n * called with the current value. If newValue is undefined, the record is\n * deleted instead.\n * @return Updated value\n */\nexport async function update<ValueType extends InstallationEntry | undefined>(\n  appConfig: AppConfig,\n  updateFn: (previousValue: InstallationEntry | undefined) => ValueType\n): Promise<ValueType> {\n  const key = getKey(appConfig);\n  const db = await getDbPromise();\n  const tx = db.transaction(OBJECT_STORE_NAME, 'readwrite');\n  const store = tx.objectStore(OBJECT_STORE_NAME);\n  const oldValue: InstallationEntry | undefined = (await store.get(\n    key\n  )) as InstallationEntry;\n  const newValue = updateFn(oldValue);\n\n  if (newValue === undefined) {\n    await store.delete(key);\n  } else {\n    await store.put(newValue, key);\n  }\n  await tx.done;\n\n  if (newValue && (!oldValue || oldValue.fid !== newValue.fid)) {\n    fidChanged(appConfig, newValue.fid);\n  }\n\n  return newValue;\n}\n\nexport async function clear(): Promise<void> {\n  const db = await getDbPromise();\n  const tx = db.transaction(OBJECT_STORE_NAME, 'readwrite');\n  await tx.objectStore(OBJECT_STORE_NAME).clear();\n  await tx.done;\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 { createInstallationRequest } from '../functions/create-installation-request';\nimport {\n  AppConfig,\n  FirebaseInstallationsImpl\n} from '../interfaces/installation-impl';\nimport {\n  InProgressInstallationEntry,\n  InstallationEntry,\n  RegisteredInstallationEntry,\n  RequestStatus\n} from '../interfaces/installation-entry';\nimport { PENDING_TIMEOUT_MS } from '../util/constants';\nimport { ERROR_FACTORY, ErrorCode, isServerError } from '../util/errors';\nimport { sleep } from '../util/sleep';\nimport { generateFid, INVALID_FID } from './generate-fid';\nimport { remove, set, update } from './idb-manager';\n\nexport interface InstallationEntryWithRegistrationPromise {\n  installationEntry: InstallationEntry;\n  /** Exist iff the installationEntry is not registered. */\n  registrationPromise?: Promise<RegisteredInstallationEntry>;\n}\n\n/**\n * Updates and returns the InstallationEntry from the database.\n * Also triggers a registration request if it is necessary and possible.\n */\nexport async function getInstallationEntry(\n  installations: FirebaseInstallationsImpl\n): Promise<InstallationEntryWithRegistrationPromise> {\n  let registrationPromise: Promise<RegisteredInstallationEntry> | undefined;\n\n  const installationEntry = await update(installations.appConfig, oldEntry => {\n    const installationEntry = updateOrCreateInstallationEntry(oldEntry);\n    const entryWithPromise = triggerRegistrationIfNecessary(\n      installations,\n      installationEntry\n    );\n    registrationPromise = entryWithPromise.registrationPromise;\n    return entryWithPromise.installationEntry;\n  });\n\n  if (installationEntry.fid === INVALID_FID) {\n    // FID generation failed. Waiting for the FID from the server.\n    return { installationEntry: await registrationPromise! };\n  }\n\n  return {\n    installationEntry,\n    registrationPromise\n  };\n}\n\n/**\n * Creates a new Installation Entry if one does not exist.\n * Also clears timed out pending requests.\n */\nfunction updateOrCreateInstallationEntry(\n  oldEntry: InstallationEntry | undefined\n): InstallationEntry {\n  const entry: InstallationEntry = oldEntry || {\n    fid: generateFid(),\n    registrationStatus: RequestStatus.NOT_STARTED\n  };\n\n  return clearTimedOutRequest(entry);\n}\n\n/**\n * If the Firebase Installation is not registered yet, this will trigger the\n * registration and return an InProgressInstallationEntry.\n *\n * If registrationPromise does not exist, the installationEntry is guaranteed\n * to be registered.\n */\nfunction triggerRegistrationIfNecessary(\n  installations: FirebaseInstallationsImpl,\n  installationEntry: InstallationEntry\n): InstallationEntryWithRegistrationPromise {\n  if (installationEntry.registrationStatus === RequestStatus.NOT_STARTED) {\n    if (!navigator.onLine) {\n      // Registration required but app is offline.\n      const registrationPromiseWithError = Promise.reject(\n        ERROR_FACTORY.create(ErrorCode.APP_OFFLINE)\n      );\n      return {\n        installationEntry,\n        registrationPromise: registrationPromiseWithError\n      };\n    }\n\n    // Try registering. Change status to IN_PROGRESS.\n    const inProgressEntry: InProgressInstallationEntry = {\n      fid: installationEntry.fid,\n      registrationStatus: RequestStatus.IN_PROGRESS,\n      registrationTime: Date.now()\n    };\n    const registrationPromise = registerInstallation(\n      installations,\n      inProgressEntry\n    );\n    return { installationEntry: inProgressEntry, registrationPromise };\n  } else if (\n    installationEntry.registrationStatus === RequestStatus.IN_PROGRESS\n  ) {\n    return {\n      installationEntry,\n      registrationPromise: waitUntilFidRegistration(installations)\n    };\n  } else {\n    return { installationEntry };\n  }\n}\n\n/** This will be executed only once for each new Firebase Installation. */\nasync function registerInstallation(\n  installations: FirebaseInstallationsImpl,\n  installationEntry: InProgressInstallationEntry\n): Promise<RegisteredInstallationEntry> {\n  try {\n    const registeredInstallationEntry = await createInstallationRequest(\n      installations,\n      installationEntry\n    );\n    return set(installations.appConfig, registeredInstallationEntry);\n  } catch (e) {\n    if (isServerError(e) && e.customData.serverCode === 409) {\n      // Server returned a \"FID can not be used\" error.\n      // Generate a new ID next time.\n      await remove(installations.appConfig);\n    } else {\n      // Registration failed. Set FID as not registered.\n      await set(installations.appConfig, {\n        fid: installationEntry.fid,\n        registrationStatus: RequestStatus.NOT_STARTED\n      });\n    }\n    throw e;\n  }\n}\n\n/** Call if FID registration is pending in another request. */\nasync function waitUntilFidRegistration(\n  installations: FirebaseInstallationsImpl\n): Promise<RegisteredInstallationEntry> {\n  // Unfortunately, there is no way of reliably observing when a value in\n  // IndexedDB changes (yet, see https://github.com/WICG/indexed-db-observers),\n  // so we need to poll.\n\n  let entry: InstallationEntry = await updateInstallationRequest(\n    installations.appConfig\n  );\n  while (entry.registrationStatus === RequestStatus.IN_PROGRESS) {\n    // createInstallation request still in progress.\n    await sleep(100);\n\n    entry = await updateInstallationRequest(installations.appConfig);\n  }\n\n  if (entry.registrationStatus === RequestStatus.NOT_STARTED) {\n    // The request timed out or failed in a different call. Try again.\n    const { installationEntry, registrationPromise } =\n      await getInstallationEntry(installations);\n\n    if (registrationPromise) {\n      return registrationPromise;\n    } else {\n      // if there is no registrationPromise, entry is registered.\n      return installationEntry as RegisteredInstallationEntry;\n    }\n  }\n\n  return entry;\n}\n\n/**\n * Called only if there is a CreateInstallation request in progress.\n *\n * Updates the InstallationEntry in the DB based on the status of the\n * CreateInstallation request.\n *\n * Returns the updated InstallationEntry.\n */\nfunction updateInstallationRequest(\n  appConfig: AppConfig\n): Promise<InstallationEntry> {\n  return update(appConfig, oldEntry => {\n    if (!oldEntry) {\n      throw ERROR_FACTORY.create(ErrorCode.INSTALLATION_NOT_FOUND);\n    }\n    return clearTimedOutRequest(oldEntry);\n  });\n}\n\nfunction clearTimedOutRequest(entry: InstallationEntry): InstallationEntry {\n  if (hasInstallationRequestTimedOut(entry)) {\n    return {\n      fid: entry.fid,\n      registrationStatus: RequestStatus.NOT_STARTED\n    };\n  }\n\n  return entry;\n}\n\nfunction hasInstallationRequestTimedOut(\n  installationEntry: InstallationEntry\n): boolean {\n  return (\n    installationEntry.registrationStatus === RequestStatus.IN_PROGRESS &&\n    installationEntry.registrationTime + PENDING_TIMEOUT_MS < Date.now()\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 { CreateInstallationResponse } from '../interfaces/api-response';\nimport {\n  InProgressInstallationEntry,\n  RegisteredInstallationEntry,\n  RequestStatus\n} from '../interfaces/installation-entry';\nimport { INTERNAL_AUTH_VERSION, PACKAGE_VERSION } from '../util/constants';\nimport {\n  extractAuthTokenInfoFromResponse,\n  getErrorFromResponse,\n  getHeaders,\n  getInstallationsEndpoint,\n  retryIfServerError\n} from './common';\nimport { FirebaseInstallationsImpl } from '../interfaces/installation-impl';\n\nexport async function createInstallationRequest(\n  { appConfig, heartbeatServiceProvider }: FirebaseInstallationsImpl,\n  { fid }: InProgressInstallationEntry\n): Promise<RegisteredInstallationEntry> {\n  const endpoint = getInstallationsEndpoint(appConfig);\n\n  const headers = getHeaders(appConfig);\n\n  // If heartbeat service exists, add the heartbeat string to the header.\n  const heartbeatService = heartbeatServiceProvider.getImmediate({\n    optional: true\n  });\n  if (heartbeatService) {\n    const heartbeatsHeader = await heartbeatService.getHeartbeatsHeader();\n    if (heartbeatsHeader) {\n      headers.append('x-firebase-client', heartbeatsHeader);\n    }\n  }\n\n  const body = {\n    fid,\n    authVersion: INTERNAL_AUTH_VERSION,\n    appId: appConfig.appId,\n    sdkVersion: PACKAGE_VERSION\n  };\n\n  const request: RequestInit = {\n    method: 'POST',\n    headers,\n    body: JSON.stringify(body)\n  };\n\n  const response = await retryIfServerError(() => fetch(endpoint, request));\n  if (response.ok) {\n    const responseValue: CreateInstallationResponse = await response.json();\n    const registeredInstallationEntry: RegisteredInstallationEntry = {\n      fid: responseValue.fid || fid,\n      registrationStatus: RequestStatus.COMPLETED,\n      refreshToken: responseValue.refreshToken,\n      authToken: extractAuthTokenInfoFromResponse(responseValue.authToken)\n    };\n    return registeredInstallationEntry;\n  } else {\n    throw await getErrorFromResponse('Create Installation', response);\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 { GenerateAuthTokenResponse } from '../interfaces/api-response';\nimport {\n  CompletedAuthToken,\n  RegisteredInstallationEntry\n} from '../interfaces/installation-entry';\nimport { PACKAGE_VERSION } from '../util/constants';\nimport {\n  extractAuthTokenInfoFromResponse,\n  getErrorFromResponse,\n  getHeadersWithAuth,\n  getInstallationsEndpoint,\n  retryIfServerError\n} from './common';\nimport {\n  FirebaseInstallationsImpl,\n  AppConfig\n} from '../interfaces/installation-impl';\n\nexport async function generateAuthTokenRequest(\n  { appConfig, heartbeatServiceProvider }: FirebaseInstallationsImpl,\n  installationEntry: RegisteredInstallationEntry\n): Promise<CompletedAuthToken> {\n  const endpoint = getGenerateAuthTokenEndpoint(appConfig, installationEntry);\n\n  const headers = getHeadersWithAuth(appConfig, installationEntry);\n\n  // If heartbeat service exists, add the heartbeat string to the header.\n  const heartbeatService = heartbeatServiceProvider.getImmediate({\n    optional: true\n  });\n  if (heartbeatService) {\n    const heartbeatsHeader = await heartbeatService.getHeartbeatsHeader();\n    if (heartbeatsHeader) {\n      headers.append('x-firebase-client', heartbeatsHeader);\n    }\n  }\n\n  const body = {\n    installation: {\n      sdkVersion: PACKAGE_VERSION,\n      appId: appConfig.appId\n    }\n  };\n\n  const request: RequestInit = {\n    method: 'POST',\n    headers,\n    body: JSON.stringify(body)\n  };\n\n  const response = await retryIfServerError(() => fetch(endpoint, request));\n  if (response.ok) {\n    const responseValue: GenerateAuthTokenResponse = await response.json();\n    const completedAuthToken: CompletedAuthToken =\n      extractAuthTokenInfoFromResponse(responseValue);\n    return completedAuthToken;\n  } else {\n    throw await getErrorFromResponse('Generate Auth Token', response);\n  }\n}\n\nfunction getGenerateAuthTokenEndpoint(\n  appConfig: AppConfig,\n  { fid }: RegisteredInstallationEntry\n): string {\n  return `${getInstallationsEndpoint(appConfig)}/${fid}/authTokens:generate`;\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 { generateAuthTokenRequest } from '../functions/generate-auth-token-request';\nimport {\n  AppConfig,\n  FirebaseInstallationsImpl\n} from '../interfaces/installation-impl';\nimport {\n  AuthToken,\n  CompletedAuthToken,\n  InProgressAuthToken,\n  InstallationEntry,\n  RegisteredInstallationEntry,\n  RequestStatus\n} from '../interfaces/installation-entry';\nimport { PENDING_TIMEOUT_MS, TOKEN_EXPIRATION_BUFFER } from '../util/constants';\nimport { ERROR_FACTORY, ErrorCode, isServerError } from '../util/errors';\nimport { sleep } from '../util/sleep';\nimport { remove, set, update } from './idb-manager';\n\n/**\n * Returns a valid authentication token for the installation. Generates a new\n * token if one doesn't exist, is expired or about to expire.\n *\n * Should only be called if the Firebase Installation is registered.\n */\nexport async function refreshAuthToken(\n  installations: FirebaseInstallationsImpl,\n  forceRefresh = false\n): Promise<CompletedAuthToken> {\n  let tokenPromise: Promise<CompletedAuthToken> | undefined;\n  const entry = await update(installations.appConfig, oldEntry => {\n    if (!isEntryRegistered(oldEntry)) {\n      throw ERROR_FACTORY.create(ErrorCode.NOT_REGISTERED);\n    }\n\n    const oldAuthToken = oldEntry.authToken;\n    if (!forceRefresh && isAuthTokenValid(oldAuthToken)) {\n      // There is a valid token in the DB.\n      return oldEntry;\n    } else if (oldAuthToken.requestStatus === RequestStatus.IN_PROGRESS) {\n      // There already is a token request in progress.\n      tokenPromise = waitUntilAuthTokenRequest(installations, forceRefresh);\n      return oldEntry;\n    } else {\n      // No token or token expired.\n      if (!navigator.onLine) {\n        throw ERROR_FACTORY.create(ErrorCode.APP_OFFLINE);\n      }\n\n      const inProgressEntry = makeAuthTokenRequestInProgressEntry(oldEntry);\n      tokenPromise = fetchAuthTokenFromServer(installations, inProgressEntry);\n      return inProgressEntry;\n    }\n  });\n\n  const authToken = tokenPromise\n    ? await tokenPromise\n    : (entry.authToken as CompletedAuthToken);\n  return authToken;\n}\n\n/**\n * Call only if FID is registered and Auth Token request is in progress.\n *\n * Waits until the current pending request finishes. If the request times out,\n * tries once in this thread as well.\n */\nasync function waitUntilAuthTokenRequest(\n  installations: FirebaseInstallationsImpl,\n  forceRefresh: boolean\n): Promise<CompletedAuthToken> {\n  // Unfortunately, there is no way of reliably observing when a value in\n  // IndexedDB changes (yet, see https://github.com/WICG/indexed-db-observers),\n  // so we need to poll.\n\n  let entry = await updateAuthTokenRequest(installations.appConfig);\n  while (entry.authToken.requestStatus === RequestStatus.IN_PROGRESS) {\n    // generateAuthToken still in progress.\n    await sleep(100);\n\n    entry = await updateAuthTokenRequest(installations.appConfig);\n  }\n\n  const authToken = entry.authToken;\n  if (authToken.requestStatus === RequestStatus.NOT_STARTED) {\n    // The request timed out or failed in a different call. Try again.\n    return refreshAuthToken(installations, forceRefresh);\n  } else {\n    return authToken;\n  }\n}\n\n/**\n * Called only if there is a GenerateAuthToken request in progress.\n *\n * Updates the InstallationEntry in the DB based on the status of the\n * GenerateAuthToken request.\n *\n * Returns the updated InstallationEntry.\n */\nfunction updateAuthTokenRequest(\n  appConfig: AppConfig\n): Promise<RegisteredInstallationEntry> {\n  return update(appConfig, oldEntry => {\n    if (!isEntryRegistered(oldEntry)) {\n      throw ERROR_FACTORY.create(ErrorCode.NOT_REGISTERED);\n    }\n\n    const oldAuthToken = oldEntry.authToken;\n    if (hasAuthTokenRequestTimedOut(oldAuthToken)) {\n      return {\n        ...oldEntry,\n        authToken: { requestStatus: RequestStatus.NOT_STARTED }\n      };\n    }\n\n    return oldEntry;\n  });\n}\n\nasync function fetchAuthTokenFromServer(\n  installations: FirebaseInstallationsImpl,\n  installationEntry: RegisteredInstallationEntry\n): Promise<CompletedAuthToken> {\n  try {\n    const authToken = await generateAuthTokenRequest(\n      installations,\n      installationEntry\n    );\n    const updatedInstallationEntry: RegisteredInstallationEntry = {\n      ...installationEntry,\n      authToken\n    };\n    await set(installations.appConfig, updatedInstallationEntry);\n    return authToken;\n  } catch (e) {\n    if (\n      isServerError(e) &&\n      (e.customData.serverCode === 401 || e.customData.serverCode === 404)\n    ) {\n      // Server returned a \"FID not found\" or a \"Invalid authentication\" error.\n      // Generate a new ID next time.\n      await remove(installations.appConfig);\n    } else {\n      const updatedInstallationEntry: RegisteredInstallationEntry = {\n        ...installationEntry,\n        authToken: { requestStatus: RequestStatus.NOT_STARTED }\n      };\n      await set(installations.appConfig, updatedInstallationEntry);\n    }\n    throw e;\n  }\n}\n\nfunction isEntryRegistered(\n  installationEntry: InstallationEntry | undefined\n): installationEntry is RegisteredInstallationEntry {\n  return (\n    installationEntry !== undefined &&\n    installationEntry.registrationStatus === RequestStatus.COMPLETED\n  );\n}\n\nfunction isAuthTokenValid(authToken: AuthToken): boolean {\n  return (\n    authToken.requestStatus === RequestStatus.COMPLETED &&\n    !isAuthTokenExpired(authToken)\n  );\n}\n\nfunction isAuthTokenExpired(authToken: CompletedAuthToken): boolean {\n  const now = Date.now();\n  return (\n    now < authToken.creationTime ||\n    authToken.creationTime + authToken.expiresIn < now + TOKEN_EXPIRATION_BUFFER\n  );\n}\n\n/** Returns an updated InstallationEntry with an InProgressAuthToken. */\nfunction makeAuthTokenRequestInProgressEntry(\n  oldEntry: RegisteredInstallationEntry\n): RegisteredInstallationEntry {\n  const inProgressAuthToken: InProgressAuthToken = {\n    requestStatus: RequestStatus.IN_PROGRESS,\n    requestTime: Date.now()\n  };\n  return {\n    ...oldEntry,\n    authToken: inProgressAuthToken\n  };\n}\n\nfunction hasAuthTokenRequestTimedOut(authToken: AuthToken): boolean {\n  return (\n    authToken.requestStatus === RequestStatus.IN_PROGRESS &&\n    authToken.requestTime + PENDING_TIMEOUT_MS < Date.now()\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 { getInstallationEntry } from '../helpers/get-installation-entry';\nimport { refreshAuthToken } from '../helpers/refresh-auth-token';\nimport { FirebaseInstallationsImpl } from '../interfaces/installation-impl';\nimport { Installations } from '../interfaces/public-types';\n\n/**\n * Returns a Firebase Installations auth token, identifying the current\n * Firebase Installation.\n * @param installations - The `Installations` instance.\n * @param forceRefresh - Force refresh regardless of token expiration.\n *\n * @public\n */\nexport async function getToken(\n  installations: Installations,\n  forceRefresh = false\n): Promise<string> {\n  const installationsImpl = installations as FirebaseInstallationsImpl;\n  await completeInstallationRegistration(installationsImpl);\n\n  // At this point we either have a Registered Installation in the DB, or we've\n  // already thrown an error.\n  const authToken = await refreshAuthToken(installationsImpl, forceRefresh);\n  return authToken.token;\n}\n\nasync function completeInstallationRegistration(\n  installations: FirebaseInstallationsImpl\n): Promise<void> {\n  const { registrationPromise } = await getInstallationEntry(installations);\n\n  if (registrationPromise) {\n    // A createInstallation request is in progress. Wait until it finishes.\n    await registrationPromise;\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 { ERROR_FACTORY, ErrorCode } from '../util/errors';\nimport { FirebaseApp, FirebaseOptions } from '@firebase/app';\n\nimport { AppConfig } from '../interfaces/app-config';\nimport { FirebaseError } from '@firebase/util';\n\nexport function extractAppConfig(app: FirebaseApp): AppConfig {\n  if (!app || !app.options) {\n    throw getMissingValueError('App Configuration Object');\n  }\n\n  if (!app.name) {\n    throw getMissingValueError('App Name');\n  }\n\n  // Required app config keys\n  const configKeys: ReadonlyArray<keyof FirebaseOptions> = [\n    'projectId',\n    'apiKey',\n    'appId',\n    'messagingSenderId'\n  ];\n\n  const { options } = app;\n  for (const keyName of configKeys) {\n    if (!options[keyName]) {\n      throw getMissingValueError(keyName);\n    }\n  }\n\n  return {\n    appName: app.name,\n    projectId: options.projectId!,\n    apiKey: options.apiKey!,\n    appId: options.appId!,\n    senderId: options.messagingSenderId!\n  };\n}\n\nfunction getMissingValueError(valueName: string): FirebaseError {\n  return ERROR_FACTORY.create(ErrorCode.MISSING_APP_CONFIG_VALUES, {\n    valueName\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, _getProvider } from '@firebase/app';\nimport {\n  Component,\n  ComponentType,\n  InstanceFactory,\n  ComponentContainer\n} from '@firebase/component';\nimport { getId, getToken } from '../api/index';\nimport { _FirebaseInstallationsInternal } from '../interfaces/public-types';\nimport { FirebaseInstallationsImpl } from '../interfaces/installation-impl';\nimport { extractAppConfig } from '../helpers/extract-app-config';\n\nconst INSTALLATIONS_NAME = 'installations';\nconst INSTALLATIONS_NAME_INTERNAL = 'installations-internal';\n\nconst publicFactory: InstanceFactory<'installations'> = (\n  container: ComponentContainer\n) => {\n  const app = container.getProvider('app').getImmediate();\n  // Throws if app isn't configured properly.\n  const appConfig = extractAppConfig(app);\n  const heartbeatServiceProvider = _getProvider(app, 'heartbeat');\n\n  const installationsImpl: FirebaseInstallationsImpl = {\n    app,\n    appConfig,\n    heartbeatServiceProvider,\n    _delete: () => Promise.resolve()\n  };\n  return installationsImpl;\n};\n\nconst internalFactory: InstanceFactory<'installations-internal'> = (\n  container: ComponentContainer\n) => {\n  const app = container.getProvider('app').getImmediate();\n  // Internal FIS instance relies on public FIS instance.\n  const installations = _getProvider(app, INSTALLATIONS_NAME).getImmediate();\n\n  const installationsInternal: _FirebaseInstallationsInternal = {\n    getId: () => getId(installations),\n    getToken: (forceRefresh?: boolean) => getToken(installations, forceRefresh)\n  };\n  return installationsInternal;\n};\n\nexport function registerInstallations(): void {\n  _registerComponent(\n    new Component(INSTALLATIONS_NAME, publicFactory, ComponentType.PUBLIC)\n  );\n  _registerComponent(\n    new Component(\n      INSTALLATIONS_NAME_INTERNAL,\n      internalFactory,\n      ComponentType.PRIVATE\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 { getInstallationEntry } from '../helpers/get-installation-entry';\nimport { refreshAuthToken } from '../helpers/refresh-auth-token';\nimport { FirebaseInstallationsImpl } from '../interfaces/installation-impl';\nimport { Installations } from '../interfaces/public-types';\n\n/**\n * Creates a Firebase Installation if there isn't one for the app and\n * returns the Installation ID.\n * @param installations - The `Installations` instance.\n *\n * @public\n */\nexport async function getId(installations: Installations): Promise<string> {\n  const installationsImpl = installations as FirebaseInstallationsImpl;\n  const { installationEntry, registrationPromise } = await getInstallationEntry(\n    installationsImpl\n  );\n\n  if (registrationPromise) {\n    registrationPromise.catch(console.error);\n  } else {\n    // If the installation is already registered, update the authentication\n    // token if needed.\n    refreshAuthToken(installationsImpl).catch(console.error);\n  }\n\n  return installationEntry.fid;\n}\n","/**\n * @license\n * Copyright 2018 Google LLC\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\"); you may not use this file except\n * in compliance with the License. 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 distributed under the License\n * is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express\n * or implied. See the License for the specific language governing permissions and limitations under\n * the License.\n */\n\nimport {\n  CONSOLE_CAMPAIGN_ANALYTICS_ENABLED,\n  CONSOLE_CAMPAIGN_ID,\n  CONSOLE_CAMPAIGN_NAME,\n  CONSOLE_CAMPAIGN_TIME\n} from '../util/constants';\n\nexport interface MessagePayloadInternal {\n  notification?: NotificationPayloadInternal;\n  data?: unknown;\n  fcmOptions?: FcmOptionsInternal;\n  messageType?: MessageType;\n  isFirebaseMessaging?: boolean;\n  from: string;\n  fcmMessageId: string;\n  // eslint-disable-next-line camelcase\n  collapse_key: string;\n}\n\nexport interface NotificationPayloadInternal extends NotificationOptions {\n  title: string;\n  // Supported in the Legacy Send API.\n  // See:https://firebase.google.com/docs/cloud-messaging/xmpp-server-ref.\n  // eslint-disable-next-line camelcase\n  click_action?: string;\n  icon?: string;\n}\n\n// Defined in\n// https://firebase.google.com/docs/reference/fcm/rest/v1/projects.messages#webpushfcmoptions. Note\n// that the keys are sent to the clients in snake cases which we need to convert to camel so it can\n// be exposed as a type to match the Firebase API convention.\nexport interface FcmOptionsInternal {\n  link?: string;\n\n  // eslint-disable-next-line camelcase\n  analytics_label?: string;\n}\n\nexport enum MessageType {\n  PUSH_RECEIVED = 'push-received',\n  NOTIFICATION_CLICKED = 'notification-clicked'\n}\n\n/** Additional data of a message sent from the FN Console. */\nexport interface ConsoleMessageData {\n  [CONSOLE_CAMPAIGN_ID]: string;\n  [CONSOLE_CAMPAIGN_TIME]: string;\n  [CONSOLE_CAMPAIGN_NAME]?: string;\n  [CONSOLE_CAMPAIGN_ANALYTICS_ENABLED]?: '1';\n}\n","/**\n * @license\n * Copyright 2017 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 arrayToBase64(array: Uint8Array | ArrayBuffer): string {\n  const uint8Array = new Uint8Array(array);\n  const base64String = btoa(String.fromCharCode(...uint8Array));\n  return base64String.replace(/=/g, '').replace(/\\+/g, '-').replace(/\\//g, '_');\n}\n\nexport function base64ToArray(base64String: string): Uint8Array {\n  const padding = '='.repeat((4 - (base64String.length % 4)) % 4);\n  const base64 = (base64String + padding)\n    .replace(/\\-/g, '+')\n    .replace(/_/g, '/');\n\n  const rawData = atob(base64);\n  const outputArray = new Uint8Array(rawData.length);\n\n  for (let i = 0; i < rawData.length; ++i) {\n    outputArray[i] = rawData.charCodeAt(i);\n  }\n  return outputArray;\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 { deleteDB, openDB } from 'idb';\n\nimport { TokenDetails } from '../interfaces/token-details';\nimport { arrayToBase64 } from './array-base64-translator';\n\n// https://github.com/firebase/firebase-js-sdk/blob/7857c212f944a2a9eb421fd4cb7370181bc034b5/packages/messaging/src/interfaces/token-details.ts\nexport interface V2TokenDetails {\n  fcmToken: string;\n  swScope: string;\n  vapidKey: string | Uint8Array;\n  subscription: PushSubscription;\n  fcmSenderId: string;\n  fcmPushSet: string;\n  createTime?: number;\n  endpoint?: string;\n  auth?: string;\n  p256dh?: string;\n}\n\n// https://github.com/firebase/firebase-js-sdk/blob/6b5b15ce4ea3df5df5df8a8b33a4e41e249c7715/packages/messaging/src/interfaces/token-details.ts\nexport interface V3TokenDetails {\n  fcmToken: string;\n  swScope: string;\n  vapidKey: Uint8Array;\n  fcmSenderId: string;\n  fcmPushSet: string;\n  endpoint: string;\n  auth: ArrayBuffer;\n  p256dh: ArrayBuffer;\n  createTime: number;\n}\n\n// https://github.com/firebase/firebase-js-sdk/blob/9567dba664732f681fa7fe60f5b7032bb1daf4c9/packages/messaging/src/interfaces/token-details.ts\nexport interface V4TokenDetails {\n  fcmToken: string;\n  swScope: string;\n  vapidKey: Uint8Array;\n  fcmSenderId: string;\n  endpoint: string;\n  auth: ArrayBufferLike;\n  p256dh: ArrayBufferLike;\n  createTime: number;\n}\n\nconst OLD_DB_NAME = 'fcm_token_details_db';\n/**\n * The last DB version of 'fcm_token_details_db' was 4. This is one higher, so that the upgrade\n * callback is called for all versions of the old DB.\n */\nconst OLD_DB_VERSION = 5;\nconst OLD_OBJECT_STORE_NAME = 'fcm_token_object_Store';\n\nexport async function migrateOldDatabase(\n  senderId: string\n): Promise<TokenDetails | null> {\n  if ('databases' in indexedDB) {\n    // indexedDb.databases() is an IndexedDB v3 API and does not exist in all browsers. TODO: Remove\n    // typecast when it lands in TS types.\n    const databases = await (\n      indexedDB as {\n        databases(): Promise<Array<{ name: string; version: number }>>;\n      }\n    ).databases();\n    const dbNames = databases.map(db => db.name);\n\n    if (!dbNames.includes(OLD_DB_NAME)) {\n      // old DB didn't exist, no need to open.\n      return null;\n    }\n  }\n\n  let tokenDetails: TokenDetails | null = null;\n\n  const db = await openDB(OLD_DB_NAME, OLD_DB_VERSION, {\n    upgrade: async (db, oldVersion, newVersion, upgradeTransaction) => {\n      if (oldVersion < 2) {\n        // Database too old, skip migration.\n        return;\n      }\n\n      if (!db.objectStoreNames.contains(OLD_OBJECT_STORE_NAME)) {\n        // Database did not exist. Nothing to do.\n        return;\n      }\n\n      const objectStore = upgradeTransaction.objectStore(OLD_OBJECT_STORE_NAME);\n      const value = await objectStore.index('fcmSenderId').get(senderId);\n      await objectStore.clear();\n\n      if (!value) {\n        // No entry in the database, nothing to migrate.\n        return;\n      }\n\n      if (oldVersion === 2) {\n        const oldDetails = value as V2TokenDetails;\n\n        if (!oldDetails.auth || !oldDetails.p256dh || !oldDetails.endpoint) {\n          return;\n        }\n\n        tokenDetails = {\n          token: oldDetails.fcmToken,\n          createTime: oldDetails.createTime ?? Date.now(),\n          subscriptionOptions: {\n            auth: oldDetails.auth,\n            p256dh: oldDetails.p256dh,\n            endpoint: oldDetails.endpoint,\n            swScope: oldDetails.swScope,\n            vapidKey:\n              typeof oldDetails.vapidKey === 'string'\n                ? oldDetails.vapidKey\n                : arrayToBase64(oldDetails.vapidKey)\n          }\n        };\n      } else if (oldVersion === 3) {\n        const oldDetails = value as V3TokenDetails;\n\n        tokenDetails = {\n          token: oldDetails.fcmToken,\n          createTime: oldDetails.createTime,\n          subscriptionOptions: {\n            auth: arrayToBase64(oldDetails.auth),\n            p256dh: arrayToBase64(oldDetails.p256dh),\n            endpoint: oldDetails.endpoint,\n            swScope: oldDetails.swScope,\n            vapidKey: arrayToBase64(oldDetails.vapidKey)\n          }\n        };\n      } else if (oldVersion === 4) {\n        const oldDetails = value as V4TokenDetails;\n\n        tokenDetails = {\n          token: oldDetails.fcmToken,\n          createTime: oldDetails.createTime,\n          subscriptionOptions: {\n            auth: arrayToBase64(oldDetails.auth),\n            p256dh: arrayToBase64(oldDetails.p256dh),\n            endpoint: oldDetails.endpoint,\n            swScope: oldDetails.swScope,\n            vapidKey: arrayToBase64(oldDetails.vapidKey)\n          }\n        };\n      }\n    }\n  });\n  db.close();\n\n  // Delete all old databases.\n  await deleteDB(OLD_DB_NAME);\n  await deleteDB('fcm_vapid_details_db');\n  await deleteDB('undefined');\n\n  return checkTokenDetails(tokenDetails) ? tokenDetails : null;\n}\n\nfunction checkTokenDetails(\n  tokenDetails: TokenDetails | null\n): tokenDetails is TokenDetails {\n  if (!tokenDetails || !tokenDetails.subscriptionOptions) {\n    return false;\n  }\n  const { subscriptionOptions } = tokenDetails;\n  return (\n    typeof tokenDetails.createTime === 'number' &&\n    tokenDetails.createTime > 0 &&\n    typeof tokenDetails.token === 'string' &&\n    tokenDetails.token.length > 0 &&\n    typeof subscriptionOptions.auth === 'string' &&\n    subscriptionOptions.auth.length > 0 &&\n    typeof subscriptionOptions.p256dh === 'string' &&\n    subscriptionOptions.p256dh.length > 0 &&\n    typeof subscriptionOptions.endpoint === 'string' &&\n    subscriptionOptions.endpoint.length > 0 &&\n    typeof subscriptionOptions.swScope === 'string' &&\n    subscriptionOptions.swScope.length > 0 &&\n    typeof subscriptionOptions.vapidKey === 'string' &&\n    subscriptionOptions.vapidKey.length > 0\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 { DBSchema, IDBPDatabase, deleteDB, openDB } from 'idb';\n\nimport { FirebaseInternalDependencies } from '../interfaces/internal-dependencies';\nimport { TokenDetails } from '../interfaces/token-details';\nimport { migrateOldDatabase } from '../helpers/migrate-old-database';\n\n// Exported for tests.\nexport const DATABASE_NAME = 'firebase-messaging-database';\nconst DATABASE_VERSION = 1;\nconst OBJECT_STORE_NAME = 'firebase-messaging-store';\n\ninterface MessagingDB extends DBSchema {\n  'firebase-messaging-store': {\n    key: string;\n    value: TokenDetails;\n  };\n}\n\nlet dbPromise: Promise<IDBPDatabase<MessagingDB>> | null = null;\nfunction getDbPromise(): Promise<IDBPDatabase<MessagingDB>> {\n  if (!dbPromise) {\n    dbPromise = openDB(DATABASE_NAME, DATABASE_VERSION, {\n      upgrade: (upgradeDb, oldVersion) => {\n        // We don't use 'break' in this switch statement, the fall-through behavior is what we want,\n        // because if there are multiple versions between the old version and the current version, we\n        // want ALL the migrations that correspond to those versions to run, not only the last one.\n        // eslint-disable-next-line default-case\n        switch (oldVersion) {\n          case 0:\n            upgradeDb.createObjectStore(OBJECT_STORE_NAME);\n        }\n      }\n    });\n  }\n  return dbPromise;\n}\n\n/** Gets record(s) from the objectStore that match the given key. */\nexport async function dbGet(\n  firebaseDependencies: FirebaseInternalDependencies\n): Promise<TokenDetails | undefined> {\n  const key = getKey(firebaseDependencies);\n  const db = await getDbPromise();\n  const tokenDetails = (await db\n    .transaction(OBJECT_STORE_NAME)\n    .objectStore(OBJECT_STORE_NAME)\n    .get(key)) as TokenDetails;\n\n  if (tokenDetails) {\n    return tokenDetails;\n  } else {\n    // Check if there is a tokenDetails object in the old DB.\n    const oldTokenDetails = await migrateOldDatabase(\n      firebaseDependencies.appConfig.senderId\n    );\n    if (oldTokenDetails) {\n      await dbSet(firebaseDependencies, oldTokenDetails);\n      return oldTokenDetails;\n    }\n  }\n}\n\n/** Assigns or overwrites the record for the given key with the given value. */\nexport async function dbSet(\n  firebaseDependencies: FirebaseInternalDependencies,\n  tokenDetails: TokenDetails\n): Promise<TokenDetails> {\n  const key = getKey(firebaseDependencies);\n  const db = await getDbPromise();\n  const tx = db.transaction(OBJECT_STORE_NAME, 'readwrite');\n  await tx.objectStore(OBJECT_STORE_NAME).put(tokenDetails, key);\n  await tx.done;\n  return tokenDetails;\n}\n\n/** Removes record(s) from the objectStore that match the given key. */\nexport async function dbRemove(\n  firebaseDependencies: FirebaseInternalDependencies\n): Promise<void> {\n  const key = getKey(firebaseDependencies);\n  const db = await getDbPromise();\n  const tx = db.transaction(OBJECT_STORE_NAME, 'readwrite');\n  await tx.objectStore(OBJECT_STORE_NAME).delete(key);\n  await tx.done;\n}\n\n/** Deletes the DB. Useful for tests. */\nexport async function dbDelete(): Promise<void> {\n  if (dbPromise) {\n    (await dbPromise).close();\n    await deleteDB(DATABASE_NAME);\n    dbPromise = null;\n  }\n}\n\nfunction getKey({ appConfig }: FirebaseInternalDependencies): string {\n  return appConfig.appId;\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 { DEFAULT_VAPID_KEY, ENDPOINT } from '../util/constants';\nimport { ERROR_FACTORY, ErrorCode } from '../util/errors';\nimport { SubscriptionOptions, TokenDetails } from '../interfaces/token-details';\n\nimport { AppConfig } from '../interfaces/app-config';\nimport { FirebaseInternalDependencies } from '../interfaces/internal-dependencies';\n\nexport interface ApiResponse {\n  token?: string;\n  error?: { message: string };\n}\n\nexport interface ApiRequestBody {\n  web: {\n    endpoint: string;\n    p256dh: string;\n    auth: string;\n    applicationPubKey?: string;\n  };\n}\n\nexport async function requestGetToken(\n  firebaseDependencies: FirebaseInternalDependencies,\n  subscriptionOptions: SubscriptionOptions\n): Promise<string> {\n  const headers = await getHeaders(firebaseDependencies);\n  const body = getBody(subscriptionOptions);\n\n  const subscribeOptions = {\n    method: 'POST',\n    headers,\n    body: JSON.stringify(body)\n  };\n\n  let responseData: ApiResponse;\n  try {\n    const response = await fetch(\n      getEndpoint(firebaseDependencies.appConfig),\n      subscribeOptions\n    );\n    responseData = await response.json();\n  } catch (err) {\n    throw ERROR_FACTORY.create(ErrorCode.TOKEN_SUBSCRIBE_FAILED, {\n      errorInfo: (err as Error)?.toString()\n    });\n  }\n\n  if (responseData.error) {\n    const message = responseData.error.message;\n    throw ERROR_FACTORY.create(ErrorCode.TOKEN_SUBSCRIBE_FAILED, {\n      errorInfo: message\n    });\n  }\n\n  if (!responseData.token) {\n    throw ERROR_FACTORY.create(ErrorCode.TOKEN_SUBSCRIBE_NO_TOKEN);\n  }\n\n  return responseData.token;\n}\n\nexport async function requestUpdateToken(\n  firebaseDependencies: FirebaseInternalDependencies,\n  tokenDetails: TokenDetails\n): Promise<string> {\n  const headers = await getHeaders(firebaseDependencies);\n  const body = getBody(tokenDetails.subscriptionOptions!);\n\n  const updateOptions = {\n    method: 'PATCH',\n    headers,\n    body: JSON.stringify(body)\n  };\n\n  let responseData: ApiResponse;\n  try {\n    const response = await fetch(\n      `${getEndpoint(firebaseDependencies.appConfig)}/${tokenDetails.token}`,\n      updateOptions\n    );\n    responseData = await response.json();\n  } catch (err) {\n    throw ERROR_FACTORY.create(ErrorCode.TOKEN_UPDATE_FAILED, {\n      errorInfo: (err as Error)?.toString()\n    });\n  }\n\n  if (responseData.error) {\n    const message = responseData.error.message;\n    throw ERROR_FACTORY.create(ErrorCode.TOKEN_UPDATE_FAILED, {\n      errorInfo: message\n    });\n  }\n\n  if (!responseData.token) {\n    throw ERROR_FACTORY.create(ErrorCode.TOKEN_UPDATE_NO_TOKEN);\n  }\n\n  return responseData.token;\n}\n\nexport async function requestDeleteToken(\n  firebaseDependencies: FirebaseInternalDependencies,\n  token: string\n): Promise<void> {\n  const headers = await getHeaders(firebaseDependencies);\n\n  const unsubscribeOptions = {\n    method: 'DELETE',\n    headers\n  };\n\n  try {\n    const response = await fetch(\n      `${getEndpoint(firebaseDependencies.appConfig)}/${token}`,\n      unsubscribeOptions\n    );\n    const responseData: ApiResponse = await response.json();\n    if (responseData.error) {\n      const message = responseData.error.message;\n      throw ERROR_FACTORY.create(ErrorCode.TOKEN_UNSUBSCRIBE_FAILED, {\n        errorInfo: message\n      });\n    }\n  } catch (err) {\n    throw ERROR_FACTORY.create(ErrorCode.TOKEN_UNSUBSCRIBE_FAILED, {\n      errorInfo: (err as Error)?.toString()\n    });\n  }\n}\n\nfunction getEndpoint({ projectId }: AppConfig): string {\n  return `${ENDPOINT}/projects/${projectId!}/registrations`;\n}\n\nasync function getHeaders({\n  appConfig,\n  installations\n}: FirebaseInternalDependencies): Promise<Headers> {\n  const authToken = await installations.getToken();\n\n  return new Headers({\n    'Content-Type': 'application/json',\n    Accept: 'application/json',\n    'x-goog-api-key': appConfig.apiKey!,\n    'x-goog-firebase-installations-auth': `FIS ${authToken}`\n  });\n}\n\nfunction getBody({\n  p256dh,\n  auth,\n  endpoint,\n  vapidKey\n}: SubscriptionOptions): ApiRequestBody {\n  const body: ApiRequestBody = {\n    web: {\n      endpoint,\n      auth,\n      p256dh\n    }\n  };\n\n  if (vapidKey !== DEFAULT_VAPID_KEY) {\n    body.web.applicationPubKey = vapidKey;\n  }\n\n  return body;\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 { SubscriptionOptions, TokenDetails } from '../interfaces/token-details';\nimport {\n  arrayToBase64,\n  base64ToArray\n} from '../helpers/array-base64-translator';\nimport { dbGet, dbRemove, dbSet } from './idb-manager';\nimport {\n  requestDeleteToken,\n  requestGetToken,\n  requestUpdateToken\n} from './requests';\n\nimport { FirebaseInternalDependencies } from '../interfaces/internal-dependencies';\nimport { MessagingService } from '../messaging-service';\n\n// UpdateRegistration will be called once every week.\nconst TOKEN_EXPIRATION_MS = 7 * 24 * 60 * 60 * 1000; // 7 days\n\nexport async function getTokenInternal(\n  messaging: MessagingService\n): Promise<string> {\n  const pushSubscription = await getPushSubscription(\n    messaging.swRegistration!,\n    messaging.vapidKey!\n  );\n\n  const subscriptionOptions: SubscriptionOptions = {\n    vapidKey: messaging.vapidKey!,\n    swScope: messaging.swRegistration!.scope,\n    endpoint: pushSubscription.endpoint,\n    auth: arrayToBase64(pushSubscription.getKey('auth')!),\n    p256dh: arrayToBase64(pushSubscription.getKey('p256dh')!)\n  };\n\n  const tokenDetails = await dbGet(messaging.firebaseDependencies);\n  if (!tokenDetails) {\n    // No token, get a new one.\n    return getNewToken(messaging.firebaseDependencies, subscriptionOptions);\n  } else if (\n    !isTokenValid(tokenDetails.subscriptionOptions!, subscriptionOptions)\n  ) {\n    // Invalid token, get a new one.\n    try {\n      await requestDeleteToken(\n        messaging.firebaseDependencies!,\n        tokenDetails.token\n      );\n    } catch (e) {\n      // Suppress errors because of #2364\n      console.warn(e);\n    }\n\n    return getNewToken(messaging.firebaseDependencies!, subscriptionOptions);\n  } else if (Date.now() >= tokenDetails.createTime + TOKEN_EXPIRATION_MS) {\n    // Weekly token refresh\n    return updateToken(messaging, {\n      token: tokenDetails.token,\n      createTime: Date.now(),\n      subscriptionOptions\n    });\n  } else {\n    // Valid token, nothing to do.\n    return tokenDetails.token;\n  }\n}\n\n/**\n * This method deletes the token from the database, unsubscribes the token from FCM, and unregisters\n * the push subscription if it exists.\n */\nexport async function deleteTokenInternal(\n  messaging: MessagingService\n): Promise<boolean> {\n  const tokenDetails = await dbGet(messaging.firebaseDependencies);\n  if (tokenDetails) {\n    await requestDeleteToken(\n      messaging.firebaseDependencies,\n      tokenDetails.token\n    );\n    await dbRemove(messaging.firebaseDependencies);\n  }\n\n  // Unsubscribe from the push subscription.\n  const pushSubscription =\n    await messaging.swRegistration!.pushManager.getSubscription();\n  if (pushSubscription) {\n    return pushSubscription.unsubscribe();\n  }\n\n  // If there's no SW, consider it a success.\n  return true;\n}\n\nasync function updateToken(\n  messaging: MessagingService,\n  tokenDetails: TokenDetails\n): Promise<string> {\n  try {\n    const updatedToken = await requestUpdateToken(\n      messaging.firebaseDependencies,\n      tokenDetails\n    );\n\n    const updatedTokenDetails: TokenDetails = {\n      ...tokenDetails,\n      token: updatedToken,\n      createTime: Date.now()\n    };\n\n    await dbSet(messaging.firebaseDependencies, updatedTokenDetails);\n    return updatedToken;\n  } catch (e) {\n    await deleteTokenInternal(messaging);\n    throw e;\n  }\n}\n\nasync function getNewToken(\n  firebaseDependencies: FirebaseInternalDependencies,\n  subscriptionOptions: SubscriptionOptions\n): Promise<string> {\n  const token = await requestGetToken(\n    firebaseDependencies,\n    subscriptionOptions\n  );\n  const tokenDetails: TokenDetails = {\n    token,\n    createTime: Date.now(),\n    subscriptionOptions\n  };\n  await dbSet(firebaseDependencies, tokenDetails);\n  return tokenDetails.token;\n}\n\n/**\n * Gets a PushSubscription for the current user.\n */\nasync function getPushSubscription(\n  swRegistration: ServiceWorkerRegistration,\n  vapidKey: string\n): Promise<PushSubscription> {\n  const subscription = await swRegistration.pushManager.getSubscription();\n  if (subscription) {\n    return subscription;\n  }\n\n  return swRegistration.pushManager.subscribe({\n    userVisibleOnly: true,\n    // Chrome <= 75 doesn't support base64-encoded VAPID key. For backward compatibility, VAPID key\n    // submitted to pushManager#subscribe must be of type Uint8Array.\n    applicationServerKey: base64ToArray(vapidKey)\n  });\n}\n\n/**\n * Checks if the saved tokenDetails object matches the configuration provided.\n */\nfunction isTokenValid(\n  dbOptions: SubscriptionOptions,\n  currentOptions: SubscriptionOptions\n): boolean {\n  const isVapidKeyEqual = currentOptions.vapidKey === dbOptions.vapidKey;\n  const isEndpointEqual = currentOptions.endpoint === dbOptions.endpoint;\n  const isAuthEqual = currentOptions.auth === dbOptions.auth;\n  const isP256dhEqual = currentOptions.p256dh === dbOptions.p256dh;\n\n  return isVapidKeyEqual && isEndpointEqual && isAuthEqual && isP256dhEqual;\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 { MessagePayload } from '../interfaces/public-types';\nimport { MessagePayloadInternal } from '../interfaces/internal-message-payload';\n\nexport function externalizePayload(\n  internalPayload: MessagePayloadInternal\n): MessagePayload {\n  const payload: MessagePayload = {\n    from: internalPayload.from,\n    // eslint-disable-next-line camelcase\n    collapseKey: internalPayload.collapse_key,\n    // eslint-disable-next-line camelcase\n    messageId: internalPayload.fcmMessageId\n  } as MessagePayload;\n\n  propagateNotificationPayload(payload, internalPayload);\n  propagateDataPayload(payload, internalPayload);\n  propagateFcmOptions(payload, internalPayload);\n\n  return payload;\n}\n\nfunction propagateNotificationPayload(\n  payload: MessagePayload,\n  messagePayloadInternal: MessagePayloadInternal\n): void {\n  if (!messagePayloadInternal.notification) {\n    return;\n  }\n\n  payload.notification = {};\n\n  const title = messagePayloadInternal.notification!.title;\n  if (!!title) {\n    payload.notification!.title = title;\n  }\n\n  const body = messagePayloadInternal.notification!.body;\n  if (!!body) {\n    payload.notification!.body = body;\n  }\n\n  const image = messagePayloadInternal.notification!.image;\n  if (!!image) {\n    payload.notification!.image = image;\n  }\n\n  const icon = messagePayloadInternal.notification!.icon;\n  if (!!icon) {\n    payload.notification!.icon = icon;\n  }\n}\n\nfunction propagateDataPayload(\n  payload: MessagePayload,\n  messagePayloadInternal: MessagePayloadInternal\n): void {\n  if (!messagePayloadInternal.data) {\n    return;\n  }\n\n  payload.data = messagePayloadInternal.data as { [key: string]: string };\n}\n\nfunction propagateFcmOptions(\n  payload: MessagePayload,\n  messagePayloadInternal: MessagePayloadInternal\n): void {\n  // fcmOptions.link value is written into notification.click_action. see more in b/232072111\n  if (\n    !messagePayloadInternal.fcmOptions &&\n    !messagePayloadInternal.notification?.click_action\n  ) {\n    return;\n  }\n\n  payload.fcmOptions = {};\n\n  const link =\n    messagePayloadInternal.fcmOptions?.link ??\n    messagePayloadInternal.notification?.click_action;\n\n  if (!!link) {\n    payload.fcmOptions!.link = link;\n  }\n\n  // eslint-disable-next-line camelcase\n  const analyticsLabel = messagePayloadInternal.fcmOptions?.analytics_label;\n  if (!!analyticsLabel) {\n    payload.fcmOptions!.analyticsLabel = analyticsLabel;\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  DEFAULT_BACKOFF_TIME_MS,\n  EVENT_MESSAGE_DELIVERED,\n  FCM_LOG_SOURCE,\n  LOG_INTERVAL_IN_MS,\n  MAX_NUMBER_OF_EVENTS_PER_LOG_REQUEST,\n  MAX_RETRIES,\n  MessageType,\n  SDK_PLATFORM_WEB\n} from '../util/constants';\nimport {\n  FcmEvent,\n  LogEvent,\n  LogRequest,\n  LogResponse\n} from '../interfaces/logging-types';\n\nimport { MessagePayloadInternal } from '../interfaces/internal-message-payload';\nimport { MessagingService } from '../messaging-service';\n\nconst FIRELOG_ENDPOINT = _mergeStrings(\n  'hts/frbslgigp.ogepscmv/ieo/eaylg',\n  'tp:/ieaeogn-agolai.o/1frlglgc/o'\n);\n\nconst FCM_TRANSPORT_KEY = _mergeStrings(\n  'AzSCbw63g1R0nCw85jG8',\n  'Iaya3yLKwmgvh7cF0q4'\n);\n\nexport function startLoggingService(messaging: MessagingService): void {\n  if (!messaging.isLogServiceStarted) {\n    _processQueue(messaging, LOG_INTERVAL_IN_MS);\n    messaging.isLogServiceStarted = true;\n  }\n}\n\n/**\n *\n * @param messaging the messaging instance.\n * @param offsetInMs this method execute after `offsetInMs` elapsed .\n */\nexport function _processQueue(\n  messaging: MessagingService,\n  offsetInMs: number\n): void {\n  setTimeout(async () => {\n    if (!messaging.deliveryMetricsExportedToBigQueryEnabled) {\n      // flush events and terminate logging service\n      messaging.logEvents = [];\n      messaging.isLogServiceStarted = false;\n\n      return;\n    }\n\n    if (!messaging.logEvents.length) {\n      return _processQueue(messaging, LOG_INTERVAL_IN_MS);\n    }\n\n    await _dispatchLogEvents(messaging);\n  }, offsetInMs);\n}\n\nexport async function _dispatchLogEvents(\n  messaging: MessagingService\n): Promise<void> {\n  for (\n    let i = 0, n = messaging.logEvents.length;\n    i < n;\n    i += MAX_NUMBER_OF_EVENTS_PER_LOG_REQUEST\n  ) {\n    const logRequest = _createLogRequest(\n      messaging.logEvents.slice(i, i + MAX_NUMBER_OF_EVENTS_PER_LOG_REQUEST)\n    );\n\n    let retryCount = 0,\n      response = {} as Response;\n\n    do {\n      try {\n        response = await fetch(\n          FIRELOG_ENDPOINT.concat('?key=', FCM_TRANSPORT_KEY),\n          {\n            method: 'POST',\n            body: JSON.stringify(logRequest)\n          }\n        );\n\n        // don't retry on 200s or non retriable errors\n        if (response.ok || (!response.ok && !isRetriableError(response))) {\n          break;\n        }\n\n        if (!response.ok && isRetriableError(response)) {\n          // rethrow to retry with quota\n          throw new Error(\n            'a retriable Non-200 code is returned in fetch to Firelog endpoint. Retry'\n          );\n        }\n      } catch (error) {\n        const isLastAttempt = retryCount === MAX_RETRIES;\n        if (isLastAttempt) {\n          // existing the do-while interactive retry logic because retry quota has reached.\n          break;\n        }\n      }\n\n      let delayInMs: number;\n      try {\n        delayInMs = Number(\n          ((await response.json()) as LogResponse).nextRequestWaitMillis\n        );\n      } catch (e) {\n        delayInMs = DEFAULT_BACKOFF_TIME_MS;\n      }\n\n      await new Promise(resolve => setTimeout(resolve, delayInMs));\n\n      retryCount++;\n    } while (retryCount < MAX_RETRIES);\n  }\n\n  messaging.logEvents = [];\n  // schedule for next logging\n  _processQueue(messaging, LOG_INTERVAL_IN_MS);\n}\n\nfunction isRetriableError(response: Response): boolean {\n  const httpStatus = response.status;\n\n  return (\n    httpStatus === 429 ||\n    httpStatus === 500 ||\n    httpStatus === 503 ||\n    httpStatus === 504\n  );\n}\n\nexport async function stageLog(\n  messaging: MessagingService,\n  internalPayload: MessagePayloadInternal\n): Promise<void> {\n  const fcmEvent = createFcmEvent(\n    internalPayload,\n    await messaging.firebaseDependencies.installations.getId()\n  );\n\n  createAndEnqueueLogEvent(messaging, fcmEvent);\n}\n\nfunction createFcmEvent(\n  internalPayload: MessagePayloadInternal,\n  fid: string\n): FcmEvent {\n  const fcmEvent = {} as FcmEvent;\n\n  /* eslint-disable camelcase */\n  // some fields should always be non-null. Still check to ensure.\n  if (!!internalPayload.from) {\n    fcmEvent.project_number = internalPayload.from;\n  }\n\n  if (!!internalPayload.fcmMessageId) {\n    fcmEvent.message_id = internalPayload.fcmMessageId;\n  }\n\n  fcmEvent.instance_id = fid;\n\n  if (!!internalPayload.notification) {\n    fcmEvent.message_type = MessageType.DISPLAY_NOTIFICATION.toString();\n  } else {\n    fcmEvent.message_type = MessageType.DATA_MESSAGE.toString();\n  }\n\n  fcmEvent.sdk_platform = SDK_PLATFORM_WEB.toString();\n  fcmEvent.package_name = self.origin.replace(/(^\\w+:|^)\\/\\//, '');\n\n  if (!!internalPayload.collapse_key) {\n    fcmEvent.collapse_key = internalPayload.collapse_key;\n  }\n\n  fcmEvent.event = EVENT_MESSAGE_DELIVERED.toString();\n\n  if (!!internalPayload.fcmOptions?.analytics_label) {\n    fcmEvent.analytics_label = internalPayload.fcmOptions?.analytics_label;\n  }\n\n  /* eslint-enable camelcase */\n  return fcmEvent;\n}\n\nfunction createAndEnqueueLogEvent(\n  messaging: MessagingService,\n  fcmEvent: FcmEvent\n): void {\n  const logEvent = {} as LogEvent;\n\n  /* eslint-disable camelcase */\n  logEvent.event_time_ms = Math.floor(Date.now()).toString();\n  logEvent.source_extension_json_proto3 = JSON.stringify(fcmEvent);\n  // eslint-disable-next-line camelcase\n\n  messaging.logEvents.push(logEvent);\n}\n\nexport function _createLogRequest(logEventQueue: LogEvent[]): LogRequest {\n  const logRequest = {} as LogRequest;\n\n  /* eslint-disable camelcase */\n  logRequest.log_source = FCM_LOG_SOURCE.toString();\n  logRequest.log_event = logEventQueue;\n  /* eslint-enable camelcase */\n\n  return logRequest;\n}\n\nexport function _mergeStrings(s1: string, s2: string): string {\n  const resultArray = [];\n  for (let i = 0; i < s1.length; i++) {\n    resultArray.push(s1.charAt(i));\n    if (i < s2.length) {\n      resultArray.push(s2.charAt(i));\n    }\n  }\n\n  return resultArray.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 { FirebaseApp, _FirebaseService } from '@firebase/app';\nimport { MessagePayload, NextFn, Observer } from './interfaces/public-types';\n\nimport { FirebaseAnalyticsInternalName } from '@firebase/analytics-interop-types';\nimport { FirebaseInternalDependencies } from './interfaces/internal-dependencies';\nimport { LogEvent } from './interfaces/logging-types';\nimport { Provider } from '@firebase/component';\nimport { _FirebaseInstallationsInternal } from '@firebase/installations';\nimport { extractAppConfig } from './helpers/extract-app-config';\n\nexport class MessagingService implements _FirebaseService {\n  readonly app!: FirebaseApp;\n  readonly firebaseDependencies!: FirebaseInternalDependencies;\n\n  swRegistration?: ServiceWorkerRegistration;\n  vapidKey?: string;\n  // logging is only done with end user consent. Default to false.\n  deliveryMetricsExportedToBigQueryEnabled: boolean = false;\n\n  onBackgroundMessageHandler:\n    | NextFn<MessagePayload>\n    | Observer<MessagePayload>\n    | null = null;\n\n  onMessageHandler: NextFn<MessagePayload> | Observer<MessagePayload> | null =\n    null;\n\n  logEvents: LogEvent[] = [];\n  isLogServiceStarted: boolean = false;\n\n  constructor(\n    app: FirebaseApp,\n    installations: _FirebaseInstallationsInternal,\n    analyticsProvider: Provider<FirebaseAnalyticsInternalName>\n  ) {\n    const appConfig = extractAppConfig(app);\n\n    this.firebaseDependencies = {\n      app,\n      appConfig,\n      installations,\n      analyticsProvider\n    };\n  }\n\n  _delete(): Promise<void> {\n    return Promise.resolve();\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 { DEFAULT_SW_PATH, DEFAULT_SW_SCOPE } from '../util/constants';\nimport { ERROR_FACTORY, ErrorCode } from '../util/errors';\n\nimport { MessagingService } from '../messaging-service';\n\nexport async function registerDefaultSw(\n  messaging: MessagingService\n): Promise<void> {\n  try {\n    messaging.swRegistration = await navigator.serviceWorker.register(\n      DEFAULT_SW_PATH,\n      {\n        scope: DEFAULT_SW_SCOPE\n      }\n    );\n\n    // The timing when browser updates sw when sw has an update is unreliable from experiment. It\n    // leads to version conflict when the SDK upgrades to a newer version in the main page, but sw\n    // is stuck with the old version. For example,\n    // https://github.com/firebase/firebase-js-sdk/issues/2590 The following line reliably updates\n    // sw if there was an update.\n    messaging.swRegistration.update().catch(() => {\n      /* it is non blocking and we don't care if it failed */\n    });\n  } catch (e) {\n    throw ERROR_FACTORY.create(ErrorCode.FAILED_DEFAULT_REGISTRATION, {\n      browserErrorMessage: (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 { ERROR_FACTORY, ErrorCode } from '../util/errors';\n\nimport { MessagingService } from '../messaging-service';\nimport { getTokenInternal } from '../internals/token-manager';\nimport { updateSwReg } from '../helpers/updateSwReg';\nimport { updateVapidKey } from '../helpers/updateVapidKey';\nimport { GetTokenOptions } from '../interfaces/public-types';\n\nexport async function getToken(\n  messaging: MessagingService,\n  options?: GetTokenOptions\n): Promise<string> {\n  if (!navigator) {\n    throw ERROR_FACTORY.create(ErrorCode.AVAILABLE_IN_WINDOW);\n  }\n\n  if (Notification.permission === 'default') {\n    await Notification.requestPermission();\n  }\n\n  if (Notification.permission !== 'granted') {\n    throw ERROR_FACTORY.create(ErrorCode.PERMISSION_BLOCKED);\n  }\n\n  await updateVapidKey(messaging, options?.vapidKey);\n  await updateSwReg(messaging, options?.serviceWorkerRegistration);\n\n  return getTokenInternal(messaging);\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 { DEFAULT_VAPID_KEY } from '../util/constants';\nimport { MessagingService } from '../messaging-service';\n\nexport async function updateVapidKey(\n  messaging: MessagingService,\n  vapidKey?: string | undefined\n): Promise<void> {\n  if (!!vapidKey) {\n    messaging.vapidKey = vapidKey;\n  } else if (!messaging.vapidKey) {\n    messaging.vapidKey = DEFAULT_VAPID_KEY;\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 { ERROR_FACTORY, ErrorCode } from '../util/errors';\n\nimport { MessagingService } from '../messaging-service';\nimport { registerDefaultSw } from './registerDefaultSw';\n\nexport async function updateSwReg(\n  messaging: MessagingService,\n  swRegistration?: ServiceWorkerRegistration | undefined\n): Promise<void> {\n  if (!swRegistration && !messaging.swRegistration) {\n    await registerDefaultSw(messaging);\n  }\n\n  if (!swRegistration && !!messaging.swRegistration) {\n    return;\n  }\n\n  if (!(swRegistration instanceof ServiceWorkerRegistration)) {\n    throw ERROR_FACTORY.create(ErrorCode.INVALID_SW_REGISTRATION);\n  }\n\n  messaging.swRegistration = swRegistration;\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  CONSOLE_CAMPAIGN_ID,\n  CONSOLE_CAMPAIGN_NAME,\n  CONSOLE_CAMPAIGN_TIME\n} from '../util/constants';\nimport {\n  ConsoleMessageData,\n  MessageType\n} from '../interfaces/internal-message-payload';\n\nimport { MessagingService } from '../messaging-service';\n\nexport async function logToScion(\n  messaging: MessagingService,\n  messageType: MessageType,\n  data: ConsoleMessageData\n): Promise<void> {\n  const eventType = getEventType(messageType);\n  const analytics =\n    await messaging.firebaseDependencies.analyticsProvider.get();\n  analytics.logEvent(eventType, {\n    /* eslint-disable camelcase */\n    message_id: data[CONSOLE_CAMPAIGN_ID],\n    message_name: data[CONSOLE_CAMPAIGN_NAME],\n    message_time: data[CONSOLE_CAMPAIGN_TIME],\n    message_device_time: Math.floor(Date.now() / 1000)\n    /* eslint-enable camelcase */\n  });\n}\n\nfunction getEventType(messageType: MessageType): string {\n  switch (messageType) {\n    case MessageType.NOTIFICATION_CLICKED:\n      return 'notification_open';\n    case MessageType.PUSH_RECEIVED:\n      return 'notification_foreground';\n    default:\n      throw new Error();\n  }\n}\n","/**\n * @license\n * Copyright 2017 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  MessagePayloadInternal,\n  MessageType\n} from '../interfaces/internal-message-payload';\n\nimport { CONSOLE_CAMPAIGN_ANALYTICS_ENABLED } from '../util/constants';\nimport { MessagingService } from '../messaging-service';\nimport { externalizePayload } from '../helpers/externalizePayload';\nimport { isConsoleMessage } from '../helpers/is-console-message';\nimport { logToScion } from '../helpers/logToScion';\n\nexport async function messageEventListener(\n  messaging: MessagingService,\n  event: MessageEvent\n): Promise<void> {\n  const internalPayload = event.data as MessagePayloadInternal;\n\n  if (!internalPayload.isFirebaseMessaging) {\n    return;\n  }\n\n  if (\n    messaging.onMessageHandler &&\n    internalPayload.messageType === MessageType.PUSH_RECEIVED\n  ) {\n    if (typeof messaging.onMessageHandler === 'function') {\n      messaging.onMessageHandler(externalizePayload(internalPayload));\n    } else {\n      messaging.onMessageHandler.next(externalizePayload(internalPayload));\n    }\n  }\n\n  // Log to Scion if applicable\n  const dataPayload = internalPayload.data;\n  if (\n    isConsoleMessage(dataPayload) &&\n    dataPayload[CONSOLE_CAMPAIGN_ANALYTICS_ENABLED] === '1'\n  ) {\n    await logToScion(messaging, internalPayload.messageType!, dataPayload);\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 { CONSOLE_CAMPAIGN_ID } from '../util/constants';\nimport { ConsoleMessageData } from '../interfaces/internal-message-payload';\n\nexport function isConsoleMessage(data: unknown): data is ConsoleMessageData {\n  // This message has a campaign ID, meaning it was sent using the Firebase Console.\n  return typeof data === 'object' && !!data && CONSOLE_CAMPAIGN_ID in data;\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  Component,\n  ComponentContainer,\n  ComponentType,\n  InstanceFactory\n} from '@firebase/component';\nimport {\n  onNotificationClick,\n  onPush,\n  onSubChange\n} from '../listeners/sw-listeners';\n\nimport { GetTokenOptions } from '../interfaces/public-types';\nimport { MessagingInternal } from '@firebase/messaging-interop-types';\nimport { MessagingService } from '../messaging-service';\nimport { ServiceWorkerGlobalScope } from '../util/sw-types';\nimport { _registerComponent, registerVersion } from '@firebase/app';\nimport { getToken } from '../api/getToken';\nimport { messageEventListener } from '../listeners/window-listener';\n\nimport { name, version } from '../../package.json';\n\nconst WindowMessagingFactory: InstanceFactory<'messaging'> = (\n  container: ComponentContainer\n) => {\n  const messaging = new MessagingService(\n    container.getProvider('app').getImmediate(),\n    container.getProvider('installations-internal').getImmediate(),\n    container.getProvider('analytics-internal')\n  );\n\n  navigator.serviceWorker.addEventListener('message', e =>\n    messageEventListener(messaging as MessagingService, e)\n  );\n\n  return messaging;\n};\n\nconst WindowMessagingInternalFactory: InstanceFactory<'messaging-internal'> = (\n  container: ComponentContainer\n) => {\n  const messaging = container\n    .getProvider('messaging')\n    .getImmediate() as MessagingService;\n\n  const messagingInternal: MessagingInternal = {\n    getToken: (options?: GetTokenOptions) => getToken(messaging, options)\n  };\n\n  return messagingInternal;\n};\n\ndeclare const self: ServiceWorkerGlobalScope;\nconst SwMessagingFactory: InstanceFactory<'messaging'> = (\n  container: ComponentContainer\n) => {\n  const messaging = new MessagingService(\n    container.getProvider('app').getImmediate(),\n    container.getProvider('installations-internal').getImmediate(),\n    container.getProvider('analytics-internal')\n  );\n\n  self.addEventListener('push', e => {\n    e.waitUntil(onPush(e, messaging as MessagingService));\n  });\n  self.addEventListener('pushsubscriptionchange', e => {\n    e.waitUntil(onSubChange(e, messaging as MessagingService));\n  });\n  self.addEventListener('notificationclick', e => {\n    e.waitUntil(onNotificationClick(e));\n  });\n\n  return messaging;\n};\n\nexport function registerMessagingInWindow(): void {\n  _registerComponent(\n    new Component('messaging', WindowMessagingFactory, ComponentType.PUBLIC)\n  );\n\n  _registerComponent(\n    new Component(\n      'messaging-internal',\n      WindowMessagingInternalFactory,\n      ComponentType.PRIVATE\n    )\n  );\n\n  registerVersion(name, version);\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/**\n * The messaging instance registered in sw is named differently than that of in client. This is\n * because both `registerMessagingInWindow` and `registerMessagingInSw` would be called in\n * `messaging-compat` and component with the same name can only be registered once.\n */\nexport function registerMessagingInSw(): void {\n  _registerComponent(\n    new Component('messaging-sw', SwMessagingFactory, ComponentType.PUBLIC)\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  areCookiesEnabled,\n  isIndexedDBAvailable,\n  validateIndexedDBOpenable\n} from '@firebase/util';\n\n/**\n * Checks if all required APIs exist in the browser.\n * @returns a Promise that resolves to a boolean.\n *\n * @public\n */\nexport async function isWindowSupported(): Promise<boolean> {\n  try {\n    // This throws if open() is unsupported, so adding it to the conditional\n    // statement below can cause an uncaught error.\n    await validateIndexedDBOpenable();\n  } catch (e) {\n    return false;\n  }\n  // firebase-js-sdk/issues/2393 reveals that idb#open in Safari iframe and Firefox private browsing\n  // might be prohibited to run. In these contexts, an error would be thrown during the messaging\n  // instantiating phase, informing the developers to import/call isSupported for special handling.\n  return (\n    typeof window !== 'undefined' &&\n    isIndexedDBAvailable() &&\n    areCookiesEnabled() &&\n    'serviceWorker' in navigator &&\n    'PushManager' in window &&\n    'Notification' in window &&\n    'fetch' in window &&\n    ServiceWorkerRegistration.prototype.hasOwnProperty('showNotification') &&\n    PushSubscription.prototype.hasOwnProperty('getKey')\n  );\n}\n\n/**\n * Checks whether all required APIs exist within SW Context\n * @returns a Promise that resolves to a boolean.\n *\n * @public\n */\nexport async function isSwSupported(): Promise<boolean> {\n  // firebase-js-sdk/issues/2393 reveals that idb#open in Safari iframe and Firefox private browsing\n  // might be prohibited to run. In these contexts, an error would be thrown during the messaging\n  // instantiating phase, informing the developers to import/call isSupported for special handling.\n  return (\n    isIndexedDBAvailable() &&\n    (await validateIndexedDBOpenable()) &&\n    'PushManager' in self &&\n    'Notification' in self &&\n    ServiceWorkerRegistration.prototype.hasOwnProperty('showNotification') &&\n    PushSubscription.prototype.hasOwnProperty('getKey')\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  FirebaseApp,\n  FirebaseOptions,\n  FirebaseAppSettings\n} from './public-types';\nimport { DEFAULT_ENTRY_NAME, PLATFORM_LOG_STRING } from './constants';\nimport { ERROR_FACTORY, AppError } from './errors';\nimport {\n  ComponentContainer,\n  Component,\n  Name,\n  ComponentType\n} from '@firebase/component';\nimport { version } from '../../firebase/package.json';\nimport { FirebaseAppImpl } from './firebaseApp';\nimport { _apps, _components, _registerComponent } from './internal';\nimport { logger } from './logger';\nimport {\n  LogLevelString,\n  setLogLevel as setLogLevelImpl,\n  LogCallback,\n  LogOptions,\n  setUserLogHandler\n} from '@firebase/logger';\nimport { deepEqual, getDefaultAppConfig } from '@firebase/util';\n\nexport { FirebaseError } from '@firebase/util';\n\n/**\n * The current SDK version.\n *\n * @public\n */\nexport const SDK_VERSION = version;\n\n/**\n * Creates and initializes a {@link @firebase/app#FirebaseApp} instance.\n *\n * See\n * {@link\n *   https://firebase.google.com/docs/web/setup#add_firebase_to_your_app\n *   | Add Firebase to your app} and\n * {@link\n *   https://firebase.google.com/docs/web/setup#multiple-projects\n *   | Initialize multiple projects} for detailed documentation.\n *\n * @example\n * ```javascript\n *\n * // Initialize default app\n * // Retrieve your own options values by adding a web app on\n * // https://console.firebase.google.com\n * initializeApp({\n *   apiKey: \"AIza....\",                             // Auth / General Use\n *   authDomain: \"YOUR_APP.firebaseapp.com\",         // Auth with popup/redirect\n *   databaseURL: \"https://YOUR_APP.firebaseio.com\", // Realtime Database\n *   storageBucket: \"YOUR_APP.appspot.com\",          // Storage\n *   messagingSenderId: \"123456789\"                  // Cloud Messaging\n * });\n * ```\n *\n * @example\n * ```javascript\n *\n * // Initialize another app\n * const otherApp = initializeApp({\n *   databaseURL: \"https://<OTHER_DATABASE_NAME>.firebaseio.com\",\n *   storageBucket: \"<OTHER_STORAGE_BUCKET>.appspot.com\"\n * }, \"otherApp\");\n * ```\n *\n * @param options - Options to configure the app's services.\n * @param name - Optional name of the app to initialize. If no name\n *   is provided, the default is `\"[DEFAULT]\"`.\n *\n * @returns The initialized app.\n *\n * @public\n */\nexport function initializeApp(\n  options: FirebaseOptions,\n  name?: string\n): FirebaseApp;\n/**\n * Creates and initializes a FirebaseApp instance.\n *\n * @param options - Options to configure the app's services.\n * @param config - FirebaseApp Configuration\n *\n * @public\n */\nexport function initializeApp(\n  options: FirebaseOptions,\n  config?: FirebaseAppSettings\n): FirebaseApp;\n/**\n * Creates and initializes a FirebaseApp instance.\n *\n * @public\n */\nexport function initializeApp(): FirebaseApp;\nexport function initializeApp(\n  _options?: FirebaseOptions,\n  rawConfig = {}\n): FirebaseApp {\n  let options = _options;\n\n  if (typeof rawConfig !== 'object') {\n    const name = rawConfig;\n    rawConfig = { name };\n  }\n\n  const config: Required<FirebaseAppSettings> = {\n    name: DEFAULT_ENTRY_NAME,\n    automaticDataCollectionEnabled: false,\n    ...rawConfig\n  };\n  const name = config.name;\n\n  if (typeof name !== 'string' || !name) {\n    throw ERROR_FACTORY.create(AppError.BAD_APP_NAME, {\n      appName: String(name)\n    });\n  }\n\n  options ||= getDefaultAppConfig();\n\n  if (!options) {\n    throw ERROR_FACTORY.create(AppError.NO_OPTIONS);\n  }\n\n  const existingApp = _apps.get(name) as FirebaseAppImpl;\n  if (existingApp) {\n    // return the existing app if options and config deep equal the ones in the existing app.\n    if (\n      deepEqual(options, existingApp.options) &&\n      deepEqual(config, existingApp.config)\n    ) {\n      return existingApp;\n    } else {\n      throw ERROR_FACTORY.create(AppError.DUPLICATE_APP, { appName: name });\n    }\n  }\n\n  const container = new ComponentContainer(name);\n  for (const component of _components.values()) {\n    container.addComponent(component);\n  }\n\n  const newApp = new FirebaseAppImpl(options, config, container);\n\n  _apps.set(name, newApp);\n\n  return newApp;\n}\n\n/**\n * Retrieves a {@link @firebase/app#FirebaseApp} instance.\n *\n * When called with no arguments, the default app is returned. When an app name\n * is provided, the app corresponding to that name is returned.\n *\n * An exception is thrown if the app being retrieved has not yet been\n * initialized.\n *\n * @example\n * ```javascript\n * // Return the default app\n * const app = getApp();\n * ```\n *\n * @example\n * ```javascript\n * // Return a named app\n * const otherApp = getApp(\"otherApp\");\n * ```\n *\n * @param name - Optional name of the app to return. If no name is\n *   provided, the default is `\"[DEFAULT]\"`.\n *\n * @returns The app corresponding to the provided app name.\n *   If no app name is provided, the default app is returned.\n *\n * @public\n */\nexport function getApp(name: string = DEFAULT_ENTRY_NAME): FirebaseApp {\n  const app = _apps.get(name);\n  if (!app && name === DEFAULT_ENTRY_NAME && getDefaultAppConfig()) {\n    return initializeApp();\n  }\n  if (!app) {\n    throw ERROR_FACTORY.create(AppError.NO_APP, { appName: name });\n  }\n\n  return app;\n}\n\n/**\n * A (read-only) array of all initialized apps.\n * @public\n */\nexport function getApps(): FirebaseApp[] {\n  return Array.from(_apps.values());\n}\n\n/**\n * Renders this app unusable and frees the resources of all associated\n * services.\n *\n * @example\n * ```javascript\n * deleteApp(app)\n *   .then(function() {\n *     console.log(\"App deleted successfully\");\n *   })\n *   .catch(function(error) {\n *     console.log(\"Error deleting app:\", error);\n *   });\n * ```\n *\n * @public\n */\nexport async function deleteApp(app: FirebaseApp): Promise<void> {\n  const name = app.name;\n  if (_apps.has(name)) {\n    _apps.delete(name);\n    await Promise.all(\n      (app as FirebaseAppImpl).container\n        .getProviders()\n        .map(provider => provider.delete())\n    );\n    (app as FirebaseAppImpl).isDeleted = true;\n  }\n}\n\n/**\n * Registers a library's name and version for platform logging purposes.\n * @param library - Name of 1p or 3p library (e.g. firestore, angularfire)\n * @param version - Current version of that library.\n * @param variant - Bundle variant, e.g., node, rn, etc.\n *\n * @public\n */\nexport function registerVersion(\n  libraryKeyOrName: string,\n  version: string,\n  variant?: string\n): void {\n  // TODO: We can use this check to whitelist strings when/if we set up\n  // a good whitelist system.\n  let library = PLATFORM_LOG_STRING[libraryKeyOrName] ?? libraryKeyOrName;\n  if (variant) {\n    library += `-${variant}`;\n  }\n  const libraryMismatch = library.match(/\\s|\\//);\n  const versionMismatch = version.match(/\\s|\\//);\n  if (libraryMismatch || versionMismatch) {\n    const warning = [\n      `Unable to register library \"${library}\" with version \"${version}\":`\n    ];\n    if (libraryMismatch) {\n      warning.push(\n        `library name \"${library}\" contains illegal characters (whitespace or \"/\")`\n      );\n    }\n    if (libraryMismatch && versionMismatch) {\n      warning.push('and');\n    }\n    if (versionMismatch) {\n      warning.push(\n        `version name \"${version}\" contains illegal characters (whitespace or \"/\")`\n      );\n    }\n    logger.warn(warning.join(' '));\n    return;\n  }\n  _registerComponent(\n    new Component(\n      `${library}-version` as Name,\n      () => ({ library, version }),\n      ComponentType.VERSION\n    )\n  );\n}\n\n/**\n * Sets log handler for all Firebase SDKs.\n * @param logCallback - An optional custom log handler that executes user code whenever\n * the Firebase SDK makes a logging call.\n *\n * @public\n */\nexport function onLog(\n  logCallback: LogCallback | null,\n  options?: LogOptions\n): void {\n  if (logCallback !== null && typeof logCallback !== 'function') {\n    throw ERROR_FACTORY.create(AppError.INVALID_LOG_ARGUMENT);\n  }\n  setUserLogHandler(logCallback, options);\n}\n\n/**\n * Sets log level for all Firebase SDKs.\n *\n * All of the log types above the current log level are captured (i.e. if\n * you set the log level to `info`, errors are logged, but `debug` and\n * `verbose` logs are not).\n *\n * @public\n */\nexport function setLogLevel(logLevel: LogLevelString): void {\n  setLogLevelImpl(logLevel);\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 { ERROR_FACTORY, ErrorCode } from '../util/errors';\n\nimport {\n  MessagePayload,\n  NextFn,\n  Observer,\n  Unsubscribe\n} from '../interfaces/public-types';\nimport { MessagingService } from '../messaging-service';\n\nexport function onMessage(\n  messaging: MessagingService,\n  nextOrObserver: NextFn<MessagePayload> | Observer<MessagePayload>\n): Unsubscribe {\n  if (!navigator) {\n    throw ERROR_FACTORY.create(ErrorCode.AVAILABLE_IN_WINDOW);\n  }\n\n  messaging.onMessageHandler = nextOrObserver;\n\n  return () => {\n    messaging.onMessageHandler = null;\n  };\n}\n","/**\n * @license\n * Copyright 2017 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 * @fileoverview Firebase constants.  Some of these (@defines) can be overridden at compile-time.\n */\n\nexport const CONSTANTS = {\n  /**\n   * @define {boolean} Whether this is the client Node.js SDK.\n   */\n  NODE_CLIENT: false,\n  /**\n   * @define {boolean} Whether this is the Admin Node.js SDK.\n   */\n  NODE_ADMIN: false,\n\n  /**\n   * Firebase SDK Version\n   */\n  SDK_VERSION: '${JSCORE_VERSION}'\n};\n","/**\n * @license\n * Copyright 2017 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\nconst stringToByteArray = function (str: string): number[] {\n  // TODO(user): Use native implementations if/when available\n  const out: number[] = [];\n  let p = 0;\n  for (let i = 0; i < str.length; i++) {\n    let c = str.charCodeAt(i);\n    if (c < 128) {\n      out[p++] = c;\n    } else if (c < 2048) {\n      out[p++] = (c >> 6) | 192;\n      out[p++] = (c & 63) | 128;\n    } else if (\n      (c & 0xfc00) === 0xd800 &&\n      i + 1 < str.length &&\n      (str.charCodeAt(i + 1) & 0xfc00) === 0xdc00\n    ) {\n      // Surrogate Pair\n      c = 0x10000 + ((c & 0x03ff) << 10) + (str.charCodeAt(++i) & 0x03ff);\n      out[p++] = (c >> 18) | 240;\n      out[p++] = ((c >> 12) & 63) | 128;\n      out[p++] = ((c >> 6) & 63) | 128;\n      out[p++] = (c & 63) | 128;\n    } else {\n      out[p++] = (c >> 12) | 224;\n      out[p++] = ((c >> 6) & 63) | 128;\n      out[p++] = (c & 63) | 128;\n    }\n  }\n  return out;\n};\n\n/**\n * Turns an array of numbers into the string given by the concatenation of the\n * characters to which the numbers correspond.\n * @param bytes Array of numbers representing characters.\n * @return Stringification of the array.\n */\nconst byteArrayToString = function (bytes: number[]): string {\n  // TODO(user): Use native implementations if/when available\n  const out: string[] = [];\n  let pos = 0,\n    c = 0;\n  while (pos < bytes.length) {\n    const c1 = bytes[pos++];\n    if (c1 < 128) {\n      out[c++] = String.fromCharCode(c1);\n    } else if (c1 > 191 && c1 < 224) {\n      const c2 = bytes[pos++];\n      out[c++] = String.fromCharCode(((c1 & 31) << 6) | (c2 & 63));\n    } else if (c1 > 239 && c1 < 365) {\n      // Surrogate Pair\n      const c2 = bytes[pos++];\n      const c3 = bytes[pos++];\n      const c4 = bytes[pos++];\n      const u =\n        (((c1 & 7) << 18) | ((c2 & 63) << 12) | ((c3 & 63) << 6) | (c4 & 63)) -\n        0x10000;\n      out[c++] = String.fromCharCode(0xd800 + (u >> 10));\n      out[c++] = String.fromCharCode(0xdc00 + (u & 1023));\n    } else {\n      const c2 = bytes[pos++];\n      const c3 = bytes[pos++];\n      out[c++] = String.fromCharCode(\n        ((c1 & 15) << 12) | ((c2 & 63) << 6) | (c3 & 63)\n      );\n    }\n  }\n  return out.join('');\n};\n\ninterface Base64 {\n  byteToCharMap_: { [key: number]: string } | null;\n  charToByteMap_: { [key: string]: number } | null;\n  byteToCharMapWebSafe_: { [key: number]: string } | null;\n  charToByteMapWebSafe_: { [key: string]: number } | null;\n  ENCODED_VALS_BASE: string;\n  readonly ENCODED_VALS: string;\n  readonly ENCODED_VALS_WEBSAFE: string;\n  HAS_NATIVE_SUPPORT: boolean;\n  encodeByteArray(input: number[] | Uint8Array, webSafe?: boolean): string;\n  encodeString(input: string, webSafe?: boolean): string;\n  decodeString(input: string, webSafe: boolean): string;\n  decodeStringToByteArray(input: string, webSafe: boolean): number[];\n  init_(): void;\n}\n\n// We define it as an object literal instead of a class because a class compiled down to es5 can't\n// be treeshaked. https://github.com/rollup/rollup/issues/1691\n// Static lookup maps, lazily populated by init_()\nexport const base64: Base64 = {\n  /**\n   * Maps bytes to characters.\n   */\n  byteToCharMap_: null,\n\n  /**\n   * Maps characters to bytes.\n   */\n  charToByteMap_: null,\n\n  /**\n   * Maps bytes to websafe characters.\n   * @private\n   */\n  byteToCharMapWebSafe_: null,\n\n  /**\n   * Maps websafe characters to bytes.\n   * @private\n   */\n  charToByteMapWebSafe_: null,\n\n  /**\n   * Our default alphabet, shared between\n   * ENCODED_VALS and ENCODED_VALS_WEBSAFE\n   */\n  ENCODED_VALS_BASE:\n    'ABCDEFGHIJKLMNOPQRSTUVWXYZ' + 'abcdefghijklmnopqrstuvwxyz' + '0123456789',\n\n  /**\n   * Our default alphabet. Value 64 (=) is special; it means \"nothing.\"\n   */\n  get ENCODED_VALS() {\n    return this.ENCODED_VALS_BASE + '+/=';\n  },\n\n  /**\n   * Our websafe alphabet.\n   */\n  get ENCODED_VALS_WEBSAFE() {\n    return this.ENCODED_VALS_BASE + '-_.';\n  },\n\n  /**\n   * Whether this browser supports the atob and btoa functions. This extension\n   * started at Mozilla but is now implemented by many browsers. We use the\n   * ASSUME_* variables to avoid pulling in the full useragent detection library\n   * but still allowing the standard per-browser compilations.\n   *\n   */\n  HAS_NATIVE_SUPPORT: typeof atob === 'function',\n\n  /**\n   * Base64-encode an array of bytes.\n   *\n   * @param input An array of bytes (numbers with\n   *     value in [0, 255]) to encode.\n   * @param webSafe Boolean indicating we should use the\n   *     alternative alphabet.\n   * @return The base64 encoded string.\n   */\n  encodeByteArray(input: number[] | Uint8Array, webSafe?: boolean): string {\n    if (!Array.isArray(input)) {\n      throw Error('encodeByteArray takes an array as a parameter');\n    }\n\n    this.init_();\n\n    const byteToCharMap = webSafe\n      ? this.byteToCharMapWebSafe_!\n      : this.byteToCharMap_!;\n\n    const output = [];\n\n    for (let i = 0; i < input.length; i += 3) {\n      const byte1 = input[i];\n      const haveByte2 = i + 1 < input.length;\n      const byte2 = haveByte2 ? input[i + 1] : 0;\n      const haveByte3 = i + 2 < input.length;\n      const byte3 = haveByte3 ? input[i + 2] : 0;\n\n      const outByte1 = byte1 >> 2;\n      const outByte2 = ((byte1 & 0x03) << 4) | (byte2 >> 4);\n      let outByte3 = ((byte2 & 0x0f) << 2) | (byte3 >> 6);\n      let outByte4 = byte3 & 0x3f;\n\n      if (!haveByte3) {\n        outByte4 = 64;\n\n        if (!haveByte2) {\n          outByte3 = 64;\n        }\n      }\n\n      output.push(\n        byteToCharMap[outByte1],\n        byteToCharMap[outByte2],\n        byteToCharMap[outByte3],\n        byteToCharMap[outByte4]\n      );\n    }\n\n    return output.join('');\n  },\n\n  /**\n   * Base64-encode a string.\n   *\n   * @param input A string to encode.\n   * @param webSafe If true, we should use the\n   *     alternative alphabet.\n   * @return The base64 encoded string.\n   */\n  encodeString(input: string, webSafe?: boolean): string {\n    // Shortcut for Mozilla browsers that implement\n    // a native base64 encoder in the form of \"btoa/atob\"\n    if (this.HAS_NATIVE_SUPPORT && !webSafe) {\n      return btoa(input);\n    }\n    return this.encodeByteArray(stringToByteArray(input), webSafe);\n  },\n\n  /**\n   * Base64-decode a string.\n   *\n   * @param input to decode.\n   * @param webSafe True if we should use the\n   *     alternative alphabet.\n   * @return string representing the decoded value.\n   */\n  decodeString(input: string, webSafe: boolean): string {\n    // Shortcut for Mozilla browsers that implement\n    // a native base64 encoder in the form of \"btoa/atob\"\n    if (this.HAS_NATIVE_SUPPORT && !webSafe) {\n      return atob(input);\n    }\n    return byteArrayToString(this.decodeStringToByteArray(input, webSafe));\n  },\n\n  /**\n   * Base64-decode a string.\n   *\n   * In base-64 decoding, groups of four characters are converted into three\n   * bytes.  If the encoder did not apply padding, the input length may not\n   * be a multiple of 4.\n   *\n   * In this case, the last group will have fewer than 4 characters, and\n   * padding will be inferred.  If the group has one or two characters, it decodes\n   * to one byte.  If the group has three characters, it decodes to two bytes.\n   *\n   * @param input Input to decode.\n   * @param webSafe True if we should use the web-safe alphabet.\n   * @return bytes representing the decoded value.\n   */\n  decodeStringToByteArray(input: string, webSafe: boolean): number[] {\n    this.init_();\n\n    const charToByteMap = webSafe\n      ? this.charToByteMapWebSafe_!\n      : this.charToByteMap_!;\n\n    const output: number[] = [];\n\n    for (let i = 0; i < input.length; ) {\n      const byte1 = charToByteMap[input.charAt(i++)];\n\n      const haveByte2 = i < input.length;\n      const byte2 = haveByte2 ? charToByteMap[input.charAt(i)] : 0;\n      ++i;\n\n      const haveByte3 = i < input.length;\n      const byte3 = haveByte3 ? charToByteMap[input.charAt(i)] : 64;\n      ++i;\n\n      const haveByte4 = i < input.length;\n      const byte4 = haveByte4 ? charToByteMap[input.charAt(i)] : 64;\n      ++i;\n\n      if (byte1 == null || byte2 == null || byte3 == null || byte4 == null) {\n        throw new DecodeBase64StringError();\n      }\n\n      const outByte1 = (byte1 << 2) | (byte2 >> 4);\n      output.push(outByte1);\n\n      if (byte3 !== 64) {\n        const outByte2 = ((byte2 << 4) & 0xf0) | (byte3 >> 2);\n        output.push(outByte2);\n\n        if (byte4 !== 64) {\n          const outByte3 = ((byte3 << 6) & 0xc0) | byte4;\n          output.push(outByte3);\n        }\n      }\n    }\n\n    return output;\n  },\n\n  /**\n   * Lazy static initialization function. Called before\n   * accessing any of the static map variables.\n   * @private\n   */\n  init_() {\n    if (!this.byteToCharMap_) {\n      this.byteToCharMap_ = {};\n      this.charToByteMap_ = {};\n      this.byteToCharMapWebSafe_ = {};\n      this.charToByteMapWebSafe_ = {};\n\n      // We want quick mappings back and forth, so we precompute two maps.\n      for (let i = 0; i < this.ENCODED_VALS.length; i++) {\n        this.byteToCharMap_[i] = this.ENCODED_VALS.charAt(i);\n        this.charToByteMap_[this.byteToCharMap_[i]] = i;\n        this.byteToCharMapWebSafe_[i] = this.ENCODED_VALS_WEBSAFE.charAt(i);\n        this.charToByteMapWebSafe_[this.byteToCharMapWebSafe_[i]] = i;\n\n        // Be forgiving when decoding and correctly decode both encodings.\n        if (i >= this.ENCODED_VALS_BASE.length) {\n          this.charToByteMap_[this.ENCODED_VALS_WEBSAFE.charAt(i)] = i;\n          this.charToByteMapWebSafe_[this.ENCODED_VALS.charAt(i)] = i;\n        }\n      }\n    }\n  }\n};\n\n/**\n * An error encountered while decoding base64 string.\n */\nexport class DecodeBase64StringError extends Error {\n  readonly name = 'DecodeBase64StringError';\n}\n\n/**\n * URL-safe base64 encoding\n */\nexport const base64Encode = function (str: string): string {\n  const utf8Bytes = stringToByteArray(str);\n  return base64.encodeByteArray(utf8Bytes, true);\n};\n\n/**\n * URL-safe base64 encoding (without \".\" padding in the end).\n * e.g. Used in JSON Web Token (JWT) parts.\n */\nexport const base64urlEncodeWithoutPadding = function (str: string): string {\n  // Use base64url encoding and remove padding in the end (dot characters).\n  return base64Encode(str).replace(/\\./g, '');\n};\n\n/**\n * URL-safe base64 decoding\n *\n * NOTE: DO NOT use the global atob() function - it does NOT support the\n * base64Url variant encoding.\n *\n * @param str To be decoded\n * @return Decoded result, if possible\n */\nexport const base64Decode = function (str: string): string | null {\n  try {\n    return base64.decodeString(str, true);\n  } catch (e) {\n    console.error('base64Decode failed: ', e);\n  }\n  return null;\n};\n","/**\n * @license\n * Copyright 2017 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 * Do a deep-copy of basic JavaScript Objects or Arrays.\n */\nexport function deepCopy<T>(value: T): T {\n  return deepExtend(undefined, value) as T;\n}\n\n/**\n * Copy properties from source to target (recursively allows extension\n * of Objects and Arrays).  Scalar values in the target are over-written.\n * If target is undefined, an object of the appropriate type will be created\n * (and returned).\n *\n * We recursively copy all child properties of plain Objects in the source- so\n * that namespace- like dictionaries are merged.\n *\n * Note that the target can be a function, in which case the properties in\n * the source Object are copied onto it as static properties of the Function.\n *\n * Note: we don't merge __proto__ to prevent prototype pollution\n */\nexport function deepExtend(target: unknown, source: unknown): unknown {\n  if (!(source instanceof Object)) {\n    return source;\n  }\n\n  switch (source.constructor) {\n    case Date:\n      // Treat Dates like scalars; if the target date object had any child\n      // properties - they will be lost!\n      const dateValue = source as Date;\n      return new Date(dateValue.getTime());\n\n    case Object:\n      if (target === undefined) {\n        target = {};\n      }\n      break;\n    case Array:\n      // Always copy the array source and overwrite the target.\n      target = [];\n      break;\n\n    default:\n      // Not a plain Object - treat it as a scalar.\n      return source;\n  }\n\n  for (const prop in source) {\n    // use isValidKey to guard against prototype pollution. See https://snyk.io/vuln/SNYK-JS-LODASH-450202\n    if (!source.hasOwnProperty(prop) || !isValidKey(prop)) {\n      continue;\n    }\n    (target as Record<string, unknown>)[prop] = deepExtend(\n      (target as Record<string, unknown>)[prop],\n      (source as Record<string, unknown>)[prop]\n    );\n  }\n\n  return target;\n}\n\nfunction isValidKey(key: string): boolean {\n  return key !== '__proto__';\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 { base64Decode } from './crypt';\nimport { getGlobal } from './global';\n\n/**\n * Keys for experimental properties on the `FirebaseDefaults` object.\n * @public\n */\nexport type ExperimentalKey = 'authTokenSyncURL' | 'authIdTokenMaxAge';\n\n/**\n * An object that can be injected into the environment as __FIREBASE_DEFAULTS__,\n * either as a property of globalThis, a shell environment variable, or a\n * cookie.\n *\n * This object can be used to automatically configure and initialize\n * a Firebase app as well as any emulators.\n *\n * @public\n */\nexport interface FirebaseDefaults {\n  config?: Record<string, string>;\n  emulatorHosts?: Record<string, string>;\n  _authTokenSyncURL?: string;\n  _authIdTokenMaxAge?: number;\n  /**\n   * Override Firebase's runtime environment detection and\n   * force the SDK to act as if it were in the specified environment.\n   */\n  forceEnvironment?: 'browser' | 'node';\n  [key: string]: unknown;\n}\n\ndeclare global {\n  // Need `var` for this to work.\n  // eslint-disable-next-line no-var\n  var __FIREBASE_DEFAULTS__: FirebaseDefaults | undefined;\n}\n\nconst getDefaultsFromGlobal = (): FirebaseDefaults | undefined =>\n  getGlobal().__FIREBASE_DEFAULTS__;\n\n/**\n * Attempt to read defaults from a JSON string provided to\n * process(.)env(.)__FIREBASE_DEFAULTS__ or a JSON file whose path is in\n * process(.)env(.)__FIREBASE_DEFAULTS_PATH__\n * The dots are in parens because certain compilers (Vite?) cannot\n * handle seeing that variable in comments.\n * See https://github.com/firebase/firebase-js-sdk/issues/6838\n */\nconst getDefaultsFromEnvVariable = (): FirebaseDefaults | undefined => {\n  if (typeof process === 'undefined' || typeof process.env === 'undefined') {\n    return;\n  }\n  const defaultsJsonString = process.env.__FIREBASE_DEFAULTS__;\n  if (defaultsJsonString) {\n    return JSON.parse(defaultsJsonString);\n  }\n};\n\nconst getDefaultsFromCookie = (): FirebaseDefaults | undefined => {\n  if (typeof document === 'undefined') {\n    return;\n  }\n  let match;\n  try {\n    match = document.cookie.match(/__FIREBASE_DEFAULTS__=([^;]+)/);\n  } catch (e) {\n    // Some environments such as Angular Universal SSR have a\n    // `document` object but error on accessing `document.cookie`.\n    return;\n  }\n  const decoded = match && base64Decode(match[1]);\n  return decoded && JSON.parse(decoded);\n};\n\n/**\n * Get the __FIREBASE_DEFAULTS__ object. It checks in order:\n * (1) if such an object exists as a property of `globalThis`\n * (2) if such an object was provided on a shell environment variable\n * (3) if such an object exists in a cookie\n * @public\n */\nexport const getDefaults = (): FirebaseDefaults | undefined => {\n  try {\n    return (\n      getDefaultsFromGlobal() ||\n      getDefaultsFromEnvVariable() ||\n      getDefaultsFromCookie()\n    );\n  } catch (e) {\n    /**\n     * Catch-all for being unable to get __FIREBASE_DEFAULTS__ due\n     * to any environment case we have not accounted for. Log to\n     * info instead of swallowing so we can find these unknown cases\n     * and add paths for them if needed.\n     */\n    console.info(`Unable to get __FIREBASE_DEFAULTS__ due to: ${e}`);\n    return;\n  }\n};\n\n/**\n * Returns emulator host stored in the __FIREBASE_DEFAULTS__ object\n * for the given product.\n * @returns a URL host formatted like `127.0.0.1:9999` or `[::1]:4000` if available\n * @public\n */\nexport const getDefaultEmulatorHost = (\n  productName: string\n): string | undefined => getDefaults()?.emulatorHosts?.[productName];\n\n/**\n * Returns emulator hostname and port stored in the __FIREBASE_DEFAULTS__ object\n * for the given product.\n * @returns a pair of hostname and port like `[\"::1\", 4000]` if available\n * @public\n */\nexport const getDefaultEmulatorHostnameAndPort = (\n  productName: string\n): [hostname: string, port: number] | undefined => {\n  const host = getDefaultEmulatorHost(productName);\n  if (!host) {\n    return undefined;\n  }\n  const separatorIndex = host.lastIndexOf(':'); // Finding the last since IPv6 addr also has colons.\n  if (separatorIndex <= 0 || separatorIndex + 1 === host.length) {\n    throw new Error(`Invalid host ${host} with no separate hostname and port!`);\n  }\n  // eslint-disable-next-line no-restricted-globals\n  const port = parseInt(host.substring(separatorIndex + 1), 10);\n  if (host[0] === '[') {\n    // Bracket-quoted `[ipv6addr]:port` => return \"ipv6addr\" (without brackets).\n    return [host.substring(1, separatorIndex - 1), port];\n  } else {\n    return [host.substring(0, separatorIndex), port];\n  }\n};\n\n/**\n * Returns Firebase app config stored in the __FIREBASE_DEFAULTS__ object.\n * @public\n */\nexport const getDefaultAppConfig = (): Record<string, string> | undefined =>\n  getDefaults()?.config;\n\n/**\n * Returns an experimental setting on the __FIREBASE_DEFAULTS__ object (properties\n * prefixed by \"_\")\n * @public\n */\nexport const getExperimentalSetting = <T extends ExperimentalKey>(\n  name: T\n): FirebaseDefaults[`_${T}`] =>\n  getDefaults()?.[`_${name}`] as FirebaseDefaults[`_${T}`];\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\n/**\n * Polyfill for `globalThis` object.\n * @returns the `globalThis` object for the given environment.\n * @public\n */\nexport function getGlobal(): typeof globalThis {\n  if (typeof self !== 'undefined') {\n    return self;\n  }\n  if (typeof window !== 'undefined') {\n    return window;\n  }\n  if (typeof global !== 'undefined') {\n    return global;\n  }\n  throw new Error('Unable to locate global object.');\n}\n","/**\n * @license\n * Copyright 2017 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 class Deferred<R> {\n  promise: Promise<R>;\n  reject: (value?: unknown) => void = () => {};\n  resolve: (value?: unknown) => void = () => {};\n  constructor() {\n    this.promise = new Promise((resolve, reject) => {\n      this.resolve = resolve as (value?: unknown) => void;\n      this.reject = reject as (value?: unknown) => void;\n    });\n  }\n\n  /**\n   * Our API internals are not promiseified and cannot because our callback APIs have subtle expectations around\n   * invoking promises inline, which Promises are forbidden to do. This method accepts an optional node-style callback\n   * and returns a node-style callback which will resolve or reject the Deferred's promise.\n   */\n  wrapCallback(\n    callback?: (error?: unknown, value?: unknown) => void\n  ): (error: unknown, value?: unknown) => void {\n    return (error, value?) => {\n      if (error) {\n        this.reject(error);\n      } else {\n        this.resolve(value);\n      }\n      if (typeof callback === 'function') {\n        // Attaching noop handler just in case developer wasn't expecting\n        // promises\n        this.promise.catch(() => {});\n\n        // Some of our callbacks don't expect a value and our own tests\n        // assert that the parameter length is 1\n        if (callback.length === 1) {\n          callback(error);\n        } else {\n          callback(error, value);\n        }\n      }\n    };\n  }\n}\n","/**\n * @license\n * Copyright 2017 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 { CONSTANTS } from './constants';\nimport { getDefaults } from './defaults';\n\n/**\n * Returns navigator.userAgent string or '' if it's not defined.\n * @return user agent string\n */\nexport function getUA(): string {\n  if (\n    typeof navigator !== 'undefined' &&\n    typeof navigator['userAgent'] === 'string'\n  ) {\n    return navigator['userAgent'];\n  } else {\n    return '';\n  }\n}\n\n/**\n * Detect Cordova / PhoneGap / Ionic frameworks on a mobile device.\n *\n * Deliberately does not rely on checking `file://` URLs (as this fails PhoneGap\n * in the Ripple emulator) nor Cordova `onDeviceReady`, which would normally\n * wait for a callback.\n */\nexport function isMobileCordova(): boolean {\n  return (\n    typeof window !== 'undefined' &&\n    // @ts-ignore Setting up an broadly applicable index signature for Window\n    // just to deal with this case would probably be a bad idea.\n    !!(window['cordova'] || window['phonegap'] || window['PhoneGap']) &&\n    /ios|iphone|ipod|ipad|android|blackberry|iemobile/i.test(getUA())\n  );\n}\n\n/**\n * Detect Node.js.\n *\n * @return true if Node.js environment is detected or specified.\n */\n// Node detection logic from: https://github.com/iliakan/detect-node/\nexport function isNode(): boolean {\n  const forceEnvironment = getDefaults()?.forceEnvironment;\n  if (forceEnvironment === 'node') {\n    return true;\n  } else if (forceEnvironment === 'browser') {\n    return false;\n  }\n\n  try {\n    return (\n      Object.prototype.toString.call(global.process) === '[object process]'\n    );\n  } catch (e) {\n    return false;\n  }\n}\n\n/**\n * Detect Browser Environment\n */\nexport function isBrowser(): boolean {\n  return typeof self === 'object' && self.self === self;\n}\n\n/**\n * Detect browser extensions (Chrome and Firefox at least).\n */\ninterface BrowserRuntime {\n  id?: unknown;\n}\ndeclare const chrome: { runtime?: BrowserRuntime };\ndeclare const browser: { runtime?: BrowserRuntime };\nexport function isBrowserExtension(): boolean {\n  const runtime =\n    typeof chrome === 'object'\n      ? chrome.runtime\n      : typeof browser === 'object'\n      ? browser.runtime\n      : undefined;\n  return typeof runtime === 'object' && runtime.id !== undefined;\n}\n\n/**\n * Detect React Native.\n *\n * @return true if ReactNative environment is detected.\n */\nexport function isReactNative(): boolean {\n  return (\n    typeof navigator === 'object' && navigator['product'] === 'ReactNative'\n  );\n}\n\n/** Detects Electron apps. */\nexport function isElectron(): boolean {\n  return getUA().indexOf('Electron/') >= 0;\n}\n\n/** Detects Internet Explorer. */\nexport function isIE(): boolean {\n  const ua = getUA();\n  return ua.indexOf('MSIE ') >= 0 || ua.indexOf('Trident/') >= 0;\n}\n\n/** Detects Universal Windows Platform apps. */\nexport function isUWP(): boolean {\n  return getUA().indexOf('MSAppHost/') >= 0;\n}\n\n/**\n * Detect whether the current SDK build is the Node version.\n *\n * @return true if it's the Node SDK build.\n */\nexport function isNodeSdk(): boolean {\n  return CONSTANTS.NODE_CLIENT === true || CONSTANTS.NODE_ADMIN === true;\n}\n\n/** Returns true if we are running in Safari. */\nexport function isSafari(): boolean {\n  return (\n    !isNode() &&\n    navigator.userAgent.includes('Safari') &&\n    !navigator.userAgent.includes('Chrome')\n  );\n}\n\n/**\n * This method checks if indexedDB is supported by current browser/service worker context\n * @return true if indexedDB is supported by current browser/service worker context\n */\nexport function isIndexedDBAvailable(): boolean {\n  try {\n    return typeof indexedDB === 'object';\n  } catch (e) {\n    return false;\n  }\n}\n\n/**\n * This method validates browser/sw context for indexedDB by opening a dummy indexedDB database and reject\n * if errors occur during the database open operation.\n *\n * @throws exception if current browser/sw context can't run idb.open (ex: Safari iframe, Firefox\n * private browsing)\n */\nexport function validateIndexedDBOpenable(): Promise<boolean> {\n  return new Promise((resolve, reject) => {\n    try {\n      let preExist: boolean = true;\n      const DB_CHECK_NAME =\n        'validate-browser-context-for-indexeddb-analytics-module';\n      const request = self.indexedDB.open(DB_CHECK_NAME);\n      request.onsuccess = () => {\n        request.result.close();\n        // delete database only when it doesn't pre-exist\n        if (!preExist) {\n          self.indexedDB.deleteDatabase(DB_CHECK_NAME);\n        }\n        resolve(true);\n      };\n      request.onupgradeneeded = () => {\n        preExist = false;\n      };\n\n      request.onerror = () => {\n        reject(request.error?.message || '');\n      };\n    } catch (error) {\n      reject(error);\n    }\n  });\n}\n\n/**\n *\n * This method checks whether cookie is enabled within current browser\n * @return true if cookie is enabled within current browser\n */\nexport function areCookiesEnabled(): boolean {\n  if (typeof navigator === 'undefined' || !navigator.cookieEnabled) {\n    return false;\n  }\n  return true;\n}\n","/**\n * @license\n * Copyright 2017 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 * @fileoverview Standardized Firebase Error.\n *\n * Usage:\n *\n *   // Typescript string literals for type-safe codes\n *   type Err =\n *     'unknown' |\n *     'object-not-found'\n *     ;\n *\n *   // Closure enum for type-safe error codes\n *   // at-enum {string}\n *   var Err = {\n *     UNKNOWN: 'unknown',\n *     OBJECT_NOT_FOUND: 'object-not-found',\n *   }\n *\n *   let errors: Map<Err, string> = {\n *     'generic-error': \"Unknown error\",\n *     'file-not-found': \"Could not find file: {$file}\",\n *   };\n *\n *   // Type-safe function - must pass a valid error code as param.\n *   let error = new ErrorFactory<Err>('service', 'Service', errors);\n *\n *   ...\n *   throw error.create(Err.GENERIC);\n *   ...\n *   throw error.create(Err.FILE_NOT_FOUND, {'file': fileName});\n *   ...\n *   // Service: Could not file file: foo.txt (service/file-not-found).\n *\n *   catch (e) {\n *     assert(e.message === \"Could not find file: foo.txt.\");\n *     if ((e as FirebaseError)?.code === 'service/file-not-found') {\n *       console.log(\"Could not read file: \" + e['file']);\n *     }\n *   }\n */\n\nexport type ErrorMap<ErrorCode extends string> = {\n  readonly [K in ErrorCode]: string;\n};\n\nconst ERROR_NAME = 'FirebaseError';\n\nexport interface StringLike {\n  toString(): string;\n}\n\nexport interface ErrorData {\n  [key: string]: unknown;\n}\n\n// Based on code from:\n// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error#Custom_Error_Types\nexport class FirebaseError extends Error {\n  /** The custom name for all FirebaseErrors. */\n  readonly name: string = ERROR_NAME;\n\n  constructor(\n    /** The error code for this error. */\n    readonly code: string,\n    message: string,\n    /** Custom data for this error. */\n    public customData?: Record<string, unknown>\n  ) {\n    super(message);\n\n    // Fix For ES5\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, FirebaseError.prototype);\n\n    // Maintains proper stack trace for where our error was thrown.\n    // Only available on V8.\n    if (Error.captureStackTrace) {\n      Error.captureStackTrace(this, ErrorFactory.prototype.create);\n    }\n  }\n}\n\nexport class ErrorFactory<\n  ErrorCode extends string,\n  ErrorParams extends { readonly [K in ErrorCode]?: ErrorData } = {}\n> {\n  constructor(\n    private readonly service: string,\n    private readonly serviceName: string,\n    private readonly errors: ErrorMap<ErrorCode>\n  ) {}\n\n  create<K extends ErrorCode>(\n    code: K,\n    ...data: K extends keyof ErrorParams ? [ErrorParams[K]] : []\n  ): FirebaseError {\n    const customData = (data[0] as ErrorData) || {};\n    const fullCode = `${this.service}/${code}`;\n    const template = this.errors[code];\n\n    const message = template ? replaceTemplate(template, customData) : 'Error';\n    // Service Name: Error message (service/code).\n    const fullMessage = `${this.serviceName}: ${message} (${fullCode}).`;\n\n    const error = new FirebaseError(fullCode, fullMessage, customData);\n\n    return error;\n  }\n}\n\nfunction replaceTemplate(template: string, data: ErrorData): string {\n  return template.replace(PATTERN, (_, key) => {\n    const value = data[key];\n    return value != null ? String(value) : `<${key}?>`;\n  });\n}\n\nconst PATTERN = /\\{\\$([^}]+)}/g;\n","/**\n * @license\n * Copyright 2017 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 contains<T extends object>(obj: T, key: string): boolean {\n  return Object.prototype.hasOwnProperty.call(obj, key);\n}\n\nexport function safeGet<T extends object, K extends keyof T>(\n  obj: T,\n  key: K\n): T[K] | undefined {\n  if (Object.prototype.hasOwnProperty.call(obj, key)) {\n    return obj[key];\n  } else {\n    return undefined;\n  }\n}\n\nexport function isEmpty(obj: object): obj is {} {\n  for (const key in obj) {\n    if (Object.prototype.hasOwnProperty.call(obj, key)) {\n      return false;\n    }\n  }\n  return true;\n}\n\nexport function map<K extends string, V, U>(\n  obj: { [key in K]: V },\n  fn: (value: V, key: K, obj: { [key in K]: V }) => U,\n  contextObj?: unknown\n): { [key in K]: U } {\n  const res: Partial<{ [key in K]: U }> = {};\n  for (const key in obj) {\n    if (Object.prototype.hasOwnProperty.call(obj, key)) {\n      res[key] = fn.call(contextObj, obj[key], key, obj);\n    }\n  }\n  return res as { [key in K]: U };\n}\n\n/**\n * Deep equal two objects. Support Arrays and Objects.\n */\nexport function deepEqual(a: object, b: object): boolean {\n  if (a === b) {\n    return true;\n  }\n\n  const aKeys = Object.keys(a);\n  const bKeys = Object.keys(b);\n  for (const k of aKeys) {\n    if (!bKeys.includes(k)) {\n      return false;\n    }\n\n    const aProp = (a as Record<string, unknown>)[k];\n    const bProp = (b as Record<string, unknown>)[k];\n    if (isObject(aProp) && isObject(bProp)) {\n      if (!deepEqual(aProp, bProp)) {\n        return false;\n      }\n    } else if (aProp !== bProp) {\n      return false;\n    }\n  }\n\n  for (const k of bKeys) {\n    if (!aKeys.includes(k)) {\n      return false;\n    }\n  }\n  return true;\n}\n\nfunction isObject(thing: unknown): thing is object {\n  return thing !== null && typeof thing === 'object';\n}\n","/**\n * @license\n * Copyright 2017 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 * Returns a querystring-formatted string (e.g. &arg=val&arg2=val2) from a\n * params object (e.g. {arg: 'val', arg2: 'val2'})\n * Note: You must prepend it with ? when adding it to a URL.\n */\nexport function querystring(querystringParams: {\n  [key: string]: string | number;\n}): string {\n  const params = [];\n  for (const [key, value] of Object.entries(querystringParams)) {\n    if (Array.isArray(value)) {\n      value.forEach(arrayVal => {\n        params.push(\n          encodeURIComponent(key) + '=' + encodeURIComponent(arrayVal)\n        );\n      });\n    } else {\n      params.push(encodeURIComponent(key) + '=' + encodeURIComponent(value));\n    }\n  }\n  return params.length ? '&' + params.join('&') : '';\n}\n\n/**\n * Decodes a querystring (e.g. ?arg=val&arg2=val2) into a params object\n * (e.g. {arg: 'val', arg2: 'val2'})\n */\nexport function querystringDecode(querystring: string): Record<string, string> {\n  const obj: Record<string, string> = {};\n  const tokens = querystring.replace(/^\\?/, '').split('&');\n\n  tokens.forEach(token => {\n    if (token) {\n      const [key, value] = token.split('=');\n      obj[decodeURIComponent(key)] = decodeURIComponent(value);\n    }\n  });\n  return obj;\n}\n\n/**\n * Extract the query string part of a URL, including the leading question mark (if present).\n */\nexport function extractQuerystring(url: string): string {\n  const queryStart = url.indexOf('?');\n  if (!queryStart) {\n    return '';\n  }\n  const fragmentStart = url.indexOf('#', queryStart);\n  return url.substring(\n    queryStart,\n    fragmentStart > 0 ? fragmentStart : undefined\n  );\n}\n","/**\n * @license\n * Copyright 2017 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 */\nexport type NextFn<T> = (value: T) => void;\nexport type ErrorFn = (error: Error) => void;\nexport type CompleteFn = () => void;\n\nexport interface Observer<T> {\n  // Called once for each value in a stream of values.\n  next: NextFn<T>;\n\n  // A stream terminates by a single call to EITHER error() or complete().\n  error: ErrorFn;\n\n  // No events will be sent to next() once complete() is called.\n  complete: CompleteFn;\n}\n\nexport type PartialObserver<T> = Partial<Observer<T>>;\n\n// TODO: Support also Unsubscribe.unsubscribe?\nexport type Unsubscribe = () => void;\n\n/**\n * The Subscribe interface has two forms - passing the inline function\n * callbacks, or a object interface with callback properties.\n */\nexport interface Subscribe<T> {\n  (next?: NextFn<T>, error?: ErrorFn, complete?: CompleteFn): Unsubscribe;\n  (observer: PartialObserver<T>): Unsubscribe;\n}\n\nexport interface Observable<T> {\n  // Subscribe method\n  subscribe: Subscribe<T>;\n}\n\nexport type Executor<T> = (observer: Observer<T>) => void;\n\n/**\n * Helper to make a Subscribe function (just like Promise helps make a\n * Thenable).\n *\n * @param executor Function which can make calls to a single Observer\n *     as a proxy.\n * @param onNoObservers Callback when count of Observers goes to zero.\n */\nexport function createSubscribe<T>(\n  executor: Executor<T>,\n  onNoObservers?: Executor<T>\n): Subscribe<T> {\n  const proxy = new ObserverProxy<T>(executor, onNoObservers);\n  return proxy.subscribe.bind(proxy);\n}\n\n/**\n * Implement fan-out for any number of Observers attached via a subscribe\n * function.\n */\nclass ObserverProxy<T> implements Observer<T> {\n  private observers: Array<Observer<T>> | undefined = [];\n  private unsubscribes: Unsubscribe[] = [];\n  private onNoObservers: Executor<T> | undefined;\n  private observerCount = 0;\n  // Micro-task scheduling by calling task.then().\n  private task = Promise.resolve();\n  private finalized = false;\n  private finalError?: Error;\n\n  /**\n   * @param executor Function which can make calls to a single Observer\n   *     as a proxy.\n   * @param onNoObservers Callback when count of Observers goes to zero.\n   */\n  constructor(executor: Executor<T>, onNoObservers?: Executor<T>) {\n    this.onNoObservers = onNoObservers;\n    // Call the executor asynchronously so subscribers that are called\n    // synchronously after the creation of the subscribe function\n    // can still receive the very first value generated in the executor.\n    this.task\n      .then(() => {\n        executor(this);\n      })\n      .catch(e => {\n        this.error(e);\n      });\n  }\n\n  next(value: T): void {\n    this.forEachObserver((observer: Observer<T>) => {\n      observer.next(value);\n    });\n  }\n\n  error(error: Error): void {\n    this.forEachObserver((observer: Observer<T>) => {\n      observer.error(error);\n    });\n    this.close(error);\n  }\n\n  complete(): void {\n    this.forEachObserver((observer: Observer<T>) => {\n      observer.complete();\n    });\n    this.close();\n  }\n\n  /**\n   * Subscribe function that can be used to add an Observer to the fan-out list.\n   *\n   * - We require that no event is sent to a subscriber sychronously to their\n   *   call to subscribe().\n   */\n  subscribe(\n    nextOrObserver?: NextFn<T> | PartialObserver<T>,\n    error?: ErrorFn,\n    complete?: CompleteFn\n  ): Unsubscribe {\n    let observer: Observer<T>;\n\n    if (\n      nextOrObserver === undefined &&\n      error === undefined &&\n      complete === undefined\n    ) {\n      throw new Error('Missing Observer.');\n    }\n\n    // Assemble an Observer object when passed as callback functions.\n    if (\n      implementsAnyMethods(nextOrObserver as { [key: string]: unknown }, [\n        'next',\n        'error',\n        'complete'\n      ])\n    ) {\n      observer = nextOrObserver as Observer<T>;\n    } else {\n      observer = {\n        next: nextOrObserver as NextFn<T>,\n        error,\n        complete\n      } as Observer<T>;\n    }\n\n    if (observer.next === undefined) {\n      observer.next = noop as NextFn<T>;\n    }\n    if (observer.error === undefined) {\n      observer.error = noop as ErrorFn;\n    }\n    if (observer.complete === undefined) {\n      observer.complete = noop as CompleteFn;\n    }\n\n    const unsub = this.unsubscribeOne.bind(this, this.observers!.length);\n\n    // Attempt to subscribe to a terminated Observable - we\n    // just respond to the Observer with the final error or complete\n    // event.\n    if (this.finalized) {\n      // eslint-disable-next-line @typescript-eslint/no-floating-promises\n      this.task.then(() => {\n        try {\n          if (this.finalError) {\n            observer.error(this.finalError);\n          } else {\n            observer.complete();\n          }\n        } catch (e) {\n          // nothing\n        }\n        return;\n      });\n    }\n\n    this.observers!.push(observer as Observer<T>);\n\n    return unsub;\n  }\n\n  // Unsubscribe is synchronous - we guarantee that no events are sent to\n  // any unsubscribed Observer.\n  private unsubscribeOne(i: number): void {\n    if (this.observers === undefined || this.observers[i] === undefined) {\n      return;\n    }\n\n    delete this.observers[i];\n\n    this.observerCount -= 1;\n    if (this.observerCount === 0 && this.onNoObservers !== undefined) {\n      this.onNoObservers(this);\n    }\n  }\n\n  private forEachObserver(fn: (observer: Observer<T>) => void): void {\n    if (this.finalized) {\n      // Already closed by previous event....just eat the additional values.\n      return;\n    }\n\n    // Since sendOne calls asynchronously - there is no chance that\n    // this.observers will become undefined.\n    for (let i = 0; i < this.observers!.length; i++) {\n      this.sendOne(i, fn);\n    }\n  }\n\n  // Call the Observer via one of it's callback function. We are careful to\n  // confirm that the observe has not been unsubscribed since this asynchronous\n  // function had been queued.\n  private sendOne(i: number, fn: (observer: Observer<T>) => void): void {\n    // Execute the callback asynchronously\n    // eslint-disable-next-line @typescript-eslint/no-floating-promises\n    this.task.then(() => {\n      if (this.observers !== undefined && this.observers[i] !== undefined) {\n        try {\n          fn(this.observers[i]);\n        } catch (e) {\n          // Ignore exceptions raised in Observers or missing methods of an\n          // Observer.\n          // Log error to console. b/31404806\n          if (typeof console !== 'undefined' && console.error) {\n            console.error(e);\n          }\n        }\n      }\n    });\n  }\n\n  private close(err?: Error): void {\n    if (this.finalized) {\n      return;\n    }\n    this.finalized = true;\n    if (err !== undefined) {\n      this.finalError = err;\n    }\n    // Proxy is no longer needed - garbage collect references\n    // eslint-disable-next-line @typescript-eslint/no-floating-promises\n    this.task.then(() => {\n      this.observers = undefined;\n      this.onNoObservers = undefined;\n    });\n  }\n}\n\n/** Turn synchronous function into one called asynchronously. */\n// eslint-disable-next-line @typescript-eslint/ban-types\nexport function async(fn: Function, onError?: ErrorFn): Function {\n  return (...args: unknown[]) => {\n    Promise.resolve(true)\n      .then(() => {\n        fn(...args);\n      })\n      .catch((error: Error) => {\n        if (onError) {\n          onError(error);\n        }\n      });\n  };\n}\n\n/**\n * Return true if the object passed in implements any of the named methods.\n */\nfunction implementsAnyMethods(\n  obj: { [key: string]: unknown },\n  methods: string[]\n): boolean {\n  if (typeof obj !== 'object' || obj === null) {\n    return false;\n  }\n\n  for (const method of methods) {\n    if (method in obj && typeof obj[method] === 'function') {\n      return true;\n    }\n  }\n\n  return false;\n}\n\nfunction noop(): void {\n  // do nothing\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\nexport interface Compat<T> {\n  _delegate: T;\n}\n\nexport function getModularInstance<ExpService>(\n  service: Compat<ExpService> | ExpService\n): ExpService {\n  if (service && (service as Compat<ExpService>)._delegate) {\n    return (service as Compat<ExpService>)._delegate;\n  } else {\n    return service as ExpService;\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\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  TOTP: 'totp'\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_PASSWORD = 'missing-password',\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  RECAPTCHA_NOT_ENABLED = 'recaptcha-not-enabled',\n  MISSING_RECAPTCHA_TOKEN = 'missing-recaptcha-token',\n  INVALID_RECAPTCHA_TOKEN = 'invalid-recaptcha-token',\n  INVALID_RECAPTCHA_ACTION = 'invalid-recaptcha-action',\n  MISSING_CLIENT_TYPE = 'missing-client-type',\n  MISSING_RECAPTCHA_VERSION = 'missing-recaptcha-version',\n  INVALID_RECAPTCHA_VERSION = 'invalid-recaptcha-version',\n  INVALID_REQ_TYPE = 'invalid-req-type'\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]:\n      '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_PASSWORD]: 'A non-empty password must be provided',\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    [AuthErrorCode.MISSING_RECAPTCHA_TOKEN]:\n      'The reCAPTCHA token is missing when sending request to the backend.',\n    [AuthErrorCode.INVALID_RECAPTCHA_TOKEN]:\n      'The reCAPTCHA token is invalid when sending request to the backend.',\n    [AuthErrorCode.INVALID_RECAPTCHA_ACTION]:\n      'The reCAPTCHA action is invalid when sending request to the backend.',\n    [AuthErrorCode.RECAPTCHA_NOT_ENABLED]:\n      'reCAPTCHA Enterprise integration is not enabled for this project.',\n    [AuthErrorCode.MISSING_CLIENT_TYPE]:\n      'The reCAPTCHA client type is missing when sending request to the backend.',\n    [AuthErrorCode.MISSING_RECAPTCHA_VERSION]:\n      'The reCAPTCHA version is missing when sending request to the backend.',\n    [AuthErrorCode.INVALID_REQ_TYPE]: 'Invalid request parameters.',\n    [AuthErrorCode.INVALID_RECAPTCHA_VERSION]:\n      'The reCAPTCHA version is invalid when sending request to the backend.'\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]: {\n    appName?: AppName;\n    originalMessage?: string;\n  };\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  RECAPTCHA_NOT_ENABLED: 'auth/recaptcha-not-enabled',\n  MISSING_RECAPTCHA_TOKEN: 'auth/missing-recaptcha-token',\n  INVALID_RECAPTCHA_TOKEN: 'auth/invalid-recaptcha-token',\n  INVALID_RECAPTCHA_ACTION: 'auth/invalid-recaptcha-action',\n  MISSING_CLIENT_TYPE: 'auth/missing-client-type',\n  MISSING_RECAPTCHA_VERSION: 'auth/missing-recaptcha-version',\n  INVALID_RECAPTCHA_VERSION: 'auth/invalid-recaptcha-version',\n  INVALID_REQ_TYPE: 'auth/invalid-req-type'\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 _logWarn(msg: string, ...args: string[]): void {\n  if (logClient.logLevel <= LogLevel.WARN) {\n    logClient.warn(`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(\n  auth: Auth,\n  code: AuthErrorCode,\n  message: string\n): FirebaseError {\n  const errorMap = {\n    ...(prodErrorMap as ErrorMapRetriever)(),\n    [code]: message\n  };\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(\n  auth: Auth,\n  object: object,\n  instance: unknown\n): 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(\n      auth,\n      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}\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 * @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 { 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 { 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 { 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  RECAPTCHA_NOT_ENABLED = 'RECAPTCHA_NOT_ENABLED',\n  MISSING_RECAPTCHA_TOKEN = 'MISSING_RECAPTCHA_TOKEN',\n  INVALID_RECAPTCHA_TOKEN = 'INVALID_RECAPTCHA_TOKEN',\n  INVALID_RECAPTCHA_ACTION = 'INVALID_RECAPTCHA_ACTION',\n  MISSING_CLIENT_TYPE = 'MISSING_CLIENT_TYPE',\n  MISSING_RECAPTCHA_VERSION = 'MISSING_RECAPTCHA_VERSION',\n  INVALID_RECAPTCHA_VERSION = 'INVALID_RECAPTCHA_VERSION',\n  INVALID_REQ_TYPE = 'INVALID_REQ_TYPE'\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.MISSING_PASSWORD,\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  // Recaptcha related errors.\n  [ServerError.RECAPTCHA_NOT_ENABLED]: AuthErrorCode.RECAPTCHA_NOT_ENABLED,\n  [ServerError.MISSING_RECAPTCHA_TOKEN]: AuthErrorCode.MISSING_RECAPTCHA_TOKEN,\n  [ServerError.INVALID_RECAPTCHA_TOKEN]: AuthErrorCode.INVALID_RECAPTCHA_TOKEN,\n  [ServerError.INVALID_RECAPTCHA_ACTION]:\n    AuthErrorCode.INVALID_RECAPTCHA_ACTION,\n  [ServerError.MISSING_CLIENT_TYPE]: AuthErrorCode.MISSING_CLIENT_TYPE,\n  [ServerError.MISSING_RECAPTCHA_VERSION]:\n    AuthErrorCode.MISSING_RECAPTCHA_VERSION,\n  [ServerError.INVALID_RECAPTCHA_VERSION]:\n    AuthErrorCode.INVALID_RECAPTCHA_VERSION,\n  [ServerError.INVALID_REQ_TYPE]: AuthErrorCode.INVALID_REQ_TYPE\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 {\n  _createError,\n  _errorWithCustomMessage,\n  _fail\n} 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  X_FIREBASE_APP_CHECK = 'X-Firebase-AppCheck'\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_MFA_ENROLLMENT = '/v2/accounts/mfaEnrollment:start',\n  FINALIZE_MFA_ENROLLMENT = '/v2/accounts/mfaEnrollment:finalize',\n  START_MFA_SIGN_IN = '/v2/accounts/mfaSignIn:start',\n  FINALIZE_MFA_SIGN_IN = '/v2/accounts/mfaSignIn:finalize',\n  WITHDRAW_MFA = '/v2/accounts/mfaEnrollment:withdraw',\n  GET_PROJECT_CONFIG = '/v1/projects',\n  GET_RECAPTCHA_CONFIG = '/v2/recaptchaConfig'\n}\n\nexport const enum RecaptchaClientType {\n  WEB = 'CLIENT_TYPE_WEB',\n  ANDROID = 'CLIENT_TYPE_ANDROID',\n  IOS = 'CLIENT_TYPE_IOS'\n}\n\nexport const enum RecaptchaVersion {\n  ENTERPRISE = 'RECAPTCHA_ENTERPRISE'\n}\n\nexport const enum RecaptchaActionName {\n  SIGN_IN_WITH_PASSWORD = 'signInWithPassword',\n  GET_OOB_CODE = 'getOobCode',\n  SIGN_UP_PASSWORD = 'signUpPassword'\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    // Changing this to a different error code will log user out when there is a network error\n    // because we treat any error other than NETWORK_REQUEST_FAILED as token is invalid.\n    // https://github.com/firebase/firebase-js-sdk/blob/4fbc73610d70be4e0852e7de63a39cb7897e8546/packages/auth/src/core/auth/auth_impl.ts#L309-L316\n    _fail(auth, AuthErrorCode.NETWORK_REQUEST_FAILED, { 'message': String(e) });\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(\n        _createError(this.auth, AuthErrorCode.NETWORK_REQUEST_FAILED)\n      );\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\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 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 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(\n      'Caught error parsing JWT payload as JSON',\n      (e as Error)?.toString()\n    );\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 { FirebaseError } from '@firebase/util';\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 (\n        (e as FirebaseError)?.code ===\n        `auth/${AuthErrorCode.NETWORK_REQUEST_FAILED}`\n      ) {\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\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\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\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 =\n    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 { 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    const newUser = new UserImpl({\n      ...this,\n      auth,\n      stsTokenManager: this.stsTokenManager._clone()\n    });\n    newUser.metadata._copy(this.metadata);\n    return newUser;\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 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 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 (\n    /iphone|ipad|ipod/i.test(ua) ||\n    (/macintosh/i.test(ua) && /mobile/i.test(ua))\n  );\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 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  RecaptchaClientType,\n  RecaptchaVersion,\n  _performApiRequest,\n  _addTidIfNecessary\n} 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// The following functions are for reCAPTCHA enterprise integration.\ninterface GetRecaptchaConfigRequest {\n  tenantId?: string;\n  clientType?: RecaptchaClientType;\n  version?: RecaptchaVersion;\n}\n\ninterface RecaptchaEnforcementState {\n  provider: string;\n  enforcementState: string;\n}\n\nexport interface GetRecaptchaConfigResponse {\n  recaptchaKey: string;\n  recaptchaEnforcementState: RecaptchaEnforcementState[];\n}\n\nexport async function getRecaptchaConfig(\n  auth: Auth,\n  request: GetRecaptchaConfigRequest\n): Promise<GetRecaptchaConfigResponse> {\n  return _performApiRequest<\n    GetRecaptchaConfigRequest,\n    GetRecaptchaConfigResponse\n  >(\n    auth,\n    HttpMethod.GET,\n    Endpoint.GET_RECAPTCHA_CONFIG,\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 { RecaptchaParameters } from '../../model/public_types';\nimport { GetRecaptchaConfigResponse } from '../../api/authentication/recaptcha';\n\n// reCAPTCHA v2 interface\nexport interface Recaptcha {\n  render: (container: HTMLElement, parameters: RecaptchaParameters) => number;\n  getResponse: (id: number) => string;\n  execute: (id: number) => unknown;\n  reset: (id: number) => unknown;\n}\n\nexport function isV2(\n  grecaptcha: Recaptcha | GreCAPTCHA | undefined\n): grecaptcha is Recaptcha {\n  return (\n    grecaptcha !== undefined &&\n    (grecaptcha as Recaptcha).getResponse !== undefined\n  );\n}\n\n// reCAPTCHA Enterprise & v3 shared interface\nexport interface GreCAPTCHATopLevel extends GreCAPTCHA {\n  enterprise: GreCAPTCHA;\n}\n\n// reCAPTCHA Enterprise interface\nexport interface GreCAPTCHA {\n  ready: (callback: () => void) => void;\n  execute: (siteKey: string, options: { action: string }) => Promise<string>;\n  render: (\n    container: string | HTMLElement,\n    parameters: GreCAPTCHARenderOption\n  ) => string;\n}\n\nexport interface GreCAPTCHARenderOption {\n  sitekey: string;\n  size: 'invisible';\n}\n\nexport function isEnterprise(\n  grecaptcha: Recaptcha | GreCAPTCHA | undefined\n): grecaptcha is GreCAPTCHATopLevel {\n  return (\n    grecaptcha !== undefined &&\n    (grecaptcha as GreCAPTCHATopLevel).enterprise !== undefined\n  );\n}\n\n// TODO(chuanr): Replace this with the AuthWindow after resolving the dependency issue in Node.js env.\ndeclare global {\n  interface Window {\n    grecaptcha?: Recaptcha | GreCAPTCHATopLevel;\n  }\n}\n\nexport class RecaptchaConfig {\n  /**\n   * The reCAPTCHA site key.\n   */\n  siteKey: string = '';\n\n  /**\n   * The reCAPTCHA enablement status of the {@link EmailAuthProvider} for the current tenant.\n   */\n  emailPasswordEnabled: boolean = false;\n\n  constructor(response: GetRecaptchaConfigResponse) {\n    if (response.recaptchaKey === undefined) {\n      throw new Error('recaptchaKey undefined');\n    }\n    // Example response.recaptchaKey: \"projects/proj123/keys/sitekey123\"\n    this.siteKey = response.recaptchaKey.split('/')[3];\n    this.emailPasswordEnabled = response.recaptchaEnforcementState.some(\n      enforcementState =>\n        enforcementState.provider === 'EMAIL_PASSWORD_PROVIDER' &&\n        enforcementState.enforcementState !== 'OFF'\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';\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","/* eslint-disable @typescript-eslint/no-require-imports */\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 { isEnterprise, RecaptchaConfig } from './recaptcha';\nimport { getRecaptchaConfig } from '../../api/authentication/recaptcha';\nimport {\n  RecaptchaClientType,\n  RecaptchaVersion,\n  RecaptchaActionName\n} from '../../api';\n\nimport { Auth } from '../../model/public_types';\nimport { AuthInternal } from '../../model/auth';\nimport { _castAuth } from '../../core/auth/auth_impl';\nimport * as jsHelpers from '../load_js';\n\nconst RECAPTCHA_ENTERPRISE_URL =\n  'https://www.google.com/recaptcha/enterprise.js?render=';\n\nexport const RECAPTCHA_ENTERPRISE_VERIFIER_TYPE = 'recaptcha-enterprise';\nexport const FAKE_TOKEN = 'NO_RECAPTCHA';\n\nexport class RecaptchaEnterpriseVerifier {\n  /**\n   * Identifies the type of application verifier (e.g. \"recaptcha-enterprise\").\n   */\n  readonly type = RECAPTCHA_ENTERPRISE_VERIFIER_TYPE;\n\n  private readonly auth: AuthInternal;\n\n  /**\n   *\n   * @param authExtern - The corresponding Firebase {@link Auth} instance.\n   *\n   */\n  constructor(authExtern: Auth) {\n    this.auth = _castAuth(authExtern);\n  }\n\n  /**\n   * Executes the verification process.\n   *\n   * @returns A Promise for a token that can be used to assert the validity of a request.\n   */\n  async verify(\n    action: string = 'verify',\n    forceRefresh = false\n  ): Promise<string> {\n    async function retrieveSiteKey(auth: AuthInternal): Promise<string> {\n      if (!forceRefresh) {\n        if (auth.tenantId == null && auth._agentRecaptchaConfig != null) {\n          return auth._agentRecaptchaConfig.siteKey;\n        }\n        if (\n          auth.tenantId != null &&\n          auth._tenantRecaptchaConfigs[auth.tenantId] !== undefined\n        ) {\n          return auth._tenantRecaptchaConfigs[auth.tenantId].siteKey;\n        }\n      }\n\n      return new Promise<string>(async (resolve, reject) => {\n        getRecaptchaConfig(auth, {\n          clientType: RecaptchaClientType.WEB,\n          version: RecaptchaVersion.ENTERPRISE\n        })\n          .then(response => {\n            if (response.recaptchaKey === undefined) {\n              reject(new Error('recaptcha Enterprise site key undefined'));\n            } else {\n              const config = new RecaptchaConfig(response);\n              if (auth.tenantId == null) {\n                auth._agentRecaptchaConfig = config;\n              } else {\n                auth._tenantRecaptchaConfigs[auth.tenantId] = config;\n              }\n              return resolve(config.siteKey);\n            }\n          })\n          .catch(error => {\n            reject(error);\n          });\n      });\n    }\n\n    function retrieveRecaptchaToken(\n      siteKey: string,\n      resolve: (value: string | PromiseLike<string>) => void,\n      reject: (reason?: unknown) => void\n    ): void {\n      const grecaptcha = window.grecaptcha;\n      if (isEnterprise(grecaptcha)) {\n        grecaptcha.enterprise.ready(() => {\n          grecaptcha.enterprise\n            .execute(siteKey, { action })\n            .then(token => {\n              resolve(token);\n            })\n            .catch(() => {\n              resolve(FAKE_TOKEN);\n            });\n        });\n      } else {\n        reject(Error('No reCAPTCHA enterprise script loaded.'));\n      }\n    }\n\n    return new Promise<string>((resolve, reject) => {\n      retrieveSiteKey(this.auth)\n        .then(siteKey => {\n          if (!forceRefresh && isEnterprise(window.grecaptcha)) {\n            retrieveRecaptchaToken(siteKey, resolve, reject);\n          } else {\n            if (typeof window === 'undefined') {\n              reject(\n                new Error('RecaptchaVerifier is only supported in browser')\n              );\n              return;\n            }\n            jsHelpers\n              ._loadJS(RECAPTCHA_ENTERPRISE_URL + siteKey)\n              .then(() => {\n                retrieveRecaptchaToken(siteKey, resolve, reject);\n              })\n              .catch(error => {\n                reject(error);\n              });\n          }\n        })\n        .catch(error => {\n          reject(error);\n        });\n    });\n  }\n}\n\nexport async function injectRecaptchaFields<T>(\n  auth: AuthInternal,\n  request: T,\n  action: RecaptchaActionName,\n  captchaResp = false\n): Promise<T> {\n  const verifier = new RecaptchaEnterpriseVerifier(auth);\n  let captchaResponse;\n  try {\n    captchaResponse = await verifier.verify(action);\n  } catch (error) {\n    captchaResponse = await verifier.verify(action, true);\n  }\n  const newRequest = { ...request };\n  if (!captchaResp) {\n    Object.assign(newRequest, { captchaResponse });\n  } else {\n    Object.assign(newRequest, { 'captchaResp': captchaResponse });\n  }\n  Object.assign(newRequest, { 'clientType': RecaptchaClientType.WEB });\n  Object.assign(newRequest, {\n    'recaptchaVersion': RecaptchaVersion.ENTERPRISE\n  });\n  return newRequest;\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\n  ): 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\n    ): Promise<void> =>\n      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 (_) {\n          /* swallow error */\n        }\n      }\n\n      throw this.auth._errorFactory.create(AuthErrorCode.LOGIN_BLOCKED, {\n        originalMessage: (e as Error)?.message\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 { _FirebaseService, FirebaseApp } from '@firebase/app';\nimport { Provider } from '@firebase/component';\nimport { AppCheckInternalComponentName } from '@firebase/app-check-interop-types';\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  FirebaseError,\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, RecaptchaClientType, RecaptchaVersion } from '../../api';\nimport { getRecaptchaConfig } from '../../api/authentication/recaptcha';\nimport { RecaptchaEnterpriseVerifier } from '../../platform_browser/recaptcha/recaptcha_enterprise_verifier';\nimport { AuthMiddlewareQueue } from './middleware';\nimport { RecaptchaConfig } from '../../platform_browser/recaptcha/recaptcha';\nimport { _logWarn } from '../util/log';\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  _agentRecaptchaConfig: RecaptchaConfig | null = null;\n  _tenantRecaptchaConfigs: Record<string, RecaptchaConfig> = {};\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    private readonly appCheckServiceProvider: Provider<AppCheckInternalComponentName>,\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) {\n          /* Ignore the error */\n        }\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, () =>\n            Promise.reject(e)\n          );\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 (\n        (e as FirebaseError)?.code !==\n        `auth/${AuthErrorCode.NETWORK_REQUEST_FAILED}`\n      ) {\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(\n    user: User | null,\n    skipBeforeStateCallbacks: boolean = false\n  ): 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  async initializeRecaptchaConfig(): Promise<void> {\n    const response = await getRecaptchaConfig(this, {\n      clientType: RecaptchaClientType.WEB,\n      version: RecaptchaVersion.ENTERPRISE\n    });\n\n    const config = new RecaptchaConfig(response);\n    if (this.tenantId == null) {\n      this._agentRecaptchaConfig = config;\n    } else {\n      this._tenantRecaptchaConfigs[this.tenantId] = config;\n    }\n\n    if (config.emailPasswordEnabled) {\n      const verifier = new RecaptchaEnterpriseVerifier(this);\n      void verifier.verify();\n    }\n  }\n\n  _getRecaptchaConfig(): RecaptchaConfig | null {\n    if (this.tenantId == null) {\n      return this._agentRecaptchaConfig;\n    } else {\n      return this._tenantRecaptchaConfigs[this.tenantId];\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    }\n    if (user && this.isProactiveRefreshEnabled) {\n      user._startProactiveRefresh();\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\n      .getImmediate({\n        optional: true\n      })\n      ?.getHeartbeatsHeader();\n    if (heartbeatsHeader) {\n      headers[HttpHeader.X_FIREBASE_CLIENT] = heartbeatsHeader;\n    }\n\n    // If the App Check service exists, add the App Check token in the headers\n    const appCheckToken = await this._getAppCheckToken();\n    if (appCheckToken) {\n      headers[HttpHeader.X_FIREBASE_APP_CHECK] = appCheckToken;\n    }\n\n    return headers;\n  }\n\n  async _getAppCheckToken(): Promise<string | undefined> {\n    const appCheckTokenResult = await this.appCheckServiceProvider\n      .getImmediate({ optional: true })\n      ?.getToken();\n    if (appCheckTokenResult?.error) {\n      // Context: appCheck.getToken() will never throw even if an error happened.\n      // In the error case, a dummy token will be returned along with an error field describing\n      // the error. In general, we shouldn't care about the error condition and just use\n      // the token (actual or dummy) to send requests.\n      _logWarn(\n        `Error while retrieving App Check token: ${appCheckTokenResult.error}`\n      );\n    }\n    return appCheckTokenResult?.token;\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 (typeof window !== 'undefined' && typeof document !== 'undefined') {\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  RecaptchaClientType,\n  RecaptchaVersion,\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  captchaResponse?: string;\n  clientType?: RecaptchaClientType;\n  recaptchaVersion?: RecaptchaVersion;\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  clientType?: RecaptchaClientType;\n  recaptchaVersion?: RecaptchaVersion;\n}\n\nexport interface EmailSignInRequest extends GetOobCodeRequest {\n  requestType: ActionCodeOperation.EMAIL_SIGNIN;\n  email: string;\n  captchaResp?: string;\n  clientType?: RecaptchaClientType;\n  recaptchaVersion?: RecaptchaVersion;\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 { ProviderId, SignInMethod } from '../../model/enums';\n\nimport { updateEmailPassword } from '../../api/account_management/email_and_password';\nimport {\n  signInWithPassword,\n  SignInWithPasswordRequest\n} 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';\nimport { injectRecaptchaFields } from '../../platform_browser/recaptcha/recaptcha_enterprise_verifier';\nimport { RecaptchaActionName, RecaptchaClientType } from '../../api';\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        const request: SignInWithPasswordRequest = {\n          returnSecureToken: true,\n          email: this._email,\n          password: this._password,\n          clientType: RecaptchaClientType.WEB\n        };\n        if (auth._getRecaptchaConfig()?.emailPasswordEnabled) {\n          const requestWithRecaptcha = await injectRecaptchaFields(\n            auth,\n            request,\n            RecaptchaActionName.SIGN_IN_WITH_PASSWORD\n          );\n          return signInWithPassword(auth, requestWithRecaptcha);\n        } else {\n          return signInWithPassword(auth, request).catch(async error => {\n            if (\n              error.code === `auth/${AuthErrorCode.MISSING_RECAPTCHA_TOKEN}`\n            ) {\n              console.log(\n                'Sign-in with email address and password is protected by reCAPTCHA for this project. Automatically triggering the reCAPTCHA flow and restarting the sign-in flow.'\n              );\n              const requestWithRecaptcha = await injectRecaptchaFields(\n                auth,\n                request,\n                RecaptchaActionName.SIGN_IN_WITH_PASSWORD\n              );\n              return signInWithPassword(auth, requestWithRecaptcha);\n            } else {\n              return Promise.reject(error);\n            }\n          });\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  _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 {\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 { providerId, signInMethod, pendingToken }: Record<string, string> =\n      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  RecaptchaClientType,\n  RecaptchaVersion,\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  captchaResponse?: string;\n  clientType?: RecaptchaClientType;\n  recaptchaVersion?: RecaptchaVersion;\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 { FirebaseError } from '@firebase/util';\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 as FirebaseError)?.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 * or a `TOKEN_EXPIRED` 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 { 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 {\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 {\n  FactorId,\n  MultiFactorInfo,\n  PhoneMultiFactorInfo,\n  TotpMultiFactorInfo\n} from '../model/public_types';\nimport {\n  PhoneMfaEnrollment,\n  MfaEnrollment,\n  TotpMfaEnrollment\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    } else if ('totpInfo' in enrollment) {\n      return TotpMultiFactorInfoImpl._fromServerResponse(auth, enrollment);\n    }\n    return _fail(auth, AuthErrorCode.INTERNAL_ERROR);\n  }\n}\n\nexport class PhoneMultiFactorInfoImpl\n  extends MultiFactorInfoImpl\n  implements PhoneMultiFactorInfo\n{\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 as PhoneMfaEnrollment);\n  }\n}\nexport class TotpMultiFactorInfoImpl\n  extends MultiFactorInfoImpl\n  implements TotpMultiFactorInfo\n{\n  private constructor(response: TotpMfaEnrollment) {\n    super(FactorId.TOTP, response);\n  }\n\n  static _fromServerResponse(\n    _auth: AuthInternal,\n    enrollment: MfaEnrollment\n  ): TotpMultiFactorInfoImpl {\n    return new TotpMultiFactorInfoImpl(enrollment as TotpMfaEnrollment);\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, SignUpRequest } 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';\nimport { injectRecaptchaFields } from '../../platform_browser/recaptcha/recaptcha_enterprise_verifier';\nimport { IdTokenResponse } from '../../model/id_token';\nimport { RecaptchaActionName, RecaptchaClientType } from '../../api';\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 authInternal = _castAuth(auth);\n  const request: authentication.PasswordResetRequest = {\n    requestType: ActionCodeOperation.PASSWORD_RESET,\n    email,\n    clientType: RecaptchaClientType.WEB\n  };\n  if (authInternal._getRecaptchaConfig()?.emailPasswordEnabled) {\n    const requestWithRecaptcha = await injectRecaptchaFields(\n      authInternal,\n      request,\n      RecaptchaActionName.GET_OOB_CODE,\n      true\n    );\n    if (actionCodeSettings) {\n      _setActionCodeSettingsOnRequest(\n        authInternal,\n        requestWithRecaptcha,\n        actionCodeSettings\n      );\n    }\n    await authentication.sendPasswordResetEmail(\n      authInternal,\n      requestWithRecaptcha\n    );\n  } else {\n    if (actionCodeSettings) {\n      _setActionCodeSettingsOnRequest(\n        authInternal,\n        request,\n        actionCodeSettings\n      );\n    }\n    await authentication\n      .sendPasswordResetEmail(authInternal, request)\n      .catch(async error => {\n        if (error.code === `auth/${AuthErrorCode.MISSING_RECAPTCHA_TOKEN}`) {\n          console.log(\n            'Password resets are protected by reCAPTCHA for this project. Automatically triggering the reCAPTCHA flow and restarting the password reset flow.'\n          );\n          const requestWithRecaptcha = await injectRecaptchaFields(\n            authInternal,\n            request,\n            RecaptchaActionName.GET_OOB_CODE,\n            true\n          );\n          if (actionCodeSettings) {\n            _setActionCodeSettingsOnRequest(\n              authInternal,\n              requestWithRecaptcha,\n              actionCodeSettings\n            );\n          }\n          await authentication.sendPasswordResetEmail(\n            authInternal,\n            requestWithRecaptcha\n          );\n        } else {\n          return Promise.reject(error);\n        }\n      });\n  }\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 request: SignUpRequest = {\n    returnSecureToken: true,\n    email,\n    password,\n    clientType: RecaptchaClientType.WEB\n  };\n  let signUpResponse: Promise<IdTokenResponse>;\n  if (authInternal._getRecaptchaConfig()?.emailPasswordEnabled) {\n    const requestWithRecaptcha = await injectRecaptchaFields(\n      authInternal,\n      request,\n      RecaptchaActionName.SIGN_UP_PASSWORD\n    );\n    signUpResponse = signUp(authInternal, requestWithRecaptcha);\n  } else {\n    signUpResponse = signUp(authInternal, request).catch(async error => {\n      if (error.code === `auth/${AuthErrorCode.MISSING_RECAPTCHA_TOKEN}`) {\n        console.log(\n          'Sign-up is protected by reCAPTCHA for this project. Automatically triggering the reCAPTCHA flow and restarting the sign-up flow.'\n        );\n        const requestWithRecaptcha = await injectRecaptchaFields(\n          authInternal,\n          request,\n          RecaptchaActionName.SIGN_UP_PASSWORD\n        );\n        return signUp(authInternal, requestWithRecaptcha);\n      } else {\n        return Promise.reject(error);\n      }\n    });\n  }\n\n  const response = await signUpResponse.catch(error => {\n    return Promise.reject(error);\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';\nimport { _castAuth } from '../auth/auth_impl';\nimport { injectRecaptchaFields } from '../../platform_browser/recaptcha/recaptcha_enterprise_verifier';\nimport { RecaptchaActionName, RecaptchaClientType } from '../../api';\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 authInternal = _castAuth(auth);\n  const request: api.EmailSignInRequest = {\n    requestType: ActionCodeOperation.EMAIL_SIGNIN,\n    email,\n    clientType: RecaptchaClientType.WEB\n  };\n  function setActionCodeSettings(\n    request: api.EmailSignInRequest,\n    actionCodeSettings: ActionCodeSettings\n  ): void {\n    _assert(\n      actionCodeSettings.handleCodeInApp,\n      authInternal,\n      AuthErrorCode.ARGUMENT_ERROR\n    );\n    if (actionCodeSettings) {\n      _setActionCodeSettingsOnRequest(\n        authInternal,\n        request,\n        actionCodeSettings\n      );\n    }\n  }\n  if (authInternal._getRecaptchaConfig()?.emailPasswordEnabled) {\n    const requestWithRecaptcha = await injectRecaptchaFields(\n      authInternal,\n      request,\n      RecaptchaActionName.GET_OOB_CODE,\n      true\n    );\n    setActionCodeSettings(requestWithRecaptcha, actionCodeSettings);\n    await api.sendSignInLinkToEmail(authInternal, requestWithRecaptcha);\n  } else {\n    setActionCodeSettings(request, actionCodeSettings);\n    await api\n      .sendSignInLinkToEmail(authInternal, request)\n      .catch(async error => {\n        if (error.code === `auth/${AuthErrorCode.MISSING_RECAPTCHA_TOKEN}`) {\n          console.log(\n            'Email link sign-in is protected by reCAPTCHA for this project. Automatically triggering the reCAPTCHA flow and restarting the sign-in flow.'\n          );\n          const requestWithRecaptcha = await injectRecaptchaFields(\n            authInternal,\n            request,\n            RecaptchaActionName.GET_OOB_CODE,\n            true\n          );\n          setActionCodeSettings(requestWithRecaptcha, actionCodeSettings);\n          await api.sendSignInLinkToEmail(authInternal, requestWithRecaptcha);\n        } else {\n          return Promise.reject(error);\n        }\n      });\n  }\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  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 {\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 { 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 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 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 */\nimport { AuthInternal } from '../model/auth';\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    readonly auth?: AuthInternal\n  ) {}\n\n  static _fromIdtoken(\n    idToken: string,\n    auth?: AuthInternal\n  ): MultiFactorSessionImpl {\n    return new MultiFactorSessionImpl(\n      MultiFactorSessionType.ENROLL,\n      idToken,\n      auth\n    );\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(\n    error.customData.operationType,\n    authModular,\n    AuthErrorCode.ARGUMENT_ERROR\n  );\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 */\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 { _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(\n      await this.user.getIdToken(),\n      this.user.auth\n    );\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    try {\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      await this.user.reload();\n    } catch (e) {\n      throw e;\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 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 { 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 * An MFA provided by TOTP (Time-based One Time Password).\n */\nexport interface TotpMfaEnrollment extends BaseMfaEnrollment {}\n\n/**\n * MfaEnrollment can be any subtype of BaseMfaEnrollment, currently only PhoneMfaEnrollment and TotpMfaEnrollment are supported.\n */\nexport type MfaEnrollment = PhoneMfaEnrollment | TotpMfaEnrollment;\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  >(\n    auth,\n    HttpMethod.POST,\n    Endpoint.START_MFA_ENROLLMENT,\n    _addTidIfNecessary(auth, request)\n  );\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  >(\n    auth,\n    HttpMethod.POST,\n    Endpoint.FINALIZE_MFA_ENROLLMENT,\n    _addTidIfNecessary(auth, request)\n  );\n}\nexport interface StartTotpMfaEnrollmentRequest {\n  idToken: string;\n  totpEnrollmentInfo: {};\n  tenantId?: string;\n}\n\nexport interface StartTotpMfaEnrollmentResponse {\n  totpSessionInfo: {\n    sharedSecretKey: string;\n    verificationCodeLength: number;\n    hashingAlgorithm: string;\n    periodSec: number;\n    sessionInfo: string;\n    finalizeEnrollmentTime: number;\n  };\n}\n\nexport function startEnrollTotpMfa(\n  auth: AuthInternal,\n  request: StartTotpMfaEnrollmentRequest\n): Promise<StartTotpMfaEnrollmentResponse> {\n  return _performApiRequest<\n    StartTotpMfaEnrollmentRequest,\n    StartTotpMfaEnrollmentResponse\n  >(\n    auth,\n    HttpMethod.POST,\n    Endpoint.START_MFA_ENROLLMENT,\n    _addTidIfNecessary(auth, request)\n  );\n}\n\nexport interface TotpVerificationInfo {\n  sessionInfo: string;\n  verificationCode: string;\n}\nexport interface FinalizeTotpMfaEnrollmentRequest {\n  idToken: string;\n  totpVerificationInfo: TotpVerificationInfo;\n  displayName?: string | null;\n  tenantId?: string;\n}\n\nexport interface FinalizeTotpMfaEnrollmentResponse\n  extends FinalizeMfaResponse {}\n\nexport function finalizeEnrollTotpMfa(\n  auth: AuthInternal,\n  request: FinalizeTotpMfaEnrollmentRequest\n): Promise<FinalizeTotpMfaEnrollmentResponse> {\n  return _performApiRequest<\n    FinalizeTotpMfaEnrollmentRequest,\n    FinalizeTotpMfaEnrollmentResponse\n  >(\n    auth,\n    HttpMethod.POST,\n    Endpoint.FINALIZE_MFA_ENROLLMENT,\n    _addTidIfNecessary(auth, request)\n  );\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 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 = (\n    event: StorageEvent,\n    poll?: boolean\n  ): 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\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 =\n      this.handlersMap[eventType];\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 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 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, GreCAPTCHATopLevel } 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 | GreCAPTCHATopLevel;\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 { AuthErrorCode } from '../../core/errors';\nimport { _assert } from '../../core/util/assert';\nimport { AuthInternal } from '../../model/auth';\nimport { RecaptchaParameters } from '../../model/public_types';\nimport {\n  Recaptcha,\n  GreCAPTCHATopLevel,\n  GreCAPTCHARenderOption,\n  GreCAPTCHA\n} 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 MockGreCAPTCHATopLevel implements GreCAPTCHATopLevel {\n  enterprise: GreCAPTCHA = new MockGreCAPTCHA();\n  ready(callback: () => void): void {\n    callback();\n  }\n\n  execute(\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    _siteKey: string,\n    _options: { action: string }\n  ): Promise<string> {\n    return Promise.resolve('token');\n  }\n  render(\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    _container: string | HTMLElement,\n    _parameters: GreCAPTCHARenderOption\n  ): string {\n    return '';\n  }\n}\n\nexport class MockGreCAPTCHA implements GreCAPTCHA {\n  ready(callback: () => void): void {\n    callback();\n  }\n\n  execute(\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    _siteKey: string,\n    _options: { action: string }\n  ): Promise<string> {\n    return Promise.resolve('token');\n  }\n  render(\n    // eslint-disable-next-line @typescript-eslint/no-unused-vars\n    _container: string | HTMLElement,\n    _parameters: GreCAPTCHARenderOption\n  ): string {\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, isV2 } 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  /**\n   * Check for `render()` method. `window.grecaptcha` will exist if the Enterprise\n   * version of the ReCAPTCHA script was loaded by someone else (e.g. App Check) but\n   * `window.grecaptcha.render()` will not. Another load will add it.\n   */\n  private readonly librarySeparatelyLoaded = !!_window().grecaptcha?.render;\n\n  load(auth: AuthInternal, hl = ''): Promise<Recaptcha> {\n    _assert(isHostLanguageValid(hl), auth, AuthErrorCode.ARGUMENT_ERROR);\n\n    if (this.shouldResolveImmediately(hl) && isV2(_window().grecaptcha)) {\n      return Promise.resolve(_window().grecaptcha! as Recaptcha);\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 as Recaptcha;\n\n        if (!recaptcha || !isV2(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?.render &&\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  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  _performApiRequest,\n  Endpoint,\n  HttpMethod,\n  _addTidIfNecessary\n} 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  >(\n    auth,\n    HttpMethod.POST,\n    Endpoint.START_MFA_SIGN_IN,\n    _addTidIfNecessary(auth, request)\n  );\n}\n\nexport interface FinalizePhoneMfaSignInRequest {\n  mfaPendingCredential: string;\n  phoneVerificationInfo: SignInWithPhoneNumberRequest;\n  tenantId?: string;\n}\n\n// TOTP MFA Sign in only has a finalize phase. Phone MFA has a start phase to initiate sending an\n// SMS and a finalize phase to complete sign in. With TOTP, the user already has the OTP in the\n// TOTP/Authenticator app.\nexport interface FinalizeTotpMfaSignInRequest {\n  mfaPendingCredential: string;\n  totpVerificationInfo: { verificationCode: string };\n  tenantId?: string;\n  mfaEnrollmentId: string;\n}\n\nexport interface FinalizePhoneMfaSignInResponse extends FinalizeMfaResponse {}\n\nexport interface FinalizeTotpMfaSignInResponse extends FinalizeMfaResponse {}\n\nexport function finalizeSignInPhoneMfa(\n  auth: Auth,\n  request: FinalizePhoneMfaSignInRequest\n): Promise<FinalizePhoneMfaSignInResponse> {\n  return _performApiRequest<\n    FinalizePhoneMfaSignInRequest,\n    FinalizePhoneMfaSignInResponse\n  >(\n    auth,\n    HttpMethod.POST,\n    Endpoint.FINALIZE_MFA_SIGN_IN,\n    _addTidIfNecessary(auth, request)\n  );\n}\n\nexport function finalizeSignInTotpMfa(\n  auth: Auth,\n  request: FinalizeTotpMfaSignInRequest\n): Promise<FinalizeTotpMfaSignInResponse> {\n  return _performApiRequest<\n    FinalizeTotpMfaSignInRequest,\n    FinalizeTotpMfaSignInResponse\n  >(\n    auth,\n    HttpMethod.POST,\n    Endpoint.FINALIZE_MFA_SIGN_IN,\n    _addTidIfNecessary(auth, request)\n  );\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 {\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 as FirebaseError)?.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{\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 as Error);\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 as Error);\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 {\n  _assert,\n  debugAssert,\n  _createError,\n  _assertInstanceOf\n} 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. Set this to 8s since\n * blocking functions can take upto 7s to complete sign in, as documented in:\n * https://cloud.google.com/identity-platform/docs/blocking-functions#understanding_blocking_functions\n * https://firebase.google.com/docs/auth/extend-with-blocking-functions#understanding_blocking_functions\n */\nexport const enum _Timeout {\n  AUTH_EVENT = 8000\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. This is specifically true for\n        // Firefox or if the opener is in an iframe, in which case the oauth\n        // helper closes the popup.\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 = (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(\n  auth: AuthInternal,\n  result: () => Promise<UserCredentialInternal | null>\n): 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 * Follow the {@link https://firebase.google.com/docs/auth/web/redirect-best-practices\n * | best practices} when using {@link signInWithRedirect}.\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  // Wait for auth initialization to complete, this will process pending redirects and clear the\n  // PENDING_REDIRECT_KEY in persistence. This should be completed before starting a new\n  // redirect and creating a PENDING_REDIRECT_KEY entry.\n  await authInternal._initializationPromise;\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 * @remarks\n * To handle the results and errors for this operation, refer to {@link getRedirectResult}.\n * Follow the {@link https://firebase.google.com/docs/auth/web/redirect-best-practices\n * | best practices} when using {@link reauthenticateWithRedirect}.\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 * // Reauthenticate using a redirect.\n * await reauthenticateWithRedirect(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  // Wait for auth initialization to complete, this will process pending redirects and clear the\n  // PENDING_REDIRECT_KEY in persistence. This should be completed before starting a new\n  // redirect and creating a PENDING_REDIRECT_KEY entry.\n  await userInternal.auth._initializationPromise;\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 * @remarks\n * To handle the results and errors for this operation, refer to {@link getRedirectResult}.\n * Follow the {@link https://firebase.google.com/docs/auth/web/redirect-best-practices\n * | best practices} when using {@link linkWithRedirect}.\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  // Wait for auth initialization to complete, this will process pending redirects and clear the\n  // PENDING_REDIRECT_KEY in persistence. This should be completed before starting a new\n  // redirect and creating a PENDING_REDIRECT_KEY entry.\n  await userInternal.auth._initializationPromise;\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 `null`.\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\n        ._loadJS(`https://apis.google.com/js/api.js?onload=${cbName}`)\n        .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/**\n * Fragment name for the App Check token that gets passed to the widget\n *\n * @internal\n */\nconst FIREBASE_APP_CHECK_FRAGMENT_ID = encodeURIComponent('fac');\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 async function _getRedirectUrl(\n  auth: AuthInternal,\n  provider: AuthProvider,\n  authType: AuthEventType,\n  redirectUrl?: string,\n  eventId?: string,\n  additionalParams?: Record<string, string>\n): Promise<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\n  // Sets the App Check token to pass to the widget\n  const appCheckToken = await auth._getAppCheckToken();\n  const appCheckTokenFragment = appCheckToken\n    ? `#${FIREBASE_APP_CHECK_FRAGMENT_ID}=${encodeURIComponent(appCheckToken)}`\n    : '';\n\n  // Start at index 1 to skip the leading '&' in the query string\n  return `${getHandlerBase(auth)}?${querystring(paramsDict).slice(\n    1\n  )}${appCheckTokenFragment}`;\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 = await _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    const url = await _getRedirectUrl(\n      auth,\n      provider,\n      authType,\n      _getCurrentUrl(),\n      eventId\n    );\n    _setWindowLocation(url);\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 =\n  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{\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<TokenListener, 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 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 {\n  initializeAuth,\n  beforeAuthStateChanged,\n  onIdTokenChanged,\n  connectAuthEmulator\n} 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, User } from '../model/public_types';\nimport { getDefaultEmulatorHost, getExperimentalSetting } from '@firebase/util';\n\nconst DEFAULT_ID_TOKEN_MAX_AGE = 5 * 60;\nconst authIdTokenMaxAge =\n  getExperimentalSetting('authIdTokenMaxAge') || DEFAULT_ID_TOKEN_MAX_AGE;\n\nlet lastPostedIdToken: string | undefined | null = null;\n\nconst mintCookieFactory = (url: string) => async (user: User | null) => {\n  const idTokenResult = user && (await user.getIdTokenResult());\n  const idTokenAge =\n    idTokenResult &&\n    (new Date().getTime() - Date.parse(idTokenResult.issuedAtTime)) / 1_000;\n  if (idTokenAge && idTokenAge > authIdTokenMaxAge) {\n    return;\n  }\n  // Specifically trip null => undefined when logged out, to delete any existing cookie\n  const idToken = idTokenResult?.token;\n  if (lastPostedIdToken === idToken) {\n    return;\n  }\n  lastPostedIdToken = idToken;\n  await fetch(url, {\n    method: idToken ? 'POST' : 'DELETE',\n    headers: idToken\n      ? {\n          'Authorization': `Bearer ${idToken}`\n        }\n      : {}\n  });\n};\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  const auth = initializeAuth(app, {\n    popupRedirectResolver: browserPopupRedirectResolver,\n    persistence: [\n      indexedDBLocalPersistence,\n      browserLocalPersistence,\n      browserSessionPersistence\n    ]\n  });\n\n  const authTokenSyncUrl = getExperimentalSetting('authTokenSyncURL');\n  if (authTokenSyncUrl) {\n    const mintCookie = mintCookieFactory(authTokenSyncUrl);\n    beforeAuthStateChanged(auth, mintCookie, () =>\n      mintCookie(auth.currentUser)\n    );\n    onIdTokenChanged(auth, user => mintCookie(user));\n  }\n\n  const authEmulatorHost = getDefaultEmulatorHost('auth');\n  if (authEmulatorHost) {\n    connectAuthEmulator(auth, `http://${authEmulatorHost}`);\n  }\n\n  return auth;\n}\n\nregisterAuth(ClientPlatform.BROWSER);\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 =\n          container.getProvider<'heartbeat'>('heartbeat');\n        const appCheckServiceProvider =\n          container.getProvider<'app-check-internal'>('app-check-internal');\n        const { apiKey, authDomain } = app.options;\n\n        _assert(\n          apiKey && !apiKey.includes(':'),\n          AuthErrorCode.INVALID_API_KEY,\n          { appName: app.name }\n        );\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(\n          app,\n          heartbeatServiceProvider,\n          appCheckServiceProvider,\n          config\n        );\n        _initializeAuthInstance(authInstance, deps);\n\n        return authInstance;\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\nexport interface CordovaWindow extends Window {\n  cordova: {\n    plugins: {\n      browsertab: {\n        isAvailable(cb: (available: boolean) => void): void;\n        openUrl(url: string): void;\n        close(): void;\n      };\n    };\n\n    InAppBrowser: {\n      open(url: string, target: string, options: string): InAppBrowserRef;\n    };\n  };\n\n  universalLinks: {\n    subscribe(\n      n: null,\n      cb: (event: Record<string, string> | null) => void\n    ): void;\n  };\n\n  BuildInfo: {\n    readonly packageName: string;\n    readonly displayName: string;\n  };\n\n  handleOpenURL(url: string): void;\n}\n\nexport interface InAppBrowserRef {\n  close?: () => void;\n}\n\nexport function _cordovaWindow(): CordovaWindow {\n  return window as unknown as CordovaWindow;\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\nimport { AuthProvider } from '../../model/public_types';\nimport { AuthErrorCode } from '../../core/errors';\nimport {\n  debugAssert,\n  _assert,\n  _createError,\n  _fail\n} from '../../core/util/assert';\nimport { _isAndroid, _isIOS, _isIOS7Or8 } from '../../core/util/browser';\nimport { _getRedirectUrl } from '../../core/util/handler';\nimport { AuthInternal } from '../../model/auth';\nimport { AuthEvent } from '../../model/popup_redirect';\nimport { InAppBrowserRef, _cordovaWindow } from '../plugins';\nimport {\n  GetProjectConfigRequest,\n  _getProjectConfig\n} from '../../api/project_config/get_project_config';\n\n/**\n * How long to wait after the app comes back into focus before concluding that\n * the user closed the sign in tab.\n */\nconst REDIRECT_TIMEOUT_MS = 2000;\n\n/**\n * Generates the URL for the OAuth handler.\n */\nexport async function _generateHandlerUrl(\n  auth: AuthInternal,\n  event: AuthEvent,\n  provider: AuthProvider\n): Promise<string> {\n  // Get the cordova plugins\n  const { BuildInfo } = _cordovaWindow();\n  debugAssert(event.sessionId, 'AuthEvent did not contain a session ID');\n  const sessionDigest = await computeSha256(event.sessionId);\n\n  const additionalParams: Record<string, string> = {};\n  if (_isIOS()) {\n    // iOS app identifier\n    additionalParams['ibi'] = BuildInfo.packageName;\n  } else if (_isAndroid()) {\n    // Android app identifier\n    additionalParams['apn'] = BuildInfo.packageName;\n  } else {\n    _fail(auth, AuthErrorCode.OPERATION_NOT_SUPPORTED);\n  }\n\n  // Add the display name if available\n  if (BuildInfo.displayName) {\n    additionalParams['appDisplayName'] = BuildInfo.displayName;\n  }\n\n  // Attached the hashed session ID\n  additionalParams['sessionId'] = sessionDigest;\n  return _getRedirectUrl(\n    auth,\n    provider,\n    event.type,\n    undefined,\n    event.eventId ?? undefined,\n    additionalParams\n  );\n}\n\n/**\n * Validates that this app is valid for this project configuration\n */\nexport async function _validateOrigin(auth: AuthInternal): Promise<void> {\n  const { BuildInfo } = _cordovaWindow();\n  const request: GetProjectConfigRequest = {};\n  if (_isIOS()) {\n    request.iosBundleId = BuildInfo.packageName;\n  } else if (_isAndroid()) {\n    request.androidPackageName = BuildInfo.packageName;\n  } else {\n    _fail(auth, AuthErrorCode.OPERATION_NOT_SUPPORTED);\n  }\n\n  // Will fail automatically if package name is not authorized\n  await _getProjectConfig(auth, request);\n}\n\nexport function _performRedirect(\n  handlerUrl: string\n): Promise<InAppBrowserRef | null> {\n  // Get the cordova plugins\n  const { cordova } = _cordovaWindow();\n\n  return new Promise(resolve => {\n    cordova.plugins.browsertab.isAvailable(browserTabIsAvailable => {\n      let iabRef: InAppBrowserRef | null = null;\n      if (browserTabIsAvailable) {\n        cordova.plugins.browsertab.openUrl(handlerUrl);\n      } else {\n        // TODO: Return the inappbrowser ref that's returned from the open call\n        iabRef = cordova.InAppBrowser.open(\n          handlerUrl,\n          _isIOS7Or8() ? '_blank' : '_system',\n          'location=yes'\n        );\n      }\n      resolve(iabRef);\n    });\n  });\n}\n\n// Thin interface wrapper to avoid circular dependency with ./events module\ninterface PassiveAuthEventListener {\n  addPassiveListener(cb: () => void): void;\n  removePassiveListener(cb: () => void): void;\n}\n\n/**\n * This function waits for app activity to be seen before resolving. It does\n * this by attaching listeners to various dom events. Once the app is determined\n * to be visible, this promise resolves. AFTER that resolution, the listeners\n * are detached and any browser tabs left open will be closed.\n */\nexport async function _waitForAppResume(\n  auth: AuthInternal,\n  eventListener: PassiveAuthEventListener,\n  iabRef: InAppBrowserRef | null\n): Promise<void> {\n  // Get the cordova plugins\n  const { cordova } = _cordovaWindow();\n\n  let cleanup = (): void => {};\n  try {\n    await new Promise<void>((resolve, reject) => {\n      let onCloseTimer: number | null = null;\n\n      // DEFINE ALL THE CALLBACKS =====\n      function authEventSeen(): void {\n        // Auth event was detected. Resolve this promise and close the extra\n        // window if it's still open.\n        resolve();\n        const closeBrowserTab = cordova.plugins.browsertab?.close;\n        if (typeof closeBrowserTab === 'function') {\n          closeBrowserTab();\n        }\n        // Close inappbrowser emebedded webview in iOS7 and 8 case if still\n        // open.\n        if (typeof iabRef?.close === 'function') {\n          iabRef.close();\n        }\n      }\n\n      function resumed(): void {\n        if (onCloseTimer) {\n          // This code already ran; do not rerun.\n          return;\n        }\n\n        onCloseTimer = window.setTimeout(() => {\n          // Wait two seeconds after resume then reject.\n          reject(_createError(auth, AuthErrorCode.REDIRECT_CANCELLED_BY_USER));\n        }, REDIRECT_TIMEOUT_MS);\n      }\n\n      function visibilityChanged(): void {\n        if (document?.visibilityState === 'visible') {\n          resumed();\n        }\n      }\n\n      // ATTACH ALL THE LISTENERS =====\n      // Listen for the auth event\n      eventListener.addPassiveListener(authEventSeen);\n\n      // Listen for resume and visibility events\n      document.addEventListener('resume', resumed, false);\n      if (_isAndroid()) {\n        document.addEventListener('visibilitychange', visibilityChanged, false);\n      }\n\n      // SETUP THE CLEANUP FUNCTION =====\n      cleanup = () => {\n        eventListener.removePassiveListener(authEventSeen);\n        document.removeEventListener('resume', resumed, false);\n        document.removeEventListener(\n          'visibilitychange',\n          visibilityChanged,\n          false\n        );\n        if (onCloseTimer) {\n          window.clearTimeout(onCloseTimer);\n        }\n      };\n    });\n  } finally {\n    cleanup();\n  }\n}\n\n/**\n * Checks the configuration of the Cordova environment. This has no side effect\n * if the configuration is correct; otherwise it throws an error with the\n * missing plugin.\n */\nexport function _checkCordovaConfiguration(auth: AuthInternal): void {\n  const win = _cordovaWindow();\n  // Check all dependencies installed.\n  // https://github.com/nordnet/cordova-universal-links-plugin\n  // Note that cordova-universal-links-plugin has been abandoned.\n  // A fork with latest fixes is available at:\n  // https://www.npmjs.com/package/cordova-universal-links-plugin-fix\n  _assert(\n    typeof win?.universalLinks?.subscribe === 'function',\n    auth,\n    AuthErrorCode.INVALID_CORDOVA_CONFIGURATION,\n    {\n      missingPlugin: 'cordova-universal-links-plugin-fix'\n    }\n  );\n\n  // https://www.npmjs.com/package/cordova-plugin-buildinfo\n  _assert(\n    typeof win?.BuildInfo?.packageName !== 'undefined',\n    auth,\n    AuthErrorCode.INVALID_CORDOVA_CONFIGURATION,\n    {\n      missingPlugin: 'cordova-plugin-buildInfo'\n    }\n  );\n\n  // https://github.com/google/cordova-plugin-browsertab\n  _assert(\n    typeof win?.cordova?.plugins?.browsertab?.openUrl === 'function',\n    auth,\n    AuthErrorCode.INVALID_CORDOVA_CONFIGURATION,\n    {\n      missingPlugin: 'cordova-plugin-browsertab'\n    }\n  );\n  _assert(\n    typeof win?.cordova?.plugins?.browsertab?.isAvailable === 'function',\n    auth,\n    AuthErrorCode.INVALID_CORDOVA_CONFIGURATION,\n    {\n      missingPlugin: 'cordova-plugin-browsertab'\n    }\n  );\n\n  // https://cordova.apache.org/docs/en/latest/reference/cordova-plugin-inappbrowser/\n  _assert(\n    typeof win?.cordova?.InAppBrowser?.open === 'function',\n    auth,\n    AuthErrorCode.INVALID_CORDOVA_CONFIGURATION,\n    {\n      missingPlugin: 'cordova-plugin-inappbrowser'\n    }\n  );\n}\n\n/**\n * Computes the SHA-256 of a session ID. The SubtleCrypto interface is only\n * available in \"secure\" contexts, which covers Cordova (which is served on a file\n * protocol).\n */\nasync function computeSha256(sessionId: string): Promise<string> {\n  const bytes = stringToArrayBuffer(sessionId);\n\n  // TODO: For IE11 crypto has a different name and this operation comes back\n  //       as an object, not a promise. This is the old proposed standard that\n  //       is used by IE11:\n  // https://www.w3.org/TR/2013/WD-WebCryptoAPI-20130108/#cryptooperation-interface\n  const buf = await crypto.subtle.digest('SHA-256', bytes);\n  const arr = Array.from(new Uint8Array(buf));\n  return arr.map(num => num.toString(16).padStart(2, '0')).join('');\n}\n\nfunction stringToArrayBuffer(str: string): Uint8Array {\n  // This function is only meant to deal with an ASCII charset and makes\n  // certain simplifying assumptions.\n  debugAssert(\n    /[0-9a-zA-Z]+/.test(str),\n    'Can only convert alpha-numeric strings'\n  );\n  if (typeof TextEncoder !== 'undefined') {\n    return new TextEncoder().encode(str);\n  }\n\n  const buff = new ArrayBuffer(str.length);\n  const view = new Uint8Array(buff);\n  for (let i = 0; i < str.length; i++) {\n    view[i] = str.charCodeAt(i);\n  }\n  return view;\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 { querystringDecode } from '@firebase/util';\nimport { AuthEventManager } from '../../core/auth/auth_event_manager';\nimport { AuthErrorCode } from '../../core/errors';\nimport { PersistedBlob, PersistenceInternal } from '../../core/persistence';\nimport {\n  KeyName,\n  _persistenceKeyName\n} from '../../core/persistence/persistence_user_manager';\nimport { _createError } from '../../core/util/assert';\nimport { _getInstance } from '../../core/util/instantiator';\nimport { AuthInternal } from '../../model/auth';\nimport { AuthEvent, AuthEventType } from '../../model/popup_redirect';\nimport { browserLocalPersistence } from '../../platform_browser/persistence/local_storage';\n\nconst SESSION_ID_LENGTH = 20;\n\n/** Custom AuthEventManager that adds passive listeners to events */\nexport class CordovaAuthEventManager extends AuthEventManager {\n  private readonly passiveListeners = new Set<(e: AuthEvent) => void>();\n  private resolveInialized!: () => void;\n  private initPromise = new Promise<void>(resolve => {\n    this.resolveInialized = resolve;\n  });\n\n  addPassiveListener(cb: (e: AuthEvent) => void): void {\n    this.passiveListeners.add(cb);\n  }\n\n  removePassiveListener(cb: (e: AuthEvent) => void): void {\n    this.passiveListeners.delete(cb);\n  }\n\n  // In a Cordova environment, this manager can live through multiple redirect\n  // operations\n  resetRedirect(): void {\n    this.queuedRedirectEvent = null;\n    this.hasHandledPotentialRedirect = false;\n  }\n\n  /** Override the onEvent method */\n  onEvent(event: AuthEvent): boolean {\n    this.resolveInialized();\n    this.passiveListeners.forEach(cb => cb(event));\n    return super.onEvent(event);\n  }\n\n  async initialized(): Promise<void> {\n    await this.initPromise;\n  }\n}\n\n/**\n * Generates a (partial) {@link AuthEvent}.\n */\nexport function _generateNewEvent(\n  auth: AuthInternal,\n  type: AuthEventType,\n  eventId: string | null = null\n): AuthEvent {\n  return {\n    type,\n    eventId,\n    urlResponse: null,\n    sessionId: generateSessionId(),\n    postBody: null,\n    tenantId: auth.tenantId,\n    error: _createError(auth, AuthErrorCode.NO_AUTH_EVENT)\n  };\n}\n\nexport function _savePartialEvent(\n  auth: AuthInternal,\n  event: AuthEvent\n): Promise<void> {\n  return storage()._set(persistenceKey(auth), event as object as PersistedBlob);\n}\n\nexport async function _getAndRemoveEvent(\n  auth: AuthInternal\n): Promise<AuthEvent | null> {\n  const event = (await storage()._get(\n    persistenceKey(auth)\n  )) as AuthEvent | null;\n  if (event) {\n    await storage()._remove(persistenceKey(auth));\n  }\n  return event;\n}\n\nexport function _eventFromPartialAndUrl(\n  partialEvent: AuthEvent,\n  url: string\n): AuthEvent | null {\n  // Parse the deep link within the dynamic link URL.\n  const callbackUrl = _getDeepLinkFromCallback(url);\n  // Confirm it is actually a callback URL.\n  // Currently the universal link will be of this format:\n  // https://<AUTH_DOMAIN>/__/auth/callback<OAUTH_RESPONSE>\n  // This is a fake URL but is not intended to take the user anywhere\n  // and just redirect to the app.\n  if (callbackUrl.includes('/__/auth/callback')) {\n    // Check if there is an error in the URL.\n    // This mechanism is also used to pass errors back to the app:\n    // https://<AUTH_DOMAIN>/__/auth/callback?firebaseError=<STRINGIFIED_ERROR>\n    const params = searchParamsOrEmpty(callbackUrl);\n    // Get the error object corresponding to the stringified error if found.\n    const errorObject = params['firebaseError']\n      ? parseJsonOrNull(decodeURIComponent(params['firebaseError']))\n      : null;\n    const code = errorObject?.['code']?.split('auth/')?.[1];\n    const error = code ? _createError(code) : null;\n    if (error) {\n      return {\n        type: partialEvent.type,\n        eventId: partialEvent.eventId,\n        tenantId: partialEvent.tenantId,\n        error,\n        urlResponse: null,\n        sessionId: null,\n        postBody: null\n      };\n    } else {\n      return {\n        type: partialEvent.type,\n        eventId: partialEvent.eventId,\n        tenantId: partialEvent.tenantId,\n        sessionId: partialEvent.sessionId,\n        urlResponse: callbackUrl,\n        postBody: null\n      };\n    }\n  }\n\n  return null;\n}\n\nfunction generateSessionId(): string {\n  const chars = [];\n  const allowedChars =\n    '1234567890abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';\n  for (let i = 0; i < SESSION_ID_LENGTH; i++) {\n    const idx = Math.floor(Math.random() * allowedChars.length);\n    chars.push(allowedChars.charAt(idx));\n  }\n  return chars.join('');\n}\n\nfunction storage(): PersistenceInternal {\n  return _getInstance(browserLocalPersistence);\n}\n\nfunction persistenceKey(auth: AuthInternal): string {\n  return _persistenceKeyName(KeyName.AUTH_EVENT, auth.config.apiKey, auth.name);\n}\n\nfunction parseJsonOrNull(json: string): ReturnType<typeof JSON.parse> | null {\n  try {\n    return JSON.parse(json);\n  } catch (e) {\n    return null;\n  }\n}\n\n// Exported for testing\nexport function _getDeepLinkFromCallback(url: string): string {\n  const params = searchParamsOrEmpty(url);\n  const link = params['link'] ? decodeURIComponent(params['link']) : undefined;\n  // Double link case (automatic redirect)\n  const doubleDeepLink = searchParamsOrEmpty(link)['link'];\n  // iOS custom scheme links.\n  const iOSDeepLink = params['deep_link_id']\n    ? decodeURIComponent(params['deep_link_id'])\n    : undefined;\n  const iOSDoubleDeepLink = searchParamsOrEmpty(iOSDeepLink)['link'];\n  return iOSDoubleDeepLink || iOSDeepLink || doubleDeepLink || link || url;\n}\n\n/**\n * Optimistically tries to get search params from a string, or else returns an\n * empty search params object.\n */\nfunction searchParamsOrEmpty(url: string | undefined): Record<string, string> {\n  if (!url?.includes('?')) {\n    return {};\n  }\n\n  const [_, ...rest] = url.split('?');\n  return querystringDecode(rest.join('?')) as Record<string, string>;\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 { AuthProvider, PopupRedirectResolver } from '../../model/public_types';\nimport { browserSessionPersistence } from '../../platform_browser/persistence/session_storage';\nimport { AuthInternal } from '../../model/auth';\nimport {\n  AuthEvent,\n  AuthEventType,\n  PopupRedirectResolverInternal\n} from '../../model/popup_redirect';\nimport { AuthPopup } from '../../platform_browser/util/popup';\nimport { _createError, _fail } from '../../core/util/assert';\nimport { AuthErrorCode } from '../../core/errors';\nimport {\n  _checkCordovaConfiguration,\n  _generateHandlerUrl,\n  _performRedirect,\n  _validateOrigin,\n  _waitForAppResume\n} from './utils';\nimport {\n  CordovaAuthEventManager,\n  _eventFromPartialAndUrl,\n  _generateNewEvent,\n  _getAndRemoveEvent,\n  _savePartialEvent\n} from './events';\nimport { AuthEventManager } from '../../core/auth/auth_event_manager';\nimport { _getRedirectResult } from '../../platform_browser/strategies/redirect';\nimport {\n  _clearRedirectOutcomes,\n  _overrideRedirectResult\n} from '../../core/strategies/redirect';\nimport { _cordovaWindow } from '../plugins';\n\n/**\n * How long to wait for the initial auth event before concluding no\n * redirect pending\n */\nconst INITIAL_EVENT_TIMEOUT_MS = 500;\n\nclass CordovaPopupRedirectResolver implements PopupRedirectResolverInternal {\n  readonly _redirectPersistence = browserSessionPersistence;\n  readonly _shouldInitProactively = true; // This is lightweight for Cordova\n  private readonly eventManagers = new Map<string, CordovaAuthEventManager>();\n  private readonly originValidationPromises: Record<string, Promise<void>> = {};\n\n  _completeRedirectFn = _getRedirectResult;\n  _overrideRedirectResult = _overrideRedirectResult;\n\n  async _initialize(auth: AuthInternal): Promise<CordovaAuthEventManager> {\n    const key = auth._key();\n    let manager = this.eventManagers.get(key);\n    if (!manager) {\n      manager = new CordovaAuthEventManager(auth);\n      this.eventManagers.set(key, manager);\n      this.attachCallbackListeners(auth, manager);\n    }\n    return manager;\n  }\n\n  _openPopup(auth: AuthInternal): Promise<AuthPopup> {\n    _fail(auth, AuthErrorCode.OPERATION_NOT_SUPPORTED);\n  }\n\n  async _openRedirect(\n    auth: AuthInternal,\n    provider: AuthProvider,\n    authType: AuthEventType,\n    eventId?: string\n  ): Promise<void> {\n    _checkCordovaConfiguration(auth);\n    const manager = await this._initialize(auth);\n    await manager.initialized();\n\n    // Reset the persisted redirect states. This does not matter on Web where\n    // the redirect always blows away application state entirely. On Cordova,\n    // the app maintains control flow through the redirect.\n    manager.resetRedirect();\n    _clearRedirectOutcomes();\n\n    await this._originValidation(auth);\n\n    const event = _generateNewEvent(auth, authType, eventId);\n    await _savePartialEvent(auth, event);\n    const url = await _generateHandlerUrl(auth, event, provider);\n    const iabRef = await _performRedirect(url);\n    return _waitForAppResume(auth, manager, iabRef);\n  }\n\n  _isIframeWebStorageSupported(\n    _auth: AuthInternal,\n    _cb: (support: boolean) => unknown\n  ): void {\n    throw new Error('Method not implemented.');\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  private attachCallbackListeners(\n    auth: AuthInternal,\n    manager: AuthEventManager\n  ): void {\n    // Get the global plugins\n    const { universalLinks, handleOpenURL, BuildInfo } = _cordovaWindow();\n\n    const noEventTimeout = setTimeout(async () => {\n      // We didn't see that initial event. Clear any pending object and\n      // dispatch no event\n      await _getAndRemoveEvent(auth);\n      manager.onEvent(generateNoEvent());\n    }, INITIAL_EVENT_TIMEOUT_MS);\n\n    const universalLinksCb = async (\n      eventData: Record<string, string> | null\n    ): Promise<void> => {\n      // We have an event so we can clear the no event timeout\n      clearTimeout(noEventTimeout);\n\n      const partialEvent = await _getAndRemoveEvent(auth);\n      let finalEvent: AuthEvent | null = null;\n      if (partialEvent && eventData?.['url']) {\n        finalEvent = _eventFromPartialAndUrl(partialEvent, eventData['url']);\n      }\n\n      // If finalEvent is never filled, trigger with no event\n      manager.onEvent(finalEvent || generateNoEvent());\n    };\n\n    // Universal links subscriber doesn't exist for iOS, so we need to check\n    if (\n      typeof universalLinks !== 'undefined' &&\n      typeof universalLinks.subscribe === 'function'\n    ) {\n      universalLinks.subscribe(null, universalLinksCb);\n    }\n\n    // iOS 7 or 8 custom URL schemes.\n    // This is also the current default behavior for iOS 9+.\n    // For this to work, cordova-plugin-customurlscheme needs to be installed.\n    // https://github.com/EddyVerbruggen/Custom-URL-scheme\n    // Do not overwrite the existing developer's URL handler.\n    const existingHandleOpenURL = handleOpenURL;\n    const packagePrefix = `${BuildInfo.packageName.toLowerCase()}://`;\n    _cordovaWindow().handleOpenURL = async url => {\n      if (url.toLowerCase().startsWith(packagePrefix)) {\n        // We want this intentionally to float\n        // eslint-disable-next-line @typescript-eslint/no-floating-promises\n        universalLinksCb({ url });\n      }\n      // Call the developer's handler if it is present.\n      if (typeof existingHandleOpenURL === 'function') {\n        try {\n          existingHandleOpenURL(url);\n        } catch (e) {\n          // This is a developer error. Don't stop the flow of the SDK.\n          console.error(e);\n        }\n      }\n    };\n  }\n}\n\n/**\n * An implementation of {@link PopupRedirectResolver} suitable for Cordova\n * based applications.\n *\n * @public\n */\nexport const cordovaPopupRedirectResolver: PopupRedirectResolver =\n  CordovaPopupRedirectResolver;\n\nfunction generateNoEvent(): AuthEvent {\n  return {\n    type: AuthEventType.UNKNOWN,\n    eventId: null,\n    sessionId: null,\n    urlResponse: null,\n    postBody: null,\n    tenantId: null,\n    error: _createError(AuthErrorCode.NO_AUTH_EVENT)\n  };\n}\n","/**\n * @license\n * Copyright 2017 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 { _castAuth } from '../src/core/auth/auth_impl';\nimport { Auth } from '../src/model/public_types';\n\n/**\n * This interface is intended only for use by @firebase/auth-compat, do not use directly\n */\nexport * from '../index';\n\nexport { SignInWithIdpResponse } from '../src/api/authentication/idp';\nexport { AuthErrorCode } from '../src/core/errors';\nexport { PersistenceInternal } from '../src/core/persistence';\nexport { _persistenceKeyName } from '../src/core/persistence/persistence_user_manager';\nexport { UserImpl } from '../src/core/user/user_impl';\nexport { _getInstance } from '../src/core/util/instantiator';\nexport {\n  PopupRedirectResolverInternal,\n  EventManager,\n  AuthEventType\n} from '../src/model/popup_redirect';\nexport { UserCredentialInternal, UserParameters } from '../src/model/user';\nexport { AuthInternal, ConfigInternal } from '../src/model/auth';\nexport { DefaultConfig, AuthImpl, _castAuth } from '../src/core/auth/auth_impl';\n\nexport { ClientPlatform, _getClientVersion } from '../src/core/util/version';\n\nexport { _generateEventId } from '../src/core/util/event_id';\nexport { TaggedWithTokenResponse } from '../src/model/id_token';\nexport { _fail, _assert } from '../src/core/util/assert';\nexport { AuthPopup } from '../src/platform_browser/util/popup';\nexport { _getRedirectResult } from '../src/platform_browser/strategies/redirect';\nexport { _overrideRedirectResult } from '../src/core/strategies/redirect';\nexport { cordovaPopupRedirectResolver } from '../src/platform_cordova/popup_redirect/popup_redirect';\nexport { FetchProvider } from '../src/core/util/fetch_provider';\nexport { SAMLAuthCredential } from '../src/core/credentials/saml';\n\n// This function should only be called by frameworks (e.g. FirebaseUI-web) to log their usage.\n// It is not intended for direct use by developer apps. NO jsdoc here to intentionally leave it out\n// of autogenerated documentation pages to reduce accidental misuse.\nexport function addFrameworkForLogging(auth: Auth, framework: string): void {\n  _castAuth(auth)._logFramework(framework);\n}\n","const instanceOfAny = (object, constructors) => constructors.some((c) => object instanceof c);\n\nlet idbProxyableTypes;\nlet cursorAdvanceMethods;\n// This is a function to prevent it throwing up in node environments.\nfunction getIdbProxyableTypes() {\n    return (idbProxyableTypes ||\n        (idbProxyableTypes = [\n            IDBDatabase,\n            IDBObjectStore,\n            IDBIndex,\n            IDBCursor,\n            IDBTransaction,\n        ]));\n}\n// This is a function to prevent it throwing up in node environments.\nfunction getCursorAdvanceMethods() {\n    return (cursorAdvanceMethods ||\n        (cursorAdvanceMethods = [\n            IDBCursor.prototype.advance,\n            IDBCursor.prototype.continue,\n            IDBCursor.prototype.continuePrimaryKey,\n        ]));\n}\nconst cursorRequestMap = new WeakMap();\nconst transactionDoneMap = new WeakMap();\nconst transactionStoreNamesMap = new WeakMap();\nconst transformCache = new WeakMap();\nconst reverseTransformCache = new WeakMap();\nfunction promisifyRequest(request) {\n    const promise = new Promise((resolve, reject) => {\n        const unlisten = () => {\n            request.removeEventListener('success', success);\n            request.removeEventListener('error', error);\n        };\n        const success = () => {\n            resolve(wrap(request.result));\n            unlisten();\n        };\n        const error = () => {\n            reject(request.error);\n            unlisten();\n        };\n        request.addEventListener('success', success);\n        request.addEventListener('error', error);\n    });\n    promise\n        .then((value) => {\n        // Since cursoring reuses the IDBRequest (*sigh*), we cache it for later retrieval\n        // (see wrapFunction).\n        if (value instanceof IDBCursor) {\n            cursorRequestMap.set(value, request);\n        }\n        // Catching to avoid \"Uncaught Promise exceptions\"\n    })\n        .catch(() => { });\n    // This mapping exists in reverseTransformCache but doesn't doesn't exist in transformCache. This\n    // is because we create many promises from a single IDBRequest.\n    reverseTransformCache.set(promise, request);\n    return promise;\n}\nfunction cacheDonePromiseForTransaction(tx) {\n    // Early bail if we've already created a done promise for this transaction.\n    if (transactionDoneMap.has(tx))\n        return;\n    const done = new Promise((resolve, reject) => {\n        const unlisten = () => {\n            tx.removeEventListener('complete', complete);\n            tx.removeEventListener('error', error);\n            tx.removeEventListener('abort', error);\n        };\n        const complete = () => {\n            resolve();\n            unlisten();\n        };\n        const error = () => {\n            reject(tx.error || new DOMException('AbortError', 'AbortError'));\n            unlisten();\n        };\n        tx.addEventListener('complete', complete);\n        tx.addEventListener('error', error);\n        tx.addEventListener('abort', error);\n    });\n    // Cache it for later retrieval.\n    transactionDoneMap.set(tx, done);\n}\nlet idbProxyTraps = {\n    get(target, prop, receiver) {\n        if (target instanceof IDBTransaction) {\n            // Special handling for transaction.done.\n            if (prop === 'done')\n                return transactionDoneMap.get(target);\n            // Polyfill for objectStoreNames because of Edge.\n            if (prop === 'objectStoreNames') {\n                return target.objectStoreNames || transactionStoreNamesMap.get(target);\n            }\n            // Make tx.store return the only store in the transaction, or undefined if there are many.\n            if (prop === 'store') {\n                return receiver.objectStoreNames[1]\n                    ? undefined\n                    : receiver.objectStore(receiver.objectStoreNames[0]);\n            }\n        }\n        // Else transform whatever we get back.\n        return wrap(target[prop]);\n    },\n    set(target, prop, value) {\n        target[prop] = value;\n        return true;\n    },\n    has(target, prop) {\n        if (target instanceof IDBTransaction &&\n            (prop === 'done' || prop === 'store')) {\n            return true;\n        }\n        return prop in target;\n    },\n};\nfunction replaceTraps(callback) {\n    idbProxyTraps = callback(idbProxyTraps);\n}\nfunction wrapFunction(func) {\n    // Due to expected object equality (which is enforced by the caching in `wrap`), we\n    // only create one new func per func.\n    // Edge doesn't support objectStoreNames (booo), so we polyfill it here.\n    if (func === IDBDatabase.prototype.transaction &&\n        !('objectStoreNames' in IDBTransaction.prototype)) {\n        return function (storeNames, ...args) {\n            const tx = func.call(unwrap(this), storeNames, ...args);\n            transactionStoreNamesMap.set(tx, storeNames.sort ? storeNames.sort() : [storeNames]);\n            return wrap(tx);\n        };\n    }\n    // Cursor methods are special, as the behaviour is a little more different to standard IDB. In\n    // IDB, you advance the cursor and wait for a new 'success' on the IDBRequest that gave you the\n    // cursor. It's kinda like a promise that can resolve with many values. That doesn't make sense\n    // with real promises, so each advance methods returns a new promise for the cursor object, or\n    // undefined if the end of the cursor has been reached.\n    if (getCursorAdvanceMethods().includes(func)) {\n        return function (...args) {\n            // Calling the original function with the proxy as 'this' causes ILLEGAL INVOCATION, so we use\n            // the original object.\n            func.apply(unwrap(this), args);\n            return wrap(cursorRequestMap.get(this));\n        };\n    }\n    return function (...args) {\n        // Calling the original function with the proxy as 'this' causes ILLEGAL INVOCATION, so we use\n        // the original object.\n        return wrap(func.apply(unwrap(this), args));\n    };\n}\nfunction transformCachableValue(value) {\n    if (typeof value === 'function')\n        return wrapFunction(value);\n    // This doesn't return, it just creates a 'done' promise for the transaction,\n    // which is later returned for transaction.done (see idbObjectHandler).\n    if (value instanceof IDBTransaction)\n        cacheDonePromiseForTransaction(value);\n    if (instanceOfAny(value, getIdbProxyableTypes()))\n        return new Proxy(value, idbProxyTraps);\n    // Return the same value back if we're not going to transform it.\n    return value;\n}\nfunction wrap(value) {\n    // We sometimes generate multiple promises from a single IDBRequest (eg when cursoring), because\n    // IDB is weird and a single IDBRequest can yield many responses, so these can't be cached.\n    if (value instanceof IDBRequest)\n        return promisifyRequest(value);\n    // If we've already transformed this value before, reuse the transformed value.\n    // This is faster, but it also provides object equality.\n    if (transformCache.has(value))\n        return transformCache.get(value);\n    const newValue = transformCachableValue(value);\n    // Not all types are transformed.\n    // These may be primitive types, so they can't be WeakMap keys.\n    if (newValue !== value) {\n        transformCache.set(value, newValue);\n        reverseTransformCache.set(newValue, value);\n    }\n    return newValue;\n}\nconst unwrap = (value) => reverseTransformCache.get(value);\n\nexport { reverseTransformCache as a, instanceOfAny as i, replaceTraps as r, unwrap as u, wrap as w };\n","import { w as wrap, r as replaceTraps } from './wrap-idb-value.js';\nexport { u as unwrap, w as wrap } from './wrap-idb-value.js';\n\n/**\n * Open a database.\n *\n * @param name Name of the database.\n * @param version Schema version.\n * @param callbacks Additional callbacks.\n */\nfunction openDB(name, version, { blocked, upgrade, blocking, terminated } = {}) {\n    const request = indexedDB.open(name, version);\n    const openPromise = wrap(request);\n    if (upgrade) {\n        request.addEventListener('upgradeneeded', (event) => {\n            upgrade(wrap(request.result), event.oldVersion, event.newVersion, wrap(request.transaction), event);\n        });\n    }\n    if (blocked) {\n        request.addEventListener('blocked', (event) => blocked(\n        // Casting due to https://github.com/microsoft/TypeScript-DOM-lib-generator/pull/1405\n        event.oldVersion, event.newVersion, event));\n    }\n    openPromise\n        .then((db) => {\n        if (terminated)\n            db.addEventListener('close', () => terminated());\n        if (blocking) {\n            db.addEventListener('versionchange', (event) => blocking(event.oldVersion, event.newVersion, event));\n        }\n    })\n        .catch(() => { });\n    return openPromise;\n}\n/**\n * Delete a database.\n *\n * @param name Name of the database.\n */\nfunction deleteDB(name, { blocked } = {}) {\n    const request = indexedDB.deleteDatabase(name);\n    if (blocked) {\n        request.addEventListener('blocked', (event) => blocked(\n        // Casting due to https://github.com/microsoft/TypeScript-DOM-lib-generator/pull/1405\n        event.oldVersion, event));\n    }\n    return wrap(request).then(() => undefined);\n}\n\nconst readMethods = ['get', 'getKey', 'getAll', 'getAllKeys', 'count'];\nconst writeMethods = ['put', 'add', 'delete', 'clear'];\nconst cachedMethods = new Map();\nfunction getMethod(target, prop) {\n    if (!(target instanceof IDBDatabase &&\n        !(prop in target) &&\n        typeof prop === 'string')) {\n        return;\n    }\n    if (cachedMethods.get(prop))\n        return cachedMethods.get(prop);\n    const targetFuncName = prop.replace(/FromIndex$/, '');\n    const useIndex = prop !== targetFuncName;\n    const isWrite = writeMethods.includes(targetFuncName);\n    if (\n    // Bail if the target doesn't exist on the target. Eg, getAll isn't in Edge.\n    !(targetFuncName in (useIndex ? IDBIndex : IDBObjectStore).prototype) ||\n        !(isWrite || readMethods.includes(targetFuncName))) {\n        return;\n    }\n    const method = async function (storeName, ...args) {\n        // isWrite ? 'readwrite' : undefined gzipps better, but fails in Edge :(\n        const tx = this.transaction(storeName, isWrite ? 'readwrite' : 'readonly');\n        let target = tx.store;\n        if (useIndex)\n            target = target.index(args.shift());\n        // Must reject if op rejects.\n        // If it's a write operation, must reject if tx.done rejects.\n        // Must reject with op rejection first.\n        // Must resolve with op value.\n        // Must handle both promises (no unhandled rejections)\n        return (await Promise.all([\n            target[targetFuncName](...args),\n            isWrite && tx.done,\n        ]))[0];\n    };\n    cachedMethods.set(prop, method);\n    return method;\n}\nreplaceTraps((oldTraps) => ({\n    ...oldTraps,\n    get: (target, prop, receiver) => getMethod(target, prop) || oldTraps.get(target, prop, receiver),\n    has: (target, prop) => !!getMethod(target, prop) || oldTraps.has(target, prop),\n}));\n\nexport { deleteDB, openDB };\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  ComponentContainer,\n  ComponentType,\n  Provider,\n  Name\n} from '@firebase/component';\nimport { PlatformLoggerService, VersionService } from './types';\n\nexport class PlatformLoggerServiceImpl implements PlatformLoggerService {\n  constructor(private readonly container: ComponentContainer) {}\n  // In initial implementation, this will be called by installations on\n  // auth token refresh, and installations will send this string.\n  getPlatformInfoString(): string {\n    const providers = this.container.getProviders();\n    // Loop through providers and get library/version pairs from any that are\n    // version components.\n    return providers\n      .map(provider => {\n        if (isVersionServiceProvider(provider)) {\n          const service = provider.getImmediate() as VersionService;\n          return `${service.library}/${service.version}`;\n        } else {\n          return null;\n        }\n      })\n      .filter(logString => logString)\n      .join(' ');\n  }\n}\n/**\n *\n * @param provider check if this provider provides a VersionService\n *\n * NOTE: Using Provider<'app-version'> is a hack to indicate that the provider\n * provides VersionService. The provider is not necessarily a 'app-version'\n * provider.\n */\nfunction isVersionServiceProvider(provider: Provider<Name>): boolean {\n  const component = provider.getComponent();\n  return component?.type === ComponentType.VERSION;\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\nexport const DEFAULT_ENTRY_NAME = '[DEFAULT]';\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 { FirebaseApp } from './public-types';\nimport { Component, Provider, Name } from '@firebase/component';\nimport { logger } from './logger';\nimport { DEFAULT_ENTRY_NAME } from './constants';\nimport { FirebaseAppImpl } from './firebaseApp';\n\n/**\n * @internal\n */\nexport const _apps = new Map<string, FirebaseApp>();\n\n/**\n * Registered components.\n *\n * @internal\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport const _components = new Map<string, Component<any>>();\n\n/**\n * @param component - the component being added to this app's container\n *\n * @internal\n */\nexport function _addComponent<T extends Name>(\n  app: FirebaseApp,\n  component: Component<T>\n): void {\n  try {\n    (app as FirebaseAppImpl).container.addComponent(component);\n  } catch (e) {\n    logger.debug(\n      `Component ${component.name} failed to register with FirebaseApp ${app.name}`,\n      e\n    );\n  }\n}\n\n/**\n *\n * @internal\n */\nexport function _addOrOverwriteComponent(\n  app: FirebaseApp,\n  component: Component\n): void {\n  (app as FirebaseAppImpl).container.addOrOverwriteComponent(component);\n}\n\n/**\n *\n * @param component - the component to register\n * @returns whether or not the component is registered successfully\n *\n * @internal\n */\nexport function _registerComponent<T extends Name>(\n  component: Component<T>\n): boolean {\n  const componentName = component.name;\n  if (_components.has(componentName)) {\n    logger.debug(\n      `There were multiple attempts to register component ${componentName}.`\n    );\n\n    return false;\n  }\n\n  _components.set(componentName, component);\n\n  // add the component to existing app instances\n  for (const app of _apps.values()) {\n    _addComponent(app as FirebaseAppImpl, component);\n  }\n\n  return true;\n}\n\n/**\n *\n * @param app - FirebaseApp instance\n * @param name - service name\n *\n * @returns the provider for the service with the matching name\n *\n * @internal\n */\nexport function _getProvider<T extends Name>(\n  app: FirebaseApp,\n  name: T\n): Provider<T> {\n  const heartbeatController = (app as FirebaseAppImpl).container\n    .getProvider('heartbeat')\n    .getImmediate({ optional: true });\n  if (heartbeatController) {\n    void heartbeatController.triggerHeartbeat();\n  }\n  return (app as FirebaseAppImpl).container.getProvider(name);\n}\n\n/**\n *\n * @param app - FirebaseApp instance\n * @param name - service name\n * @param instanceIdentifier - service instance identifier in case the service supports multiple instances\n *\n * @internal\n */\nexport function _removeServiceInstance<T extends Name>(\n  app: FirebaseApp,\n  name: T,\n  instanceIdentifier: string = DEFAULT_ENTRY_NAME\n): void {\n  _getProvider(app, name).clearInstance(instanceIdentifier);\n}\n\n/**\n * Test only\n *\n * @internal\n */\nexport function _clearComponents(): void {\n  _components.clear();\n}\n\n/**\n * Exported in order to be used in app-compat package\n */\nexport { DEFAULT_ENTRY_NAME as _DEFAULT_ENTRY_NAME };\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 { FirebaseError } from '@firebase/util';\nimport { DBSchema, openDB, IDBPDatabase } from 'idb';\nimport { AppError, ERROR_FACTORY } from './errors';\nimport { FirebaseApp } from './public-types';\nimport { HeartbeatsInIndexedDB } from './types';\nimport { logger } from './logger';\n\nconst DB_NAME = 'firebase-heartbeat-database';\nconst DB_VERSION = 1;\nconst STORE_NAME = 'firebase-heartbeat-store';\n\ninterface AppDB extends DBSchema {\n  'firebase-heartbeat-store': {\n    key: string;\n    value: HeartbeatsInIndexedDB;\n  };\n}\n\nlet dbPromise: Promise<IDBPDatabase<AppDB>> | null = null;\nfunction getDbPromise(): Promise<IDBPDatabase<AppDB>> {\n  if (!dbPromise) {\n    dbPromise = openDB<AppDB>(DB_NAME, DB_VERSION, {\n      upgrade: (db, oldVersion) => {\n        // We don't use 'break' in this switch statement, the fall-through\n        // behavior is what we want, because if there are multiple versions between\n        // the old version and the current version, we want ALL the migrations\n        // that correspond to those versions to run, not only the last one.\n        // eslint-disable-next-line default-case\n        switch (oldVersion) {\n          case 0:\n            db.createObjectStore(STORE_NAME);\n        }\n      }\n    }).catch(e => {\n      throw ERROR_FACTORY.create(AppError.IDB_OPEN, {\n        originalErrorMessage: e.message\n      });\n    });\n  }\n  return dbPromise;\n}\n\nexport async function readHeartbeatsFromIndexedDB(\n  app: FirebaseApp\n): Promise<HeartbeatsInIndexedDB | undefined> {\n  try {\n    const db = await getDbPromise();\n    const result = await db\n      .transaction(STORE_NAME)\n      .objectStore(STORE_NAME)\n      .get(computeKey(app));\n    return result;\n  } catch (e) {\n    if (e instanceof FirebaseError) {\n      logger.warn(e.message);\n    } else {\n      const idbGetError = ERROR_FACTORY.create(AppError.IDB_GET, {\n        originalErrorMessage: (e as Error)?.message\n      });\n      logger.warn(idbGetError.message);\n    }\n  }\n}\n\nexport async function writeHeartbeatsToIndexedDB(\n  app: FirebaseApp,\n  heartbeatObject: HeartbeatsInIndexedDB\n): Promise<void> {\n  try {\n    const db = await getDbPromise();\n    const tx = db.transaction(STORE_NAME, 'readwrite');\n    const objectStore = tx.objectStore(STORE_NAME);\n    await objectStore.put(heartbeatObject, computeKey(app));\n    await tx.done;\n  } catch (e) {\n    if (e instanceof FirebaseError) {\n      logger.warn(e.message);\n    } else {\n      const idbGetError = ERROR_FACTORY.create(AppError.IDB_WRITE, {\n        originalErrorMessage: (e as Error)?.message\n      });\n      logger.warn(idbGetError.message);\n    }\n  }\n}\n\nfunction computeKey(app: FirebaseApp): string {\n  return `${app.name}!${app.options.appId}`;\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 { ComponentContainer } from '@firebase/component';\nimport {\n  base64urlEncodeWithoutPadding,\n  isIndexedDBAvailable,\n  validateIndexedDBOpenable\n} from '@firebase/util';\nimport {\n  readHeartbeatsFromIndexedDB,\n  writeHeartbeatsToIndexedDB\n} from './indexeddb';\nimport { FirebaseApp } from './public-types';\nimport {\n  HeartbeatsByUserAgent,\n  HeartbeatService,\n  HeartbeatsInIndexedDB,\n  HeartbeatStorage,\n  SingleDateHeartbeat\n} from './types';\n\nconst MAX_HEADER_BYTES = 1024;\n// 30 days\nconst STORED_HEARTBEAT_RETENTION_MAX_MILLIS = 30 * 24 * 60 * 60 * 1000;\n\nexport class HeartbeatServiceImpl implements HeartbeatService {\n  /**\n   * The persistence layer for heartbeats\n   * Leave public for easier testing.\n   */\n  _storage: HeartbeatStorageImpl;\n\n  /**\n   * In-memory cache for heartbeats, used by getHeartbeatsHeader() to generate\n   * the header string.\n   * Stores one record per date. This will be consolidated into the standard\n   * format of one record per user agent string before being sent as a header.\n   * Populated from indexedDB when the controller is instantiated and should\n   * be kept in sync with indexedDB.\n   * Leave public for easier testing.\n   */\n  _heartbeatsCache: HeartbeatsInIndexedDB | null = null;\n\n  /**\n   * the initialization promise for populating heartbeatCache.\n   * If getHeartbeatsHeader() is called before the promise resolves\n   * (hearbeatsCache == null), it should wait for this promise\n   * Leave public for easier testing.\n   */\n  _heartbeatsCachePromise: Promise<HeartbeatsInIndexedDB>;\n  constructor(private readonly container: ComponentContainer) {\n    const app = this.container.getProvider('app').getImmediate();\n    this._storage = new HeartbeatStorageImpl(app);\n    this._heartbeatsCachePromise = this._storage.read().then(result => {\n      this._heartbeatsCache = result;\n      return result;\n    });\n  }\n\n  /**\n   * Called to report a heartbeat. The function will generate\n   * a HeartbeatsByUserAgent object, update heartbeatsCache, and persist it\n   * to IndexedDB.\n   * Note that we only store one heartbeat per day. So if a heartbeat for today is\n   * already logged, subsequent calls to this function in the same day will be ignored.\n   */\n  async triggerHeartbeat(): Promise<void> {\n    const platformLogger = this.container\n      .getProvider('platform-logger')\n      .getImmediate();\n\n    // This is the \"Firebase user agent\" string from the platform logger\n    // service, not the browser user agent.\n    const agent = platformLogger.getPlatformInfoString();\n    const date = getUTCDateString();\n    if (this._heartbeatsCache === null) {\n      this._heartbeatsCache = await this._heartbeatsCachePromise;\n    }\n    // Do not store a heartbeat if one is already stored for this day\n    // or if a header has already been sent today.\n    if (\n      this._heartbeatsCache.lastSentHeartbeatDate === date ||\n      this._heartbeatsCache.heartbeats.some(\n        singleDateHeartbeat => singleDateHeartbeat.date === date\n      )\n    ) {\n      return;\n    } else {\n      // There is no entry for this date. Create one.\n      this._heartbeatsCache.heartbeats.push({ date, agent });\n    }\n    // Remove entries older than 30 days.\n    this._heartbeatsCache.heartbeats = this._heartbeatsCache.heartbeats.filter(\n      singleDateHeartbeat => {\n        const hbTimestamp = new Date(singleDateHeartbeat.date).valueOf();\n        const now = Date.now();\n        return now - hbTimestamp <= STORED_HEARTBEAT_RETENTION_MAX_MILLIS;\n      }\n    );\n    return this._storage.overwrite(this._heartbeatsCache);\n  }\n\n  /**\n   * Returns a base64 encoded string which can be attached to the heartbeat-specific header directly.\n   * It also clears all heartbeats from memory as well as in IndexedDB.\n   *\n   * NOTE: Consuming product SDKs should not send the header if this method\n   * returns an empty string.\n   */\n  async getHeartbeatsHeader(): Promise<string> {\n    if (this._heartbeatsCache === null) {\n      await this._heartbeatsCachePromise;\n    }\n    // If it's still null or the array is empty, there is no data to send.\n    if (\n      this._heartbeatsCache === null ||\n      this._heartbeatsCache.heartbeats.length === 0\n    ) {\n      return '';\n    }\n    const date = getUTCDateString();\n    // Extract as many heartbeats from the cache as will fit under the size limit.\n    const { heartbeatsToSend, unsentEntries } = extractHeartbeatsForHeader(\n      this._heartbeatsCache.heartbeats\n    );\n    const headerString = base64urlEncodeWithoutPadding(\n      JSON.stringify({ version: 2, heartbeats: heartbeatsToSend })\n    );\n    // Store last sent date to prevent another being logged/sent for the same day.\n    this._heartbeatsCache.lastSentHeartbeatDate = date;\n    if (unsentEntries.length > 0) {\n      // Store any unsent entries if they exist.\n      this._heartbeatsCache.heartbeats = unsentEntries;\n      // This seems more likely than emptying the array (below) to lead to some odd state\n      // since the cache isn't empty and this will be called again on the next request,\n      // and is probably safest if we await it.\n      await this._storage.overwrite(this._heartbeatsCache);\n    } else {\n      this._heartbeatsCache.heartbeats = [];\n      // Do not wait for this, to reduce latency.\n      void this._storage.overwrite(this._heartbeatsCache);\n    }\n    return headerString;\n  }\n}\n\nfunction getUTCDateString(): string {\n  const today = new Date();\n  // Returns date format 'YYYY-MM-DD'\n  return today.toISOString().substring(0, 10);\n}\n\nexport function extractHeartbeatsForHeader(\n  heartbeatsCache: SingleDateHeartbeat[],\n  maxSize = MAX_HEADER_BYTES\n): {\n  heartbeatsToSend: HeartbeatsByUserAgent[];\n  unsentEntries: SingleDateHeartbeat[];\n} {\n  // Heartbeats grouped by user agent in the standard format to be sent in\n  // the header.\n  const heartbeatsToSend: HeartbeatsByUserAgent[] = [];\n  // Single date format heartbeats that are not sent.\n  let unsentEntries = heartbeatsCache.slice();\n  for (const singleDateHeartbeat of heartbeatsCache) {\n    // Look for an existing entry with the same user agent.\n    const heartbeatEntry = heartbeatsToSend.find(\n      hb => hb.agent === singleDateHeartbeat.agent\n    );\n    if (!heartbeatEntry) {\n      // If no entry for this user agent exists, create one.\n      heartbeatsToSend.push({\n        agent: singleDateHeartbeat.agent,\n        dates: [singleDateHeartbeat.date]\n      });\n      if (countBytes(heartbeatsToSend) > maxSize) {\n        // If the header would exceed max size, remove the added heartbeat\n        // entry and stop adding to the header.\n        heartbeatsToSend.pop();\n        break;\n      }\n    } else {\n      heartbeatEntry.dates.push(singleDateHeartbeat.date);\n      // If the header would exceed max size, remove the added date\n      // and stop adding to the header.\n      if (countBytes(heartbeatsToSend) > maxSize) {\n        heartbeatEntry.dates.pop();\n        break;\n      }\n    }\n    // Pop unsent entry from queue. (Skipped if adding the entry exceeded\n    // quota and the loop breaks early.)\n    unsentEntries = unsentEntries.slice(1);\n  }\n  return {\n    heartbeatsToSend,\n    unsentEntries\n  };\n}\n\nexport class HeartbeatStorageImpl implements HeartbeatStorage {\n  private _canUseIndexedDBPromise: Promise<boolean>;\n  constructor(public app: FirebaseApp) {\n    this._canUseIndexedDBPromise = this.runIndexedDBEnvironmentCheck();\n  }\n  async runIndexedDBEnvironmentCheck(): Promise<boolean> {\n    if (!isIndexedDBAvailable()) {\n      return false;\n    } else {\n      return validateIndexedDBOpenable()\n        .then(() => true)\n        .catch(() => false);\n    }\n  }\n  /**\n   * Read all heartbeats.\n   */\n  async read(): Promise<HeartbeatsInIndexedDB> {\n    const canUseIndexedDB = await this._canUseIndexedDBPromise;\n    if (!canUseIndexedDB) {\n      return { heartbeats: [] };\n    } else {\n      const idbHeartbeatObject = await readHeartbeatsFromIndexedDB(this.app);\n      return idbHeartbeatObject || { heartbeats: [] };\n    }\n  }\n  // overwrite the storage with the provided heartbeats\n  async overwrite(heartbeatsObject: HeartbeatsInIndexedDB): Promise<void> {\n    const canUseIndexedDB = await this._canUseIndexedDBPromise;\n    if (!canUseIndexedDB) {\n      return;\n    } else {\n      const existingHeartbeatsObject = await this.read();\n      return writeHeartbeatsToIndexedDB(this.app, {\n        lastSentHeartbeatDate:\n          heartbeatsObject.lastSentHeartbeatDate ??\n          existingHeartbeatsObject.lastSentHeartbeatDate,\n        heartbeats: heartbeatsObject.heartbeats\n      });\n    }\n  }\n  // add heartbeats\n  async add(heartbeatsObject: HeartbeatsInIndexedDB): Promise<void> {\n    const canUseIndexedDB = await this._canUseIndexedDBPromise;\n    if (!canUseIndexedDB) {\n      return;\n    } else {\n      const existingHeartbeatsObject = await this.read();\n      return writeHeartbeatsToIndexedDB(this.app, {\n        lastSentHeartbeatDate:\n          heartbeatsObject.lastSentHeartbeatDate ??\n          existingHeartbeatsObject.lastSentHeartbeatDate,\n        heartbeats: [\n          ...existingHeartbeatsObject.heartbeats,\n          ...heartbeatsObject.heartbeats\n        ]\n      });\n    }\n  }\n}\n\n/**\n * Calculate bytes of a HeartbeatsByUserAgent array after being wrapped\n * in a platform logging header JSON object, stringified, and converted\n * to base 64.\n */\nexport function countBytes(heartbeatsCache: HeartbeatsByUserAgent[]): number {\n  // base64 has a restricted set of characters, all of which should be 1 byte.\n  return base64urlEncodeWithoutPadding(\n    // heartbeatsCache wrapper properties\n    JSON.stringify({ version: 2, heartbeats: heartbeatsCache })\n  ).length;\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 * as impl from '@firebase/auth/internal';\nimport {\n  getUA,\n  isBrowserExtension,\n  isReactNative,\n  isNode,\n  isIE,\n  isIndexedDBAvailable\n} from '@firebase/util';\n\ndeclare global {\n  interface Document {\n    documentMode?: number;\n  }\n}\n\nconst CORDOVA_ONDEVICEREADY_TIMEOUT_MS = 1000;\n\nfunction _getCurrentScheme(): string | null {\n  return self?.location?.protocol || null;\n}\n\n/**\n * @return {boolean} Whether the current environment is http or https.\n */\nfunction _isHttpOrHttps(): boolean {\n  return _getCurrentScheme() === 'http:' || _getCurrentScheme() === 'https:';\n}\n\n/**\n * @param {?string=} ua The user agent.\n * @return {boolean} Whether the app is rendered in a mobile iOS or Android\n *     Cordova environment.\n */\nexport function _isAndroidOrIosCordovaScheme(ua: string = getUA()): boolean {\n  return !!(\n    (_getCurrentScheme() === 'file:' ||\n      _getCurrentScheme() === 'ionic:' ||\n      _getCurrentScheme() === 'capacitor:') &&\n    ua.toLowerCase().match(/iphone|ipad|ipod|android/)\n  );\n}\n\n/**\n * @return {boolean} Whether the environment is a native environment, where\n *     CORS checks do not apply.\n */\nfunction _isNativeEnvironment(): boolean {\n  return isReactNative() || isNode();\n}\n\n/**\n * Checks whether the user agent is IE11.\n * @return {boolean} True if it is IE11.\n */\nfunction _isIe11(): boolean {\n  return isIE() && document?.documentMode === 11;\n}\n\n/**\n * Checks whether the user agent is Edge.\n * @param {string} userAgent The browser user agent string.\n * @return {boolean} True if it is Edge.\n */\nfunction _isEdge(ua: string = getUA()): boolean {\n  return /Edge\\/\\d+/.test(ua);\n}\n\n/**\n * @param {?string=} opt_userAgent The navigator user agent.\n * @return {boolean} Whether local storage is not synchronized between an iframe\n *     and a popup of the same domain.\n */\nfunction _isLocalStorageNotSynchronized(ua: string = getUA()): boolean {\n  return _isIe11() || _isEdge(ua);\n}\n\n/** @return {boolean} Whether web storage is supported. */\nexport function _isWebStorageSupported(): boolean {\n  try {\n    const storage = self.localStorage;\n    const key = impl._generateEventId();\n    if (storage) {\n      // setItem will throw an exception if we cannot access WebStorage (e.g.,\n      // Safari in private mode).\n      storage['setItem'](key, '1');\n      storage['removeItem'](key);\n      // For browsers where iframe web storage does not synchronize with a popup\n      // of the same domain, indexedDB is used for persistent storage. These\n      // browsers include IE11 and Edge.\n      // Make sure it is supported (IE11 and Edge private mode does not support\n      // that).\n      if (_isLocalStorageNotSynchronized()) {\n        // In such browsers, if indexedDB is not supported, an iframe cannot be\n        // notified of the popup sign in result.\n        return isIndexedDBAvailable();\n      }\n      return true;\n    }\n  } catch (e) {\n    // localStorage is not available from a worker. Test availability of\n    // indexedDB.\n    return _isWorker() && isIndexedDBAvailable();\n  }\n  return false;\n}\n\n/**\n * @param {?Object=} global The optional global scope.\n * @return {boolean} Whether current environment is a worker.\n */\nexport function _isWorker(): boolean {\n  // WorkerGlobalScope only defined in worker environment.\n  return (\n    typeof global !== 'undefined' &&\n    'WorkerGlobalScope' in global &&\n    'importScripts' in global\n  );\n}\n\nexport function _isPopupRedirectSupported(): boolean {\n  return (\n    (_isHttpOrHttps() ||\n      isBrowserExtension() ||\n      _isAndroidOrIosCordovaScheme()) &&\n    // React Native with remote debugging reports its location.protocol as\n    // http.\n    !_isNativeEnvironment() &&\n    // Local storage has to be supported for browser popup and redirect\n    // operations to work.\n    _isWebStorageSupported() &&\n    // DOM, popups and redirects are not supported within a worker.\n    !_isWorker()\n  );\n}\n\n/** Quick check that indicates the platform *may* be Cordova */\nexport function _isLikelyCordova(): boolean {\n  return _isAndroidOrIosCordovaScheme() && typeof document !== 'undefined';\n}\n\nexport async function _isCordova(): Promise<boolean> {\n  if (!_isLikelyCordova()) {\n    return false;\n  }\n\n  return new Promise(resolve => {\n    const timeoutId = setTimeout(() => {\n      // We've waited long enough; the telltale Cordova event didn't happen\n      resolve(false);\n    }, CORDOVA_ONDEVICEREADY_TIMEOUT_MS);\n\n    document.addEventListener('deviceready', () => {\n      clearTimeout(timeoutId);\n      resolve(true);\n    });\n  });\n}\n\nexport function _getSelfWindow(): Window | null {\n  return typeof window !== 'undefined' ? window : 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 * as exp from '@firebase/auth/internal';\nimport { isIndexedDBAvailable, isNode, isReactNative } from '@firebase/util';\nimport { _getSelfWindow, _isWebStorageSupported, _isWorker } from './platform';\n\nexport const Persistence = {\n  LOCAL: 'local',\n  NONE: 'none',\n  SESSION: 'session'\n};\n\nconst _assert: typeof exp._assert = exp._assert;\n\nconst PERSISTENCE_KEY = 'persistence';\n\n/**\n * Validates that an argument is a valid persistence value. If an invalid type\n * is specified, an error is thrown synchronously.\n */\nexport function _validatePersistenceArgument(\n  auth: exp.Auth,\n  persistence: string\n): void {\n  _assert(\n    Object.values(Persistence).includes(persistence),\n    auth,\n    exp.AuthErrorCode.INVALID_PERSISTENCE\n  );\n  // Validate if the specified type is supported in the current environment.\n  if (isReactNative()) {\n    // This is only supported in a browser.\n    _assert(\n      persistence !== Persistence.SESSION,\n      auth,\n      exp.AuthErrorCode.UNSUPPORTED_PERSISTENCE\n    );\n    return;\n  }\n  if (isNode()) {\n    // Only none is supported in Node.js.\n    _assert(\n      persistence === Persistence.NONE,\n      auth,\n      exp.AuthErrorCode.UNSUPPORTED_PERSISTENCE\n    );\n    return;\n  }\n  if (_isWorker()) {\n    // In a worker environment, either LOCAL or NONE are supported.\n    // If indexedDB not supported and LOCAL provided, throw an error\n    _assert(\n      persistence === Persistence.NONE ||\n        (persistence === Persistence.LOCAL && isIndexedDBAvailable()),\n      auth,\n      exp.AuthErrorCode.UNSUPPORTED_PERSISTENCE\n    );\n    return;\n  }\n  // This is restricted by what the browser supports.\n  _assert(\n    persistence === Persistence.NONE || _isWebStorageSupported(),\n    auth,\n    exp.AuthErrorCode.UNSUPPORTED_PERSISTENCE\n  );\n}\n\nexport async function _savePersistenceForRedirect(\n  auth: exp.AuthInternal\n): Promise<void> {\n  await auth._initializationPromise;\n  const session = getSessionStorageIfAvailable();\n  const key = exp._persistenceKeyName(\n    PERSISTENCE_KEY,\n    auth.config.apiKey,\n    auth.name\n  );\n  if (session) {\n    session.setItem(key, auth._getPersistence());\n  }\n}\n\nexport function _getPersistencesFromRedirect(\n  apiKey: string,\n  appName: string\n): exp.Persistence[] {\n  const session = getSessionStorageIfAvailable();\n  if (!session) {\n    return [];\n  }\n\n  const key = exp._persistenceKeyName(PERSISTENCE_KEY, apiKey, appName);\n  const persistence = session.getItem(key);\n\n  switch (persistence) {\n    case Persistence.NONE:\n      return [exp.inMemoryPersistence];\n    case Persistence.LOCAL:\n      return [exp.indexedDBLocalPersistence, exp.browserSessionPersistence];\n    case Persistence.SESSION:\n      return [exp.browserSessionPersistence];\n    default:\n      return [];\n  }\n}\n\n/** Returns session storage, or null if the property access errors */\nfunction getSessionStorageIfAvailable(): Storage | null {\n  try {\n    return _getSelfWindow()?.sessionStorage || null;\n  } catch (e) {\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 * as exp from '@firebase/auth/internal';\nimport { _isCordova, _isLikelyCordova } from './platform';\n\nconst _assert: typeof exp._assert = exp._assert;\n\n/** Platform-agnostic popup-redirect resolver */\nexport class CompatPopupRedirectResolver\n  implements exp.PopupRedirectResolverInternal\n{\n  // Create both resolvers for dynamic resolution later\n  private readonly browserResolver: exp.PopupRedirectResolverInternal =\n    exp._getInstance(exp.browserPopupRedirectResolver);\n  private readonly cordovaResolver: exp.PopupRedirectResolverInternal =\n    exp._getInstance(exp.cordovaPopupRedirectResolver);\n  // The actual resolver in use: either browserResolver or cordovaResolver.\n  private underlyingResolver: exp.PopupRedirectResolverInternal | null = null;\n  _redirectPersistence = exp.browserSessionPersistence;\n\n  _completeRedirectFn: (\n    auth: exp.Auth,\n    resolver: exp.PopupRedirectResolver,\n    bypassAuthState: boolean\n  ) => Promise<exp.UserCredential | null> = exp._getRedirectResult;\n  _overrideRedirectResult = exp._overrideRedirectResult;\n\n  async _initialize(auth: exp.AuthImpl): Promise<exp.EventManager> {\n    await this.selectUnderlyingResolver();\n    return this.assertedUnderlyingResolver._initialize(auth);\n  }\n\n  async _openPopup(\n    auth: exp.AuthImpl,\n    provider: exp.AuthProvider,\n    authType: exp.AuthEventType,\n    eventId?: string\n  ): Promise<exp.AuthPopup> {\n    await this.selectUnderlyingResolver();\n    return this.assertedUnderlyingResolver._openPopup(\n      auth,\n      provider,\n      authType,\n      eventId\n    );\n  }\n\n  async _openRedirect(\n    auth: exp.AuthImpl,\n    provider: exp.AuthProvider,\n    authType: exp.AuthEventType,\n    eventId?: string\n  ): Promise<void> {\n    await this.selectUnderlyingResolver();\n    return this.assertedUnderlyingResolver._openRedirect(\n      auth,\n      provider,\n      authType,\n      eventId\n    );\n  }\n\n  _isIframeWebStorageSupported(\n    auth: exp.AuthImpl,\n    cb: (support: boolean) => unknown\n  ): void {\n    this.assertedUnderlyingResolver._isIframeWebStorageSupported(auth, cb);\n  }\n\n  _originValidation(auth: exp.Auth): Promise<void> {\n    return this.assertedUnderlyingResolver._originValidation(auth);\n  }\n\n  get _shouldInitProactively(): boolean {\n    return _isLikelyCordova() || this.browserResolver._shouldInitProactively;\n  }\n\n  private get assertedUnderlyingResolver(): exp.PopupRedirectResolverInternal {\n    _assert(this.underlyingResolver, exp.AuthErrorCode.INTERNAL_ERROR);\n    return this.underlyingResolver;\n  }\n\n  private async selectUnderlyingResolver(): Promise<void> {\n    if (this.underlyingResolver) {\n      return;\n    }\n\n    // We haven't yet determined whether or not we're in Cordova; go ahead\n    // and determine that state now.\n    const isCordova = await _isCordova();\n    this.underlyingResolver = isCordova\n      ? this.cordovaResolver\n      : this.browserResolver;\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/** Forward direction wrapper from Compat --unwrap-> Exp */\nexport interface Wrapper<T> {\n  unwrap(): T;\n}\n\n/** Reverse direction wrapper from Exp --wrapped--> Compat */\nexport interface ReverseWrapper<T> {\n  wrapped(): T;\n}\n\nexport function unwrap<T>(object: unknown): T {\n  return (object as Wrapper<T>).unwrap();\n}\n\nexport function wrapped<T>(object: unknown): T {\n  return (object as ReverseWrapper<T>).wrapped();\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 * as exp from '@firebase/auth/internal';\nimport * as compat from '@firebase/auth-types';\nimport { FirebaseError } from '@firebase/util';\nimport { Auth } from './auth';\nimport { User } from './user';\nimport { unwrap, wrapped } from './wrap';\n\nfunction credentialFromResponse(\n  userCredential: exp.UserCredentialInternal\n): exp.AuthCredential | null {\n  return credentialFromObject(userCredential);\n}\n\nfunction attachExtraErrorFields(auth: exp.Auth, e: FirebaseError): void {\n  // The response contains all fields from the server which may or may not\n  // actually match the underlying type\n  const response = (e.customData as exp.TaggedWithTokenResponse | undefined)\n    ?._tokenResponse as unknown as Record<string, string>;\n  if ((e as FirebaseError)?.code === 'auth/multi-factor-auth-required') {\n    const mfaErr = e as compat.MultiFactorError;\n    mfaErr.resolver = new MultiFactorResolver(\n      auth,\n      exp.getMultiFactorResolver(auth, e as exp.MultiFactorError)\n    );\n  } else if (response) {\n    const credential = credentialFromObject(e);\n    const credErr = e as compat.AuthError;\n    if (credential) {\n      credErr.credential = credential;\n      credErr.tenantId = response.tenantId || undefined;\n      credErr.email = response.email || undefined;\n      credErr.phoneNumber = response.phoneNumber || undefined;\n    }\n  }\n}\n\nfunction credentialFromObject(\n  object: FirebaseError | exp.UserCredential\n): exp.AuthCredential | null {\n  const { _tokenResponse } = (\n    object instanceof FirebaseError ? object.customData : object\n  ) as exp.TaggedWithTokenResponse;\n  if (!_tokenResponse) {\n    return null;\n  }\n\n  // Handle phone Auth credential responses, as they have a different format\n  // from other backend responses (i.e. no providerId). This is also only the\n  // case for user credentials (does not work for errors).\n  if (!(object instanceof FirebaseError)) {\n    if ('temporaryProof' in _tokenResponse && 'phoneNumber' in _tokenResponse) {\n      return exp.PhoneAuthProvider.credentialFromResult(object);\n    }\n  }\n\n  const providerId = _tokenResponse.providerId;\n\n  // Email and password is not supported as there is no situation where the\n  // server would return the password to the client.\n  if (!providerId || providerId === exp.ProviderId.PASSWORD) {\n    return null;\n  }\n\n  let provider: Pick<\n    typeof exp.OAuthProvider,\n    'credentialFromResult' | 'credentialFromError'\n  >;\n  switch (providerId) {\n    case exp.ProviderId.GOOGLE:\n      provider = exp.GoogleAuthProvider;\n      break;\n    case exp.ProviderId.FACEBOOK:\n      provider = exp.FacebookAuthProvider;\n      break;\n    case exp.ProviderId.GITHUB:\n      provider = exp.GithubAuthProvider;\n      break;\n    case exp.ProviderId.TWITTER:\n      provider = exp.TwitterAuthProvider;\n      break;\n    default:\n      const {\n        oauthIdToken,\n        oauthAccessToken,\n        oauthTokenSecret,\n        pendingToken,\n        nonce\n      } = _tokenResponse as exp.SignInWithIdpResponse;\n      if (\n        !oauthAccessToken &&\n        !oauthTokenSecret &&\n        !oauthIdToken &&\n        !pendingToken\n      ) {\n        return null;\n      }\n      // TODO(avolkovi): uncomment this and get it working with SAML & OIDC\n      if (pendingToken) {\n        if (providerId.startsWith('saml.')) {\n          return exp.SAMLAuthCredential._create(providerId, pendingToken);\n        } else {\n          // OIDC and non-default providers excluding Twitter.\n          return exp.OAuthCredential._fromParams({\n            providerId,\n            signInMethod: providerId,\n            pendingToken,\n            idToken: oauthIdToken,\n            accessToken: oauthAccessToken\n          });\n        }\n      }\n      return new exp.OAuthProvider(providerId).credential({\n        idToken: oauthIdToken,\n        accessToken: oauthAccessToken,\n        rawNonce: nonce\n      });\n  }\n\n  return object instanceof FirebaseError\n    ? provider.credentialFromError(object)\n    : provider.credentialFromResult(object);\n}\n\nexport function convertCredential(\n  auth: exp.Auth,\n  credentialPromise: Promise<exp.UserCredential>\n): Promise<compat.UserCredential> {\n  return credentialPromise\n    .catch(e => {\n      if (e instanceof FirebaseError) {\n        attachExtraErrorFields(auth, e);\n      }\n      throw e;\n    })\n    .then(credential => {\n      const operationType = credential.operationType;\n      const user = credential.user;\n\n      return {\n        operationType,\n        credential: credentialFromResponse(\n          credential as exp.UserCredentialInternal\n        ),\n        additionalUserInfo: exp.getAdditionalUserInfo(\n          credential as exp.UserCredential\n        ),\n        user: User.getOrCreate(user)\n      };\n    });\n}\n\nexport async function convertConfirmationResult(\n  auth: exp.Auth,\n  confirmationResultPromise: Promise<exp.ConfirmationResult>\n): Promise<compat.ConfirmationResult> {\n  const confirmationResultExp = await confirmationResultPromise;\n  return {\n    verificationId: confirmationResultExp.verificationId,\n    confirm: (verificationCode: string) =>\n      convertCredential(auth, confirmationResultExp.confirm(verificationCode))\n  };\n}\n\nclass MultiFactorResolver implements compat.MultiFactorResolver {\n  readonly auth: Auth;\n  constructor(\n    auth: exp.Auth,\n    private readonly resolver: exp.MultiFactorResolver\n  ) {\n    this.auth = wrapped(auth);\n  }\n\n  get session(): compat.MultiFactorSession {\n    return this.resolver.session;\n  }\n\n  get hints(): compat.MultiFactorInfo[] {\n    return this.resolver.hints;\n  }\n\n  resolveSignIn(\n    assertion: compat.MultiFactorAssertion\n  ): Promise<compat.UserCredential> {\n    return convertCredential(\n      unwrap(this.auth),\n      this.resolver.resolveSignIn(assertion as exp.MultiFactorAssertion)\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 * as exp from '@firebase/auth/internal';\nimport * as compat from '@firebase/auth-types';\nimport { Compat } from '@firebase/util';\nimport { _savePersistenceForRedirect } from './persistence';\nimport { CompatPopupRedirectResolver } from './popup_redirect';\nimport {\n  convertConfirmationResult,\n  convertCredential\n} from './user_credential';\n\nexport class User implements compat.User, Compat<exp.User> {\n  // Maintain a map so that there's always a 1:1 mapping between new User and\n  // legacy compat users\n  private static readonly USER_MAP = new WeakMap<exp.User, User>();\n\n  readonly multiFactor: compat.MultiFactorUser;\n\n  private constructor(readonly _delegate: exp.User) {\n    this.multiFactor = exp.multiFactor(_delegate);\n  }\n\n  static getOrCreate(user: exp.User): User {\n    if (!User.USER_MAP.has(user)) {\n      User.USER_MAP.set(user, new User(user));\n    }\n\n    return User.USER_MAP.get(user)!;\n  }\n\n  delete(): Promise<void> {\n    return this._delegate.delete();\n  }\n  reload(): Promise<void> {\n    return this._delegate.reload();\n  }\n  toJSON(): object {\n    return this._delegate.toJSON();\n  }\n  getIdTokenResult(forceRefresh?: boolean): Promise<compat.IdTokenResult> {\n    return this._delegate.getIdTokenResult(forceRefresh);\n  }\n  getIdToken(forceRefresh?: boolean): Promise<string> {\n    return this._delegate.getIdToken(forceRefresh);\n  }\n  linkAndRetrieveDataWithCredential(\n    credential: compat.AuthCredential\n  ): Promise<compat.UserCredential> {\n    return this.linkWithCredential(credential);\n  }\n  async linkWithCredential(\n    credential: compat.AuthCredential\n  ): Promise<compat.UserCredential> {\n    return convertCredential(\n      this.auth,\n      exp.linkWithCredential(this._delegate, credential as exp.AuthCredential)\n    );\n  }\n  async linkWithPhoneNumber(\n    phoneNumber: string,\n    applicationVerifier: compat.ApplicationVerifier\n  ): Promise<compat.ConfirmationResult> {\n    return convertConfirmationResult(\n      this.auth,\n      exp.linkWithPhoneNumber(this._delegate, phoneNumber, applicationVerifier)\n    );\n  }\n  async linkWithPopup(\n    provider: compat.AuthProvider\n  ): Promise<compat.UserCredential> {\n    return convertCredential(\n      this.auth,\n      exp.linkWithPopup(\n        this._delegate,\n        provider as exp.AuthProvider,\n        CompatPopupRedirectResolver\n      )\n    );\n  }\n  async linkWithRedirect(provider: compat.AuthProvider): Promise<void> {\n    await _savePersistenceForRedirect(exp._castAuth(this.auth));\n    return exp.linkWithRedirect(\n      this._delegate,\n      provider as exp.AuthProvider,\n      CompatPopupRedirectResolver\n    );\n  }\n  reauthenticateAndRetrieveDataWithCredential(\n    credential: compat.AuthCredential\n  ): Promise<compat.UserCredential> {\n    return this.reauthenticateWithCredential(credential);\n  }\n  async reauthenticateWithCredential(\n    credential: compat.AuthCredential\n  ): Promise<compat.UserCredential> {\n    return convertCredential(\n      this.auth as unknown as exp.Auth,\n      exp.reauthenticateWithCredential(\n        this._delegate,\n        credential as exp.AuthCredential\n      )\n    );\n  }\n  reauthenticateWithPhoneNumber(\n    phoneNumber: string,\n    applicationVerifier: compat.ApplicationVerifier\n  ): Promise<compat.ConfirmationResult> {\n    return convertConfirmationResult(\n      this.auth,\n      exp.reauthenticateWithPhoneNumber(\n        this._delegate,\n        phoneNumber,\n        applicationVerifier\n      )\n    );\n  }\n  reauthenticateWithPopup(\n    provider: compat.AuthProvider\n  ): Promise<compat.UserCredential> {\n    return convertCredential(\n      this.auth,\n      exp.reauthenticateWithPopup(\n        this._delegate,\n        provider as exp.AuthProvider,\n        CompatPopupRedirectResolver\n      )\n    );\n  }\n  async reauthenticateWithRedirect(\n    provider: compat.AuthProvider\n  ): Promise<void> {\n    await _savePersistenceForRedirect(exp._castAuth(this.auth));\n    return exp.reauthenticateWithRedirect(\n      this._delegate,\n      provider as exp.AuthProvider,\n      CompatPopupRedirectResolver\n    );\n  }\n  sendEmailVerification(\n    actionCodeSettings?: compat.ActionCodeSettings | null\n  ): Promise<void> {\n    return exp.sendEmailVerification(this._delegate, actionCodeSettings);\n  }\n  async unlink(providerId: string): Promise<compat.User> {\n    await exp.unlink(this._delegate, providerId);\n    return this;\n  }\n  updateEmail(newEmail: string): Promise<void> {\n    return exp.updateEmail(this._delegate, newEmail);\n  }\n  updatePassword(newPassword: string): Promise<void> {\n    return exp.updatePassword(this._delegate, newPassword);\n  }\n  updatePhoneNumber(phoneCredential: compat.AuthCredential): Promise<void> {\n    return exp.updatePhoneNumber(\n      this._delegate,\n      phoneCredential as exp.PhoneAuthCredential\n    );\n  }\n  updateProfile(profile: {\n    displayName?: string | null;\n    photoURL?: string | null;\n  }): Promise<void> {\n    return exp.updateProfile(this._delegate, profile);\n  }\n  verifyBeforeUpdateEmail(\n    newEmail: string,\n    actionCodeSettings?: compat.ActionCodeSettings | null\n  ): Promise<void> {\n    return exp.verifyBeforeUpdateEmail(\n      this._delegate,\n      newEmail,\n      actionCodeSettings\n    );\n  }\n  get emailVerified(): boolean {\n    return this._delegate.emailVerified;\n  }\n  get isAnonymous(): boolean {\n    return this._delegate.isAnonymous;\n  }\n  get metadata(): compat.UserMetadata {\n    return this._delegate.metadata;\n  }\n  get phoneNumber(): string | null {\n    return this._delegate.phoneNumber;\n  }\n  get providerData(): Array<compat.UserInfo | null> {\n    return this._delegate.providerData;\n  }\n  get refreshToken(): string {\n    return this._delegate.refreshToken;\n  }\n  get tenantId(): string | null {\n    return this._delegate.tenantId;\n  }\n  get displayName(): string | null {\n    return this._delegate.displayName;\n  }\n  get email(): string | null {\n    return this._delegate.email;\n  }\n  get photoURL(): string | null {\n    return this._delegate.photoURL;\n  }\n  get providerId(): string {\n    return this._delegate.providerId;\n  }\n  get uid(): string {\n    return this._delegate.uid;\n  }\n  private get auth(): exp.Auth {\n    return (this._delegate as exp.UserImpl).auth as unknown as exp.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 { FirebaseApp, _FirebaseService } from '@firebase/app-compat';\nimport * as exp from '@firebase/auth/internal';\nimport * as compat from '@firebase/auth-types';\nimport { Provider } from '@firebase/component';\nimport { ErrorFn, Observer, Unsubscribe } from '@firebase/util';\n\nimport {\n  _validatePersistenceArgument,\n  Persistence,\n  _getPersistencesFromRedirect,\n  _savePersistenceForRedirect\n} from './persistence';\nimport { _isPopupRedirectSupported } from './platform';\nimport { CompatPopupRedirectResolver } from './popup_redirect';\nimport { User } from './user';\nimport {\n  convertConfirmationResult,\n  convertCredential\n} from './user_credential';\nimport { ReverseWrapper, Wrapper } from './wrap';\n\nconst _assert: typeof exp._assert = exp._assert;\n\nexport class Auth\n  implements compat.FirebaseAuth, Wrapper<exp.Auth>, _FirebaseService\n{\n  static Persistence = Persistence;\n  readonly _delegate: exp.AuthImpl;\n\n  constructor(readonly app: FirebaseApp, provider: Provider<'auth'>) {\n    if (provider.isInitialized()) {\n      this._delegate = provider.getImmediate() as exp.AuthImpl;\n      this.linkUnderlyingAuth();\n      return;\n    }\n\n    const { apiKey } = app.options;\n    // TODO: platform needs to be determined using heuristics\n    _assert(apiKey, exp.AuthErrorCode.INVALID_API_KEY, {\n      appName: app.name\n    });\n\n    // TODO: platform needs to be determined using heuristics\n    _assert(apiKey, exp.AuthErrorCode.INVALID_API_KEY, {\n      appName: app.name\n    });\n\n    // Only use a popup/redirect resolver in browser environments\n    const resolver =\n      typeof window !== 'undefined' ? CompatPopupRedirectResolver : undefined;\n    this._delegate = provider.initialize({\n      options: {\n        persistence: buildPersistenceHierarchy(apiKey, app.name),\n        popupRedirectResolver: resolver\n      }\n    }) as exp.AuthImpl;\n\n    this._delegate._updateErrorMap(exp.debugErrorMap);\n    this.linkUnderlyingAuth();\n  }\n\n  get emulatorConfig(): compat.EmulatorConfig | null {\n    return this._delegate.emulatorConfig;\n  }\n\n  get currentUser(): compat.User | null {\n    if (!this._delegate.currentUser) {\n      return null;\n    }\n\n    return User.getOrCreate(this._delegate.currentUser);\n  }\n  get languageCode(): string | null {\n    return this._delegate.languageCode;\n  }\n  set languageCode(languageCode: string | null) {\n    this._delegate.languageCode = languageCode;\n  }\n  get settings(): compat.AuthSettings {\n    return this._delegate.settings;\n  }\n  get tenantId(): string | null {\n    return this._delegate.tenantId;\n  }\n  set tenantId(tid: string | null) {\n    this._delegate.tenantId = tid;\n  }\n  useDeviceLanguage(): void {\n    this._delegate.useDeviceLanguage();\n  }\n  signOut(): Promise<void> {\n    return this._delegate.signOut();\n  }\n  useEmulator(url: string, options?: { disableWarnings: boolean }): void {\n    exp.connectAuthEmulator(this._delegate, url, options);\n  }\n  applyActionCode(code: string): Promise<void> {\n    return exp.applyActionCode(this._delegate, code);\n  }\n\n  checkActionCode(code: string): Promise<compat.ActionCodeInfo> {\n    return exp.checkActionCode(this._delegate, code);\n  }\n\n  confirmPasswordReset(code: string, newPassword: string): Promise<void> {\n    return exp.confirmPasswordReset(this._delegate, code, newPassword);\n  }\n\n  async createUserWithEmailAndPassword(\n    email: string,\n    password: string\n  ): Promise<compat.UserCredential> {\n    return convertCredential(\n      this._delegate,\n      exp.createUserWithEmailAndPassword(this._delegate, email, password)\n    );\n  }\n  fetchProvidersForEmail(email: string): Promise<string[]> {\n    return this.fetchSignInMethodsForEmail(email);\n  }\n  fetchSignInMethodsForEmail(email: string): Promise<string[]> {\n    return exp.fetchSignInMethodsForEmail(this._delegate, email);\n  }\n  isSignInWithEmailLink(emailLink: string): boolean {\n    return exp.isSignInWithEmailLink(this._delegate, emailLink);\n  }\n  async getRedirectResult(): Promise<compat.UserCredential> {\n    _assert(\n      _isPopupRedirectSupported(),\n      this._delegate,\n      exp.AuthErrorCode.OPERATION_NOT_SUPPORTED\n    );\n    const credential = await exp.getRedirectResult(\n      this._delegate,\n      CompatPopupRedirectResolver\n    );\n    if (!credential) {\n      return {\n        credential: null,\n        user: null\n      };\n    }\n    return convertCredential(this._delegate, Promise.resolve(credential));\n  }\n\n  // This function should only be called by frameworks (e.g. FirebaseUI-web) to log their usage.\n  // It is not intended for direct use by developer apps. NO jsdoc here to intentionally leave it\n  // out of autogenerated documentation pages to reduce accidental misuse.\n  addFrameworkForLogging(framework: string): void {\n    exp.addFrameworkForLogging(this._delegate, framework);\n  }\n\n  onAuthStateChanged(\n    nextOrObserver: Observer<unknown> | ((a: compat.User | null) => unknown),\n    errorFn?: (error: compat.Error) => unknown,\n    completed?: Unsubscribe\n  ): Unsubscribe {\n    const { next, error, complete } = wrapObservers(\n      nextOrObserver,\n      errorFn,\n      completed\n    );\n    return this._delegate.onAuthStateChanged(next!, error, complete);\n  }\n  onIdTokenChanged(\n    nextOrObserver: Observer<unknown> | ((a: compat.User | null) => unknown),\n    errorFn?: (error: compat.Error) => unknown,\n    completed?: Unsubscribe\n  ): Unsubscribe {\n    const { next, error, complete } = wrapObservers(\n      nextOrObserver,\n      errorFn,\n      completed\n    );\n    return this._delegate.onIdTokenChanged(next!, error, complete);\n  }\n  sendSignInLinkToEmail(\n    email: string,\n    actionCodeSettings: compat.ActionCodeSettings\n  ): Promise<void> {\n    return exp.sendSignInLinkToEmail(this._delegate, email, actionCodeSettings);\n  }\n  sendPasswordResetEmail(\n    email: string,\n    actionCodeSettings?: compat.ActionCodeSettings | null\n  ): Promise<void> {\n    return exp.sendPasswordResetEmail(\n      this._delegate,\n      email,\n      actionCodeSettings || undefined\n    );\n  }\n  async setPersistence(persistence: string): Promise<void> {\n    _validatePersistenceArgument(this._delegate, persistence);\n    let converted;\n    switch (persistence) {\n      case Persistence.SESSION:\n        converted = exp.browserSessionPersistence;\n        break;\n      case Persistence.LOCAL:\n        // Not using isIndexedDBAvailable() since it only checks if indexedDB is defined.\n        const isIndexedDBFullySupported = await exp\n          ._getInstance<exp.PersistenceInternal>(exp.indexedDBLocalPersistence)\n          ._isAvailable();\n        converted = isIndexedDBFullySupported\n          ? exp.indexedDBLocalPersistence\n          : exp.browserLocalPersistence;\n        break;\n      case Persistence.NONE:\n        converted = exp.inMemoryPersistence;\n        break;\n      default:\n        return exp._fail(exp.AuthErrorCode.ARGUMENT_ERROR, {\n          appName: this._delegate.name\n        });\n    }\n\n    return this._delegate.setPersistence(converted);\n  }\n\n  signInAndRetrieveDataWithCredential(\n    credential: compat.AuthCredential\n  ): Promise<compat.UserCredential> {\n    return this.signInWithCredential(credential);\n  }\n  signInAnonymously(): Promise<compat.UserCredential> {\n    return convertCredential(\n      this._delegate,\n      exp.signInAnonymously(this._delegate)\n    );\n  }\n  signInWithCredential(\n    credential: compat.AuthCredential\n  ): Promise<compat.UserCredential> {\n    return convertCredential(\n      this._delegate,\n      exp.signInWithCredential(this._delegate, credential as exp.AuthCredential)\n    );\n  }\n  signInWithCustomToken(token: string): Promise<compat.UserCredential> {\n    return convertCredential(\n      this._delegate,\n      exp.signInWithCustomToken(this._delegate, token)\n    );\n  }\n  signInWithEmailAndPassword(\n    email: string,\n    password: string\n  ): Promise<compat.UserCredential> {\n    return convertCredential(\n      this._delegate,\n      exp.signInWithEmailAndPassword(this._delegate, email, password)\n    );\n  }\n  signInWithEmailLink(\n    email: string,\n    emailLink?: string\n  ): Promise<compat.UserCredential> {\n    return convertCredential(\n      this._delegate,\n      exp.signInWithEmailLink(this._delegate, email, emailLink)\n    );\n  }\n  signInWithPhoneNumber(\n    phoneNumber: string,\n    applicationVerifier: compat.ApplicationVerifier\n  ): Promise<compat.ConfirmationResult> {\n    return convertConfirmationResult(\n      this._delegate,\n      exp.signInWithPhoneNumber(\n        this._delegate,\n        phoneNumber,\n        applicationVerifier\n      )\n    );\n  }\n  async signInWithPopup(\n    provider: compat.AuthProvider\n  ): Promise<compat.UserCredential> {\n    _assert(\n      _isPopupRedirectSupported(),\n      this._delegate,\n      exp.AuthErrorCode.OPERATION_NOT_SUPPORTED\n    );\n    return convertCredential(\n      this._delegate,\n      exp.signInWithPopup(\n        this._delegate,\n        provider as exp.AuthProvider,\n        CompatPopupRedirectResolver\n      )\n    );\n  }\n  async signInWithRedirect(provider: compat.AuthProvider): Promise<void> {\n    _assert(\n      _isPopupRedirectSupported(),\n      this._delegate,\n      exp.AuthErrorCode.OPERATION_NOT_SUPPORTED\n    );\n\n    await _savePersistenceForRedirect(this._delegate);\n    return exp.signInWithRedirect(\n      this._delegate,\n      provider as exp.AuthProvider,\n      CompatPopupRedirectResolver\n    );\n  }\n  updateCurrentUser(user: compat.User | null): Promise<void> {\n    // remove ts-ignore once overloads are defined for exp functions to accept compat objects\n    // @ts-ignore\n    return this._delegate.updateCurrentUser(user);\n  }\n  verifyPasswordResetCode(code: string): Promise<string> {\n    return exp.verifyPasswordResetCode(this._delegate, code);\n  }\n  unwrap(): exp.Auth {\n    return this._delegate;\n  }\n  _delete(): Promise<void> {\n    return this._delegate._delete();\n  }\n  private linkUnderlyingAuth(): void {\n    (this._delegate as unknown as ReverseWrapper<Auth>).wrapped = () => this;\n  }\n}\n\nfunction wrapObservers(\n  nextOrObserver: Observer<unknown> | ((a: compat.User | null) => unknown),\n  error?: (error: compat.Error) => unknown,\n  complete?: Unsubscribe\n): Partial<Observer<exp.User | null>> {\n  let next = nextOrObserver;\n  if (typeof nextOrObserver !== 'function') {\n    ({ next, error, complete } = nextOrObserver);\n  }\n\n  // We know 'next' is now a function\n  const oldNext = next as (a: compat.User | null) => unknown;\n\n  const newNext = (user: exp.User | null): unknown =>\n    oldNext(user && User.getOrCreate(user as exp.User));\n  return {\n    next: newNext,\n    error: error as ErrorFn,\n    complete\n  };\n}\n\nfunction buildPersistenceHierarchy(\n  apiKey: string,\n  appName: string\n): exp.Persistence[] {\n  // Note this is slightly different behavior: in this case, the stored\n  // persistence is checked *first* rather than last. This is because we want\n  // to prefer stored persistence type in the hierarchy. This is an empty\n  // array if window is not available or there is no pending redirect\n  const persistences = _getPersistencesFromRedirect(apiKey, appName);\n\n  // If \"self\" is available, add indexedDB\n  if (\n    typeof self !== 'undefined' &&\n    !persistences.includes(exp.indexedDBLocalPersistence)\n  ) {\n    persistences.push(exp.indexedDBLocalPersistence);\n  }\n\n  // If \"window\" is available, add HTML Storage persistences\n  if (typeof window !== 'undefined') {\n    for (const persistence of [\n      exp.browserLocalPersistence,\n      exp.browserSessionPersistence\n    ]) {\n      if (!persistences.includes(persistence)) {\n        persistences.push(persistence);\n      }\n    }\n  }\n\n  // Add in-memory as a final fallback\n  if (!persistences.includes(exp.inMemoryPersistence)) {\n    persistences.push(exp.inMemoryPersistence);\n  }\n\n  return persistences;\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 * as exp from '@firebase/auth/internal';\nimport * as compat from '@firebase/auth-types';\nimport firebase from '@firebase/app-compat';\nimport { Compat } from '@firebase/util';\nimport { unwrap } from './wrap';\n\nexport class PhoneAuthProvider\n  implements compat.PhoneAuthProvider, Compat<exp.PhoneAuthProvider>\n{\n  providerId = 'phone';\n  readonly _delegate: exp.PhoneAuthProvider;\n\n  static PHONE_SIGN_IN_METHOD = exp.PhoneAuthProvider.PHONE_SIGN_IN_METHOD;\n  static PROVIDER_ID = exp.PhoneAuthProvider.PROVIDER_ID;\n\n  static credential(\n    verificationId: string,\n    verificationCode: string\n  ): compat.AuthCredential {\n    return exp.PhoneAuthProvider.credential(verificationId, verificationCode);\n  }\n\n  constructor() {\n    // TODO: remove ts-ignore when moving types from auth-types to auth-compat\n    // @ts-ignore\n    this._delegate = new exp.PhoneAuthProvider(unwrap(firebase.auth!()));\n  }\n\n  verifyPhoneNumber(\n    phoneInfoOptions:\n      | string\n      | compat.PhoneSingleFactorInfoOptions\n      | compat.PhoneMultiFactorEnrollInfoOptions\n      | compat.PhoneMultiFactorSignInInfoOptions,\n    applicationVerifier: compat.ApplicationVerifier\n  ): Promise<string> {\n    return this._delegate.verifyPhoneNumber(\n      // The implementation matches but the types are subtly incompatible\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      phoneInfoOptions as any,\n      applicationVerifier\n    );\n  }\n\n  unwrap(): exp.PhoneAuthProvider {\n    return this._delegate;\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 firebase, { FirebaseApp } from '@firebase/app-compat';\nimport * as exp from '@firebase/auth/internal';\nimport * as compat from '@firebase/auth-types';\nimport { Compat } from '@firebase/util';\n\nconst _assert: typeof exp._assert = exp._assert;\n\nexport class RecaptchaVerifier\n  implements compat.RecaptchaVerifier, Compat<exp.ApplicationVerifier>\n{\n  readonly _delegate: exp.RecaptchaVerifier;\n  type: string;\n  constructor(\n    container: HTMLElement | string,\n    parameters?: object | null,\n    app: FirebaseApp = firebase.app()\n  ) {\n    // API key is required for web client RPC calls.\n    _assert(app.options?.apiKey, exp.AuthErrorCode.INVALID_API_KEY, {\n      appName: app.name\n    });\n    this._delegate = new exp.RecaptchaVerifier(\n      container,\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      parameters as any,\n\n      // TODO: remove ts-ignore when moving types from auth-types to auth-compat\n      // @ts-ignore\n      app.auth!()\n    );\n    this.type = this._delegate.type;\n  }\n  clear(): void {\n    this._delegate.clear();\n  }\n  render(): Promise<number> {\n    return this._delegate.render();\n  }\n  verify(): Promise<string> {\n    return this._delegate.verify();\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 firebase, { _FirebaseNamespace } from '@firebase/app-compat';\nimport * as impl from '@firebase/auth/internal';\nimport {\n  Component,\n  ComponentType,\n  InstantiationMode\n} from '@firebase/component';\nimport { FirebaseError } from '@firebase/util';\n\nimport * as types from '@firebase/auth-types';\nimport { name, version } from './package.json';\nimport { Auth } from './src/auth';\nimport { PhoneAuthProvider as CompatAuthProvider } from './src/phone_auth_provider';\nimport { RecaptchaVerifier as CompatRecaptchaVerifier } from './src/recaptcha_verifier';\n\nconst AUTH_TYPE = 'auth-compat';\n\ndeclare module '@firebase/component' {\n  interface NameServiceMapping {\n    'auth-compat': types.FirebaseAuth;\n  }\n}\n\ndeclare module '@firebase/app-compat' {\n  interface FirebaseNamespace {\n    auth: {\n      (app?: FirebaseApp): types.FirebaseAuth;\n      Auth: typeof types.FirebaseAuth;\n      EmailAuthProvider: typeof types.EmailAuthProvider;\n      EmailAuthProvider_Instance: typeof types.EmailAuthProvider_Instance;\n      FacebookAuthProvider: typeof types.FacebookAuthProvider;\n      FacebookAuthProvider_Instance: typeof types.FacebookAuthProvider_Instance;\n      GithubAuthProvider: typeof types.GithubAuthProvider;\n      GithubAuthProvider_Instance: typeof types.GithubAuthProvider_Instance;\n      GoogleAuthProvider: typeof types.GoogleAuthProvider;\n      GoogleAuthProvider_Instance: typeof types.GoogleAuthProvider_Instance;\n      OAuthProvider: typeof types.OAuthProvider;\n      SAMLAuthProvider: typeof types.SAMLAuthProvider;\n      PhoneAuthProvider: typeof types.PhoneAuthProvider;\n      PhoneAuthProvider_Instance: typeof types.PhoneAuthProvider_Instance;\n      PhoneMultiFactorGenerator: typeof types.PhoneMultiFactorGenerator;\n      RecaptchaVerifier: typeof types.RecaptchaVerifier;\n      RecaptchaVerifier_Instance: typeof types.RecaptchaVerifier_Instance;\n      TwitterAuthProvider: typeof types.TwitterAuthProvider;\n      TwitterAuthProvider_Instance: typeof types.TwitterAuthProvider_Instance;\n    };\n  }\n  interface FirebaseApp {\n    auth?(): types.FirebaseAuth;\n  }\n}\n\n// Create auth components to register with firebase.\n// Provides Auth public APIs.\nfunction registerAuthCompat(instance: _FirebaseNamespace): void {\n  instance.INTERNAL.registerComponent(\n    new Component(\n      AUTH_TYPE,\n      container => {\n        // getImmediate for FirebaseApp will always succeed\n        const app = container.getProvider('app-compat').getImmediate();\n        const authProvider = container.getProvider('auth');\n        return new Auth(app, authProvider);\n      },\n      ComponentType.PUBLIC\n    )\n      .setServiceProps({\n        ActionCodeInfo: {\n          Operation: {\n            EMAIL_SIGNIN: impl.ActionCodeOperation.EMAIL_SIGNIN,\n            PASSWORD_RESET: impl.ActionCodeOperation.PASSWORD_RESET,\n            RECOVER_EMAIL: impl.ActionCodeOperation.RECOVER_EMAIL,\n            REVERT_SECOND_FACTOR_ADDITION:\n              impl.ActionCodeOperation.REVERT_SECOND_FACTOR_ADDITION,\n            VERIFY_AND_CHANGE_EMAIL:\n              impl.ActionCodeOperation.VERIFY_AND_CHANGE_EMAIL,\n            VERIFY_EMAIL: impl.ActionCodeOperation.VERIFY_EMAIL\n          }\n        },\n        EmailAuthProvider: impl.EmailAuthProvider,\n        FacebookAuthProvider: impl.FacebookAuthProvider,\n        GithubAuthProvider: impl.GithubAuthProvider,\n        GoogleAuthProvider: impl.GoogleAuthProvider,\n        OAuthProvider: impl.OAuthProvider,\n        SAMLAuthProvider: impl.SAMLAuthProvider,\n        PhoneAuthProvider: CompatAuthProvider,\n        PhoneMultiFactorGenerator: impl.PhoneMultiFactorGenerator,\n        RecaptchaVerifier: CompatRecaptchaVerifier,\n        TwitterAuthProvider: impl.TwitterAuthProvider,\n        Auth,\n        AuthCredential: impl.AuthCredential,\n        Error: FirebaseError\n      })\n      .setInstantiationMode(InstantiationMode.LAZY)\n      .setMultipleInstances(false)\n  );\n\n  instance.registerVersion(name, version);\n}\n\nregisterAuthCompat(firebase as _FirebaseNamespace);\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 {\n  InstantiationMode,\n  InstanceFactory,\n  ComponentType,\n  Dictionary,\n  Name,\n  onInstanceCreatedCallback\n} from './types';\n\n/**\n * Component for service name T, e.g. `auth`, `auth-internal`\n */\nexport class Component<T extends Name = Name> {\n  multipleInstances = false;\n  /**\n   * Properties to be added to the service namespace\n   */\n  serviceProps: Dictionary = {};\n\n  instantiationMode = InstantiationMode.LAZY;\n\n  onInstanceCreated: onInstanceCreatedCallback<T> | null = null;\n\n  /**\n   *\n   * @param name The public service name, e.g. app, auth, firestore, database\n   * @param instanceFactory Service factory responsible for creating the public interface\n   * @param type whether the service provided by the component is public or private\n   */\n  constructor(\n    readonly name: T,\n    readonly instanceFactory: InstanceFactory<T>,\n    readonly type: ComponentType\n  ) {}\n\n  setInstantiationMode(mode: InstantiationMode): this {\n    this.instantiationMode = mode;\n    return this;\n  }\n\n  setMultipleInstances(multipleInstances: boolean): this {\n    this.multipleInstances = multipleInstances;\n    return this;\n  }\n\n  setServiceProps(props: Dictionary): this {\n    this.serviceProps = props;\n    return this;\n  }\n\n  setInstanceCreatedCallback(callback: onInstanceCreatedCallback<T>): this {\n    this.onInstanceCreated = callback;\n    return this;\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 { Deferred } from '@firebase/util';\nimport { ComponentContainer } from './component_container';\nimport { DEFAULT_ENTRY_NAME } from './constants';\nimport {\n  InitializeOptions,\n  InstantiationMode,\n  Name,\n  NameServiceMapping,\n  OnInitCallBack\n} from './types';\nimport { Component } from './component';\n\n/**\n * Provider for instance for service name T, e.g. 'auth', 'auth-internal'\n * NameServiceMapping[T] is an alias for the type of the instance\n */\nexport class Provider<T extends Name> {\n  private component: Component<T> | null = null;\n  private readonly instances: Map<string, NameServiceMapping[T]> = new Map();\n  private readonly instancesDeferred: Map<\n    string,\n    Deferred<NameServiceMapping[T]>\n  > = new Map();\n  private readonly instancesOptions: Map<string, Record<string, unknown>> =\n    new Map();\n  private onInitCallbacks: Map<string, Set<OnInitCallBack<T>>> = new Map();\n\n  constructor(\n    private readonly name: T,\n    private readonly container: ComponentContainer\n  ) {}\n\n  /**\n   * @param identifier A provider can provide mulitple instances of a service\n   * if this.component.multipleInstances is true.\n   */\n  get(identifier?: string): Promise<NameServiceMapping[T]> {\n    // if multipleInstances is not supported, use the default name\n    const normalizedIdentifier = this.normalizeInstanceIdentifier(identifier);\n\n    if (!this.instancesDeferred.has(normalizedIdentifier)) {\n      const deferred = new Deferred<NameServiceMapping[T]>();\n      this.instancesDeferred.set(normalizedIdentifier, deferred);\n\n      if (\n        this.isInitialized(normalizedIdentifier) ||\n        this.shouldAutoInitialize()\n      ) {\n        // initialize the service if it can be auto-initialized\n        try {\n          const instance = this.getOrInitializeService({\n            instanceIdentifier: normalizedIdentifier\n          });\n          if (instance) {\n            deferred.resolve(instance);\n          }\n        } catch (e) {\n          // when the instance factory throws an exception during get(), it should not cause\n          // a fatal error. We just return the unresolved promise in this case.\n        }\n      }\n    }\n\n    return this.instancesDeferred.get(normalizedIdentifier)!.promise;\n  }\n\n  /**\n   *\n   * @param options.identifier A provider can provide mulitple instances of a service\n   * if this.component.multipleInstances is true.\n   * @param options.optional If optional is false or not provided, the method throws an error when\n   * the service is not immediately available.\n   * If optional is true, the method returns null if the service is not immediately available.\n   */\n  getImmediate(options: {\n    identifier?: string;\n    optional: true;\n  }): NameServiceMapping[T] | null;\n  getImmediate(options?: {\n    identifier?: string;\n    optional?: false;\n  }): NameServiceMapping[T];\n  getImmediate(options?: {\n    identifier?: string;\n    optional?: boolean;\n  }): NameServiceMapping[T] | null {\n    // if multipleInstances is not supported, use the default name\n    const normalizedIdentifier = this.normalizeInstanceIdentifier(\n      options?.identifier\n    );\n    const optional = options?.optional ?? false;\n\n    if (\n      this.isInitialized(normalizedIdentifier) ||\n      this.shouldAutoInitialize()\n    ) {\n      try {\n        return this.getOrInitializeService({\n          instanceIdentifier: normalizedIdentifier\n        });\n      } catch (e) {\n        if (optional) {\n          return null;\n        } else {\n          throw e;\n        }\n      }\n    } else {\n      // In case a component is not initialized and should/can not be auto-initialized at the moment, return null if the optional flag is set, or throw\n      if (optional) {\n        return null;\n      } else {\n        throw Error(`Service ${this.name} is not available`);\n      }\n    }\n  }\n\n  getComponent(): Component<T> | null {\n    return this.component;\n  }\n\n  setComponent(component: Component<T>): void {\n    if (component.name !== this.name) {\n      throw Error(\n        `Mismatching Component ${component.name} for Provider ${this.name}.`\n      );\n    }\n\n    if (this.component) {\n      throw Error(`Component for ${this.name} has already been provided`);\n    }\n\n    this.component = component;\n\n    // return early without attempting to initialize the component if the component requires explicit initialization (calling `Provider.initialize()`)\n    if (!this.shouldAutoInitialize()) {\n      return;\n    }\n\n    // if the service is eager, initialize the default instance\n    if (isComponentEager(component)) {\n      try {\n        this.getOrInitializeService({ instanceIdentifier: DEFAULT_ENTRY_NAME });\n      } catch (e) {\n        // when the instance factory for an eager Component throws an exception during the eager\n        // initialization, it should not cause a fatal error.\n        // TODO: Investigate if we need to make it configurable, because some component may want to cause\n        // a fatal error in this case?\n      }\n    }\n\n    // Create service instances for the pending promises and resolve them\n    // NOTE: if this.multipleInstances is false, only the default instance will be created\n    // and all promises with resolve with it regardless of the identifier.\n    for (const [\n      instanceIdentifier,\n      instanceDeferred\n    ] of this.instancesDeferred.entries()) {\n      const normalizedIdentifier =\n        this.normalizeInstanceIdentifier(instanceIdentifier);\n\n      try {\n        // `getOrInitializeService()` should always return a valid instance since a component is guaranteed. use ! to make typescript happy.\n        const instance = this.getOrInitializeService({\n          instanceIdentifier: normalizedIdentifier\n        })!;\n        instanceDeferred.resolve(instance);\n      } catch (e) {\n        // when the instance factory throws an exception, it should not cause\n        // a fatal error. We just leave the promise unresolved.\n      }\n    }\n  }\n\n  clearInstance(identifier: string = DEFAULT_ENTRY_NAME): void {\n    this.instancesDeferred.delete(identifier);\n    this.instancesOptions.delete(identifier);\n    this.instances.delete(identifier);\n  }\n\n  // app.delete() will call this method on every provider to delete the services\n  // TODO: should we mark the provider as deleted?\n  async delete(): Promise<void> {\n    const services = Array.from(this.instances.values());\n\n    await Promise.all([\n      ...services\n        .filter(service => 'INTERNAL' in service) // legacy services\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        .map(service => (service as any).INTERNAL!.delete()),\n      ...services\n        .filter(service => '_delete' in service) // modularized services\n        // eslint-disable-next-line @typescript-eslint/no-explicit-any\n        .map(service => (service as any)._delete())\n    ]);\n  }\n\n  isComponentSet(): boolean {\n    return this.component != null;\n  }\n\n  isInitialized(identifier: string = DEFAULT_ENTRY_NAME): boolean {\n    return this.instances.has(identifier);\n  }\n\n  getOptions(identifier: string = DEFAULT_ENTRY_NAME): Record<string, unknown> {\n    return this.instancesOptions.get(identifier) || {};\n  }\n\n  initialize(opts: InitializeOptions = {}): NameServiceMapping[T] {\n    const { options = {} } = opts;\n    const normalizedIdentifier = this.normalizeInstanceIdentifier(\n      opts.instanceIdentifier\n    );\n    if (this.isInitialized(normalizedIdentifier)) {\n      throw Error(\n        `${this.name}(${normalizedIdentifier}) has already been initialized`\n      );\n    }\n\n    if (!this.isComponentSet()) {\n      throw Error(`Component ${this.name} has not been registered yet`);\n    }\n\n    const instance = this.getOrInitializeService({\n      instanceIdentifier: normalizedIdentifier,\n      options\n    })!;\n\n    // resolve any pending promise waiting for the service instance\n    for (const [\n      instanceIdentifier,\n      instanceDeferred\n    ] of this.instancesDeferred.entries()) {\n      const normalizedDeferredIdentifier =\n        this.normalizeInstanceIdentifier(instanceIdentifier);\n      if (normalizedIdentifier === normalizedDeferredIdentifier) {\n        instanceDeferred.resolve(instance);\n      }\n    }\n\n    return instance;\n  }\n\n  /**\n   *\n   * @param callback - a function that will be invoked  after the provider has been initialized by calling provider.initialize().\n   * The function is invoked SYNCHRONOUSLY, so it should not execute any longrunning tasks in order to not block the program.\n   *\n   * @param identifier An optional instance identifier\n   * @returns a function to unregister the callback\n   */\n  onInit(callback: OnInitCallBack<T>, identifier?: string): () => void {\n    const normalizedIdentifier = this.normalizeInstanceIdentifier(identifier);\n    const existingCallbacks =\n      this.onInitCallbacks.get(normalizedIdentifier) ??\n      new Set<OnInitCallBack<T>>();\n    existingCallbacks.add(callback);\n    this.onInitCallbacks.set(normalizedIdentifier, existingCallbacks);\n\n    const existingInstance = this.instances.get(normalizedIdentifier);\n    if (existingInstance) {\n      callback(existingInstance, normalizedIdentifier);\n    }\n\n    return () => {\n      existingCallbacks.delete(callback);\n    };\n  }\n\n  /**\n   * Invoke onInit callbacks synchronously\n   * @param instance the service instance`\n   */\n  private invokeOnInitCallbacks(\n    instance: NameServiceMapping[T],\n    identifier: string\n  ): void {\n    const callbacks = this.onInitCallbacks.get(identifier);\n    if (!callbacks) {\n      return;\n    }\n    for (const callback of callbacks) {\n      try {\n        callback(instance, identifier);\n      } catch {\n        // ignore errors in the onInit callback\n      }\n    }\n  }\n\n  private getOrInitializeService({\n    instanceIdentifier,\n    options = {}\n  }: {\n    instanceIdentifier: string;\n    options?: Record<string, unknown>;\n  }): NameServiceMapping[T] | null {\n    let instance = this.instances.get(instanceIdentifier);\n    if (!instance && this.component) {\n      instance = this.component.instanceFactory(this.container, {\n        instanceIdentifier: normalizeIdentifierForFactory(instanceIdentifier),\n        options\n      });\n      this.instances.set(instanceIdentifier, instance);\n      this.instancesOptions.set(instanceIdentifier, options);\n\n      /**\n       * Invoke onInit listeners.\n       * Note this.component.onInstanceCreated is different, which is used by the component creator,\n       * while onInit listeners are registered by consumers of the provider.\n       */\n      this.invokeOnInitCallbacks(instance, instanceIdentifier);\n\n      /**\n       * Order is important\n       * onInstanceCreated() should be called after this.instances.set(instanceIdentifier, instance); which\n       * makes `isInitialized()` return true.\n       */\n      if (this.component.onInstanceCreated) {\n        try {\n          this.component.onInstanceCreated(\n            this.container,\n            instanceIdentifier,\n            instance\n          );\n        } catch {\n          // ignore errors in the onInstanceCreatedCallback\n        }\n      }\n    }\n\n    return instance || null;\n  }\n\n  private normalizeInstanceIdentifier(\n    identifier: string = DEFAULT_ENTRY_NAME\n  ): string {\n    if (this.component) {\n      return this.component.multipleInstances ? identifier : DEFAULT_ENTRY_NAME;\n    } else {\n      return identifier; // assume multiple instances are supported before the component is provided.\n    }\n  }\n\n  private shouldAutoInitialize(): boolean {\n    return (\n      !!this.component &&\n      this.component.instantiationMode !== InstantiationMode.EXPLICIT\n    );\n  }\n}\n\n// undefined should be passed to the service factory for the default instance\nfunction normalizeIdentifierForFactory(identifier: string): string | undefined {\n  return identifier === DEFAULT_ENTRY_NAME ? undefined : identifier;\n}\n\nfunction isComponentEager<T extends Name>(component: Component<T>): boolean {\n  return component.instantiationMode === InstantiationMode.EAGER;\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 { Provider } from './provider';\nimport { Component } from './component';\nimport { Name } from './types';\n\n/**\n * ComponentContainer that provides Providers for service name T, e.g. `auth`, `auth-internal`\n */\nexport class ComponentContainer {\n  private readonly providers = new Map<string, Provider<Name>>();\n\n  constructor(private readonly name: string) {}\n\n  /**\n   *\n   * @param component Component being added\n   * @param overwrite When a component with the same name has already been registered,\n   * if overwrite is true: overwrite the existing component with the new component and create a new\n   * provider with the new component. It can be useful in tests where you want to use different mocks\n   * for different tests.\n   * if overwrite is false: throw an exception\n   */\n  addComponent<T extends Name>(component: Component<T>): void {\n    const provider = this.getProvider(component.name);\n    if (provider.isComponentSet()) {\n      throw new Error(\n        `Component ${component.name} has already been registered with ${this.name}`\n      );\n    }\n\n    provider.setComponent(component);\n  }\n\n  addOrOverwriteComponent<T extends Name>(component: Component<T>): void {\n    const provider = this.getProvider(component.name);\n    if (provider.isComponentSet()) {\n      // delete the existing provider from the container, so we can register the new component\n      this.providers.delete(component.name);\n    }\n\n    this.addComponent(component);\n  }\n\n  /**\n   * getProvider provides a type safe interface where it can only be called with a field name\n   * present in NameServiceMapping interface.\n   *\n   * Firebase SDKs providing services should extend NameServiceMapping interface to register\n   * themselves.\n   */\n  getProvider<T extends Name>(name: T): Provider<T> {\n    if (this.providers.has(name)) {\n      return this.providers.get(name) as unknown as Provider<T>;\n    }\n\n    // create a Provider for a service that hasn't registered with Firebase\n    const provider = new Provider<T>(name, this);\n    this.providers.set(name, provider as unknown as Provider<Name>);\n\n    return provider as Provider<T>;\n  }\n\n  getProviders(): Array<Provider<Name>> {\n    return Array.from(this.providers.values());\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 firebase from '@firebase/app-compat';\nimport { name, version } from '../../package.json';\n\nfirebase.registerVersion(name, version, 'app-compat');\n\nexport default firebase;\n"],"sourceRoot":""}