@firebase/auth-compat 0.5.14 → 0.5.15

package/dist/index.node.cjs.js

@@ -4,8 +4,6 @@ var firebase = require('@firebase/app-compat');
 var exp = require('@firebase/auth/internal');
 var component = require('@firebase/component');
 var util = require('@firebase/util');
-var tslib = require('tslib');
-var undici = require('undici');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
@@ -31,7 +29,7 @@ var firebase__default = /*#__PURE__*/_interopDefaultLegacy(firebase);
 var exp__namespace = /*#__PURE__*/_interopNamespace(exp);
 
 var name = "@firebase/auth-compat";
-var version = "0.5.14";
+var version = "0.5.15";
 
 /**
  * @license
@@ -49,7 +47,7 @@ var version = "0.5.14";
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-var CORDOVA_ONDEVICEREADY_TIMEOUT_MS = 1000;
+const CORDOVA_ONDEVICEREADY_TIMEOUT_MS = 1000;
 function _getCurrentScheme() {
     var _a;
     return ((_a = self === null || self === void 0 ? void 0 : self.location) === null || _a === void 0 ? void 0 : _a.protocol) || null;
@@ -65,8 +63,7 @@ function _isHttpOrHttps() {
  * @return {boolean} Whether the app is rendered in a mobile iOS or Android
  *     Cordova environment.
  */
-function _isAndroidOrIosCordovaScheme(ua) {
-    if (ua === void 0) { ua = util.getUA(); }
+function _isAndroidOrIosCordovaScheme(ua = util.getUA()) {
     return !!((_getCurrentScheme() === 'file:' ||
         _getCurrentScheme() === 'ionic:' ||
         _getCurrentScheme() === 'capacitor:') &&
@@ -91,8 +88,7 @@ function _isIe11() {
  * @param {string} userAgent The browser user agent string.
  * @return {boolean} True if it is Edge.
  */
-function _isEdge(ua) {
-    if (ua === void 0) { ua = util.getUA(); }
+function _isEdge(ua = util.getUA()) {
     return /Edge\/\d+/.test(ua);
 }
 /**
@@ -100,15 +96,14 @@ function _isEdge(ua) {
  * @return {boolean} Whether local storage is not synchronized between an iframe
  *     and a popup of the same domain.
  */
-function _isLocalStorageNotSynchronized(ua) {
-    if (ua === void 0) { ua = util.getUA(); }
+function _isLocalStorageNotSynchronized(ua = util.getUA()) {
     return _isIe11() || _isEdge(ua);
 }
 /** @return {boolean} Whether web storage is supported. */
 function _isWebStorageSupported() {
     try {
-        var storage = self.localStorage;
-        var key = exp__namespace._generateEventId();
+        const storage = self.localStorage;
+        const key = exp__namespace._generateEventId();
         if (storage) {
             // setItem will throw an exception if we cannot access WebStorage (e.g.,
             // Safari in private mode).
@@ -161,22 +156,18 @@ function _isPopupRedirectSupported() {
 function _isLikelyCordova() {
     return _isAndroidOrIosCordovaScheme() && typeof document !== 'undefined';
 }
-function _isCordova() {
-    return tslib.__awaiter(this, void 0, void 0, function () {
-        return tslib.__generator(this, function (_a) {
-            if (!_isLikelyCordova()) {
-                return [2 /*return*/, false];
-            }
-            return [2 /*return*/, new Promise(function (resolve) {
-                    var timeoutId = setTimeout(function () {
-                        // We've waited long enough; the telltale Cordova event didn't happen
-                        resolve(false);
-                    }, CORDOVA_ONDEVICEREADY_TIMEOUT_MS);
-                    document.addEventListener('deviceready', function () {
-                        clearTimeout(timeoutId);
-                        resolve(true);
-                    });
-                })];
+async function _isCordova() {
+    if (!_isLikelyCordova()) {
+        return false;
+    }
+    return new Promise(resolve => {
+        const timeoutId = setTimeout(() => {
+            // We've waited long enough; the telltale Cordova event didn't happen
+            resolve(false);
+        }, CORDOVA_ONDEVICEREADY_TIMEOUT_MS);
+        document.addEventListener('deviceready', () => {
+            clearTimeout(timeoutId);
+            resolve(true);
         });
     });
 }
@@ -200,13 +191,13 @@ function _getSelfWindow() {
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-var Persistence = {
+const Persistence = {
     LOCAL: 'local',
     NONE: 'none',
     SESSION: 'session'
 };
-var _assert$3 = exp__namespace._assert;
-var PERSISTENCE_KEY = 'persistence';
+const _assert$3 = exp__namespace._assert;
+const PERSISTENCE_KEY = 'persistence';
 /**
  * Validates that an argument is a valid persistence value. If an invalid type
  * is specified, an error is thrown synchronously.
@@ -234,31 +225,21 @@ function _validatePersistenceArgument(auth, persistence) {
     // This is restricted by what the browser supports.
     _assert$3(persistence === Persistence.NONE || _isWebStorageSupported(), auth, "unsupported-persistence-type" /* exp.AuthErrorCode.UNSUPPORTED_PERSISTENCE */);
 }
-function _savePersistenceForRedirect(auth) {
-    return tslib.__awaiter(this, void 0, void 0, function () {
-        var session, key;
-        return tslib.__generator(this, function (_a) {
-            switch (_a.label) {
-                case 0: return [4 /*yield*/, auth._initializationPromise];
-                case 1:
-                    _a.sent();
-                    session = getSessionStorageIfAvailable();
-                    key = exp__namespace._persistenceKeyName(PERSISTENCE_KEY, auth.config.apiKey, auth.name);
-                    if (session) {
-                        session.setItem(key, auth._getPersistence());
-                    }
-                    return [2 /*return*/];
-            }
-        });
-    });
+async function _savePersistenceForRedirect(auth) {
+    await auth._initializationPromise;
+    const session = getSessionStorageIfAvailable();
+    const key = exp__namespace._persistenceKeyName(PERSISTENCE_KEY, auth.config.apiKey, auth.name);
+    if (session) {
+        session.setItem(key, auth._getPersistence());
+    }
 }
 function _getPersistencesFromRedirect(apiKey, appName) {
-    var session = getSessionStorageIfAvailable();
+    const session = getSessionStorageIfAvailable();
     if (!session) {
         return [];
     }
-    var key = exp__namespace._persistenceKeyName(PERSISTENCE_KEY, apiKey, appName);
-    var persistence = session.getItem(key);
+    const key = exp__namespace._persistenceKeyName(PERSISTENCE_KEY, apiKey, appName);
+    const persistence = session.getItem(key);
     switch (persistence) {
         case Persistence.NONE:
             return [exp__namespace.inMemoryPersistence];
@@ -297,10 +278,10 @@ function getSessionStorageIfAvailable() {
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-var _assert$2 = exp__namespace._assert;
+const _assert$2 = exp__namespace._assert;
 /** Platform-agnostic popup-redirect resolver */
-var CompatPopupRedirectResolver = /** @class */ (function () {
-    function CompatPopupRedirectResolver() {
+class CompatPopupRedirectResolver {
+    constructor() {
         // Create both resolvers for dynamic resolution later
         this.browserResolver = exp__namespace._getInstance(exp__namespace.browserPopupRedirectResolver);
         this.cordovaResolver = exp__namespace._getInstance(exp__namespace.cordovaPopupRedirectResolver);
@@ -310,85 +291,43 @@ var CompatPopupRedirectResolver = /** @class */ (function () {
         this._completeRedirectFn = exp__namespace._getRedirectResult;
         this._overrideRedirectResult = exp__namespace._overrideRedirectResult;
     }
-    CompatPopupRedirectResolver.prototype._initialize = function (auth) {
-        return tslib.__awaiter(this, void 0, void 0, function () {
-            return tslib.__generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.selectUnderlyingResolver()];
-                    case 1:
-                        _a.sent();
-                        return [2 /*return*/, this.assertedUnderlyingResolver._initialize(auth)];
-                }
-            });
-        });
-    };
-    CompatPopupRedirectResolver.prototype._openPopup = function (auth, provider, authType, eventId) {
-        return tslib.__awaiter(this, void 0, void 0, function () {
-            return tslib.__generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.selectUnderlyingResolver()];
-                    case 1:
-                        _a.sent();
-                        return [2 /*return*/, this.assertedUnderlyingResolver._openPopup(auth, provider, authType, eventId)];
-                }
-            });
-        });
-    };
-    CompatPopupRedirectResolver.prototype._openRedirect = function (auth, provider, authType, eventId) {
-        return tslib.__awaiter(this, void 0, void 0, function () {
-            return tslib.__generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.selectUnderlyingResolver()];
-                    case 1:
-                        _a.sent();
-                        return [2 /*return*/, this.assertedUnderlyingResolver._openRedirect(auth, provider, authType, eventId)];
-                }
-            });
-        });
-    };
-    CompatPopupRedirectResolver.prototype._isIframeWebStorageSupported = function (auth, cb) {
+    async _initialize(auth) {
+        await this.selectUnderlyingResolver();
+        return this.assertedUnderlyingResolver._initialize(auth);
+    }
+    async _openPopup(auth, provider, authType, eventId) {
+        await this.selectUnderlyingResolver();
+        return this.assertedUnderlyingResolver._openPopup(auth, provider, authType, eventId);
+    }
+    async _openRedirect(auth, provider, authType, eventId) {
+        await this.selectUnderlyingResolver();
+        return this.assertedUnderlyingResolver._openRedirect(auth, provider, authType, eventId);
+    }
+    _isIframeWebStorageSupported(auth, cb) {
         this.assertedUnderlyingResolver._isIframeWebStorageSupported(auth, cb);
-    };
-    CompatPopupRedirectResolver.prototype._originValidation = function (auth) {
+    }
+    _originValidation(auth) {
         return this.assertedUnderlyingResolver._originValidation(auth);
-    };
-    Object.defineProperty(CompatPopupRedirectResolver.prototype, "_shouldInitProactively", {
-        get: function () {
-            return _isLikelyCordova() || this.browserResolver._shouldInitProactively;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(CompatPopupRedirectResolver.prototype, "assertedUnderlyingResolver", {
-        get: function () {
-            _assert$2(this.underlyingResolver, "internal-error" /* exp.AuthErrorCode.INTERNAL_ERROR */);
-            return this.underlyingResolver;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    CompatPopupRedirectResolver.prototype.selectUnderlyingResolver = function () {
-        return tslib.__awaiter(this, void 0, void 0, function () {
-            var isCordova;
-            return tslib.__generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        if (this.underlyingResolver) {
-                            return [2 /*return*/];
-                        }
-                        return [4 /*yield*/, _isCordova()];
-                    case 1:
-                        isCordova = _a.sent();
-                        this.underlyingResolver = isCordova
-                            ? this.cordovaResolver
-                            : this.browserResolver;
-                        return [2 /*return*/];
-                }
-            });
-        });
-    };
-    return CompatPopupRedirectResolver;
-}());
+    }
+    get _shouldInitProactively() {
+        return _isLikelyCordova() || this.browserResolver._shouldInitProactively;
+    }
+    get assertedUnderlyingResolver() {
+        _assert$2(this.underlyingResolver, "internal-error" /* exp.AuthErrorCode.INTERNAL_ERROR */);
+        return this.underlyingResolver;
+    }
+    async selectUnderlyingResolver() {
+        if (this.underlyingResolver) {
+            return;
+        }
+        // We haven't yet determined whether or not we're in Cordova; go ahead
+        // and determine that state now.
+        const isCordova = await _isCordova();
+        this.underlyingResolver = isCordova
+            ? this.cordovaResolver
+            : this.browserResolver;
+    }
+}
 
 /**
  * @license
@@ -436,14 +375,14 @@ function attachExtraErrorFields(auth, e) {
     var _a;
     // The response contains all fields from the server which may or may not
     // actually match the underlying type
-    var response = (_a = e.customData) === null || _a === void 0 ? void 0 : _a._tokenResponse;
+    const response = (_a = e.customData) === null || _a === void 0 ? void 0 : _a._tokenResponse;
     if ((e === null || e === void 0 ? void 0 : e.code) === 'auth/multi-factor-auth-required') {
-        var mfaErr = e;
+        const mfaErr = e;
         mfaErr.resolver = new MultiFactorResolver(auth, exp__namespace.getMultiFactorResolver(auth, e));
     }
     else if (response) {
-        var credential = credentialFromObject(e);
-        var credErr = e;
+        const credential = credentialFromObject(e);
+        const credErr = e;
         if (credential) {
             credErr.credential = credential;
             credErr.tenantId = response.tenantId || undefined;
@@ -453,7 +392,7 @@ function attachExtraErrorFields(auth, e) {
     }
 }
 function credentialFromObject(object) {
-    var _tokenResponse = (object instanceof util.FirebaseError ? object.customData : object)._tokenResponse;
+    const { _tokenResponse } = (object instanceof util.FirebaseError ? object.customData : object);
     if (!_tokenResponse) {
         return null;
     }
@@ -465,13 +404,13 @@ function credentialFromObject(object) {
             return exp__namespace.PhoneAuthProvider.credentialFromResult(object);
         }
     }
-    var providerId = _tokenResponse.providerId;
+    const providerId = _tokenResponse.providerId;
     // Email and password is not supported as there is no situation where the
     // server would return the password to the client.
     if (!providerId || providerId === exp__namespace.ProviderId.PASSWORD) {
         return null;
     }
-    var provider;
+    let provider;
     switch (providerId) {
         case exp__namespace.ProviderId.GOOGLE:
             provider = exp__namespace.GoogleAuthProvider;
@@ -486,7 +425,7 @@ function credentialFromObject(object) {
             provider = exp__namespace.TwitterAuthProvider;
             break;
         default:
-            var _a = _tokenResponse, oauthIdToken = _a.oauthIdToken, oauthAccessToken = _a.oauthAccessToken, oauthTokenSecret = _a.oauthTokenSecret, pendingToken = _a.pendingToken, nonce = _a.nonce;
+            const { oauthIdToken, oauthAccessToken, oauthTokenSecret, pendingToken, nonce } = _tokenResponse;
             if (!oauthAccessToken &&
                 !oauthTokenSecret &&
                 !oauthIdToken &&
@@ -501,9 +440,9 @@ function credentialFromObject(object) {
                 else {
                     // OIDC and non-default providers excluding Twitter.
                     return exp__namespace.OAuthCredential._fromParams({
-                        providerId: providerId,
+                        providerId,
                         signInMethod: providerId,
-                        pendingToken: pendingToken,
+                        pendingToken,
                         idToken: oauthIdToken,
                         accessToken: oauthAccessToken
                     });
@@ -521,65 +460,45 @@ function credentialFromObject(object) {
 }
 function convertCredential(auth, credentialPromise) {
     return credentialPromise
-        .catch(function (e) {
+        .catch(e => {
         if (e instanceof util.FirebaseError) {
             attachExtraErrorFields(auth, e);
         }
         throw e;
     })
-        .then(function (credential) {
-        var operationType = credential.operationType;
-        var user = credential.user;
+        .then(credential => {
+        const operationType = credential.operationType;
+        const user = credential.user;
         return {
-            operationType: operationType,
+            operationType,
             credential: credentialFromResponse(credential),
             additionalUserInfo: exp__namespace.getAdditionalUserInfo(credential),
             user: User.getOrCreate(user)
         };
     });
 }
-function convertConfirmationResult(auth, confirmationResultPromise) {
-    return tslib.__awaiter(this, void 0, void 0, function () {
-        var confirmationResultExp;
-        return tslib.__generator(this, function (_a) {
-            switch (_a.label) {
-                case 0: return [4 /*yield*/, confirmationResultPromise];
-                case 1:
-                    confirmationResultExp = _a.sent();
-                    return [2 /*return*/, {
-                            verificationId: confirmationResultExp.verificationId,
-                            confirm: function (verificationCode) {
-                                return convertCredential(auth, confirmationResultExp.confirm(verificationCode));
-                            }
-                        }];
-            }
-        });
-    });
+async function convertConfirmationResult(auth, confirmationResultPromise) {
+    const confirmationResultExp = await confirmationResultPromise;
+    return {
+        verificationId: confirmationResultExp.verificationId,
+        confirm: (verificationCode) => convertCredential(auth, confirmationResultExp.confirm(verificationCode))
+    };
 }
-var MultiFactorResolver = /** @class */ (function () {
-    function MultiFactorResolver(auth, resolver) {
+class MultiFactorResolver {
+    constructor(auth, resolver) {
         this.resolver = resolver;
         this.auth = wrapped(auth);
     }
-    Object.defineProperty(MultiFactorResolver.prototype, "session", {
-        get: function () {
-            return this.resolver.session;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(MultiFactorResolver.prototype, "hints", {
-        get: function () {
-            return this.resolver.hints;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    MultiFactorResolver.prototype.resolveSignIn = function (assertion) {
+    get session() {
+        return this.resolver.session;
+    }
+    get hints() {
+        return this.resolver.hints;
+    }
+    resolveSignIn(assertion) {
         return convertCredential(unwrap(this.auth), this.resolver.resolveSignIn(assertion));
-    };
-    return MultiFactorResolver;
-}());
+    }
+}
 
 /**
  * @license
@@ -597,222 +516,129 @@ var MultiFactorResolver = /** @class */ (function () {
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-var User = /** @class */ (function () {
-    function User(_delegate) {
+class User {
+    constructor(_delegate) {
         this._delegate = _delegate;
         this.multiFactor = exp__namespace.multiFactor(_delegate);
     }
-    User.getOrCreate = function (user) {
+    static getOrCreate(user) {
         if (!User.USER_MAP.has(user)) {
             User.USER_MAP.set(user, new User(user));
         }
         return User.USER_MAP.get(user);
-    };
-    User.prototype.delete = function () {
+    }
+    delete() {
         return this._delegate.delete();
-    };
-    User.prototype.reload = function () {
+    }
+    reload() {
         return this._delegate.reload();
-    };
-    User.prototype.toJSON = function () {
+    }
+    toJSON() {
         return this._delegate.toJSON();
-    };
-    User.prototype.getIdTokenResult = function (forceRefresh) {
+    }
+    getIdTokenResult(forceRefresh) {
         return this._delegate.getIdTokenResult(forceRefresh);
-    };
-    User.prototype.getIdToken = function (forceRefresh) {
+    }
+    getIdToken(forceRefresh) {
         return this._delegate.getIdToken(forceRefresh);
-    };
-    User.prototype.linkAndRetrieveDataWithCredential = function (credential) {
+    }
+    linkAndRetrieveDataWithCredential(credential) {
         return this.linkWithCredential(credential);
-    };
-    User.prototype.linkWithCredential = function (credential) {
-        return tslib.__awaiter(this, void 0, void 0, function () {
-            return tslib.__generator(this, function (_a) {
-                return [2 /*return*/, convertCredential(this.auth, exp__namespace.linkWithCredential(this._delegate, credential))];
-            });
-        });
-    };
-    User.prototype.linkWithPhoneNumber = function (phoneNumber, applicationVerifier) {
-        return tslib.__awaiter(this, void 0, void 0, function () {
-            return tslib.__generator(this, function (_a) {
-                return [2 /*return*/, convertConfirmationResult(this.auth, exp__namespace.linkWithPhoneNumber(this._delegate, phoneNumber, applicationVerifier))];
-            });
-        });
-    };
-    User.prototype.linkWithPopup = function (provider) {
-        return tslib.__awaiter(this, void 0, void 0, function () {
-            return tslib.__generator(this, function (_a) {
-                return [2 /*return*/, convertCredential(this.auth, exp__namespace.linkWithPopup(this._delegate, provider, CompatPopupRedirectResolver))];
-            });
-        });
-    };
-    User.prototype.linkWithRedirect = function (provider) {
-        return tslib.__awaiter(this, void 0, void 0, function () {
-            return tslib.__generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, _savePersistenceForRedirect(exp__namespace._castAuth(this.auth))];
-                    case 1:
-                        _a.sent();
-                        return [2 /*return*/, exp__namespace.linkWithRedirect(this._delegate, provider, CompatPopupRedirectResolver)];
-                }
-            });
-        });
-    };
-    User.prototype.reauthenticateAndRetrieveDataWithCredential = function (credential) {
+    }
+    async linkWithCredential(credential) {
+        return convertCredential(this.auth, exp__namespace.linkWithCredential(this._delegate, credential));
+    }
+    async linkWithPhoneNumber(phoneNumber, applicationVerifier) {
+        return convertConfirmationResult(this.auth, exp__namespace.linkWithPhoneNumber(this._delegate, phoneNumber, applicationVerifier));
+    }
+    async linkWithPopup(provider) {
+        return convertCredential(this.auth, exp__namespace.linkWithPopup(this._delegate, provider, CompatPopupRedirectResolver));
+    }
+    async linkWithRedirect(provider) {
+        await _savePersistenceForRedirect(exp__namespace._castAuth(this.auth));
+        return exp__namespace.linkWithRedirect(this._delegate, provider, CompatPopupRedirectResolver);
+    }
+    reauthenticateAndRetrieveDataWithCredential(credential) {
         return this.reauthenticateWithCredential(credential);
-    };
-    User.prototype.reauthenticateWithCredential = function (credential) {
-        return tslib.__awaiter(this, void 0, void 0, function () {
-            return tslib.__generator(this, function (_a) {
-                return [2 /*return*/, convertCredential(this.auth, exp__namespace.reauthenticateWithCredential(this._delegate, credential))];
-            });
-        });
-    };
-    User.prototype.reauthenticateWithPhoneNumber = function (phoneNumber, applicationVerifier) {
+    }
+    async reauthenticateWithCredential(credential) {
+        return convertCredential(this.auth, exp__namespace.reauthenticateWithCredential(this._delegate, credential));
+    }
+    reauthenticateWithPhoneNumber(phoneNumber, applicationVerifier) {
         return convertConfirmationResult(this.auth, exp__namespace.reauthenticateWithPhoneNumber(this._delegate, phoneNumber, applicationVerifier));
-    };
-    User.prototype.reauthenticateWithPopup = function (provider) {
+    }
+    reauthenticateWithPopup(provider) {
         return convertCredential(this.auth, exp__namespace.reauthenticateWithPopup(this._delegate, provider, CompatPopupRedirectResolver));
-    };
-    User.prototype.reauthenticateWithRedirect = function (provider) {
-        return tslib.__awaiter(this, void 0, void 0, function () {
-            return tslib.__generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, _savePersistenceForRedirect(exp__namespace._castAuth(this.auth))];
-                    case 1:
-                        _a.sent();
-                        return [2 /*return*/, exp__namespace.reauthenticateWithRedirect(this._delegate, provider, CompatPopupRedirectResolver)];
-                }
-            });
-        });
-    };
-    User.prototype.sendEmailVerification = function (actionCodeSettings) {
+    }
+    async reauthenticateWithRedirect(provider) {
+        await _savePersistenceForRedirect(exp__namespace._castAuth(this.auth));
+        return exp__namespace.reauthenticateWithRedirect(this._delegate, provider, CompatPopupRedirectResolver);
+    }
+    sendEmailVerification(actionCodeSettings) {
         return exp__namespace.sendEmailVerification(this._delegate, actionCodeSettings);
-    };
-    User.prototype.unlink = function (providerId) {
-        return tslib.__awaiter(this, void 0, void 0, function () {
-            return tslib.__generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, exp__namespace.unlink(this._delegate, providerId)];
-                    case 1:
-                        _a.sent();
-                        return [2 /*return*/, this];
-                }
-            });
-        });
-    };
-    User.prototype.updateEmail = function (newEmail) {
+    }
+    async unlink(providerId) {
+        await exp__namespace.unlink(this._delegate, providerId);
+        return this;
+    }
+    updateEmail(newEmail) {
         return exp__namespace.updateEmail(this._delegate, newEmail);
-    };
-    User.prototype.updatePassword = function (newPassword) {
+    }
+    updatePassword(newPassword) {
         return exp__namespace.updatePassword(this._delegate, newPassword);
-    };
-    User.prototype.updatePhoneNumber = function (phoneCredential) {
+    }
+    updatePhoneNumber(phoneCredential) {
         return exp__namespace.updatePhoneNumber(this._delegate, phoneCredential);
-    };
-    User.prototype.updateProfile = function (profile) {
+    }
+    updateProfile(profile) {
         return exp__namespace.updateProfile(this._delegate, profile);
-    };
-    User.prototype.verifyBeforeUpdateEmail = function (newEmail, actionCodeSettings) {
+    }
+    verifyBeforeUpdateEmail(newEmail, actionCodeSettings) {
         return exp__namespace.verifyBeforeUpdateEmail(this._delegate, newEmail, actionCodeSettings);
-    };
-    Object.defineProperty(User.prototype, "emailVerified", {
-        get: function () {
-            return this._delegate.emailVerified;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(User.prototype, "isAnonymous", {
-        get: function () {
-            return this._delegate.isAnonymous;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(User.prototype, "metadata", {
-        get: function () {
-            return this._delegate.metadata;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(User.prototype, "phoneNumber", {
-        get: function () {
-            return this._delegate.phoneNumber;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(User.prototype, "providerData", {
-        get: function () {
-            return this._delegate.providerData;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(User.prototype, "refreshToken", {
-        get: function () {
-            return this._delegate.refreshToken;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(User.prototype, "tenantId", {
-        get: function () {
-            return this._delegate.tenantId;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(User.prototype, "displayName", {
-        get: function () {
-            return this._delegate.displayName;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(User.prototype, "email", {
-        get: function () {
-            return this._delegate.email;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(User.prototype, "photoURL", {
-        get: function () {
-            return this._delegate.photoURL;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(User.prototype, "providerId", {
-        get: function () {
-            return this._delegate.providerId;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(User.prototype, "uid", {
-        get: function () {
-            return this._delegate.uid;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(User.prototype, "auth", {
-        get: function () {
-            return this._delegate.auth;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    // Maintain a map so that there's always a 1:1 mapping between new User and
-    // legacy compat users
-    User.USER_MAP = new WeakMap();
-    return User;
-}());
+    }
+    get emailVerified() {
+        return this._delegate.emailVerified;
+    }
+    get isAnonymous() {
+        return this._delegate.isAnonymous;
+    }
+    get metadata() {
+        return this._delegate.metadata;
+    }
+    get phoneNumber() {
+        return this._delegate.phoneNumber;
+    }
+    get providerData() {
+        return this._delegate.providerData;
+    }
+    get refreshToken() {
+        return this._delegate.refreshToken;
+    }
+    get tenantId() {
+        return this._delegate.tenantId;
+    }
+    get displayName() {
+        return this._delegate.displayName;
+    }
+    get email() {
+        return this._delegate.email;
+    }
+    get photoURL() {
+        return this._delegate.photoURL;
+    }
+    get providerId() {
+        return this._delegate.providerId;
+    }
+    get uid() {
+        return this._delegate.uid;
+    }
+    get auth() {
+        return this._delegate.auth;
+    }
+}
+// Maintain a map so that there's always a 1:1 mapping between new User and
+// legacy compat users
+User.USER_MAP = new WeakMap();
 
 /**
  * @license
@@ -830,16 +656,16 @@ var User = /** @class */ (function () {
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-var _assert$1 = exp__namespace._assert;
-var Auth = /** @class */ (function () {
-    function Auth(app, provider) {
+const _assert$1 = exp__namespace._assert;
+class Auth {
+    constructor(app, provider) {
         this.app = app;
         if (provider.isInitialized()) {
             this._delegate = provider.getImmediate();
             this.linkUnderlyingAuth();
             return;
         }
-        var apiKey = app.options.apiKey;
+        const { apiKey } = app.options;
         // TODO: platform needs to be determined using heuristics
         _assert$1(apiKey, "invalid-api-key" /* exp.AuthErrorCode.INVALID_API_KEY */, {
             appName: app.name
@@ -849,7 +675,7 @@ var Auth = /** @class */ (function () {
             appName: app.name
         });
         // Only use a popup/redirect resolver in browser environments
-        var resolver = typeof window !== 'undefined' ? CompatPopupRedirectResolver : undefined;
+        const resolver = typeof window !== 'undefined' ? CompatPopupRedirectResolver : undefined;
         this._delegate = provider.initialize({
             options: {
                 persistence: buildPersistenceHierarchy(apiKey, app.name),
@@ -859,240 +685,178 @@ var Auth = /** @class */ (function () {
         this._delegate._updateErrorMap(exp__namespace.debugErrorMap);
         this.linkUnderlyingAuth();
     }
-    Object.defineProperty(Auth.prototype, "emulatorConfig", {
-        get: function () {
-            return this._delegate.emulatorConfig;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(Auth.prototype, "currentUser", {
-        get: function () {
-            if (!this._delegate.currentUser) {
-                return null;
-            }
-            return User.getOrCreate(this._delegate.currentUser);
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(Auth.prototype, "languageCode", {
-        get: function () {
-            return this._delegate.languageCode;
-        },
-        set: function (languageCode) {
-            this._delegate.languageCode = languageCode;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(Auth.prototype, "settings", {
-        get: function () {
-            return this._delegate.settings;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Object.defineProperty(Auth.prototype, "tenantId", {
-        get: function () {
-            return this._delegate.tenantId;
-        },
-        set: function (tid) {
-            this._delegate.tenantId = tid;
-        },
-        enumerable: false,
-        configurable: true
-    });
-    Auth.prototype.useDeviceLanguage = function () {
+    get emulatorConfig() {
+        return this._delegate.emulatorConfig;
+    }
+    get currentUser() {
+        if (!this._delegate.currentUser) {
+            return null;
+        }
+        return User.getOrCreate(this._delegate.currentUser);
+    }
+    get languageCode() {
+        return this._delegate.languageCode;
+    }
+    set languageCode(languageCode) {
+        this._delegate.languageCode = languageCode;
+    }
+    get settings() {
+        return this._delegate.settings;
+    }
+    get tenantId() {
+        return this._delegate.tenantId;
+    }
+    set tenantId(tid) {
+        this._delegate.tenantId = tid;
+    }
+    useDeviceLanguage() {
         this._delegate.useDeviceLanguage();
-    };
-    Auth.prototype.signOut = function () {
+    }
+    signOut() {
         return this._delegate.signOut();
-    };
-    Auth.prototype.useEmulator = function (url, options) {
+    }
+    useEmulator(url, options) {
         exp__namespace.connectAuthEmulator(this._delegate, url, options);
-    };
-    Auth.prototype.applyActionCode = function (code) {
+    }
+    applyActionCode(code) {
         return exp__namespace.applyActionCode(this._delegate, code);
-    };
-    Auth.prototype.checkActionCode = function (code) {
+    }
+    checkActionCode(code) {
         return exp__namespace.checkActionCode(this._delegate, code);
-    };
-    Auth.prototype.confirmPasswordReset = function (code, newPassword) {
+    }
+    confirmPasswordReset(code, newPassword) {
         return exp__namespace.confirmPasswordReset(this._delegate, code, newPassword);
-    };
-    Auth.prototype.createUserWithEmailAndPassword = function (email, password) {
-        return tslib.__awaiter(this, void 0, void 0, function () {
-            return tslib.__generator(this, function (_a) {
-                return [2 /*return*/, convertCredential(this._delegate, exp__namespace.createUserWithEmailAndPassword(this._delegate, email, password))];
-            });
-        });
-    };
-    Auth.prototype.fetchProvidersForEmail = function (email) {
+    }
+    async createUserWithEmailAndPassword(email, password) {
+        return convertCredential(this._delegate, exp__namespace.createUserWithEmailAndPassword(this._delegate, email, password));
+    }
+    fetchProvidersForEmail(email) {
         return this.fetchSignInMethodsForEmail(email);
-    };
-    Auth.prototype.fetchSignInMethodsForEmail = function (email) {
+    }
+    fetchSignInMethodsForEmail(email) {
         return exp__namespace.fetchSignInMethodsForEmail(this._delegate, email);
-    };
-    Auth.prototype.isSignInWithEmailLink = function (emailLink) {
+    }
+    isSignInWithEmailLink(emailLink) {
         return exp__namespace.isSignInWithEmailLink(this._delegate, emailLink);
-    };
-    Auth.prototype.getRedirectResult = function () {
-        return tslib.__awaiter(this, void 0, void 0, function () {
-            var credential;
-            return tslib.__generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        _assert$1(_isPopupRedirectSupported(), this._delegate, "operation-not-supported-in-this-environment" /* exp.AuthErrorCode.OPERATION_NOT_SUPPORTED */);
-                        return [4 /*yield*/, exp__namespace.getRedirectResult(this._delegate, CompatPopupRedirectResolver)];
-                    case 1:
-                        credential = _a.sent();
-                        if (!credential) {
-                            return [2 /*return*/, {
-                                    credential: null,
-                                    user: null
-                                }];
-                        }
-                        return [2 /*return*/, convertCredential(this._delegate, Promise.resolve(credential))];
-                }
-            });
-        });
-    };
+    }
+    async getRedirectResult() {
+        _assert$1(_isPopupRedirectSupported(), this._delegate, "operation-not-supported-in-this-environment" /* exp.AuthErrorCode.OPERATION_NOT_SUPPORTED */);
+        const credential = await exp__namespace.getRedirectResult(this._delegate, CompatPopupRedirectResolver);
+        if (!credential) {
+            return {
+                credential: null,
+                user: null
+            };
+        }
+        return convertCredential(this._delegate, Promise.resolve(credential));
+    }
     // This function should only be called by frameworks (e.g. FirebaseUI-web) to log their usage.
     // It is not intended for direct use by developer apps. NO jsdoc here to intentionally leave it
     // out of autogenerated documentation pages to reduce accidental misuse.
-    Auth.prototype.addFrameworkForLogging = function (framework) {
+    addFrameworkForLogging(framework) {
         exp__namespace.addFrameworkForLogging(this._delegate, framework);
-    };
-    Auth.prototype.onAuthStateChanged = function (nextOrObserver, errorFn, completed) {
-        var _a = wrapObservers(nextOrObserver, errorFn, completed), next = _a.next, error = _a.error, complete = _a.complete;
+    }
+    onAuthStateChanged(nextOrObserver, errorFn, completed) {
+        const { next, error, complete } = wrapObservers(nextOrObserver, errorFn, completed);
         return this._delegate.onAuthStateChanged(next, error, complete);
-    };
-    Auth.prototype.onIdTokenChanged = function (nextOrObserver, errorFn, completed) {
-        var _a = wrapObservers(nextOrObserver, errorFn, completed), next = _a.next, error = _a.error, complete = _a.complete;
+    }
+    onIdTokenChanged(nextOrObserver, errorFn, completed) {
+        const { next, error, complete } = wrapObservers(nextOrObserver, errorFn, completed);
         return this._delegate.onIdTokenChanged(next, error, complete);
-    };
-    Auth.prototype.sendSignInLinkToEmail = function (email, actionCodeSettings) {
+    }
+    sendSignInLinkToEmail(email, actionCodeSettings) {
         return exp__namespace.sendSignInLinkToEmail(this._delegate, email, actionCodeSettings);
-    };
-    Auth.prototype.sendPasswordResetEmail = function (email, actionCodeSettings) {
+    }
+    sendPasswordResetEmail(email, actionCodeSettings) {
         return exp__namespace.sendPasswordResetEmail(this._delegate, email, actionCodeSettings || undefined);
-    };
-    Auth.prototype.setPersistence = function (persistence) {
-        return tslib.__awaiter(this, void 0, void 0, function () {
-            var converted, _a, isIndexedDBFullySupported;
-            return tslib.__generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        _validatePersistenceArgument(this._delegate, persistence);
-                        _a = persistence;
-                        switch (_a) {
-                            case Persistence.SESSION: return [3 /*break*/, 1];
-                            case Persistence.LOCAL: return [3 /*break*/, 2];
-                            case Persistence.NONE: return [3 /*break*/, 4];
-                        }
-                        return [3 /*break*/, 5];
-                    case 1:
-                        converted = exp__namespace.browserSessionPersistence;
-                        return [3 /*break*/, 6];
-                    case 2: return [4 /*yield*/, exp__namespace
-                            ._getInstance(exp__namespace.indexedDBLocalPersistence)
-                            ._isAvailable()];
-                    case 3:
-                        isIndexedDBFullySupported = _b.sent();
-                        converted = isIndexedDBFullySupported
-                            ? exp__namespace.indexedDBLocalPersistence
-                            : exp__namespace.browserLocalPersistence;
-                        return [3 /*break*/, 6];
-                    case 4:
-                        converted = exp__namespace.inMemoryPersistence;
-                        return [3 /*break*/, 6];
-                    case 5: return [2 /*return*/, exp__namespace._fail("argument-error" /* exp.AuthErrorCode.ARGUMENT_ERROR */, {
-                            appName: this._delegate.name
-                        })];
-                    case 6: return [2 /*return*/, this._delegate.setPersistence(converted)];
-                }
-            });
-        });
-    };
-    Auth.prototype.signInAndRetrieveDataWithCredential = function (credential) {
+    }
+    async setPersistence(persistence) {
+        _validatePersistenceArgument(this._delegate, persistence);
+        let converted;
+        switch (persistence) {
+            case Persistence.SESSION:
+                converted = exp__namespace.browserSessionPersistence;
+                break;
+            case Persistence.LOCAL:
+                // Not using isIndexedDBAvailable() since it only checks if indexedDB is defined.
+                const isIndexedDBFullySupported = await exp__namespace
+                    ._getInstance(exp__namespace.indexedDBLocalPersistence)
+                    ._isAvailable();
+                converted = isIndexedDBFullySupported
+                    ? exp__namespace.indexedDBLocalPersistence
+                    : exp__namespace.browserLocalPersistence;
+                break;
+            case Persistence.NONE:
+                converted = exp__namespace.inMemoryPersistence;
+                break;
+            default:
+                return exp__namespace._fail("argument-error" /* exp.AuthErrorCode.ARGUMENT_ERROR */, {
+                    appName: this._delegate.name
+                });
+        }
+        return this._delegate.setPersistence(converted);
+    }
+    signInAndRetrieveDataWithCredential(credential) {
         return this.signInWithCredential(credential);
-    };
-    Auth.prototype.signInAnonymously = function () {
+    }
+    signInAnonymously() {
         return convertCredential(this._delegate, exp__namespace.signInAnonymously(this._delegate));
-    };
-    Auth.prototype.signInWithCredential = function (credential) {
+    }
+    signInWithCredential(credential) {
         return convertCredential(this._delegate, exp__namespace.signInWithCredential(this._delegate, credential));
-    };
-    Auth.prototype.signInWithCustomToken = function (token) {
+    }
+    signInWithCustomToken(token) {
         return convertCredential(this._delegate, exp__namespace.signInWithCustomToken(this._delegate, token));
-    };
-    Auth.prototype.signInWithEmailAndPassword = function (email, password) {
+    }
+    signInWithEmailAndPassword(email, password) {
         return convertCredential(this._delegate, exp__namespace.signInWithEmailAndPassword(this._delegate, email, password));
-    };
-    Auth.prototype.signInWithEmailLink = function (email, emailLink) {
+    }
+    signInWithEmailLink(email, emailLink) {
         return convertCredential(this._delegate, exp__namespace.signInWithEmailLink(this._delegate, email, emailLink));
-    };
-    Auth.prototype.signInWithPhoneNumber = function (phoneNumber, applicationVerifier) {
+    }
+    signInWithPhoneNumber(phoneNumber, applicationVerifier) {
         return convertConfirmationResult(this._delegate, exp__namespace.signInWithPhoneNumber(this._delegate, phoneNumber, applicationVerifier));
-    };
-    Auth.prototype.signInWithPopup = function (provider) {
-        return tslib.__awaiter(this, void 0, void 0, function () {
-            return tslib.__generator(this, function (_a) {
-                _assert$1(_isPopupRedirectSupported(), this._delegate, "operation-not-supported-in-this-environment" /* exp.AuthErrorCode.OPERATION_NOT_SUPPORTED */);
-                return [2 /*return*/, convertCredential(this._delegate, exp__namespace.signInWithPopup(this._delegate, provider, CompatPopupRedirectResolver))];
-            });
-        });
-    };
-    Auth.prototype.signInWithRedirect = function (provider) {
-        return tslib.__awaiter(this, void 0, void 0, function () {
-            return tslib.__generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        _assert$1(_isPopupRedirectSupported(), this._delegate, "operation-not-supported-in-this-environment" /* exp.AuthErrorCode.OPERATION_NOT_SUPPORTED */);
-                        return [4 /*yield*/, _savePersistenceForRedirect(this._delegate)];
-                    case 1:
-                        _a.sent();
-                        return [2 /*return*/, exp__namespace.signInWithRedirect(this._delegate, provider, CompatPopupRedirectResolver)];
-                }
-            });
-        });
-    };
-    Auth.prototype.updateCurrentUser = function (user) {
+    }
+    async signInWithPopup(provider) {
+        _assert$1(_isPopupRedirectSupported(), this._delegate, "operation-not-supported-in-this-environment" /* exp.AuthErrorCode.OPERATION_NOT_SUPPORTED */);
+        return convertCredential(this._delegate, exp__namespace.signInWithPopup(this._delegate, provider, CompatPopupRedirectResolver));
+    }
+    async signInWithRedirect(provider) {
+        _assert$1(_isPopupRedirectSupported(), this._delegate, "operation-not-supported-in-this-environment" /* exp.AuthErrorCode.OPERATION_NOT_SUPPORTED */);
+        await _savePersistenceForRedirect(this._delegate);
+        return exp__namespace.signInWithRedirect(this._delegate, provider, CompatPopupRedirectResolver);
+    }
+    updateCurrentUser(user) {
         // remove ts-ignore once overloads are defined for exp functions to accept compat objects
         // @ts-ignore
         return this._delegate.updateCurrentUser(user);
-    };
-    Auth.prototype.verifyPasswordResetCode = function (code) {
+    }
+    verifyPasswordResetCode(code) {
         return exp__namespace.verifyPasswordResetCode(this._delegate, code);
-    };
-    Auth.prototype.unwrap = function () {
+    }
+    unwrap() {
         return this._delegate;
-    };
-    Auth.prototype._delete = function () {
+    }
+    _delete() {
         return this._delegate._delete();
-    };
-    Auth.prototype.linkUnderlyingAuth = function () {
-        var _this = this;
-        this._delegate.wrapped = function () { return _this; };
-    };
-    Auth.Persistence = Persistence;
-    return Auth;
-}());
+    }
+    linkUnderlyingAuth() {
+        this._delegate.wrapped = () => this;
+    }
+}
+Auth.Persistence = Persistence;
 function wrapObservers(nextOrObserver, error, complete) {
-    var next = nextOrObserver;
+    let next = nextOrObserver;
     if (typeof nextOrObserver !== 'function') {
-        (next = nextOrObserver.next, error = nextOrObserver.error, complete = nextOrObserver.complete);
+        ({ next, error, complete } = nextOrObserver);
     }
     // We know 'next' is now a function
-    var oldNext = next;
-    var newNext = function (user) {
-        return oldNext(user && User.getOrCreate(user));
-    };
+    const oldNext = next;
+    const newNext = (user) => oldNext(user && User.getOrCreate(user));
     return {
         next: newNext,
         error: error,
-        complete: complete
+        complete
     };
 }
 function buildPersistenceHierarchy(apiKey, appName) {
@@ -1100,7 +864,7 @@ function buildPersistenceHierarchy(apiKey, appName) {
     // persistence is checked *first* rather than last. This is because we want
     // to prefer stored persistence type in the hierarchy. This is an empty
     // array if window is not available or there is no pending redirect
-    var persistences = _getPersistencesFromRedirect(apiKey, appName);
+    const persistences = _getPersistencesFromRedirect(apiKey, appName);
     // If "self" is available, add indexedDB
     if (typeof self !== 'undefined' &&
         !persistences.includes(exp__namespace.indexedDBLocalPersistence)) {
@@ -1108,11 +872,10 @@ function buildPersistenceHierarchy(apiKey, appName) {
     }
     // If "window" is available, add HTML Storage persistences
     if (typeof window !== 'undefined') {
-        for (var _i = 0, _a = [
+        for (const persistence of [
             exp__namespace.browserLocalPersistence,
             exp__namespace.browserSessionPersistence
-        ]; _i < _a.length; _i++) {
-            var persistence = _a[_i];
+        ]) {
             if (!persistences.includes(persistence)) {
                 persistences.push(persistence);
             }
@@ -1141,29 +904,28 @@ function buildPersistenceHierarchy(apiKey, appName) {
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-var PhoneAuthProvider = /** @class */ (function () {
-    function PhoneAuthProvider() {
+class PhoneAuthProvider {
+    constructor() {
         this.providerId = 'phone';
         // TODO: remove ts-ignore when moving types from auth-types to auth-compat
         // @ts-ignore
         this._delegate = new exp__namespace.PhoneAuthProvider(unwrap(firebase__default["default"].auth()));
     }
-    PhoneAuthProvider.credential = function (verificationId, verificationCode) {
+    static credential(verificationId, verificationCode) {
         return exp__namespace.PhoneAuthProvider.credential(verificationId, verificationCode);
-    };
-    PhoneAuthProvider.prototype.verifyPhoneNumber = function (phoneInfoOptions, applicationVerifier) {
+    }
+    verifyPhoneNumber(phoneInfoOptions, applicationVerifier) {
         return this._delegate.verifyPhoneNumber(
         // The implementation matches but the types are subtly incompatible
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         phoneInfoOptions, applicationVerifier);
-    };
-    PhoneAuthProvider.prototype.unwrap = function () {
+    }
+    unwrap() {
         return this._delegate;
-    };
-    PhoneAuthProvider.PHONE_SIGN_IN_METHOD = exp__namespace.PhoneAuthProvider.PHONE_SIGN_IN_METHOD;
-    PhoneAuthProvider.PROVIDER_ID = exp__namespace.PhoneAuthProvider.PROVIDER_ID;
-    return PhoneAuthProvider;
-}());
+    }
+}
+PhoneAuthProvider.PHONE_SIGN_IN_METHOD = exp__namespace.PhoneAuthProvider.PHONE_SIGN_IN_METHOD;
+PhoneAuthProvider.PROVIDER_ID = exp__namespace.PhoneAuthProvider.PROVIDER_ID;
 
 /**
  * @license
@@ -1181,10 +943,9 @@ var PhoneAuthProvider = /** @class */ (function () {
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-var _assert = exp__namespace._assert;
-var RecaptchaVerifier = /** @class */ (function () {
-    function RecaptchaVerifier(container, parameters, app) {
-        if (app === void 0) { app = firebase__default["default"].app(); }
+const _assert = exp__namespace._assert;
+class RecaptchaVerifier {
+    constructor(container, parameters, app = firebase__default["default"].app()) {
         var _a;
         // API key is required for web client RPC calls.
         _assert((_a = app.options) === null || _a === void 0 ? void 0 : _a.apiKey, "invalid-api-key" /* exp.AuthErrorCode.INVALID_API_KEY */, {
@@ -1198,17 +959,16 @@ var RecaptchaVerifier = /** @class */ (function () {
         parameters);
         this.type = this._delegate.type;
     }
-    RecaptchaVerifier.prototype.clear = function () {
+    clear() {
         this._delegate.clear();
-    };
-    RecaptchaVerifier.prototype.render = function () {
+    }
+    render() {
         return this._delegate.render();
-    };
-    RecaptchaVerifier.prototype.verify = function () {
+    }
+    verify() {
         return this._delegate.verify();
-    };
-    return RecaptchaVerifier;
-}());
+    }
+}
 
 /**
  * @license
@@ -1226,14 +986,14 @@ var RecaptchaVerifier = /** @class */ (function () {
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-var AUTH_TYPE = 'auth-compat';
+const AUTH_TYPE = 'auth-compat';
 // Create auth components to register with firebase.
 // Provides Auth public APIs.
 function registerAuthCompat(instance) {
-    instance.INTERNAL.registerComponent(new component.Component(AUTH_TYPE, function (container) {
+    instance.INTERNAL.registerComponent(new component.Component(AUTH_TYPE, container => {
         // getImmediate for FirebaseApp will always succeed
-        var app = container.getProvider('app-compat').getImmediate();
-        var authProvider = container.getProvider('auth');
+        const app = container.getProvider('app-compat').getImmediate();
+        const authProvider = container.getProvider('auth');
         return new Auth(app, authProvider);
     }, "PUBLIC" /* ComponentType.PUBLIC */)
         .setServiceProps({
@@ -1257,7 +1017,7 @@ function registerAuthCompat(instance) {
         PhoneMultiFactorGenerator: exp__namespace.PhoneMultiFactorGenerator,
         RecaptchaVerifier: RecaptchaVerifier,
         TwitterAuthProvider: exp__namespace.TwitterAuthProvider,
-        Auth: Auth,
+        Auth,
         AuthCredential: exp__namespace.AuthCredential,
         Error: util.FirebaseError
     })
@@ -1283,5 +1043,5 @@ registerAuthCompat(firebase__default["default"]);
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-exp.FetchProvider.initialize(undici.fetch, undici.Headers, undici.Response);
+exp.FetchProvider.initialize(fetch, Headers, Response);
 //# sourceMappingURL=index.node.cjs.js.map