https://henson-fund.web.app/chunk-67BET6PV.js

66// node_modules/@firebase/installations/dist/esm/index.esm2017.js
67var name = "@firebase/installations";
68var version = "0.6.18";
69var PENDING_TIMEOUT_MS = 1e4;
70var PACKAGE_VERSION = `w:${version}`;
71var INTERNAL_AUTH_VERSION = "FIS_v2";
72var INSTALLATIONS_API_URL = "https://firebaseinstallations.googleapis.com/v1";
73var TOKEN_EXPIRATION_BUFFER = 60 * 60 * 1e3;
74var SERVICE = "installations";
75var SERVICE_NAME = "Installations";
76var ERROR_DESCRIPTION_MAP = {
77  [
78    "missing-app-config-values"
79    /* ErrorCode.MISSING_APP_CONFIG_VALUES */
80  ]: 'Missing App configuration value: "{$valueName}"',
81  [
82    "not-registered"
83    /* ErrorCode.NOT_REGISTERED */
84  ]: "Firebase Installation is not registered.",
85  [
86    "installation-not-found"
87    /* ErrorCode.INSTALLATION_NOT_FOUND */
88  ]: "Firebase Installation not found.",
89  [
90    "request-failed"
91    /* ErrorCode.REQUEST_FAILED */
92  ]: '{$requestName} request failed with error "{$serverCode} {$serverStatus}: {$serverMessage}"',
93  [
94    "app-offline"
95    /* ErrorCode.APP_OFFLINE */
96  ]: "Could not process request. Application offline.",
97  [
98    "delete-pending-registration"
99    /* ErrorCode.DELETE_PENDING_REGISTRATION */
100  ]: "Can't delete installation while there is a pending registration request."
101};
102var ERROR_FACTORY = new ErrorFactory(SERVICE, SERVICE_NAME, ERROR_DESCRIPTION_MAP);
103function isServerError(error) {
104  return error instanceof FirebaseError && error.code.includes(
105    "request-failed"
106    /* ErrorCode.REQUEST_FAILED */
107  );
108}
109function getInstallationsEndpoint({ projectId }) {
110  return `${INSTALLATIONS_API_URL}/projects/${projectId}/installations`;
111}
112function extractAuthTokenInfoFromResponse(response) {
113  return {
114    token: response.token,
115    requestStatus: 2,
116    expiresIn: getExpiresInFromResponseExpiresIn(response.expiresIn),
117    creationTime: Date.now()
118  };
119}
120function getErrorFromResponse(requestName, response) {
121  return __async(this, null, function* () {
122    const responseJson = yield response.json();
123    const errorData = responseJson.error;
124    return ERROR_FACTORY.create("request-failed", {
125      requestName,
126      serverCode: errorData.code,
127      serverMessage: errorData.message,
128      serverStatus: errorData.status
129    });
130  });
131}
132function getHeaders({ apiKey }) {
133  return new Headers({
134    "Content-Type": "application/json",
135    Accept: "application/json",
136    "x-goog-api-key": apiKey
137  });
138}
139function getHeadersWithAuth(appConfig, { refreshToken }) {
140  const headers = getHeaders(appConfig);
141  headers.append("Authorization", getAuthorizationHeader(refreshToken));
142  return headers;
143}
144function retryIfServerError(fn) {
145  return __async(this, null, function* () {
146    const result = yield fn();
147    if (result.status >= 500 && result.status < 600) {
148      return fn();
149    }
150    return result;
151  });
152}
153function getExpiresInFromResponseExpiresIn(responseExpiresIn) {
154  return Number(responseExpiresIn.replace("s", "000"));
155}
156function getAuthorizationHeader(refreshToken) {
157  return `${INTERNAL_AUTH_VERSION} ${refreshToken}`;
158}
159function createInstallationRequest(_0, _1) {
160  return __async(this, arguments, function* ({ appConfig, heartbeatServiceProvider }, { fid }) {
161    const endpoint = getInstallationsEndpoint(appConfig);
162    const headers = getHeaders(appConfig);
163    const heartbeatService = heartbeatServiceProvider.getImmediate({
164      optional: true
165    });
166    if (heartbeatService) {
167      const heartbeatsHeader = yield heartbeatService.getHeartbeatsHeader();
168      if (heartbeatsHeader) {
169        headers.append("x-firebase-client", heartbeatsHeader);
170      }
171    }
172    const body = {
173      fid,
174      authVersion: INTERNAL_AUTH_VERSION,
175      appId: appConfig.appId,
176      sdkVersion: PACKAGE_VERSION
177    };
178    const request = {
179      method: "POST",
180      headers,
181      body: JSON.stringify(body)
182    };
183    const response = yield retryIfServerError(() => fetch(endpoint, request));
184    if (response.ok) {
185      const responseValue = yield response.json();
186      const registeredInstallationEntry = {
187        fid: responseValue.fid || fid,
188        registrationStatus: 2,
189        refreshToken: responseValue.refreshToken,
190        authToken: extractAuthTokenInfoFromResponse(responseValue.authToken)
191      };
192      return registeredInstallationEntry;
193    } else {
194      throw yield getErrorFromResponse("Create Installation", response);
195    }
196  });
197}
198function sleep(ms) {
199  return new Promise((resolve) => {
200    setTimeout(resolve, ms);
201  });
202}
203function bufferToBase64UrlSafe(array) {
204  const b64 = btoa(String.fromCharCode(...array));
205  return b64.replace(/\+/g, "-").replace(/\//g, "_");
206}
207var VALID_FID_PATTERN = /^[cdef][\w-]{21}$/;
208var INVALID_FID = "";
209function generateFid() {
210  try {
211    const fidByteArray = new Uint8Array(17);
212    const crypto = self.crypto || self.msCrypto;
213    crypto.getRandomValues(fidByteArray);
214    fidByteArray[0] = 112 + fidByteArray[0] % 16;
215    const fid = encode(fidByteArray);
216    return VALID_FID_PATTERN.test(fid) ? fid : INVALID_FID;
217  } catch (_a) {
218    return INVALID_FID;
219  }
220}
221function encode(fidByteArray) {
222  const b64String = bufferToBase64UrlSafe(fidByteArray);
223  return b64String.substr(0, 22);
224}
225function getKey(appConfig) {
226  return `${appConfig.appName}!${appConfig.appId}`;
227}
228var fidChangeCallbacks = /* @__PURE__ */ new Map();
229function fidChanged(appConfig, fid) {
230  const key = getKey(appConfig);
231  callFidChangeCallbacks(key, fid);
232  broadcastFidChange(key, fid);
233}
234function callFidChangeCallbacks(key, fid) {
235  const callbacks = fidChangeCallbacks.get(key);
236  if (!callbacks) {
237    return;
238  }
239  for (const callback of callbacks) {
240    callback(fid);
241  }
242}
243function broadcastFidChange(key, fid) {
244  const channel = getBroadcastChannel();
245  if (channel) {
246    channel.postMessage({ key, fid });
247  }
248  closeBroadcastChannel();
249}
250var broadcastChannel = null;
251function getBroadcastChannel() {
252  if (!broadcastChannel && "BroadcastChannel" in self) {
253    broadcastChannel = new BroadcastChannel("[Firebase] FID Change");
254    broadcastChannel.onmessage = (e) => {
255      callFidChangeCallbacks(e.data.key, e.data.fid);
256    };
257  }
258  return broadcastChannel;
259}
260function closeBroadcastChannel() {
261  if (fidChangeCallbacks.size === 0 && broadcastChannel) {
262    broadcastChannel.close();
263    broadcastChannel = null;
264  }
265}
266var DATABASE_NAME = "firebase-installations-database";
267var DATABASE_VERSION = 1;
268var OBJECT_STORE_NAME = "firebase-installations-store";
269var dbPromise = null;
270function getDbPromise() {
271  if (!dbPromise) {
272    dbPromise = openDB(DATABASE_NAME, DATABASE_VERSION, {
273      upgrade: (db, oldVersion) => {
274        switch (oldVersion) {
275          case 0:
276            db.createObjectStore(OBJECT_STORE_NAME);
277        }
278      }
279    });
280  }
281  return dbPromise;
282}
283function set(appConfig, value) {
284  return __async(this, null, function* () {
285    const key = getKey(appConfig);
286    const db = yield getDbPromise();
287    const tx = db.transaction(OBJECT_STORE_NAME, "readwrite");
288    const objectStore = tx.objectStore(OBJECT_STORE_NAME);
289    const oldValue = yield objectStore.get(key);
290    yield objectStore.put(value, key);
291    yield tx.done;
292    if (!oldValue || oldValue.fid !== value.fid) {
293      fidChanged(appConfig, value.fid);
294    }
295    return value;
296  });
297}
298function remove(appConfig) {
299  return __async(this, null, function* () {
300    const key = getKey(appConfig);
301    const db = yield getDbPromise();
302    const tx = db.transaction(OBJECT_STORE_NAME, "readwrite");
303    yield tx.objectStore(OBJECT_STORE_NAME).delete(key);
304    yield tx.done;
305  });
306}
307function update(appConfig, updateFn) {
308  return __async(this, null, function* () {
309    const key = getKey(appConfig);
310    const db = yield getDbPromise();
311    const tx = db.transaction(OBJECT_STORE_NAME, "readwrite");
312    const store = tx.objectStore(OBJECT_STORE_NAME);
313    const oldValue = yield store.get(key);
314    const newValue = updateFn(oldValue);
315    if (newValue === void 0) {
316      yield store.delete(key);
317    } else {
318      yield store.put(newValue, key);
319    }
320    yield tx.done;
321    if (newValue && (!oldValue || oldValue.fid !== newValue.fid)) {
322      fidChanged(appConfig, newValue.fid);
323    }
324    return newValue;
325  });
326}
327function getInstallationEntry(installations) {
328  return __async(this, null, function* () {
329    let registrationPromise;
330    const installationEntry = yield update(installations.appConfig, (oldEntry) => {
331      const installationEntry2 = updateOrCreateInstallationEntry(oldEntry);
332      const entryWithPromise = triggerRegistrationIfNecessary(installations, installationEntry2);
333      registrationPromise = entryWithPromise.registrationPromise;
334      return entryWithPromise.installationEntry;
335    });
336    if (installationEntry.fid === INVALID_FID) {
337      return { installationEntry: yield registrationPromise };
338    }
339    return {
340      installationEntry,
341      registrationPromise
342    };
343  });
344}
345function updateOrCreateInstallationEntry(oldEntry) {
346  const entry = oldEntry || {
347    fid: generateFid(),
348    registrationStatus: 0
349    /* RequestStatus.NOT_STARTED */
350  };
351  return clearTimedOutRequest(entry);
352}
353function triggerRegistrationIfNecessary(installations, installationEntry) {
354  if (installationEntry.registrationStatus === 0) {
355    if (!navigator.onLine) {
356      const registrationPromiseWithError = Promise.reject(ERROR_FACTORY.create(
357        "app-offline"
358        /* ErrorCode.APP_OFFLINE */
359      ));
360      return {
361        installationEntry,
362        registrationPromise: registrationPromiseWithError
363      };
364    }
365    const inProgressEntry = {
366      fid: installationEntry.fid,
367      registrationStatus: 1,
368      registrationTime: Date.now()
369    };
370    const registrationPromise = registerInstallation(installations, inProgressEntry);
371    return { installationEntry: inProgressEntry, registrationPromise };
372  } else if (installationEntry.registrationStatus === 1) {
373    return {
374      installationEntry,
375      registrationPromise: waitUntilFidRegistration(installations)
376    };
377  } else {
378    return { installationEntry };
379  }
380}
381function registerInstallation(installations, installationEntry) {
382  return __async(this, null, function* () {
383    try {
384      const registeredInstallationEntry = yield createInstallationRequest(installations, installationEntry);
385      return set(installations.appConfig, registeredInstallationEntry);
386    } catch (e) {
387      if (isServerError(e) && e.customData.serverCode === 409) {
388        yield remove(installations.appConfig);
389      } else {
390        yield set(installations.appConfig, {
391          fid: installationEntry.fid,
392          registrationStatus: 0
393          /* RequestStatus.NOT_STARTED */
394        });
395      }
396      throw e;
397    }
398  });
399}
400function waitUntilFidRegistration(installations) {
401  return __async(this, null, function* () {
402    let entry = yield updateInstallationRequest(installations.appConfig);
403    while (entry.registrationStatus === 1) {
404      yield sleep(100);
405      entry = yield updateInstallationRequest(installations.appConfig);
406    }
407    if (entry.registrationStatus === 0) {
408      const { installationEntry, registrationPromise } = yield getInstallationEntry(installations);
409      if (registrationPromise) {
410        return registrationPromise;
411      } else {
412        return installationEntry;
413      }
414    }
415    return entry;
416  });
417}
418function updateInstallationRequest(appConfig) {
419  return update(appConfig, (oldEntry) => {
420    if (!oldEntry) {
421      throw ERROR_FACTORY.create(
422        "installation-not-found"
423        /* ErrorCode.INSTALLATION_NOT_FOUND */
424      );
425    }
426    return clearTimedOutRequest(oldEntry);
427  });
428}
429function clearTimedOutRequest(entry) {
430  if (hasInstallationRequestTimedOut(entry)) {
431    return {
432      fid: entry.fid,
433      registrationStatus: 0
434      /* RequestStatus.NOT_STARTED */
435    };
436  }
437  return entry;
438}
439function hasInstallationRequestTimedOut(installationEntry) {
440  return installationEntry.registrationStatus === 1 && installationEntry.registrationTime + PENDING_TIMEOUT_MS < Date.now();
441}
442function generateAuthTokenRequest(_0, _1) {
443  return __async(this, arguments, function* ({ appConfig, heartbeatServiceProvider }, installationEntry) {
444    const endpoint = getGenerateAuthTokenEndpoint(appConfig, installationEntry);
445    const headers = getHeadersWithAuth(appConfig, installationEntry);
446    const heartbeatService = heartbeatServiceProvider.getImmediate({
447      optional: true
448    });
449    if (heartbeatService) {
450      const heartbeatsHeader = yield heartbeatService.getHeartbeatsHeader();
451      if (heartbeatsHeader) {
452        headers.append("x-firebase-client", heartbeatsHeader);
453      }
454    }
455    const body = {
456      installation: {
457        sdkVersion: PACKAGE_VERSION,
458        appId: appConfig.appId
459      }
460    };
461    const request = {
462      method: "POST",
463      headers,
464      body: JSON.stringify(body)
465    };
466    const response = yield retryIfServerError(() => fetch(endpoint, request));
467    if (response.ok) {
468      const responseValue = yield response.json();
469      const completedAuthToken = extractAuthTokenInfoFromResponse(responseValue);
470      return completedAuthToken;
471    } else {
472      throw yield getErrorFromResponse("Generate Auth Token", response);
473    }
474  });
475}
476function getGenerateAuthTokenEndpoint(appConfig, { fid }) {
477  return `${getInstallationsEndpoint(appConfig)}/${fid}/authTokens:generate`;
478}
479function refreshAuthToken(installations, forceRefresh = false) {
480  return __async(this, null, function* () {
481    let tokenPromise;
482    const entry = yield update(installations.appConfig, (oldEntry) => {
483      if (!isEntryRegistered(oldEntry)) {
484        throw ERROR_FACTORY.create(
485          "not-registered"
486          /* ErrorCode.NOT_REGISTERED */
487        );
488      }
489      const oldAuthToken = oldEntry.authToken;
490      if (!forceRefresh && isAuthTokenValid(oldAuthToken)) {
491        return oldEntry;
492      } else if (oldAuthToken.requestStatus === 1) {
493        tokenPromise = waitUntilAuthTokenRequest(installations, forceRefresh);
494        return oldEntry;
495      } else {
496        if (!navigator.onLine) {
497          throw ERROR_FACTORY.create(
498            "app-offline"
499            /* ErrorCode.APP_OFFLINE */
500          );
501        }
502        const inProgressEntry = makeAuthTokenRequestInProgressEntry(oldEntry);
503        tokenPromise = fetchAuthTokenFromServer(installations, inProgressEntry);
504        return inProgressEntry;
505      }
506    });
507    const authToken = tokenPromise ? yield tokenPromise : entry.authToken;
508    return authToken;
509  });
510}
511function waitUntilAuthTokenRequest(installations, forceRefresh) {
512  return __async(this, null, function* () {
513    let entry = yield updateAuthTokenRequest(installations.appConfig);
514    while (entry.authToken.requestStatus === 1) {
515      yield sleep(100);
516      entry = yield updateAuthTokenRequest(installations.appConfig);
517    }
518    const authToken = entry.authToken;
519    if (authToken.requestStatus === 0) {
520      return refreshAuthToken(installations, forceRefresh);
521    } else {
522      return authToken;
523    }
524  });
525}
526function updateAuthTokenRequest(appConfig) {
527  return update(appConfig, (oldEntry) => {
528    if (!isEntryRegistered(oldEntry)) {
529      throw ERROR_FACTORY.create(
530        "not-registered"
531        /* ErrorCode.NOT_REGISTERED */
532      );
533    }
534    const oldAuthToken = oldEntry.authToken;
535    if (hasAuthTokenRequestTimedOut(oldAuthToken)) {
536      return Object.assign(Object.assign({}, oldEntry), { authToken: {
537        requestStatus: 0
538        /* RequestStatus.NOT_STARTED */
539      } });
540    }
541    return oldEntry;
542  });
543}
544function fetchAuthTokenFromServer(installations, installationEntry) {
545  return __async(this, null, function* () {
546    try {
547      const authToken = yield generateAuthTokenRequest(installations, installationEntry);
548      const updatedInstallationEntry = Object.assign(Object.assign({}, installationEntry), { authToken });
549      yield set(installations.appConfig, updatedInstallationEntry);
550      return authToken;
551    } catch (e) {
552      if (isServerError(e) && (e.customData.serverCode === 401 || e.customData.serverCode === 404)) {
553        yield remove(installations.appConfig);
554      } else {
555        const updatedInstallationEntry = Object.assign(Object.assign({}, installationEntry), { authToken: {
556          requestStatus: 0
557          /* RequestStatus.NOT_STARTED */
558        } });
559        yield set(installations.appConfig, updatedInstallationEntry);
560      }
561      throw e;
562    }
563  });
564}
565function isEntryRegistered(installationEntry) {
566  return installationEntry !== void 0 && installationEntry.registrationStatus === 2;
567}
568function isAuthTokenValid(authToken) {
569  return authToken.requestStatus === 2 && !isAuthTokenExpired(authToken);
570}
571function isAuthTokenExpired(authToken) {
572  const now = Date.now();
573  return now < authToken.creationTime || authToken.creationTime + authToken.expiresIn < now + TOKEN_EXPIRATION_BUFFER;
574}
575function makeAuthTokenRequestInProgressEntry(oldEntry) {
576  const inProgressAuthToken = {
577    requestStatus: 1,
578    requestTime: Date.now()
579  };
580  return Object.assign(Object.assign({}, oldEntry), { authToken: inProgressAuthToken });
581}
582function hasAuthTokenRequestTimedOut(authToken) {
583  return authToken.requestStatus === 1 && authToken.requestTime + PENDING_TIMEOUT_MS < Date.now();
584}
585function getId(installations) {
586  return __async(this, null, function* () {
587    const installationsImpl = installations;
588    const { installationEntry, registrationPromise } = yield getInstallationEntry(installationsImpl);
589    if (registrationPromise) {
590      registrationPromise.catch(console.error);
591    } else {
592      refreshAuthToken(installationsImpl).catch(console.error);
593    }
594    return installationEntry.fid;
595  });
596}
597function getToken(installations, forceRefresh = false) {
598  return __async(this, null, function* () {
599    const installationsImpl = installations;
600    yield completeInstallationRegistration(installationsImpl);
601    const authToken = yield refreshAuthToken(installationsImpl, forceRefresh);
602    return authToken.token;
603  });
604}
605function completeInstallationRegistration(installations) {
606  return __async(this, null, function* () {
607    const { registrationPromise } = yield getInstallationEntry(installations);
608    if (registrationPromise) {
609      yield registrationPromise;
610    }
611  });
612}
613function extractAppConfig(app) {
614  if (!app || !app.options) {
615    throw getMissingValueError("App Configuration");
616  }
617  if (!app.name) {
618    throw getMissingValueError("App Name");
619  }
620  const configKeys = [
621    "projectId",
622    "apiKey",
623    "appId"
624  ];
625  for (const keyName of configKeys) {
626    if (!app.options[keyName]) {
627      throw getMissingValueError(keyName);
628    }
629  }
630  return {
631    appName: app.name,
632    projectId: app.options.projectId,
633    apiKey: app.options.apiKey,
634    appId: app.options.appId
635  };
636}
637function getMissingValueError(valueName) {
638  return ERROR_FACTORY.create("missing-app-config-values", {
639    valueName
640  });
641}
642var INSTALLATIONS_NAME = "installations";
643var INSTALLATIONS_NAME_INTERNAL = "installations-internal";
644var publicFactory = (container) => {
645  const app = container.getProvider("app").getImmediate();
646  const appConfig = extractAppConfig(app);
647  const heartbeatServiceProvider = _getProvider(app, "heartbeat");
648  const installationsImpl = {
649    app,
650    appConfig,
651    heartbeatServiceProvider,
652    _delete: () => Promise.resolve()
653  };
654  return installationsImpl;
655};
656var internalFactory = (container) => {
657  const app = container.getProvider("app").getImmediate();
658  const installations = _getProvider(app, INSTALLATIONS_NAME).getImmediate();
659  const installationsInternal = {
660    getId: () => getId(installations),
661    getToken: (forceRefresh) => getToken(installations, forceRefresh)
662  };
663  return installationsInternal;
664};
665function registerInstallations() {
666  _registerComponent(new Component(
667    INSTALLATIONS_NAME,
668    publicFactory,
669    "PUBLIC"
670    /* ComponentType.PUBLIC */
671  ));
672  _registerComponent(new Component(
673    INSTALLATIONS_NAME_INTERNAL,
674    internalFactory,
675    "PRIVATE"
676    /* ComponentType.PRIVATE */
677  ));
678}
679registerInstallations();
680registerVersion(name, version);
681registerVersion(name, version, "esm2017");
682

683// node_modules/@firebase/analytics/dist/esm/index.esm2017.js
684var ANALYTICS_TYPE = "analytics";
685var GA_FID_KEY = "firebase_id";
686var ORIGIN_KEY = "origin";
687var FETCH_TIMEOUT_MILLIS = 60 * 1e3;
688var DYNAMIC_CONFIG_URL = "https://firebase.googleapis.com/v1alpha/projects/-/apps/{app-id}/webConfig";
689var GTAG_URL = "https://www.googletagmanager.com/gtag/js";
690var logger = new Logger("@firebase/analytics");
691var ERRORS = {
692  [
693    "already-exists"
694    /* AnalyticsError.ALREADY_EXISTS */
695  ]: "A Firebase Analytics instance with the appId {$id}  already exists. Only one Firebase Analytics instance can be created for each appId.",
696  [
697    "already-initialized"
698    /* AnalyticsError.ALREADY_INITIALIZED */
699  ]: "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.",
700  [
701    "already-initialized-settings"
702    /* AnalyticsError.ALREADY_INITIALIZED_SETTINGS */
703  ]: "Firebase Analytics has already been initialized.settings() must be called before initializing any Analytics instanceor it will have no effect.",
704  [
705    "interop-component-reg-failed"
706    /* AnalyticsError.INTEROP_COMPONENT_REG_FAILED */
707  ]: "Firebase Analytics Interop Component failed to instantiate: {$reason}",
708  [
709    "invalid-analytics-context"
710    /* AnalyticsError.INVALID_ANALYTICS_CONTEXT */
711  ]: "Firebase Analytics is not supported in this environment. Wrap initialization of analytics in analytics.isSupported() to prevent initialization in unsupported environments. Details: {$errorInfo}",
712  [
713    "indexeddb-unavailable"
714    /* AnalyticsError.INDEXEDDB_UNAVAILABLE */
715  ]: "IndexedDB unavailable or restricted in this environment. Wrap initialization of analytics in analytics.isSupported() to prevent initialization in unsupported environments. Details: {$errorInfo}",
716  [
717    "fetch-throttle"
718    /* AnalyticsError.FETCH_THROTTLE */
719  ]: "The config fetch request timed out while in an exponential backoff state. Unix timestamp in milliseconds when fetch request throttling ends: {$throttleEndTimeMillis}.",
720  [
721    "config-fetch-failed"
722    /* AnalyticsError.CONFIG_FETCH_FAILED */
723  ]: "Dynamic config fetch failed: [{$httpStatus}] {$responseMessage}",
724  [
725    "no-api-key"
726    /* AnalyticsError.NO_API_KEY */
727  ]: 'The "apiKey" field is empty in the local Firebase config. Firebase Analytics requires this field tocontain a valid API key.',
728  [
729    "no-app-id"
730    /* AnalyticsError.NO_APP_ID */
731  ]: 'The "appId" field is empty in the local Firebase config. Firebase Analytics requires this field tocontain a valid app ID.',
732  [
733    "no-client-id"
734    /* AnalyticsError.NO_CLIENT_ID */
735  ]: 'The "client_id" field is empty.',
736  [
737    "invalid-gtag-resource"
738    /* AnalyticsError.INVALID_GTAG_RESOURCE */
739  ]: "Trusted Types detected an invalid gtag resource: {$gtagURL}."
740};
741var ERROR_FACTORY2 = new ErrorFactory("analytics", "Analytics", ERRORS);
742function createGtagTrustedTypesScriptURL(url) {
743  if (!url.startsWith(GTAG_URL)) {
744    const err = ERROR_FACTORY2.create("invalid-gtag-resource", {
745      gtagURL: url
746    });
747    logger.warn(err.message);
748    return "";
749  }
750  return url;
751}
752function promiseAllSettled(promises) {
753  return Promise.all(promises.map((promise) => promise.catch((e) => e)));
754}
755function createTrustedTypesPolicy(policyName, policyOptions) {
756  let trustedTypesPolicy;
757  if (window.trustedTypes) {
758    trustedTypesPolicy = window.trustedTypes.createPolicy(policyName, policyOptions);
759  }
760  return trustedTypesPolicy;
761}
762function insertScriptTag(dataLayerName2, measurementId) {
763  const trustedTypesPolicy = createTrustedTypesPolicy("firebase-js-sdk-policy", {
764    createScriptURL: createGtagTrustedTypesScriptURL
765  });
766  const script = document.createElement("script");
767  const gtagScriptURL = `${GTAG_URL}?l=${dataLayerName2}&id=${measurementId}`;
768  script.src = trustedTypesPolicy ? trustedTypesPolicy === null || trustedTypesPolicy === void 0 ? void 0 : trustedTypesPolicy.createScriptURL(gtagScriptURL) : gtagScriptURL;
769  script.async = true;
770  document.head.appendChild(script);
771}
772function getOrCreateDataLayer(dataLayerName2) {
773  let dataLayer = [];
774  if (Array.isArray(window[dataLayerName2])) {
775    dataLayer = window[dataLayerName2];
776  } else {
777    window[dataLayerName2] = dataLayer;
778  }
779  return dataLayer;
780}
781function gtagOnConfig(gtagCore, initializationPromisesMap2, dynamicConfigPromisesList2, measurementIdToAppId2, measurementId, gtagParams) {
782  return __async(this, null, function* () {
783    const correspondingAppId = measurementIdToAppId2[measurementId];
784    try {
785      if (correspondingAppId) {
786        yield initializationPromisesMap2[correspondingAppId];
787      } else {
788        const dynamicConfigResults = yield promiseAllSettled(dynamicConfigPromisesList2);
789        const foundConfig = dynamicConfigResults.find((config) => config.measurementId === measurementId);
790        if (foundConfig) {
791          yield initializationPromisesMap2[foundConfig.appId];
792        }
793      }
794    } catch (e) {
795      logger.error(e);
796    }
797    gtagCore("config", measurementId, gtagParams);
798  });
799}
800function gtagOnEvent(gtagCore, initializationPromisesMap2, dynamicConfigPromisesList2, measurementId, gtagParams) {
801  return __async(this, null, function* () {
802    try {
803      let initializationPromisesToWaitFor = [];
804      if (gtagParams && gtagParams["send_to"]) {
805        let gaSendToList = gtagParams["send_to"];
806        if (!Array.isArray(gaSendToList)) {
807          gaSendToList = [gaSendToList];
808        }
809        const dynamicConfigResults = yield promiseAllSettled(dynamicConfigPromisesList2);
810        for (const sendToId of gaSendToList) {
811          const foundConfig = dynamicConfigResults.find((config) => config.measurementId === sendToId);
812          const initializationPromise = foundConfig && initializationPromisesMap2[foundConfig.appId];
813          if (initializationPromise) {
814            initializationPromisesToWaitFor.push(initializationPromise);
815          } else {
816            initializationPromisesToWaitFor = [];
817            break;
818          }
819        }
820      }
821      if (initializationPromisesToWaitFor.length === 0) {
822        initializationPromisesToWaitFor = Object.values(initializationPromisesMap2);
823      }
824      yield Promise.all(initializationPromisesToWaitFor);
825      gtagCore("event", measurementId, gtagParams || {});
826    } catch (e) {
827      logger.error(e);
828    }
829  });
830}
831function wrapGtag(gtagCore, initializationPromisesMap2, dynamicConfigPromisesList2, measurementIdToAppId2) {
832  function gtagWrapper(command, ...args) {
833    return __async(this, null, function* () {
834      try {
835        if (command === "event") {
836          const [measurementId, gtagParams] = args;
837          yield gtagOnEvent(gtagCore, initializationPromisesMap2, dynamicConfigPromisesList2, measurementId, gtagParams);
838        } else if (command === "config") {
839          const [measurementId, gtagParams] = args;
840          yield gtagOnConfig(gtagCore, initializationPromisesMap2, dynamicConfigPromisesList2, measurementIdToAppId2, measurementId, gtagParams);
841        } else if (command === "consent") {
842          const [consentAction, gtagParams] = args;
843          gtagCore("consent", consentAction, gtagParams);
844        } else if (command === "get") {
845          const [measurementId, fieldName, callback] = args;
846          gtagCore("get", measurementId, fieldName, callback);
847        } else if (command === "set") {
848          const [customParams] = args;
849          gtagCore("set", customParams);
850        } else {
851          gtagCore(command, ...args);
852        }
853      } catch (e) {
854        logger.error(e);
855      }
856    });
857  }
858  return gtagWrapper;
859}
860function wrapOrCreateGtag(initializationPromisesMap2, dynamicConfigPromisesList2, measurementIdToAppId2, dataLayerName2, gtagFunctionName) {
861  let gtagCore = function(..._args) {
862    window[dataLayerName2].push(arguments);
863  };
864  if (window[gtagFunctionName] && typeof window[gtagFunctionName] === "function") {
865    gtagCore = window[gtagFunctionName];
866  }
867  window[gtagFunctionName] = wrapGtag(gtagCore, initializationPromisesMap2, dynamicConfigPromisesList2, measurementIdToAppId2);
868  return {
869    gtagCore,
870    wrappedGtag: window[gtagFunctionName]
871  };
872}
873function findGtagScriptOnPage(dataLayerName2) {
874  const scriptTags = window.document.getElementsByTagName("script");
875  for (const tag of Object.values(scriptTags)) {
876    if (tag.src && tag.src.includes(GTAG_URL) && tag.src.includes(dataLayerName2)) {
877      return tag;
878    }
879  }
880  return null;
881}
882var LONG_RETRY_FACTOR = 30;
883var BASE_INTERVAL_MILLIS = 1e3;
884var RetryData = class {
885  constructor(throttleMetadata = {}, intervalMillis = BASE_INTERVAL_MILLIS) {
886    this.throttleMetadata = throttleMetadata;
887    this.intervalMillis = intervalMillis;
888  }
889  getThrottleMetadata(appId) {
890    return this.throttleMetadata[appId];
891  }
892  setThrottleMetadata(appId, metadata) {
893    this.throttleMetadata[appId] = metadata;
894  }
895  deleteThrottleMetadata(appId) {
896    delete this.throttleMetadata[appId];
897  }
898};
899var defaultRetryData = new RetryData();
900function getHeaders2(apiKey) {
901  return new Headers({
902    Accept: "application/json",
903    "x-goog-api-key": apiKey
904  });
905}
906function fetchDynamicConfig(appFields) {
907  return __async(this, null, function* () {
908    var _a;
909    const { appId, apiKey } = appFields;
910    const request = {
911      method: "GET",
912      headers: getHeaders2(apiKey)
913    };
914    const appUrl = DYNAMIC_CONFIG_URL.replace("{app-id}", appId);
915    const response = yield fetch(appUrl, request);
916    if (response.status !== 200 && response.status !== 304) {
917      let errorMessage = "";
918      try {
919        const jsonResponse = yield response.json();
920        if ((_a = jsonResponse.error) === null || _a === void 0 ? void 0 : _a.message) {
921          errorMessage = jsonResponse.error.message;
922        }
923      } catch (_ignored) {
924      }
925      throw ERROR_FACTORY2.create("config-fetch-failed", {
926        httpStatus: response.status,
927        responseMessage: errorMessage
928      });
929    }
930    return response.json();
931  });
932}
933function fetchDynamicConfigWithRetry(_0) {
934  return __async(this, arguments, function* (app, retryData = defaultRetryData, timeoutMillis) {
935    const { appId, apiKey, measurementId } = app.options;
936    if (!appId) {
937      throw ERROR_FACTORY2.create(
938        "no-app-id"
939        /* AnalyticsError.NO_APP_ID */
940      );
941    }
942    if (!apiKey) {
943      if (measurementId) {
944        return {
945          measurementId,
946          appId
947        };
948      }
949      throw ERROR_FACTORY2.create(
950        "no-api-key"
951        /* AnalyticsError.NO_API_KEY */
952      );
953    }
954    const throttleMetadata = retryData.getThrottleMetadata(appId) || {
955      backoffCount: 0,
956      throttleEndTimeMillis: Date.now()
957    };
958    const signal = new AnalyticsAbortSignal();
959    setTimeout(() => __async(null, null, function* () {
960      signal.abort();
961    }), timeoutMillis !== void 0 ? timeoutMillis : FETCH_TIMEOUT_MILLIS);
962    return attemptFetchDynamicConfigWithRetry({ appId, apiKey, measurementId }, throttleMetadata, signal, retryData);
963  });
964}
965function attemptFetchDynamicConfigWithRetry(_0, _1, _2) {
966  return __async(this, arguments, function* (appFields, { throttleEndTimeMillis, backoffCount }, signal, retryData = defaultRetryData) {
967    var _a;
968    const { appId, measurementId } = appFields;
969    try {
970      yield setAbortableTimeout(signal, throttleEndTimeMillis);
971    } catch (e) {
972      if (measurementId) {
973        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}]`);
974        return { appId, measurementId };
975      }
976      throw e;
977    }
978    try {
979      const response = yield fetchDynamicConfig(appFields);
980      retryData.deleteThrottleMetadata(appId);
981      return response;
982    } catch (e) {
983      const error = e;
984      if (!isRetriableError(error)) {
985        retryData.deleteThrottleMetadata(appId);
986        if (measurementId) {
987          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}]`);
988          return { appId, measurementId };
989        } else {
990          throw e;
991        }
992      }
993      const backoffMillis = Number((_a = error === null || error === void 0 ? void 0 : error.customData) === null || _a === void 0 ? void 0 : _a.httpStatus) === 503 ? calculateBackoffMillis(backoffCount, retryData.intervalMillis, LONG_RETRY_FACTOR) : calculateBackoffMillis(backoffCount, retryData.intervalMillis);
994      const throttleMetadata = {
995        throttleEndTimeMillis: Date.now() + backoffMillis,
996        backoffCount: backoffCount + 1
997      };
998      retryData.setThrottleMetadata(appId, throttleMetadata);
999      logger.debug(`Calling attemptFetch again in ${backoffMillis} millis`);
1000      return attemptFetchDynamicConfigWithRetry(appFields, throttleMetadata, signal, retryData);
1001    }
1002  });
1003}
1004function setAbortableTimeout(signal, throttleEndTimeMillis) {
1005  return new Promise((resolve, reject) => {
1006    const backoffMillis = Math.max(throttleEndTimeMillis - Date.now(), 0);
1007    const timeout = setTimeout(resolve, backoffMillis);
1008    signal.addEventListener(() => {
1009      clearTimeout(timeout);
1010      reject(ERROR_FACTORY2.create("fetch-throttle", {
1011        throttleEndTimeMillis
1012      }));
1013    });
1014  });
1015}
1016function isRetriableError(e) {
1017  if (!(e instanceof FirebaseError) || !e.customData) {
1018    return false;
1019  }
1020  const httpStatus = Number(e.customData["httpStatus"]);
1021  return httpStatus === 429 || httpStatus === 500 || httpStatus === 503 || httpStatus === 504;
1022}
1023var AnalyticsAbortSignal = class {
1024  constructor() {
1025    this.listeners = [];
1026  }
1027  addEventListener(listener) {
1028    this.listeners.push(listener);
1029  }
1030  abort() {
1031    this.listeners.forEach((listener) => listener());
1032  }
1033};
1034var defaultEventParametersForInit;
1035function logEvent$1(gtagFunction, initializationPromise, eventName, eventParams, options) {
1036  return __async(this, null, function* () {
1037    if (options && options.global) {
1038      gtagFunction("event", eventName, eventParams);
1039      return;
1040    } else {
1041      const measurementId = yield initializationPromise;
1042      const params = Object.assign(Object.assign({}, eventParams), { "send_to": measurementId });
1043      gtagFunction("event", eventName, params);
1044    }
1045  });
1046}
1047function setCurrentScreen$1(gtagFunction, initializationPromise, screenName, options) {
1048  return __async(this, null, function* () {
1049    if (options && options.global) {
1050      gtagFunction("set", { "screen_name": screenName });
1051      return Promise.resolve();
1052    } else {
1053      const measurementId = yield initializationPromise;
1054      gtagFunction("config", measurementId, {
1055        update: true,
1056        "screen_name": screenName
1057      });
1058    }
1059  });
1060}
1061function setUserId$1(gtagFunction, initializationPromise, id, options) {
1062  return __async(this, null, function* () {
1063    if (options && options.global) {
1064      gtagFunction("set", { "user_id": id });
1065      return Promise.resolve();
1066    } else {
1067      const measurementId = yield initializationPromise;
1068      gtagFunction("config", measurementId, {
1069        update: true,
1070        "user_id": id
1071      });
1072    }
1073  });
1074}
1075function setUserProperties$1(gtagFunction, initializationPromise, properties, options) {
1076  return __async(this, null, function* () {
1077    if (options && options.global) {
1078      const flatProperties = {};
1079      for (const key of Object.keys(properties)) {
1080        flatProperties[`user_properties.${key}`] = properties[key];
1081      }
1082      gtagFunction("set", flatProperties);
1083      return Promise.resolve();
1084    } else {
1085      const measurementId = yield initializationPromise;
1086      gtagFunction("config", measurementId, {
1087        update: true,
1088        "user_properties": properties
1089      });
1090    }
1091  });
1092}
1093function internalGetGoogleAnalyticsClientId(gtagFunction, initializationPromise) {
1094  return __async(this, null, function* () {
1095    const measurementId = yield initializationPromise;
1096    return new Promise((resolve, reject) => {
1097      gtagFunction("get", measurementId, "client_id", (clientId) => {
1098        if (!clientId) {
1099          reject(ERROR_FACTORY2.create(
1100            "no-client-id"
1101            /* AnalyticsError.NO_CLIENT_ID */
1102          ));
1103        }
1104        resolve(clientId);
1105      });
1106    });
1107  });
1108}
1109function setAnalyticsCollectionEnabled$1(initializationPromise, enabled) {
1110  return __async(this, null, function* () {
1111    const measurementId = yield initializationPromise;
1112    window[`ga-disable-${measurementId}`] = !enabled;
1113  });
1114}
1115var defaultConsentSettingsForInit;
1116function _setConsentDefaultForInit(consentSettings) {
1117  defaultConsentSettingsForInit = consentSettings;
1118}
1119function _setDefaultEventParametersForInit(customParams) {
1120  defaultEventParametersForInit = customParams;
1121}
1122function validateIndexedDB() {
1123  return __async(this, null, function* () {
1124    if (!isIndexedDBAvailable()) {
1125      logger.warn(ERROR_FACTORY2.create("indexeddb-unavailable", {
1126        errorInfo: "IndexedDB is not available in this environment."
1127      }).message);
1128      return false;
1129    } else {
1130      try {
1131        yield validateIndexedDBOpenable();
1132      } catch (e) {
1133        logger.warn(ERROR_FACTORY2.create("indexeddb-unavailable", {
1134          errorInfo: e === null || e === void 0 ? void 0 : e.toString()
1135        }).message);
1136        return false;
1137      }
1138    }
1139    return true;
1140  });
1141}
1142function _initializeAnalytics(app, dynamicConfigPromisesList2, measurementIdToAppId2, installations, gtagCore, dataLayerName2, options) {
1143  return __async(this, null, function* () {
1144    var _a;
1145    const dynamicConfigPromise = fetchDynamicConfigWithRetry(app);
1146    dynamicConfigPromise.then((config) => {
1147      measurementIdToAppId2[config.measurementId] = config.appId;
1148      if (app.options.measurementId && config.measurementId !== app.options.measurementId) {
1149        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.`);
1150      }
1151    }).catch((e) => logger.error(e));
1152    dynamicConfigPromisesList2.push(dynamicConfigPromise);
1153    const fidPromise = validateIndexedDB().then((envIsValid) => {
1154      if (envIsValid) {
1155        return installations.getId();
1156      } else {
1157        return void 0;
1158      }
1159    });
1160    const [dynamicConfig, fid] = yield Promise.all([
1161      dynamicConfigPromise,
1162      fidPromise
1163    ]);
1164    if (!findGtagScriptOnPage(dataLayerName2)) {
1165      insertScriptTag(dataLayerName2, dynamicConfig.measurementId);
1166    }
1167    if (defaultConsentSettingsForInit) {
1168      gtagCore("consent", "default", defaultConsentSettingsForInit);
1169      _setConsentDefaultForInit(void 0);
1170    }
1171    gtagCore("js", /* @__PURE__ */ new Date());
1172    const configProperties = (_a = options === null || options === void 0 ? void 0 : options.config) !== null && _a !== void 0 ? _a : {};
1173    configProperties[ORIGIN_KEY] = "firebase";
1174    configProperties.update = true;
1175    if (fid != null) {
1176      configProperties[GA_FID_KEY] = fid;
1177    }
1178    gtagCore("config", dynamicConfig.measurementId, configProperties);
1179    if (defaultEventParametersForInit) {
1180      gtagCore("set", defaultEventParametersForInit);
1181      _setDefaultEventParametersForInit(void 0);
1182    }
1183    return dynamicConfig.measurementId;
1184  });
1185}
1186var AnalyticsService = class {
1187  constructor(app) {
1188    this.app = app;
1189  }
1190  _delete() {
1191    delete initializationPromisesMap[this.app.options.appId];
1192    return Promise.resolve();
1193  }
1194};
1195var initializationPromisesMap = {};
1196var dynamicConfigPromisesList = [];
1197var measurementIdToAppId = {};
1198var dataLayerName = "dataLayer";
1199var gtagName = "gtag";
1200var gtagCoreFunction;
1201var wrappedGtagFunction;
1202var globalInitDone = false;
1203function settings(options) {
1204  if (globalInitDone) {
1205    throw ERROR_FACTORY2.create(
1206      "already-initialized"
1207      /* AnalyticsError.ALREADY_INITIALIZED */
1208    );
1209  }
1210  if (options.dataLayerName) {
1211    dataLayerName = options.dataLayerName;
1212  }
1213  if (options.gtagName) {
1214    gtagName = options.gtagName;
1215  }
1216}
1217function warnOnBrowserContextMismatch() {
1218  const mismatchedEnvMessages = [];
1219  if (isBrowserExtension()) {
1220    mismatchedEnvMessages.push("This is a browser extension environment.");
1221  }
1222  if (!areCookiesEnabled()) {
1223    mismatchedEnvMessages.push("Cookies are not available.");
1224  }
1225  if (mismatchedEnvMessages.length > 0) {
1226    const details = mismatchedEnvMessages.map((message, index) => `(${index + 1}) ${message}`).join(" ");
1227    const err = ERROR_FACTORY2.create("invalid-analytics-context", {
1228      errorInfo: details
1229    });
1230    logger.warn(err.message);
1231  }
1232}
1233function factory(app, installations, options) {
1234  warnOnBrowserContextMismatch();
1235  const appId = app.options.appId;
1236  if (!appId) {
1237    throw ERROR_FACTORY2.create(
1238      "no-app-id"
1239      /* AnalyticsError.NO_APP_ID */
1240    );
1241  }
1242  if (!app.options.apiKey) {
1243    if (app.options.measurementId) {
1244      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.`);
1245    } else {
1246      throw ERROR_FACTORY2.create(
1247        "no-api-key"
1248        /* AnalyticsError.NO_API_KEY */
1249      );
1250    }
1251  }
1252  if (initializationPromisesMap[appId] != null) {
1253    throw ERROR_FACTORY2.create("already-exists", {
1254      id: appId
1255    });
1256  }
1257  if (!globalInitDone) {
1258    getOrCreateDataLayer(dataLayerName);
1259    const { wrappedGtag, gtagCore } = wrapOrCreateGtag(initializationPromisesMap, dynamicConfigPromisesList, measurementIdToAppId, dataLayerName, gtagName);
1260    wrappedGtagFunction = wrappedGtag;
1261    gtagCoreFunction = gtagCore;
1262    globalInitDone = true;
1263  }
1264  initializationPromisesMap[appId] = _initializeAnalytics(app, dynamicConfigPromisesList, measurementIdToAppId, installations, gtagCoreFunction, dataLayerName, options);
1265  const analyticsInstance = new AnalyticsService(app);
1266  return analyticsInstance;
1267}
1268function getAnalytics(app = getApp()) {
1269  app = getModularInstance(app);
1270  const analyticsProvider = _getProvider(app, ANALYTICS_TYPE);
1271  if (analyticsProvider.isInitialized()) {
1272    return analyticsProvider.getImmediate();
1273  }
1274  return initializeAnalytics(app);
1275}
1276function initializeAnalytics(app, options = {}) {
1277  const analyticsProvider = _getProvider(app, ANALYTICS_TYPE);
1278  if (analyticsProvider.isInitialized()) {
1279    const existingInstance = analyticsProvider.getImmediate();
1280    if (deepEqual(options, analyticsProvider.getOptions())) {
1281      return existingInstance;
1282    } else {
1283      throw ERROR_FACTORY2.create(
1284        "already-initialized"
1285        /* AnalyticsError.ALREADY_INITIALIZED */
1286      );
1287    }
1288  }
1289  const analyticsInstance = analyticsProvider.initialize({ options });
1290  return analyticsInstance;
1291}
1292function isSupported() {
1293  return __async(this, null, function* () {
1294    if (isBrowserExtension()) {
1295      return false;
1296    }
1297    if (!areCookiesEnabled()) {
1298      return false;
1299    }
1300    if (!isIndexedDBAvailable()) {
1301      return false;
1302    }
1303    try {
1304      const isDBOpenable = yield validateIndexedDBOpenable();
1305      return isDBOpenable;
1306    } catch (error) {
1307      return false;
1308    }
1309  });
1310}
1311function setCurrentScreen(analyticsInstance, screenName, options) {
1312  analyticsInstance = getModularInstance(analyticsInstance);
1313  setCurrentScreen$1(wrappedGtagFunction, initializationPromisesMap[analyticsInstance.app.options.appId], screenName, options).catch((e) => logger.error(e));
1314}
1315function getGoogleAnalyticsClientId(analyticsInstance) {
1316  return __async(this, null, function* () {
1317    analyticsInstance = getModularInstance(analyticsInstance);
1318    return internalGetGoogleAnalyticsClientId(wrappedGtagFunction, initializationPromisesMap[analyticsInstance.app.options.appId]);
1319  });
1320}
1321function setUserId(analyticsInstance, id, options) {
1322  analyticsInstance = getModularInstance(analyticsInstance);
1323  setUserId$1(wrappedGtagFunction, initializationPromisesMap[analyticsInstance.app.options.appId], id, options).catch((e) => logger.error(e));
1324}
1325function setUserProperties(analyticsInstance, properties, options) {
1326  analyticsInstance = getModularInstance(analyticsInstance);
1327  setUserProperties$1(wrappedGtagFunction, initializationPromisesMap[analyticsInstance.app.options.appId], properties, options).catch((e) => logger.error(e));
1328}
1329function setAnalyticsCollectionEnabled(analyticsInstance, enabled) {
1330  analyticsInstance = getModularInstance(analyticsInstance);
1331  setAnalyticsCollectionEnabled$1(initializationPromisesMap[analyticsInstance.app.options.appId], enabled).catch((e) => logger.error(e));
1332}
1333function setDefaultEventParameters(customParams) {
1334  if (wrappedGtagFunction) {
1335    wrappedGtagFunction("set", customParams);
1336  } else {
1337    _setDefaultEventParametersForInit(customParams);
1338  }
1339}
1340function logEvent(analyticsInstance, eventName, eventParams, options) {
1341  analyticsInstance = getModularInstance(analyticsInstance);
1342  logEvent$1(wrappedGtagFunction, initializationPromisesMap[analyticsInstance.app.options.appId], eventName, eventParams, options).catch((e) => logger.error(e));
1343}
1344function setConsent(consentSettings) {
1345  if (wrappedGtagFunction) {
1346    wrappedGtagFunction("consent", "update", consentSettings);
1347  } else {
1348    _setConsentDefaultForInit(consentSettings);
1349  }
1350}
1351var name2 = "@firebase/analytics";
1352var version2 = "0.10.17";
1353function registerAnalytics() {
1354  _registerComponent(new Component(
1355    ANALYTICS_TYPE,
1356    (container, { options: analyticsOptions }) => {
1357      const app = container.getProvider("app").getImmediate();
1358      const installations = container.getProvider("installations-internal").getImmediate();
1359      return factory(app, installations, analyticsOptions);
1360    },
1361    "PUBLIC"
1362    /* ComponentType.PUBLIC */
1363  ));
1364  _registerComponent(new Component(
1365    "analytics-internal",
1366    internalFactory2,
1367    "PRIVATE"
1368    /* ComponentType.PRIVATE */
1369  ));
1370  registerVersion(name2, version2);
1371  registerVersion(name2, version2, "esm2017");
1372  function internalFactory2(container) {
1373    try {
1374      const analytics = container.getProvider(ANALYTICS_TYPE).getImmediate();
1375      return {
1376        logEvent: (eventName, eventParams, options) => logEvent(analytics, eventName, eventParams, options)
1377      };
1378    } catch (e) {
1379      throw ERROR_FACTORY2.create("interop-component-reg-failed", {
1380        reason: e
1381      });
1382    }
1383  }
1384}
1385registerAnalytics();
1386

1387// node_modules/@angular/fire/fesm2022/angular-fire-analytics.mjs
1388var Analytics = class {
1389  constructor(analytics) {
1390    return analytics;
1391  }
1392};
1393var ANALYTICS_PROVIDER_NAME = "analytics";
1394var AnalyticsInstances = class {
1395  constructor() {
1396    return \u0275getAllInstancesOf(ANALYTICS_PROVIDER_NAME);
1397  }
1398};
1399var analyticInstance$ = timer(0, 300).pipe(concatMap(() => from(\u0275getAllInstancesOf(ANALYTICS_PROVIDER_NAME))), distinct());
1400var getAnalytics2 = \u0275zoneWrap(getAnalytics, true);
1401var getGoogleAnalyticsClientId2 = \u0275zoneWrap(getGoogleAnalyticsClientId, true);
1402var initializeAnalytics2 = \u0275zoneWrap(initializeAnalytics, true);
1403var isSupported2 = \u0275zoneWrap(isSupported, false);
1404var logEvent2 = \u0275zoneWrap(logEvent, false, 2);
1405var setAnalyticsCollectionEnabled2 = \u0275zoneWrap(setAnalyticsCollectionEnabled, true, 2);
1406var setConsent2 = \u0275zoneWrap(setConsent, true, 2);
1407var setCurrentScreen2 = \u0275zoneWrap(setCurrentScreen, true, 2);
1408var setDefaultEventParameters2 = \u0275zoneWrap(setDefaultEventParameters, true, 2);
1409var setUserId2 = \u0275zoneWrap(setUserId, true, 2);
1410var setUserProperties2 = \u0275zoneWrap(setUserProperties, true, 2);
1411var settings2 = \u0275zoneWrap(settings, true);
1412var UserTrackingService = class _UserTrackingService {
1413  initialized;
1414  disposables = [];
1415  constructor(auth, zone, injector) {
1416    registerVersion("angularfire", VERSION.full, "user-tracking");
1417    let resolveInitialized;
1418    this.initialized = zone.runOutsideAngular(() => new Promise((resolve) => {
1419      resolveInitialized = resolve;
1420    }));
1421    isSupported2().then(() => {
1422      const analytics = injector.get(Analytics);
1423      if (analytics) {
1424        this.disposables = [
1425          // TODO add credential tracking back in
1426          authState(auth).subscribe((user) => {
1427            setUserId2(analytics, user?.uid);
1428            resolveInitialized();
1429          })
1430        ];
1431      } else {
1432        resolveInitialized();
1433      }
1434    });
1435  }
1436  ngOnDestroy() {
1437    this.disposables.forEach((it) => it.unsubscribe());
1438  }
1439  static \u0275fac = function UserTrackingService_Factory(__ngFactoryType__) {
1440    return new (__ngFactoryType__ || _UserTrackingService)(\u0275\u0275inject(Auth), \u0275\u0275inject(NgZone), \u0275\u0275inject(Injector));
1441  };
1442  static \u0275prov = /* @__PURE__ */ \u0275\u0275defineInjectable({
1443    token: _UserTrackingService,
1444    factory: _UserTrackingService.\u0275fac
1445  });
1446};
1447(() => {
1448  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(UserTrackingService, [{
1449    type: Injectable
1450  }], () => [{
1451    type: Auth
1452  }, {
1453    type: NgZone
1454  }, {
1455    type: Injector
1456  }], null);
1457})();
1458var FIREBASE_EVENT_ORIGIN_KEY = "firebase_event_origin";
1459var FIREBASE_PREVIOUS_SCREEN_CLASS_KEY = "firebase_previous_class";
1460var FIREBASE_PREVIOUS_SCREEN_INSTANCE_ID_KEY = "firebase_previous_id";
1461var FIREBASE_PREVIOUS_SCREEN_NAME_KEY = "firebase_previous_screen";
1462var FIREBASE_SCREEN_CLASS_KEY = "firebase_screen_class";
1463var FIREBASE_SCREEN_INSTANCE_ID_KEY = "firebase_screen_id";
1464var FIREBASE_SCREEN_NAME_KEY = "firebase_screen";
1465var OUTLET_KEY = "outlet";
1466var PAGE_PATH_KEY = "page_path";
1467var PAGE_TITLE_KEY = "page_title";
1468var SCREEN_CLASS_KEY = "screen_class";
1469var SCREEN_NAME_KEY = "screen_name";
1470var SCREEN_VIEW_EVENT = "screen_view";
1471var EVENT_ORIGIN_AUTO = "auto";
1472var SCREEN_INSTANCE_DELIMITER = "#";
1473var nextScreenInstanceID = Math.floor(Math.random() * (2 ** 32 - 1)) - 2 ** 31;
1474var knownScreenInstanceIDs = {};
1475var getScreenInstanceID = (params) => {
1476  const screenInstanceKey = [params[SCREEN_CLASS_KEY], params[OUTLET_KEY]].join(SCREEN_INSTANCE_DELIMITER);
1477  if (knownScreenInstanceIDs.hasOwnProperty(screenInstanceKey)) {
1478    return knownScreenInstanceIDs[screenInstanceKey];
1479  } else {
1480    const ret = nextScreenInstanceID++;
1481    knownScreenInstanceIDs[screenInstanceKey] = ret;
1482    return ret;
1483  }
1484};
1485var \u0275screenViewEvent = (router, title, componentFactoryResolver) => {
1486  const activationEndEvents = router.events.pipe(filter((e) => e instanceof ActivationEnd));
1487  return activationEndEvents.pipe(switchMap((activationEnd) => {
1488    const urlTree = router.parseUrl(router.url.replace(/(?:\().+(?:\))/g, (a) => a.replace("://", ":///")));
1489    const pagePath = urlTree.root.children[activationEnd.snapshot.outlet]?.toString() || "";
1490    const actualSnapshot = router.routerState.root.children.map((it) => it).find((it) => it.outlet === activationEnd.snapshot.outlet);
1491    if (!actualSnapshot) {
1492      return of(null);
1493    }
1494    let actualDeep = actualSnapshot;
1495    while (actualDeep.firstChild) {
1496      actualDeep = actualDeep.firstChild;
1497    }
1498    const screenName = actualDeep.pathFromRoot.map((s) => s.routeConfig?.path).filter((it) => it).join("/") || "/";
1499    const params = {
1500      [SCREEN_NAME_KEY]: screenName,
1501      [PAGE_PATH_KEY]: `/${pagePath}`,
1502      [FIREBASE_EVENT_ORIGIN_KEY]: EVENT_ORIGIN_AUTO,
1503      [FIREBASE_SCREEN_NAME_KEY]: screenName,
1504      [OUTLET_KEY]: activationEnd.snapshot.outlet
1505    };
1506    if (title) {
1507      params[PAGE_TITLE_KEY] = title.getTitle();
1508    }
1509    let component = actualSnapshot.component;
1510    if (component) {
1511      if (component === \u0275EmptyOutletComponent) {
1512        let deepSnapshot = activationEnd.snapshot;
1513        while (deepSnapshot.firstChild) {
1514          deepSnapshot = deepSnapshot.firstChild;
1515        }
1516        component = deepSnapshot.component;
1517      }
1518    } else {
1519      component = activationEnd.snapshot.component;
1520    }
1521    if (typeof component === "string") {
1522      return of(__spreadProps(__spreadValues({}, params), {
1523        [SCREEN_CLASS_KEY]: component
1524      }));
1525    } else if (component) {
1526      const componentFactory = componentFactoryResolver.resolveComponentFactory(component);
1527      return of(__spreadProps(__spreadValues({}, params), {
1528        [SCREEN_CLASS_KEY]: componentFactory.selector
1529      }));
1530    }
1531    return of(null);
1532  }), filter((it) => !!it), map((params) => __spreadValues({
1533    [FIREBASE_SCREEN_CLASS_KEY]: params[SCREEN_CLASS_KEY],
1534    [FIREBASE_SCREEN_INSTANCE_ID_KEY]: getScreenInstanceID(params)
1535  }, params)), groupBy((it) => it[OUTLET_KEY]), mergeMap((it) => it.pipe(distinctUntilChanged((a, b) => JSON.stringify(a) === JSON.stringify(b)), startWith(void 0), pairwise(), map(([prior, current]) => prior ? __spreadValues({
1536    [FIREBASE_PREVIOUS_SCREEN_CLASS_KEY]: prior[SCREEN_CLASS_KEY],
1537    [FIREBASE_PREVIOUS_SCREEN_NAME_KEY]: prior[SCREEN_NAME_KEY],
1538    [FIREBASE_PREVIOUS_SCREEN_INSTANCE_ID_KEY]: prior[FIREBASE_SCREEN_INSTANCE_ID_KEY]
1539  }, current) : current))));
1540};
1541var ScreenTrackingService = class _ScreenTrackingService {
1542  disposable;
1543  constructor(router, title, componentFactoryResolver, zone, userTrackingService, injector) {
1544    registerVersion("angularfire", VERSION.full, "screen-tracking");
1545    isSupported2().then(() => {
1546      const analytics = injector.get(Analytics);
1547      if (!router || !analytics) {
1548        return;
1549      }
1550      zone.runOutsideAngular(() => {
1551        this.disposable = \u0275screenViewEvent(router, title, componentFactoryResolver).pipe(switchMap((params) => __async(this, null, function* () {
1552          if (userTrackingService) {
1553            yield userTrackingService.initialized;
1554          }
1555          return logEvent2(analytics, SCREEN_VIEW_EVENT, params);
1556        }))).subscribe();
1557      });
1558    });
1559  }
1560  ngOnDestroy() {
1561    if (this.disposable) {
1562      this.disposable.unsubscribe();
1563    }
1564  }
1565  static \u0275fac = function ScreenTrackingService_Factory(__ngFactoryType__) {
1566    return new (__ngFactoryType__ || _ScreenTrackingService)(\u0275\u0275inject(Router, 8), \u0275\u0275inject(Title, 8), \u0275\u0275inject(ComponentFactoryResolver$1), \u0275\u0275inject(NgZone), \u0275\u0275inject(UserTrackingService, 8), \u0275\u0275inject(Injector));
1567  };
1568  static \u0275prov = /* @__PURE__ */ \u0275\u0275defineInjectable({
1569    token: _ScreenTrackingService,
1570    factory: _ScreenTrackingService.\u0275fac
1571  });
1572};
1573(() => {
1574  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(ScreenTrackingService, [{
1575    type: Injectable
1576  }], () => [{
1577    type: Router,
1578    decorators: [{
1579      type: Optional
1580    }]
1581  }, {
1582    type: Title,
1583    decorators: [{
1584      type: Optional
1585    }]
1586  }, {
1587    type: ComponentFactoryResolver$1
1588  }, {
1589    type: NgZone
1590  }, {
1591    type: UserTrackingService,
1592    decorators: [{
1593      type: Optional
1594    }]
1595  }, {
1596    type: Injector
1597  }], null);
1598})();
1599var PROVIDED_ANALYTICS_INSTANCES = new InjectionToken("angularfire2.analytics-instances");
1600function defaultAnalyticsInstanceFactory(provided, defaultApp, platformId) {
1601  if (!isPlatformBrowser(platformId)) {
1602    return null;
1603  }
1604  const defaultAnalytics = \u0275getDefaultInstanceOf(ANALYTICS_PROVIDER_NAME, provided, defaultApp);
1605  return defaultAnalytics && new Analytics(defaultAnalytics);
1606}
1607function analyticsInstanceFactory(fn) {
1608  return (zone, injector, platformId) => {
1609    if (!isPlatformBrowser(platformId)) {
1610      return null;
1611    }
1612    const analytics = zone.runOutsideAngular(() => fn(injector));
1613    return new Analytics(analytics);
1614  };
1615}
1616var ANALYTICS_INSTANCES_PROVIDER = {
1617  provide: AnalyticsInstances,
1618  deps: [[new Optional(), PROVIDED_ANALYTICS_INSTANCES]]
1619};
1620var DEFAULT_ANALYTICS_INSTANCE_PROVIDER = {
1621  provide: Analytics,
1622  useFactory: defaultAnalyticsInstanceFactory,
1623  deps: [[new Optional(), PROVIDED_ANALYTICS_INSTANCES], FirebaseApp, PLATFORM_ID]
1624};
1625var AnalyticsModule = class _AnalyticsModule {
1626  constructor(_screenTrackingService, _userTrackingService) {
1627    registerVersion("angularfire", VERSION.full, "analytics");
1628  }
1629  static \u0275fac = function AnalyticsModule_Factory(__ngFactoryType__) {
1630    return new (__ngFactoryType__ || _AnalyticsModule)(\u0275\u0275inject(ScreenTrackingService, 8), \u0275\u0275inject(UserTrackingService, 8));
1631  };
1632  static \u0275mod = /* @__PURE__ */ \u0275\u0275defineNgModule({
1633    type: _AnalyticsModule
1634  });
1635  static \u0275inj = /* @__PURE__ */ \u0275\u0275defineInjector({
1636    providers: [DEFAULT_ANALYTICS_INSTANCE_PROVIDER, ANALYTICS_INSTANCES_PROVIDER]
1637  });
1638};
1639(() => {
1640  (typeof ngDevMode === "undefined" || ngDevMode) && setClassMetadata(AnalyticsModule, [{
1641    type: NgModule,
1642    args: [{
1643      providers: [DEFAULT_ANALYTICS_INSTANCE_PROVIDER, ANALYTICS_INSTANCES_PROVIDER]
1644    }]
1645  }], () => [{
1646    type: ScreenTrackingService,
1647    decorators: [{
1648      type: Optional
1649    }]
1650  }, {
1651    type: UserTrackingService,
1652    decorators: [{
1653      type: Optional
1654    }]
1655  }], null);
1656})();
1657function provideAnalytics(fn, ...deps) {
1658  registerVersion("angularfire", VERSION.full, "analytics");
1659  return makeEnvironmentProviders([DEFAULT_ANALYTICS_INSTANCE_PROVIDER, ANALYTICS_INSTANCES_PROVIDER, {
1660    provide: PROVIDED_ANALYTICS_INSTANCES,
1661    useFactory: analyticsInstanceFactory(fn),
1662    multi: true,
1663    deps: [NgZone, Injector, PLATFORM_ID, \u0275AngularFireSchedulers, FirebaseApps, ...deps]
1664  }]);
1665}
1666
1667export {
1668  Analytics,
1669  getAnalytics2 as getAnalytics,
1670  logEvent2 as logEvent,
1671  UserTrackingService,
1672  ScreenTrackingService,
1673  provideAnalytics
1674};
1675/*! Bundled license information:
1676
1677@firebase/installations/dist/esm/index.esm2017.js:
1678@firebase/installations/dist/esm/index.esm2017.js:
1679@firebase/installations/dist/esm/index.esm2017.js:
1680@firebase/installations/dist/esm/index.esm2017.js:
1681  (**
1682   * @license
1683   * Copyright 2019 Google LLC
1684   *
1685   * Licensed under the Apache License, Version 2.0 (the "License");
1686   * you may not use this file except in compliance with the License.
1687   * You may obtain a copy of the License at
1688   *
1689   *   http://www.apache.org/licenses/LICENSE-2.0
1690   *
1691   * Unless required by applicable law or agreed to in writing, software
1692   * distributed under the License is distributed on an "AS IS" BASIS,
1693   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
1694   * See the License for the specific language governing permissions and
1695   * limitations under the License.
1696   *)
1697
1698@firebase/installations/dist/esm/index.esm2017.js:
1699  (**
1700   * @license
1701   * Copyright 2020 Google LLC
1702   *
1703   * Licensed under the Apache License, Version 2.0 (the "License");
1704   * you may not use this file except in compliance with the License.
1705   * You may obtain a copy of the License at
1706   *
1707   *   http://www.apache.org/licenses/LICENSE-2.0
1708   *
1709   * Unless required by applicable law or agreed to in writing, software
1710   * distributed under the License is distributed on an "AS IS" BASIS,
1711   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
1712   * See the License for the specific language governing permissions and
1713   * limitations under the License.
1714   *)
1715
1716@firebase/installations/dist/esm/index.esm2017.js:
1717@firebase/analytics/dist/esm/index.esm2017.js:
1718  (**
1719   * @license
1720   * Copyright 2019 Google LLC
1721   *
1722   * Licensed under the Apache License, Version 2.0 (the "License");
1723   * you may not use this file except in compliance with the License.
1724   * You may obtain a copy of the License at
1725   *
1726   *   http://www.apache.org/licenses/LICENSE-2.0
1727   *
1728   * Unless required by applicable law or agreed to in writing, software
1729   * distributed under the License is distributed on an "AS IS" BASIS,
1730   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
1731   * See the License for the specific language governing permissions and
1732   * limitations under the License.
1733   *)
1734  (**
1735   * @license
1736   * Copyright 2020 Google LLC
1737   *
1738   * Licensed under the Apache License, Version 2.0 (the "License");
1739   * you may not use this file except in compliance with the License.
1740   * You may obtain a copy of the License at
1741   *
1742   *   http://www.apache.org/licenses/LICENSE-2.0
1743   *
1744   * Unless required by applicable law or agreed to in writing, software
1745   * distributed under the License is distributed on an "AS IS" BASIS,
1746   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
1747   * See the License for the specific language governing permissions and
1748   * limitations under the License.
1749   *)
1750*/
1751//# sourceMappingURL=chunk-67BET6PV.js.map