@firebase/auth 1.7.9 → 1.8.0

package/dist/esm2017/{index-68602d24.js → index-a7d5cfcc.js}

@@ -1090,6 +1090,16 @@ class RecaptchaConfig {
             "ENFORCE" /* EnforcementState.ENFORCE */ ||
             this.getProviderEnforcementState(providerStr) === "AUDIT" /* EnforcementState.AUDIT */);
     }
+    /**
+     * Returns true if reCAPTCHA Enterprise protection is enabled in at least one provider, otherwise
+     * returns false.
+     *
+     * @returns Whether or not reCAPTCHA Enterprise protection is enabled for at least one provider.
+     */
+    isAnyProviderEnabled() {
+        return (this.isProviderEnabled("EMAIL_PASSWORD_PROVIDER" /* RecaptchaAuthProvider.EMAIL_PASSWORD_PROVIDER */) ||
+            this.isProviderEnabled("PHONE_PROVIDER" /* RecaptchaAuthProvider.PHONE_PROVIDER */));
+    }
 }
 
 /**
@@ -3177,6 +3187,167 @@ function _generateCallbackName(prefix) {
     return `__${prefix}${Math.floor(Math.random() * 1000000)}`;
 }
 
+/**
+ * @license
+ * Copyright 2020 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.
+ */
+const _SOLVE_TIME_MS = 500;
+const _EXPIRATION_TIME_MS = 60000;
+const _WIDGET_ID_START = 1000000000000;
+class MockReCaptcha {
+    constructor(auth) {
+        this.auth = auth;
+        this.counter = _WIDGET_ID_START;
+        this._widgets = new Map();
+    }
+    render(container, parameters) {
+        const id = this.counter;
+        this._widgets.set(id, new MockWidget(container, this.auth.name, parameters || {}));
+        this.counter++;
+        return id;
+    }
+    reset(optWidgetId) {
+        var _a;
+        const id = optWidgetId || _WIDGET_ID_START;
+        void ((_a = this._widgets.get(id)) === null || _a === void 0 ? void 0 : _a.delete());
+        this._widgets.delete(id);
+    }
+    getResponse(optWidgetId) {
+        var _a;
+        const id = optWidgetId || _WIDGET_ID_START;
+        return ((_a = this._widgets.get(id)) === null || _a === void 0 ? void 0 : _a.getResponse()) || '';
+    }
+    async execute(optWidgetId) {
+        var _a;
+        const id = optWidgetId || _WIDGET_ID_START;
+        void ((_a = this._widgets.get(id)) === null || _a === void 0 ? void 0 : _a.execute());
+        return '';
+    }
+}
+class MockGreCAPTCHATopLevel {
+    constructor() {
+        this.enterprise = new MockGreCAPTCHA();
+    }
+    ready(callback) {
+        callback();
+    }
+    execute(
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    _siteKey, _options) {
+        return Promise.resolve('token');
+    }
+    render(
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    _container, _parameters) {
+        return '';
+    }
+}
+class MockGreCAPTCHA {
+    ready(callback) {
+        callback();
+    }
+    execute(
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    _siteKey, _options) {
+        return Promise.resolve('token');
+    }
+    render(
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    _container, _parameters) {
+        return '';
+    }
+}
+class MockWidget {
+    constructor(containerOrId, appName, params) {
+        this.params = params;
+        this.timerId = null;
+        this.deleted = false;
+        this.responseToken = null;
+        this.clickHandler = () => {
+            this.execute();
+        };
+        const container = typeof containerOrId === 'string'
+            ? document.getElementById(containerOrId)
+            : containerOrId;
+        _assert(container, "argument-error" /* AuthErrorCode.ARGUMENT_ERROR */, { appName });
+        this.container = container;
+        this.isVisible = this.params.size !== 'invisible';
+        if (this.isVisible) {
+            this.execute();
+        }
+        else {
+            this.container.addEventListener('click', this.clickHandler);
+        }
+    }
+    getResponse() {
+        this.checkIfDeleted();
+        return this.responseToken;
+    }
+    delete() {
+        this.checkIfDeleted();
+        this.deleted = true;
+        if (this.timerId) {
+            clearTimeout(this.timerId);
+            this.timerId = null;
+        }
+        this.container.removeEventListener('click', this.clickHandler);
+    }
+    execute() {
+        this.checkIfDeleted();
+        if (this.timerId) {
+            return;
+        }
+        this.timerId = window.setTimeout(() => {
+            this.responseToken = generateRandomAlphaNumericString(50);
+            const { callback, 'expired-callback': expiredCallback } = this.params;
+            if (callback) {
+                try {
+                    callback(this.responseToken);
+                }
+                catch (e) { }
+            }
+            this.timerId = window.setTimeout(() => {
+                this.timerId = null;
+                this.responseToken = null;
+                if (expiredCallback) {
+                    try {
+                        expiredCallback();
+                    }
+                    catch (e) { }
+                }
+                if (this.isVisible) {
+                    this.execute();
+                }
+            }, _EXPIRATION_TIME_MS);
+        }, _SOLVE_TIME_MS);
+    }
+    checkIfDeleted() {
+        if (this.deleted) {
+            throw new Error('reCAPTCHA mock was already deleted!');
+        }
+    }
+}
+function generateRandomAlphaNumericString(len) {
+    const chars = [];
+    const allowedChars = '1234567890abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';
+    for (let i = 0; i < len; i++) {
+        chars.push(allowedChars.charAt(Math.floor(Math.random() * allowedChars.length)));
+    }
+    return chars.join('');
+}
+
 /* eslint-disable @typescript-eslint/no-require-imports */
 const RECAPTCHA_ENTERPRISE_VERIFIER_TYPE = 'recaptcha-enterprise';
 const FAKE_TOKEN = 'NO_RECAPTCHA';
@@ -3252,6 +3423,11 @@ class RecaptchaEnterpriseVerifier {
                 reject(Error('No reCAPTCHA enterprise script loaded.'));
             }
         }
+        // Returns Promise for a mock token when appVerificationDisabledForTesting is true.
+        if (this.auth.settings.appVerificationDisabledForTesting) {
+            const mockRecaptcha = new MockGreCAPTCHATopLevel();
+            return mockRecaptcha.execute('siteKey', { action: 'verify' });
+        }
         return new Promise((resolve, reject) => {
             retrieveSiteKey(this.auth)
                 .then(siteKey => {
@@ -3282,17 +3458,50 @@ class RecaptchaEnterpriseVerifier {
         });
     }
 }
-async function injectRecaptchaFields(auth, request, action, captchaResp = false) {
+async function injectRecaptchaFields(auth, request, action, isCaptchaResp = false, isFakeToken = false) {
     const verifier = new RecaptchaEnterpriseVerifier(auth);
     let captchaResponse;
-    try {
-        captchaResponse = await verifier.verify(action);
+    if (isFakeToken) {
+        captchaResponse = FAKE_TOKEN;
     }
-    catch (error) {
-        captchaResponse = await verifier.verify(action, true);
+    else {
+        try {
+            captchaResponse = await verifier.verify(action);
+        }
+        catch (error) {
+            captchaResponse = await verifier.verify(action, true);
+        }
     }
     const newRequest = Object.assign({}, request);
-    if (!captchaResp) {
+    if (action === "mfaSmsEnrollment" /* RecaptchaActionName.MFA_SMS_ENROLLMENT */ ||
+        action === "mfaSmsSignIn" /* RecaptchaActionName.MFA_SMS_SIGNIN */) {
+        if ('phoneEnrollmentInfo' in newRequest) {
+            const phoneNumber = newRequest.phoneEnrollmentInfo.phoneNumber;
+            const recaptchaToken = newRequest.phoneEnrollmentInfo.recaptchaToken;
+            Object.assign(newRequest, {
+                'phoneEnrollmentInfo': {
+                    phoneNumber,
+                    recaptchaToken,
+                    captchaResponse,
+                    'clientType': "CLIENT_TYPE_WEB" /* RecaptchaClientType.WEB */,
+                    'recaptchaVersion': "RECAPTCHA_ENTERPRISE" /* RecaptchaVersion.ENTERPRISE */
+                }
+            });
+        }
+        else if ('phoneSignInInfo' in newRequest) {
+            const recaptchaToken = newRequest.phoneSignInInfo.recaptchaToken;
+            Object.assign(newRequest, {
+                'phoneSignInInfo': {
+                    recaptchaToken,
+                    captchaResponse,
+                    'clientType': "CLIENT_TYPE_WEB" /* RecaptchaClientType.WEB */,
+                    'recaptchaVersion': "RECAPTCHA_ENTERPRISE" /* RecaptchaVersion.ENTERPRISE */
+                }
+            });
+        }
+        return newRequest;
+    }
+    if (!isCaptchaResp) {
         Object.assign(newRequest, { captchaResponse });
     }
     else {
@@ -3304,24 +3513,64 @@ async function injectRecaptchaFields(auth, request, action, captchaResp = false)
     });
     return newRequest;
 }
-async function handleRecaptchaFlow(authInstance, request, actionName, actionMethod) {
-    var _a;
-    if ((_a = authInstance
-        ._getRecaptchaConfig()) === null || _a === void 0 ? void 0 : _a.isProviderEnabled("EMAIL_PASSWORD_PROVIDER" /* RecaptchaProvider.EMAIL_PASSWORD_PROVIDER */)) {
-        const requestWithRecaptcha = await injectRecaptchaFields(authInstance, request, actionName, actionName === "getOobCode" /* RecaptchaActionName.GET_OOB_CODE */);
-        return actionMethod(authInstance, requestWithRecaptcha);
+async function handleRecaptchaFlow(authInstance, request, actionName, actionMethod, recaptchaAuthProvider) {
+    var _a, _b;
+    if (recaptchaAuthProvider === "EMAIL_PASSWORD_PROVIDER" /* RecaptchaAuthProvider.EMAIL_PASSWORD_PROVIDER */) {
+        if ((_a = authInstance
+            ._getRecaptchaConfig()) === null || _a === void 0 ? void 0 : _a.isProviderEnabled("EMAIL_PASSWORD_PROVIDER" /* RecaptchaAuthProvider.EMAIL_PASSWORD_PROVIDER */)) {
+            const requestWithRecaptcha = await injectRecaptchaFields(authInstance, request, actionName, actionName === "getOobCode" /* RecaptchaActionName.GET_OOB_CODE */);
+            return actionMethod(authInstance, requestWithRecaptcha);
+        }
+        else {
+            return actionMethod(authInstance, request).catch(async (error) => {
+                if (error.code === `auth/${"missing-recaptcha-token" /* AuthErrorCode.MISSING_RECAPTCHA_TOKEN */}`) {
+                    console.log(`${actionName} is protected by reCAPTCHA Enterprise for this project. Automatically triggering the reCAPTCHA flow and restarting the flow.`);
+                    const requestWithRecaptcha = await injectRecaptchaFields(authInstance, request, actionName, actionName === "getOobCode" /* RecaptchaActionName.GET_OOB_CODE */);
+                    return actionMethod(authInstance, requestWithRecaptcha);
+                }
+                else {
+                    return Promise.reject(error);
+                }
+            });
+        }
     }
-    else {
-        return actionMethod(authInstance, request).catch(async (error) => {
-            if (error.code === `auth/${"missing-recaptcha-token" /* AuthErrorCode.MISSING_RECAPTCHA_TOKEN */}`) {
-                console.log(`${actionName} is protected by reCAPTCHA Enterprise for this project. Automatically triggering the reCAPTCHA flow and restarting the flow.`);
-                const requestWithRecaptcha = await injectRecaptchaFields(authInstance, request, actionName, actionName === "getOobCode" /* RecaptchaActionName.GET_OOB_CODE */);
-                return actionMethod(authInstance, requestWithRecaptcha);
-            }
-            else {
+    else if (recaptchaAuthProvider === "PHONE_PROVIDER" /* RecaptchaAuthProvider.PHONE_PROVIDER */) {
+        if ((_b = authInstance
+            ._getRecaptchaConfig()) === null || _b === void 0 ? void 0 : _b.isProviderEnabled("PHONE_PROVIDER" /* RecaptchaAuthProvider.PHONE_PROVIDER */)) {
+            const requestWithRecaptcha = await injectRecaptchaFields(authInstance, request, actionName);
+            return actionMethod(authInstance, requestWithRecaptcha).catch(async (error) => {
+                var _a;
+                if (((_a = authInstance
+                    ._getRecaptchaConfig()) === null || _a === void 0 ? void 0 : _a.getProviderEnforcementState("PHONE_PROVIDER" /* RecaptchaAuthProvider.PHONE_PROVIDER */)) === "AUDIT" /* EnforcementState.AUDIT */) {
+                    // AUDIT mode
+                    if (error.code === `auth/${"missing-recaptcha-token" /* AuthErrorCode.MISSING_RECAPTCHA_TOKEN */}` ||
+                        error.code === `auth/${"invalid-app-credential" /* AuthErrorCode.INVALID_APP_CREDENTIAL */}`) {
+                        console.log(`Failed to verify with reCAPTCHA Enterprise. Automatically triggering the reCAPTCHA v2 flow to complete the ${actionName} flow.`);
+                        // reCAPTCHA Enterprise token is missing or reCAPTCHA Enterprise token
+                        // check fails.
+                        // Fallback to reCAPTCHA v2 flow.
+                        const requestWithRecaptchaFields = await injectRecaptchaFields(authInstance, request, actionName, false, // isCaptchaResp
+                        true // isFakeToken
+                        );
+                        // This will call the PhoneApiCaller to fetch and inject reCAPTCHA v2 token.
+                        return actionMethod(authInstance, requestWithRecaptchaFields);
+                    }
+                }
+                // ENFORCE mode or AUDIT mode with any other error.
                 return Promise.reject(error);
-            }
-        });
+            });
+        }
+        else {
+            // Do reCAPTCHA v2 flow.
+            const requestWithRecaptchaFields = await injectRecaptchaFields(authInstance, request, actionName, false, // isCaptchaResp
+            true // isFakeToken
+            );
+            // This will call the PhoneApiCaller to fetch and inject v2 token.
+            return actionMethod(authInstance, requestWithRecaptchaFields);
+        }
+    }
+    else {
+        return Promise.reject(recaptchaAuthProvider + ' provider is not supported.');
     }
 }
 async function _initializeRecaptchaConfig(auth) {
@@ -3337,7 +3586,7 @@ async function _initializeRecaptchaConfig(auth) {
     else {
         authInternal._tenantRecaptchaConfigs[authInternal.tenantId] = config;
     }
-    if (config.isProviderEnabled("EMAIL_PASSWORD_PROVIDER" /* RecaptchaProvider.EMAIL_PASSWORD_PROVIDER */)) {
+    if (config.isAnyProviderEnabled()) {
         const verifier = new RecaptchaEnterpriseVerifier(authInternal);
         void verifier.verify();
     }
@@ -3763,7 +4012,7 @@ class EmailAuthCredential extends AuthCredential {
                     password: this._password,
                     clientType: "CLIENT_TYPE_WEB" /* RecaptchaClientType.WEB */
                 };
-                return handleRecaptchaFlow(auth, request, "signInWithPassword" /* RecaptchaActionName.SIGN_IN_WITH_PASSWORD */, signInWithPassword);
+                return handleRecaptchaFlow(auth, request, "signInWithPassword" /* RecaptchaActionName.SIGN_IN_WITH_PASSWORD */, signInWithPassword, "EMAIL_PASSWORD_PROVIDER" /* RecaptchaAuthProvider.EMAIL_PASSWORD_PROVIDER */);
             case "emailLink" /* SignInMethod.EMAIL_LINK */:
                 return signInWithEmailLink$1(auth, {
                     email: this._email,
@@ -3784,7 +4033,7 @@ class EmailAuthCredential extends AuthCredential {
                     password: this._password,
                     clientType: "CLIENT_TYPE_WEB" /* RecaptchaClientType.WEB */
                 };
-                return handleRecaptchaFlow(auth, request, "signUpPassword" /* RecaptchaActionName.SIGN_UP_PASSWORD */, linkEmailPassword);
+                return handleRecaptchaFlow(auth, request, "signUpPassword" /* RecaptchaActionName.SIGN_UP_PASSWORD */, linkEmailPassword, "EMAIL_PASSWORD_PROVIDER" /* RecaptchaAuthProvider.EMAIL_PASSWORD_PROVIDER */);
             case "emailLink" /* SignInMethod.EMAIL_LINK */:
                 return signInWithEmailLinkForLinking(auth, {
                     idToken,
@@ -5779,7 +6028,7 @@ async function sendPasswordResetEmail(auth, email, actionCodeSettings) {
     if (actionCodeSettings) {
         _setActionCodeSettingsOnRequest(authInternal, request, actionCodeSettings);
     }
-    await handleRecaptchaFlow(authInternal, request, "getOobCode" /* RecaptchaActionName.GET_OOB_CODE */, sendPasswordResetEmail$1);
+    await handleRecaptchaFlow(authInternal, request, "getOobCode" /* RecaptchaActionName.GET_OOB_CODE */, sendPasswordResetEmail$1, "EMAIL_PASSWORD_PROVIDER" /* RecaptchaAuthProvider.EMAIL_PASSWORD_PROVIDER */);
 }
 /**
  * Completes the password reset process, given a confirmation code and new password.
@@ -5912,7 +6161,7 @@ async function createUserWithEmailAndPassword(auth, email, password) {
         password,
         clientType: "CLIENT_TYPE_WEB" /* RecaptchaClientType.WEB */
     };
-    const signUpResponse = handleRecaptchaFlow(authInternal, request, "signUpPassword" /* RecaptchaActionName.SIGN_UP_PASSWORD */, signUp);
+    const signUpResponse = handleRecaptchaFlow(authInternal, request, "signUpPassword" /* RecaptchaActionName.SIGN_UP_PASSWORD */, signUp, "EMAIL_PASSWORD_PROVIDER" /* RecaptchaAuthProvider.EMAIL_PASSWORD_PROVIDER */);
     const response = await signUpResponse.catch(error => {
         if (error.code === `auth/${"password-does-not-meet-requirements" /* AuthErrorCode.PASSWORD_DOES_NOT_MEET_REQUIREMENTS */}`) {
             void recachePasswordPolicy(auth);
@@ -6026,7 +6275,7 @@ async function sendSignInLinkToEmail(auth, email, actionCodeSettings) {
         }
     }
     setActionCodeSettings(request, actionCodeSettings);
-    await handleRecaptchaFlow(authInternal, request, "getOobCode" /* RecaptchaActionName.GET_OOB_CODE */, sendSignInLinkToEmail$1);
+    await handleRecaptchaFlow(authInternal, request, "getOobCode" /* RecaptchaActionName.GET_OOB_CODE */, sendSignInLinkToEmail$1, "EMAIL_PASSWORD_PROVIDER" /* RecaptchaAuthProvider.EMAIL_PASSWORD_PROVIDER */);
 }
 /**
  * Checks if an incoming link is a sign-in with email link suitable for {@link signInWithEmailLink}.
@@ -7961,134 +8210,6 @@ function finalizeSignInTotpMfa(auth, request) {
     return _performApiRequest(auth, "POST" /* HttpMethod.POST */, "/v2/accounts/mfaSignIn:finalize" /* Endpoint.FINALIZE_MFA_SIGN_IN */, _addTidIfNecessary(auth, request));
 }
 
-/**
- * @license
- * Copyright 2020 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.
- */
-const _SOLVE_TIME_MS = 500;
-const _EXPIRATION_TIME_MS = 60000;
-const _WIDGET_ID_START = 1000000000000;
-class MockReCaptcha {
-    constructor(auth) {
-        this.auth = auth;
-        this.counter = _WIDGET_ID_START;
-        this._widgets = new Map();
-    }
-    render(container, parameters) {
-        const id = this.counter;
-        this._widgets.set(id, new MockWidget(container, this.auth.name, parameters || {}));
-        this.counter++;
-        return id;
-    }
-    reset(optWidgetId) {
-        var _a;
-        const id = optWidgetId || _WIDGET_ID_START;
-        void ((_a = this._widgets.get(id)) === null || _a === void 0 ? void 0 : _a.delete());
-        this._widgets.delete(id);
-    }
-    getResponse(optWidgetId) {
-        var _a;
-        const id = optWidgetId || _WIDGET_ID_START;
-        return ((_a = this._widgets.get(id)) === null || _a === void 0 ? void 0 : _a.getResponse()) || '';
-    }
-    async execute(optWidgetId) {
-        var _a;
-        const id = optWidgetId || _WIDGET_ID_START;
-        void ((_a = this._widgets.get(id)) === null || _a === void 0 ? void 0 : _a.execute());
-        return '';
-    }
-}
-class MockWidget {
-    constructor(containerOrId, appName, params) {
-        this.params = params;
-        this.timerId = null;
-        this.deleted = false;
-        this.responseToken = null;
-        this.clickHandler = () => {
-            this.execute();
-        };
-        const container = typeof containerOrId === 'string'
-            ? document.getElementById(containerOrId)
-            : containerOrId;
-        _assert(container, "argument-error" /* AuthErrorCode.ARGUMENT_ERROR */, { appName });
-        this.container = container;
-        this.isVisible = this.params.size !== 'invisible';
-        if (this.isVisible) {
-            this.execute();
-        }
-        else {
-            this.container.addEventListener('click', this.clickHandler);
-        }
-    }
-    getResponse() {
-        this.checkIfDeleted();
-        return this.responseToken;
-    }
-    delete() {
-        this.checkIfDeleted();
-        this.deleted = true;
-        if (this.timerId) {
-            clearTimeout(this.timerId);
-            this.timerId = null;
-        }
-        this.container.removeEventListener('click', this.clickHandler);
-    }
-    execute() {
-        this.checkIfDeleted();
-        if (this.timerId) {
-            return;
-        }
-        this.timerId = window.setTimeout(() => {
-            this.responseToken = generateRandomAlphaNumericString(50);
-            const { callback, 'expired-callback': expiredCallback } = this.params;
-            if (callback) {
-                try {
-                    callback(this.responseToken);
-                }
-                catch (e) { }
-            }
-            this.timerId = window.setTimeout(() => {
-                this.timerId = null;
-                this.responseToken = null;
-                if (expiredCallback) {
-                    try {
-                        expiredCallback();
-                    }
-                    catch (e) { }
-                }
-                if (this.isVisible) {
-                    this.execute();
-                }
-            }, _EXPIRATION_TIME_MS);
-        }, _SOLVE_TIME_MS);
-    }
-    checkIfDeleted() {
-        if (this.deleted) {
-            throw new Error('reCAPTCHA mock was already deleted!');
-        }
-    }
-}
-function generateRandomAlphaNumericString(len) {
-    const chars = [];
-    const allowedChars = '1234567890abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';
-    for (let i = 0; i < len; i++) {
-        chars.push(allowedChars.charAt(Math.floor(Math.random() * allowedChars.length)));
-    }
-    return chars.join('');
-}
-
 /**
  * @license
  * Copyright 2020 Google LLC
@@ -8443,12 +8564,15 @@ class ConfirmationResultImpl {
  * provides the code sent to their phone, call {@link ConfirmationResult.confirm}
  * with the code to sign the user in.
  *
- * For abuse prevention, this method also requires a {@link ApplicationVerifier}.
- * This SDK includes a reCAPTCHA-based implementation, {@link RecaptchaVerifier}.
+ * For abuse prevention, this method requires a {@link ApplicationVerifier}.
+ * This SDK includes an implementation based on reCAPTCHA v2, {@link RecaptchaVerifier}.
  * This function can work on other platforms that do not support the
  * {@link RecaptchaVerifier} (like React Native), but you need to use a
  * third-party {@link ApplicationVerifier} implementation.
  *
+ * If you've enabled project-level reCAPTCHA Enterprise bot protection in
+ * Enforce mode, you can omit the {@link ApplicationVerifier}.
+ *
  * This method does not work in a Node.js environment or with {@link Auth} instances created with a
  * {@link @firebase/app#FirebaseServerApp}.
  *
@@ -8522,10 +8646,19 @@ async function reauthenticateWithPhoneNumber(user, phoneNumber, appVerifier) {
  */
 async function _verifyPhoneNumber(auth, options, verifier) {
     var _a;
-    const recaptchaToken = await verifier.verify();
+    if (!auth._getRecaptchaConfig()) {
+        try {
+            await _initializeRecaptchaConfig(auth);
+        }
+        catch (error) {
+            // If an error occurs while fetching the config, there is no way to know the enablement state
+            // of Phone provider, so we proceed with recaptcha V2 verification.
+            // The error is likely "recaptchaKey undefined", as reCAPTCHA Enterprise is not
+            // enabled for any provider.
+            console.log('Failed to initialize reCAPTCHA Enterprise config. Triggering the reCAPTCHA v2 verification.');
+        }
+    }
     try {
-        _assert(typeof recaptchaToken === 'string', auth, "argument-error" /* AuthErrorCode.ARGUMENT_ERROR */);
-        _assert(verifier.type === RECAPTCHA_VERIFIER_TYPE, auth, "argument-error" /* AuthErrorCode.ARGUMENT_ERROR */);
         let phoneInfoOptions;
         if (typeof options === 'string') {
             phoneInfoOptions = {
@@ -8539,12 +8672,25 @@ async function _verifyPhoneNumber(auth, options, verifier) {
             const session = phoneInfoOptions.session;
             if ('phoneNumber' in phoneInfoOptions) {
                 _assert(session.type === "enroll" /* MultiFactorSessionType.ENROLL */, auth, "internal-error" /* AuthErrorCode.INTERNAL_ERROR */);
-                const response = await startEnrollPhoneMfa(auth, {
+                const startPhoneMfaEnrollmentRequest = {
                     idToken: session.credential,
                     phoneEnrollmentInfo: {
                         phoneNumber: phoneInfoOptions.phoneNumber,
-                        recaptchaToken
+                        clientType: "CLIENT_TYPE_WEB" /* RecaptchaClientType.WEB */
+                    }
+                };
+                const startEnrollPhoneMfaActionCallback = async (authInstance, request) => {
+                    // If reCAPTCHA Enterprise token is FAKE_TOKEN, fetch reCAPTCHA v2 token and inject into request.
+                    if (request.phoneEnrollmentInfo.captchaResponse === FAKE_TOKEN) {
+                        _assert((verifier === null || verifier === void 0 ? void 0 : verifier.type) === RECAPTCHA_VERIFIER_TYPE, authInstance, "argument-error" /* AuthErrorCode.ARGUMENT_ERROR */);
+                        const requestWithRecaptchaV2 = await injectRecaptchaV2Token(authInstance, request, verifier);
+                        return startEnrollPhoneMfa(authInstance, requestWithRecaptchaV2);
                     }
+                    return startEnrollPhoneMfa(authInstance, request);
+                };
+                const startPhoneMfaEnrollmentResponse = handleRecaptchaFlow(auth, startPhoneMfaEnrollmentRequest, "mfaSmsEnrollment" /* RecaptchaActionName.MFA_SMS_ENROLLMENT */, startEnrollPhoneMfaActionCallback, "PHONE_PROVIDER" /* RecaptchaAuthProvider.PHONE_PROVIDER */);
+                const response = await startPhoneMfaEnrollmentResponse.catch(error => {
+                    return Promise.reject(error);
                 });
                 return response.phoneSessionInfo.sessionInfo;
             }
@@ -8553,26 +8699,52 @@ async function _verifyPhoneNumber(auth, options, verifier) {
                 const mfaEnrollmentId = ((_a = phoneInfoOptions.multiFactorHint) === null || _a === void 0 ? void 0 : _a.uid) ||
                     phoneInfoOptions.multiFactorUid;
                 _assert(mfaEnrollmentId, auth, "missing-multi-factor-info" /* AuthErrorCode.MISSING_MFA_INFO */);
-                const response = await startSignInPhoneMfa(auth, {
+                const startPhoneMfaSignInRequest = {
                     mfaPendingCredential: session.credential,
                     mfaEnrollmentId,
                     phoneSignInInfo: {
-                        recaptchaToken
+                        clientType: "CLIENT_TYPE_WEB" /* RecaptchaClientType.WEB */
+                    }
+                };
+                const startSignInPhoneMfaActionCallback = async (authInstance, request) => {
+                    // If reCAPTCHA Enterprise token is FAKE_TOKEN, fetch reCAPTCHA v2 token and inject into request.
+                    if (request.phoneSignInInfo.captchaResponse === FAKE_TOKEN) {
+                        _assert((verifier === null || verifier === void 0 ? void 0 : verifier.type) === RECAPTCHA_VERIFIER_TYPE, authInstance, "argument-error" /* AuthErrorCode.ARGUMENT_ERROR */);
+                        const requestWithRecaptchaV2 = await injectRecaptchaV2Token(authInstance, request, verifier);
+                        return startSignInPhoneMfa(authInstance, requestWithRecaptchaV2);
                     }
+                    return startSignInPhoneMfa(authInstance, request);
+                };
+                const startPhoneMfaSignInResponse = handleRecaptchaFlow(auth, startPhoneMfaSignInRequest, "mfaSmsSignIn" /* RecaptchaActionName.MFA_SMS_SIGNIN */, startSignInPhoneMfaActionCallback, "PHONE_PROVIDER" /* RecaptchaAuthProvider.PHONE_PROVIDER */);
+                const response = await startPhoneMfaSignInResponse.catch(error => {
+                    return Promise.reject(error);
                 });
                 return response.phoneResponseInfo.sessionInfo;
             }
         }
         else {
-            const { sessionInfo } = await sendPhoneVerificationCode(auth, {
+            const sendPhoneVerificationCodeRequest = {
                 phoneNumber: phoneInfoOptions.phoneNumber,
-                recaptchaToken
+                clientType: "CLIENT_TYPE_WEB" /* RecaptchaClientType.WEB */
+            };
+            const sendPhoneVerificationCodeActionCallback = async (authInstance, request) => {
+                // If reCAPTCHA Enterprise token is FAKE_TOKEN, fetch reCAPTCHA v2 token and inject into request.
+                if (request.captchaResponse === FAKE_TOKEN) {
+                    _assert((verifier === null || verifier === void 0 ? void 0 : verifier.type) === RECAPTCHA_VERIFIER_TYPE, authInstance, "argument-error" /* AuthErrorCode.ARGUMENT_ERROR */);
+                    const requestWithRecaptchaV2 = await injectRecaptchaV2Token(authInstance, request, verifier);
+                    return sendPhoneVerificationCode(authInstance, requestWithRecaptchaV2);
+                }
+                return sendPhoneVerificationCode(authInstance, request);
+            };
+            const sendPhoneVerificationCodeResponse = handleRecaptchaFlow(auth, sendPhoneVerificationCodeRequest, "sendVerificationCode" /* RecaptchaActionName.SEND_VERIFICATION_CODE */, sendPhoneVerificationCodeActionCallback, "PHONE_PROVIDER" /* RecaptchaAuthProvider.PHONE_PROVIDER */);
+            const response = await sendPhoneVerificationCodeResponse.catch(error => {
+                return Promise.reject(error);
             });
-            return sessionInfo;
+            return response.sessionInfo;
         }
     }
     finally {
-        verifier._reset();
+        verifier === null || verifier === void 0 ? void 0 : verifier._reset();
     }
 }
 /**
@@ -8604,6 +8776,49 @@ async function updatePhoneNumber(user, credential) {
         return Promise.reject(_serverAppCurrentUserOperationNotSupportedError(userInternal.auth));
     }
     await _link$1(userInternal, credential);
+}
+// Helper function that fetches and injects a reCAPTCHA v2 token into the request.
+async function injectRecaptchaV2Token(auth, request, recaptchaV2Verifier) {
+    _assert(recaptchaV2Verifier.type === RECAPTCHA_VERIFIER_TYPE, auth, "argument-error" /* AuthErrorCode.ARGUMENT_ERROR */);
+    const recaptchaV2Token = await recaptchaV2Verifier.verify();
+    _assert(typeof recaptchaV2Token === 'string', auth, "argument-error" /* AuthErrorCode.ARGUMENT_ERROR */);
+    const newRequest = Object.assign({}, request);
+    if ('phoneEnrollmentInfo' in newRequest) {
+        const phoneNumber = newRequest.phoneEnrollmentInfo.phoneNumber;
+        const captchaResponse = newRequest.phoneEnrollmentInfo.captchaResponse;
+        const clientType = newRequest
+            .phoneEnrollmentInfo.clientType;
+        const recaptchaVersion = newRequest.phoneEnrollmentInfo.recaptchaVersion;
+        Object.assign(newRequest, {
+            'phoneEnrollmentInfo': {
+                phoneNumber,
+                recaptchaToken: recaptchaV2Token,
+                captchaResponse,
+                clientType,
+                recaptchaVersion
+            }
+        });
+        return newRequest;
+    }
+    else if ('phoneSignInInfo' in newRequest) {
+        const captchaResponse = newRequest.phoneSignInInfo.captchaResponse;
+        const clientType = newRequest
+            .phoneSignInInfo.clientType;
+        const recaptchaVersion = newRequest.phoneSignInInfo.recaptchaVersion;
+        Object.assign(newRequest, {
+            'phoneSignInInfo': {
+                recaptchaToken: recaptchaV2Token,
+                captchaResponse,
+                clientType,
+                recaptchaVersion
+            }
+        });
+        return newRequest;
+    }
+    else {
+        Object.assign(newRequest, { 'recaptchaToken': recaptchaV2Token });
+        return newRequest;
+    }
 }
 
 /**
@@ -8675,12 +8890,14 @@ class PhoneAuthProvider {
      *
      * @param phoneInfoOptions - The user's {@link PhoneInfoOptions}. The phone number should be in
      * E.164 format (e.g. +16505550101).
-     * @param applicationVerifier - For abuse prevention, this method also requires a
-     * {@link ApplicationVerifier}. This SDK includes a reCAPTCHA-based implementation,
-     * {@link RecaptchaVerifier}.
+     * @param applicationVerifier - An {@link ApplicationVerifier}, which prevents
+     * requests from unauthorized clients. This SDK includes an implementation
+     * based on reCAPTCHA v2, {@link RecaptchaVerifier}. If you've enabled
+     * reCAPTCHA Enterprise bot protection in Enforce mode, this parameter is
+     * optional; in all other configurations, the parameter is required.
      *
      * @returns A Promise for a verification ID that can be passed to
-     * {@link PhoneAuthProvider.credential} to identify this flow..
+     * {@link PhoneAuthProvider.credential} to identify this flow.
      */
     verifyPhoneNumber(phoneOptions, applicationVerifier) {
         return _verifyPhoneNumber(this.auth, phoneOptions, getModularInstance(applicationVerifier));
@@ -10439,7 +10656,7 @@ function _isEmptyString(input) {
 }
 
 var name = "@firebase/auth";
-var version = "1.7.9";
+var version = "1.8.0";
 
 /**
  * @license
@@ -10581,7 +10798,7 @@ function registerAuth(clientPlatform) {
         return (auth => new AuthInterop(auth))(auth);
     }, "PRIVATE" /* ComponentType.PRIVATE */).setInstantiationMode("EXPLICIT" /* InstantiationMode.EXPLICIT */));
     registerVersion(name, version, getVersionForPlatform(clientPlatform));
-    // BUILD_TARGET will be replaced by values like esm5, esm2017, cjs5, etc during the compilation
+    // BUILD_TARGET will be replaced by values like esm2017, cjs2017, etc during the compilation
     registerVersion(name, version, 'esm2017');
 }
 
@@ -10694,4 +10911,4 @@ _setExternalJSProvider({
 registerAuth("Browser" /* ClientPlatform.BROWSER */);
 
 export { TwitterAuthProvider as $, ActionCodeOperation as A, updateCurrentUser as B, signOut as C, revokeAccessToken as D, deleteUser as E, FactorId as F, debugErrorMap as G, prodErrorMap as H, AUTH_ERROR_CODES_MAP_DO_NOT_USE_INTERNALLY as I, initializeAuth as J, connectAuthEmulator as K, AuthCredential as L, EmailAuthCredential as M, OAuthCredential as N, OperationType as O, PhoneAuthProvider as P, PhoneAuthCredential as Q, RecaptchaVerifier as R, SignInMethod as S, TotpMultiFactorGenerator as T, inMemoryPersistence as U, EmailAuthProvider as V, FacebookAuthProvider as W, GoogleAuthProvider as X, GithubAuthProvider as Y, OAuthProvider as Z, SAMLAuthProvider as _, browserSessionPersistence as a, signInAnonymously as a0, signInWithCredential as a1, linkWithCredential as a2, reauthenticateWithCredential as a3, signInWithCustomToken as a4, sendPasswordResetEmail as a5, confirmPasswordReset as a6, applyActionCode as a7, checkActionCode as a8, verifyPasswordResetCode as a9, _isIOS7Or8 as aA, _createError as aB, _assert as aC, AuthEventManager as aD, _getInstance as aE, _persistenceKeyName as aF, _getRedirectResult as aG, _overrideRedirectResult as aH, _clearRedirectOutcomes as aI, _castAuth as aJ, UserImpl as aK, AuthImpl as aL, _getClientVersion as aM, _generateEventId as aN, AuthPopup as aO, FetchProvider as aP, SAMLAuthCredential as aQ, createUserWithEmailAndPassword as aa, signInWithEmailAndPassword as ab, sendSignInLinkToEmail as ac, isSignInWithEmailLink as ad, signInWithEmailLink as ae, fetchSignInMethodsForEmail as af, sendEmailVerification as ag, verifyBeforeUpdateEmail as ah, ActionCodeURL as ai, parseActionCodeURL as aj, updateProfile as ak, updateEmail as al, updatePassword as am, getIdToken as an, getIdTokenResult as ao, unlink as ap, getAdditionalUserInfo as aq, reload as ar, getMultiFactorResolver as as, multiFactor as at, debugAssert as au, _isIOS as av, _isAndroid as aw, _fail as ax, _getRedirectUrl as ay, _getProjectConfig 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, TotpSecret as n, getAuth as o, ProviderId as p, setPersistence as q, reauthenticateWithPhoneNumber as r, signInWithPhoneNumber as s, initializeRecaptchaConfig as t, updatePhoneNumber as u, validatePassword as v, onIdTokenChanged as w, beforeAuthStateChanged as x, onAuthStateChanged as y, useDeviceLanguage as z };
-//# sourceMappingURL=index-68602d24.js.map
+//# sourceMappingURL=index-a7d5cfcc.js.map