@firebase/auth 0.19.12 → 0.20.0

package/dist/node/src/core/auth/middleware.d.ts

@@ -0,0 +1,25 @@
+/**
+ * @license
+ * Copyright 2022 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { AuthInternal } from '../../model/auth';
+import { Unsubscribe, User } from '../../model/public_types';
+export declare class AuthMiddlewareQueue {
+    private readonly auth;
+    private readonly queue;
+    constructor(auth: AuthInternal);
+    pushCallback(callback: (user: User | null) => void | Promise<void>, onAbort?: () => void): Unsubscribe;
+    runMiddleware(nextUser: User | null): Promise<void>;
+}

package/dist/node/src/core/auth/middleware.test.d.ts

@@ -0,0 +1,17 @@
+/**
+ * @license
+ * Copyright 2022 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+export {};

package/dist/node/src/core/errors.d.ts

@@ -72,6 +72,7 @@ export declare const enum AuthErrorCode {
     INVALID_SENDER = "invalid-sender",
     INVALID_SESSION_INFO = "invalid-verification-id",
     INVALID_TENANT_ID = "invalid-tenant-id",
+    LOGIN_BLOCKED = "login-blocked",
     MFA_INFO_NOT_FOUND = "multi-factor-info-not-found",
     MFA_REQUIRED = "multi-factor-auth-required",
     MISSING_ANDROID_PACKAGE_NAME = "missing-android-pkg-name",
@@ -154,9 +155,10 @@ export interface NamedErrorParams {
  */
 declare type GenericAuthErrorParams = {
     [key in Exclude<AuthErrorCode, AuthErrorCode.ARGUMENT_ERROR | AuthErrorCode.DEPENDENT_SDK_INIT_BEFORE_AUTH | AuthErrorCode.INTERNAL_ERROR | AuthErrorCode.MFA_REQUIRED | AuthErrorCode.NO_AUTH_EVENT | AuthErrorCode.OPERATION_NOT_SUPPORTED>]: {
-        appName: AppName;
+        appName?: AppName;
         email?: string;
         phoneNumber?: string;
+        message?: string;
     };
 };
 /**
@@ -172,6 +174,10 @@ export interface AuthErrorParams extends GenericAuthErrorParams {
     [AuthErrorCode.INTERNAL_ERROR]: {
         appName?: AppName;
     };
+    [AuthErrorCode.LOGIN_BLOCKED]: {
+        appName?: AppName;
+        originalMessage?: string;
+    };
     [AuthErrorCode.OPERATION_NOT_SUPPORTED]: {
         appName?: AppName;
     };

package/dist/node/src/core/index.d.ts

@@ -50,6 +50,17 @@ export declare function setPersistence(auth: Auth, persistence: Persistence): Pr
  * @public
  */
 export declare function onIdTokenChanged(auth: Auth, nextOrObserver: NextOrObserver<User>, error?: ErrorFn, completed?: CompleteFn): Unsubscribe;
+/**
+ * Adds a blocking callback that runs before an auth state change
+ * sets a new user.
+ *
+ * @param auth - The {@link Auth} instance.
+ * @param callback - callback triggered before new user value is set.
+ *   If this throws, it blocks the user from being set.
+ * @param onAbort - callback triggered if a later `beforeAuthStateChanged()`
+ *   callback throws, allowing you to undo any side effects.
+ */
+export declare function beforeAuthStateChanged(auth: Auth, callback: (user: User | null) => void | Promise<void>, onAbort?: () => void): Unsubscribe;
 /**
  * Adds an observer for changes to the user's sign-in state.
  *

package/dist/node/src/core/strategies/redirect.d.ts

@@ -33,3 +33,4 @@ export declare class RedirectAction extends AbstractPopupRedirectOperation {
 export declare function _getAndClearPendingRedirectStatus(resolver: PopupRedirectResolverInternal, auth: AuthInternal): Promise<boolean>;
 export declare function _setPendingRedirectStatus(resolver: PopupRedirectResolverInternal, auth: AuthInternal): Promise<void>;
 export declare function _clearRedirectOutcomes(): void;
+export declare function _overrideRedirectResult(auth: AuthInternal, result: () => Promise<UserCredentialInternal | null>): void;

package/dist/node/src/model/popup_redirect.d.ts

@@ -18,6 +18,7 @@ import { Auth, AuthProvider, Persistence, PopupRedirectResolver, UserCredential
 import { FirebaseError } from '@firebase/util';
 import { AuthPopup } from '../platform_browser/util/popup';
 import { AuthInternal } from './auth';
+import { UserCredentialInternal } from './user';
 export declare const enum EventFilter {
     POPUP = 0,
     REDIRECT = 1
@@ -89,4 +90,5 @@ export interface PopupRedirectResolverInternal extends PopupRedirectResolver {
     _redirectPersistence: Persistence;
     _originValidation(auth: Auth): Promise<void>;
     _completeRedirectFn: (auth: Auth, resolver: PopupRedirectResolver, bypassAuthState: boolean) => Promise<UserCredential | null>;
+    _overrideRedirectResult: (auth: AuthInternal, resultGetter: () => Promise<UserCredentialInternal | null>) => void;
 }

package/dist/node/src/model/public_types.d.ts

@@ -228,6 +228,16 @@ export interface Auth {
      * @param completed - callback triggered when observer is removed.
      */
     onAuthStateChanged(nextOrObserver: NextOrObserver<User | null>, error?: ErrorFn, completed?: CompleteFn): Unsubscribe;
+    /**
+     * Adds a blocking callback that runs before an auth state change
+     * sets a new user.
+     *
+     * @param callback - callback triggered before new user value is set.
+     *   If this throws, it blocks the user from being set.
+     * @param onAbort - callback triggered if a later `beforeAuthStateChanged()`
+     *   callback throws, allowing you to undo any side effects.
+     */
+    beforeAuthStateChanged(callback: (user: User | null) => void | Promise<void>, onAbort?: () => void): Unsubscribe;
     /**
      * Adds an observer for changes to the signed-in user's ID token.
      *

package/dist/node/test/integration/flows/middleware_test_generator.d.ts

@@ -0,0 +1,18 @@
+/**
+ * @license
+ * Copyright 2022 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { Auth } from '@firebase/auth';
+export declare function generateMiddlewareTests(authGetter: () => Auth, signIn: () => Promise<unknown>): void;

package/dist/node/test/integration/webdriver/util/functions.d.ts

@@ -70,6 +70,10 @@ export declare enum PersistenceFunction {
     SET_PERSISTENCE_INDEXED_DB = "persistence.setPersistenceIndexedDB",
     SET_PERSISTENCE_LOCAL_STORAGE = "persistence.setPersistenceLocalStorage"
 }
+export declare enum MiddlewareFunction {
+    ATTACH_BLOCKING_MIDDLEWARE = "middleware.attachBlockingMiddleware",
+    ATTACH_BLOCKING_MIDDLEWARE_ON_START = "middleware.attachBlockingMiddlewareOnStart"
+}
 /** Available firebase UI functions (only for compat tests) */
 export declare enum UiFunction {
     LOAD = "ui.loadUiCode",

package/dist/node-esm/{index-d709908a.js → index-c85cf380.js}

@@ -199,6 +199,7 @@ function _debugErrorMap() {
             'Please fix by going to the Auth email templates section in the Firebase Console.',
         ["invalid-verification-id" /* INVALID_SESSION_INFO */]: 'The verification ID used to create the phone auth credential is invalid.',
         ["invalid-tenant-id" /* INVALID_TENANT_ID */]: "The Auth instance's tenant ID is invalid.",
+        ["login-blocked" /* LOGIN_BLOCKED */]: "Login blocked by user-provided method: {$originalMessage}",
         ["missing-android-pkg-name" /* MISSING_ANDROID_PACKAGE_NAME */]: 'An Android Package Name must be provided if the Android App is required to be installed.',
         ["auth-domain-config-required" /* MISSING_AUTH_DOMAIN */]: 'Be sure to include authDomain when calling firebase.initializeApp(), ' +
             'by following the instructions in the Firebase console.',
@@ -2103,6 +2104,83 @@ function _getClientVersion(clientPlatform, frameworks = []) {
     return `${reportedPlatform}/${"JsCore" /* CORE */}/${SDK_VERSION}/${reportedFrameworks}`;
 }
 
+/**
+ * @license
+ * Copyright 2022 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+class AuthMiddlewareQueue {
+    constructor(auth) {
+        this.auth = auth;
+        this.queue = [];
+    }
+    pushCallback(callback, onAbort) {
+        // The callback could be sync or async. Wrap it into a
+        // function that is always async.
+        const wrappedCallback = (user) => new Promise((resolve, reject) => {
+            try {
+                const result = callback(user);
+                // Either resolve with existing promise or wrap a non-promise
+                // return value into a promise.
+                resolve(result);
+            }
+            catch (e) {
+                // Sync callback throws.
+                reject(e);
+            }
+        });
+        // Attach the onAbort if present
+        wrappedCallback.onAbort = onAbort;
+        this.queue.push(wrappedCallback);
+        const index = this.queue.length - 1;
+        return () => {
+            // Unsubscribe. Replace with no-op. Do not remove from array, or it will disturb
+            // indexing of other elements.
+            this.queue[index] = () => Promise.resolve();
+        };
+    }
+    async runMiddleware(nextUser) {
+        if (this.auth.currentUser === nextUser) {
+            return;
+        }
+        // While running the middleware, build a temporary stack of onAbort
+        // callbacks to call if one middleware callback rejects.
+        const onAbortStack = [];
+        try {
+            for (const beforeStateCallback of this.queue) {
+                await beforeStateCallback(nextUser);
+                // Only push the onAbort if the callback succeeds
+                if (beforeStateCallback.onAbort) {
+                    onAbortStack.push(beforeStateCallback.onAbort);
+                }
+            }
+        }
+        catch (e) {
+            // Run all onAbort, with separate try/catch to ignore any errors and
+            // continue
+            onAbortStack.reverse();
+            for (const onAbort of onAbortStack) {
+                try {
+                    onAbort();
+                }
+                catch (_) { /* swallow error */ }
+            }
+            throw this.auth._errorFactory.create("login-blocked" /* LOGIN_BLOCKED */, { originalMessage: e.message });
+        }
+    }
+}
+
 /**
  * @license
  * Copyright 2020 Google LLC
@@ -2129,6 +2207,7 @@ class AuthImpl {
         this.operations = Promise.resolve();
         this.authStateSubscription = new Subscription(this);
         this.idTokenSubscription = new Subscription(this);
+        this.beforeStateQueue = new AuthMiddlewareQueue(this);
         this.redirectUser = null;
         this.isProactiveRefreshEnabled = false;
         // Any network calls will set this to true and prevent subsequent emulator
@@ -2205,16 +2284,19 @@ class AuthImpl {
             return;
         }
         // Update current Auth state. Either a new login or logout.
-        await this._updateCurrentUser(user);
+        // Skip blocking callbacks, they should not apply to a change in another tab.
+        await this._updateCurrentUser(user, /* skipBeforeStateCallbacks */ true);
     }
     async initializeCurrentUser(popupRedirectResolver) {
         var _a;
         // First check to see if we have a pending redirect event.
-        let storedUser = (await this.assertedPersistence.getCurrentUser());
+        const previouslyStoredUser = (await this.assertedPersistence.getCurrentUser());
+        let futureCurrentUser = previouslyStoredUser;
+        let needsTocheckMiddleware = false;
         if (popupRedirectResolver && this.config.authDomain) {
             await this.getOrInitRedirectPersistenceManager();
             const redirectUserEventId = (_a = this.redirectUser) === null || _a === void 0 ? void 0 : _a._redirectEventId;
-            const storedUserEventId = storedUser === null || storedUser === void 0 ? void 0 : storedUser._redirectEventId;
+            const storedUserEventId = futureCurrentUser === null || futureCurrentUser === void 0 ? void 0 : futureCurrentUser._redirectEventId;
             const result = await this.tryRedirectSignIn(popupRedirectResolver);
             // If the stored user (i.e. the old "currentUser") has a redirectId that
             // matches the redirect user, then we want to initially sign in with the
@@ -2222,18 +2304,34 @@ class AuthImpl {
             // TODO(samgho): More thoroughly test all of this
             if ((!redirectUserEventId || redirectUserEventId === storedUserEventId) &&
                 (result === null || result === void 0 ? void 0 : result.user)) {
-                storedUser = result.user;
+                futureCurrentUser = result.user;
+                needsTocheckMiddleware = true;
             }
         }
         // If no user in persistence, there is no current user. Set to null.
-        if (!storedUser) {
+        if (!futureCurrentUser) {
             return this.directlySetCurrentUser(null);
         }
-        if (!storedUser._redirectEventId) {
-            // This isn't a redirect user, we can reload and bail
-            // This will also catch the redirected user, if available, as that method
-            // strips the _redirectEventId
-            return this.reloadAndSetCurrentUserOrClear(storedUser);
+        if (!futureCurrentUser._redirectEventId) {
+            // This isn't a redirect link operation, we can reload and bail.
+            // First though, ensure that we check the middleware is happy.
+            if (needsTocheckMiddleware) {
+                try {
+                    await this.beforeStateQueue.runMiddleware(futureCurrentUser);
+                }
+                catch (e) {
+                    futureCurrentUser = previouslyStoredUser;
+                    // We know this is available since the bit is only set when the
+                    // resolver is available
+                    this._popupRedirectResolver._overrideRedirectResult(this, () => Promise.reject(e));
+                }
+            }
+            if (futureCurrentUser) {
+                return this.reloadAndSetCurrentUserOrClear(futureCurrentUser);
+            }
+            else {
+                return this.directlySetCurrentUser(null);
+            }
         }
         _assert(this._popupRedirectResolver, this, "argument-error" /* ARGUMENT_ERROR */);
         await this.getOrInitRedirectPersistenceManager();
@@ -2241,10 +2339,10 @@ class AuthImpl {
         // DO NOT reload the current user, otherwise they'll be cleared from storage.
         // This is important for the reauthenticateWithRedirect() flow.
         if (this.redirectUser &&
-            this.redirectUser._redirectEventId === storedUser._redirectEventId) {
-            return this.directlySetCurrentUser(storedUser);
+            this.redirectUser._redirectEventId === futureCurrentUser._redirectEventId) {
+            return this.directlySetCurrentUser(futureCurrentUser);
         }
-        return this.reloadAndSetCurrentUserOrClear(storedUser);
+        return this.reloadAndSetCurrentUserOrClear(futureCurrentUser);
     }
     async tryRedirectSignIn(redirectResolver) {
         // The redirect user needs to be checked (and signed in if available)
@@ -2305,24 +2403,31 @@ class AuthImpl {
         }
         return this._updateCurrentUser(user && user._clone(this));
     }
-    async _updateCurrentUser(user) {
+    async _updateCurrentUser(user, skipBeforeStateCallbacks = false) {
         if (this._deleted) {
             return;
         }
         if (user) {
             _assert(this.tenantId === user.tenantId, this, "tenant-id-mismatch" /* TENANT_ID_MISMATCH */);
         }
+        if (!skipBeforeStateCallbacks) {
+            await this.beforeStateQueue.runMiddleware(user);
+        }
         return this.queue(async () => {
             await this.directlySetCurrentUser(user);
             this.notifyAuthListeners();
         });
     }
     async signOut() {
+        // Run first, to block _setRedirectUser() if any callbacks fail.
+        await this.beforeStateQueue.runMiddleware(null);
         // Clear the redirect user when signOut is called
         if (this.redirectPersistenceManager || this._popupRedirectResolver) {
             await this._setRedirectUser(null);
         }
-        return this._updateCurrentUser(null);
+        // Prevent callbacks from being called again in _updateCurrentUser, as
+        // they were already called in the first line.
+        return this._updateCurrentUser(null, /* skipBeforeStateCallbacks */ true);
     }
     setPersistence(persistence) {
         return this.queue(async () => {
@@ -2338,6 +2443,9 @@ class AuthImpl {
     onAuthStateChanged(nextOrObserver, error, completed) {
         return this.registerStateListener(this.authStateSubscription, nextOrObserver, error, completed);
     }
+    beforeAuthStateChanged(callback, onAbort) {
+        return this.beforeStateQueue.pushCallback(callback, onAbort);
+    }
     onIdTokenChanged(nextOrObserver, error, completed) {
         return this.registerStateListener(this.idTokenSubscription, nextOrObserver, error, completed);
     }
@@ -5543,6 +5651,19 @@ function setPersistence(auth, persistence) {
 function onIdTokenChanged(auth, nextOrObserver, error, completed) {
     return getModularInstance(auth).onIdTokenChanged(nextOrObserver, error, completed);
 }
+/**
+ * Adds a blocking callback that runs before an auth state change
+ * sets a new user.
+ *
+ * @param auth - The {@link Auth} instance.
+ * @param callback - callback triggered before new user value is set.
+ *   If this throws, it blocks the user from being set.
+ * @param onAbort - callback triggered if a later `beforeAuthStateChanged()`
+ *   callback throws, allowing you to undo any side effects.
+ */
+function beforeAuthStateChanged(auth, callback, onAbort) {
+    return getModularInstance(auth).beforeAuthStateChanged(callback, onAbort);
+}
 /**
  * Adds an observer for changes to the user's sign-in state.
  *
@@ -5817,7 +5938,7 @@ function multiFactor(user) {
 }
 
 var name = "@firebase/auth";
-var version = "0.19.12";
+var version = "0.20.0";
 
 /**
  * @license
@@ -6043,5 +6164,5 @@ class PhoneMultiFactorGenerator {
 // auth.setPersistence(persistence) are covered.
 AuthImpl.prototype.setPersistence = async () => { };
 
-export { sendPasswordResetEmail as $, ActionCodeOperation as A, prodErrorMap as B, AUTH_ERROR_CODES_MAP_DO_NOT_USE_INTERNALLY as C, initializeAuth as D, connectAuthEmulator as E, FactorId as F, AuthCredential as G, EmailAuthCredential as H, OAuthCredential as I, PhoneAuthCredential as J, inMemoryPersistence as K, EmailAuthProvider as L, FacebookAuthProvider as M, GoogleAuthProvider as N, OperationType as O, PhoneAuthProvider as P, GithubAuthProvider as Q, RecaptchaVerifier as R, SignInMethod as S, OAuthProvider as T, SAMLAuthProvider as U, TwitterAuthProvider as V, signInAnonymously as W, signInWithCredential as X, linkWithCredential as Y, reauthenticateWithCredential as Z, signInWithCustomToken as _, browserSessionPersistence as a, confirmPasswordReset as a0, applyActionCode as a1, checkActionCode as a2, verifyPasswordResetCode as a3, createUserWithEmailAndPassword as a4, signInWithEmailAndPassword as a5, sendSignInLinkToEmail as a6, isSignInWithEmailLink as a7, signInWithEmailLink as a8, fetchSignInMethodsForEmail as a9, _emulatorUrl as aA, _performApiRequest as aB, _isIOS7Or8 as aC, _isIOS as aD, _isAndroid as aE, _createError as aF, _isSafari as aG, _isIframe as aH, _isMobileBrowser as aI, _isIE10 as aJ, UserImpl as aK, AuthImpl as aL, _getClientVersion as aM, FetchProvider as aN, SAMLAuthCredential as aO, sendEmailVerification as aa, verifyBeforeUpdateEmail as ab, ActionCodeURL as ac, parseActionCodeURL as ad, updateProfile as ae, updateEmail as af, updatePassword as ag, getIdToken as ah, getIdTokenResult as ai, unlink as aj, getAdditionalUserInfo as ak, reload as al, getMultiFactorResolver as am, multiFactor as an, _getInstance as ao, _assert as ap, _signInWithCredential as aq, _reauthenticate as ar, _link as as, signInWithIdp as at, _fail as au, debugAssert as av, _persistenceKeyName as aw, _castAuth as ax, FederatedAuthProvider as ay, BaseOAuthProvider as az, browserLocalPersistence as b, signInWithPopup as c, linkWithPopup as d, reauthenticateWithPopup as e, signInWithRedirect as f, linkWithRedirect as g, reauthenticateWithRedirect as h, indexedDBLocalPersistence as i, getRedirectResult as j, browserPopupRedirectResolver as k, linkWithPhoneNumber as l, PhoneMultiFactorGenerator as m, getAuth as n, ProviderId as o, setPersistence as p, onIdTokenChanged as q, reauthenticateWithPhoneNumber as r, signInWithPhoneNumber as s, onAuthStateChanged as t, updatePhoneNumber as u, useDeviceLanguage as v, updateCurrentUser as w, signOut as x, deleteUser as y, debugErrorMap as z };
-//# sourceMappingURL=index-d709908a.js.map
+export { signInWithCustomToken as $, ActionCodeOperation as A, debugErrorMap as B, prodErrorMap as C, AUTH_ERROR_CODES_MAP_DO_NOT_USE_INTERNALLY as D, initializeAuth as E, FactorId as F, connectAuthEmulator as G, AuthCredential as H, EmailAuthCredential as I, OAuthCredential as J, PhoneAuthCredential as K, inMemoryPersistence as L, EmailAuthProvider as M, FacebookAuthProvider as N, OperationType as O, PhoneAuthProvider as P, GoogleAuthProvider as Q, RecaptchaVerifier as R, SignInMethod as S, GithubAuthProvider as T, OAuthProvider as U, SAMLAuthProvider as V, TwitterAuthProvider as W, signInAnonymously as X, signInWithCredential as Y, linkWithCredential as Z, reauthenticateWithCredential as _, browserSessionPersistence as a, sendPasswordResetEmail as a0, confirmPasswordReset as a1, applyActionCode as a2, checkActionCode as a3, verifyPasswordResetCode as a4, createUserWithEmailAndPassword as a5, signInWithEmailAndPassword as a6, sendSignInLinkToEmail as a7, isSignInWithEmailLink as a8, signInWithEmailLink as a9, BaseOAuthProvider as aA, _emulatorUrl as aB, _performApiRequest as aC, _isIOS7Or8 as aD, _isIOS as aE, _isAndroid as aF, _createError as aG, _isSafari as aH, _isIframe as aI, _isMobileBrowser as aJ, _isIE10 as aK, UserImpl as aL, AuthImpl as aM, _getClientVersion as aN, FetchProvider as aO, SAMLAuthCredential as aP, fetchSignInMethodsForEmail as aa, sendEmailVerification as ab, verifyBeforeUpdateEmail as ac, ActionCodeURL as ad, parseActionCodeURL as ae, updateProfile as af, updateEmail as ag, updatePassword as ah, getIdToken as ai, getIdTokenResult as aj, unlink as ak, getAdditionalUserInfo as al, reload as am, getMultiFactorResolver as an, multiFactor as ao, _getInstance as ap, _assert as aq, _signInWithCredential as ar, _reauthenticate as as, _link as at, signInWithIdp as au, _fail as av, debugAssert as aw, _persistenceKeyName as ax, _castAuth as ay, FederatedAuthProvider as az, browserLocalPersistence as b, signInWithPopup as c, linkWithPopup as d, reauthenticateWithPopup as e, signInWithRedirect as f, linkWithRedirect as g, reauthenticateWithRedirect as h, indexedDBLocalPersistence as i, getRedirectResult as j, browserPopupRedirectResolver as k, linkWithPhoneNumber as l, PhoneMultiFactorGenerator as m, getAuth as n, ProviderId as o, setPersistence as p, onIdTokenChanged as q, reauthenticateWithPhoneNumber as r, signInWithPhoneNumber as s, beforeAuthStateChanged as t, updatePhoneNumber as u, onAuthStateChanged as v, useDeviceLanguage as w, updateCurrentUser as x, signOut as y, deleteUser as z };
+//# sourceMappingURL=index-c85cf380.js.map