@firebase/analytics 0.10.8 → 0.10.9-canary.a97ac88db

package/dist/index.cjs.js

@@ -3,7 +3,6 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 var app = require('@firebase/app');
-var tslib = require('tslib');
 var logger$1 = require('@firebase/logger');
 var util = require('@firebase/util');
 var component = require('@firebase/component');
@@ -28,13 +27,13 @@ require('@firebase/installations');
 /**
  * Type constant for Firebase Analytics.
  */
-var ANALYTICS_TYPE = 'analytics';
+const ANALYTICS_TYPE = 'analytics';
 // Key to attach FID to in gtag params.
-var GA_FID_KEY = 'firebase_id';
-var ORIGIN_KEY = 'origin';
-var FETCH_TIMEOUT_MILLIS = 60 * 1000;
-var DYNAMIC_CONFIG_URL = 'https://firebase.googleapis.com/v1alpha/projects/-/apps/{app-id}/webConfig';
-var GTAG_URL = 'https://www.googletagmanager.com/gtag/js';
+const GA_FID_KEY = 'firebase_id';
+const ORIGIN_KEY = 'origin';
+const FETCH_TIMEOUT_MILLIS = 60 * 1000;
+const DYNAMIC_CONFIG_URL = 'https://firebase.googleapis.com/v1alpha/projects/-/apps/{app-id}/webConfig';
+const GTAG_URL = 'https://www.googletagmanager.com/gtag/js';
 
 /**
  * @license
@@ -52,7 +51,7 @@ var GTAG_URL = 'https://www.googletagmanager.com/gtag/js';
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-var logger = new logger$1.Logger('@firebase/analytics');
+const logger = new logger$1.Logger('@firebase/analytics');
 
 /**
  * @license
@@ -70,36 +69,35 @@ var logger = new logger$1.Logger('@firebase/analytics');
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-var _a;
-var ERRORS = (_a = {},
-    _a["already-exists" /* AnalyticsError.ALREADY_EXISTS */] = 'A Firebase Analytics instance with the appId {$id} ' +
+const ERRORS = {
+    ["already-exists" /* AnalyticsError.ALREADY_EXISTS */]: 'A Firebase Analytics instance with the appId {$id} ' +
         ' already exists. ' +
         'Only one Firebase Analytics instance can be created for each appId.',
-    _a["already-initialized" /* AnalyticsError.ALREADY_INITIALIZED */] = 'initializeAnalytics() cannot be called again with different options than those ' +
+    ["already-initialized" /* AnalyticsError.ALREADY_INITIALIZED */]: 'initializeAnalytics() cannot be called again with different options than those ' +
         'it was initially called with. It can be called again with the same options to ' +
         'return the existing instance, or getAnalytics() can be used ' +
         'to get a reference to the already-initialized instance.',
-    _a["already-initialized-settings" /* AnalyticsError.ALREADY_INITIALIZED_SETTINGS */] = 'Firebase Analytics has already been initialized.' +
+    ["already-initialized-settings" /* AnalyticsError.ALREADY_INITIALIZED_SETTINGS */]: 'Firebase Analytics has already been initialized.' +
         'settings() must be called before initializing any Analytics instance' +
         'or it will have no effect.',
-    _a["interop-component-reg-failed" /* AnalyticsError.INTEROP_COMPONENT_REG_FAILED */] = 'Firebase Analytics Interop Component failed to instantiate: {$reason}',
-    _a["invalid-analytics-context" /* AnalyticsError.INVALID_ANALYTICS_CONTEXT */] = 'Firebase Analytics is not supported in this environment. ' +
+    ["interop-component-reg-failed" /* AnalyticsError.INTEROP_COMPONENT_REG_FAILED */]: 'Firebase Analytics Interop Component failed to instantiate: {$reason}',
+    ["invalid-analytics-context" /* AnalyticsError.INVALID_ANALYTICS_CONTEXT */]: 'Firebase Analytics is not supported in this environment. ' +
         'Wrap initialization of analytics in analytics.isSupported() ' +
         'to prevent initialization in unsupported environments. Details: {$errorInfo}',
-    _a["indexeddb-unavailable" /* AnalyticsError.INDEXEDDB_UNAVAILABLE */] = 'IndexedDB unavailable or restricted in this environment. ' +
+    ["indexeddb-unavailable" /* AnalyticsError.INDEXEDDB_UNAVAILABLE */]: 'IndexedDB unavailable or restricted in this environment. ' +
         'Wrap initialization of analytics in analytics.isSupported() ' +
         'to prevent initialization in unsupported environments. Details: {$errorInfo}',
-    _a["fetch-throttle" /* AnalyticsError.FETCH_THROTTLE */] = 'The config fetch request timed out while in an exponential backoff state.' +
+    ["fetch-throttle" /* AnalyticsError.FETCH_THROTTLE */]: 'The config fetch request timed out while in an exponential backoff state.' +
         ' Unix timestamp in milliseconds when fetch request throttling ends: {$throttleEndTimeMillis}.',
-    _a["config-fetch-failed" /* AnalyticsError.CONFIG_FETCH_FAILED */] = 'Dynamic config fetch failed: [{$httpStatus}] {$responseMessage}',
-    _a["no-api-key" /* AnalyticsError.NO_API_KEY */] = 'The "apiKey" field is empty in the local Firebase config. Firebase Analytics requires this field to' +
+    ["config-fetch-failed" /* AnalyticsError.CONFIG_FETCH_FAILED */]: 'Dynamic config fetch failed: [{$httpStatus}] {$responseMessage}',
+    ["no-api-key" /* AnalyticsError.NO_API_KEY */]: 'The "apiKey" field is empty in the local Firebase config. Firebase Analytics requires this field to' +
         'contain a valid API key.',
-    _a["no-app-id" /* AnalyticsError.NO_APP_ID */] = 'The "appId" field is empty in the local Firebase config. Firebase Analytics requires this field to' +
+    ["no-app-id" /* AnalyticsError.NO_APP_ID */]: 'The "appId" field is empty in the local Firebase config. Firebase Analytics requires this field to' +
         'contain a valid app ID.',
-    _a["no-client-id" /* AnalyticsError.NO_CLIENT_ID */] = 'The "client_id" field is empty.',
-    _a["invalid-gtag-resource" /* AnalyticsError.INVALID_GTAG_RESOURCE */] = 'Trusted Types detected an invalid gtag resource: {$gtagURL}.',
-    _a);
-var ERROR_FACTORY = new util.ErrorFactory('analytics', 'Analytics', ERRORS);
+    ["no-client-id" /* AnalyticsError.NO_CLIENT_ID */]: 'The "client_id" field is empty.',
+    ["invalid-gtag-resource" /* AnalyticsError.INVALID_GTAG_RESOURCE */]: 'Trusted Types detected an invalid gtag resource: {$gtagURL}.'
+};
+const ERROR_FACTORY = new util.ErrorFactory('analytics', 'Analytics', ERRORS);
 
 /**
  * @license
@@ -122,7 +120,7 @@ var ERROR_FACTORY = new util.ErrorFactory('analytics', 'Analytics', ERRORS);
  */
 function createGtagTrustedTypesScriptURL(url) {
     if (!url.startsWith(GTAG_URL)) {
-        var err = ERROR_FACTORY.create("invalid-gtag-resource" /* AnalyticsError.INVALID_GTAG_RESOURCE */, {
+        const err = ERROR_FACTORY.create("invalid-gtag-resource" /* AnalyticsError.INVALID_GTAG_RESOURCE */, {
             gtagURL: url
         });
         logger.warn(err.message);
@@ -137,7 +135,7 @@ function createGtagTrustedTypesScriptURL(url) {
  * @param promises Array of promises to wait for.
  */
 function promiseAllSettled(promises) {
-    return Promise.all(promises.map(function (promise) { return promise.catch(function (e) { return e; }); }));
+    return Promise.all(promises.map(promise => promise.catch(e => e)));
 }
 /**
  * Creates a TrustedTypePolicy object that implements the rules passed as policyOptions.
@@ -149,7 +147,7 @@ function promiseAllSettled(promises) {
 function createTrustedTypesPolicy(policyName, policyOptions) {
     // Create a TrustedTypes policy that we can use for updating src
     // properties
-    var trustedTypesPolicy;
+    let trustedTypesPolicy;
     if (window.trustedTypes) {
         trustedTypesPolicy = window.trustedTypes.createPolicy(policyName, policyOptions);
     }
@@ -160,13 +158,13 @@ function createTrustedTypesPolicy(policyName, policyOptions) {
  * @param dataLayerName Name of datalayer (most often the default, "_dataLayer").
  */
 function insertScriptTag(dataLayerName, measurementId) {
-    var trustedTypesPolicy = createTrustedTypesPolicy('firebase-js-sdk-policy', {
+    const trustedTypesPolicy = createTrustedTypesPolicy('firebase-js-sdk-policy', {
         createScriptURL: createGtagTrustedTypesScriptURL
     });
-    var script = document.createElement('script');
+    const script = document.createElement('script');
     // We are not providing an analyticsId in the URL because it would trigger a `page_view`
     // without fid. We will initialize ga-id using gtag (config) command together with fid.
-    var gtagScriptURL = "".concat(GTAG_URL, "?l=").concat(dataLayerName, "&id=").concat(measurementId);
+    const gtagScriptURL = `${GTAG_URL}?l=${dataLayerName}&id=${measurementId}`;
     script.src = trustedTypesPolicy
         ? trustedTypesPolicy === null || trustedTypesPolicy === void 0 ? void 0 : trustedTypesPolicy.createScriptURL(gtagScriptURL)
         : gtagScriptURL;
@@ -179,7 +177,7 @@ function insertScriptTag(dataLayerName, measurementId) {
  */
 function getOrCreateDataLayer(dataLayerName) {
     // Check for existing dataLayer and create if needed.
-    var dataLayer = [];
+    let dataLayer = [];
     if (Array.isArray(window[dataLayerName])) {
         dataLayer = window[dataLayerName];
     }
@@ -198,41 +196,30 @@ function getOrCreateDataLayer(dataLayerName) {
  * @param measurementId GA Measurement ID to set config for.
  * @param gtagParams Gtag config params to set.
  */
-function gtagOnConfig(gtagCore, initializationPromisesMap, dynamicConfigPromisesList, measurementIdToAppId, measurementId, gtagParams) {
-    return tslib.__awaiter(this, void 0, void 0, function () {
-        var correspondingAppId, dynamicConfigResults, foundConfig, e_1;
-        return tslib.__generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    correspondingAppId = measurementIdToAppId[measurementId];
-                    _a.label = 1;
-                case 1:
-                    _a.trys.push([1, 7, , 8]);
-                    if (!correspondingAppId) return [3 /*break*/, 3];
-                    return [4 /*yield*/, initializationPromisesMap[correspondingAppId]];
-                case 2:
-                    _a.sent();
-                    return [3 /*break*/, 6];
-                case 3: return [4 /*yield*/, promiseAllSettled(dynamicConfigPromisesList)];
-                case 4:
-                    dynamicConfigResults = _a.sent();
-                    foundConfig = dynamicConfigResults.find(function (config) { return config.measurementId === measurementId; });
-                    if (!foundConfig) return [3 /*break*/, 6];
-                    return [4 /*yield*/, initializationPromisesMap[foundConfig.appId]];
-                case 5:
-                    _a.sent();
-                    _a.label = 6;
-                case 6: return [3 /*break*/, 8];
-                case 7:
-                    e_1 = _a.sent();
-                    logger.error(e_1);
-                    return [3 /*break*/, 8];
-                case 8:
-                    gtagCore("config" /* GtagCommand.CONFIG */, measurementId, gtagParams);
-                    return [2 /*return*/];
+async function gtagOnConfig(gtagCore, initializationPromisesMap, dynamicConfigPromisesList, measurementIdToAppId, measurementId, gtagParams) {
+    // If config is already fetched, we know the appId and can use it to look up what FID promise we
+    /// are waiting for, and wait only on that one.
+    const correspondingAppId = measurementIdToAppId[measurementId];
+    try {
+        if (correspondingAppId) {
+            await initializationPromisesMap[correspondingAppId];
+        }
+        else {
+            // If config is not fetched yet, wait for all configs (we don't know which one we need) and
+            // find the appId (if any) corresponding to this measurementId. If there is one, wait on
+            // that appId's initialization promise. If there is none, promise resolves and gtag
+            // call goes through.
+            const dynamicConfigResults = await promiseAllSettled(dynamicConfigPromisesList);
+            const foundConfig = dynamicConfigResults.find(config => config.measurementId === measurementId);
+            if (foundConfig) {
+                await initializationPromisesMap[foundConfig.appId];
             }
-        });
-    });
+        }
+    }
+    catch (e) {
+        logger.error(e);
+    }
+    gtagCore("config" /* GtagCommand.CONFIG */, measurementId, gtagParams);
 }
 /**
  * Wrapped gtag logic when gtag is called with 'event' command.
@@ -243,71 +230,52 @@ function gtagOnConfig(gtagCore, initializationPromisesMap, dynamicConfigPromises
  * @param measurementId GA Measurement ID to log event to.
  * @param gtagParams Params to log with this event.
  */
-function gtagOnEvent(gtagCore, initializationPromisesMap, dynamicConfigPromisesList, measurementId, gtagParams) {
-    return tslib.__awaiter(this, void 0, void 0, function () {
-        var initializationPromisesToWaitFor, gaSendToList, dynamicConfigResults, _loop_1, _i, gaSendToList_1, sendToId, state_1, e_2;
-        return tslib.__generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    _a.trys.push([0, 4, , 5]);
+async function gtagOnEvent(gtagCore, initializationPromisesMap, dynamicConfigPromisesList, measurementId, gtagParams) {
+    try {
+        let initializationPromisesToWaitFor = [];
+        // If there's a 'send_to' param, check if any ID specified matches
+        // an initializeIds() promise we are waiting for.
+        if (gtagParams && gtagParams['send_to']) {
+            let gaSendToList = gtagParams['send_to'];
+            // Make it an array if is isn't, so it can be dealt with the same way.
+            if (!Array.isArray(gaSendToList)) {
+                gaSendToList = [gaSendToList];
+            }
+            // Checking 'send_to' fields requires having all measurement ID results back from
+            // the dynamic config fetch.
+            const dynamicConfigResults = await promiseAllSettled(dynamicConfigPromisesList);
+            for (const sendToId of gaSendToList) {
+                // Any fetched dynamic measurement ID that matches this 'send_to' ID
+                const foundConfig = dynamicConfigResults.find(config => config.measurementId === sendToId);
+                const initializationPromise = foundConfig && initializationPromisesMap[foundConfig.appId];
+                if (initializationPromise) {
+                    initializationPromisesToWaitFor.push(initializationPromise);
+                }
+                else {
+                    // Found an item in 'send_to' that is not associated
+                    // directly with an FID, possibly a group.  Empty this array,
+                    // exit the loop early, and let it get populated below.
                     initializationPromisesToWaitFor = [];
-                    if (!(gtagParams && gtagParams['send_to'])) return [3 /*break*/, 2];
-                    gaSendToList = gtagParams['send_to'];
-                    // Make it an array if is isn't, so it can be dealt with the same way.
-                    if (!Array.isArray(gaSendToList)) {
-                        gaSendToList = [gaSendToList];
-                    }
-                    return [4 /*yield*/, promiseAllSettled(dynamicConfigPromisesList)];
-                case 1:
-                    dynamicConfigResults = _a.sent();
-                    _loop_1 = function (sendToId) {
-                        // Any fetched dynamic measurement ID that matches this 'send_to' ID
-                        var foundConfig = dynamicConfigResults.find(function (config) { return config.measurementId === sendToId; });
-                        var initializationPromise = foundConfig && initializationPromisesMap[foundConfig.appId];
-                        if (initializationPromise) {
-                            initializationPromisesToWaitFor.push(initializationPromise);
-                        }
-                        else {
-                            // Found an item in 'send_to' that is not associated
-                            // directly with an FID, possibly a group.  Empty this array,
-                            // exit the loop early, and let it get populated below.
-                            initializationPromisesToWaitFor = [];
-                            return "break";
-                        }
-                    };
-                    for (_i = 0, gaSendToList_1 = gaSendToList; _i < gaSendToList_1.length; _i++) {
-                        sendToId = gaSendToList_1[_i];
-                        state_1 = _loop_1(sendToId);
-                        if (state_1 === "break")
-                            break;
-                    }
-                    _a.label = 2;
-                case 2:
-                    // This will be unpopulated if there was no 'send_to' field , or
-                    // if not all entries in the 'send_to' field could be mapped to
-                    // a FID. In these cases, wait on all pending initialization promises.
-                    if (initializationPromisesToWaitFor.length === 0) {
-                        /* eslint-disable-next-line @typescript-eslint/no-floating-promises */
-                        initializationPromisesToWaitFor = Object.values(initializationPromisesMap);
-                    }
-                    // Run core gtag function with args after all relevant initialization
-                    // promises have been resolved.
-                    return [4 /*yield*/, Promise.all(initializationPromisesToWaitFor)];
-                case 3:
-                    // Run core gtag function with args after all relevant initialization
-                    // promises have been resolved.
-                    _a.sent();
-                    // Workaround for http://b/141370449 - third argument cannot be undefined.
-                    gtagCore("event" /* GtagCommand.EVENT */, measurementId, gtagParams || {});
-                    return [3 /*break*/, 5];
-                case 4:
-                    e_2 = _a.sent();
-                    logger.error(e_2);
-                    return [3 /*break*/, 5];
-                case 5: return [2 /*return*/];
+                    break;
+                }
             }
-        });
-    });
+        }
+        // This will be unpopulated if there was no 'send_to' field , or
+        // if not all entries in the 'send_to' field could be mapped to
+        // a FID. In these cases, wait on all pending initialization promises.
+        if (initializationPromisesToWaitFor.length === 0) {
+            /* eslint-disable-next-line @typescript-eslint/no-floating-promises */
+            initializationPromisesToWaitFor = Object.values(initializationPromisesMap);
+        }
+        // Run core gtag function with args after all relevant initialization
+        // promises have been resolved.
+        await Promise.all(initializationPromisesToWaitFor);
+        // Workaround for http://b/141370449 - third argument cannot be undefined.
+        gtagCore("event" /* GtagCommand.EVENT */, measurementId, gtagParams || {});
+    }
+    catch (e) {
+        logger.error(e);
+    }
 }
 /**
  * Wraps a standard gtag function with extra code to wait for completion of
@@ -341,62 +309,40 @@ measurementIdToAppId) {
      * @param idOrNameOrParams Measurement ID if command is EVENT/CONFIG, params if command is SET.
      * @param gtagParams Params if event is EVENT/CONFIG.
      */
-    function gtagWrapper(command) {
-        var args = [];
-        for (var _i = 1; _i < arguments.length; _i++) {
-            args[_i - 1] = arguments[_i];
+    async function gtagWrapper(command, ...args) {
+        try {
+            // If event, check that relevant initialization promises have completed.
+            if (command === "event" /* GtagCommand.EVENT */) {
+                const [measurementId, gtagParams] = args;
+                // If EVENT, second arg must be measurementId.
+                await gtagOnEvent(gtagCore, initializationPromisesMap, dynamicConfigPromisesList, measurementId, gtagParams);
+            }
+            else if (command === "config" /* GtagCommand.CONFIG */) {
+                const [measurementId, gtagParams] = args;
+                // If CONFIG, second arg must be measurementId.
+                await gtagOnConfig(gtagCore, initializationPromisesMap, dynamicConfigPromisesList, measurementIdToAppId, measurementId, gtagParams);
+            }
+            else if (command === "consent" /* GtagCommand.CONSENT */) {
+                const [consentAction, gtagParams] = args;
+                // consentAction can be one of 'default' or 'update'.
+                gtagCore("consent" /* GtagCommand.CONSENT */, consentAction, gtagParams);
+            }
+            else if (command === "get" /* GtagCommand.GET */) {
+                const [measurementId, fieldName, callback] = args;
+                gtagCore("get" /* GtagCommand.GET */, measurementId, fieldName, callback);
+            }
+            else if (command === "set" /* GtagCommand.SET */) {
+                const [customParams] = args;
+                // If SET, second arg must be params.
+                gtagCore("set" /* GtagCommand.SET */, customParams);
+            }
+            else {
+                gtagCore(command, ...args);
+            }
+        }
+        catch (e) {
+            logger.error(e);
         }
-        return tslib.__awaiter(this, void 0, void 0, function () {
-            var measurementId, gtagParams, measurementId, gtagParams, consentAction, gtagParams, measurementId, fieldName, callback, customParams, e_3;
-            return tslib.__generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        _a.trys.push([0, 6, , 7]);
-                        if (!(command === "event" /* GtagCommand.EVENT */)) return [3 /*break*/, 2];
-                        measurementId = args[0], gtagParams = args[1];
-                        // If EVENT, second arg must be measurementId.
-                        return [4 /*yield*/, gtagOnEvent(gtagCore, initializationPromisesMap, dynamicConfigPromisesList, measurementId, gtagParams)];
-                    case 1:
-                        // If EVENT, second arg must be measurementId.
-                        _a.sent();
-                        return [3 /*break*/, 5];
-                    case 2:
-                        if (!(command === "config" /* GtagCommand.CONFIG */)) return [3 /*break*/, 4];
-                        measurementId = args[0], gtagParams = args[1];
-                        // If CONFIG, second arg must be measurementId.
-                        return [4 /*yield*/, gtagOnConfig(gtagCore, initializationPromisesMap, dynamicConfigPromisesList, measurementIdToAppId, measurementId, gtagParams)];
-                    case 3:
-                        // If CONFIG, second arg must be measurementId.
-                        _a.sent();
-                        return [3 /*break*/, 5];
-                    case 4:
-                        if (command === "consent" /* GtagCommand.CONSENT */) {
-                            consentAction = args[0], gtagParams = args[1];
-                            // consentAction can be one of 'default' or 'update'.
-                            gtagCore("consent" /* GtagCommand.CONSENT */, consentAction, gtagParams);
-                        }
-                        else if (command === "get" /* GtagCommand.GET */) {
-                            measurementId = args[0], fieldName = args[1], callback = args[2];
-                            gtagCore("get" /* GtagCommand.GET */, measurementId, fieldName, callback);
-                        }
-                        else if (command === "set" /* GtagCommand.SET */) {
-                            customParams = args[0];
-                            // If SET, second arg must be params.
-                            gtagCore("set" /* GtagCommand.SET */, customParams);
-                        }
-                        else {
-                            gtagCore.apply(void 0, tslib.__spreadArray([command], args, false));
-                        }
-                        _a.label = 5;
-                    case 5: return [3 /*break*/, 7];
-                    case 6:
-                        e_3 = _a.sent();
-                        logger.error(e_3);
-                        return [3 /*break*/, 7];
-                    case 7: return [2 /*return*/];
-                }
-            });
-        });
     }
     return gtagWrapper;
 }
@@ -413,7 +359,7 @@ measurementIdToAppId) {
  */
 function wrapOrCreateGtag(initializationPromisesMap, dynamicConfigPromisesList, measurementIdToAppId, dataLayerName, gtagFunctionName) {
     // Create a basic core gtag function
-    var gtagCore = function () {
+    let gtagCore = function (..._args) {
         // Must push IArguments object, not an array.
         window[dataLayerName].push(arguments);
     };
@@ -425,7 +371,7 @@ function wrapOrCreateGtag(initializationPromisesMap, dynamicConfigPromisesList,
     }
     window[gtagFunctionName] = wrapGtag(gtagCore, initializationPromisesMap, dynamicConfigPromisesList, measurementIdToAppId);
     return {
-        gtagCore: gtagCore,
+        gtagCore,
         wrappedGtag: window[gtagFunctionName]
     };
 }
@@ -434,9 +380,8 @@ function wrapOrCreateGtag(initializationPromisesMap, dynamicConfigPromisesList,
  * and the provided data layer name.
  */
 function findGtagScriptOnPage(dataLayerName) {
-    var scriptTags = window.document.getElementsByTagName('script');
-    for (var _i = 0, _a = Object.values(scriptTags); _i < _a.length; _i++) {
-        var tag = _a[_i];
+    const scriptTags = window.document.getElementsByTagName('script');
+    for (const tag of Object.values(scriptTags)) {
         if (tag.src &&
             tag.src.includes(GTAG_URL) &&
             tag.src.includes(dataLayerName)) {
@@ -468,33 +413,30 @@ function findGtagScriptOnPage(dataLayerName) {
  * BASE_INTERVAL_MILLIS * LONG_RETRY_FACTOR ^ retryCount, so the second one
  * will be ~30 seconds (with fuzzing).
  */
-var LONG_RETRY_FACTOR = 30;
+const LONG_RETRY_FACTOR = 30;
 /**
  * Base wait interval to multiplied by backoffFactor^backoffCount.
  */
-var BASE_INTERVAL_MILLIS = 1000;
+const BASE_INTERVAL_MILLIS = 1000;
 /**
  * Stubbable retry data storage class.
  */
-var RetryData = /** @class */ (function () {
-    function RetryData(throttleMetadata, intervalMillis) {
-        if (throttleMetadata === void 0) { throttleMetadata = {}; }
-        if (intervalMillis === void 0) { intervalMillis = BASE_INTERVAL_MILLIS; }
+class RetryData {
+    constructor(throttleMetadata = {}, intervalMillis = BASE_INTERVAL_MILLIS) {
         this.throttleMetadata = throttleMetadata;
         this.intervalMillis = intervalMillis;
     }
-    RetryData.prototype.getThrottleMetadata = function (appId) {
+    getThrottleMetadata(appId) {
         return this.throttleMetadata[appId];
-    };
-    RetryData.prototype.setThrottleMetadata = function (appId, metadata) {
+    }
+    setThrottleMetadata(appId, metadata) {
         this.throttleMetadata[appId] = metadata;
-    };
-    RetryData.prototype.deleteThrottleMetadata = function (appId) {
+    }
+    deleteThrottleMetadata(appId) {
         delete this.throttleMetadata[appId];
-    };
-    return RetryData;
-}());
-var defaultRetryData = new RetryData();
+    }
+}
+const defaultRetryData = new RetryData();
 /**
  * Set GET request headers.
  * @param apiKey App API key.
@@ -509,86 +451,62 @@ function getHeaders(apiKey) {
  * Fetches dynamic config from backend.
  * @param app Firebase app to fetch config for.
  */
-function fetchDynamicConfig(appFields) {
+async function fetchDynamicConfig(appFields) {
     var _a;
-    return tslib.__awaiter(this, void 0, void 0, function () {
-        var appId, apiKey, request, appUrl, response, errorMessage, jsonResponse;
-        return tslib.__generator(this, function (_b) {
-            switch (_b.label) {
-                case 0:
-                    appId = appFields.appId, apiKey = appFields.apiKey;
-                    request = {
-                        method: 'GET',
-                        headers: getHeaders(apiKey)
-                    };
-                    appUrl = DYNAMIC_CONFIG_URL.replace('{app-id}', appId);
-                    return [4 /*yield*/, fetch(appUrl, request)];
-                case 1:
-                    response = _b.sent();
-                    if (!(response.status !== 200 && response.status !== 304)) return [3 /*break*/, 6];
-                    errorMessage = '';
-                    _b.label = 2;
-                case 2:
-                    _b.trys.push([2, 4, , 5]);
-                    return [4 /*yield*/, response.json()];
-                case 3:
-                    jsonResponse = (_b.sent());
-                    if ((_a = jsonResponse.error) === null || _a === void 0 ? void 0 : _a.message) {
-                        errorMessage = jsonResponse.error.message;
-                    }
-                    return [3 /*break*/, 5];
-                case 4:
-                    _b.sent();
-                    return [3 /*break*/, 5];
-                case 5: throw ERROR_FACTORY.create("config-fetch-failed" /* AnalyticsError.CONFIG_FETCH_FAILED */, {
-                    httpStatus: response.status,
-                    responseMessage: errorMessage
-                });
-                case 6: return [2 /*return*/, response.json()];
+    const { appId, apiKey } = appFields;
+    const request = {
+        method: 'GET',
+        headers: getHeaders(apiKey)
+    };
+    const appUrl = DYNAMIC_CONFIG_URL.replace('{app-id}', appId);
+    const response = await fetch(appUrl, request);
+    if (response.status !== 200 && response.status !== 304) {
+        let errorMessage = '';
+        try {
+            // Try to get any error message text from server response.
+            const jsonResponse = (await response.json());
+            if ((_a = jsonResponse.error) === null || _a === void 0 ? void 0 : _a.message) {
+                errorMessage = jsonResponse.error.message;
             }
+        }
+        catch (_ignored) { }
+        throw ERROR_FACTORY.create("config-fetch-failed" /* AnalyticsError.CONFIG_FETCH_FAILED */, {
+            httpStatus: response.status,
+            responseMessage: errorMessage
         });
-    });
+    }
+    return response.json();
 }
 /**
  * Fetches dynamic config from backend, retrying if failed.
  * @param app Firebase app to fetch config for.
  */
-function fetchDynamicConfigWithRetry(app, 
+async function fetchDynamicConfigWithRetry(app, 
 // retryData and timeoutMillis are parameterized to allow passing a different value for testing.
-retryData, timeoutMillis) {
-    if (retryData === void 0) { retryData = defaultRetryData; }
-    return tslib.__awaiter(this, void 0, void 0, function () {
-        var _a, appId, apiKey, measurementId, throttleMetadata, signal;
-        var _this = this;
-        return tslib.__generator(this, function (_b) {
-            _a = app.options, appId = _a.appId, apiKey = _a.apiKey, measurementId = _a.measurementId;
-            if (!appId) {
-                throw ERROR_FACTORY.create("no-app-id" /* AnalyticsError.NO_APP_ID */);
-            }
-            if (!apiKey) {
-                if (measurementId) {
-                    return [2 /*return*/, {
-                            measurementId: measurementId,
-                            appId: appId
-                        }];
-                }
-                throw ERROR_FACTORY.create("no-api-key" /* AnalyticsError.NO_API_KEY */);
-            }
-            throttleMetadata = retryData.getThrottleMetadata(appId) || {
-                backoffCount: 0,
-                throttleEndTimeMillis: Date.now()
+retryData = defaultRetryData, timeoutMillis) {
+    const { appId, apiKey, measurementId } = app.options;
+    if (!appId) {
+        throw ERROR_FACTORY.create("no-app-id" /* AnalyticsError.NO_APP_ID */);
+    }
+    if (!apiKey) {
+        if (measurementId) {
+            return {
+                measurementId,
+                appId
             };
-            signal = new AnalyticsAbortSignal();
-            setTimeout(function () { return tslib.__awaiter(_this, void 0, void 0, function () {
-                return tslib.__generator(this, function (_a) {
-                    // Note a very low delay, eg < 10ms, can elapse before listeners are initialized.
-                    signal.abort();
-                    return [2 /*return*/];
-                });
-            }); }, timeoutMillis !== undefined ? timeoutMillis : FETCH_TIMEOUT_MILLIS);
-            return [2 /*return*/, attemptFetchDynamicConfigWithRetry({ appId: appId, apiKey: apiKey, measurementId: measurementId }, throttleMetadata, signal, retryData)];
-        });
-    });
+        }
+        throw ERROR_FACTORY.create("no-api-key" /* AnalyticsError.NO_API_KEY */);
+    }
+    const throttleMetadata = retryData.getThrottleMetadata(appId) || {
+        backoffCount: 0,
+        throttleEndTimeMillis: Date.now()
+    };
+    const signal = new AnalyticsAbortSignal();
+    setTimeout(async () => {
+        // Note a very low delay, eg < 10ms, can elapse before listeners are initialized.
+        signal.abort();
+    }, timeoutMillis !== undefined ? timeoutMillis : FETCH_TIMEOUT_MILLIS);
+    return attemptFetchDynamicConfigWithRetry({ appId, apiKey, measurementId }, throttleMetadata, signal, retryData);
 }
 /**
  * Runs one retry attempt.
@@ -596,71 +514,58 @@ retryData, timeoutMillis) {
  * @param throttleMetadata Ongoing metadata to determine throttling times.
  * @param signal Abort signal.
  */
-function attemptFetchDynamicConfigWithRetry(appFields, _a, signal, retryData // for testing
+async function attemptFetchDynamicConfigWithRetry(appFields, { throttleEndTimeMillis, backoffCount }, signal, retryData = defaultRetryData // for testing
 ) {
-    var _b;
-    var throttleEndTimeMillis = _a.throttleEndTimeMillis, backoffCount = _a.backoffCount;
-    if (retryData === void 0) { retryData = defaultRetryData; }
-    return tslib.__awaiter(this, void 0, void 0, function () {
-        var appId, measurementId, e_1, response, e_2, error, backoffMillis, throttleMetadata;
-        return tslib.__generator(this, function (_c) {
-            switch (_c.label) {
-                case 0:
-                    appId = appFields.appId, measurementId = appFields.measurementId;
-                    _c.label = 1;
-                case 1:
-                    _c.trys.push([1, 3, , 4]);
-                    return [4 /*yield*/, setAbortableTimeout(signal, throttleEndTimeMillis)];
-                case 2:
-                    _c.sent();
-                    return [3 /*break*/, 4];
-                case 3:
-                    e_1 = _c.sent();
-                    if (measurementId) {
-                        logger.warn("Timed out fetching this Firebase app's measurement ID from the server." +
-                            " Falling back to the measurement ID ".concat(measurementId) +
-                            " provided in the \"measurementId\" field in the local Firebase config. [".concat(e_1 === null || e_1 === void 0 ? void 0 : e_1.message, "]"));
-                        return [2 /*return*/, { appId: appId, measurementId: measurementId }];
-                    }
-                    throw e_1;
-                case 4:
-                    _c.trys.push([4, 6, , 7]);
-                    return [4 /*yield*/, fetchDynamicConfig(appFields)];
-                case 5:
-                    response = _c.sent();
-                    // Note the SDK only clears throttle state if response is success or non-retriable.
-                    retryData.deleteThrottleMetadata(appId);
-                    return [2 /*return*/, response];
-                case 6:
-                    e_2 = _c.sent();
-                    error = e_2;
-                    if (!isRetriableError(error)) {
-                        retryData.deleteThrottleMetadata(appId);
-                        if (measurementId) {
-                            logger.warn("Failed to fetch this Firebase app's measurement ID from the server." +
-                                " Falling back to the measurement ID ".concat(measurementId) +
-                                " provided in the \"measurementId\" field in the local Firebase config. [".concat(error === null || error === void 0 ? void 0 : error.message, "]"));
-                            return [2 /*return*/, { appId: appId, measurementId: measurementId }];
-                        }
-                        else {
-                            throw e_2;
-                        }
-                    }
-                    backoffMillis = Number((_b = error === null || error === void 0 ? void 0 : error.customData) === null || _b === void 0 ? void 0 : _b.httpStatus) === 503
-                        ? util.calculateBackoffMillis(backoffCount, retryData.intervalMillis, LONG_RETRY_FACTOR)
-                        : util.calculateBackoffMillis(backoffCount, retryData.intervalMillis);
-                    throttleMetadata = {
-                        throttleEndTimeMillis: Date.now() + backoffMillis,
-                        backoffCount: backoffCount + 1
-                    };
-                    // Persists state.
-                    retryData.setThrottleMetadata(appId, throttleMetadata);
-                    logger.debug("Calling attemptFetch again in ".concat(backoffMillis, " millis"));
-                    return [2 /*return*/, attemptFetchDynamicConfigWithRetry(appFields, throttleMetadata, signal, retryData)];
-                case 7: return [2 /*return*/];
+    var _a;
+    const { appId, measurementId } = appFields;
+    // Starts with a (potentially zero) timeout to support resumption from stored state.
+    // Ensures the throttle end time is honored if the last attempt timed out.
+    // Note the SDK will never make a request if the fetch timeout expires at this point.
+    try {
+        await setAbortableTimeout(signal, throttleEndTimeMillis);
+    }
+    catch (e) {
+        if (measurementId) {
+            logger.warn(`Timed out fetching this Firebase app's measurement ID from the server.` +
+                ` Falling back to the measurement ID ${measurementId}` +
+                ` provided in the "measurementId" field in the local Firebase config. [${e === null || e === void 0 ? void 0 : e.message}]`);
+            return { appId, measurementId };
+        }
+        throw e;
+    }
+    try {
+        const response = await fetchDynamicConfig(appFields);
+        // Note the SDK only clears throttle state if response is success or non-retriable.
+        retryData.deleteThrottleMetadata(appId);
+        return response;
+    }
+    catch (e) {
+        const error = e;
+        if (!isRetriableError(error)) {
+            retryData.deleteThrottleMetadata(appId);
+            if (measurementId) {
+                logger.warn(`Failed to fetch this Firebase app's measurement ID from the server.` +
+                    ` Falling back to the measurement ID ${measurementId}` +
+                    ` provided in the "measurementId" field in the local Firebase config. [${error === null || error === void 0 ? void 0 : error.message}]`);
+                return { appId, measurementId };
             }
-        });
-    });
+            else {
+                throw e;
+            }
+        }
+        const backoffMillis = Number((_a = error === null || error === void 0 ? void 0 : error.customData) === null || _a === void 0 ? void 0 : _a.httpStatus) === 503
+            ? util.calculateBackoffMillis(backoffCount, retryData.intervalMillis, LONG_RETRY_FACTOR)
+            : util.calculateBackoffMillis(backoffCount, retryData.intervalMillis);
+        // Increments backoff state.
+        const throttleMetadata = {
+            throttleEndTimeMillis: Date.now() + backoffMillis,
+            backoffCount: backoffCount + 1
+        };
+        // Persists state.
+        retryData.setThrottleMetadata(appId, throttleMetadata);
+        logger.debug(`Calling attemptFetch again in ${backoffMillis} millis`);
+        return attemptFetchDynamicConfigWithRetry(appFields, throttleMetadata, signal, retryData);
+    }
 }
 /**
  * Supports waiting on a backoff by:
@@ -675,16 +580,16 @@ function attemptFetchDynamicConfigWithRetry(appFields, _a, signal, retryData //
  * <p>Visible for testing.
  */
 function setAbortableTimeout(signal, throttleEndTimeMillis) {
-    return new Promise(function (resolve, reject) {
+    return new Promise((resolve, reject) => {
         // Derives backoff from given end time, normalizing negative numbers to zero.
-        var backoffMillis = Math.max(throttleEndTimeMillis - Date.now(), 0);
-        var timeout = setTimeout(resolve, backoffMillis);
+        const backoffMillis = Math.max(throttleEndTimeMillis - Date.now(), 0);
+        const timeout = setTimeout(resolve, backoffMillis);
         // Adds listener, rather than sets onabort, because signal is a shared object.
-        signal.addEventListener(function () {
+        signal.addEventListener(() => {
             clearTimeout(timeout);
             // If the request completes before this timeout, the rejection has no effect.
             reject(ERROR_FACTORY.create("fetch-throttle" /* AnalyticsError.FETCH_THROTTLE */, {
-                throttleEndTimeMillis: throttleEndTimeMillis
+                throttleEndTimeMillis
             }));
         });
     });
@@ -697,7 +602,7 @@ function isRetriableError(e) {
         return false;
     }
     // Uses string index defined by ErrorData, which FirebaseError implements.
-    var httpStatus = Number(e.customData['httpStatus']);
+    const httpStatus = Number(e.customData['httpStatus']);
     return (httpStatus === 429 ||
         httpStatus === 500 ||
         httpStatus === 503 ||
@@ -711,18 +616,17 @@ function isRetriableError(e) {
  * polyfill recommendation, like we do with the Fetch API, but this minimal shim can easily be
  * swapped out if/when we do.
  */
-var AnalyticsAbortSignal = /** @class */ (function () {
-    function AnalyticsAbortSignal() {
+class AnalyticsAbortSignal {
+    constructor() {
         this.listeners = [];
     }
-    AnalyticsAbortSignal.prototype.addEventListener = function (listener) {
+    addEventListener(listener) {
         this.listeners.push(listener);
-    };
-    AnalyticsAbortSignal.prototype.abort = function () {
-        this.listeners.forEach(function (listener) { return listener(); });
-    };
-    return AnalyticsAbortSignal;
-}());
+    }
+    abort() {
+        this.listeners.forEach(listener => listener());
+    }
+}
 
 /**
  * @license
@@ -743,7 +647,7 @@ var AnalyticsAbortSignal = /** @class */ (function () {
 /**
  * Event parameters to set on 'gtag' during initialization.
  */
-var defaultEventParametersForInit;
+let defaultEventParametersForInit;
 /**
  * Logs an analytics event through the Firebase SDK.
  *
@@ -751,25 +655,16 @@ var defaultEventParametersForInit;
  * @param eventName Google Analytics event name, choose from standard list or use a custom string.
  * @param eventParams Analytics event parameters.
  */
-function logEvent$1(gtagFunction, initializationPromise, eventName, eventParams, options) {
-    return tslib.__awaiter(this, void 0, void 0, function () {
-        var measurementId, params;
-        return tslib.__generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    if (!(options && options.global)) return [3 /*break*/, 1];
-                    gtagFunction("event" /* GtagCommand.EVENT */, eventName, eventParams);
-                    return [2 /*return*/];
-                case 1: return [4 /*yield*/, initializationPromise];
-                case 2:
-                    measurementId = _a.sent();
-                    params = tslib.__assign(tslib.__assign({}, eventParams), { 'send_to': measurementId });
-                    gtagFunction("event" /* GtagCommand.EVENT */, eventName, params);
-                    _a.label = 3;
-                case 3: return [2 /*return*/];
-            }
-        });
-    });
+async function logEvent$1(gtagFunction, initializationPromise, eventName, eventParams, options) {
+    if (options && options.global) {
+        gtagFunction("event" /* GtagCommand.EVENT */, eventName, eventParams);
+        return;
+    }
+    else {
+        const measurementId = await initializationPromise;
+        const params = Object.assign(Object.assign({}, eventParams), { 'send_to': measurementId });
+        gtagFunction("event" /* GtagCommand.EVENT */, eventName, params);
+    }
 }
 /**
  * Set screen_name parameter for this Google Analytics ID.
@@ -780,27 +675,18 @@ function logEvent$1(gtagFunction, initializationPromise, eventName, eventParams,
  * @param gtagFunction Wrapped gtag function that waits for fid to be set before sending an event
  * @param screenName Screen name string to set.
  */
-function setCurrentScreen$1(gtagFunction, initializationPromise, screenName, options) {
-    return tslib.__awaiter(this, void 0, void 0, function () {
-        var measurementId;
-        return tslib.__generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    if (!(options && options.global)) return [3 /*break*/, 1];
-                    gtagFunction("set" /* GtagCommand.SET */, { 'screen_name': screenName });
-                    return [2 /*return*/, Promise.resolve()];
-                case 1: return [4 /*yield*/, initializationPromise];
-                case 2:
-                    measurementId = _a.sent();
-                    gtagFunction("config" /* GtagCommand.CONFIG */, measurementId, {
-                        update: true,
-                        'screen_name': screenName
-                    });
-                    _a.label = 3;
-                case 3: return [2 /*return*/];
-            }
+async function setCurrentScreen$1(gtagFunction, initializationPromise, screenName, options) {
+    if (options && options.global) {
+        gtagFunction("set" /* GtagCommand.SET */, { 'screen_name': screenName });
+        return Promise.resolve();
+    }
+    else {
+        const measurementId = await initializationPromise;
+        gtagFunction("config" /* GtagCommand.CONFIG */, measurementId, {
+            update: true,
+            'screen_name': screenName
         });
-    });
+    }
 }
 /**
  * Set user_id parameter for this Google Analytics ID.
@@ -808,27 +694,18 @@ function setCurrentScreen$1(gtagFunction, initializationPromise, screenName, opt
  * @param gtagFunction Wrapped gtag function that waits for fid to be set before sending an event
  * @param id User ID string to set
  */
-function setUserId$1(gtagFunction, initializationPromise, id, options) {
-    return tslib.__awaiter(this, void 0, void 0, function () {
-        var measurementId;
-        return tslib.__generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    if (!(options && options.global)) return [3 /*break*/, 1];
-                    gtagFunction("set" /* GtagCommand.SET */, { 'user_id': id });
-                    return [2 /*return*/, Promise.resolve()];
-                case 1: return [4 /*yield*/, initializationPromise];
-                case 2:
-                    measurementId = _a.sent();
-                    gtagFunction("config" /* GtagCommand.CONFIG */, measurementId, {
-                        update: true,
-                        'user_id': id
-                    });
-                    _a.label = 3;
-                case 3: return [2 /*return*/];
-            }
+async function setUserId$1(gtagFunction, initializationPromise, id, options) {
+    if (options && options.global) {
+        gtagFunction("set" /* GtagCommand.SET */, { 'user_id': id });
+        return Promise.resolve();
+    }
+    else {
+        const measurementId = await initializationPromise;
+        gtagFunction("config" /* GtagCommand.CONFIG */, measurementId, {
+            update: true,
+            'user_id': id
         });
-    });
+    }
 }
 /**
  * Set all other user properties other than user_id and screen_name.
@@ -836,33 +713,23 @@ function setUserId$1(gtagFunction, initializationPromise, id, options) {
  * @param gtagFunction Wrapped gtag function that waits for fid to be set before sending an event
  * @param properties Map of user properties to set
  */
-function setUserProperties$1(gtagFunction, initializationPromise, properties, options) {
-    return tslib.__awaiter(this, void 0, void 0, function () {
-        var flatProperties, _i, _a, key, measurementId;
-        return tslib.__generator(this, function (_b) {
-            switch (_b.label) {
-                case 0:
-                    if (!(options && options.global)) return [3 /*break*/, 1];
-                    flatProperties = {};
-                    for (_i = 0, _a = Object.keys(properties); _i < _a.length; _i++) {
-                        key = _a[_i];
-                        // use dot notation for merge behavior in gtag.js
-                        flatProperties["user_properties.".concat(key)] = properties[key];
-                    }
-                    gtagFunction("set" /* GtagCommand.SET */, flatProperties);
-                    return [2 /*return*/, Promise.resolve()];
-                case 1: return [4 /*yield*/, initializationPromise];
-                case 2:
-                    measurementId = _b.sent();
-                    gtagFunction("config" /* GtagCommand.CONFIG */, measurementId, {
-                        update: true,
-                        'user_properties': properties
-                    });
-                    _b.label = 3;
-                case 3: return [2 /*return*/];
-            }
+async function setUserProperties$1(gtagFunction, initializationPromise, properties, options) {
+    if (options && options.global) {
+        const flatProperties = {};
+        for (const key of Object.keys(properties)) {
+            // use dot notation for merge behavior in gtag.js
+            flatProperties[`user_properties.${key}`] = properties[key];
+        }
+        gtagFunction("set" /* GtagCommand.SET */, flatProperties);
+        return Promise.resolve();
+    }
+    else {
+        const measurementId = await initializationPromise;
+        gtagFunction("config" /* GtagCommand.CONFIG */, measurementId, {
+            update: true,
+            'user_properties': properties
         });
-    });
+    }
 }
 /**
  * Retrieves a unique Google Analytics identifier for the web client.
@@ -870,23 +737,14 @@ function setUserProperties$1(gtagFunction, initializationPromise, properties, op
  *
  * @param gtagFunction Wrapped gtag function that waits for fid to be set before sending an event
  */
-function internalGetGoogleAnalyticsClientId(gtagFunction, initializationPromise) {
-    return tslib.__awaiter(this, void 0, void 0, function () {
-        var measurementId;
-        return tslib.__generator(this, function (_a) {
-            switch (_a.label) {
-                case 0: return [4 /*yield*/, initializationPromise];
-                case 1:
-                    measurementId = _a.sent();
-                    return [2 /*return*/, new Promise(function (resolve, reject) {
-                            gtagFunction("get" /* GtagCommand.GET */, measurementId, 'client_id', function (clientId) {
-                                if (!clientId) {
-                                    reject(ERROR_FACTORY.create("no-client-id" /* AnalyticsError.NO_CLIENT_ID */));
-                                }
-                                resolve(clientId);
-                            });
-                        })];
+async function internalGetGoogleAnalyticsClientId(gtagFunction, initializationPromise) {
+    const measurementId = await initializationPromise;
+    return new Promise((resolve, reject) => {
+        gtagFunction("get" /* GtagCommand.GET */, measurementId, 'client_id', (clientId) => {
+            if (!clientId) {
+                reject(ERROR_FACTORY.create("no-client-id" /* AnalyticsError.NO_CLIENT_ID */));
             }
+            resolve(clientId);
         });
     });
 }
@@ -895,24 +753,14 @@ function internalGetGoogleAnalyticsClientId(gtagFunction, initializationPromise)
  *
  * @param enabled If true, collection is enabled for this ID.
  */
-function setAnalyticsCollectionEnabled$1(initializationPromise, enabled) {
-    return tslib.__awaiter(this, void 0, void 0, function () {
-        var measurementId;
-        return tslib.__generator(this, function (_a) {
-            switch (_a.label) {
-                case 0: return [4 /*yield*/, initializationPromise];
-                case 1:
-                    measurementId = _a.sent();
-                    window["ga-disable-".concat(measurementId)] = !enabled;
-                    return [2 /*return*/];
-            }
-        });
-    });
+async function setAnalyticsCollectionEnabled$1(initializationPromise, enabled) {
+    const measurementId = await initializationPromise;
+    window[`ga-disable-${measurementId}`] = !enabled;
 }
 /**
  * Consent parameters to default to during 'gtag' initialization.
  */
-var defaultConsentSettingsForInit;
+let defaultConsentSettingsForInit;
 /**
  * Sets the variable {@link defaultConsentSettingsForInit} for use in the initialization of
  * analytics.
@@ -948,33 +796,25 @@ function _setDefaultEventParametersForInit(customParams) {
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-function validateIndexedDB() {
-    return tslib.__awaiter(this, void 0, void 0, function () {
-        var e_1;
-        return tslib.__generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    if (!!util.isIndexedDBAvailable()) return [3 /*break*/, 1];
-                    logger.warn(ERROR_FACTORY.create("indexeddb-unavailable" /* AnalyticsError.INDEXEDDB_UNAVAILABLE */, {
-                        errorInfo: 'IndexedDB is not available in this environment.'
-                    }).message);
-                    return [2 /*return*/, false];
-                case 1:
-                    _a.trys.push([1, 3, , 4]);
-                    return [4 /*yield*/, util.validateIndexedDBOpenable()];
-                case 2:
-                    _a.sent();
-                    return [3 /*break*/, 4];
-                case 3:
-                    e_1 = _a.sent();
-                    logger.warn(ERROR_FACTORY.create("indexeddb-unavailable" /* AnalyticsError.INDEXEDDB_UNAVAILABLE */, {
-                        errorInfo: e_1 === null || e_1 === void 0 ? void 0 : e_1.toString()
-                    }).message);
-                    return [2 /*return*/, false];
-                case 4: return [2 /*return*/, true];
-            }
-        });
-    });
+async function validateIndexedDB() {
+    if (!util.isIndexedDBAvailable()) {
+        logger.warn(ERROR_FACTORY.create("indexeddb-unavailable" /* AnalyticsError.INDEXEDDB_UNAVAILABLE */, {
+            errorInfo: 'IndexedDB is not available in this environment.'
+        }).message);
+        return false;
+    }
+    else {
+        try {
+            await util.validateIndexedDBOpenable();
+        }
+        catch (e) {
+            logger.warn(ERROR_FACTORY.create("indexeddb-unavailable" /* AnalyticsError.INDEXEDDB_UNAVAILABLE */, {
+                errorInfo: e === null || e === void 0 ? void 0 : e.toString()
+            }).message);
+            return false;
+        }
+    }
+    return true;
 }
 /**
  * Initialize the analytics instance in gtag.js by calling config command with fid.
@@ -989,80 +829,72 @@ function validateIndexedDB() {
  *
  * @returns Measurement ID.
  */
-function _initializeAnalytics(app, dynamicConfigPromisesList, measurementIdToAppId, installations, gtagCore, dataLayerName, options) {
+async function _initializeAnalytics(app, dynamicConfigPromisesList, measurementIdToAppId, installations, gtagCore, dataLayerName, options) {
     var _a;
-    return tslib.__awaiter(this, void 0, void 0, function () {
-        var dynamicConfigPromise, fidPromise, _b, dynamicConfig, fid, configProperties;
-        return tslib.__generator(this, function (_c) {
-            switch (_c.label) {
-                case 0:
-                    dynamicConfigPromise = fetchDynamicConfigWithRetry(app);
-                    // Once fetched, map measurementIds to appId, for ease of lookup in wrapped gtag function.
-                    dynamicConfigPromise
-                        .then(function (config) {
-                        measurementIdToAppId[config.measurementId] = config.appId;
-                        if (app.options.measurementId &&
-                            config.measurementId !== app.options.measurementId) {
-                            logger.warn("The measurement ID in the local Firebase config (".concat(app.options.measurementId, ")") +
-                                " does not match the measurement ID fetched from the server (".concat(config.measurementId, ").") +
-                                " To ensure analytics events are always sent to the correct Analytics property," +
-                                " update the" +
-                                " measurement ID field in the local config or remove it from the local config.");
-                        }
-                    })
-                        .catch(function (e) { return logger.error(e); });
-                    // Add to list to track state of all dynamic config promises.
-                    dynamicConfigPromisesList.push(dynamicConfigPromise);
-                    fidPromise = validateIndexedDB().then(function (envIsValid) {
-                        if (envIsValid) {
-                            return installations.getId();
-                        }
-                        else {
-                            return undefined;
-                        }
-                    });
-                    return [4 /*yield*/, Promise.all([
-                            dynamicConfigPromise,
-                            fidPromise
-                        ])];
-                case 1:
-                    _b = _c.sent(), dynamicConfig = _b[0], fid = _b[1];
-                    // Detect if user has already put the gtag <script> tag on this page with the passed in
-                    // data layer name.
-                    if (!findGtagScriptOnPage(dataLayerName)) {
-                        insertScriptTag(dataLayerName, dynamicConfig.measurementId);
-                    }
-                    // Detects if there are consent settings that need to be configured.
-                    if (defaultConsentSettingsForInit) {
-                        gtagCore("consent" /* GtagCommand.CONSENT */, 'default', defaultConsentSettingsForInit);
-                        _setConsentDefaultForInit(undefined);
-                    }
-                    // This command initializes gtag.js and only needs to be called once for the entire web app,
-                    // but since it is idempotent, we can call it multiple times.
-                    // We keep it together with other initialization logic for better code structure.
-                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                    gtagCore('js', new Date());
-                    configProperties = (_a = options === null || options === void 0 ? void 0 : options.config) !== null && _a !== void 0 ? _a : {};
-                    // guard against developers accidentally setting properties with prefix `firebase_`
-                    configProperties[ORIGIN_KEY] = 'firebase';
-                    configProperties.update = true;
-                    if (fid != null) {
-                        configProperties[GA_FID_KEY] = fid;
-                    }
-                    // It should be the first config command called on this GA-ID
-                    // Initialize this GA-ID and set FID on it using the gtag config API.
-                    // Note: This will trigger a page_view event unless 'send_page_view' is set to false in
-                    // `configProperties`.
-                    gtagCore("config" /* GtagCommand.CONFIG */, dynamicConfig.measurementId, configProperties);
-                    // Detects if there is data that will be set on every event logged from the SDK.
-                    if (defaultEventParametersForInit) {
-                        gtagCore("set" /* GtagCommand.SET */, defaultEventParametersForInit);
-                        _setDefaultEventParametersForInit(undefined);
-                    }
-                    return [2 /*return*/, dynamicConfig.measurementId];
-            }
-        });
+    const dynamicConfigPromise = fetchDynamicConfigWithRetry(app);
+    // Once fetched, map measurementIds to appId, for ease of lookup in wrapped gtag function.
+    dynamicConfigPromise
+        .then(config => {
+        measurementIdToAppId[config.measurementId] = config.appId;
+        if (app.options.measurementId &&
+            config.measurementId !== app.options.measurementId) {
+            logger.warn(`The measurement ID in the local Firebase config (${app.options.measurementId})` +
+                ` does not match the measurement ID fetched from the server (${config.measurementId}).` +
+                ` To ensure analytics events are always sent to the correct Analytics property,` +
+                ` update the` +
+                ` measurement ID field in the local config or remove it from the local config.`);
+        }
+    })
+        .catch(e => logger.error(e));
+    // Add to list to track state of all dynamic config promises.
+    dynamicConfigPromisesList.push(dynamicConfigPromise);
+    const fidPromise = validateIndexedDB().then(envIsValid => {
+        if (envIsValid) {
+            return installations.getId();
+        }
+        else {
+            return undefined;
+        }
     });
+    const [dynamicConfig, fid] = await Promise.all([
+        dynamicConfigPromise,
+        fidPromise
+    ]);
+    // Detect if user has already put the gtag <script> tag on this page with the passed in
+    // data layer name.
+    if (!findGtagScriptOnPage(dataLayerName)) {
+        insertScriptTag(dataLayerName, dynamicConfig.measurementId);
+    }
+    // Detects if there are consent settings that need to be configured.
+    if (defaultConsentSettingsForInit) {
+        gtagCore("consent" /* GtagCommand.CONSENT */, 'default', defaultConsentSettingsForInit);
+        _setConsentDefaultForInit(undefined);
+    }
+    // This command initializes gtag.js and only needs to be called once for the entire web app,
+    // but since it is idempotent, we can call it multiple times.
+    // We keep it together with other initialization logic for better code structure.
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    gtagCore('js', new Date());
+    // User config added first. We don't want users to accidentally overwrite
+    // base Firebase config properties.
+    const configProperties = (_a = options === null || options === void 0 ? void 0 : options.config) !== null && _a !== void 0 ? _a : {};
+    // guard against developers accidentally setting properties with prefix `firebase_`
+    configProperties[ORIGIN_KEY] = 'firebase';
+    configProperties.update = true;
+    if (fid != null) {
+        configProperties[GA_FID_KEY] = fid;
+    }
+    // It should be the first config command called on this GA-ID
+    // Initialize this GA-ID and set FID on it using the gtag config API.
+    // Note: This will trigger a page_view event unless 'send_page_view' is set to false in
+    // `configProperties`.
+    gtagCore("config" /* GtagCommand.CONFIG */, dynamicConfig.measurementId, configProperties);
+    // Detects if there is data that will be set on every event logged from the SDK.
+    if (defaultEventParametersForInit) {
+        gtagCore("set" /* GtagCommand.SET */, defaultEventParametersForInit);
+        _setDefaultEventParametersForInit(undefined);
+    }
+    return dynamicConfig.measurementId;
 }
 
 /**
@@ -1084,58 +916,57 @@ function _initializeAnalytics(app, dynamicConfigPromisesList, measurementIdToApp
 /**
  * Analytics Service class.
  */
-var AnalyticsService = /** @class */ (function () {
-    function AnalyticsService(app) {
+class AnalyticsService {
+    constructor(app) {
         this.app = app;
     }
-    AnalyticsService.prototype._delete = function () {
+    _delete() {
         delete initializationPromisesMap[this.app.options.appId];
         return Promise.resolve();
-    };
-    return AnalyticsService;
-}());
+    }
+}
 /**
  * Maps appId to full initialization promise. Wrapped gtag calls must wait on
  * all or some of these, depending on the call's `send_to` param and the status
  * of the dynamic config fetches (see below).
  */
-var initializationPromisesMap = {};
+let initializationPromisesMap = {};
 /**
  * List of dynamic config fetch promises. In certain cases, wrapped gtag calls
  * wait on all these to be complete in order to determine if it can selectively
  * wait for only certain initialization (FID) promises or if it must wait for all.
  */
-var dynamicConfigPromisesList = [];
+let dynamicConfigPromisesList = [];
 /**
  * Maps fetched measurementIds to appId. Populated when the app's dynamic config
  * fetch completes. If already populated, gtag config calls can use this to
  * selectively wait for only this app's initialization promise (FID) instead of all
  * initialization promises.
  */
-var measurementIdToAppId = {};
+const measurementIdToAppId = {};
 /**
  * Name for window global data layer array used by GA: defaults to 'dataLayer'.
  */
-var dataLayerName = 'dataLayer';
+let dataLayerName = 'dataLayer';
 /**
  * Name for window global gtag function used by GA: defaults to 'gtag'.
  */
-var gtagName = 'gtag';
+let gtagName = 'gtag';
 /**
  * Reproduction of standard gtag function or reference to existing
  * gtag function on window object.
  */
-var gtagCoreFunction;
+let gtagCoreFunction;
 /**
  * Wrapper around gtag function that ensures FID is sent with all
  * relevant event and config calls.
  */
-var wrappedGtagFunction;
+let wrappedGtagFunction;
 /**
  * Flag to ensure page initialization steps (creation or wrapping of
  * dataLayer and gtag script) are only run once per page load.
  */
-var globalInitDone = false;
+let globalInitDone = false;
 /**
  * Configures Firebase Analytics to use custom `gtag` or `dataLayer` names.
  * Intended to be used if `gtag.js` script has been installed on
@@ -1165,7 +996,7 @@ function settings(options) {
  * error that also lists details for each mismatch found.
  */
 function warnOnBrowserContextMismatch() {
-    var mismatchedEnvMessages = [];
+    const mismatchedEnvMessages = [];
     if (util.isBrowserExtension()) {
         mismatchedEnvMessages.push('This is a browser extension environment.');
     }
@@ -1173,10 +1004,10 @@ function warnOnBrowserContextMismatch() {
         mismatchedEnvMessages.push('Cookies are not available.');
     }
     if (mismatchedEnvMessages.length > 0) {
-        var details = mismatchedEnvMessages
-            .map(function (message, index) { return "(".concat(index + 1, ") ").concat(message); })
+        const details = mismatchedEnvMessages
+            .map((message, index) => `(${index + 1}) ${message}`)
             .join(' ');
-        var err = ERROR_FACTORY.create("invalid-analytics-context" /* AnalyticsError.INVALID_ANALYTICS_CONTEXT */, {
+        const err = ERROR_FACTORY.create("invalid-analytics-context" /* AnalyticsError.INVALID_ANALYTICS_CONTEXT */, {
             errorInfo: details
         });
         logger.warn(err.message);
@@ -1188,15 +1019,15 @@ function warnOnBrowserContextMismatch() {
  */
 function factory(app, installations, options) {
     warnOnBrowserContextMismatch();
-    var appId = app.options.appId;
+    const appId = app.options.appId;
     if (!appId) {
         throw ERROR_FACTORY.create("no-app-id" /* AnalyticsError.NO_APP_ID */);
     }
     if (!app.options.apiKey) {
         if (app.options.measurementId) {
-            logger.warn("The \"apiKey\" field is empty in the local Firebase config. This is needed to fetch the latest" +
-                " measurement ID for this Firebase app. Falling back to the measurement ID ".concat(app.options.measurementId) +
-                " provided in the \"measurementId\" field in the local Firebase config.");
+            logger.warn(`The "apiKey" field is empty in the local Firebase config. This is needed to fetch the latest` +
+                ` measurement ID for this Firebase app. Falling back to the measurement ID ${app.options.measurementId}` +
+                ` provided in the "measurementId" field in the local Firebase config.`);
         }
         else {
             throw ERROR_FACTORY.create("no-api-key" /* AnalyticsError.NO_API_KEY */);
@@ -1211,7 +1042,7 @@ function factory(app, installations, options) {
         // Steps here should only be done once per page: creation or wrapping
         // of dataLayer and global gtag function.
         getOrCreateDataLayer(dataLayerName);
-        var _a = wrapOrCreateGtag(initializationPromisesMap, dynamicConfigPromisesList, measurementIdToAppId, dataLayerName, gtagName), wrappedGtag = _a.wrappedGtag, gtagCore = _a.gtagCore;
+        const { wrappedGtag, gtagCore } = wrapOrCreateGtag(initializationPromisesMap, dynamicConfigPromisesList, measurementIdToAppId, dataLayerName, gtagName);
         wrappedGtagFunction = wrappedGtag;
         gtagCoreFunction = gtagCore;
         globalInitDone = true;
@@ -1219,7 +1050,7 @@ function factory(app, installations, options) {
     // Async but non-blocking.
     // This map reflects the completion state of all promises for each appId.
     initializationPromisesMap[appId] = _initializeAnalytics(app, dynamicConfigPromisesList, measurementIdToAppId, installations, gtagCoreFunction, dataLayerName, options);
-    var analyticsInstance = new AnalyticsService(app);
+    const analyticsInstance = new AnalyticsService(app);
     return analyticsInstance;
 }
 
@@ -1231,11 +1062,10 @@ function factory(app, installations, options) {
  *
  * @param app - The {@link @firebase/app#FirebaseApp} to use.
  */
-function getAnalytics(app$1) {
-    if (app$1 === void 0) { app$1 = app.getApp(); }
+function getAnalytics(app$1 = app.getApp()) {
     app$1 = util.getModularInstance(app$1);
     // Dependencies
-    var analyticsProvider = app._getProvider(app$1, ANALYTICS_TYPE);
+    const analyticsProvider = app._getProvider(app$1, ANALYTICS_TYPE);
     if (analyticsProvider.isInitialized()) {
         return analyticsProvider.getImmediate();
     }
@@ -1248,12 +1078,11 @@ function getAnalytics(app$1) {
  *
  * @param app - The {@link @firebase/app#FirebaseApp} to use.
  */
-function initializeAnalytics(app$1, options) {
-    if (options === void 0) { options = {}; }
+function initializeAnalytics(app$1, options = {}) {
     // Dependencies
-    var analyticsProvider = app._getProvider(app$1, ANALYTICS_TYPE);
+    const analyticsProvider = app._getProvider(app$1, ANALYTICS_TYPE);
     if (analyticsProvider.isInitialized()) {
-        var existingInstance = analyticsProvider.getImmediate();
+        const existingInstance = analyticsProvider.getImmediate();
         if (util.deepEqual(options, analyticsProvider.getOptions())) {
             return existingInstance;
         }
@@ -1261,7 +1090,7 @@ function initializeAnalytics(app$1, options) {
             throw ERROR_FACTORY.create("already-initialized" /* AnalyticsError.ALREADY_INITIALIZED */);
         }
     }
-    var analyticsInstance = analyticsProvider.initialize({ options: options });
+    const analyticsInstance = analyticsProvider.initialize({ options });
     return analyticsInstance;
 }
 /**
@@ -1275,35 +1104,23 @@ function initializeAnalytics(app$1, options) {
  * @public
  *
  */
-function isSupported() {
-    return tslib.__awaiter(this, void 0, void 0, function () {
-        var isDBOpenable;
-        return tslib.__generator(this, function (_a) {
-            switch (_a.label) {
-                case 0:
-                    if (util.isBrowserExtension()) {
-                        return [2 /*return*/, false];
-                    }
-                    if (!util.areCookiesEnabled()) {
-                        return [2 /*return*/, false];
-                    }
-                    if (!util.isIndexedDBAvailable()) {
-                        return [2 /*return*/, false];
-                    }
-                    _a.label = 1;
-                case 1:
-                    _a.trys.push([1, 3, , 4]);
-                    return [4 /*yield*/, util.validateIndexedDBOpenable()];
-                case 2:
-                    isDBOpenable = _a.sent();
-                    return [2 /*return*/, isDBOpenable];
-                case 3:
-                    _a.sent();
-                    return [2 /*return*/, false];
-                case 4: return [2 /*return*/];
-            }
-        });
-    });
+async function isSupported() {
+    if (util.isBrowserExtension()) {
+        return false;
+    }
+    if (!util.areCookiesEnabled()) {
+        return false;
+    }
+    if (!util.isIndexedDBAvailable()) {
+        return false;
+    }
+    try {
+        const isDBOpenable = await util.validateIndexedDBOpenable();
+        return isDBOpenable;
+    }
+    catch (error) {
+        return false;
+    }
 }
 /**
  * Use gtag `config` command to set `screen_name`.
@@ -1318,7 +1135,7 @@ function isSupported() {
  */
 function setCurrentScreen(analyticsInstance, screenName, options) {
     analyticsInstance = util.getModularInstance(analyticsInstance);
-    setCurrentScreen$1(wrappedGtagFunction, initializationPromisesMap[analyticsInstance.app.options.appId], screenName, options).catch(function (e) { return logger.error(e); });
+    setCurrentScreen$1(wrappedGtagFunction, initializationPromisesMap[analyticsInstance.app.options.appId], screenName, options).catch(e => logger.error(e));
 }
 /**
  * Retrieves a unique Google Analytics identifier for the web client.
@@ -1328,13 +1145,9 @@ function setCurrentScreen(analyticsInstance, screenName, options) {
  *
  * @param app - The {@link @firebase/app#FirebaseApp} to use.
  */
-function getGoogleAnalyticsClientId(analyticsInstance) {
-    return tslib.__awaiter(this, void 0, void 0, function () {
-        return tslib.__generator(this, function (_a) {
-            analyticsInstance = util.getModularInstance(analyticsInstance);
-            return [2 /*return*/, internalGetGoogleAnalyticsClientId(wrappedGtagFunction, initializationPromisesMap[analyticsInstance.app.options.appId])];
-        });
-    });
+async function getGoogleAnalyticsClientId(analyticsInstance) {
+    analyticsInstance = util.getModularInstance(analyticsInstance);
+    return internalGetGoogleAnalyticsClientId(wrappedGtagFunction, initializationPromisesMap[analyticsInstance.app.options.appId]);
 }
 /**
  * Use gtag `config` command to set `user_id`.
@@ -1346,7 +1159,7 @@ function getGoogleAnalyticsClientId(analyticsInstance) {
  */
 function setUserId(analyticsInstance, id, options) {
     analyticsInstance = util.getModularInstance(analyticsInstance);
-    setUserId$1(wrappedGtagFunction, initializationPromisesMap[analyticsInstance.app.options.appId], id, options).catch(function (e) { return logger.error(e); });
+    setUserId$1(wrappedGtagFunction, initializationPromisesMap[analyticsInstance.app.options.appId], id, options).catch(e => logger.error(e));
 }
 /**
  * Use gtag `config` command to set all params specified.
@@ -1355,7 +1168,7 @@ function setUserId(analyticsInstance, id, options) {
  */
 function setUserProperties(analyticsInstance, properties, options) {
     analyticsInstance = util.getModularInstance(analyticsInstance);
-    setUserProperties$1(wrappedGtagFunction, initializationPromisesMap[analyticsInstance.app.options.appId], properties, options).catch(function (e) { return logger.error(e); });
+    setUserProperties$1(wrappedGtagFunction, initializationPromisesMap[analyticsInstance.app.options.appId], properties, options).catch(e => logger.error(e));
 }
 /**
  * Sets whether Google Analytics collection is enabled for this app on this device.
@@ -1368,7 +1181,7 @@ function setUserProperties(analyticsInstance, properties, options) {
  */
 function setAnalyticsCollectionEnabled(analyticsInstance, enabled) {
     analyticsInstance = util.getModularInstance(analyticsInstance);
-    setAnalyticsCollectionEnabled$1(initializationPromisesMap[analyticsInstance.app.options.appId], enabled).catch(function (e) { return logger.error(e); });
+    setAnalyticsCollectionEnabled$1(initializationPromisesMap[analyticsInstance.app.options.appId], enabled).catch(e => logger.error(e));
 }
 /**
  * Adds data that will be set on every event logged from the SDK, including automatic ones.
@@ -1399,7 +1212,7 @@ function setDefaultEventParameters(customParams) {
  */
 function logEvent(analyticsInstance, eventName, eventParams, options) {
     analyticsInstance = util.getModularInstance(analyticsInstance);
-    logEvent$1(wrappedGtagFunction, initializationPromisesMap[analyticsInstance.app.options.appId], eventName, eventParams, options).catch(function (e) { return logger.error(e); });
+    logEvent$1(wrappedGtagFunction, initializationPromisesMap[analyticsInstance.app.options.appId], eventName, eventParams, options).catch(e => logger.error(e));
 }
 /**
  * Sets the applicable end user consent state for this web app across all gtag references once
@@ -1420,8 +1233,8 @@ function setConsent(consentSettings) {
     }
 }
 
-var name = "@firebase/analytics";
-var version = "0.10.8";
+const name = "@firebase/analytics";
+const version = "0.10.9-canary.a97ac88db";
 
 /**
  * The Firebase Analytics Web SDK.
@@ -1430,24 +1243,23 @@ var version = "0.10.8";
  * @packageDocumentation
  */
 function registerAnalytics() {
-    app._registerComponent(new component.Component(ANALYTICS_TYPE, function (container, _a) {
-        var analyticsOptions = _a.options;
+    app._registerComponent(new component.Component(ANALYTICS_TYPE, (container, { options: analyticsOptions }) => {
         // getImmediate for FirebaseApp will always succeed
-        var app = container.getProvider('app').getImmediate();
-        var installations = container
+        const app = container.getProvider('app').getImmediate();
+        const installations = container
             .getProvider('installations-internal')
             .getImmediate();
         return factory(app, installations, analyticsOptions);
     }, "PUBLIC" /* ComponentType.PUBLIC */));
     app._registerComponent(new component.Component('analytics-internal', internalFactory, "PRIVATE" /* ComponentType.PRIVATE */));
     app.registerVersion(name, version);
-    // BUILD_TARGET will be replaced by values like esm5, esm2017, cjs5, etc during the compilation
-    app.registerVersion(name, version, 'cjs5');
+    // BUILD_TARGET will be replaced by values like esm2017, cjs2017, etc during the compilation
+    app.registerVersion(name, version, 'cjs2017');
     function internalFactory(container) {
         try {
-            var analytics_1 = container.getProvider(ANALYTICS_TYPE).getImmediate();
+            const analytics = container.getProvider(ANALYTICS_TYPE).getImmediate();
             return {
-                logEvent: function (eventName, eventParams, options) { return logEvent(analytics_1, eventName, eventParams, options); }
+                logEvent: (eventName, eventParams, options) => logEvent(analytics, eventName, eventParams, options)
             };
         }
         catch (e) {