@firebase/app-check 0.8.8 → 0.8.9

package/dist/index.cjs.js

@@ -4,7 +4,6 @@ Object.defineProperty(exports, '__esModule', { value: true });
 
 var app = require('@firebase/app');
 var component = require('@firebase/component');
-var tslib = require('tslib');
 var util = require('@firebase/util');
 var logger$1 = require('@firebase/logger');
 
@@ -24,12 +23,12 @@ var logger$1 = require('@firebase/logger');
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-var APP_CHECK_STATES = new Map();
-var DEFAULT_STATE = {
+const APP_CHECK_STATES = new Map();
+const DEFAULT_STATE = {
     activated: false,
     tokenObservers: []
 };
-var DEBUG_STATE = {
+const DEBUG_STATE = {
     initialized: false,
     enabled: false
 };
@@ -37,7 +36,7 @@ var DEBUG_STATE = {
  * Gets a reference to the state object.
  */
 function getStateReference(app) {
-    return APP_CHECK_STATES.get(app) || tslib.__assign({}, DEFAULT_STATE);
+    return APP_CHECK_STATES.get(app) || Object.assign({}, DEFAULT_STATE);
 }
 /**
  * Set once on initialization. The map should hold the same reference to the
@@ -67,11 +66,11 @@ function getDebugState() {
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-var BASE_ENDPOINT = 'https://content-firebaseappcheck.googleapis.com/v1';
-var EXCHANGE_RECAPTCHA_TOKEN_METHOD = 'exchangeRecaptchaV3Token';
-var EXCHANGE_RECAPTCHA_ENTERPRISE_TOKEN_METHOD = 'exchangeRecaptchaEnterpriseToken';
-var EXCHANGE_DEBUG_TOKEN_METHOD = 'exchangeDebugToken';
-var TOKEN_REFRESH_TIME = {
+const BASE_ENDPOINT = 'https://content-firebaseappcheck.googleapis.com/v1';
+const EXCHANGE_RECAPTCHA_TOKEN_METHOD = 'exchangeRecaptchaV3Token';
+const EXCHANGE_RECAPTCHA_ENTERPRISE_TOKEN_METHOD = 'exchangeRecaptchaEnterpriseToken';
+const EXCHANGE_DEBUG_TOKEN_METHOD = 'exchangeDebugToken';
+const TOKEN_REFRESH_TIME = {
     /**
      * The offset time before token natural expiration to run the refresh.
      * This is currently 5 minutes.
@@ -90,7 +89,7 @@ var TOKEN_REFRESH_TIME = {
 /**
  * One day in millis, for certain error code backoffs.
  */
-var ONE_DAY = 24 * 60 * 60 * 1000;
+const ONE_DAY = 24 * 60 * 60 * 1000;
 
 /**
  * @license
@@ -114,8 +113,8 @@ var ONE_DAY = 24 * 60 * 60 * 1000;
  */
 // TODO: move it to @firebase/util?
 // TODO: allow to config whether refresh should happen in the background
-var Refresher = /** @class */ (function () {
-    function Refresher(operation, retryPolicy, getWaitDuration, lowerBound, upperBound) {
+class Refresher {
+    constructor(operation, retryPolicy, getWaitDuration, lowerBound, upperBound) {
         this.operation = operation;
         this.retryPolicy = retryPolicy;
         this.getWaitDuration = getWaitDuration;
@@ -127,79 +126,59 @@ var Refresher = /** @class */ (function () {
             throw new Error('Proactive refresh lower bound greater than upper bound!');
         }
     }
-    Refresher.prototype.start = function () {
+    start() {
         this.nextErrorWaitInterval = this.lowerBound;
-        this.process(true).catch(function () {
+        this.process(true).catch(() => {
             /* we don't care about the result */
         });
-    };
-    Refresher.prototype.stop = function () {
+    }
+    stop() {
         if (this.pending) {
             this.pending.reject('cancelled');
             this.pending = null;
         }
-    };
-    Refresher.prototype.isRunning = function () {
+    }
+    isRunning() {
         return !!this.pending;
-    };
-    Refresher.prototype.process = function (hasSucceeded) {
-        return tslib.__awaiter(this, void 0, void 0, function () {
-            var error_1;
-            return tslib.__generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        this.stop();
-                        _a.label = 1;
-                    case 1:
-                        _a.trys.push([1, 6, , 7]);
-                        this.pending = new util.Deferred();
-                        this.pending.promise.catch(function (_e) {
-                            /* ignore */
-                        });
-                        return [4 /*yield*/, sleep(this.getNextRun(hasSucceeded))];
-                    case 2:
-                        _a.sent();
-                        // Why do we resolve a promise, then immediate wait for it?
-                        // We do it to make the promise chain cancellable.
-                        // We can call stop() which rejects the promise before the following line execute, which makes
-                        // the code jump to the catch block.
-                        // TODO: unit test this
-                        this.pending.resolve();
-                        return [4 /*yield*/, this.pending.promise];
-                    case 3:
-                        _a.sent();
-                        this.pending = new util.Deferred();
-                        this.pending.promise.catch(function (_e) {
-                            /* ignore */
-                        });
-                        return [4 /*yield*/, this.operation()];
-                    case 4:
-                        _a.sent();
-                        this.pending.resolve();
-                        return [4 /*yield*/, this.pending.promise];
-                    case 5:
-                        _a.sent();
-                        this.process(true).catch(function () {
-                            /* we don't care about the result */
-                        });
-                        return [3 /*break*/, 7];
-                    case 6:
-                        error_1 = _a.sent();
-                        if (this.retryPolicy(error_1)) {
-                            this.process(false).catch(function () {
-                                /* we don't care about the result */
-                            });
-                        }
-                        else {
-                            this.stop();
-                        }
-                        return [3 /*break*/, 7];
-                    case 7: return [2 /*return*/];
-                }
+    }
+    async process(hasSucceeded) {
+        this.stop();
+        try {
+            this.pending = new util.Deferred();
+            this.pending.promise.catch(_e => {
+                /* ignore */
             });
-        });
-    };
-    Refresher.prototype.getNextRun = function (hasSucceeded) {
+            await sleep(this.getNextRun(hasSucceeded));
+            // Why do we resolve a promise, then immediate wait for it?
+            // We do it to make the promise chain cancellable.
+            // We can call stop() which rejects the promise before the following line execute, which makes
+            // the code jump to the catch block.
+            // TODO: unit test this
+            this.pending.resolve();
+            await this.pending.promise;
+            this.pending = new util.Deferred();
+            this.pending.promise.catch(_e => {
+                /* ignore */
+            });
+            await this.operation();
+            this.pending.resolve();
+            await this.pending.promise;
+            this.process(true).catch(() => {
+                /* we don't care about the result */
+            });
+        }
+        catch (error) {
+            if (this.retryPolicy(error)) {
+                this.process(false).catch(() => {
+                    /* we don't care about the result */
+                });
+            }
+            else {
+                this.stop();
+            }
+        }
+    }
+    getNextRun(hasSucceeded) {
         if (hasSucceeded) {
             // If last operation succeeded, reset next error wait interval and return
             // the default wait duration.
@@ -209,7 +188,7 @@ var Refresher = /** @class */ (function () {
         }
         else {
             // Get next error wait interval.
-            var currentErrorWaitInterval = this.nextErrorWaitInterval;
+            const currentErrorWaitInterval = this.nextErrorWaitInterval;
             // Double interval for next consecutive error.
             this.nextErrorWaitInterval *= 2;
             // Make sure next wait interval does not exceed the maximum upper bound.
@@ -218,11 +197,10 @@ var Refresher = /** @class */ (function () {
             }
             return currentErrorWaitInterval;
         }
-    };
-    return Refresher;
-}());
+    }
+}
 function sleep(ms) {
-    return new Promise(function (resolve) {
+    return new Promise(resolve => {
         setTimeout(resolve, ms);
     });
 }
@@ -243,26 +221,25 @@ function sleep(ms) {
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-var _a;
-var ERRORS = (_a = {},
-    _a["already-initialized" /* AppCheckError.ALREADY_INITIALIZED */] = 'You have already called initializeAppCheck() for FirebaseApp {$appName} with ' +
+const ERRORS = {
+    ["already-initialized" /* AppCheckError.ALREADY_INITIALIZED */]: 'You have already called initializeAppCheck() for FirebaseApp {$appName} with ' +
         'different options. To avoid this error, call initializeAppCheck() with the ' +
         'same options as when it was originally called. This will return the ' +
         'already initialized instance.',
-    _a["use-before-activation" /* AppCheckError.USE_BEFORE_ACTIVATION */] = 'App Check is being used before initializeAppCheck() is called for FirebaseApp {$appName}. ' +
+    ["use-before-activation" /* AppCheckError.USE_BEFORE_ACTIVATION */]: 'App Check is being used before initializeAppCheck() is called for FirebaseApp {$appName}. ' +
         'Call initializeAppCheck() before instantiating other Firebase services.',
-    _a["fetch-network-error" /* AppCheckError.FETCH_NETWORK_ERROR */] = 'Fetch failed to connect to a network. Check Internet connection. ' +
+    ["fetch-network-error" /* AppCheckError.FETCH_NETWORK_ERROR */]: 'Fetch failed to connect to a network. Check Internet connection. ' +
         'Original error: {$originalErrorMessage}.',
-    _a["fetch-parse-error" /* AppCheckError.FETCH_PARSE_ERROR */] = 'Fetch client could not parse response.' +
+    ["fetch-parse-error" /* AppCheckError.FETCH_PARSE_ERROR */]: 'Fetch client could not parse response.' +
         ' Original error: {$originalErrorMessage}.',
-    _a["fetch-status-error" /* AppCheckError.FETCH_STATUS_ERROR */] = 'Fetch server returned an HTTP error status. HTTP status: {$httpStatus}.',
-    _a["storage-open" /* AppCheckError.STORAGE_OPEN */] = 'Error thrown when opening storage. Original error: {$originalErrorMessage}.',
-    _a["storage-get" /* AppCheckError.STORAGE_GET */] = 'Error thrown when reading from storage. Original error: {$originalErrorMessage}.',
-    _a["storage-set" /* AppCheckError.STORAGE_WRITE */] = 'Error thrown when writing to storage. Original error: {$originalErrorMessage}.',
-    _a["recaptcha-error" /* AppCheckError.RECAPTCHA_ERROR */] = 'ReCAPTCHA error.',
-    _a["throttled" /* AppCheckError.THROTTLED */] = "Requests throttled due to {$httpStatus} error. Attempts allowed again after {$time}",
-    _a);
-var ERROR_FACTORY = new util.ErrorFactory('appCheck', 'AppCheck', ERRORS);
+    ["fetch-status-error" /* AppCheckError.FETCH_STATUS_ERROR */]: 'Fetch server returned an HTTP error status. HTTP status: {$httpStatus}.',
+    ["storage-open" /* AppCheckError.STORAGE_OPEN */]: 'Error thrown when opening storage. Original error: {$originalErrorMessage}.',
+    ["storage-get" /* AppCheckError.STORAGE_GET */]: 'Error thrown when reading from storage. Original error: {$originalErrorMessage}.',
+    ["storage-set" /* AppCheckError.STORAGE_WRITE */]: 'Error thrown when writing to storage. Original error: {$originalErrorMessage}.',
+    ["recaptcha-error" /* AppCheckError.RECAPTCHA_ERROR */]: 'ReCAPTCHA error.',
+    ["throttled" /* AppCheckError.THROTTLED */]: `Requests throttled due to {$httpStatus} error. Attempts allowed again after {$time}`
+};
+const ERROR_FACTORY = new util.ErrorFactory('appCheck', 'AppCheck', ERRORS);
 
 /**
  * @license
@@ -280,9 +257,8 @@ var ERROR_FACTORY = new util.ErrorFactory('appCheck', 'AppCheck', ERRORS);
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-function getRecaptcha(isEnterprise) {
+function getRecaptcha(isEnterprise = false) {
     var _a;
-    if (isEnterprise === void 0) { isEnterprise = false; }
     if (isEnterprise) {
         return (_a = self.grecaptcha) === null || _a === void 0 ? void 0 : _a.enterprise;
     }
@@ -296,12 +272,12 @@ function ensureActivated(app) {
     }
 }
 function getDurationString(durationInMillis) {
-    var totalSeconds = Math.round(durationInMillis / 1000);
-    var days = Math.floor(totalSeconds / (3600 * 24));
-    var hours = Math.floor((totalSeconds - days * 3600 * 24) / 3600);
-    var minutes = Math.floor((totalSeconds - days * 3600 * 24 - hours * 3600) / 60);
-    var seconds = totalSeconds - days * 3600 * 24 - hours * 3600 - minutes * 60;
-    var result = '';
+    const totalSeconds = Math.round(durationInMillis / 1000);
+    const days = Math.floor(totalSeconds / (3600 * 24));
+    const hours = Math.floor((totalSeconds - days * 3600 * 24) / 3600);
+    const minutes = Math.floor((totalSeconds - days * 3600 * 24 - hours * 3600) / 60);
+    const seconds = totalSeconds - days * 3600 * 24 - hours * 3600 - minutes * 60;
+    let result = '';
     if (days) {
         result += pad(days) + 'd:';
     }
@@ -334,105 +310,88 @@ function pad(value) {
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-function exchangeToken(_a, heartbeatServiceProvider) {
-    var url = _a.url, body = _a.body;
-    return tslib.__awaiter(this, void 0, void 0, function () {
-        var headers, heartbeatService, heartbeatsHeader, options, response, originalError_1, responseBody, originalError_2, match, timeToLiveAsNumber, now;
-        return tslib.__generator(this, function (_b) {
-            switch (_b.label) {
-                case 0:
-                    headers = {
-                        'Content-Type': 'application/json'
-                    };
-                    heartbeatService = heartbeatServiceProvider.getImmediate({
-                        optional: true
-                    });
-                    if (!heartbeatService) return [3 /*break*/, 2];
-                    return [4 /*yield*/, heartbeatService.getHeartbeatsHeader()];
-                case 1:
-                    heartbeatsHeader = _b.sent();
-                    if (heartbeatsHeader) {
-                        headers['X-Firebase-Client'] = heartbeatsHeader;
-                    }
-                    _b.label = 2;
-                case 2:
-                    options = {
-                        method: 'POST',
-                        body: JSON.stringify(body),
-                        headers: headers
-                    };
-                    _b.label = 3;
-                case 3:
-                    _b.trys.push([3, 5, , 6]);
-                    return [4 /*yield*/, fetch(url, options)];
-                case 4:
-                    response = _b.sent();
-                    return [3 /*break*/, 6];
-                case 5:
-                    originalError_1 = _b.sent();
-                    throw ERROR_FACTORY.create("fetch-network-error" /* AppCheckError.FETCH_NETWORK_ERROR */, {
-                        originalErrorMessage: originalError_1 === null || originalError_1 === void 0 ? void 0 : originalError_1.message
-                    });
-                case 6:
-                    if (response.status !== 200) {
-                        throw ERROR_FACTORY.create("fetch-status-error" /* AppCheckError.FETCH_STATUS_ERROR */, {
-                            httpStatus: response.status
-                        });
-                    }
-                    _b.label = 7;
-                case 7:
-                    _b.trys.push([7, 9, , 10]);
-                    return [4 /*yield*/, response.json()];
-                case 8:
-                    // JSON parsing throws SyntaxError if the response body isn't a JSON string.
-                    responseBody = _b.sent();
-                    return [3 /*break*/, 10];
-                case 9:
-                    originalError_2 = _b.sent();
-                    throw ERROR_FACTORY.create("fetch-parse-error" /* AppCheckError.FETCH_PARSE_ERROR */, {
-                        originalErrorMessage: originalError_2 === null || originalError_2 === void 0 ? void 0 : originalError_2.message
-                    });
-                case 10:
-                    match = responseBody.ttl.match(/^([\d.]+)(s)$/);
-                    if (!match || !match[2] || isNaN(Number(match[1]))) {
-                        throw ERROR_FACTORY.create("fetch-parse-error" /* AppCheckError.FETCH_PARSE_ERROR */, {
-                            originalErrorMessage: "ttl field (timeToLive) is not in standard Protobuf Duration " +
-                                "format: ".concat(responseBody.ttl)
-                        });
-                    }
-                    timeToLiveAsNumber = Number(match[1]) * 1000;
-                    now = Date.now();
-                    return [2 /*return*/, {
-                            token: responseBody.token,
-                            expireTimeMillis: now + timeToLiveAsNumber,
-                            issuedAtTimeMillis: now
-                        }];
-            }
-        });
+async function exchangeToken({ url, body }, heartbeatServiceProvider) {
+    const headers = {
+        'Content-Type': 'application/json'
+    };
+    // If heartbeat service exists, add heartbeat header string to the header.
+    const heartbeatService = heartbeatServiceProvider.getImmediate({
+        optional: true
     });
+    if (heartbeatService) {
+        const heartbeatsHeader = await heartbeatService.getHeartbeatsHeader();
+        if (heartbeatsHeader) {
+            headers['X-Firebase-Client'] = heartbeatsHeader;
+        }
+    }
+    const options = {
+        method: 'POST',
+        body: JSON.stringify(body),
+        headers
+    };
+    let response;
+    try {
+        response = await fetch(url, options);
+    }
+    catch (originalError) {
+        throw ERROR_FACTORY.create("fetch-network-error" /* AppCheckError.FETCH_NETWORK_ERROR */, {
+            originalErrorMessage: originalError === null || originalError === void 0 ? void 0 : originalError.message
+        });
+    }
+    if (response.status !== 200) {
+        throw ERROR_FACTORY.create("fetch-status-error" /* AppCheckError.FETCH_STATUS_ERROR */, {
+            httpStatus: response.status
+        });
+    }
+    let responseBody;
+    try {
+        // JSON parsing throws SyntaxError if the response body isn't a JSON string.
+        responseBody = await response.json();
+    }
+    catch (originalError) {
+        throw ERROR_FACTORY.create("fetch-parse-error" /* AppCheckError.FETCH_PARSE_ERROR */, {
+            originalErrorMessage: originalError === null || originalError === void 0 ? void 0 : originalError.message
+        });
+    }
+    // Protobuf duration format.
+    // https://developers.google.com/protocol-buffers/docs/reference/java/com/google/protobuf/Duration
+    const match = responseBody.ttl.match(/^([\d.]+)(s)$/);
+    if (!match || !match[2] || isNaN(Number(match[1]))) {
+        throw ERROR_FACTORY.create("fetch-parse-error" /* AppCheckError.FETCH_PARSE_ERROR */, {
+            originalErrorMessage: `ttl field (timeToLive) is not in standard Protobuf Duration ` +
+                `format: ${responseBody.ttl}`
+        });
+    }
+    const timeToLiveAsNumber = Number(match[1]) * 1000;
+    const now = Date.now();
+    return {
+        token: responseBody.token,
+        expireTimeMillis: now + timeToLiveAsNumber,
+        issuedAtTimeMillis: now
+    };
 }
 function getExchangeRecaptchaV3TokenRequest(app, reCAPTCHAToken) {
-    var _a = app.options, projectId = _a.projectId, appId = _a.appId, apiKey = _a.apiKey;
+    const { projectId, appId, apiKey } = app.options;
     return {
-        url: "".concat(BASE_ENDPOINT, "/projects/").concat(projectId, "/apps/").concat(appId, ":").concat(EXCHANGE_RECAPTCHA_TOKEN_METHOD, "?key=").concat(apiKey),
+        url: `${BASE_ENDPOINT}/projects/${projectId}/apps/${appId}:${EXCHANGE_RECAPTCHA_TOKEN_METHOD}?key=${apiKey}`,
         body: {
             'recaptcha_v3_token': reCAPTCHAToken
         }
     };
 }
 function getExchangeRecaptchaEnterpriseTokenRequest(app, reCAPTCHAToken) {
-    var _a = app.options, projectId = _a.projectId, appId = _a.appId, apiKey = _a.apiKey;
+    const { projectId, appId, apiKey } = app.options;
     return {
-        url: "".concat(BASE_ENDPOINT, "/projects/").concat(projectId, "/apps/").concat(appId, ":").concat(EXCHANGE_RECAPTCHA_ENTERPRISE_TOKEN_METHOD, "?key=").concat(apiKey),
+        url: `${BASE_ENDPOINT}/projects/${projectId}/apps/${appId}:${EXCHANGE_RECAPTCHA_ENTERPRISE_TOKEN_METHOD}?key=${apiKey}`,
         body: {
             'recaptcha_enterprise_token': reCAPTCHAToken
         }
     };
 }
 function getExchangeDebugTokenRequest(app, debugToken) {
-    var _a = app.options, projectId = _a.projectId, appId = _a.appId, apiKey = _a.apiKey;
+    const { projectId, appId, apiKey } = app.options;
     return {
-        url: "".concat(BASE_ENDPOINT, "/projects/").concat(projectId, "/apps/").concat(appId, ":").concat(EXCHANGE_DEBUG_TOKEN_METHOD, "?key=").concat(apiKey),
+        url: `${BASE_ENDPOINT}/projects/${projectId}/apps/${appId}:${EXCHANGE_DEBUG_TOKEN_METHOD}?key=${apiKey}`,
         body: {
             // eslint-disable-next-line
             debug_token: debugToken
@@ -456,29 +415,29 @@ function getExchangeDebugTokenRequest(app, debugToken) {
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-var DB_NAME = 'firebase-app-check-database';
-var DB_VERSION = 1;
-var STORE_NAME = 'firebase-app-check-store';
-var DEBUG_TOKEN_KEY = 'debug-token';
-var dbPromise = null;
+const DB_NAME = 'firebase-app-check-database';
+const DB_VERSION = 1;
+const STORE_NAME = 'firebase-app-check-store';
+const DEBUG_TOKEN_KEY = 'debug-token';
+let dbPromise = null;
 function getDBPromise() {
     if (dbPromise) {
         return dbPromise;
     }
-    dbPromise = new Promise(function (resolve, reject) {
+    dbPromise = new Promise((resolve, reject) => {
         try {
-            var request = indexedDB.open(DB_NAME, DB_VERSION);
-            request.onsuccess = function (event) {
+            const request = indexedDB.open(DB_NAME, DB_VERSION);
+            request.onsuccess = event => {
                 resolve(event.target.result);
             };
-            request.onerror = function (event) {
+            request.onerror = event => {
                 var _a;
                 reject(ERROR_FACTORY.create("storage-open" /* AppCheckError.STORAGE_OPEN */, {
                     originalErrorMessage: (_a = event.target.error) === null || _a === void 0 ? void 0 : _a.message
                 }));
             };
-            request.onupgradeneeded = function (event) {
-                var db = event.target.result;
+            request.onupgradeneeded = event => {
+                const db = event.target.result;
                 // We don't use 'break' in this switch statement, the fall-through
                 // behavior is what we want, because if there are multiple versions between
                 // the old version and the current version, we want ALL the migrations
@@ -512,69 +471,51 @@ function writeDebugTokenToIndexedDB(token) {
 function readDebugTokenFromIndexedDB() {
     return read(DEBUG_TOKEN_KEY);
 }
-function write(key, value) {
-    return tslib.__awaiter(this, void 0, void 0, function () {
-        var db, transaction, store, request;
-        return tslib.__generator(this, function (_a) {
-            switch (_a.label) {
-                case 0: return [4 /*yield*/, getDBPromise()];
-                case 1:
-                    db = _a.sent();
-                    transaction = db.transaction(STORE_NAME, 'readwrite');
-                    store = transaction.objectStore(STORE_NAME);
-                    request = store.put({
-                        compositeKey: key,
-                        value: value
-                    });
-                    return [2 /*return*/, new Promise(function (resolve, reject) {
-                            request.onsuccess = function (_event) {
-                                resolve();
-                            };
-                            transaction.onerror = function (event) {
-                                var _a;
-                                reject(ERROR_FACTORY.create("storage-set" /* AppCheckError.STORAGE_WRITE */, {
-                                    originalErrorMessage: (_a = event.target.error) === null || _a === void 0 ? void 0 : _a.message
-                                }));
-                            };
-                        })];
-            }
-        });
+async function write(key, value) {
+    const db = await getDBPromise();
+    const transaction = db.transaction(STORE_NAME, 'readwrite');
+    const store = transaction.objectStore(STORE_NAME);
+    const request = store.put({
+        compositeKey: key,
+        value
+    });
+    return new Promise((resolve, reject) => {
+        request.onsuccess = _event => {
+            resolve();
+        };
+        transaction.onerror = event => {
+            var _a;
+            reject(ERROR_FACTORY.create("storage-set" /* AppCheckError.STORAGE_WRITE */, {
+                originalErrorMessage: (_a = event.target.error) === null || _a === void 0 ? void 0 : _a.message
+            }));
+        };
     });
 }
-function read(key) {
-    return tslib.__awaiter(this, void 0, void 0, function () {
-        var db, transaction, store, request;
-        return tslib.__generator(this, function (_a) {
-            switch (_a.label) {
-                case 0: return [4 /*yield*/, getDBPromise()];
-                case 1:
-                    db = _a.sent();
-                    transaction = db.transaction(STORE_NAME, 'readonly');
-                    store = transaction.objectStore(STORE_NAME);
-                    request = store.get(key);
-                    return [2 /*return*/, new Promise(function (resolve, reject) {
-                            request.onsuccess = function (event) {
-                                var result = event.target.result;
-                                if (result) {
-                                    resolve(result.value);
-                                }
-                                else {
-                                    resolve(undefined);
-                                }
-                            };
-                            transaction.onerror = function (event) {
-                                var _a;
-                                reject(ERROR_FACTORY.create("storage-get" /* AppCheckError.STORAGE_GET */, {
-                                    originalErrorMessage: (_a = event.target.error) === null || _a === void 0 ? void 0 : _a.message
-                                }));
-                            };
-                        })];
+async function read(key) {
+    const db = await getDBPromise();
+    const transaction = db.transaction(STORE_NAME, 'readonly');
+    const store = transaction.objectStore(STORE_NAME);
+    const request = store.get(key);
+    return new Promise((resolve, reject) => {
+        request.onsuccess = event => {
+            const result = event.target.result;
+            if (result) {
+                resolve(result.value);
             }
-        });
+            else {
+                resolve(undefined);
+            }
+        };
+        transaction.onerror = event => {
+            var _a;
+            reject(ERROR_FACTORY.create("storage-get" /* AppCheckError.STORAGE_GET */, {
+                originalErrorMessage: (_a = event.target.error) === null || _a === void 0 ? void 0 : _a.message
+            }));
+        };
     });
 }
 function computeKey(app) {
-    return "".concat(app.options.appId, "-").concat(app.name);
+    return `${app.options.appId}-${app.name}`;
 }
 
 /**
@@ -593,7 +534,7 @@ function computeKey(app) {
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-var logger = new logger$1.Logger('@firebase/app-check');
+const logger = new logger$1.Logger('@firebase/app-check');
 
 /**
  * @license
@@ -614,80 +555,58 @@ var logger = new logger$1.Logger('@firebase/app-check');
 /**
  * Always resolves. In case of an error reading from indexeddb, resolve with undefined
  */
-function readTokenFromStorage(app) {
-    return tslib.__awaiter(this, void 0, void 0, function () {
-        var token, e_1;
-        return tslib.__generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    if (!util.isIndexedDBAvailable()) return [3 /*break*/, 5];
-                    token = undefined;
-                    _a.label = 1;
-                case 1:
-                    _a.trys.push([1, 3, , 4]);
-                    return [4 /*yield*/, readTokenFromIndexedDB(app)];
-                case 2:
-                    token = _a.sent();
-                    return [3 /*break*/, 4];
-                case 3:
-                    e_1 = _a.sent();
-                    // swallow the error and return undefined
-                    logger.warn("Failed to read token from IndexedDB. Error: ".concat(e_1));
-                    return [3 /*break*/, 4];
-                case 4: return [2 /*return*/, token];
-                case 5: return [2 /*return*/, undefined];
-            }
-        });
-    });
+async function readTokenFromStorage(app) {
+    if (util.isIndexedDBAvailable()) {
+        let token = undefined;
+        try {
+            token = await readTokenFromIndexedDB(app);
+        }
+        catch (e) {
+            // swallow the error and return undefined
+            logger.warn(`Failed to read token from IndexedDB. Error: ${e}`);
+        }
+        return token;
+    }
+    return undefined;
 }
 /**
  * Always resolves. In case of an error writing to indexeddb, print a warning and resolve the promise
  */
 function writeTokenToStorage(app, token) {
     if (util.isIndexedDBAvailable()) {
-        return writeTokenToIndexedDB(app, token).catch(function (e) {
+        return writeTokenToIndexedDB(app, token).catch(e => {
             // swallow the error and resolve the promise
-            logger.warn("Failed to write token to IndexedDB. Error: ".concat(e));
+            logger.warn(`Failed to write token to IndexedDB. Error: ${e}`);
         });
     }
     return Promise.resolve();
 }
-function readOrCreateDebugTokenFromStorage() {
-    return tslib.__awaiter(this, void 0, void 0, function () {
-        var existingDebugToken, newToken;
-        return tslib.__generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    existingDebugToken = undefined;
-                    _a.label = 1;
-                case 1:
-                    _a.trys.push([1, 3, , 4]);
-                    return [4 /*yield*/, readDebugTokenFromIndexedDB()];
-                case 2:
-                    existingDebugToken = _a.sent();
-                    return [3 /*break*/, 4];
-                case 3:
-                    _a.sent();
-                    return [3 /*break*/, 4];
-                case 4:
-                    if (!existingDebugToken) {
-                        newToken = util.uuidv4();
-                        // We don't need to block on writing to indexeddb
-                        // In case persistence failed, a new debug token will be generated every time the page is refreshed.
-                        // It renders the debug token useless because you have to manually register(whitelist) the new token in the firebase console again and again.
-                        // If you see this error trying to use debug token, it probably means you are using a browser that doesn't support indexeddb.
-                        // You should switch to a different browser that supports indexeddb
-                        writeDebugTokenToIndexedDB(newToken).catch(function (e) {
-                            return logger.warn("Failed to persist debug token to IndexedDB. Error: ".concat(e));
-                        });
-                        return [2 /*return*/, newToken];
-                    }
-                    else {
-                        return [2 /*return*/, existingDebugToken];
-                    }
-            }
-        });
-    });
+async function readOrCreateDebugTokenFromStorage() {
+    /**
+     * Theoretically race condition can happen if we read, then write in 2 separate transactions.
+     * But it won't happen here, because this function will be called exactly once.
+     */
+    let existingDebugToken = undefined;
+    try {
+        existingDebugToken = await readDebugTokenFromIndexedDB();
+    }
+    catch (_e) {
+        // failed to read from indexeddb. We assume there is no existing debug token, and generate a new one.
+    }
+    if (!existingDebugToken) {
+        // create a new debug token
+        const newToken = util.uuidv4();
+        // We don't need to block on writing to indexeddb
+        // In case persistence failed, a new debug token will be generated every time the page is refreshed.
+        // It renders the debug token useless because you have to manually register(whitelist) the new token in the firebase console again and again.
+        // If you see this error trying to use debug token, it probably means you are using a browser that doesn't support indexeddb.
+        // You should switch to a different browser that supports indexeddb
+        writeDebugTokenToIndexedDB(newToken).catch(e => logger.warn(`Failed to persist debug token to IndexedDB. Error: ${e}`));
+        return newToken;
+    }
+    else {
+        return existingDebugToken;
+    }
 }
 
 /**
@@ -707,27 +626,24 @@ function readOrCreateDebugTokenFromStorage() {
  * limitations under the License.
  */
 function isDebugMode() {
-    var debugState = getDebugState();
+    const debugState = getDebugState();
     return debugState.enabled;
 }
-function getDebugToken() {
-    return tslib.__awaiter(this, void 0, void 0, function () {
-        var state;
-        return tslib.__generator(this, function (_a) {
-            state = getDebugState();
-            if (state.enabled && state.token) {
-                return [2 /*return*/, state.token.promise];
-            }
-            else {
-                // should not happen!
-                throw Error("\n            Can't get debug token in production mode.\n        ");
-            }
-        });
-    });
+async function getDebugToken() {
+    const state = getDebugState();
+    if (state.enabled && state.token) {
+        return state.token.promise;
+    }
+    else {
+        // should not happen!
+        throw Error(`
+            Can't get debug token in production mode.
+        `);
+    }
 }
 function initializeDebugMode() {
-    var globals = util.getGlobal();
-    var debugState = getDebugState();
+    const globals = util.getGlobal();
+    const debugState = getDebugState();
     // Set to true if this function has been called, whether or not
     // it enabled debug mode.
     debugState.initialized = true;
@@ -736,7 +652,7 @@ function initializeDebugMode() {
         return;
     }
     debugState.enabled = true;
-    var deferredToken = new util.Deferred();
+    const deferredToken = new util.Deferred();
     debugState.token = deferredToken;
     if (typeof globals.FIREBASE_APPCHECK_DEBUG_TOKEN === 'string') {
         deferredToken.resolve(globals.FIREBASE_APPCHECK_DEBUG_TOKEN);
@@ -764,7 +680,7 @@ function initializeDebugMode() {
  */
 // Initial hardcoded value agreed upon across platforms for initial launch.
 // Format left open for possible dynamic error values and other fields in the future.
-var defaultTokenErrorData = { error: 'UNKNOWN_ERROR' };
+const defaultTokenErrorData = { error: 'UNKNOWN_ERROR' };
 /**
  * Stringify and base64 encode token error data.
  *
@@ -779,200 +695,179 @@ function formatDummyToken(tokenErrorData) {
  * The result will contain an error field if there is any error.
  * In case there is an error, the token field in the result will be populated with a dummy value
  */
-function getToken$2(appCheck, forceRefresh) {
-    if (forceRefresh === void 0) { forceRefresh = false; }
-    return tslib.__awaiter(this, void 0, void 0, function () {
-        var app, state, token, error, cachedToken, shouldCallListeners, _a, _b, _c, _d, tokenFromDebugExchange, e_1, interopTokenResult;
-        return tslib.__generator(this, function (_e) {
-            switch (_e.label) {
-                case 0:
-                    app = appCheck.app;
-                    ensureActivated(app);
-                    state = getStateReference(app);
-                    token = state.token;
-                    error = undefined;
-                    /**
-                     * If an invalid token was found in memory, clear token from
-                     * memory and unset the local variable `token`.
-                     */
-                    if (token && !isValid(token)) {
-                        state.token = undefined;
-                        token = undefined;
-                    }
-                    if (!!token) return [3 /*break*/, 4];
-                    return [4 /*yield*/, state.cachedTokenPromise];
-                case 1:
-                    cachedToken = _e.sent();
-                    if (!cachedToken) return [3 /*break*/, 4];
-                    if (!isValid(cachedToken)) return [3 /*break*/, 2];
-                    token = cachedToken;
-                    return [3 /*break*/, 4];
-                case 2: 
+async function getToken$2(appCheck, forceRefresh = false) {
+    const app = appCheck.app;
+    ensureActivated(app);
+    const state = getStateReference(app);
+    /**
+     * First check if there is a token in memory from a previous `getToken()` call.
+     */
+    let token = state.token;
+    let error = undefined;
+    /**
+     * If an invalid token was found in memory, clear token from
+     * memory and unset the local variable `token`.
+     */
+    if (token && !isValid(token)) {
+        state.token = undefined;
+        token = undefined;
+    }
+    /**
+     * If there is no valid token in memory, try to load token from indexedDB.
+     */
+    if (!token) {
+        // cachedTokenPromise contains the token found in IndexedDB or undefined if not found.
+        const cachedToken = await state.cachedTokenPromise;
+        if (cachedToken) {
+            if (isValid(cachedToken)) {
+                token = cachedToken;
+            }
+            else {
                 // If there was an invalid token in the indexedDB cache, clear it.
-                return [4 /*yield*/, writeTokenToStorage(app, undefined)];
-                case 3:
-                    // If there was an invalid token in the indexedDB cache, clear it.
-                    _e.sent();
-                    _e.label = 4;
-                case 4:
-                    // Return the cached token (from either memory or indexedDB) if it's valid
-                    if (!forceRefresh && token && isValid(token)) {
-                        return [2 /*return*/, {
-                                token: token.token
-                            }];
-                    }
-                    shouldCallListeners = false;
-                    if (!isDebugMode()) return [3 /*break*/, 9];
-                    if (!!state.exchangeTokenPromise) return [3 /*break*/, 6];
-                    _a = state;
-                    _b = exchangeToken;
-                    _c = getExchangeDebugTokenRequest;
-                    _d = [app];
-                    return [4 /*yield*/, getDebugToken()];
-                case 5:
-                    _a.exchangeTokenPromise = _b.apply(void 0, [_c.apply(void 0, _d.concat([_e.sent()])),
-                        appCheck.heartbeatServiceProvider]).finally(function () {
-                        // Clear promise when settled - either resolved or rejected.
-                        state.exchangeTokenPromise = undefined;
-                    });
-                    shouldCallListeners = true;
-                    _e.label = 6;
-                case 6: return [4 /*yield*/, state.exchangeTokenPromise];
-                case 7:
-                    tokenFromDebugExchange = _e.sent();
-                    // Write debug token to indexedDB.
-                    return [4 /*yield*/, writeTokenToStorage(app, tokenFromDebugExchange)];
-                case 8:
-                    // Write debug token to indexedDB.
-                    _e.sent();
-                    // Write debug token to state.
-                    state.token = tokenFromDebugExchange;
-                    return [2 /*return*/, { token: tokenFromDebugExchange.token }];
-                case 9:
-                    _e.trys.push([9, 11, , 12]);
-                    // Avoid making another call to the exchange endpoint if one is in flight.
-                    if (!state.exchangeTokenPromise) {
-                        // state.provider is populated in initializeAppCheck()
-                        // ensureActivated() at the top of this function checks that
-                        // initializeAppCheck() has been called.
-                        state.exchangeTokenPromise = state.provider.getToken().finally(function () {
-                            // Clear promise when settled - either resolved or rejected.
-                            state.exchangeTokenPromise = undefined;
-                        });
-                        shouldCallListeners = true;
-                    }
-                    return [4 /*yield*/, getStateReference(app).exchangeTokenPromise];
-                case 10:
-                    token = _e.sent();
-                    return [3 /*break*/, 12];
-                case 11:
-                    e_1 = _e.sent();
-                    if (e_1.code === "appCheck/".concat("throttled" /* AppCheckError.THROTTLED */)) {
-                        // Warn if throttled, but do not treat it as an error.
-                        logger.warn(e_1.message);
-                    }
-                    else {
-                        // `getToken()` should never throw, but logging error text to console will aid debugging.
-                        logger.error(e_1);
-                    }
-                    // Always save error to be added to dummy token.
-                    error = e_1;
-                    return [3 /*break*/, 12];
-                case 12:
-                    if (!!token) return [3 /*break*/, 13];
-                    // If token is undefined, there must be an error.
-                    // Return a dummy token along with the error.
-                    interopTokenResult = makeDummyTokenResult(error);
-                    return [3 /*break*/, 16];
-                case 13:
-                    if (!error) return [3 /*break*/, 14];
-                    if (isValid(token)) {
-                        // It's also possible a valid token exists, but there's also an error.
-                        // (Such as if the token is almost expired, tries to refresh, and
-                        // the exchange request fails.)
-                        // We add a special error property here so that the refresher will
-                        // count this as a failed attempt and use the backoff instead of
-                        // retrying repeatedly with no delay, but any 3P listeners will not
-                        // be hindered in getting the still-valid token.
-                        interopTokenResult = {
-                            token: token.token,
-                            internalError: error
-                        };
-                    }
-                    else {
-                        // No invalid tokens should make it to this step. Memory and cached tokens
-                        // are checked. Other tokens are from fresh exchanges. But just in case.
-                        interopTokenResult = makeDummyTokenResult(error);
-                    }
-                    return [3 /*break*/, 16];
-                case 14:
-                    interopTokenResult = {
-                        token: token.token
-                    };
-                    // write the new token to the memory state as well as the persistent storage.
-                    // Only do it if we got a valid new token
-                    state.token = token;
-                    return [4 /*yield*/, writeTokenToStorage(app, token)];
-                case 15:
-                    _e.sent();
-                    _e.label = 16;
-                case 16:
-                    if (shouldCallListeners) {
-                        notifyTokenListeners(app, interopTokenResult);
-                    }
-                    return [2 /*return*/, interopTokenResult];
+                await writeTokenToStorage(app, undefined);
             }
-        });
-    });
+        }
+    }
+    // Return the cached token (from either memory or indexedDB) if it's valid
+    if (!forceRefresh && token && isValid(token)) {
+        return {
+            token: token.token
+        };
+    }
+    // Only set to true if this `getToken()` call is making the actual
+    // REST call to the exchange endpoint, versus waiting for an already
+    // in-flight call (see debug and regular exchange endpoint paths below)
+    let shouldCallListeners = false;
+    /**
+     * DEBUG MODE
+     * If debug mode is set, and there is no cached token, fetch a new App
+     * Check token using the debug token, and return it directly.
+     */
+    if (isDebugMode()) {
+        // Avoid making another call to the exchange endpoint if one is in flight.
+        if (!state.exchangeTokenPromise) {
+            state.exchangeTokenPromise = exchangeToken(getExchangeDebugTokenRequest(app, await getDebugToken()), appCheck.heartbeatServiceProvider).finally(() => {
+                // Clear promise when settled - either resolved or rejected.
+                state.exchangeTokenPromise = undefined;
+            });
+            shouldCallListeners = true;
+        }
+        const tokenFromDebugExchange = await state.exchangeTokenPromise;
+        // Write debug token to indexedDB.
+        await writeTokenToStorage(app, tokenFromDebugExchange);
+        // Write debug token to state.
+        state.token = tokenFromDebugExchange;
+        return { token: tokenFromDebugExchange.token };
+    }
+    /**
+     * There are no valid tokens in memory or indexedDB and we are not in
+     * debug mode.
+     * Request a new token from the exchange endpoint.
+     */
+    try {
+        // Avoid making another call to the exchange endpoint if one is in flight.
+        if (!state.exchangeTokenPromise) {
+            // state.provider is populated in initializeAppCheck()
+            // ensureActivated() at the top of this function checks that
+            // initializeAppCheck() has been called.
+            state.exchangeTokenPromise = state.provider.getToken().finally(() => {
+                // Clear promise when settled - either resolved or rejected.
+                state.exchangeTokenPromise = undefined;
+            });
+            shouldCallListeners = true;
+        }
+        token = await getStateReference(app).exchangeTokenPromise;
+    }
+    catch (e) {
+        if (e.code === `appCheck/${"throttled" /* AppCheckError.THROTTLED */}`) {
+            // Warn if throttled, but do not treat it as an error.
+            logger.warn(e.message);
+        }
+        else {
+            // `getToken()` should never throw, but logging error text to console will aid debugging.
+            logger.error(e);
+        }
+        // Always save error to be added to dummy token.
+        error = e;
+    }
+    let interopTokenResult;
+    if (!token) {
+        // If token is undefined, there must be an error.
+        // Return a dummy token along with the error.
+        interopTokenResult = makeDummyTokenResult(error);
+    }
+    else if (error) {
+        if (isValid(token)) {
+            // It's also possible a valid token exists, but there's also an error.
+            // (Such as if the token is almost expired, tries to refresh, and
+            // the exchange request fails.)
+            // We add a special error property here so that the refresher will
+            // count this as a failed attempt and use the backoff instead of
+            // retrying repeatedly with no delay, but any 3P listeners will not
+            // be hindered in getting the still-valid token.
+            interopTokenResult = {
+                token: token.token,
+                internalError: error
+            };
+        }
+        else {
+            // No invalid tokens should make it to this step. Memory and cached tokens
+            // are checked. Other tokens are from fresh exchanges. But just in case.
+            interopTokenResult = makeDummyTokenResult(error);
+        }
+    }
+    else {
+        interopTokenResult = {
+            token: token.token
+        };
+        // write the new token to the memory state as well as the persistent storage.
+        // Only do it if we got a valid new token
+        state.token = token;
+        await writeTokenToStorage(app, token);
+    }
+    if (shouldCallListeners) {
+        notifyTokenListeners(app, interopTokenResult);
+    }
+    return interopTokenResult;
 }
 /**
  * Internal API for limited use tokens. Skips all FAC state and simply calls
  * the underlying provider.
  */
-function getLimitedUseToken$1(appCheck) {
-    return tslib.__awaiter(this, void 0, void 0, function () {
-        var app, provider, debugToken, token, token;
-        return tslib.__generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    app = appCheck.app;
-                    ensureActivated(app);
-                    provider = getStateReference(app).provider;
-                    if (!isDebugMode()) return [3 /*break*/, 3];
-                    return [4 /*yield*/, getDebugToken()];
-                case 1:
-                    debugToken = _a.sent();
-                    return [4 /*yield*/, exchangeToken(getExchangeDebugTokenRequest(app, debugToken), appCheck.heartbeatServiceProvider)];
-                case 2:
-                    token = (_a.sent()).token;
-                    return [2 /*return*/, { token: token }];
-                case 3: return [4 /*yield*/, provider.getToken()];
-                case 4:
-                    token = (_a.sent()).token;
-                    return [2 /*return*/, { token: token }];
-            }
-        });
-    });
+async function getLimitedUseToken$1(appCheck) {
+    const app = appCheck.app;
+    ensureActivated(app);
+    const { provider } = getStateReference(app);
+    if (isDebugMode()) {
+        const debugToken = await getDebugToken();
+        const { token } = await exchangeToken(getExchangeDebugTokenRequest(app, debugToken), appCheck.heartbeatServiceProvider);
+        return { token };
+    }
+    else {
+        // provider is definitely valid since we ensure AppCheck was activated
+        const { token } = await provider.getToken();
+        return { token };
+    }
 }
 function addTokenListener(appCheck, type, listener, onError) {
-    var app = appCheck.app;
-    var state = getStateReference(app);
-    var tokenObserver = {
+    const { app } = appCheck;
+    const state = getStateReference(app);
+    const tokenObserver = {
         next: listener,
         error: onError,
-        type: type
+        type
     };
-    state.tokenObservers = tslib.__spreadArray(tslib.__spreadArray([], state.tokenObservers, true), [tokenObserver], false);
+    state.tokenObservers = [...state.tokenObservers, tokenObserver];
     // Invoke the listener async immediately if there is a valid token
     // in memory.
     if (state.token && isValid(state.token)) {
-        var validToken_1 = state.token;
+        const validToken = state.token;
         Promise.resolve()
-            .then(function () {
-            listener({ token: validToken_1.token });
+            .then(() => {
+            listener({ token: validToken.token });
             initTokenRefresher(appCheck);
         })
-            .catch(function () {
+            .catch(() => {
             /* we don't care about exceptions thrown in listeners */
         });
     }
@@ -986,11 +881,11 @@ function addTokenListener(appCheck, type, listener, onError) {
      * listeners that exist when it resolves.
      */
     // state.cachedTokenPromise is always populated in `activate()`.
-    void state.cachedTokenPromise.then(function () { return initTokenRefresher(appCheck); });
+    void state.cachedTokenPromise.then(() => initTokenRefresher(appCheck));
 }
 function removeTokenListener(app, listener) {
-    var state = getStateReference(app);
-    var newObservers = state.tokenObservers.filter(function (tokenObserver) { return tokenObserver.next !== listener; });
+    const state = getStateReference(app);
+    const newObservers = state.tokenObservers.filter(tokenObserver => tokenObserver.next !== listener);
     if (newObservers.length === 0 &&
         state.tokenRefresher &&
         state.tokenRefresher.isRunning()) {
@@ -1002,11 +897,11 @@ function removeTokenListener(app, listener) {
  * Logic to create and start refresher as needed.
  */
 function initTokenRefresher(appCheck) {
-    var app = appCheck.app;
-    var state = getStateReference(app);
+    const { app } = appCheck;
+    const state = getStateReference(app);
     // Create the refresher but don't start it if `isTokenAutoRefreshEnabled`
     // is not true.
-    var refresher = state.tokenRefresher;
+    let refresher = state.tokenRefresher;
     if (!refresher) {
         refresher = createTokenRefresher(appCheck);
         state.tokenRefresher = refresher;
@@ -1016,60 +911,51 @@ function initTokenRefresher(appCheck) {
     }
 }
 function createTokenRefresher(appCheck) {
-    var _this = this;
-    var app = appCheck.app;
+    const { app } = appCheck;
     return new Refresher(
     // Keep in mind when this fails for any reason other than the ones
     // for which we should retry, it will effectively stop the proactive refresh.
-    function () { return tslib.__awaiter(_this, void 0, void 0, function () {
-        var state, result;
-        return tslib.__generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    state = getStateReference(app);
-                    if (!!state.token) return [3 /*break*/, 2];
-                    return [4 /*yield*/, getToken$2(appCheck)];
-                case 1:
-                    result = _a.sent();
-                    return [3 /*break*/, 4];
-                case 2: return [4 /*yield*/, getToken$2(appCheck, true)];
-                case 3:
-                    result = _a.sent();
-                    _a.label = 4;
-                case 4:
-                    /**
-                     * getToken() always resolves. In case the result has an error field defined, it means
-                     * the operation failed, and we should retry.
-                     */
-                    if (result.error) {
-                        throw result.error;
-                    }
-                    /**
-                     * A special `internalError` field reflects that there was an error
-                     * getting a new token from the exchange endpoint, but there's still a
-                     * previous token that's valid for now and this should be passed to 2P/3P
-                     * requests for a token. But we want this callback (`this.operation` in
-                     * `Refresher`) to throw in order to kick off the Refresher's retry
-                     * backoff. (Setting `hasSucceeded` to false.)
-                     */
-                    if (result.internalError) {
-                        throw result.internalError;
-                    }
-                    return [2 /*return*/];
-            }
-        });
-    }); }, function () {
+    async () => {
+        const state = getStateReference(app);
+        // If there is no token, we will try to load it from storage and use it
+        // If there is a token, we force refresh it because we know it's going to expire soon
+        let result;
+        if (!state.token) {
+            result = await getToken$2(appCheck);
+        }
+        else {
+            result = await getToken$2(appCheck, true);
+        }
+        /**
+         * getToken() always resolves. In case the result has an error field defined, it means
+         * the operation failed, and we should retry.
+         */
+        if (result.error) {
+            throw result.error;
+        }
+        /**
+         * A special `internalError` field reflects that there was an error
+         * getting a new token from the exchange endpoint, but there's still a
+         * previous token that's valid for now and this should be passed to 2P/3P
+         * requests for a token. But we want this callback (`this.operation` in
+         * `Refresher`) to throw in order to kick off the Refresher's retry
+         * backoff. (Setting `hasSucceeded` to false.)
+         */
+        if (result.internalError) {
+            throw result.internalError;
+        }
+    }, () => {
         return true;
-    }, function () {
-        var state = getStateReference(app);
+    }, () => {
+        const state = getStateReference(app);
         if (state.token) {
             // issuedAtTime + (50% * total TTL) + 5 minutes
-            var nextRefreshTimeMillis = state.token.issuedAtTimeMillis +
+            let nextRefreshTimeMillis = state.token.issuedAtTimeMillis +
                 (state.token.expireTimeMillis - state.token.issuedAtTimeMillis) *
                     0.5 +
                 5 * 60 * 1000;
             // Do not allow refresh time to be past (expireTime - 5 minutes)
-            var latestAllowableRefresh = state.token.expireTimeMillis - 5 * 60 * 1000;
+            const latestAllowableRefresh = state.token.expireTimeMillis - 5 * 60 * 1000;
             nextRefreshTimeMillis = Math.min(nextRefreshTimeMillis, latestAllowableRefresh);
             return Math.max(0, nextRefreshTimeMillis - Date.now());
         }
@@ -1079,9 +965,8 @@ function createTokenRefresher(appCheck) {
     }, TOKEN_REFRESH_TIME.RETRIAL_MIN_WAIT, TOKEN_REFRESH_TIME.RETRIAL_MAX_WAIT);
 }
 function notifyTokenListeners(app, token) {
-    var observers = getStateReference(app).tokenObservers;
-    for (var _i = 0, observers_1 = observers; _i < observers_1.length; _i++) {
-        var observer = observers_1[_i];
+    const observers = getStateReference(app).tokenObservers;
+    for (const observer of observers) {
         try {
             if (observer.type === "EXTERNAL" /* ListenerType.EXTERNAL */ && token.error != null) {
                 // If this listener was added by a 3P call, send any token error to
@@ -1107,7 +992,7 @@ function isValid(token) {
 function makeDummyTokenResult(error) {
     return {
         token: formatDummyToken(defaultTokenErrorData),
-        error: error
+        error
     };
 }
 
@@ -1130,37 +1015,33 @@ function makeDummyTokenResult(error) {
 /**
  * AppCheck Service class.
  */
-var AppCheckService = /** @class */ (function () {
-    function AppCheckService(app, heartbeatServiceProvider) {
+class AppCheckService {
+    constructor(app, heartbeatServiceProvider) {
         this.app = app;
         this.heartbeatServiceProvider = heartbeatServiceProvider;
     }
-    AppCheckService.prototype._delete = function () {
-        var tokenObservers = getStateReference(this.app).tokenObservers;
-        for (var _i = 0, tokenObservers_1 = tokenObservers; _i < tokenObservers_1.length; _i++) {
-            var tokenObserver = tokenObservers_1[_i];
+    _delete() {
+        const { tokenObservers } = getStateReference(this.app);
+        for (const tokenObserver of tokenObservers) {
             removeTokenListener(this.app, tokenObserver.next);
         }
         return Promise.resolve();
-    };
-    return AppCheckService;
-}());
+    }
+}
 function factory(app, heartbeatServiceProvider) {
     return new AppCheckService(app, heartbeatServiceProvider);
 }
 function internalFactory(appCheck) {
     return {
-        getToken: function (forceRefresh) { return getToken$2(appCheck, forceRefresh); },
-        getLimitedUseToken: function () { return getLimitedUseToken$1(appCheck); },
-        addTokenListener: function (listener) {
-            return addTokenListener(appCheck, "INTERNAL" /* ListenerType.INTERNAL */, listener);
-        },
-        removeTokenListener: function (listener) { return removeTokenListener(appCheck.app, listener); }
+        getToken: forceRefresh => getToken$2(appCheck, forceRefresh),
+        getLimitedUseToken: () => getLimitedUseToken$1(appCheck),
+        addTokenListener: listener => addTokenListener(appCheck, "INTERNAL" /* ListenerType.INTERNAL */, listener),
+        removeTokenListener: listener => removeTokenListener(appCheck.app, listener)
     };
 }
 
-var name = "@firebase/app-check";
-var version = "0.8.8";
+const name = "@firebase/app-check";
+const version = "0.8.9";
 
 /**
  * @license
@@ -1178,17 +1059,17 @@ var version = "0.8.8";
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-var RECAPTCHA_URL = 'https://www.google.com/recaptcha/api.js';
-var RECAPTCHA_ENTERPRISE_URL = 'https://www.google.com/recaptcha/enterprise.js';
+const RECAPTCHA_URL = 'https://www.google.com/recaptcha/api.js';
+const RECAPTCHA_ENTERPRISE_URL = 'https://www.google.com/recaptcha/enterprise.js';
 function initializeV3(app, siteKey) {
-    var initialized = new util.Deferred();
-    var state = getStateReference(app);
-    state.reCAPTCHAState = { initialized: initialized };
-    var divId = makeDiv(app);
-    var grecaptcha = getRecaptcha(false);
+    const initialized = new util.Deferred();
+    const state = getStateReference(app);
+    state.reCAPTCHAState = { initialized };
+    const divId = makeDiv(app);
+    const grecaptcha = getRecaptcha(false);
     if (!grecaptcha) {
-        loadReCAPTCHAV3Script(function () {
-            var grecaptcha = getRecaptcha(false);
+        loadReCAPTCHAV3Script(() => {
+            const grecaptcha = getRecaptcha(false);
             if (!grecaptcha) {
                 // it shouldn't happen.
                 throw new Error('no recaptcha');
@@ -1202,14 +1083,14 @@ function initializeV3(app, siteKey) {
     return initialized.promise;
 }
 function initializeEnterprise(app, siteKey) {
-    var initialized = new util.Deferred();
-    var state = getStateReference(app);
-    state.reCAPTCHAState = { initialized: initialized };
-    var divId = makeDiv(app);
-    var grecaptcha = getRecaptcha(true);
+    const initialized = new util.Deferred();
+    const state = getStateReference(app);
+    state.reCAPTCHAState = { initialized };
+    const divId = makeDiv(app);
+    const grecaptcha = getRecaptcha(true);
     if (!grecaptcha) {
-        loadReCAPTCHAEnterpriseScript(function () {
-            var grecaptcha = getRecaptcha(true);
+        loadReCAPTCHAEnterpriseScript(() => {
+            const grecaptcha = getRecaptcha(true);
             if (!grecaptcha) {
                 // it shouldn't happen.
                 throw new Error('no recaptcha');
@@ -1227,7 +1108,7 @@ function initializeEnterprise(app, siteKey) {
  * the grecaptcha.ready() event fires.
  */
 function queueWidgetRender(app, siteKey, grecaptcha, container, initialized) {
-    grecaptcha.ready(function () {
+    grecaptcha.ready(() => {
         // Invisible widgets allow us to set a different siteKey for each widget,
         // so we use them to support multiple apps
         renderInvisibleWidget(app, siteKey, grecaptcha, container);
@@ -1238,36 +1119,27 @@ function queueWidgetRender(app, siteKey, grecaptcha, container, initialized) {
  * Add invisible div to page.
  */
 function makeDiv(app) {
-    var divId = "fire_app_check_".concat(app.name);
-    var invisibleDiv = document.createElement('div');
+    const divId = `fire_app_check_${app.name}`;
+    const invisibleDiv = document.createElement('div');
     invisibleDiv.id = divId;
     invisibleDiv.style.display = 'none';
     document.body.appendChild(invisibleDiv);
     return divId;
 }
-function getToken$1(app) {
-    return tslib.__awaiter(this, void 0, void 0, function () {
-        var reCAPTCHAState, recaptcha;
-        return tslib.__generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    ensureActivated(app);
-                    reCAPTCHAState = getStateReference(app).reCAPTCHAState;
-                    return [4 /*yield*/, reCAPTCHAState.initialized.promise];
-                case 1:
-                    recaptcha = _a.sent();
-                    return [2 /*return*/, new Promise(function (resolve, _reject) {
-                            // Updated after initialization is complete.
-                            var reCAPTCHAState = getStateReference(app).reCAPTCHAState;
-                            recaptcha.ready(function () {
-                                resolve(
-                                // widgetId is guaranteed to be available if reCAPTCHAState.initialized.promise resolved.
-                                recaptcha.execute(reCAPTCHAState.widgetId, {
-                                    action: 'fire_app_check'
-                                }));
-                            });
-                        })];
-            }
+async function getToken$1(app) {
+    ensureActivated(app);
+    // ensureActivated() guarantees that reCAPTCHAState is set
+    const reCAPTCHAState = getStateReference(app).reCAPTCHAState;
+    const recaptcha = await reCAPTCHAState.initialized.promise;
+    return new Promise((resolve, _reject) => {
+        // Updated after initialization is complete.
+        const reCAPTCHAState = getStateReference(app).reCAPTCHAState;
+        recaptcha.ready(() => {
+            resolve(
+            // widgetId is guaranteed to be available if reCAPTCHAState.initialized.promise resolved.
+            recaptcha.execute(reCAPTCHAState.widgetId, {
+                action: 'fire_app_check'
+            }));
         });
     });
 }
@@ -1277,30 +1149,30 @@ function getToken$1(app) {
  * @param container - Id of a HTML element.
  */
 function renderInvisibleWidget(app, siteKey, grecaptcha, container) {
-    var widgetId = grecaptcha.render(container, {
+    const widgetId = grecaptcha.render(container, {
         sitekey: siteKey,
         size: 'invisible',
         // Success callback - set state
-        callback: function () {
+        callback: () => {
             getStateReference(app).reCAPTCHAState.succeeded = true;
         },
         // Failure callback - set state
-        'error-callback': function () {
+        'error-callback': () => {
             getStateReference(app).reCAPTCHAState.succeeded = false;
         }
     });
-    var state = getStateReference(app);
-    state.reCAPTCHAState = tslib.__assign(tslib.__assign({}, state.reCAPTCHAState), { // state.reCAPTCHAState is set in the initialize()
-        widgetId: widgetId });
+    const state = getStateReference(app);
+    state.reCAPTCHAState = Object.assign(Object.assign({}, state.reCAPTCHAState), { // state.reCAPTCHAState is set in the initialize()
+        widgetId });
 }
 function loadReCAPTCHAV3Script(onload) {
-    var script = document.createElement('script');
+    const script = document.createElement('script');
     script.src = RECAPTCHA_URL;
     script.onload = onload;
     document.head.appendChild(script);
 }
 function loadReCAPTCHAEnterpriseScript(onload) {
-    var script = document.createElement('script');
+    const script = document.createElement('script');
     script.src = RECAPTCHA_ENTERPRISE_URL;
     script.onload = onload;
     document.head.appendChild(script);
@@ -1328,12 +1200,12 @@ function loadReCAPTCHAEnterpriseScript(onload) {
  *
  * @public
  */
-var ReCaptchaV3Provider = /** @class */ (function () {
+class ReCaptchaV3Provider {
     /**
      * Create a ReCaptchaV3Provider instance.
      * @param siteKey - ReCAPTCHA V3 siteKey.
      */
-    function ReCaptchaV3Provider(_siteKey) {
+    constructor(_siteKey) {
         this._siteKey = _siteKey;
         /**
          * Throttle requests on certain error codes to prevent too many retries
@@ -1345,86 +1217,73 @@ var ReCaptchaV3Provider = /** @class */ (function () {
      * Returns an App Check token.
      * @internal
      */
-    ReCaptchaV3Provider.prototype.getToken = function () {
+    async getToken() {
         var _a, _b, _c;
-        return tslib.__awaiter(this, void 0, void 0, function () {
-            var attestedClaimsToken, result, e_1;
-            return tslib.__generator(this, function (_d) {
-                switch (_d.label) {
-                    case 0:
-                        throwIfThrottled(this._throttleData);
-                        return [4 /*yield*/, getToken$1(this._app).catch(function (_e) {
-                                // reCaptcha.execute() throws null which is not very descriptive.
-                                throw ERROR_FACTORY.create("recaptcha-error" /* AppCheckError.RECAPTCHA_ERROR */);
-                            })];
-                    case 1:
-                        attestedClaimsToken = _d.sent();
-                        // Check if a failure state was set by the recaptcha "error-callback".
-                        if (!((_a = getStateReference(this._app).reCAPTCHAState) === null || _a === void 0 ? void 0 : _a.succeeded)) {
-                            throw ERROR_FACTORY.create("recaptcha-error" /* AppCheckError.RECAPTCHA_ERROR */);
-                        }
-                        _d.label = 2;
-                    case 2:
-                        _d.trys.push([2, 4, , 5]);
-                        return [4 /*yield*/, exchangeToken(getExchangeRecaptchaV3TokenRequest(this._app, attestedClaimsToken), this._heartbeatServiceProvider)];
-                    case 3:
-                        result = _d.sent();
-                        return [3 /*break*/, 5];
-                    case 4:
-                        e_1 = _d.sent();
-                        if ((_b = e_1.code) === null || _b === void 0 ? void 0 : _b.includes("fetch-status-error" /* AppCheckError.FETCH_STATUS_ERROR */)) {
-                            this._throttleData = setBackoff(Number((_c = e_1.customData) === null || _c === void 0 ? void 0 : _c.httpStatus), this._throttleData);
-                            throw ERROR_FACTORY.create("throttled" /* AppCheckError.THROTTLED */, {
-                                time: getDurationString(this._throttleData.allowRequestsAfter - Date.now()),
-                                httpStatus: this._throttleData.httpStatus
-                            });
-                        }
-                        else {
-                            throw e_1;
-                        }
-                    case 5:
-                        // If successful, clear throttle data.
-                        this._throttleData = null;
-                        return [2 /*return*/, result];
-                }
-            });
+        throwIfThrottled(this._throttleData);
+        // Top-level `getToken()` has already checked that App Check is initialized
+        // and therefore this._app and this._heartbeatServiceProvider are available.
+        const attestedClaimsToken = await getToken$1(this._app).catch(_e => {
+            // reCaptcha.execute() throws null which is not very descriptive.
+            throw ERROR_FACTORY.create("recaptcha-error" /* AppCheckError.RECAPTCHA_ERROR */);
         });
-    };
+        // Check if a failure state was set by the recaptcha "error-callback".
+        if (!((_a = getStateReference(this._app).reCAPTCHAState) === null || _a === void 0 ? void 0 : _a.succeeded)) {
+            throw ERROR_FACTORY.create("recaptcha-error" /* AppCheckError.RECAPTCHA_ERROR */);
+        }
+        let result;
+        try {
+            result = await exchangeToken(getExchangeRecaptchaV3TokenRequest(this._app, attestedClaimsToken), this._heartbeatServiceProvider);
+        }
+        catch (e) {
+            if ((_b = e.code) === null || _b === void 0 ? void 0 : _b.includes("fetch-status-error" /* AppCheckError.FETCH_STATUS_ERROR */)) {
+                this._throttleData = setBackoff(Number((_c = e.customData) === null || _c === void 0 ? void 0 : _c.httpStatus), this._throttleData);
+                throw ERROR_FACTORY.create("throttled" /* AppCheckError.THROTTLED */, {
+                    time: getDurationString(this._throttleData.allowRequestsAfter - Date.now()),
+                    httpStatus: this._throttleData.httpStatus
+                });
+            }
+            else {
+                throw e;
+            }
+        }
+        // If successful, clear throttle data.
+        this._throttleData = null;
+        return result;
+    }
     /**
      * @internal
      */
-    ReCaptchaV3Provider.prototype.initialize = function (app$1) {
+    initialize(app$1) {
         this._app = app$1;
         this._heartbeatServiceProvider = app._getProvider(app$1, 'heartbeat');
-        initializeV3(app$1, this._siteKey).catch(function () {
+        initializeV3(app$1, this._siteKey).catch(() => {
             /* we don't care about the initialization result */
         });
-    };
+    }
     /**
      * @internal
      */
-    ReCaptchaV3Provider.prototype.isEqual = function (otherProvider) {
+    isEqual(otherProvider) {
         if (otherProvider instanceof ReCaptchaV3Provider) {
             return this._siteKey === otherProvider._siteKey;
         }
         else {
             return false;
         }
-    };
-    return ReCaptchaV3Provider;
-}());
+    }
+}
 /**
  * App Check provider that can obtain a reCAPTCHA Enterprise token and exchange it
  * for an App Check token.
  *
  * @public
  */
-var ReCaptchaEnterpriseProvider = /** @class */ (function () {
+class ReCaptchaEnterpriseProvider {
     /**
      * Create a ReCaptchaEnterpriseProvider instance.
      * @param siteKey - reCAPTCHA Enterprise score-based site key.
      */
-    function ReCaptchaEnterpriseProvider(_siteKey) {
+    constructor(_siteKey) {
         this._siteKey = _siteKey;
         /**
          * Throttle requests on certain error codes to prevent too many retries
@@ -1436,114 +1295,97 @@ var ReCaptchaEnterpriseProvider = /** @class */ (function () {
      * Returns an App Check token.
      * @internal
      */
-    ReCaptchaEnterpriseProvider.prototype.getToken = function () {
+    async getToken() {
         var _a, _b, _c;
-        return tslib.__awaiter(this, void 0, void 0, function () {
-            var attestedClaimsToken, result, e_2;
-            return tslib.__generator(this, function (_d) {
-                switch (_d.label) {
-                    case 0:
-                        throwIfThrottled(this._throttleData);
-                        return [4 /*yield*/, getToken$1(this._app).catch(function (_e) {
-                                // reCaptcha.execute() throws null which is not very descriptive.
-                                throw ERROR_FACTORY.create("recaptcha-error" /* AppCheckError.RECAPTCHA_ERROR */);
-                            })];
-                    case 1:
-                        attestedClaimsToken = _d.sent();
-                        // Check if a failure state was set by the recaptcha "error-callback".
-                        if (!((_a = getStateReference(this._app).reCAPTCHAState) === null || _a === void 0 ? void 0 : _a.succeeded)) {
-                            throw ERROR_FACTORY.create("recaptcha-error" /* AppCheckError.RECAPTCHA_ERROR */);
-                        }
-                        _d.label = 2;
-                    case 2:
-                        _d.trys.push([2, 4, , 5]);
-                        return [4 /*yield*/, exchangeToken(getExchangeRecaptchaEnterpriseTokenRequest(this._app, attestedClaimsToken), this._heartbeatServiceProvider)];
-                    case 3:
-                        result = _d.sent();
-                        return [3 /*break*/, 5];
-                    case 4:
-                        e_2 = _d.sent();
-                        if ((_b = e_2.code) === null || _b === void 0 ? void 0 : _b.includes("fetch-status-error" /* AppCheckError.FETCH_STATUS_ERROR */)) {
-                            this._throttleData = setBackoff(Number((_c = e_2.customData) === null || _c === void 0 ? void 0 : _c.httpStatus), this._throttleData);
-                            throw ERROR_FACTORY.create("throttled" /* AppCheckError.THROTTLED */, {
-                                time: getDurationString(this._throttleData.allowRequestsAfter - Date.now()),
-                                httpStatus: this._throttleData.httpStatus
-                            });
-                        }
-                        else {
-                            throw e_2;
-                        }
-                    case 5:
-                        // If successful, clear throttle data.
-                        this._throttleData = null;
-                        return [2 /*return*/, result];
-                }
-            });
+        throwIfThrottled(this._throttleData);
+        // Top-level `getToken()` has already checked that App Check is initialized
+        // and therefore this._app and this._heartbeatServiceProvider are available.
+        const attestedClaimsToken = await getToken$1(this._app).catch(_e => {
+            // reCaptcha.execute() throws null which is not very descriptive.
+            throw ERROR_FACTORY.create("recaptcha-error" /* AppCheckError.RECAPTCHA_ERROR */);
         });
-    };
+        // Check if a failure state was set by the recaptcha "error-callback".
+        if (!((_a = getStateReference(this._app).reCAPTCHAState) === null || _a === void 0 ? void 0 : _a.succeeded)) {
+            throw ERROR_FACTORY.create("recaptcha-error" /* AppCheckError.RECAPTCHA_ERROR */);
+        }
+        let result;
+        try {
+            result = await exchangeToken(getExchangeRecaptchaEnterpriseTokenRequest(this._app, attestedClaimsToken), this._heartbeatServiceProvider);
+        }
+        catch (e) {
+            if ((_b = e.code) === null || _b === void 0 ? void 0 : _b.includes("fetch-status-error" /* AppCheckError.FETCH_STATUS_ERROR */)) {
+                this._throttleData = setBackoff(Number((_c = e.customData) === null || _c === void 0 ? void 0 : _c.httpStatus), this._throttleData);
+                throw ERROR_FACTORY.create("throttled" /* AppCheckError.THROTTLED */, {
+                    time: getDurationString(this._throttleData.allowRequestsAfter - Date.now()),
+                    httpStatus: this._throttleData.httpStatus
+                });
+            }
+            else {
+                throw e;
+            }
+        }
+        // If successful, clear throttle data.
+        this._throttleData = null;
+        return result;
+    }
     /**
      * @internal
      */
-    ReCaptchaEnterpriseProvider.prototype.initialize = function (app$1) {
+    initialize(app$1) {
         this._app = app$1;
         this._heartbeatServiceProvider = app._getProvider(app$1, 'heartbeat');
-        initializeEnterprise(app$1, this._siteKey).catch(function () {
+        initializeEnterprise(app$1, this._siteKey).catch(() => {
             /* we don't care about the initialization result */
         });
-    };
+    }
     /**
      * @internal
      */
-    ReCaptchaEnterpriseProvider.prototype.isEqual = function (otherProvider) {
+    isEqual(otherProvider) {
         if (otherProvider instanceof ReCaptchaEnterpriseProvider) {
             return this._siteKey === otherProvider._siteKey;
         }
         else {
             return false;
         }
-    };
-    return ReCaptchaEnterpriseProvider;
-}());
+    }
+}
 /**
  * Custom provider class.
  * @public
  */
-var CustomProvider = /** @class */ (function () {
-    function CustomProvider(_customProviderOptions) {
+class CustomProvider {
+    constructor(_customProviderOptions) {
         this._customProviderOptions = _customProviderOptions;
     }
     /**
      * @internal
      */
-    CustomProvider.prototype.getToken = function () {
-        return tslib.__awaiter(this, void 0, void 0, function () {
-            var customToken, issuedAtTimeSeconds, issuedAtTimeMillis;
-            return tslib.__generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0: return [4 /*yield*/, this._customProviderOptions.getToken()];
-                    case 1:
-                        customToken = _a.sent();
-                        issuedAtTimeSeconds = util.issuedAtTime(customToken.token);
-                        issuedAtTimeMillis = issuedAtTimeSeconds !== null &&
-                            issuedAtTimeSeconds < Date.now() &&
-                            issuedAtTimeSeconds > 0
-                            ? issuedAtTimeSeconds * 1000
-                            : Date.now();
-                        return [2 /*return*/, tslib.__assign(tslib.__assign({}, customToken), { issuedAtTimeMillis: issuedAtTimeMillis })];
-                }
-            });
-        });
-    };
+    async getToken() {
+        // custom provider
+        const customToken = await this._customProviderOptions.getToken();
+        // Try to extract IAT from custom token, in case this token is not
+        // being newly issued. JWT timestamps are in seconds since epoch.
+        const issuedAtTimeSeconds = util.issuedAtTime(customToken.token);
+        // Very basic validation, use current timestamp as IAT if JWT
+        // has no `iat` field or value is out of bounds.
+        const issuedAtTimeMillis = issuedAtTimeSeconds !== null &&
+            issuedAtTimeSeconds < Date.now() &&
+            issuedAtTimeSeconds > 0
+            ? issuedAtTimeSeconds * 1000
+            : Date.now();
+        return Object.assign(Object.assign({}, customToken), { issuedAtTimeMillis });
+    }
     /**
      * @internal
      */
-    CustomProvider.prototype.initialize = function (app) {
+    initialize(app) {
         this._app = app;
-    };
+    }
     /**
      * @internal
      */
-    CustomProvider.prototype.isEqual = function (otherProvider) {
+    isEqual(otherProvider) {
         if (otherProvider instanceof CustomProvider) {
             return (this._customProviderOptions.getToken.toString() ===
                 otherProvider._customProviderOptions.getToken.toString());
@@ -1551,9 +1393,8 @@ var CustomProvider = /** @class */ (function () {
         else {
             return false;
         }
-    };
-    return CustomProvider;
-}());
+    }
+}
 /**
  * Set throttle data to block requests until after a certain time
  * depending on the failed request's status code.
@@ -1577,7 +1418,7 @@ function setBackoff(httpStatus, throttleData) {
         return {
             backoffCount: 1,
             allowRequestsAfter: Date.now() + ONE_DAY,
-            httpStatus: httpStatus
+            httpStatus
         };
     }
     else {
@@ -1585,12 +1426,12 @@ function setBackoff(httpStatus, throttleData) {
          * For all other error codes, the time when it is ok to retry again
          * is based on exponential backoff.
          */
-        var backoffCount = throttleData ? throttleData.backoffCount : 0;
-        var backoffMillis = util.calculateBackoffMillis(backoffCount, 1000, 2);
+        const backoffCount = throttleData ? throttleData.backoffCount : 0;
+        const backoffMillis = util.calculateBackoffMillis(backoffCount, 1000, 2);
         return {
             backoffCount: backoffCount + 1,
             allowRequestsAfter: Date.now() + backoffMillis,
-            httpStatus: httpStatus
+            httpStatus
         };
     }
 }
@@ -1628,10 +1469,9 @@ function throwIfThrottled(throttleData) {
  * @param options - App Check initialization options
  * @public
  */
-function initializeAppCheck(app$1, options) {
-    if (app$1 === void 0) { app$1 = app.getApp(); }
+function initializeAppCheck(app$1 = app.getApp(), options) {
     app$1 = util.getModularInstance(app$1);
-    var provider = app._getProvider(app$1, 'app-check');
+    const provider = app._getProvider(app$1, 'app-check');
     // Ensure initializeDebugMode() is only called once.
     if (!getDebugState().initialized) {
         initializeDebugMode();
@@ -1640,14 +1480,13 @@ function initializeAppCheck(app$1, options) {
     // is called in debug mode.
     if (isDebugMode()) {
         // Do not block initialization to get the token for the message.
-        void getDebugToken().then(function (token) {
-            // Not using logger because I don't think we ever want this accidentally hidden.
-            return console.log("App Check debug token: ".concat(token, ". You will need to add it to your app's App Check settings in the Firebase console for it to work."));
-        });
+        void getDebugToken().then(token => 
+        // Not using logger because I don't think we ever want this accidentally hidden.
+        console.log(`App Check debug token: ${token}. You will need to add it to your app's App Check settings in the Firebase console for it to work.`));
     }
     if (provider.isInitialized()) {
-        var existingInstance = provider.getImmediate();
-        var initialOptions = provider.getOptions();
+        const existingInstance = provider.getImmediate();
+        const initialOptions = provider.getOptions();
         if (initialOptions.isTokenAutoRefreshEnabled ===
             options.isTokenAutoRefreshEnabled &&
             initialOptions.provider.isEqual(options.provider)) {
@@ -1659,7 +1498,7 @@ function initializeAppCheck(app$1, options) {
             });
         }
     }
-    var appCheck = provider.initialize({ options: options });
+    const appCheck = provider.initialize({ options });
     _activate(app$1, options.provider, options.isTokenAutoRefreshEnabled);
     // If isTokenAutoRefreshEnabled is false, do not send any requests to the
     // exchange endpoint without an explicit call from the user either directly
@@ -1670,7 +1509,7 @@ function initializeAppCheck(app$1, options) {
         // requests the token.
         // Listener function does not need to do anything, its base functionality
         // of calling getToken() already fetches token and writes it to memory/storage.
-        addTokenListener(appCheck, "INTERNAL" /* ListenerType.INTERNAL */, function () { });
+        addTokenListener(appCheck, "INTERNAL" /* ListenerType.INTERNAL */, () => { });
     }
     return appCheck;
 }
@@ -1687,10 +1526,10 @@ function initializeAppCheck(app$1, options) {
 function _activate(app, provider, isTokenAutoRefreshEnabled) {
     // Create an entry in the APP_CHECK_STATES map. Further changes should
     // directly mutate this object.
-    var state = setInitialState(app, tslib.__assign({}, DEFAULT_STATE));
+    const state = setInitialState(app, Object.assign({}, DEFAULT_STATE));
     state.activated = true;
     state.provider = provider; // Read cached token from storage if it exists and store it in memory.
-    state.cachedTokenPromise = readTokenFromStorage(app).then(function (cachedToken) {
+    state.cachedTokenPromise = readTokenFromStorage(app).then(cachedToken => {
         if (cachedToken && isValid(cachedToken)) {
             state.token = cachedToken;
             // notify all listeners with the cached token
@@ -1717,8 +1556,8 @@ function _activate(app, provider, isTokenAutoRefreshEnabled) {
  * @public
  */
 function setTokenAutoRefreshEnabled(appCheckInstance, isTokenAutoRefreshEnabled) {
-    var app = appCheckInstance.app;
-    var state = getStateReference(app);
+    const app = appCheckInstance.app;
+    const state = getStateReference(app);
     // This will exist if any product libraries have called
     // `addTokenListener()`
     if (state.tokenRefresher) {
@@ -1743,21 +1582,12 @@ function setTokenAutoRefreshEnabled(appCheckInstance, isTokenAutoRefreshEnabled)
  * If false, will use a cached token if found in storage.
  * @public
  */
-function getToken(appCheckInstance, forceRefresh) {
-    return tslib.__awaiter(this, void 0, void 0, function () {
-        var result;
-        return tslib.__generator(this, function (_a) {
-            switch (_a.label) {
-                case 0: return [4 /*yield*/, getToken$2(appCheckInstance, forceRefresh)];
-                case 1:
-                    result = _a.sent();
-                    if (result.error) {
-                        throw result.error;
-                    }
-                    return [2 /*return*/, { token: result.token }];
-            }
-        });
-    });
+async function getToken(appCheckInstance, forceRefresh) {
+    const result = await getToken$2(appCheckInstance, forceRefresh);
+    if (result.error) {
+        throw result.error;
+    }
+    return { token: result.token };
 }
 /**
  * Requests a Firebase App Check token. This method should be used
@@ -1790,8 +1620,8 @@ function onTokenChanged(appCheckInstance, onNextOrObserver, onError,
  */
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
 onCompletion) {
-    var nextFn = function () { };
-    var errorFn = function () { };
+    let nextFn = () => { };
+    let errorFn = () => { };
     if (onNextOrObserver.next != null) {
         nextFn = onNextOrObserver.next.bind(onNextOrObserver);
     }
@@ -1805,7 +1635,7 @@ onCompletion) {
         errorFn = onError;
     }
     addTokenListener(appCheckInstance, "EXTERNAL" /* ListenerType.EXTERNAL */, nextFn, errorFn);
-    return function () { return removeTokenListener(appCheckInstance.app, nextFn); };
+    return () => removeTokenListener(appCheckInstance.app, nextFn);
 }
 
 /**
@@ -1818,14 +1648,14 @@ onCompletion) {
  *
  * @packageDocumentation
  */
-var APP_CHECK_NAME = 'app-check';
-var APP_CHECK_NAME_INTERNAL = 'app-check-internal';
+const APP_CHECK_NAME = 'app-check';
+const APP_CHECK_NAME_INTERNAL = 'app-check-internal';
 function registerAppCheck() {
     // The public interface
-    app._registerComponent(new component.Component(APP_CHECK_NAME, function (container) {
+    app._registerComponent(new component.Component(APP_CHECK_NAME, container => {
         // getImmediate for FirebaseApp will always succeed
-        var app = container.getProvider('app').getImmediate();
-        var heartbeatServiceProvider = container.getProvider('heartbeat');
+        const app = container.getProvider('app').getImmediate();
+        const heartbeatServiceProvider = container.getProvider('heartbeat');
         return factory(app, heartbeatServiceProvider);
     }, "PUBLIC" /* ComponentType.PUBLIC */)
         .setInstantiationMode("EXPLICIT" /* InstantiationMode.EXPLICIT */)
@@ -1833,12 +1663,12 @@ function registerAppCheck() {
          * Initialize app-check-internal after app-check is initialized to make AppCheck available to
          * other Firebase SDKs
          */
-        .setInstanceCreatedCallback(function (container, _identifier, _appcheckService) {
+        .setInstanceCreatedCallback((container, _identifier, _appcheckService) => {
         container.getProvider(APP_CHECK_NAME_INTERNAL).initialize();
     }));
     // The internal interface used by other Firebase products
-    app._registerComponent(new component.Component(APP_CHECK_NAME_INTERNAL, function (container) {
-        var appCheck = container.getProvider('app-check').getImmediate();
+    app._registerComponent(new component.Component(APP_CHECK_NAME_INTERNAL, container => {
+        const appCheck = container.getProvider('app-check').getImmediate();
         return internalFactory(appCheck);
     }, "PUBLIC" /* ComponentType.PUBLIC */).setInstantiationMode("EXPLICIT" /* InstantiationMode.EXPLICIT */));
     app.registerVersion(name, version);