gather-vue 8.6.0

package/dist/index-BDyGxL1x.js

@@ -0,0 +1,255 @@
+var k = Object.defineProperty;
+var w = (r) => {
+  throw TypeError(r);
+};
+var q = (r, e, t) => e in r ? k(r, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : r[e] = t;
+var D = (r, e, t) => q(r, typeof e != "symbol" ? e + "" : e, t), F = (r, e, t) => e.has(r) || w("Cannot " + t);
+var a = (r, e, t) => (F(r, e, "read from private field"), t ? t.call(r) : e.get(r)), T = (r, e, t) => e.has(r) ? w("Cannot add the same private member more than once") : e instanceof WeakSet ? e.add(r) : e.set(r, t), c = (r, e, t, i) => (F(r, e, "write to private field"), i ? i.call(r, t) : e.set(r, t), t);
+import { T as C, y as d, U as g, V as N, d as O, W as P, r as v, i as K, B as R, t as M, z as b, v as S, X as L } from "./main-DPldah1M.js";
+import { a as x, b as A } from "./nav-timing-B-TNQpyK.js";
+import { A as W } from "./aggregate-base-C6N8Ymd5.js";
+import { f as G, a as U } from "./first-paint-B61SrVKm.js";
+import { t as I } from "./time-to-first-byte-kiwh1xjs.js";
+import { a as z } from "./traverse-Bw4y1x4D.js";
+function H(r) {
+  const e = [], t = C();
+  try {
+    Object.keys(t.initializedAgents[r].features).forEach((i) => {
+      switch (i) {
+        case d.ajax:
+          e.push("xhr");
+          break;
+        case d.jserrors:
+          e.push("err");
+          break;
+        case d.genericEvents:
+          e.push("ins");
+          break;
+        case d.sessionTrace:
+          e.push("stn");
+          break;
+        case d.softNav:
+        case d.spa:
+          e.push("spa");
+          break;
+      }
+    });
+  } catch {
+  }
+  return e;
+}
+var y, h, m, u;
+class V {
+  constructor(e) {
+    /**
+     * Pointer to the current agent session if it exists.
+     * @type {import('../session/session-entity').SessionEntity}
+     */
+    T(this, y);
+    /**
+     * Represents the browser origin time corrected to NR server time.
+     * @type {number}
+     */
+    T(this, h);
+    /**
+     * Represents the difference in milliseconds between the calculated NR server time and
+     * the local time.
+     * @type {number}
+     */
+    T(this, m);
+    /**
+     * Represents whether the timekeeper is in a state that it can accurately convert
+     * timestamps.
+     * @type {boolean}
+     */
+    T(this, u, !1);
+    c(this, y, e), this.processStoredDiff();
+  }
+  get ready() {
+    return a(this, u);
+  }
+  get correctedOriginTime() {
+    return a(this, h);
+  }
+  get localTimeDiff() {
+    return a(this, m);
+  }
+  /**
+   * Process a rum request to calculate NR server time.
+   * @param rumRequest {XMLHttpRequest} The xhr for the rum request
+   * @param startTime {number} The start time of the RUM request
+   * @param endTime {number} The end time of the RUM request
+   * @param nrServerTime {number} the unix number value of the NR server time in MS, returned in the RUM request body
+   */
+  processRumRequest(e, t, i, s) {
+    var f;
+    if (this.processStoredDiff(), a(this, u)) return;
+    if (!s) throw new Error("nrServerTime not found");
+    const n = (i - t) / 2, o = t + n;
+    if (c(this, h, Math.floor(s - o)), c(this, m, g - a(this, h)), isNaN(a(this, h)))
+      throw new Error("Failed to correct browser time to server time");
+    (f = a(this, y)) == null || f.write({
+      serverTimeDiff: a(this, m)
+    }), c(this, u, !0);
+  }
+  /**
+   * Converts a page origin relative time to an absolute timestamp
+   * using the user's local clock.
+   * @param relativeTime {number} The relative time of the event in milliseconds
+   * @returns {number} Corrected unix/epoch timestamp
+   */
+  convertRelativeTimestamp(e) {
+    return g + e;
+  }
+  /**
+   * Converts an absolute timestamp to a relative timestamp using the
+   * user's local clock.
+   * @param timestamp
+   * @returns {number}
+   */
+  convertAbsoluteTimestamp(e) {
+    return e - g;
+  }
+  /**
+   * Corrects an absolute timestamp to NR server time.
+   * @param timestamp {number} The unix/epoch timestamp of the event with milliseconds
+   * @return {number} Corrected unix/epoch timestamp
+   */
+  correctAbsoluteTimestamp(e) {
+    return e - a(this, m);
+  }
+  /**
+   * Corrects relative timestamp to NR server time (epoch).
+   * @param {DOMHighResTimeStamp} relativeTime
+   * @returns {number}
+   */
+  correctRelativeTimestamp(e) {
+    return this.correctAbsoluteTimestamp(this.convertRelativeTimestamp(e));
+  }
+  /** Process the session entity and use the info to set the main time calculations if present */
+  processStoredDiff() {
+    var t, i;
+    if (a(this, u)) return;
+    const e = (i = (t = a(this, y)) == null ? void 0 : t.read()) == null ? void 0 : i.serverTimeDiff;
+    typeof e == "number" && !isNaN(e) && (c(this, m, e), c(this, h, g - a(this, m)), c(this, u, !0));
+  }
+}
+y = new WeakMap(), h = new WeakMap(), m = new WeakMap(), u = new WeakMap();
+class _ extends W {
+  constructor(e) {
+    if (super(e, N), this.timeToFirstByte = 0, this.firstByteToWindowLoad = 0, this.firstByteToDomContent = 0, O("send-rum", (t, i) => {
+      this.sendRum(t, i);
+    }, this.featureName, this.ee), !P(e.info))
+      return this.ee.abort(), v(43);
+    e.runtime.timeKeeper = new V(e.runtime.session), K ? I.subscribe(({
+      value: t,
+      attrs: i
+    }) => {
+      const s = i.navigationEntry;
+      this.timeToFirstByte = Math.max(t, this.timeToFirstByte), this.firstByteToWindowLoad = Math.max(Math.round(s.loadEventEnd - this.timeToFirstByte), this.firstByteToWindowLoad), this.firstByteToDomContent = Math.max(Math.round(s.domContentLoadedEventEnd - this.timeToFirstByte), this.firstByteToDomContent), this.sendRum();
+    }) : this.sendRum();
+  }
+  /**
+   *
+   * @param {Function} cb A function to run once the RUM call has finished - Defaults to activateFeatures
+   * @param {*} customAttributes custom attributes to attach to the RUM call - Defaults to info.js
+   * @param {*} target The target to harvest to - Since we will not know the entityGuid before harvesting, this must be an object directly supplied from the info object or API, not an entityGuid string for lookup with the entityManager - Defaults to { licenseKey: this.agentRef.info.licenseKey, applicationID: this.agentRef.info.applicationID }
+   */
+  sendRum(e = this.agentRef.info.jsAttributes, t = {
+    licenseKey: this.agentRef.info.licenseKey,
+    applicationID: this.agentRef.info.applicationID
+  }) {
+    var p, E, B;
+    const i = this.agentRef.info, s = {};
+    i.queueTime && (s.qt = i.queueTime), i.applicationTime && (s.ap = i.applicationTime), s.be = this.timeToFirstByte, s.fe = this.firstByteToWindowLoad, s.dc = this.firstByteToDomContent;
+    const n = {
+      tt: i.ttGuid,
+      us: i.user,
+      ac: i.account,
+      pr: i.product,
+      af: H(this.agentIdentifier).join(","),
+      ...s,
+      xx: i.extra,
+      ua: i.userAttributes,
+      at: i.atts
+    };
+    this.agentRef.runtime.session && (n.fsh = Number(this.agentRef.runtime.session.isNew));
+    let o;
+    if (typeof e == "object" && Object.keys(e).length > 0 && (o = z({
+      ja: e
+    }, this.obfuscator.obfuscateString.bind(this.obfuscator), "string")), R.performance) {
+      if (typeof PerformanceNavigationTiming < "u") {
+        const l = (B = (E = (p = R) == null ? void 0 : p.performance) == null ? void 0 : E.getEntriesByType("navigation")) == null ? void 0 : B[0], j = {
+          timing: A(g, l, {}),
+          navigation: x(l, {})
+        };
+        n.perf = M(j);
+      } else if (typeof PerformanceTiming < "u") {
+        const l = {
+          timing: A(g, R.performance.timing, {}, !0),
+          navigation: x(R.performance.navigation, {})
+        };
+        n.perf = M(l);
+      }
+    }
+    n.fp = G.current.value, n.fcp = U.current.value;
+    const f = this.agentRef.runtime.timeKeeper;
+    f != null && f.ready && (n.timestamp = Math.floor(f.correctRelativeTimestamp(b()))), this.rumStartTime = b(), this.agentRef.runtime.harvester.triggerHarvestFor(this, {
+      directSend: {
+        targetApp: t,
+        payload: {
+          qs: n,
+          body: o
+        }
+      },
+      needResponse: !0,
+      sendEmptyBody: !0
+    });
+  }
+  postHarvestCleanup({
+    status: e,
+    responseText: t,
+    xhr: i,
+    targetApp: s
+  }) {
+    const n = b();
+    let o, f;
+    try {
+      ({
+        app: o,
+        ...f
+      } = JSON.parse(t)), this.processEntities(o.agents, s);
+    } catch (p) {
+      v(53, p);
+    }
+    if (S(s, this.agentRef)) {
+      if (e >= 400 || e === 0) {
+        v(18, e), this.ee.abort();
+        return;
+      }
+      try {
+        if (this.agentRef.runtime.timeKeeper.processRumRequest(i, this.rumStartTime, n, o.nrServerTime), !this.agentRef.runtime.timeKeeper.ready) throw new Error("TimeKeeper not ready");
+      } catch (p) {
+        this.ee.abort(), v(17, p);
+        return;
+      }
+      Object.keys(this.agentRef.runtime.appMetadata).length || (this.agentRef.runtime.appMetadata = o), this.drain(), this.agentRef.runtime.harvester.startTimer(), L(f, this.agentRef);
+    }
+  }
+  processEntities(e, t) {
+    !e || !t || e.forEach((i) => {
+      const s = this.agentRef.runtime.entityManager, n = i.entityGuid;
+      s.get(n) || (S(t, this.agentRef) && s.setDefaultEntity({
+        ...t,
+        entityGuid: n
+      }), s.set(i.entityGuid, {
+        ...t,
+        entityGuid: n
+      }));
+    });
+  }
+}
+D(_, "featureName", N);
+export {
+  _ as Aggregate
+};

package/dist/index-BF9haAFD.js

@@ -0,0 +1,343 @@
+var H = Object.defineProperty;
+var P = (t) => {
+  throw TypeError(t);
+};
+var K = (t, e, i) => e in t ? H(t, e, { enumerable: !0, configurable: !0, writable: !0, value: i }) : t[e] = i;
+var _ = (t, e, i) => K(t, typeof e != "symbol" ? e + "" : e, i), C = (t, e, i) => e.has(t) || P("Cannot " + i);
+var y = (t, e, i) => (C(t, e, "read from private field"), i ? i.call(t) : e.get(t)), M = (t, e, i) => e.has(t) ? P("Cannot add the same private member more than once") : e instanceof WeakSet ? e.add(t) : e.set(t, i), E = (t, e, i, n) => (C(t, e, "write to private field"), n ? n.call(t, i) : e.set(t, i), i);
+import { aS as A, aT as L, aU as O, aV as N, i as S, d as v, aW as B, r as R, B as I, t as V, z as W, S as x, j as G } from "./main-DPldah1M.js";
+import { c as b, A as j } from "./aggregate-base-C6N8Ymd5.js";
+import { a as F } from "./traverse-Bw4y1x4D.js";
+import { i as U } from "./iframe-BELrOJ1p.js";
+import { i as D } from "./type-check-Bp684oBR.js";
+const z = (t, e = []) => {
+  if (!t) return {
+    path: void 0,
+    nearestFields: {}
+  };
+  const i = (s) => {
+    try {
+      let u = 1;
+      const {
+        tagName: f
+      } = s;
+      for (; s.previousElementSibling; )
+        s.previousElementSibling.tagName === f && u++, s = s.previousElementSibling;
+      return u;
+    } catch {
+    }
+  };
+  let n = "", l = i(t);
+  const r = {};
+  try {
+    for (; t != null && t.tagName; ) {
+      const {
+        id: s,
+        localName: u
+      } = t;
+      e.forEach((o) => {
+        var h, p;
+        r[p = c(o)] || (r[p] = ((h = t[o]) == null ? void 0 : h.baseVal) || t[o]);
+      }), n = [u, s ? "#".concat(s) : "", n ? ">".concat(n) : ""].join(""), t = t.parentNode;
+    }
+  } catch {
+  }
+  return {
+    path: n ? l ? "".concat(n, ":nth-of-type(").concat(l, ")") : n : void 0,
+    nearestFields: r
+  };
+  function c(s) {
+    return s === "tagName" && (s = "tag"), s === "className" && (s = "class"), "nearest".concat(s.charAt(0).toUpperCase() + s.slice(1));
+  }
+};
+class Y {
+  constructor(e, i, n) {
+    this.event = e, this.count = 1, this.originMs = Math.floor(e.timeStamp), this.relativeMs = [0], this.selectorPath = i, this.rageClick = void 0, this.nearestTargetFields = n, this.currentUrl = b("" + location);
+  }
+  /**
+   * Aggregates the count and maintains the relative MS array for matching events
+   * Will determine if a rage click was observed as part of the aggregation
+   * @param {Event} evt
+   * @returns {void}
+   */
+  aggregate(e) {
+    this.count++, this.relativeMs.push(Math.floor(e.timeStamp - this.originMs)), this.isRageClick() && (this.rageClick = !0);
+  }
+  /**
+   * Determines if the current set of relative ms values constitutes a rage click
+   * @returns {boolean}
+   */
+  isRageClick() {
+    const e = this.relativeMs.length;
+    return this.event.type === "click" && e >= A && this.relativeMs[e - 1] - this.relativeMs[e - A] < L;
+  }
+}
+var m, g;
+class q {
+  constructor() {
+    /** @type {AggregatedUserAction=} */
+    M(this, m);
+    M(this, g, "");
+  }
+  get aggregationEvent() {
+    const e = y(this, m);
+    return E(this, g, ""), E(this, m, void 0), e;
+  }
+  /**
+   * Process the event and determine if a new aggregation set should be made or if it should increment the current aggregation
+   * @param {Event} evt The event supplied by the addEventListener callback
+   * @returns {AggregatedUserAction|undefined} The previous aggregation set if it has been completed by processing the current event
+   */
+  process(e, i) {
+    if (!e) return;
+    const {
+      selectorPath: n,
+      nearestTargetFields: l
+    } = Q(e, i), r = X(e, n);
+    if (r && r === y(this, g))
+      y(this, m).aggregate(e);
+    else {
+      const a = y(this, m);
+      return E(this, g, r), E(this, m, new Y(e, n, l)), a;
+    }
+  }
+}
+m = new WeakMap(), g = new WeakMap();
+function Q(t, e) {
+  let i, n = {};
+  if (O.includes(t.type) || t.target === window) i = "window";
+  else if (t.target === document) i = "document";
+  else {
+    const {
+      path: l,
+      nearestFields: r
+    } = z(t.target, e);
+    i = l, n = r;
+  }
+  return {
+    selectorPath: i,
+    nearestTargetFields: n
+  };
+}
+function X(t, e) {
+  let i = t.type;
+  return t.type !== "scrollend" && (i += "-" + e), i;
+}
+class Z extends j {
+  constructor(e) {
+    super(e, N), this.eventsPerHarvest = 1e3, this.referrerUrl = S && document.referrer ? b(document.referrer) : void 0, this.waitForFlags(["ins"]).then(([i]) => {
+      if (!i) {
+        this.blocked = !0, this.deregisterDrain();
+        return;
+      }
+      this.trackSupportabilityMetrics(), v("api-recordCustomEvent", (r, a, c) => {
+        if (B.includes(a)) return R(46);
+        this.addEvent({
+          eventType: a,
+          timestamp: this.toEpoch(r),
+          ...c
+        });
+      }, this.featureName, this.ee), e.init.page_action.enabled && v("api-addPageAction", (r, a, c, s) => {
+        var u, f;
+        if (!this.agentRef.runtime.entityManager.get(s)) return R(56, this.featureName);
+        this.addEvent({
+          ...c,
+          eventType: "PageAction",
+          timestamp: this.toEpoch(r),
+          timeSinceLoad: r / 1e3,
+          actionName: a,
+          referrerUrl: this.referrerUrl,
+          ...S && {
+            browserWidth: (u = window.document.documentElement) == null ? void 0 : u.clientWidth,
+            browserHeight: (f = window.document.documentElement) == null ? void 0 : f.clientHeight
+          }
+        }, s);
+      }, this.featureName, this.ee);
+      let n = () => {
+      };
+      S && e.init.user_actions.enabled && (this.userActionAggregator = new q(), this.harvestOpts.beforeUnload = () => n == null ? void 0 : n(this.userActionAggregator.aggregationEvent), n = (r) => {
+        try {
+          if (r != null && r.event) {
+            let u = function(o) {
+              return o === "tagName" && (o = "tag"), o === "className" && (o = "class"), "target".concat(o.charAt(0).toUpperCase() + o.slice(1));
+            }, f = function(o) {
+              return !!(r.selectorPath !== "window" && r.selectorPath !== "document" && a instanceof HTMLElement && (a != null && a[o]));
+            };
+            const {
+              target: a,
+              timeStamp: c,
+              type: s
+            } = r.event;
+            this.addEvent({
+              eventType: "UserAction",
+              timestamp: this.toEpoch(c),
+              action: s,
+              actionCount: r.count,
+              actionDuration: r.relativeMs[r.relativeMs.length - 1],
+              actionMs: r.relativeMs,
+              rageClick: r.rageClick,
+              target: r.selectorPath,
+              currentUrl: r.currentUrl,
+              ...U(window) && {
+                iframe: !0
+              },
+              ...this.agentRef.init.user_actions.elementAttributes.reduce((o, h) => (f(h) && (o[u(h)] = String(a[h]).trim().slice(0, 128)), o), {}),
+              ...r.nearestTargetFields
+            });
+          }
+        } catch {
+        }
+      }, v("ua", (r) => {
+        n(this.userActionAggregator.process(r, this.agentRef.init.user_actions.elementAttributes));
+      }, this.featureName, this.ee));
+      const l = [...e.init.performance.capture_marks ? ["mark"] : [], ...e.init.performance.capture_measures ? ["measure"] : []];
+      if (l.length)
+        try {
+          l.forEach((r) => {
+            PerformanceObserver.supportedEntryTypes.includes(r) && new PerformanceObserver((c) => {
+              c.getEntries().forEach((s) => {
+                try {
+                  let f = function(o) {
+                    if (o == null) return {};
+                    return D(o) ? h(o) : {
+                      entryDetail: o
+                    };
+                    function h(p, k = "entryDetail") {
+                      let T = {};
+                      return p == null || Object.keys(p).forEach((d) => {
+                        let w = k + "." + d;
+                        D(p[d]) ? Object.assign(T, h(p[d], w)) : p[d] !== null && p[d] !== void 0 && (T[w] = p[d]);
+                      }), T;
+                    }
+                  };
+                  this.reportSupportabilityMetric("Generic/Performance/" + r + "/Seen");
+                  const u = e.init.performance.capture_detail ? f(s.detail) : {};
+                  this.addEvent({
+                    ...u,
+                    eventType: "BrowserPerformance",
+                    timestamp: this.toEpoch(s.startTime),
+                    entryName: s.name,
+                    entryDuration: s.duration,
+                    entryType: r
+                  });
+                } catch {
+                }
+              });
+            }).observe({
+              buffered: !0,
+              type: r
+            });
+          });
+        } catch {
+        }
+      S && e.init.performance.resources.enabled && v("browserPerformance.resource", (r) => {
+        var a;
+        try {
+          const {
+            name: c,
+            duration: s,
+            ...u
+          } = r.toJSON();
+          let f = !1;
+          try {
+            const h = new URL(c).hostname, p = h.includes("newrelic.com") || h.includes("nr-data.net") || h.includes("nr-local.net");
+            if (this.agentRef.init.performance.resources.ignore_newrelic && p || this.agentRef.init.performance.resources.asset_types.length && !this.agentRef.init.performance.resources.asset_types.includes(u.initiatorType)) return;
+            f = h === ((a = I) == null ? void 0 : a.location.hostname) || e.init.performance.resources.first_party_domains.includes(h), f && this.reportSupportabilityMetric("Generic/Performance/FirstPartyResource/Seen"), p && this.reportSupportabilityMetric("Generic/Performance/NrResource/Seen");
+          } catch {
+          }
+          this.reportSupportabilityMetric("Generic/Performance/Resource/Seen");
+          const o = {
+            ...u,
+            eventType: "BrowserPerformance",
+            timestamp: Math.floor(e.runtime.timeKeeper.correctRelativeTimestamp(u.startTime)),
+            entryName: b(c),
+            entryDuration: s,
+            firstParty: f
+          };
+          this.addEvent(o);
+        } catch (c) {
+          this.ee.emit("internal-error", [c, "GenericEvents-Resource"]);
+        }
+      }, this.featureName, this.ee), v("api-measure", (r, a) => {
+        const {
+          start: c,
+          duration: s,
+          customAttributes: u
+        } = r, f = {
+          ...u,
+          eventType: "BrowserPerformance",
+          timestamp: Math.floor(e.runtime.timeKeeper.correctRelativeTimestamp(c)),
+          entryName: a,
+          entryDuration: s,
+          entryType: "measure"
+        };
+        this.addEvent(f);
+      }, this.featureName, this.ee), e.runtime.harvester.triggerHarvestFor(this), this.drain();
+    });
+  }
+  // WARNING: Insights times are in seconds. EXCEPT timestamp, which is in ms.
+  /** Some keys are set by the query params or request headers sent with the harvest and override the body values, so check those before adding new standard body values...
+   * see harvest.js#baseQueryString for more info on the query params
+   * Notably:
+   * * name: set by the `t=` query param
+   * * appId: set by the `a=` query param
+   * * standalone: set by the `sa=` query param
+   * * session: set by the `s=` query param
+   * * sessionTraceId: set by the `ptid=` query param
+   * * userAgent*: set by the userAgent header
+   * @param {object=} obj the event object for storing in the event buffer
+   * @param {string=} targetEntityGuid the target entity guid for the event to scope buffering and harvesting. Defaults to agent config if undefined
+   * @returns void
+   */
+  addEvent(e = {}, i) {
+    if (!e || !Object.keys(e).length) return;
+    if (!e.eventType) {
+      R(44);
+      return;
+    }
+    for (let a in e) {
+      let c = e[a];
+      e[a] = c && typeof c == "object" ? V(c) : c;
+    }
+    const n = {
+      /** should be overridden by the event-specific attributes, but just in case -- set it to now() */
+      timestamp: Math.floor(this.agentRef.runtime.timeKeeper.correctRelativeTimestamp(W())),
+      /** all generic events require pageUrl(s) */
+      pageUrl: b("" + G),
+      currentUrl: b("" + location)
+    }, l = {
+      /** Agent-level custom attributes */
+      ...this.agentRef.info.jsAttributes || {},
+      /** Fallbacks for required properties in-case the event did not supply them, should take precedence over agent-level custom attrs */
+      ...n,
+      /** Event-specific attributes take precedence over agent-level custom attributes and fallbacks */
+      ...e
+    };
+    !this.events.add(l, i) && !this.events.isEmpty(void 0, i) && (this.ee.emit(x, ["GenericEvents/Harvest/Max/Seen"]), this.agentRef.runtime.harvester.triggerHarvestFor(this, {
+      targetEntityGuid: i
+    }), this.events.add(l));
+  }
+  serializer(e) {
+    return F({
+      ins: e
+    }, this.obfuscator.obfuscateString.bind(this.obfuscator), "string");
+  }
+  queryStringsBuilder() {
+    return {
+      ua: this.agentRef.info.userAttributes,
+      at: this.agentRef.info.atts
+    };
+  }
+  toEpoch(e) {
+    return Math.floor(this.agentRef.runtime.timeKeeper.correctRelativeTimestamp(e));
+  }
+  trackSupportabilityMetrics() {
+    var i, n;
+    const e = "Config/Performance/";
+    this.agentRef.init.performance.capture_marks && this.reportSupportabilityMetric(e + "CaptureMarks/Enabled"), this.agentRef.init.performance.capture_measures && this.reportSupportabilityMetric(e + "CaptureMeasures/Enabled"), this.agentRef.init.performance.resources.enabled && this.reportSupportabilityMetric(e + "Resources/Enabled"), ((i = this.agentRef.init.performance.resources.asset_types) == null ? void 0 : i.length) !== 0 && this.reportSupportabilityMetric(e + "Resources/AssetTypes/Changed"), ((n = this.agentRef.init.performance.resources.first_party_domains) == null ? void 0 : n.length) !== 0 && this.reportSupportabilityMetric(e + "Resources/FirstPartyDomains/Changed"), this.agentRef.init.performance.resources.ignore_newrelic === !1 && this.reportSupportabilityMetric(e + "Resources/IgnoreNewrelic/Changed");
+  }
+}
+_(Z, "featureName", N);
+export {
+  Z as Aggregate
+};