gather-vue 8.6.0

package/dist/aggregate-base-C6N8Ymd5.js

@@ -0,0 +1,830 @@
+var ge = Object.defineProperty;
+var te = (s) => {
+  throw TypeError(s);
+};
+var ve = (s, e, t) => e in s ? ge(s, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : s[e] = t;
+var se = (s, e, t) => ve(s, typeof e != "symbol" ? e + "" : e, t), _ = (s, e, t) => e.has(s) || te("Cannot " + t);
+var o = (s, e, t) => (_(s, e, "read from private field"), t ? t.call(s) : e.get(s)), l = (s, e, t) => e.has(s) ? te("Cannot add the same private member more than once") : e instanceof WeakSet ? e.add(s) : e.set(s, t), S = (s, e, t, r) => (_(s, e, "write to private field"), r ? r.call(s, t) : e.set(s, t), t), d = (s, e, t) => (_(s, e, "access private method"), t);
+import { B as D, r as B, v as pe, ao as ae, ap as z, i as ne, $ as me, h as P, t as K, aq as ye, ar as Se, as as be, N as Ee, at as xe, au as ke, av as we, z as De, aw as Oe, D as oe, y as M, S as ce, ax as Re, ay as Te, W as Me, az as Ce, aA as Ae } from "./main-DPldah1M.js";
+function Ne() {
+  var s, e;
+  return ((e = (s = D) == null ? void 0 : s.location) == null ? void 0 : e.protocol) === "file:";
+}
+class Be {
+  constructor(e) {
+    this.agentRef = e, this.warnedRegexMissing = !1, this.warnedInvalidRegex = !1, this.warnedInvalidReplacement = !1;
+  }
+  get obfuscateConfigRules() {
+    return this.agentRef.init.obfuscate || [];
+  }
+  /**
+   * Applies all valid obfuscation rules to the provided input string
+   * @param {string} input String to obfuscate
+   * @returns {string}
+   */
+  obfuscateString(e) {
+    if (typeof e != "string" || e.trim().length === 0) return e;
+    const t = this.obfuscateConfigRules.map((r) => this.validateObfuscationRule(r));
+    return Ne() && t.push({
+      regex: /^file:\/\/(.*)/,
+      replacement: atob("ZmlsZTovL09CRlVTQ0FURUQ=")
+    }), t.filter((r) => r.isValid).reduce((r, a) => {
+      const {
+        rule: i
+      } = a;
+      return r.replace(i.regex, i.replacement || "*");
+    }, e);
+  }
+  /**
+   * Validates an obfuscation rule and provides errors if any are found.
+   * @param {ObfuscationRule} rule The rule to validate
+   * @returns {ObfuscationRuleValidation} The validation state of the rule
+   */
+  validateObfuscationRule(e) {
+    const t = e.regex === void 0, r = e.regex !== void 0 && typeof e.regex != "string" && !(e.regex instanceof RegExp), a = !!(e.replacement && typeof e.replacement != "string");
+    return t && !this.warnedRegexMissing ? (B(12, e), this.warnedRegexMissing = !0) : r && !this.warnedInvalidRegex && (B(13, e), this.warnedInvalidRegex = !0), a && !this.warnedInvalidReplacement && (B(14, e), this.warnedInvalidReplacement = !0), {
+      rule: e,
+      isValid: !t && !r && !a,
+      errors: {
+        regexMissingDetected: t,
+        invalidRegexDetected: r,
+        invalidReplacementDetected: a
+      }
+    };
+  }
+}
+const ot = 64e3, He = 1e6, O = "NR_CONTAINER_AGENT";
+var g, b;
+class re {
+  /**
+   * @param {object} agentRef - reference to base agent class
+   * @param {EventBuffer|EventAggregator} storageClass - the type of storage to use in this manager; 'EventBuffer' (1), 'EventAggregator' (2)
+   * @param {string} [defaultEntityGuid] - the entity guid to use as the default storage instance; if not provided, a new one is created
+   * @param {string} featureName - the name of the feature this manager is for; used for event dispatching
+   */
+  constructor(e, t, r, a) {
+    l(this, g);
+    this.agentRef = e, this.entityManager = e.runtime.entityManager, this.StorageClass = t, this.appStorageMap = /* @__PURE__ */ new Map([[O, new this.StorageClass()]]), this.featureName = a, this.setEventStore(r);
+  }
+  setEventStore(e) {
+    if (!e) return;
+    const t = pe(this.entityManager.get(e), this.agentRef) ? this.appStorageMap.get(O) : new this.StorageClass();
+    this.appStorageMap.set(e, t);
+  }
+  // This class must contain an union of all methods from all supported storage classes and conceptualize away the target app argument.
+  /**
+   * Calls the isEmpty method on the underlying storage class. If target is provided, runs just for the target, otherwise runs for all apps.
+   * @param {object} optsIfPresent - exists if called during harvest interval, @see AggregateBase.makeHarvestPayload
+   * @param {object} target - specific app's storage to check; if not provided, this method takes into account all apps recorded by this manager
+   * @returns {boolean} True if the target's storage is empty, or target does not exist in map (defaults to all storages)
+   */
+  isEmpty(e, t) {
+    if (t) return d(this, g, b).call(this, t).isEmpty(e);
+    for (const r of this.appStorageMap.values())
+      if (!r.isEmpty(e)) return !1;
+    return !0;
+  }
+  /**
+   * Calls the add method on the underlying storage class.
+   * @param {string} event - the event element to store
+   * @param {object} targetEntityGuid - the entity guid lookup to store event under; if not provided, this method adds to the default
+   * @returns {boolean} True if the event was successfully added
+   */
+  add(e, t) {
+    var r;
+    return ae({
+      agentIdentifier: this.agentRef.agentIdentifier,
+      drained: !!((r = z) != null && r[this.agentRef.agentIdentifier]),
+      type: "data",
+      name: "buffer",
+      feature: this.featureName,
+      data: e
+    }), d(this, g, b).call(this, t).add(e);
+  }
+  /** This is only used by the Metrics feature which has no need to add metric under a different app atm. */
+  addMetric(e, t, r, a) {
+    return d(this, g, b).call(this).addMetric(e, t, r, a);
+  }
+  /**
+   * Calls the get method on the underlying storage class. If target is provided, runs just for the target, otherwise runs for all apps.
+   * @param {object=} opts - exists if called during harvest interval, @see AggregateBase.makeHarvestPayload
+   * @param {object=} target - specific app to fetch; if not provided, this method fetches from all apps
+   * @returns {Array} Objects of `data` labeled with their respective `target` app to be sent to
+   */
+  get(e, t) {
+    if (t) return [{
+      targetApp: this.entityManager.get(t),
+      data: d(this, g, b).call(this, t).get(e)
+    }];
+    const r = [];
+    return this.appStorageMap.forEach((a, i) => {
+      if (i === O) return;
+      const n = this.entityManager.get(i);
+      n && r.push({
+        targetApp: n,
+        data: a.get(e)
+      });
+    }), r;
+  }
+  /**
+   * Calls the byteSize method on the underlying storage class
+   * @param {*} targetEntityGuid
+   * @returns
+   */
+  byteSize(e) {
+    return d(this, g, b).call(this, e).byteSize();
+  }
+  /**
+   * Calls the wouldExceedMaxSize method on the underlying storage class
+   * @param {*} incomingSize
+   * @param {*} targetEntityGuid
+   * @returns
+   */
+  wouldExceedMaxSize(e, t) {
+    return d(this, g, b).call(this, t).wouldExceedMaxSize(e);
+  }
+  /**
+   * Calls the save method on the underlying storage class. If target is provided, runs just for the target, otherwise runs for all apps.
+   * @param {*} optsIfPresent
+   * @param {*} targetEntityGuid
+   * @returns
+   */
+  save(e, t) {
+    if (t) return d(this, g, b).call(this, t).save(e);
+    this.appStorageMap.forEach((r) => r.save(e));
+  }
+  /**
+   * Calls the clear method on the underlying storage class. If target is provided, runs just for the target, otherwise runs for all apps.
+   * @param {*} optsIfPresent
+   * @param {*} targetEntityGuid
+   * @returns
+   */
+  clear(e, t) {
+    if (t) return d(this, g, b).call(this, t).clear(e);
+    this.appStorageMap.forEach((r) => r.clear(e));
+  }
+  // Unlike the methods above, the following will have a target as they are called by AggregateBase.postHarvestCleanup callback on harvest finish after getting & sending the data.
+  reloadSave(e, t) {
+    return d(this, g, b).call(this, t).reloadSave(e);
+  }
+  clearSave(e, t) {
+    return d(this, g, b).call(this, t).clearSave(e);
+  }
+}
+g = new WeakSet(), /**
+ * Always returns a storage instance.  Creates one if one does not exist.  If a lookup is not provided, uses the DEFAULT namespace
+ * @param {string=} targetEntityGuid the lookup
+ * @returns {*} ALWAYS returns a storage instance
+ */
+b = function(e = O) {
+  return this.appStorageMap.has(e) || this.setEventStore(e), this.appStorageMap.get(e);
+};
+if (P) {
+  D.cleanupTasks = [];
+  const s = D.close;
+  D.close = () => {
+    for (let e of D.cleanupTasks)
+      e();
+    s();
+  };
+}
+function Fe(s, e) {
+  ne ? me(s, !0, e) : P && D.cleanupTasks.push(s);
+}
+var je = /([^?#]*)[^#]*(#[^?]*|$).*/, ze = /([^?#]*)().*/;
+function Pe(s, e) {
+  return s.replace(e ? je : ze, "$1$2");
+}
+var he = {
+  "%2C": ",",
+  "%3A": ":",
+  "%2F": "/",
+  "%40": "@",
+  "%24": "$",
+  "%3B": ";"
+}, Ie = Object.keys(he), Le = new RegExp(Ie.join("|"), "g");
+function Ue(s) {
+  return he[s];
+}
+function q(s) {
+  return s == null ? "null" : encodeURIComponent(s).replace(Le, Ue);
+}
+function _e(s, e) {
+  var t = 0, r = "";
+  return Object.entries(s || {}).forEach(([a, i]) => {
+    var n = [], c, h;
+    if (typeof i == "string" || !Array.isArray(i) && i !== null && i !== void 0 && i.toString().length)
+      c = "&" + a + "=" + q(i), t += c.length, r += c;
+    else if (Array.isArray(i) && i.length) {
+      for (t += 9, h = 0; h < i.length && (c = q(K(i[h])), t += c.length, !(typeof e < "u" && t >= e)); h++)
+        n.push(c);
+      r += "&" + a + "=%5B" + n.join(",") + "%5D";
+    }
+  }), r;
+}
+function k(s, e, t = {}) {
+  return Object.keys(t).includes(s) ? "" : e && typeof e == "string" ? "&" + s + "=" + q(e) : "";
+}
+function qe({
+  isFinalHarvest: s = !1
+} = {}) {
+  return s && ne ? Ve : typeof XMLHttpRequest < "u" ? I : V;
+}
+function V({
+  url: s,
+  body: e = null,
+  method: t = "POST",
+  headers: r = [{
+    key: "content-type",
+    value: "text/plain"
+  }]
+}) {
+  const a = {};
+  for (const i of r)
+    a[i.key] = i.value;
+  return fetch(s, {
+    headers: a,
+    method: t,
+    body: e,
+    credentials: "include"
+  });
+}
+function I({
+  url: s,
+  body: e = null,
+  sync: t,
+  method: r = "POST",
+  headers: a = [{
+    key: "content-type",
+    value: "text/plain"
+  }]
+}) {
+  const i = new XMLHttpRequest();
+  i.open(r, s, !t);
+  try {
+    "withCredentials" in i && (i.withCredentials = !0);
+  } catch {
+  }
+  return a.forEach((n) => {
+    i.setRequestHeader(n.key, n.value);
+  }), i.send(e), i;
+}
+function Ve({
+  url: s,
+  body: e
+}) {
+  try {
+    return window.navigator.sendBeacon.bind(window.navigator)(s, e);
+  } catch {
+    return !1;
+  }
+}
+const Ye = "Harvester/Retry/Failed/", Ke = "Harvester/Retry/Succeeded/";
+var H;
+class We {
+  constructor(e) {
+    l(this, H, !1);
+    se(this, "initializedAggregates", []);
+    this.agentRef = e, Fe(() => {
+      this.initializedAggregates.forEach((t) => {
+        typeof t.harvestOpts.beforeUnload == "function" && t.harvestOpts.beforeUnload();
+      }), this.initializedAggregates.forEach((t) => this.triggerHarvestFor(t, {
+        isFinalHarvest: !0
+      }));
+    }, !1);
+  }
+  startTimer(e = this.agentRef.init.harvest.interval) {
+    if (o(this, H)) return;
+    S(this, H, !0);
+    const t = () => {
+      this.initializedAggregates.forEach((r) => this.triggerHarvestFor(r)), setTimeout(t, e * 1e3);
+    };
+    setTimeout(t, e * 1e3);
+  }
+  /**
+   * Given a feature (aggregate), execute a harvest on-demand.
+   * @param {object} aggregateInst
+   * @param {object} localOpts
+   * @returns {boolean} True if 1+ network call was made. Note that this does not mean or guarantee that it was successful (or that all were in the case of more than 1).
+   */
+  triggerHarvestFor(e, t = {}) {
+    if (e.blocked) return !1;
+    const r = qe(t);
+    if (!r) return !1;
+    const a = !t.isFinalHarvest && r === I;
+    let i, n = !1;
+    if (t.directSend)
+      i = [t.directSend];
+    else if (i = e.makeHarvestPayload(a, t), !i) return !1;
+    return i.forEach(({
+      targetApp: h,
+      payload: u
+    }) => {
+      u && ($e(this.agentRef, {
+        endpoint: ye[e.featureName],
+        targetApp: h,
+        payload: u,
+        localOpts: t,
+        submitMethod: r,
+        cbFinished: c,
+        raw: e.harvestOpts.raw,
+        featureName: e.featureName
+      }), n = !0);
+    }), n;
+    function c(h) {
+      e.harvestOpts.prevAttemptCode && (oe(ce, [(h.retry ? Ye : Ke) + e.harvestOpts.prevAttemptCode], void 0, M.metrics, e.ee), delete e.harvestOpts.prevAttemptCode), h.retry && (e.harvestOpts.prevAttemptCode = h.status), t.forceNoRetry && (h.retry = !1), e.postHarvestCleanup(h);
+    }
+  }
+}
+H = new WeakMap();
+const ie = {};
+function $e(s, {
+  endpoint: e,
+  targetApp: t,
+  payload: r,
+  localOpts: a = {},
+  submitMethod: i,
+  cbFinished: n,
+  raw: c,
+  featureName: h
+}) {
+  var Q, G;
+  if (!s.info.errorBeacon) return !1;
+  let {
+    body: u,
+    qs: v
+  } = Xe(r);
+  if (Object.keys(u).length === 0 && !a.sendEmptyBody)
+    return n && n({
+      sent: !1,
+      targetApp: t
+    }), !1;
+  const f = s.init.ssl === !1 ? "http" : "https", N = s.init.proxy.beacon || s.info.errorBeacon, de = c ? "".concat(f, "://").concat(N, "/").concat(e) : "".concat(f, "://").concat(N).concat(e !== Se ? "/" + e : "", "/1/").concat(t.licenseKey), W = c ? "" : Ze(s, v, e, t.applicationID);
+  let F = _e(v, s.runtime.maxBytes);
+  W === "" && F.startsWith("&") && (F = F.substring(1));
+  const U = "".concat(de, "?").concat(W).concat(F);
+  !!((Q = v == null ? void 0 : v.attributes) != null && Q.includes("gzip")) || (e !== be && (u = K(u)), u.length > 75e4 && (ie[e] = (ie[e] || 0) + 1) === 1 && B(28, e)), (!u || u.length === 0 || u === "{}" || u === "[]") && (u = "");
+  const $ = [{
+    key: "content-type",
+    value: "text/plain"
+  }];
+  let X = i({
+    url: U,
+    body: u,
+    sync: a.isFinalHarvest && P,
+    headers: $
+  });
+  return !a.isFinalHarvest && n && (i === I ? X.addEventListener("loadend", function() {
+    const p = {
+      sent: this.status !== 0,
+      status: this.status,
+      retry: Z(this.status),
+      fullUrl: U,
+      xhr: this,
+      targetApp: t
+    };
+    a.needResponse && (p.responseText = this.responseText), n(p);
+  }, Ee(!1)) : i === V && X.then(async function(p) {
+    const J = p.status, ee = {
+      sent: !0,
+      status: J,
+      retry: Z(J),
+      fullUrl: U,
+      fetchResponse: p,
+      targetApp: t
+    };
+    a.needResponse && (ee.responseText = await p.text()), n(ee);
+  })), ae({
+    agentIdentifier: s.agentIdentifier,
+    drained: !!((G = z) != null && G[s.agentIdentifier]),
+    type: "data",
+    name: "harvest",
+    feature: h,
+    data: {
+      endpoint: e,
+      headers: $,
+      targetApp: t,
+      payload: r,
+      submitMethod: le(),
+      raw: c,
+      synchronousXhr: !!(a.isFinalHarvest && P)
+    }
+  }), !0;
+  function Z(p) {
+    switch (p) {
+      case 408:
+      case 429:
+      case 500:
+        return !0;
+    }
+    return p >= 502 && p <= 504 || p >= 512 && p <= 530;
+  }
+  function le() {
+    return i === I ? "xhr" : i === V ? "fetch" : "beacon";
+  }
+}
+function Xe(s = {}) {
+  const e = (t) => typeof Uint8Array < "u" && t instanceof Uint8Array || Array.isArray(t) ? t : typeof t == "string" ? t.length > 0 ? t : null : Object.entries(t || {}).reduce((r, [a, i]) => ((typeof i == "number" || typeof i == "string" && i.length > 0 || typeof i == "object" && Object.keys(i || {}).length > 0) && (r[a] = i), r), {});
+  return {
+    body: e(s.body),
+    qs: e(s.qs)
+  };
+}
+function Ze(s, e, t, r) {
+  var u, v, f;
+  const a = s.runtime.obfuscator.obfuscateString(Pe("" + D.location)), i = ((u = s.runtime.session) == null ? void 0 : u.state.sessionReplayMode) === 1 && t !== xe, n = ((v = s.runtime.session) == null ? void 0 : v.state.sessionTraceMode) === 1 && ![ke, we].includes(t), c = [
+    "a=" + r,
+    k("sa", s.info.sa ? "" + s.info.sa : ""),
+    k("v", Oe),
+    h(),
+    k("ct", s.runtime.customTransaction),
+    "&rst=" + De(),
+    "&ck=0",
+    // ck param DEPRECATED - still expected by backend
+    "&s=" + (((f = s.runtime.session) == null ? void 0 : f.state.value) || "0"),
+    // the 0 id encaps all untrackable and default traffic
+    k("ref", a),
+    k("ptid", s.runtime.ptid ? "" + s.runtime.ptid : "")
+  ];
+  return i && c.push(k("hr", "1", e)), n && c.push(k("ht", "1", e)), c.join("");
+  function h() {
+    return s.info.transactionName ? k("to", s.info.transactionName) : k("t", s.info.tNamePlain || "Unnamed Transaction");
+  }
+}
+var w, E;
+class Qe {
+  constructor(e) {
+    l(this, w, /* @__PURE__ */ new Map());
+    l(this, E, {});
+    this.agentRef = e, o(this, w).set(O, {
+      licenseKey: e.info.licenseKey,
+      applicationID: e.info.applicationID
+    });
+  }
+  get(e = O) {
+    return o(this, w).get(e);
+  }
+  getEntityGuidFor(e, t) {
+    if (!(!o(this, E)[e] || !o(this, E)[t]))
+      return o(this, E)[e].filter((r) => o(this, E)[t].includes(r))[0];
+  }
+  set(e, t) {
+    var r, a, i, n;
+    o(this, w).has(e) || (o(this, w).set(e, t), (r = o(this, E))[a = t.licenseKey] ?? (r[a] = []), o(this, E)[t.licenseKey].push(e), (i = o(this, E))[n = t.applicationID] ?? (i[n] = []), o(this, E)[t.applicationID].push(e), this.agentRef.ee.emit("entity-added", [t]));
+  }
+  clear() {
+    o(this, w).clear();
+  }
+  setDefaultEntity(e) {
+    o(this, w).set(O, e);
+  }
+}
+w = new WeakMap(), E = new WeakMap();
+var x, m, R, T;
+class Ge {
+  /**
+   * @param {number} maxPayloadSize
+   */
+  constructor(e = He) {
+    l(this, x, []);
+    l(this, m, 0);
+    l(this, R);
+    l(this, T);
+    this.maxPayloadSize = e;
+  }
+  isEmpty() {
+    return o(this, x).length === 0;
+  }
+  get() {
+    return o(this, x);
+  }
+  byteSize() {
+    return o(this, m);
+  }
+  wouldExceedMaxSize(e) {
+    return o(this, m) + e > this.maxPayloadSize;
+  }
+  /**
+   * Add feature-processed event to our buffer. If this event would cause our total raw size to exceed the set max payload size, it is dropped.
+   * @param {any} event - any primitive type or object
+   * @returns {Boolean} true if successfully added; false otherwise
+   */
+  add(e) {
+    var r;
+    const t = ((r = K(e)) == null ? void 0 : r.length) || 0;
+    return o(this, m) + t > this.maxPayloadSize ? !1 : (o(this, x).push(e), S(this, m, o(this, m) + t), !0);
+  }
+  /**
+   * Wipes the main buffer
+   */
+  clear() {
+    S(this, x, []), S(this, m, 0);
+  }
+  /**
+   * Backup the buffered data and clear the main buffer
+   */
+  save() {
+    S(this, R, o(this, x)), S(this, T, o(this, m));
+  }
+  /**
+   * Wipes the backup buffer
+   */
+  clearSave() {
+    S(this, R, void 0), S(this, T, void 0);
+  }
+  /**
+   * Prepend the backup buffer back into the main buffer
+   */
+  reloadSave() {
+    o(this, R) && (o(this, T) + o(this, m) > this.maxPayloadSize || (S(this, x, [...o(this, R), ...o(this, x)]), S(this, m, o(this, T) + o(this, m))));
+  }
+}
+x = new WeakMap(), m = new WeakMap(), R = new WeakMap(), T = new WeakMap();
+var C, j;
+class Je {
+  constructor() {
+    l(this, C);
+    this.aggregatedData = {};
+  }
+  // Items with the same type and name get aggregated together
+  // params are example data from the aggregated items
+  // metrics are the numeric values to be aggregated
+  store(e, t, r, a, i) {
+    var n = d(this, C, j).call(this, e, t, r, i);
+    return n.metrics = et(a, n.metrics), n;
+  }
+  merge(e, t, r, a, i, n = !1) {
+    var c = d(this, C, j).call(this, e, t, a, i);
+    if (n && (c.params = a), !c.metrics) {
+      c.metrics = r;
+      return;
+    }
+    var h = c.metrics;
+    h.count += r.count, Object.keys(r || {}).forEach((u) => {
+      if (u !== "count") {
+        var v = h[u], f = r[u];
+        f && !f.c ? h[u] = Y(f.t, v) : h[u] = st(f, h[u]);
+      }
+    });
+  }
+  storeMetric(e, t, r, a) {
+    var i = d(this, C, j).call(this, e, t, r);
+    return i.stats = Y(a, i.stats), i;
+  }
+  // Get all listed types buckets and it deletes the retrieved content from the aggregatedData
+  take(e, t = !0) {
+    for (var r = {}, a = "", i = !1, n = 0; n < e.length; n++)
+      a = e[n], r[a] = Object.values(this.aggregatedData[a] || {}), r[a].length && (i = !0), t && delete this.aggregatedData[a];
+    return i ? r : null;
+  }
+}
+C = new WeakSet(), j = function(e, t, r, a) {
+  this.aggregatedData[e] || (this.aggregatedData[e] = {});
+  var i = this.aggregatedData[e][t];
+  return i || (i = this.aggregatedData[e][t] = {
+    params: r || {}
+  }, a && (i.custom = a)), i;
+};
+function et(s, e) {
+  return e || (e = {
+    count: 0
+  }), e.count += 1, Object.entries(s || {}).forEach(([t, r]) => {
+    e[t] = Y(r, e[t]);
+  }), e;
+}
+function Y(s, e) {
+  return s == null ? tt(e) : e ? (e.c || (e = ue(e.t)), e.c += 1, e.t += s, e.sos += s * s, s > e.max && (e.max = s), s < e.min && (e.min = s), e) : {
+    t: s
+  };
+}
+function tt(s) {
+  return s ? s.c++ : s = {
+    c: 1
+  }, s;
+}
+function st(s, e) {
+  return e ? (e.c || (e = ue(e.t)), e.min = Math.min(s.min, e.min), e.max = Math.max(s.max, e.max), e.t += s.t, e.sos += s.sos, e.c += s.c, e) : s;
+}
+function ue(s) {
+  return {
+    t: s,
+    min: s,
+    max: s,
+    sos: s * s,
+    c: 1
+  };
+}
+var y, A;
+class rt {
+  constructor() {
+    l(this, y, new Je());
+    l(this, A, {});
+  }
+  isEmpty({
+    aggregatorTypes: e
+  }) {
+    return e ? e.every((t) => !o(this, y).aggregatedData[t]) : Object.keys(o(this, y).aggregatedData).length === 0;
+  }
+  add([e, t, r, a, i]) {
+    return o(this, y).store(e, t, r, a, i), !0;
+  }
+  addMetric(e, t, r, a) {
+    return o(this, y).storeMetric(e, t, r, a), !0;
+  }
+  save({
+    aggregatorTypes: e
+  }) {
+    const t = e.toString(), r = {};
+    e.forEach((a) => r[a] = o(this, y).aggregatedData[a]), o(this, A)[t] = r;
+  }
+  get(e) {
+    const t = Array.isArray(e) ? e : e.aggregatorTypes;
+    return o(this, y).take(t, !1);
+  }
+  clear({
+    aggregatorTypes: e
+  } = {}) {
+    if (!e) {
+      o(this, y).aggregatedData = {};
+      return;
+    }
+    e.forEach((t) => delete o(this, y).aggregatedData[t]);
+  }
+  reloadSave({
+    aggregatorTypes: e
+  }) {
+    const t = e.toString(), r = o(this, A)[t];
+    e.forEach((a) => {
+      Object.keys(r[a] || {}).forEach((i) => {
+        const n = r[a][i];
+        o(this, y).merge(a, i, n.metrics, n.params, n.custom, !0);
+      });
+    });
+  }
+  clearSave({
+    aggregatorTypes: e
+  }) {
+    const t = e.toString();
+    delete o(this, A)[t];
+  }
+}
+y = new WeakMap(), A = new WeakMap();
+var L, fe;
+class ct extends Re {
+  /**
+   * Create an AggregateBase instance.
+   * @param {Object} agentRef The reference to the agent instance.
+   * @param {string} featureName The name of the feature creating the instance.
+   */
+  constructor(t, r) {
+    var i, n, c, h, u;
+    super(t.agentIdentifier, r);
+    l(this, L);
+    this.agentRef = t, this.checkConfiguration(t), this.doOnceForAllAggregate(t), this.harvestOpts = {};
+    const a = (u = (h = (c = (n = (i = this.agentRef) == null ? void 0 : i.runtime) == null ? void 0 : n.appMetadata) == null ? void 0 : c.agents) == null ? void 0 : h[0]) == null ? void 0 : u.entityGuid;
+    d(this, L, fe).call(this, a), a || this.ee.on("entity-added", (v) => {
+      var f, N;
+      (N = (f = this.events) == null ? void 0 : f.setEventStore) == null || N.call(f, v.entityGuid);
+    });
+  }
+  /**
+   * New handler for waiting for multiple flags. Useful when expecting multiple flags simultaneously (ex. stn vs sr)
+   * @param {string[]} flagNames
+   * @returns {Promise}
+   */
+  waitForFlags(t = []) {
+    return new Promise((a, i) => {
+      z[this.agentIdentifier] ? a(n(z[this.agentIdentifier])) : this.ee.on("rumresp", (c = {}) => {
+        a(n(c));
+      });
+      function n(c) {
+        return t.map((h) => c[h] ? c[h] : 0);
+      }
+    }).catch((a) => {
+      this.ee.emit("internal-error", [a]), this.blocked = !0, this.deregisterDrain();
+    });
+  }
+  /**
+   * Stages the feature to be drained
+   */
+  drain() {
+    Te(this.agentIdentifier, this.featureName), this.drained = !0;
+  }
+  preHarvestChecks(t) {
+    return !this.blocked;
+  }
+  /**
+   * Return harvest payload. A "serializer" function can be defined on a derived class to format the payload.
+   * @param {Boolean} shouldRetryOnFail - harvester flag to backup payload for retry later if harvest request fails; this should be moved to harvester logic
+   * @param {object|undefined} opts - opts passed from the harvester to help form the payload
+   * @param {string} opts.targetEntityGuid - the entity guid of the target app
+   * @returns {Array} Final payload tagged with their targeting browser app. The value of `payload` can be undefined if there are no pending events for an app. This should be a minimum length of 1.
+   */
+  makeHarvestPayload(t = !1, r = {}) {
+    if (!this.events || this.events.isEmpty(this.harvestOpts, r.targetEntityGuid) || this.preHarvestChecks && !this.preHarvestChecks(r)) return;
+    t && this.events.save(this.harvestOpts, r.targetEntityGuid);
+    const a = this.events.get(this.harvestOpts, r.targetEntityGuid);
+    return a.length ? (this.events.clear(this.harvestOpts, r.targetEntityGuid), a.map(({
+      targetApp: i,
+      data: n
+    }) => {
+      const h = {
+        body: this.serializer ? this.serializer(n, i == null ? void 0 : i.entityGuid) : n
+      };
+      return this.queryStringsBuilder && (h.qs = this.queryStringsBuilder(n, i == null ? void 0 : i.entityGuid)), {
+        targetApp: i,
+        payload: h
+      };
+    })) : B(52);
+  }
+  /**
+   * Cleanup task after a harvest.
+   * @param {object} result - the cbResult object from the harvester's send method
+   * @param {object=} result.targetApp - the target app object that was used to point the harvest to the correct app
+   * @param {string=} result.targetApp.entityGuid - the entity guid of the target app
+   * @param {boolean=} result.sent - whether the harvest was sent successfully
+   * @param {boolean=} result.retry - whether the harvest should be retried
+   */
+  postHarvestCleanup(t = {}) {
+    var a, i;
+    t.sent && t.retry && this.events.reloadSave(this.harvestOpts, (a = t.targetApp) == null ? void 0 : a.entityGuid), this.events.clearSave(this.harvestOpts, (i = t.targetApp) == null ? void 0 : i.entityGuid);
+  }
+  /**
+   * Checks for additional `jsAttributes` items to support backward compatibility with implementations of the agent where
+   * loader configurations may appear after the loader code is executed.
+   */
+  checkConfiguration(t) {
+    var r, a;
+    if (!Me(t.info)) {
+      const i = Ce();
+      let n = {
+        ...(r = i.info) == null ? void 0 : r.jsAttributes
+      };
+      try {
+        n = {
+          ...n,
+          ...(a = t.info) == null ? void 0 : a.jsAttributes
+        };
+      } catch {
+      }
+      Ae(t, {
+        ...i,
+        info: {
+          ...i.info,
+          jsAttributes: n
+        },
+        runtime: t.runtime
+      }, t.runtime.loaderType);
+    }
+  }
+  /**
+   * These are actions related to shared resources that should be initialized once by whichever feature Aggregate subclass loads first.
+   * This method should run after checkConfiguration, which may reset the agent's info/runtime object that is used here.
+   */
+  doOnceForAllAggregate(t) {
+    t.runtime.obfuscator || (t.runtime.obfuscator = new Be(t)), this.obfuscator = t.runtime.obfuscator, t.runtime.entityManager || (t.runtime.entityManager = new Qe(this.agentRef)), t.runtime.harvester || (t.runtime.harvester = new We(t));
+  }
+  /**
+   * Report a supportability metric
+   * @param {*} metricName The tag of the name matching the Angler aggregation tag
+   * @param {*} [value] An optional value to supply. If not supplied, the metric count will be incremented by 1 for every call.
+   */
+  reportSupportabilityMetric(t, r) {
+    oe(ce, [t, r], void 0, M.metrics, this.ee);
+  }
+}
+L = new WeakSet(), /**
+ * sets up the event store for the feature.  It must wait for the entity guid to be available before setting up the event store.  This is called once the rum response is received with an entityGuid.
+ * @param {string} entityGuid
+ * @returns {void}
+ */
+fe = function(t) {
+  var r;
+  if (!this.events)
+    switch (this.featureName) {
+      // SessionTrace + Replay have their own storage mechanisms.
+      case M.sessionTrace:
+      case M.sessionReplay:
+        break;
+      // Jserror and Metric features uses a singleton EventAggregator instead of a regular EventBuffer.
+      case M.jserrors:
+      case M.metrics:
+        this.events = (r = this.agentRef).sharedAggregator ?? (r.sharedAggregator = new re(this.agentRef, rt, t, "shared_aggregator"));
+        break;
+      /** All other features get EventBuffer in the ESM by default. Note: PVE is included here, but event buffer will always be empty so future harvests will still not happen by interval or EOL.
+      This was necessary to prevent race cond. issues where the event buffer was checked before the feature could "block" itself.
+      Its easier to just keep an empty event buffer in place. */
+      default:
+        this.events = new re(this.agentRef, Ge, t, this.featureName);
+        break;
+    }
+};
+export {
+  ct as A,
+  Ge as E,
+  ot as I,
+  He as M,
+  Pe as c,
+  Ne as i,
+  _e as o
+};