@firebase/messaging 0.12.12 → 0.12.13

package/dist/index.sw.cjs

@@ -4,7 +4,6 @@ Object.defineProperty(exports, '__esModule', { value: true });
 
 require('@firebase/installations');
 var component = require('@firebase/component');
-var tslib = require('tslib');
 var idb = require('idb');
 var util = require('@firebase/util');
 var app = require('@firebase/app');
@@ -25,14 +24,14 @@ var app = require('@firebase/app');
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-var DEFAULT_VAPID_KEY = 'BDOU99-h67HcA6JeFXHbSNMu7e2yNNu3RzoMj8TM4W88jITfq7ZmPvIM1Iv-4_l2LxQcYwhqby2xGpWwzjfAnG4';
-var ENDPOINT = 'https://fcmregistrations.googleapis.com/v1';
+const DEFAULT_VAPID_KEY = 'BDOU99-h67HcA6JeFXHbSNMu7e2yNNu3RzoMj8TM4W88jITfq7ZmPvIM1Iv-4_l2LxQcYwhqby2xGpWwzjfAnG4';
+const ENDPOINT = 'https://fcmregistrations.googleapis.com/v1';
 /** Key of FCM Payload in Notification's data field. */
-var FCM_MSG = 'FCM_MSG';
-var CONSOLE_CAMPAIGN_ID = 'google.c.a.c_id';
+const FCM_MSG = 'FCM_MSG';
+const CONSOLE_CAMPAIGN_ID = 'google.c.a.c_id';
 // Defined as in proto/messaging_event.proto. Neglecting fields that are supported.
-var SDK_PLATFORM_WEB = 3;
-var EVENT_MESSAGE_DELIVERED = 1;
+const SDK_PLATFORM_WEB = 3;
+const EVENT_MESSAGE_DELIVERED = 1;
 var MessageType$1;
 (function (MessageType) {
     MessageType[MessageType["DATA_MESSAGE"] = 1] = "DATA_MESSAGE";
@@ -76,18 +75,18 @@ var MessageType;
  * limitations under the License.
  */
 function arrayToBase64(array) {
-    var uint8Array = new Uint8Array(array);
-    var base64String = btoa(String.fromCharCode.apply(String, tslib.__spreadArray([], tslib.__read(uint8Array), false)));
+    const uint8Array = new Uint8Array(array);
+    const base64String = btoa(String.fromCharCode(...uint8Array));
     return base64String.replace(/=/g, '').replace(/\+/g, '-').replace(/\//g, '_');
 }
 function base64ToArray(base64String) {
-    var padding = '='.repeat((4 - (base64String.length % 4)) % 4);
-    var base64 = (base64String + padding)
+    const padding = '='.repeat((4 - (base64String.length % 4)) % 4);
+    const base64 = (base64String + padding)
         .replace(/\-/g, '+')
         .replace(/_/g, '/');
-    var rawData = atob(base64);
-    var outputArray = new Uint8Array(rawData.length);
-    for (var i = 0; i < rawData.length; ++i) {
+    const rawData = atob(base64);
+    const outputArray = new Uint8Array(rawData.length);
+    for (let i = 0; i < rawData.length; ++i) {
         outputArray[i] = rawData.charCodeAt(i);
     }
     return outputArray;
@@ -109,134 +108,104 @@ function base64ToArray(base64String) {
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-var OLD_DB_NAME = 'fcm_token_details_db';
+const OLD_DB_NAME = 'fcm_token_details_db';
 /**
  * The last DB version of 'fcm_token_details_db' was 4. This is one higher, so that the upgrade
  * callback is called for all versions of the old DB.
  */
-var OLD_DB_VERSION = 5;
-var OLD_OBJECT_STORE_NAME = 'fcm_token_object_Store';
-function migrateOldDatabase(senderId) {
-    return tslib.__awaiter(this, void 0, void 0, function () {
-        var databases, dbNames, tokenDetails, db;
-        var _this = this;
-        return tslib.__generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    if (!('databases' in indexedDB)) return [3 /*break*/, 2];
-                    return [4 /*yield*/, indexedDB.databases()];
-                case 1:
-                    databases = _a.sent();
-                    dbNames = databases.map(function (db) { return db.name; });
-                    if (!dbNames.includes(OLD_DB_NAME)) {
-                        // old DB didn't exist, no need to open.
-                        return [2 /*return*/, null];
+const OLD_DB_VERSION = 5;
+const OLD_OBJECT_STORE_NAME = 'fcm_token_object_Store';
+async function migrateOldDatabase(senderId) {
+    if ('databases' in indexedDB) {
+        // indexedDb.databases() is an IndexedDB v3 API and does not exist in all browsers. TODO: Remove
+        // typecast when it lands in TS types.
+        const databases = await indexedDB.databases();
+        const dbNames = databases.map(db => db.name);
+        if (!dbNames.includes(OLD_DB_NAME)) {
+            // old DB didn't exist, no need to open.
+            return null;
+        }
+    }
+    let tokenDetails = null;
+    const db = await idb.openDB(OLD_DB_NAME, OLD_DB_VERSION, {
+        upgrade: async (db, oldVersion, newVersion, upgradeTransaction) => {
+            var _a;
+            if (oldVersion < 2) {
+                // Database too old, skip migration.
+                return;
+            }
+            if (!db.objectStoreNames.contains(OLD_OBJECT_STORE_NAME)) {
+                // Database did not exist. Nothing to do.
+                return;
+            }
+            const objectStore = upgradeTransaction.objectStore(OLD_OBJECT_STORE_NAME);
+            const value = await objectStore.index('fcmSenderId').get(senderId);
+            await objectStore.clear();
+            if (!value) {
+                // No entry in the database, nothing to migrate.
+                return;
+            }
+            if (oldVersion === 2) {
+                const oldDetails = value;
+                if (!oldDetails.auth || !oldDetails.p256dh || !oldDetails.endpoint) {
+                    return;
+                }
+                tokenDetails = {
+                    token: oldDetails.fcmToken,
+                    createTime: (_a = oldDetails.createTime) !== null && _a !== void 0 ? _a : Date.now(),
+                    subscriptionOptions: {
+                        auth: oldDetails.auth,
+                        p256dh: oldDetails.p256dh,
+                        endpoint: oldDetails.endpoint,
+                        swScope: oldDetails.swScope,
+                        vapidKey: typeof oldDetails.vapidKey === 'string'
+                            ? oldDetails.vapidKey
+                            : arrayToBase64(oldDetails.vapidKey)
                     }
-                    _a.label = 2;
-                case 2:
-                    tokenDetails = null;
-                    return [4 /*yield*/, idb.openDB(OLD_DB_NAME, OLD_DB_VERSION, {
-                            upgrade: function (db, oldVersion, newVersion, upgradeTransaction) { return tslib.__awaiter(_this, void 0, void 0, function () {
-                                var objectStore, value, oldDetails, oldDetails, oldDetails;
-                                var _a;
-                                return tslib.__generator(this, function (_b) {
-                                    switch (_b.label) {
-                                        case 0:
-                                            if (oldVersion < 2) {
-                                                // Database too old, skip migration.
-                                                return [2 /*return*/];
-                                            }
-                                            if (!db.objectStoreNames.contains(OLD_OBJECT_STORE_NAME)) {
-                                                // Database did not exist. Nothing to do.
-                                                return [2 /*return*/];
-                                            }
-                                            objectStore = upgradeTransaction.objectStore(OLD_OBJECT_STORE_NAME);
-                                            return [4 /*yield*/, objectStore.index('fcmSenderId').get(senderId)];
-                                        case 1:
-                                            value = _b.sent();
-                                            return [4 /*yield*/, objectStore.clear()];
-                                        case 2:
-                                            _b.sent();
-                                            if (!value) {
-                                                // No entry in the database, nothing to migrate.
-                                                return [2 /*return*/];
-                                            }
-                                            if (oldVersion === 2) {
-                                                oldDetails = value;
-                                                if (!oldDetails.auth || !oldDetails.p256dh || !oldDetails.endpoint) {
-                                                    return [2 /*return*/];
-                                                }
-                                                tokenDetails = {
-                                                    token: oldDetails.fcmToken,
-                                                    createTime: (_a = oldDetails.createTime) !== null && _a !== void 0 ? _a : Date.now(),
-                                                    subscriptionOptions: {
-                                                        auth: oldDetails.auth,
-                                                        p256dh: oldDetails.p256dh,
-                                                        endpoint: oldDetails.endpoint,
-                                                        swScope: oldDetails.swScope,
-                                                        vapidKey: typeof oldDetails.vapidKey === 'string'
-                                                            ? oldDetails.vapidKey
-                                                            : arrayToBase64(oldDetails.vapidKey)
-                                                    }
-                                                };
-                                            }
-                                            else if (oldVersion === 3) {
-                                                oldDetails = value;
-                                                tokenDetails = {
-                                                    token: oldDetails.fcmToken,
-                                                    createTime: oldDetails.createTime,
-                                                    subscriptionOptions: {
-                                                        auth: arrayToBase64(oldDetails.auth),
-                                                        p256dh: arrayToBase64(oldDetails.p256dh),
-                                                        endpoint: oldDetails.endpoint,
-                                                        swScope: oldDetails.swScope,
-                                                        vapidKey: arrayToBase64(oldDetails.vapidKey)
-                                                    }
-                                                };
-                                            }
-                                            else if (oldVersion === 4) {
-                                                oldDetails = value;
-                                                tokenDetails = {
-                                                    token: oldDetails.fcmToken,
-                                                    createTime: oldDetails.createTime,
-                                                    subscriptionOptions: {
-                                                        auth: arrayToBase64(oldDetails.auth),
-                                                        p256dh: arrayToBase64(oldDetails.p256dh),
-                                                        endpoint: oldDetails.endpoint,
-                                                        swScope: oldDetails.swScope,
-                                                        vapidKey: arrayToBase64(oldDetails.vapidKey)
-                                                    }
-                                                };
-                                            }
-                                            return [2 /*return*/];
-                                    }
-                                });
-                            }); }
-                        })];
-                case 3:
-                    db = _a.sent();
-                    db.close();
-                    // Delete all old databases.
-                    return [4 /*yield*/, idb.deleteDB(OLD_DB_NAME)];
-                case 4:
-                    // Delete all old databases.
-                    _a.sent();
-                    return [4 /*yield*/, idb.deleteDB('fcm_vapid_details_db')];
-                case 5:
-                    _a.sent();
-                    return [4 /*yield*/, idb.deleteDB('undefined')];
-                case 6:
-                    _a.sent();
-                    return [2 /*return*/, checkTokenDetails(tokenDetails) ? tokenDetails : null];
+                };
             }
-        });
+            else if (oldVersion === 3) {
+                const oldDetails = value;
+                tokenDetails = {
+                    token: oldDetails.fcmToken,
+                    createTime: oldDetails.createTime,
+                    subscriptionOptions: {
+                        auth: arrayToBase64(oldDetails.auth),
+                        p256dh: arrayToBase64(oldDetails.p256dh),
+                        endpoint: oldDetails.endpoint,
+                        swScope: oldDetails.swScope,
+                        vapidKey: arrayToBase64(oldDetails.vapidKey)
+                    }
+                };
+            }
+            else if (oldVersion === 4) {
+                const oldDetails = value;
+                tokenDetails = {
+                    token: oldDetails.fcmToken,
+                    createTime: oldDetails.createTime,
+                    subscriptionOptions: {
+                        auth: arrayToBase64(oldDetails.auth),
+                        p256dh: arrayToBase64(oldDetails.p256dh),
+                        endpoint: oldDetails.endpoint,
+                        swScope: oldDetails.swScope,
+                        vapidKey: arrayToBase64(oldDetails.vapidKey)
+                    }
+                };
+            }
+        }
     });
+    db.close();
+    // Delete all old databases.
+    await idb.deleteDB(OLD_DB_NAME);
+    await idb.deleteDB('fcm_vapid_details_db');
+    await idb.deleteDB('undefined');
+    return checkTokenDetails(tokenDetails) ? tokenDetails : null;
 }
 function checkTokenDetails(tokenDetails) {
     if (!tokenDetails || !tokenDetails.subscriptionOptions) {
         return false;
     }
-    var subscriptionOptions = tokenDetails.subscriptionOptions;
+    const { subscriptionOptions } = tokenDetails;
     return (typeof tokenDetails.createTime === 'number' &&
         tokenDetails.createTime > 0 &&
         typeof tokenDetails.token === 'string' &&
@@ -270,14 +239,14 @@ function checkTokenDetails(tokenDetails) {
  * limitations under the License.
  */
 // Exported for tests.
-var DATABASE_NAME = 'firebase-messaging-database';
-var DATABASE_VERSION = 1;
-var OBJECT_STORE_NAME = 'firebase-messaging-store';
-var dbPromise = null;
+const DATABASE_NAME = 'firebase-messaging-database';
+const DATABASE_VERSION = 1;
+const OBJECT_STORE_NAME = 'firebase-messaging-store';
+let dbPromise = null;
 function getDbPromise() {
     if (!dbPromise) {
         dbPromise = idb.openDB(DATABASE_NAME, DATABASE_VERSION, {
-            upgrade: function (upgradeDb, oldVersion) {
+            upgrade: (upgradeDb, oldVersion) => {
                 // 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 that correspond to those versions to run, not only the last one.
@@ -292,85 +261,43 @@ function getDbPromise() {
     return dbPromise;
 }
 /** Gets record(s) from the objectStore that match the given key. */
-function dbGet(firebaseDependencies) {
-    return tslib.__awaiter(this, void 0, void 0, function () {
-        var key, db, tokenDetails, oldTokenDetails;
-        return tslib.__generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    key = getKey(firebaseDependencies);
-                    return [4 /*yield*/, getDbPromise()];
-                case 1:
-                    db = _a.sent();
-                    return [4 /*yield*/, db
-                            .transaction(OBJECT_STORE_NAME)
-                            .objectStore(OBJECT_STORE_NAME)
-                            .get(key)];
-                case 2:
-                    tokenDetails = (_a.sent());
-                    if (!tokenDetails) return [3 /*break*/, 3];
-                    return [2 /*return*/, tokenDetails];
-                case 3: return [4 /*yield*/, migrateOldDatabase(firebaseDependencies.appConfig.senderId)];
-                case 4:
-                    oldTokenDetails = _a.sent();
-                    if (!oldTokenDetails) return [3 /*break*/, 6];
-                    return [4 /*yield*/, dbSet(firebaseDependencies, oldTokenDetails)];
-                case 5:
-                    _a.sent();
-                    return [2 /*return*/, oldTokenDetails];
-                case 6: return [2 /*return*/];
-            }
-        });
-    });
+async function dbGet(firebaseDependencies) {
+    const key = getKey(firebaseDependencies);
+    const db = await getDbPromise();
+    const tokenDetails = (await db
+        .transaction(OBJECT_STORE_NAME)
+        .objectStore(OBJECT_STORE_NAME)
+        .get(key));
+    if (tokenDetails) {
+        return tokenDetails;
+    }
+    else {
+        // Check if there is a tokenDetails object in the old DB.
+        const oldTokenDetails = await migrateOldDatabase(firebaseDependencies.appConfig.senderId);
+        if (oldTokenDetails) {
+            await dbSet(firebaseDependencies, oldTokenDetails);
+            return oldTokenDetails;
+        }
+    }
 }
 /** Assigns or overwrites the record for the given key with the given value. */
-function dbSet(firebaseDependencies, tokenDetails) {
-    return tslib.__awaiter(this, void 0, void 0, function () {
-        var key, db, tx;
-        return tslib.__generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    key = getKey(firebaseDependencies);
-                    return [4 /*yield*/, getDbPromise()];
-                case 1:
-                    db = _a.sent();
-                    tx = db.transaction(OBJECT_STORE_NAME, 'readwrite');
-                    return [4 /*yield*/, tx.objectStore(OBJECT_STORE_NAME).put(tokenDetails, key)];
-                case 2:
-                    _a.sent();
-                    return [4 /*yield*/, tx.done];
-                case 3:
-                    _a.sent();
-                    return [2 /*return*/, tokenDetails];
-            }
-        });
-    });
+async function dbSet(firebaseDependencies, tokenDetails) {
+    const key = getKey(firebaseDependencies);
+    const db = await getDbPromise();
+    const tx = db.transaction(OBJECT_STORE_NAME, 'readwrite');
+    await tx.objectStore(OBJECT_STORE_NAME).put(tokenDetails, key);
+    await tx.done;
+    return tokenDetails;
 }
 /** Removes record(s) from the objectStore that match the given key. */
-function dbRemove(firebaseDependencies) {
-    return tslib.__awaiter(this, void 0, void 0, function () {
-        var key, db, tx;
-        return tslib.__generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    key = getKey(firebaseDependencies);
-                    return [4 /*yield*/, getDbPromise()];
-                case 1:
-                    db = _a.sent();
-                    tx = db.transaction(OBJECT_STORE_NAME, 'readwrite');
-                    return [4 /*yield*/, tx.objectStore(OBJECT_STORE_NAME).delete(key)];
-                case 2:
-                    _a.sent();
-                    return [4 /*yield*/, tx.done];
-                case 3:
-                    _a.sent();
-                    return [2 /*return*/];
-            }
-        });
-    });
+async function dbRemove(firebaseDependencies) {
+    const key = getKey(firebaseDependencies);
+    const db = await getDbPromise();
+    const tx = db.transaction(OBJECT_STORE_NAME, 'readwrite');
+    await tx.objectStore(OBJECT_STORE_NAME).delete(key);
+    await tx.done;
 }
-function getKey(_a) {
-    var appConfig = _a.appConfig;
+function getKey({ appConfig }) {
     return appConfig.appId;
 }
 
@@ -390,31 +317,30 @@ function getKey(_a) {
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-var _a;
-var ERROR_MAP = (_a = {},
-    _a["missing-app-config-values" /* ErrorCode.MISSING_APP_CONFIG_VALUES */] = 'Missing App configuration value: "{$valueName}"',
-    _a["only-available-in-window" /* ErrorCode.AVAILABLE_IN_WINDOW */] = 'This method is available in a Window context.',
-    _a["only-available-in-sw" /* ErrorCode.AVAILABLE_IN_SW */] = 'This method is available in a service worker context.',
-    _a["permission-default" /* ErrorCode.PERMISSION_DEFAULT */] = 'The notification permission was not granted and dismissed instead.',
-    _a["permission-blocked" /* ErrorCode.PERMISSION_BLOCKED */] = 'The notification permission was not granted and blocked instead.',
-    _a["unsupported-browser" /* ErrorCode.UNSUPPORTED_BROWSER */] = "This browser doesn't support the API's required to use the Firebase SDK.",
-    _a["indexed-db-unsupported" /* ErrorCode.INDEXED_DB_UNSUPPORTED */] = "This browser doesn't support indexedDb.open() (ex. Safari iFrame, Firefox Private Browsing, etc)",
-    _a["failed-service-worker-registration" /* ErrorCode.FAILED_DEFAULT_REGISTRATION */] = 'We are unable to register the default service worker. {$browserErrorMessage}',
-    _a["token-subscribe-failed" /* ErrorCode.TOKEN_SUBSCRIBE_FAILED */] = 'A problem occurred while subscribing the user to FCM: {$errorInfo}',
-    _a["token-subscribe-no-token" /* ErrorCode.TOKEN_SUBSCRIBE_NO_TOKEN */] = 'FCM returned no token when subscribing the user to push.',
-    _a["token-unsubscribe-failed" /* ErrorCode.TOKEN_UNSUBSCRIBE_FAILED */] = 'A problem occurred while unsubscribing the ' +
+const ERROR_MAP = {
+    ["missing-app-config-values" /* ErrorCode.MISSING_APP_CONFIG_VALUES */]: 'Missing App configuration value: "{$valueName}"',
+    ["only-available-in-window" /* ErrorCode.AVAILABLE_IN_WINDOW */]: 'This method is available in a Window context.',
+    ["only-available-in-sw" /* ErrorCode.AVAILABLE_IN_SW */]: 'This method is available in a service worker context.',
+    ["permission-default" /* ErrorCode.PERMISSION_DEFAULT */]: 'The notification permission was not granted and dismissed instead.',
+    ["permission-blocked" /* ErrorCode.PERMISSION_BLOCKED */]: 'The notification permission was not granted and blocked instead.',
+    ["unsupported-browser" /* ErrorCode.UNSUPPORTED_BROWSER */]: "This browser doesn't support the API's required to use the Firebase SDK.",
+    ["indexed-db-unsupported" /* ErrorCode.INDEXED_DB_UNSUPPORTED */]: "This browser doesn't support indexedDb.open() (ex. Safari iFrame, Firefox Private Browsing, etc)",
+    ["failed-service-worker-registration" /* ErrorCode.FAILED_DEFAULT_REGISTRATION */]: 'We are unable to register the default service worker. {$browserErrorMessage}',
+    ["token-subscribe-failed" /* ErrorCode.TOKEN_SUBSCRIBE_FAILED */]: 'A problem occurred while subscribing the user to FCM: {$errorInfo}',
+    ["token-subscribe-no-token" /* ErrorCode.TOKEN_SUBSCRIBE_NO_TOKEN */]: 'FCM returned no token when subscribing the user to push.',
+    ["token-unsubscribe-failed" /* ErrorCode.TOKEN_UNSUBSCRIBE_FAILED */]: 'A problem occurred while unsubscribing the ' +
         'user from FCM: {$errorInfo}',
-    _a["token-update-failed" /* ErrorCode.TOKEN_UPDATE_FAILED */] = 'A problem occurred while updating the user from FCM: {$errorInfo}',
-    _a["token-update-no-token" /* ErrorCode.TOKEN_UPDATE_NO_TOKEN */] = 'FCM returned no token when updating the user to push.',
-    _a["use-sw-after-get-token" /* ErrorCode.USE_SW_AFTER_GET_TOKEN */] = 'The useServiceWorker() method may only be called once and must be ' +
+    ["token-update-failed" /* ErrorCode.TOKEN_UPDATE_FAILED */]: 'A problem occurred while updating the user from FCM: {$errorInfo}',
+    ["token-update-no-token" /* ErrorCode.TOKEN_UPDATE_NO_TOKEN */]: 'FCM returned no token when updating the user to push.',
+    ["use-sw-after-get-token" /* ErrorCode.USE_SW_AFTER_GET_TOKEN */]: 'The useServiceWorker() method may only be called once and must be ' +
         'called before calling getToken() to ensure your service worker is used.',
-    _a["invalid-sw-registration" /* ErrorCode.INVALID_SW_REGISTRATION */] = 'The input to useServiceWorker() must be a ServiceWorkerRegistration.',
-    _a["invalid-bg-handler" /* ErrorCode.INVALID_BG_HANDLER */] = 'The input to setBackgroundMessageHandler() must be a function.',
-    _a["invalid-vapid-key" /* ErrorCode.INVALID_VAPID_KEY */] = 'The public VAPID key must be a string.',
-    _a["use-vapid-key-after-get-token" /* ErrorCode.USE_VAPID_KEY_AFTER_GET_TOKEN */] = 'The usePublicVapidKey() method may only be called once and must be ' +
-        'called before calling getToken() to ensure your VAPID key is used.',
-    _a);
-var ERROR_FACTORY = new util.ErrorFactory('messaging', 'Messaging', ERROR_MAP);
+    ["invalid-sw-registration" /* ErrorCode.INVALID_SW_REGISTRATION */]: 'The input to useServiceWorker() must be a ServiceWorkerRegistration.',
+    ["invalid-bg-handler" /* ErrorCode.INVALID_BG_HANDLER */]: 'The input to setBackgroundMessageHandler() must be a function.',
+    ["invalid-vapid-key" /* ErrorCode.INVALID_VAPID_KEY */]: 'The public VAPID key must be a string.',
+    ["use-vapid-key-after-get-token" /* ErrorCode.USE_VAPID_KEY_AFTER_GET_TOKEN */]: 'The usePublicVapidKey() method may only be called once and must be ' +
+        'called before calling getToken() to ensure your VAPID key is used.'
+};
+const ERROR_FACTORY = new util.ErrorFactory('messaging', 'Messaging', ERROR_MAP);
 
 /**
  * @license
@@ -432,162 +358,104 @@ var ERROR_FACTORY = new util.ErrorFactory('messaging', 'Messaging', ERROR_MAP);
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-function requestGetToken(firebaseDependencies, subscriptionOptions) {
-    return tslib.__awaiter(this, void 0, void 0, function () {
-        var headers, body, subscribeOptions, responseData, response, err_1, message;
-        return tslib.__generator(this, function (_a) {
-            switch (_a.label) {
-                case 0: return [4 /*yield*/, getHeaders(firebaseDependencies)];
-                case 1:
-                    headers = _a.sent();
-                    body = getBody(subscriptionOptions);
-                    subscribeOptions = {
-                        method: 'POST',
-                        headers: headers,
-                        body: JSON.stringify(body)
-                    };
-                    _a.label = 2;
-                case 2:
-                    _a.trys.push([2, 5, , 6]);
-                    return [4 /*yield*/, fetch(getEndpoint(firebaseDependencies.appConfig), subscribeOptions)];
-                case 3:
-                    response = _a.sent();
-                    return [4 /*yield*/, response.json()];
-                case 4:
-                    responseData = _a.sent();
-                    return [3 /*break*/, 6];
-                case 5:
-                    err_1 = _a.sent();
-                    throw ERROR_FACTORY.create("token-subscribe-failed" /* ErrorCode.TOKEN_SUBSCRIBE_FAILED */, {
-                        errorInfo: err_1 === null || err_1 === void 0 ? void 0 : err_1.toString()
-                    });
-                case 6:
-                    if (responseData.error) {
-                        message = responseData.error.message;
-                        throw ERROR_FACTORY.create("token-subscribe-failed" /* ErrorCode.TOKEN_SUBSCRIBE_FAILED */, {
-                            errorInfo: message
-                        });
-                    }
-                    if (!responseData.token) {
-                        throw ERROR_FACTORY.create("token-subscribe-no-token" /* ErrorCode.TOKEN_SUBSCRIBE_NO_TOKEN */);
-                    }
-                    return [2 /*return*/, responseData.token];
-            }
+async function requestGetToken(firebaseDependencies, subscriptionOptions) {
+    const headers = await getHeaders(firebaseDependencies);
+    const body = getBody(subscriptionOptions);
+    const subscribeOptions = {
+        method: 'POST',
+        headers,
+        body: JSON.stringify(body)
+    };
+    let responseData;
+    try {
+        const response = await fetch(getEndpoint(firebaseDependencies.appConfig), subscribeOptions);
+        responseData = await response.json();
+    }
+    catch (err) {
+        throw ERROR_FACTORY.create("token-subscribe-failed" /* ErrorCode.TOKEN_SUBSCRIBE_FAILED */, {
+            errorInfo: err === null || err === void 0 ? void 0 : err.toString()
         });
-    });
+    }
+    if (responseData.error) {
+        const message = responseData.error.message;
+        throw ERROR_FACTORY.create("token-subscribe-failed" /* ErrorCode.TOKEN_SUBSCRIBE_FAILED */, {
+            errorInfo: message
+        });
+    }
+    if (!responseData.token) {
+        throw ERROR_FACTORY.create("token-subscribe-no-token" /* ErrorCode.TOKEN_SUBSCRIBE_NO_TOKEN */);
+    }
+    return responseData.token;
 }
-function requestUpdateToken(firebaseDependencies, tokenDetails) {
-    return tslib.__awaiter(this, void 0, void 0, function () {
-        var headers, body, updateOptions, responseData, response, err_2, message;
-        return tslib.__generator(this, function (_a) {
-            switch (_a.label) {
-                case 0: return [4 /*yield*/, getHeaders(firebaseDependencies)];
-                case 1:
-                    headers = _a.sent();
-                    body = getBody(tokenDetails.subscriptionOptions);
-                    updateOptions = {
-                        method: 'PATCH',
-                        headers: headers,
-                        body: JSON.stringify(body)
-                    };
-                    _a.label = 2;
-                case 2:
-                    _a.trys.push([2, 5, , 6]);
-                    return [4 /*yield*/, fetch("".concat(getEndpoint(firebaseDependencies.appConfig), "/").concat(tokenDetails.token), updateOptions)];
-                case 3:
-                    response = _a.sent();
-                    return [4 /*yield*/, response.json()];
-                case 4:
-                    responseData = _a.sent();
-                    return [3 /*break*/, 6];
-                case 5:
-                    err_2 = _a.sent();
-                    throw ERROR_FACTORY.create("token-update-failed" /* ErrorCode.TOKEN_UPDATE_FAILED */, {
-                        errorInfo: err_2 === null || err_2 === void 0 ? void 0 : err_2.toString()
-                    });
-                case 6:
-                    if (responseData.error) {
-                        message = responseData.error.message;
-                        throw ERROR_FACTORY.create("token-update-failed" /* ErrorCode.TOKEN_UPDATE_FAILED */, {
-                            errorInfo: message
-                        });
-                    }
-                    if (!responseData.token) {
-                        throw ERROR_FACTORY.create("token-update-no-token" /* ErrorCode.TOKEN_UPDATE_NO_TOKEN */);
-                    }
-                    return [2 /*return*/, responseData.token];
-            }
+async function requestUpdateToken(firebaseDependencies, tokenDetails) {
+    const headers = await getHeaders(firebaseDependencies);
+    const body = getBody(tokenDetails.subscriptionOptions);
+    const updateOptions = {
+        method: 'PATCH',
+        headers,
+        body: JSON.stringify(body)
+    };
+    let responseData;
+    try {
+        const response = await fetch(`${getEndpoint(firebaseDependencies.appConfig)}/${tokenDetails.token}`, updateOptions);
+        responseData = await response.json();
+    }
+    catch (err) {
+        throw ERROR_FACTORY.create("token-update-failed" /* ErrorCode.TOKEN_UPDATE_FAILED */, {
+            errorInfo: err === null || err === void 0 ? void 0 : err.toString()
         });
-    });
+    }
+    if (responseData.error) {
+        const message = responseData.error.message;
+        throw ERROR_FACTORY.create("token-update-failed" /* ErrorCode.TOKEN_UPDATE_FAILED */, {
+            errorInfo: message
+        });
+    }
+    if (!responseData.token) {
+        throw ERROR_FACTORY.create("token-update-no-token" /* ErrorCode.TOKEN_UPDATE_NO_TOKEN */);
+    }
+    return responseData.token;
 }
-function requestDeleteToken(firebaseDependencies, token) {
-    return tslib.__awaiter(this, void 0, void 0, function () {
-        var headers, unsubscribeOptions, response, responseData, message, err_3;
-        return tslib.__generator(this, function (_a) {
-            switch (_a.label) {
-                case 0: return [4 /*yield*/, getHeaders(firebaseDependencies)];
-                case 1:
-                    headers = _a.sent();
-                    unsubscribeOptions = {
-                        method: 'DELETE',
-                        headers: headers
-                    };
-                    _a.label = 2;
-                case 2:
-                    _a.trys.push([2, 5, , 6]);
-                    return [4 /*yield*/, fetch("".concat(getEndpoint(firebaseDependencies.appConfig), "/").concat(token), unsubscribeOptions)];
-                case 3:
-                    response = _a.sent();
-                    return [4 /*yield*/, response.json()];
-                case 4:
-                    responseData = _a.sent();
-                    if (responseData.error) {
-                        message = responseData.error.message;
-                        throw ERROR_FACTORY.create("token-unsubscribe-failed" /* ErrorCode.TOKEN_UNSUBSCRIBE_FAILED */, {
-                            errorInfo: message
-                        });
-                    }
-                    return [3 /*break*/, 6];
-                case 5:
-                    err_3 = _a.sent();
-                    throw ERROR_FACTORY.create("token-unsubscribe-failed" /* ErrorCode.TOKEN_UNSUBSCRIBE_FAILED */, {
-                        errorInfo: err_3 === null || err_3 === void 0 ? void 0 : err_3.toString()
-                    });
-                case 6: return [2 /*return*/];
-            }
+async function requestDeleteToken(firebaseDependencies, token) {
+    const headers = await getHeaders(firebaseDependencies);
+    const unsubscribeOptions = {
+        method: 'DELETE',
+        headers
+    };
+    try {
+        const response = await fetch(`${getEndpoint(firebaseDependencies.appConfig)}/${token}`, unsubscribeOptions);
+        const responseData = await response.json();
+        if (responseData.error) {
+            const message = responseData.error.message;
+            throw ERROR_FACTORY.create("token-unsubscribe-failed" /* ErrorCode.TOKEN_UNSUBSCRIBE_FAILED */, {
+                errorInfo: message
+            });
+        }
+    }
+    catch (err) {
+        throw ERROR_FACTORY.create("token-unsubscribe-failed" /* ErrorCode.TOKEN_UNSUBSCRIBE_FAILED */, {
+            errorInfo: err === null || err === void 0 ? void 0 : err.toString()
         });
-    });
+    }
 }
-function getEndpoint(_a) {
-    var projectId = _a.projectId;
-    return "".concat(ENDPOINT, "/projects/").concat(projectId, "/registrations");
+function getEndpoint({ projectId }) {
+    return `${ENDPOINT}/projects/${projectId}/registrations`;
 }
-function getHeaders(_a) {
-    var appConfig = _a.appConfig, installations = _a.installations;
-    return tslib.__awaiter(this, void 0, void 0, function () {
-        var authToken;
-        return tslib.__generator(this, function (_b) {
-            switch (_b.label) {
-                case 0: return [4 /*yield*/, installations.getToken()];
-                case 1:
-                    authToken = _b.sent();
-                    return [2 /*return*/, new Headers({
-                            'Content-Type': 'application/json',
-                            Accept: 'application/json',
-                            'x-goog-api-key': appConfig.apiKey,
-                            'x-goog-firebase-installations-auth': "FIS ".concat(authToken)
-                        })];
-            }
-        });
+async function getHeaders({ appConfig, installations }) {
+    const authToken = await installations.getToken();
+    return new Headers({
+        'Content-Type': 'application/json',
+        Accept: 'application/json',
+        'x-goog-api-key': appConfig.apiKey,
+        'x-goog-firebase-installations-auth': `FIS ${authToken}`
     });
 }
-function getBody(_a) {
-    var p256dh = _a.p256dh, auth = _a.auth, endpoint = _a.endpoint, vapidKey = _a.vapidKey;
-    var body = {
+function getBody({ p256dh, auth, endpoint, vapidKey }) {
+    const body = {
         web: {
-            endpoint: endpoint,
-            auth: auth,
-            p256dh: p256dh
+            endpoint,
+            auth,
+            p256dh
         }
     };
     if (vapidKey !== DEFAULT_VAPID_KEY) {
@@ -613,169 +481,107 @@ function getBody(_a) {
  * limitations under the License.
  */
 // UpdateRegistration will be called once every week.
-var TOKEN_EXPIRATION_MS = 7 * 24 * 60 * 60 * 1000; // 7 days
-function getTokenInternal(messaging) {
-    return tslib.__awaiter(this, void 0, void 0, function () {
-        var pushSubscription, subscriptionOptions, tokenDetails, e_1;
-        return tslib.__generator(this, function (_a) {
-            switch (_a.label) {
-                case 0: return [4 /*yield*/, getPushSubscription(messaging.swRegistration, messaging.vapidKey)];
-                case 1:
-                    pushSubscription = _a.sent();
-                    subscriptionOptions = {
-                        vapidKey: messaging.vapidKey,
-                        swScope: messaging.swRegistration.scope,
-                        endpoint: pushSubscription.endpoint,
-                        auth: arrayToBase64(pushSubscription.getKey('auth')),
-                        p256dh: arrayToBase64(pushSubscription.getKey('p256dh'))
-                    };
-                    return [4 /*yield*/, dbGet(messaging.firebaseDependencies)];
-                case 2:
-                    tokenDetails = _a.sent();
-                    if (!!tokenDetails) return [3 /*break*/, 3];
-                    // No token, get a new one.
-                    return [2 /*return*/, getNewToken(messaging.firebaseDependencies, subscriptionOptions)];
-                case 3:
-                    if (!!isTokenValid(tokenDetails.subscriptionOptions, subscriptionOptions)) return [3 /*break*/, 8];
-                    _a.label = 4;
-                case 4:
-                    _a.trys.push([4, 6, , 7]);
-                    return [4 /*yield*/, requestDeleteToken(messaging.firebaseDependencies, tokenDetails.token)];
-                case 5:
-                    _a.sent();
-                    return [3 /*break*/, 7];
-                case 6:
-                    e_1 = _a.sent();
-                    // Suppress errors because of #2364
-                    console.warn(e_1);
-                    return [3 /*break*/, 7];
-                case 7: return [2 /*return*/, getNewToken(messaging.firebaseDependencies, subscriptionOptions)];
-                case 8:
-                    if (Date.now() >= tokenDetails.createTime + TOKEN_EXPIRATION_MS) {
-                        // Weekly token refresh
-                        return [2 /*return*/, updateToken(messaging, {
-                                token: tokenDetails.token,
-                                createTime: Date.now(),
-                                subscriptionOptions: subscriptionOptions
-                            })];
-                    }
-                    else {
-                        // Valid token, nothing to do.
-                        return [2 /*return*/, tokenDetails.token];
-                    }
-                case 9: return [2 /*return*/];
-            }
+const TOKEN_EXPIRATION_MS = 7 * 24 * 60 * 60 * 1000; // 7 days
+async function getTokenInternal(messaging) {
+    const pushSubscription = await getPushSubscription(messaging.swRegistration, messaging.vapidKey);
+    const subscriptionOptions = {
+        vapidKey: messaging.vapidKey,
+        swScope: messaging.swRegistration.scope,
+        endpoint: pushSubscription.endpoint,
+        auth: arrayToBase64(pushSubscription.getKey('auth')),
+        p256dh: arrayToBase64(pushSubscription.getKey('p256dh'))
+    };
+    const tokenDetails = await dbGet(messaging.firebaseDependencies);
+    if (!tokenDetails) {
+        // No token, get a new one.
+        return getNewToken(messaging.firebaseDependencies, subscriptionOptions);
+    }
+    else if (!isTokenValid(tokenDetails.subscriptionOptions, subscriptionOptions)) {
+        // Invalid token, get a new one.
+        try {
+            await requestDeleteToken(messaging.firebaseDependencies, tokenDetails.token);
+        }
+        catch (e) {
+            // Suppress errors because of #2364
+            console.warn(e);
+        }
+        return getNewToken(messaging.firebaseDependencies, subscriptionOptions);
+    }
+    else if (Date.now() >= tokenDetails.createTime + TOKEN_EXPIRATION_MS) {
+        // Weekly token refresh
+        return updateToken(messaging, {
+            token: tokenDetails.token,
+            createTime: Date.now(),
+            subscriptionOptions
         });
-    });
+    }
+    else {
+        // Valid token, nothing to do.
+        return tokenDetails.token;
+    }
 }
 /**
  * This method deletes the token from the database, unsubscribes the token from FCM, and unregisters
  * the push subscription if it exists.
  */
-function deleteTokenInternal(messaging) {
-    return tslib.__awaiter(this, void 0, void 0, function () {
-        var tokenDetails, pushSubscription;
-        return tslib.__generator(this, function (_a) {
-            switch (_a.label) {
-                case 0: return [4 /*yield*/, dbGet(messaging.firebaseDependencies)];
-                case 1:
-                    tokenDetails = _a.sent();
-                    if (!tokenDetails) return [3 /*break*/, 4];
-                    return [4 /*yield*/, requestDeleteToken(messaging.firebaseDependencies, tokenDetails.token)];
-                case 2:
-                    _a.sent();
-                    return [4 /*yield*/, dbRemove(messaging.firebaseDependencies)];
-                case 3:
-                    _a.sent();
-                    _a.label = 4;
-                case 4: return [4 /*yield*/, messaging.swRegistration.pushManager.getSubscription()];
-                case 5:
-                    pushSubscription = _a.sent();
-                    if (pushSubscription) {
-                        return [2 /*return*/, pushSubscription.unsubscribe()];
-                    }
-                    // If there's no SW, consider it a success.
-                    return [2 /*return*/, true];
-            }
-        });
-    });
+async function deleteTokenInternal(messaging) {
+    const tokenDetails = await dbGet(messaging.firebaseDependencies);
+    if (tokenDetails) {
+        await requestDeleteToken(messaging.firebaseDependencies, tokenDetails.token);
+        await dbRemove(messaging.firebaseDependencies);
+    }
+    // Unsubscribe from the push subscription.
+    const pushSubscription = await messaging.swRegistration.pushManager.getSubscription();
+    if (pushSubscription) {
+        return pushSubscription.unsubscribe();
+    }
+    // If there's no SW, consider it a success.
+    return true;
 }
-function updateToken(messaging, tokenDetails) {
-    return tslib.__awaiter(this, void 0, void 0, function () {
-        var updatedToken, updatedTokenDetails, e_2;
-        return tslib.__generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    _a.trys.push([0, 3, , 4]);
-                    return [4 /*yield*/, requestUpdateToken(messaging.firebaseDependencies, tokenDetails)];
-                case 1:
-                    updatedToken = _a.sent();
-                    updatedTokenDetails = tslib.__assign(tslib.__assign({}, tokenDetails), { token: updatedToken, createTime: Date.now() });
-                    return [4 /*yield*/, dbSet(messaging.firebaseDependencies, updatedTokenDetails)];
-                case 2:
-                    _a.sent();
-                    return [2 /*return*/, updatedToken];
-                case 3:
-                    e_2 = _a.sent();
-                    throw e_2;
-                case 4: return [2 /*return*/];
-            }
-        });
-    });
+async function updateToken(messaging, tokenDetails) {
+    try {
+        const updatedToken = await requestUpdateToken(messaging.firebaseDependencies, tokenDetails);
+        const updatedTokenDetails = Object.assign(Object.assign({}, tokenDetails), { token: updatedToken, createTime: Date.now() });
+        await dbSet(messaging.firebaseDependencies, updatedTokenDetails);
+        return updatedToken;
+    }
+    catch (e) {
+        throw e;
+    }
 }
-function getNewToken(firebaseDependencies, subscriptionOptions) {
-    return tslib.__awaiter(this, void 0, void 0, function () {
-        var token, tokenDetails;
-        return tslib.__generator(this, function (_a) {
-            switch (_a.label) {
-                case 0: return [4 /*yield*/, requestGetToken(firebaseDependencies, subscriptionOptions)];
-                case 1:
-                    token = _a.sent();
-                    tokenDetails = {
-                        token: token,
-                        createTime: Date.now(),
-                        subscriptionOptions: subscriptionOptions
-                    };
-                    return [4 /*yield*/, dbSet(firebaseDependencies, tokenDetails)];
-                case 2:
-                    _a.sent();
-                    return [2 /*return*/, tokenDetails.token];
-            }
-        });
-    });
+async function getNewToken(firebaseDependencies, subscriptionOptions) {
+    const token = await requestGetToken(firebaseDependencies, subscriptionOptions);
+    const tokenDetails = {
+        token,
+        createTime: Date.now(),
+        subscriptionOptions
+    };
+    await dbSet(firebaseDependencies, tokenDetails);
+    return tokenDetails.token;
 }
 /**
  * Gets a PushSubscription for the current user.
  */
-function getPushSubscription(swRegistration, vapidKey) {
-    return tslib.__awaiter(this, void 0, void 0, function () {
-        var subscription;
-        return tslib.__generator(this, function (_a) {
-            switch (_a.label) {
-                case 0: return [4 /*yield*/, swRegistration.pushManager.getSubscription()];
-                case 1:
-                    subscription = _a.sent();
-                    if (subscription) {
-                        return [2 /*return*/, subscription];
-                    }
-                    return [2 /*return*/, swRegistration.pushManager.subscribe({
-                            userVisibleOnly: true,
-                            // Chrome <= 75 doesn't support base64-encoded VAPID key. For backward compatibility, VAPID key
-                            // submitted to pushManager#subscribe must be of type Uint8Array.
-                            applicationServerKey: base64ToArray(vapidKey)
-                        })];
-            }
-        });
+async function getPushSubscription(swRegistration, vapidKey) {
+    const subscription = await swRegistration.pushManager.getSubscription();
+    if (subscription) {
+        return subscription;
+    }
+    return swRegistration.pushManager.subscribe({
+        userVisibleOnly: true,
+        // Chrome <= 75 doesn't support base64-encoded VAPID key. For backward compatibility, VAPID key
+        // submitted to pushManager#subscribe must be of type Uint8Array.
+        applicationServerKey: base64ToArray(vapidKey)
     });
 }
 /**
  * Checks if the saved tokenDetails object matches the configuration provided.
  */
 function isTokenValid(dbOptions, currentOptions) {
-    var isVapidKeyEqual = currentOptions.vapidKey === dbOptions.vapidKey;
-    var isEndpointEqual = currentOptions.endpoint === dbOptions.endpoint;
-    var isAuthEqual = currentOptions.auth === dbOptions.auth;
-    var isP256dhEqual = currentOptions.p256dh === dbOptions.p256dh;
+    const isVapidKeyEqual = currentOptions.vapidKey === dbOptions.vapidKey;
+    const isEndpointEqual = currentOptions.endpoint === dbOptions.endpoint;
+    const isAuthEqual = currentOptions.auth === dbOptions.auth;
+    const isP256dhEqual = currentOptions.p256dh === dbOptions.p256dh;
     return isVapidKeyEqual && isEndpointEqual && isAuthEqual && isP256dhEqual;
 }
 
@@ -796,7 +602,7 @@ function isTokenValid(dbOptions, currentOptions) {
  * limitations under the License.
  */
 function externalizePayload(internalPayload) {
-    var payload = {
+    const payload = {
         from: internalPayload.from,
         // eslint-disable-next-line camelcase
         collapseKey: internalPayload.collapse_key,
@@ -813,19 +619,19 @@ function propagateNotificationPayload(payload, messagePayloadInternal) {
         return;
     }
     payload.notification = {};
-    var title = messagePayloadInternal.notification.title;
+    const title = messagePayloadInternal.notification.title;
     if (!!title) {
         payload.notification.title = title;
     }
-    var body = messagePayloadInternal.notification.body;
+    const body = messagePayloadInternal.notification.body;
     if (!!body) {
         payload.notification.body = body;
     }
-    var image = messagePayloadInternal.notification.image;
+    const image = messagePayloadInternal.notification.image;
     if (!!image) {
         payload.notification.image = image;
     }
-    var icon = messagePayloadInternal.notification.icon;
+    const icon = messagePayloadInternal.notification.icon;
     if (!!icon) {
         payload.notification.icon = icon;
     }
@@ -844,12 +650,12 @@ function propagateFcmOptions(payload, messagePayloadInternal) {
         return;
     }
     payload.fcmOptions = {};
-    var link = (_c = (_b = messagePayloadInternal.fcmOptions) === null || _b === void 0 ? void 0 : _b.link) !== null && _c !== void 0 ? _c : (_d = messagePayloadInternal.notification) === null || _d === void 0 ? void 0 : _d.click_action;
+    const link = (_c = (_b = messagePayloadInternal.fcmOptions) === null || _b === void 0 ? void 0 : _b.link) !== null && _c !== void 0 ? _c : (_d = messagePayloadInternal.notification) === null || _d === void 0 ? void 0 : _d.click_action;
     if (!!link) {
         payload.fcmOptions.link = link;
     }
     // eslint-disable-next-line camelcase
-    var analyticsLabel = (_e = messagePayloadInternal.fcmOptions) === null || _e === void 0 ? void 0 : _e.analytics_label;
+    const analyticsLabel = (_e = messagePayloadInternal.fcmOptions) === null || _e === void 0 ? void 0 : _e.analytics_label;
     if (!!analyticsLabel) {
         payload.fcmOptions.analyticsLabel = analyticsLabel;
     }
@@ -894,7 +700,7 @@ function isConsoleMessage(data) {
  */
 /** Returns a promise that resolves after given time passes. */
 function sleep(ms) {
-    return new Promise(function (resolve) {
+    return new Promise(resolve => {
         setTimeout(resolve, ms);
     });
 }
@@ -916,26 +722,13 @@ function sleep(ms) {
  * limitations under the License.
  */
 _mergeStrings('AzSCbw63g1R0nCw85jG8', 'Iaya3yLKwmgvh7cF0q4');
-function stageLog(messaging, internalPayload) {
-    return tslib.__awaiter(this, void 0, void 0, function () {
-        var fcmEvent, _a, _b;
-        return tslib.__generator(this, function (_c) {
-            switch (_c.label) {
-                case 0:
-                    _a = createFcmEvent;
-                    _b = [internalPayload];
-                    return [4 /*yield*/, messaging.firebaseDependencies.installations.getId()];
-                case 1:
-                    fcmEvent = _a.apply(void 0, _b.concat([_c.sent()]));
-                    createAndEnqueueLogEvent(messaging, fcmEvent, internalPayload.productId);
-                    return [2 /*return*/];
-            }
-        });
-    });
+async function stageLog(messaging, internalPayload) {
+    const fcmEvent = createFcmEvent(internalPayload, await messaging.firebaseDependencies.installations.getId());
+    createAndEnqueueLogEvent(messaging, fcmEvent, internalPayload.productId);
 }
 function createFcmEvent(internalPayload, fid) {
     var _a, _b;
-    var fcmEvent = {};
+    const fcmEvent = {};
     /* eslint-disable camelcase */
     // some fields should always be non-null. Still check to ensure.
     if (!!internalPayload.from) {
@@ -964,7 +757,7 @@ function createFcmEvent(internalPayload, fid) {
     return fcmEvent;
 }
 function createAndEnqueueLogEvent(messaging, fcmEvent, productId) {
-    var logEvent = {};
+    const logEvent = {};
     /* eslint-disable camelcase */
     logEvent.event_time_ms = Math.floor(Date.now()).toString();
     logEvent.source_extension_json_proto3 = JSON.stringify({
@@ -977,7 +770,7 @@ function createAndEnqueueLogEvent(messaging, fcmEvent, productId) {
     messaging.logEvents.push(logEvent);
 }
 function buildComplianceData(productId) {
-    var complianceData = {
+    const complianceData = {
         privacy_context: {
             prequest: {
                 origin_associated_product_id: productId
@@ -987,8 +780,8 @@ function buildComplianceData(productId) {
     return complianceData;
 }
 function _mergeStrings(s1, s2) {
-    var resultArray = [];
-    for (var i = 0; i < s1.length; i++) {
+    const resultArray = [];
+    for (let i = 0; i < s1.length; i++) {
         resultArray.push(s1.charAt(i));
         if (i < s2.length) {
             resultArray.push(s2.charAt(i));
@@ -1013,155 +806,106 @@ function _mergeStrings(s1, s2) {
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-function onSubChange(event, messaging) {
+async function onSubChange(event, messaging) {
     var _a, _b;
-    return tslib.__awaiter(this, void 0, void 0, function () {
-        var newSubscription, tokenDetails;
-        return tslib.__generator(this, function (_c) {
-            switch (_c.label) {
-                case 0:
-                    newSubscription = event.newSubscription;
-                    if (!!newSubscription) return [3 /*break*/, 2];
-                    // Subscription revoked, delete token
-                    return [4 /*yield*/, deleteTokenInternal(messaging)];
-                case 1:
-                    // Subscription revoked, delete token
-                    _c.sent();
-                    return [2 /*return*/];
-                case 2: return [4 /*yield*/, dbGet(messaging.firebaseDependencies)];
-                case 3:
-                    tokenDetails = _c.sent();
-                    return [4 /*yield*/, deleteTokenInternal(messaging)];
-                case 4:
-                    _c.sent();
-                    messaging.vapidKey =
-                        (_b = (_a = tokenDetails === null || tokenDetails === void 0 ? void 0 : tokenDetails.subscriptionOptions) === null || _a === void 0 ? void 0 : _a.vapidKey) !== null && _b !== void 0 ? _b : DEFAULT_VAPID_KEY;
-                    return [4 /*yield*/, getTokenInternal(messaging)];
-                case 5:
-                    _c.sent();
-                    return [2 /*return*/];
-            }
-        });
-    });
+    const { newSubscription } = event;
+    if (!newSubscription) {
+        // Subscription revoked, delete token
+        await deleteTokenInternal(messaging);
+        return;
+    }
+    const tokenDetails = await dbGet(messaging.firebaseDependencies);
+    await deleteTokenInternal(messaging);
+    messaging.vapidKey =
+        (_b = (_a = tokenDetails === null || tokenDetails === void 0 ? void 0 : tokenDetails.subscriptionOptions) === null || _a === void 0 ? void 0 : _a.vapidKey) !== null && _b !== void 0 ? _b : DEFAULT_VAPID_KEY;
+    await getTokenInternal(messaging);
 }
-function onPush(event, messaging) {
-    return tslib.__awaiter(this, void 0, void 0, function () {
-        var internalPayload, clientList, payload;
-        return tslib.__generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    internalPayload = getMessagePayloadInternal(event);
-                    if (!internalPayload) {
-                        // Failed to get parsed MessagePayload from the PushEvent. Skip handling the push.
-                        return [2 /*return*/];
-                    }
-                    if (!messaging.deliveryMetricsExportedToBigQueryEnabled) return [3 /*break*/, 2];
-                    return [4 /*yield*/, stageLog(messaging, internalPayload)];
-                case 1:
-                    _a.sent();
-                    _a.label = 2;
-                case 2: return [4 /*yield*/, getClientList()];
-                case 3:
-                    clientList = _a.sent();
-                    if (hasVisibleClients(clientList)) {
-                        return [2 /*return*/, sendMessagePayloadInternalToWindows(clientList, internalPayload)];
-                    }
-                    if (!!!internalPayload.notification) return [3 /*break*/, 5];
-                    return [4 /*yield*/, showNotification(wrapInternalPayload(internalPayload))];
-                case 4:
-                    _a.sent();
-                    _a.label = 5;
-                case 5:
-                    if (!messaging) {
-                        return [2 /*return*/];
-                    }
-                    if (!!!messaging.onBackgroundMessageHandler) return [3 /*break*/, 8];
-                    payload = externalizePayload(internalPayload);
-                    if (!(typeof messaging.onBackgroundMessageHandler === 'function')) return [3 /*break*/, 7];
-                    return [4 /*yield*/, messaging.onBackgroundMessageHandler(payload)];
-                case 6:
-                    _a.sent();
-                    return [3 /*break*/, 8];
-                case 7:
-                    messaging.onBackgroundMessageHandler.next(payload);
-                    _a.label = 8;
-                case 8: return [2 /*return*/];
-            }
-        });
-    });
+async function onPush(event, messaging) {
+    const internalPayload = getMessagePayloadInternal(event);
+    if (!internalPayload) {
+        // Failed to get parsed MessagePayload from the PushEvent. Skip handling the push.
+        return;
+    }
+    // log to Firelog with user consent
+    if (messaging.deliveryMetricsExportedToBigQueryEnabled) {
+        await stageLog(messaging, internalPayload);
+    }
+    // foreground handling: eventually passed to onMessage hook
+    const clientList = await getClientList();
+    if (hasVisibleClients(clientList)) {
+        return sendMessagePayloadInternalToWindows(clientList, internalPayload);
+    }
+    // background handling: display if possible and pass to onBackgroundMessage hook
+    if (!!internalPayload.notification) {
+        await showNotification(wrapInternalPayload(internalPayload));
+    }
+    if (!messaging) {
+        return;
+    }
+    if (!!messaging.onBackgroundMessageHandler) {
+        const payload = externalizePayload(internalPayload);
+        if (typeof messaging.onBackgroundMessageHandler === 'function') {
+            await messaging.onBackgroundMessageHandler(payload);
+        }
+        else {
+            messaging.onBackgroundMessageHandler.next(payload);
+        }
+    }
 }
-function onNotificationClick(event) {
+async function onNotificationClick(event) {
     var _a, _b;
-    return tslib.__awaiter(this, void 0, void 0, function () {
-        var internalPayload, link, url, originUrl, client;
-        return tslib.__generator(this, function (_c) {
-            switch (_c.label) {
-                case 0:
-                    internalPayload = (_b = (_a = event.notification) === null || _a === void 0 ? void 0 : _a.data) === null || _b === void 0 ? void 0 : _b[FCM_MSG];
-                    if (!internalPayload) {
-                        return [2 /*return*/];
-                    }
-                    else if (event.action) {
-                        // User clicked on an action button. This will allow developers to act on action button clicks
-                        // by using a custom onNotificationClick listener that they define.
-                        return [2 /*return*/];
-                    }
-                    // Prevent other listeners from receiving the event
-                    event.stopImmediatePropagation();
-                    event.notification.close();
-                    link = getLink(internalPayload);
-                    if (!link) {
-                        return [2 /*return*/];
-                    }
-                    url = new URL(link, self.location.href);
-                    originUrl = new URL(self.location.origin);
-                    if (url.host !== originUrl.host) {
-                        return [2 /*return*/];
-                    }
-                    return [4 /*yield*/, getWindowClient(url)];
-                case 1:
-                    client = _c.sent();
-                    if (!!client) return [3 /*break*/, 4];
-                    return [4 /*yield*/, self.clients.openWindow(link)];
-                case 2:
-                    client = _c.sent();
-                    // Wait three seconds for the client to initialize and set up the message handler so that it
-                    // can receive the message.
-                    return [4 /*yield*/, sleep(3000)];
-                case 3:
-                    // Wait three seconds for the client to initialize and set up the message handler so that it
-                    // can receive the message.
-                    _c.sent();
-                    return [3 /*break*/, 6];
-                case 4: return [4 /*yield*/, client.focus()];
-                case 5:
-                    client = _c.sent();
-                    _c.label = 6;
-                case 6:
-                    if (!client) {
-                        // Window Client will not be returned if it's for a third party origin.
-                        return [2 /*return*/];
-                    }
-                    internalPayload.messageType = MessageType.NOTIFICATION_CLICKED;
-                    internalPayload.isFirebaseMessaging = true;
-                    return [2 /*return*/, client.postMessage(internalPayload)];
-            }
-        });
-    });
+    const internalPayload = (_b = (_a = event.notification) === null || _a === void 0 ? void 0 : _a.data) === null || _b === void 0 ? void 0 : _b[FCM_MSG];
+    if (!internalPayload) {
+        return;
+    }
+    else if (event.action) {
+        // User clicked on an action button. This will allow developers to act on action button clicks
+        // by using a custom onNotificationClick listener that they define.
+        return;
+    }
+    // Prevent other listeners from receiving the event
+    event.stopImmediatePropagation();
+    event.notification.close();
+    // Note clicking on a notification with no link set will focus the Chrome's current tab.
+    const link = getLink(internalPayload);
+    if (!link) {
+        return;
+    }
+    // FM should only open/focus links from app's origin.
+    const url = new URL(link, self.location.href);
+    const originUrl = new URL(self.location.origin);
+    if (url.host !== originUrl.host) {
+        return;
+    }
+    let client = await getWindowClient(url);
+    if (!client) {
+        client = await self.clients.openWindow(link);
+        // Wait three seconds for the client to initialize and set up the message handler so that it
+        // can receive the message.
+        await sleep(3000);
+    }
+    else {
+        client = await client.focus();
+    }
+    if (!client) {
+        // Window Client will not be returned if it's for a third party origin.
+        return;
+    }
+    internalPayload.messageType = MessageType.NOTIFICATION_CLICKED;
+    internalPayload.isFirebaseMessaging = true;
+    return client.postMessage(internalPayload);
 }
 function wrapInternalPayload(internalPayload) {
-    var _a;
-    var wrappedInternalPayload = tslib.__assign({}, internalPayload.notification);
+    const wrappedInternalPayload = Object.assign({}, internalPayload.notification);
     // Put the message payload under FCM_MSG name so we can identify the notification as being an FCM
     // notification vs a notification from somewhere else (i.e. normal web push or developer generated
     // notification).
-    wrappedInternalPayload.data = (_a = {},
-        _a[FCM_MSG] = internalPayload,
-        _a);
+    wrappedInternalPayload.data = {
+        [FCM_MSG]: internalPayload
+    };
     return wrappedInternalPayload;
 }
-function getMessagePayloadInternal(_a) {
-    var data = _a.data;
+function getMessagePayloadInternal({ data }) {
     if (!data) {
         return null;
     }
@@ -1177,64 +921,31 @@ function getMessagePayloadInternal(_a) {
  * @param url The URL to look for when focusing a client.
  * @return Returns an existing window client or a newly opened WindowClient.
  */
-function getWindowClient(url) {
-    return tslib.__awaiter(this, void 0, void 0, function () {
-        var clientList, clientList_1, clientList_1_1, client, clientUrl;
-        var e_1, _a;
-        return tslib.__generator(this, function (_b) {
-            switch (_b.label) {
-                case 0: return [4 /*yield*/, getClientList()];
-                case 1:
-                    clientList = _b.sent();
-                    try {
-                        for (clientList_1 = tslib.__values(clientList), clientList_1_1 = clientList_1.next(); !clientList_1_1.done; clientList_1_1 = clientList_1.next()) {
-                            client = clientList_1_1.value;
-                            clientUrl = new URL(client.url, self.location.href);
-                            if (url.host === clientUrl.host) {
-                                return [2 /*return*/, client];
-                            }
-                        }
-                    }
-                    catch (e_1_1) { e_1 = { error: e_1_1 }; }
-                    finally {
-                        try {
-                            if (clientList_1_1 && !clientList_1_1.done && (_a = clientList_1.return)) _a.call(clientList_1);
-                        }
-                        finally { if (e_1) throw e_1.error; }
-                    }
-                    return [2 /*return*/, null];
-            }
-        });
-    });
+async function getWindowClient(url) {
+    const clientList = await getClientList();
+    for (const client of clientList) {
+        const clientUrl = new URL(client.url, self.location.href);
+        if (url.host === clientUrl.host) {
+            return client;
+        }
+    }
+    return null;
 }
 /**
  * @returns If there is currently a visible WindowClient, this method will resolve to true,
  * otherwise false.
  */
 function hasVisibleClients(clientList) {
-    return clientList.some(function (client) {
-        return client.visibilityState === 'visible' &&
-            // Ignore chrome-extension clients as that matches the background pages of extensions, which
-            // are always considered visible for some reason.
-            !client.url.startsWith('chrome-extension://');
-    });
+    return clientList.some(client => client.visibilityState === 'visible' &&
+        // Ignore chrome-extension clients as that matches the background pages of extensions, which
+        // are always considered visible for some reason.
+        !client.url.startsWith('chrome-extension://'));
 }
 function sendMessagePayloadInternalToWindows(clientList, internalPayload) {
-    var e_2, _a;
     internalPayload.isFirebaseMessaging = true;
     internalPayload.messageType = MessageType.PUSH_RECEIVED;
-    try {
-        for (var clientList_2 = tslib.__values(clientList), clientList_2_1 = clientList_2.next(); !clientList_2_1.done; clientList_2_1 = clientList_2.next()) {
-            var client = clientList_2_1.value;
-            client.postMessage(internalPayload);
-        }
-    }
-    catch (e_2_1) { e_2 = { error: e_2_1 }; }
-    finally {
-        try {
-            if (clientList_2_1 && !clientList_2_1.done && (_a = clientList_2.return)) _a.call(clientList_2);
-        }
-        finally { if (e_2) throw e_2.error; }
+    for (const client of clientList) {
+        client.postMessage(internalPayload);
     }
 }
 function getClientList() {
@@ -1248,10 +959,10 @@ function showNotification(notificationPayloadInternal) {
     var _a;
     // Note: Firefox does not support the maxActions property.
     // https://developer.mozilla.org/en-US/docs/Web/API/notification/maxActions
-    var actions = notificationPayloadInternal.actions;
-    var maxActions = Notification.maxActions;
+    const { actions } = notificationPayloadInternal;
+    const { maxActions } = Notification;
     if (actions && maxActions && actions.length > maxActions) {
-        console.warn("This browser only supports ".concat(maxActions, " actions. The remaining actions will not be displayed."));
+        console.warn(`This browser only supports ${maxActions} actions. The remaining actions will not be displayed.`);
     }
     return self.registration.showNotification(
     /* title= */ (_a = notificationPayloadInternal.title) !== null && _a !== void 0 ? _a : '', notificationPayloadInternal);
@@ -1259,7 +970,7 @@ function showNotification(notificationPayloadInternal) {
 function getLink(payload) {
     var _a, _b, _c;
     // eslint-disable-next-line camelcase
-    var link = (_b = (_a = payload.fcmOptions) === null || _a === void 0 ? void 0 : _a.link) !== null && _b !== void 0 ? _b : (_c = payload.notification) === null || _c === void 0 ? void 0 : _c.click_action;
+    const link = (_b = (_a = payload.fcmOptions) === null || _a === void 0 ? void 0 : _a.link) !== null && _b !== void 0 ? _b : (_c = payload.notification) === null || _c === void 0 ? void 0 : _c.click_action;
     if (link) {
         return link;
     }
@@ -1289,7 +1000,6 @@ function getLink(payload) {
  * limitations under the License.
  */
 function extractAppConfig(app) {
-    var e_1, _a;
     if (!app || !app.options) {
         throw getMissingValueError('App Configuration Object');
     }
@@ -1297,28 +1007,18 @@ function extractAppConfig(app) {
         throw getMissingValueError('App Name');
     }
     // Required app config keys
-    var configKeys = [
+    const configKeys = [
         'projectId',
         'apiKey',
         'appId',
         'messagingSenderId'
     ];
-    var options = app.options;
-    try {
-        for (var configKeys_1 = tslib.__values(configKeys), configKeys_1_1 = configKeys_1.next(); !configKeys_1_1.done; configKeys_1_1 = configKeys_1.next()) {
-            var keyName = configKeys_1_1.value;
-            if (!options[keyName]) {
-                throw getMissingValueError(keyName);
-            }
+    const { options } = app;
+    for (const keyName of configKeys) {
+        if (!options[keyName]) {
+            throw getMissingValueError(keyName);
         }
     }
-    catch (e_1_1) { e_1 = { error: e_1_1 }; }
-    finally {
-        try {
-            if (configKeys_1_1 && !configKeys_1_1.done && (_a = configKeys_1.return)) _a.call(configKeys_1);
-        }
-        finally { if (e_1) throw e_1.error; }
-    }
     return {
         appName: app.name,
         projectId: options.projectId,
@@ -1329,7 +1029,7 @@ function extractAppConfig(app) {
 }
 function getMissingValueError(valueName) {
     return ERROR_FACTORY.create("missing-app-config-values" /* ErrorCode.MISSING_APP_CONFIG_VALUES */, {
-        valueName: valueName
+        valueName
     });
 }
 
@@ -1349,27 +1049,26 @@ function getMissingValueError(valueName) {
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-var MessagingService = /** @class */ (function () {
-    function MessagingService(app, installations, analyticsProvider) {
+class MessagingService {
+    constructor(app, installations, analyticsProvider) {
         // logging is only done with end user consent. Default to false.
         this.deliveryMetricsExportedToBigQueryEnabled = false;
         this.onBackgroundMessageHandler = null;
         this.onMessageHandler = null;
         this.logEvents = [];
         this.isLogServiceStarted = false;
-        var appConfig = extractAppConfig(app);
+        const appConfig = extractAppConfig(app);
         this.firebaseDependencies = {
-            app: app,
-            appConfig: appConfig,
-            installations: installations,
-            analyticsProvider: analyticsProvider
+            app,
+            appConfig,
+            installations,
+            analyticsProvider
         };
     }
-    MessagingService.prototype._delete = function () {
+    _delete() {
         return Promise.resolve();
-    };
-    return MessagingService;
-}());
+    }
+}
 
 /**
  * @license
@@ -1387,15 +1086,15 @@ var MessagingService = /** @class */ (function () {
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-var SwMessagingFactory = function (container) {
-    var messaging = new MessagingService(container.getProvider('app').getImmediate(), container.getProvider('installations-internal').getImmediate(), container.getProvider('analytics-internal'));
-    self.addEventListener('push', function (e) {
+const SwMessagingFactory = (container) => {
+    const messaging = new MessagingService(container.getProvider('app').getImmediate(), container.getProvider('installations-internal').getImmediate(), container.getProvider('analytics-internal'));
+    self.addEventListener('push', e => {
         e.waitUntil(onPush(e, messaging));
     });
-    self.addEventListener('pushsubscriptionchange', function (e) {
+    self.addEventListener('pushsubscriptionchange', e => {
         e.waitUntil(onSubChange(e, messaging));
     });
-    self.addEventListener('notificationclick', function (e) {
+    self.addEventListener('notificationclick', e => {
         e.waitUntil(onNotificationClick(e));
     });
     return messaging;
@@ -1431,30 +1130,16 @@ function registerMessagingInSw() {
  *
  * @public
  */
-function isSwSupported() {
-    return tslib.__awaiter(this, void 0, void 0, function () {
-        var _a;
-        return tslib.__generator(this, function (_b) {
-            switch (_b.label) {
-                case 0:
-                    _a = util.isIndexedDBAvailable();
-                    if (!_a) return [3 /*break*/, 2];
-                    return [4 /*yield*/, util.validateIndexedDBOpenable()];
-                case 1:
-                    _a = (_b.sent());
-                    _b.label = 2;
-                case 2: 
-                // firebase-js-sdk/issues/2393 reveals that idb#open in Safari iframe and Firefox private browsing
-                // might be prohibited to run. In these contexts, an error would be thrown during the messaging
-                // instantiating phase, informing the developers to import/call isSupported for special handling.
-                return [2 /*return*/, (_a &&
-                        'PushManager' in self &&
-                        'Notification' in self &&
-                        ServiceWorkerRegistration.prototype.hasOwnProperty('showNotification') &&
-                        PushSubscription.prototype.hasOwnProperty('getKey'))];
-            }
-        });
-    });
+async function isSwSupported() {
+    // firebase-js-sdk/issues/2393 reveals that idb#open in Safari iframe and Firefox private browsing
+    // might be prohibited to run. In these contexts, an error would be thrown during the messaging
+    // instantiating phase, informing the developers to import/call isSupported for special handling.
+    return (util.isIndexedDBAvailable() &&
+        (await util.validateIndexedDBOpenable()) &&
+        'PushManager' in self &&
+        'Notification' in self &&
+        ServiceWorkerRegistration.prototype.hasOwnProperty('showNotification') &&
+        PushSubscription.prototype.hasOwnProperty('getKey'));
 }
 
 /**
@@ -1478,7 +1163,7 @@ function onBackgroundMessage$1(messaging, nextOrObserver) {
         throw ERROR_FACTORY.create("only-available-in-sw" /* ErrorCode.AVAILABLE_IN_SW */);
     }
     messaging.onBackgroundMessageHandler = nextOrObserver;
-    return function () {
+    return () => {
         messaging.onBackgroundMessageHandler = null;
     };
 }
@@ -1527,18 +1212,17 @@ function _setDeliveryMetricsExportedToBigQueryEnabled(messaging, enable) {
  *
  * @public
  */
-function getMessagingInSw(app$1) {
-    if (app$1 === void 0) { app$1 = app.getApp(); }
+function getMessagingInSw(app$1 = app.getApp()) {
     // Conscious decision to make this async check non-blocking during the messaging instance
     // initialization phase for performance consideration. An error would be thrown latter for
     // developer's information. Developers can then choose to import and call `isSupported` for
     // special handling.
-    isSwSupported().then(function (isSupported) {
+    isSwSupported().then(isSupported => {
         // If `isSwSupported()` resolved, but returned false.
         if (!isSupported) {
             throw ERROR_FACTORY.create("unsupported-browser" /* ErrorCode.UNSUPPORTED_BROWSER */);
         }
-    }, function (_) {
+    }, _ => {
         // If `isSwSupported()` rejected.
         throw ERROR_FACTORY.create("indexed-db-unsupported" /* ErrorCode.INDEXED_DB_UNSUPPORTED */);
     });