gather-vue 8.6.0

package/dist/index-BMIST_QA.js

@@ -0,0 +1,128 @@
+var M = Object.defineProperty;
+var E = (n, t, e) => t in n ? M(n, t, { enumerable: !0, configurable: !0, writable: !0, value: e }) : n[t] = e;
+var o = (n, t, e) => E(n, typeof t != "symbol" ? t + "" : t, e);
+import { L as m, j as b, k as u, l as y, m as d, A as f, n as R, p as a, d as L, q as T, r as g, s as v, t as S, v as F } from "./main-DPldah1M.js";
+import { c as O, A, M as N } from "./aggregate-base-C6N8Ymd5.js";
+import { a as _ } from "./traverse-Bw4y1x4D.js";
+class I {
+  /**
+   * @param {number} timestamp - Unix timestamp
+   * @param {string} message - message string
+   * @param {object} attributes - other log event attributes
+   * @param {enum} level - Log level
+   */
+  constructor(t, e, i = {}, s = m.INFO) {
+    /** @type {long} the unix timestamp of the log event */
+    o(this, "timestamp");
+    /** @type {string} the log message */
+    o(this, "message");
+    /** @type {object} the object of attributes to be parsed by logging ingest into top-level properties */
+    o(this, "attributes");
+    /** @type {'ERROR'|'TRACE'|'DEBUG'|'INFO'|'WARN'} the log type of the log */
+    o(this, "level");
+    this.timestamp = t, this.message = e, this.attributes = {
+      ...i,
+      pageUrl: O("" + b)
+    }, this.level = s.toUpperCase();
+  }
+}
+class k extends A {
+  constructor(t) {
+    super(t, u), this.isSessionTrackingEnabled = y(t.init) && t.runtime.session, this.ee.on(d.RESET, () => {
+      this.abort(f.RESET);
+    }), this.ee.on(d.UPDATE, (e, i) => {
+      this.blocked || e !== R.CROSS_TAB || (this.loggingMode !== a.OFF && i.loggingMode === a.OFF ? this.abort(f.CROSS_TAB) : this.loggingMode = i.loggingMode);
+    }), this.harvestOpts.raw = !0, this.waitForFlags(["log"]).then(([e]) => {
+      const i = this.agentRef.runtime.session ?? {};
+      if (this.loggingMode === a.OFF || i.isNew && e === a.OFF) {
+        this.blocked = !0, this.deregisterDrain();
+        return;
+      }
+      i.isNew || !this.isSessionTrackingEnabled ? this.updateLoggingMode(e) : this.loggingMode = i.state.loggingMode, L(T, this.handleLog.bind(this), this.featureName, this.ee), this.drain(), t.runtime.harvester.triggerHarvestFor(this);
+    });
+  }
+  updateLoggingMode(t) {
+    this.loggingMode = t, this.syncWithSessionManager({
+      loggingMode: this.loggingMode
+    });
+  }
+  handleLog(t, e, i = {}, s = m.INFO, l) {
+    if (!this.agentRef.runtime.entityManager.get(l)) return g(56, this.featureName);
+    if (this.blocked || !this.loggingMode) return;
+    if ((!i || typeof i != "object") && (i = {}), typeof s == "string" && (s = s.toUpperCase()), !v(s)) return g(30, s);
+    if (this.loggingMode < (a[s] || 1 / 0)) {
+      this.reportSupportabilityMetric("Logging/Event/Dropped/Sampling");
+      return;
+    }
+    try {
+      if (typeof e != "string") {
+        const p = S(e);
+        p && p !== "{}" ? e = p : e = String(e);
+      }
+    } catch {
+      g(16, e), this.reportSupportabilityMetric("Logging/Event/Dropped/Casting");
+      return;
+    }
+    if (typeof e != "string" || !e) return g(32);
+    const r = new I(Math.floor(this.agentRef.runtime.timeKeeper.correctRelativeTimestamp(t)), e, i, s), h = r.message.length + S(r.attributes).length + r.level.length + 10, c = "Logging/Harvest/Failed/Seen";
+    if (h > N) {
+      this.reportSupportabilityMetric(c, h), g(31, r.message.slice(0, 25) + "...");
+      return;
+    }
+    this.events.wouldExceedMaxSize(h, l) && (this.reportSupportabilityMetric("Logging/Harvest/Early/Seen", this.events.byteSize() + h), this.agentRef.runtime.harvester.triggerHarvestFor(this, {
+      targetEntityGuid: l
+    })), this.events.add(r, l) ? this.reportSupportabilityMetric("Logging/Event/Added/Seen") : (this.reportSupportabilityMetric(c, h), g(31, r.message.slice(0, 25) + "..."));
+  }
+  serializer(t, e) {
+    const i = this.agentRef.runtime.entityManager.get(e), s = this.agentRef.runtime.session;
+    return [{
+      common: {
+        /** Attributes in the `common` section are added to `all` logs generated in the payload */
+        attributes: {
+          "entity.guid": i.entityGuid,
+          // browser entity guid as provided API target OR the default from RUM response if not supplied
+          ...s && {
+            session: s.state.value || "0",
+            // The session ID that we generate and keep across page loads
+            hasReplay: s.state.sessionReplayMode === 1 && F(i, this.agentRef),
+            // True if a session replay recording is running
+            hasTrace: s.state.sessionTraceMode === 1
+            // True if a session trace recording is running
+          },
+          ptid: this.agentRef.runtime.ptid,
+          // page trace id
+          appId: i.applicationID || this.agentRef.info.applicationID,
+          // Application ID from info object,
+          standalone: !!this.agentRef.info.sa,
+          // copy paste (true) vs APM (false)
+          agentVersion: this.agentRef.runtime.version,
+          // browser agent version
+          // The following 3 attributes are evaluated and dropped at ingest processing time and do not get stored on NRDB:
+          "instrumentation.provider": "browser",
+          "instrumentation.version": this.agentRef.runtime.version,
+          "instrumentation.name": this.agentRef.runtime.loaderType,
+          // Custom attributes
+          ...this.agentRef.info.jsAttributes
+        }
+      },
+      /** logs section contains individual unique log entries */
+      logs: _(t, this.obfuscator.obfuscateString.bind(this.obfuscator), "string")
+    }];
+  }
+  queryStringsBuilder(t, e) {
+    return {
+      browser_monitoring_key: this.agentRef.runtime.entityManager.get(e).licenseKey
+    };
+  }
+  /** Abort the feature, once aborted it will not resume */
+  abort(t = {}) {
+    this.reportSupportabilityMetric("Logging/Abort/".concat(t.sm)), this.blocked = !0, this.events && (this.events.clear(), this.events.clearSave()), this.updateLoggingMode(a.OFF), this.deregisterDrain();
+  }
+  syncWithSessionManager(t = {}) {
+    this.isSessionTrackingEnabled && this.agentRef.runtime.session.write(t);
+  }
+}
+o(k, "featureName", u);
+export {
+  k as Aggregate
+};

package/dist/index-BdWnMhAc.js

@@ -0,0 +1,235 @@
+var U = Object.defineProperty;
+var I = (c, u, e) => u in c ? U(c, u, { enumerable: !0, configurable: !0, writable: !0, value: e }) : c[u] = e;
+var M = (c, u, e) => I(c, typeof u != "symbol" ? u + "" : u, e);
+import { aH as A, aF as a, l as L, m as R, A as f, n as z, d as O, aI as v, B, aJ as P, aK as N, t as w, r as C, aL as b, z as K, aM as D, aN as W } from "./main-DPldah1M.js";
+import { A as H, M as G, o as V, c as Y } from "./aggregate-base-C6N8Ymd5.js";
+import { s as j } from "./stylesheet-evaluator-B4P289vW.js";
+let k;
+const x = new Promise((c) => {
+  k = c;
+}), J = Object.freeze({
+  onReplayReady: k,
+  sessionReplayInitialized: x
+});
+class q extends H {
+  // pass the recorder into the aggregator
+  constructor(e, t) {
+    super(e, A);
+    M(this, "mode", a.OFF);
+    this.initialized = !1, this.blocked = !1, this.gzipper = void 0, this.u8 = void 0, this.entitled = !1, this.timeKeeper = void 0, this.recorder = t == null ? void 0 : t.recorder, this.errorNoticed = (t == null ? void 0 : t.errorNoticed) || !1, this.harvestOpts.raw = !0, this.isSessionTrackingEnabled = L(e.init) && !!e.runtime.session, this.reportSupportabilityMetric("Config/SessionReplay/Enabled"), this.ee.on(R.RESET, () => {
+      this.abort(f.RESET);
+    }), this.ee.on(R.PAUSE, () => {
+      var o;
+      (o = this.recorder) == null || o.stopRecording();
+    }), this.ee.on(R.RESUME, () => {
+      var o;
+      this.recorder && (this.mode = e.runtime.session.state.sessionReplayMode, !(!this.initialized || this.mode === a.OFF) && ((o = this.recorder) == null || o.startRecording()));
+    }), this.ee.on(R.UPDATE, (o, d) => {
+      !this.recorder || !this.initialized || this.blocked || o !== z.CROSS_TAB || (this.mode !== a.OFF && d.sessionReplayMode === a.OFF && this.abort(f.CROSS_TAB), this.mode = d.sessionReplayMode);
+    }), O(v.PAUSE, () => {
+      this.forceStop(this.mode === a.FULL);
+    }, this.featureName, this.ee), O(v.ERROR_DURING_REPLAY, (o) => {
+      this.handleError(o);
+    }, this.featureName, this.ee);
+    const {
+      error_sampling_rate: i,
+      sampling_rate: r,
+      autoStart: n,
+      block_selector: p,
+      mask_text_selector: l,
+      mask_all_inputs: s,
+      inline_images: h,
+      collect_fonts: g
+    } = e.init.session_replay;
+    this.waitForFlags(["srs", "sr"]).then(([o, d]) => {
+      if (this.entitled = !!d, !this.entitled) {
+        this.deregisterDrain(), this.agentRef.runtime.isRecording && (this.abort(f.ENTITLEMENTS), this.reportSupportabilityMetric("SessionReplay/EnabledNotEntitled/Detected"));
+        return;
+      }
+      this.drain(), this.initializeRecording(o);
+    }).then(() => {
+      var o, d, m, y;
+      if (this.mode === a.OFF)
+        for ((o = this.recorder) == null || o.stopRecording(); (d = this.recorder) != null && d.getEvents().events.length; ) (y = (m = this.recorder) == null ? void 0 : m.clearBuffer) == null || y.call(m);
+      J.onReplayReady(this.mode);
+    }), n || this.reportSupportabilityMetric("Config/SessionReplay/AutoStart/Modified"), g === !0 && this.reportSupportabilityMetric("Config/SessionReplay/CollectFonts/Modified"), h === !0 && this.reportSupportabilityMetric("Config/SessionReplay/InlineImages/Modifed"), s !== !0 && this.reportSupportabilityMetric("Config/SessionReplay/MaskAllInputs/Modified"), p !== "[data-nr-block]" && this.reportSupportabilityMetric("Config/SessionReplay/BlockSelector/Modified"), l !== "*" && this.reportSupportabilityMetric("Config/SessionReplay/MaskTextSelector/Modified"), this.reportSupportabilityMetric("Config/SessionReplay/SamplingRate/Value", r), this.reportSupportabilityMetric("Config/SessionReplay/ErrorSamplingRate/Value", i);
+  }
+  replayIsActive() {
+    return !!(this.recorder && this.mode === a.FULL && !this.blocked && this.entitled);
+  }
+  handleError(e) {
+    var t;
+    this.recorder && (this.recorder.currentBufferTarget.hasError = !0), this.mode === a.ERROR && ((t = B) == null ? void 0 : t.document.visibilityState) === "visible" && this.switchToFull();
+  }
+  switchToFull() {
+    !this.entitled || this.blocked || (this.mode = a.FULL, this.recorder && this.initialized ? (this.agentRef.runtime.isRecording || this.recorder.startRecording(), this.syncWithSessionManager({
+      sessionReplayMode: this.mode
+    })) : this.initializeRecording(a.FULL, !0));
+  }
+  /**
+   * Evaluate entitlements and sampling before starting feature mechanics, importing and configuring recording library, and setting storage state
+   * @param {boolean} srMode - the true/false state of the "sr" flag (aka. entitlements) from RUM response
+   * @param {boolean} ignoreSession - whether to force the method to ignore the session state and use just the sample flags
+   * @returns {void}
+   */
+  async initializeRecording(e, t) {
+    var n, p;
+    if (this.initialized = !0, !this.entitled) return;
+    const {
+      session: i,
+      timeKeeper: r
+    } = this.agentRef.runtime;
+    if (this.timeKeeper = r, ((n = this.recorder) == null ? void 0 : n.parent.trigger) === P.API && this.agentRef.runtime.isRecording ? this.mode = a.FULL : !i.isNew && !t ? this.mode = i.state.sessionReplayMode : this.mode = e, this.mode !== a.OFF) {
+      if (this.recorder)
+        this.recorder.parent = this;
+      else
+        try {
+          const {
+            Recorder: l
+          } = await import(
+            /* webpackChunkName: "recorder" */
+            "./recorder-PHZWRV-S.js"
+          );
+          this.recorder = new l(this), this.recorder.currentBufferTarget.hasError = this.errorNoticed;
+        } catch {
+          return this.abort(f.IMPORT);
+        }
+      this.mode === a.ERROR && this.errorNoticed && (this.mode = a.FULL), this.mode === a.FULL && ((p = this.recorder) == null ? void 0 : p.getEvents().type) === "preloaded" && this.prepUtils().then(() => this.agentRef.runtime.harvester.triggerHarvestFor(this)), await this.prepUtils(), this.agentRef.runtime.isRecording || this.recorder.startRecording(), this.syncWithSessionManager({
+        sessionReplayMode: this.mode
+      });
+    }
+  }
+  async prepUtils() {
+    try {
+      const {
+        gzipSync: e,
+        strToU8: t
+      } = await import(
+        /* webpackChunkName: "compressor" */
+        "./browser-q7cvfJ-2.js"
+      );
+      this.gzipper = e, this.u8 = t;
+    } catch {
+    }
+  }
+  makeHarvestPayload(e) {
+    var p;
+    const t = {
+      targetApp: void 0,
+      payload: void 0
+    };
+    if (this.mode !== a.FULL || this.blocked || !this.recorder || !((p = this.timeKeeper) != null && p.ready) || !this.recorder.hasSeenSnapshot) return;
+    const i = this.recorder.getEvents();
+    if (!i.events.length) return;
+    const r = this.getHarvestContents(i);
+    if (!r.body.length)
+      return this.recorder.clearBuffer(), [t];
+    this.reportSupportabilityMetric("SessionReplay/Harvest/Attempts");
+    let n = 0;
+    return this.gzipper && this.u8 ? (r.body = this.gzipper(this.u8("[".concat(r.body.map(({
+      __serialized: l,
+      ...s
+    }) => {
+      if (s.__newrelic && l) return l;
+      const h = {
+        ...s
+      };
+      return h.__newrelic || (h.__newrelic = N(s.timestamp, this.timeKeeper), h.timestamp = this.timeKeeper.correctAbsoluteTimestamp(s.timestamp)), w(h);
+    }).join(","), "]"))), n = r.body.length) : (r.body = r.body.map(({
+      __serialized: l,
+      ...s
+    }) => {
+      if (s.__newrelic) return s;
+      const h = {
+        ...s
+      };
+      return h.__newrelic = N(s.timestamp, this.timeKeeper), h.timestamp = this.timeKeeper.correctAbsoluteTimestamp(s.timestamp), h;
+    }), n = w(r.body).length), n > G ? (this.abort(f.TOO_BIG, n), [t]) : (this.agentRef.runtime.session.state.sessionReplaySentFirstChunk || this.syncWithSessionManager({
+      sessionReplaySentFirstChunk: !0
+    }), this.recorder.clearBuffer(), i.type === "preloaded" && this.agentRef.runtime.harvester.triggerHarvestFor(this), t.payload = r, this.agentRef.runtime.session.state.traceHarvestStarted || C(59, JSON.stringify(this.agentRef.runtime.session.state)), [t]);
+  }
+  getCorrectedTimestamp(e) {
+    if (e != null && e.timestamp)
+      return e.__newrelic ? e.timestamp : this.timeKeeper.correctAbsoluteTimestamp(e.timestamp);
+  }
+  getHarvestContents(e) {
+    var m, y, E, _, T, F;
+    e ?? (e = this.recorder.getEvents());
+    let t = e.events;
+    const i = this.agentRef.runtime, r = (m = this.agentRef.info.jsAttributes) == null ? void 0 : m["enduser.id"];
+    ((y = t == null ? void 0 : t[0]) == null ? void 0 : y.type) === b.FullSnapshot && this.recorder.lastMeta && (e.hasMeta = !0, t.unshift(this.recorder.lastMeta), this.recorder.lastMeta = void 0), ((E = t[t.length - 1]) == null ? void 0 : E.type) === b.Meta && (this.recorder.lastMeta = t[t.length - 1], t = t.slice(0, t.length - 1), e.hasMeta = !!t.find((S) => S.type === b.Meta));
+    const l = K(), s = this.getCorrectedTimestamp(t[0]), h = this.getCorrectedTimestamp(t[t.length - 1]), g = s || Math.floor(this.timeKeeper.correctAbsoluteTimestamp(e.cycleTimestamp)), o = h || Math.floor(this.timeKeeper.correctRelativeTimestamp(l)), d = ((T = (_ = i.appMetadata) == null ? void 0 : _.agents) == null ? void 0 : T[0]) || {};
+    return {
+      qs: {
+        browser_monitoring_key: this.agentRef.info.licenseKey,
+        type: "SessionReplay",
+        app_id: this.agentRef.info.applicationID,
+        protocol_version: "0",
+        timestamp: g,
+        attributes: V({
+          // this section of attributes must be controllable and stay below the query param padding limit -- see QUERY_PARAM_PADDING
+          // if not, data could be lost to truncation at time of sending, potentially breaking parsing / API behavior in NR1
+          ...!!this.gzipper && !!this.u8 && {
+            content_encoding: "gzip"
+          },
+          ...d.entityGuid && {
+            entityGuid: d.entityGuid
+          },
+          harvestId: [(F = i.session) == null ? void 0 : F.state.value, i.ptid, i.harvestCount].filter((S) => S).join("_"),
+          "replay.firstTimestamp": g,
+          "replay.lastTimestamp": o,
+          "replay.nodes": t.length,
+          "session.durationMs": i.session.getDuration(),
+          agentVersion: i.version,
+          session: i.session.state.value,
+          rst: l,
+          hasMeta: e.hasMeta || !1,
+          hasSnapshot: e.hasSnapshot || !1,
+          hasError: e.hasError || !1,
+          isFirstChunk: i.session.state.sessionReplaySentFirstChunk === !1,
+          decompressedBytes: e.payloadBytesEstimation,
+          invalidStylesheetsDetected: j.invalidStylesheetsDetected,
+          inlinedAllStylesheets: e.inlinedAllStylesheets,
+          "rrweb.version": W,
+          "payload.type": e.type,
+          // customer-defined data should go last so that if it exceeds the query param padding limit it will be truncated instead of important attrs
+          ...r && {
+            "enduser.id": this.obfuscator.obfuscateString(r)
+          },
+          currentUrl: this.obfuscator.obfuscateString(Y("" + location))
+          // The Query Param is being arbitrarily limited in length here.  It is also applied when estimating the size of the payload in getPayloadSize()
+        }, D).substring(1)
+        // remove the leading '&'
+      },
+      body: t
+    };
+  }
+  postHarvestCleanup(e) {
+    e.status === 429 && this.abort(f.TOO_MANY);
+  }
+  /**
+   * Forces the agent into OFF mode so that changing tabs or navigating
+   * does not restart the recording. This is used when the customer calls
+   * the stopRecording API.
+   */
+  forceStop(e) {
+    var t, i;
+    e && this.agentRef.runtime.harvester.triggerHarvestFor(this), this.mode = a.OFF, (i = (t = this.recorder) == null ? void 0 : t.stopRecording) == null || i.call(t), this.syncWithSessionManager({
+      sessionReplayMode: this.mode
+    });
+  }
+  /** Abort the feature, once aborted it will not resume */
+  abort(e = {}, t) {
+    var i, r, n, p, l, s, h;
+    for (C(33, e.message), this.reportSupportabilityMetric("SessionReplay/Abort/".concat(e.sm), t), this.blocked = !0, this.mode = a.OFF, (r = (i = this.recorder) == null ? void 0 : i.stopRecording) == null || r.call(i), this.syncWithSessionManager({
+      sessionReplayMode: this.mode
+    }), (p = (n = this.recorder) == null ? void 0 : n.clearTimestamps) == null || p.call(n); (l = this.recorder) != null && l.getEvents().events.length; ) (h = (s = this.recorder) == null ? void 0 : s.clearBuffer) == null || h.call(s);
+  }
+  syncWithSessionManager(e = {}) {
+    this.isSessionTrackingEnabled && this.agentRef.runtime.session.write(e);
+  }
+}
+M(q, "featureName", A);
+export {
+  q as Aggregate
+};

package/dist/index-BioZsJbf.js

@@ -0,0 +1,190 @@
+var y = Object.defineProperty;
+var w = (e, t, i) => t in e ? y(e, t, { enumerable: !0, configurable: !0, writable: !0, value: i }) : e[t] = i;
+var u = (e, t, i) => w(e, typeof t != "symbol" ? t + "" : t, i);
+import { i as n, F as l, d, S, e as O, f as b, g as E, o as g, h as R, w as A } from "./main-DPldah1M.js";
+import { A as M, i as m } from "./aggregate-base-C6N8Ymd5.js";
+import { i as T } from "./iframe-BELrOJ1p.js";
+const r = {
+  REACT: "React",
+  NEXTJS: "NextJS",
+  VUE: "Vue",
+  NUXTJS: "NuxtJS",
+  ANGULAR: "Angular",
+  ANGULARUNIVERSAL: "AngularUniversal",
+  SVELTE: "Svelte",
+  SVELTEKIT: "SvelteKit",
+  PREACT: "Preact",
+  PREACTSSR: "PreactSSR",
+  ANGULARJS: "AngularJS",
+  BACKBONE: "Backbone",
+  EMBER: "Ember",
+  METEOR: "Meteor",
+  ZEPTO: "Zepto",
+  JQUERY: "Jquery",
+  MOOTOOLS: "MooTools",
+  QWIK: "Qwik",
+  ELECTRON: "Electron"
+};
+function P() {
+  if (!n) return [];
+  const e = [];
+  try {
+    C() && (e.push(r.REACT), N() && e.push(r.NEXTJS)), v() && (e.push(r.VUE), L() && e.push(r.NUXTJS)), j() && (e.push(r.ANGULAR), U() && e.push(r.ANGULARUNIVERSAL)), k() && (e.push(r.SVELTE), G() && e.push(r.SVELTEKIT)), I() && (e.push(r.PREACT), _() && e.push(r.PREACTSSR)), D() && e.push(r.ANGULARJS), Object.prototype.hasOwnProperty.call(window, "Backbone") && e.push(r.BACKBONE), Object.prototype.hasOwnProperty.call(window, "Ember") && e.push(r.EMBER), Object.prototype.hasOwnProperty.call(window, "Meteor") && e.push(r.METEOR), Object.prototype.hasOwnProperty.call(window, "Zepto") && e.push(r.ZEPTO), Object.prototype.hasOwnProperty.call(window, "jQuery") && e.push(r.JQUERY), Object.prototype.hasOwnProperty.call(window, "MooTools") && e.push(r.MOOTOOLS), Object.prototype.hasOwnProperty.call(window, "qwikevents") && e.push(r.QWIK), x() && e.push(r.ELECTRON);
+  } catch {
+  }
+  return e;
+}
+function C() {
+  try {
+    return Object.prototype.hasOwnProperty.call(window, "React") || Object.prototype.hasOwnProperty.call(window, "ReactDOM") || Object.prototype.hasOwnProperty.call(window, "ReactRedux") || document.querySelector("[data-reactroot], [data-reactid]") || (() => {
+      const e = document.querySelectorAll("body > div");
+      for (let t = 0; t < e.length; t++)
+        if (Object.prototype.hasOwnProperty.call(e[t], "_reactRootContainer"))
+          return !0;
+    })();
+  } catch {
+    return !1;
+  }
+}
+function N() {
+  try {
+    return Object.prototype.hasOwnProperty.call(window, "next") && Object.prototype.hasOwnProperty.call(window.next, "version");
+  } catch {
+    return !1;
+  }
+}
+function v() {
+  try {
+    return Object.prototype.hasOwnProperty.call(window, "Vue");
+  } catch {
+    return !1;
+  }
+}
+function L() {
+  try {
+    return Object.prototype.hasOwnProperty.call(window, "$nuxt") && Object.prototype.hasOwnProperty.call(window.$nuxt, "nuxt");
+  } catch {
+    return !1;
+  }
+}
+function j() {
+  try {
+    return Object.prototype.hasOwnProperty.call(window, "ng") || document.querySelector("[ng-version]");
+  } catch {
+    return !1;
+  }
+}
+function U() {
+  try {
+    return document.querySelector("[ng-server-context]");
+  } catch {
+    return !1;
+  }
+}
+function k() {
+  try {
+    return Object.prototype.hasOwnProperty.call(window, "__svelte");
+  } catch {
+    return !1;
+  }
+}
+function G() {
+  try {
+    return !!Object.keys(window).find((e) => e.startsWith("__sveltekit"));
+  } catch {
+    return !1;
+  }
+}
+function I() {
+  try {
+    return Object.prototype.hasOwnProperty.call(window, "preact");
+  } catch {
+    return !1;
+  }
+}
+function _() {
+  try {
+    return document.querySelector('script[type="__PREACT_CLI_DATA__"]');
+  } catch {
+    return !1;
+  }
+}
+function D() {
+  try {
+    return Object.prototype.hasOwnProperty.call(window, "angular") || document.querySelector(".ng-binding, [ng-app], [data-ng-app], [ng-controller], [data-ng-controller], [ng-repeat], [data-ng-repeat]") || document.querySelector('script[src*="angular.js"], script[src*="angular.min.js"]');
+  } catch {
+    return !1;
+  }
+}
+function x() {
+  try {
+    return typeof navigator == "object" && typeof navigator.userAgent == "string" && navigator.userAgent.indexOf("Electron") >= 0;
+  } catch {
+    return !1;
+  }
+}
+class F extends M {
+  constructor(t) {
+    var i;
+    super(t, l), this.harvestOpts.aggregatorTypes = ["cm", "sm"], this.agentNonce = n && ((i = document.currentScript) == null ? void 0 : i.nonce), this.waitForFlags(["err"]).then(([o]) => {
+      o ? (this.singleChecks(), this.eachSessionChecks(), this.drain()) : (this.blocked = !0, this.deregisterDrain());
+    }), d(S, this.storeSupportabilityMetrics.bind(this), this.featureName, this.ee), d(O, this.storeEventMetrics.bind(this), this.featureName, this.ee);
+  }
+  preHarvestChecks(t) {
+    return this.drained && t.isFinalHarvest;
+  }
+  // only allow any metrics to be sent after we get the right RUM flag and only on EoL
+  storeSupportabilityMetrics(t, i) {
+    if (this.blocked) return;
+    const o = b, s = {
+      name: t
+    };
+    this.events.addMetric(o, t, s, i);
+  }
+  storeEventMetrics(t, i) {
+    if (this.blocked) return;
+    const o = E, s = {
+      name: t
+    };
+    this.events.add([o, t, s, i]);
+  }
+  singleChecks() {
+    const {
+      distMethod: t,
+      loaderType: i
+    } = this.agentRef.runtime, {
+      proxy: o,
+      privacy: s
+    } = this.agentRef.init;
+    if (i && this.storeSupportabilityMetrics("Generic/LoaderType/".concat(i, "/Detected")), t && this.storeSupportabilityMetrics("Generic/DistMethod/".concat(t, "/Detected")), n ? (this.storeSupportabilityMetrics("Generic/Runtime/Browser/Detected"), this.agentNonce && this.agentNonce !== "" && this.storeSupportabilityMetrics("Generic/Runtime/Nonce/Detected"), g(() => {
+      P().forEach((c) => {
+        this.storeSupportabilityMetrics("Framework/" + c + "/Detected");
+      });
+    }), s.cookies_enabled || this.storeSupportabilityMetrics("Config/SessionTracking/Disabled")) : R ? this.storeSupportabilityMetrics("Generic/Runtime/Worker/Detected") : this.storeSupportabilityMetrics("Generic/Runtime/Unknown/Detected"), m() && this.storeSupportabilityMetrics("Generic/FileProtocol/Detected"), this.obfuscator.obfuscateConfigRules.length > 0 && this.storeSupportabilityMetrics("Generic/Obfuscate/Detected"), o.assets && this.storeSupportabilityMetrics("Config/AssetsUrl/Changed"), o.beacon && this.storeSupportabilityMetrics("Config/BeaconUrl/Changed"), n && window.MutationObserver) {
+      T(window) && this.storeSupportabilityMetrics("Generic/Runtime/IFrame/Detected");
+      const c = window.document.querySelectorAll("video").length;
+      c && this.storeSupportabilityMetrics("Generic/VideoElement/Added", c);
+      const a = window.document.querySelectorAll("iframe").length;
+      a && this.storeSupportabilityMetrics("Generic/IFrame/Added", a), new MutationObserver((h) => {
+        h.forEach((f) => {
+          f.addedNodes.forEach((p) => {
+            p instanceof HTMLVideoElement && this.storeSupportabilityMetrics("Generic/VideoElement/Added", 1), p instanceof HTMLIFrameElement && this.storeSupportabilityMetrics("Generic/IFrame/Added", 1);
+          });
+        });
+      }).observe(window.document.body, {
+        childList: !0,
+        subtree: !0
+      });
+    }
+    navigator.webdriver && this.storeSupportabilityMetrics("Generic/WebDriver/Detected");
+  }
+  eachSessionChecks() {
+    n && A("pageshow", (t) => {
+      t != null && t.persisted && this.storeSupportabilityMetrics("Generic/BFCache/PageRestored");
+    });
+  }
+}
+u(F, "featureName", l);
+export {
+  F as Aggregate
+};