gather-vue 8.6.0

package/dist/gather_widget.css

@@ -0,0 +1,58 @@
+.gather-panel-frame-container {
+  position: fixed;
+  border: 0;
+  outline: 0;
+  overflow: hidden;
+  z-index: 1;
+  /* box-shadow: 0 0 80px 0 rgba(0,0,0,.12); */
+  -webkit-animation: smileFadeSlideUp .2s ease-in!important;
+  animation: smileFadeSlideUp .2s ease-in!important;
+}
+.gather-panel-frame-container.gather-minimized {
+  width: 195px;
+  height: 50px;
+  background: transparent;
+  overflow: hidden;
+  border-radius: 4px;
+}
+.gather-panel-frame-container.gather-minimized.gather-sticky-left {
+  transform: rotate(-90deg);
+  transform-origin: bottom left;
+}
+.gather-panel-frame-container.gather-minimized.gather-sticky-right {
+  transform: rotate(90deg);
+  transform-origin: bottom right;
+}
+.gather-panel-frame-container.gather-minimized.gather-center-full {
+  width: auto;
+  border-radius: 0px;
+}
+.gather-panel-frame-container.gather-maximized {
+  height: 100%;
+  width: 600px;
+}
+.gather-panel-frame-container.gather-hidden {
+  display: none;
+}
+.gather-panel-frame-container.gather-inline {
+  width: 100% !important;
+  height: 100% !important;
+  position: relative;
+}
+.gather-panel-frame-container.gather-inline  .gather-panel-ui-container {
+  width: 100%;
+  height: 100%;
+}
+
+@media only screen and (max-height: 450px), only screen and (max-width: 600px) {
+  .gather-panel-frame-container.gather-maximized {
+    border-radius: 0!important;
+    height: 100%!important;
+    max-height: 100vh!important;
+    top: 0!important;
+    right: 0!important;
+    left: 0!important;
+    width: 100% !important;
+    max-width: 100vw !important;
+  }
+}

package/dist/gather_widget.js

@@ -0,0 +1,72 @@
+function loadGather() {
+  console.log('Loading gather.......1');
+  if (document.createStyleSheet) {
+    document.createStyleSheet('https://d1zrcjopr6e3i9.cloudfront.net/gather_widget.css');
+  } else {
+    var styles = "@import url(' https://d1zrcjopr6e3i9.cloudfront.net/gather_widget.css ');";
+    var newSS = document.createElement('link');
+    newSS.rel = 'stylesheet';
+    newSS.href = 'data:text/css,' + escape(styles);
+    document.getElementsByTagName('head')[0].appendChild(newSS);
+  }
+
+  window.addEventListener(
+    'message',
+    function (event) {
+      if (event.data.gatherMessage === 'toggleVisible') {
+        var container = this.document.getElementsByClassName('gather-panel-frame-container')[0];
+        console.log('Going to toggle!');
+        container.classList.toggle('gather-minimized');
+        container.classList.toggle('gather-maximized');
+
+        if (container.classList.contains('gather-maximized')) {
+          container.style.bottom = 'calc(0px)';
+          container.style.left = '0px';
+        } else if (container.classList.contains('gather-minimized')) {
+          container.style.bottom = '20px';
+          container.style.left = '20px';
+        }
+      }
+      if (event.data === 'toggle-gather-app') {
+        var launcher = this.document.getElementById('gather-launcher');
+        if (launcher && launcher.contentWindow) {
+          launcher.contentWindow.postMessage('toggle-gather-app', '*');
+        }
+      }
+    },
+    false
+  );
+
+  var div = document.createElement('div');
+  div.insertAdjacentHTML(
+    'beforeend',
+    `<div id="gather-panel-container" class="gather-panel-ui-container" style="position: fixed; width: 0px; height: 0px; bottom: 0px; right: 0px; z-index: 2147483647;">
+      <div class="gather-panel-frame-container gather-minimized" style="bottom: 20px; left: 20px;">
+        <iframe
+          id="gather-launcher"
+          src="https://d1zrcjopr6e3i9.cloudfront.net/index.html?campaignid=${window.gather_campaignid}&accountid=${window.gather_accountid}&referralcode=${window.gather_referralcode}"
+          class="gather-launcher-frame"
+          allowTransparency="true"
+          style="
+            position: absolute;
+            width: 100%;
+            height: 100%;
+            border: 0;
+            outline: 0;
+            top: 0;
+            right: 0;
+            bottom: 0;
+            left: 0;
+            background: transparent;"
+        ></iframe>
+      </div>
+    </div>`
+  );
+  document.body.appendChild(div);
+}
+
+window.onload = function () {
+  setTimeout(function () {
+    loadGather();
+  }, 1000);
+};

package/dist/iframe-BELrOJ1p.js

@@ -0,0 +1,6 @@
+function e(r) {
+  return r ? r.self !== r.top : !1;
+}
+export {
+  e as i
+};

package/dist/index-3lvNtPTE.js

@@ -0,0 +1,327 @@
+var U = Object.defineProperty;
+var N = (h) => {
+  throw TypeError(h);
+};
+var x = (h, e, t) => e in h ? U(h, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : h[e] = t;
+var g = (h, e, t) => x(h, typeof e != "symbol" ? e + "" : e, t), A = (h, e, t) => e.has(h) || N("Cannot " + t);
+var M = (h, e, t) => (A(h, e, "read from private field"), t ? t.call(h) : e.get(h)), b = (h, e, t) => e.has(h) ? N("Cannot add the same private member more than once") : e instanceof WeakSet ? e.add(h) : e.set(h, t), y = (h, e, t, s) => (A(h, e, "write to private field"), s ? s.call(h, t) : e.set(h, t), t), u = (h, e, t) => (A(h, e, "access private method"), t);
+import { aE as D, aF as m, z as H, B as E, M as C, aG as _, m as L, d, r as K } from "./main-DPldah1M.js";
+import { A as P, o as B, c as j } from "./aggregate-base-C6N8Ymd5.js";
+import { e as F } from "./event-origin-BSW5uum9.js";
+import { a as z } from "./traverse-Bw4y1x4D.js";
+class R {
+  constructor(e, t, s, i, n) {
+    this.n = e, this.s = t, this.e = s, this.o = i, this.t = n;
+  }
+}
+const V = 30 * 1e3, G = typeof E.PerformanceObserver == "function", T = {
+  // we find that certain events make the data too noisy to be useful
+  global: {
+    mouseup: !0,
+    mousedown: !0,
+    mousemove: !0
+  },
+  // certain events are present both in the window and in PVT metrics.  PVT metrics are prefered so the window events should be ignored
+  window: {
+    load: !0,
+    pagehide: !0
+  },
+  // when ajax instrumentation is disabled, all XMLHttpRequest events will return with origin = xhrOriginMissing and should be ignored
+  xhrOriginMissing: {
+    ignoreAll: !0
+  }
+}, k = {
+  typing: [1e3, 2e3],
+  scrolling: [100, 1e3],
+  mousing: [1e3, 2e3],
+  touching: [1e3, 2e3]
+};
+var v, c, l, p, S;
+class W {
+  constructor(e) {
+    b(this, c);
+    g(this, "nodeCount", 0);
+    g(this, "trace", {});
+    g(this, "earliestTimeStamp", 1 / 0);
+    g(this, "latestTimeStamp", 0);
+    g(this, "prevStoredEvents", /* @__PURE__ */ new Set());
+    b(this, v);
+    b(this, S, 0);
+    this.parent = e;
+  }
+  /**
+   * Trim the collection of nodes awaiting harvest such that those seen outside a certain span of time are discarded.
+   * @param {number} lookbackDuration Past length of time until now for which we care about nodes, in milliseconds
+   * @returns {number} However many nodes were discarded after trimming.
+   */
+  trimSTNs(e) {
+    let t = 0;
+    const s = Math.max(H() - e, 0);
+    return Object.keys(this.trace).forEach((i) => {
+      const n = this.trace[i];
+      let r = n.findIndex((a) => s <= a.e);
+      r !== 0 && (r < 0 ? (r = n.length, delete this.trace[i]) : n.splice(0, r), this.nodeCount -= r, t += r);
+    }), t;
+  }
+  /** Used by session trace's harvester to create the payload body. */
+  takeSTNs() {
+    var i, n;
+    G || this.storeResources((n = (i = E.performance) == null ? void 0 : i.getEntriesByType) == null ? void 0 : n.call(i, "resource"));
+    const e = Object.entries(this.trace).flatMap(([r, a]) => {
+      if (!(r in k)) return a;
+      const o = this.smearEvtsByOrigin(r), f = a.sort((O, w) => O.s - w.s).reduce(o, {});
+      return Object.values(f).flat();
+    }, this), t = this.earliestTimeStamp, s = this.latestTimeStamp;
+    return {
+      stns: e,
+      earliestTimeStamp: t,
+      latestTimeStamp: s
+    };
+  }
+  smearEvtsByOrigin(e) {
+    const t = k[e][0], s = k[e][1], i = {};
+    return (r, a) => {
+      let o = r[a.o];
+      o || (o = r[a.o] = []);
+      const f = i[a.o];
+      return e === "scrolling" && !n(a) ? (i[a.o] = null, a.n = "scroll", o.push(a)) : f && a.s - f.s < s && f.e > a.s - t ? f.e = a.e : (i[a.o] = a, o.push(a)), r;
+    };
+    function n(r) {
+      return !!(r && typeof r.e == "number" && typeof r.s == "number" && r.e - r.s < 4);
+    }
+  }
+  storeNode(e) {
+    u(this, c, l).call(this) && u(this, c, p).call(this, e);
+  }
+  processPVT(e, t, s) {
+    this.storeTiming({
+      [e]: t
+    });
+  }
+  storeTiming(e, t = !1) {
+    if (e)
+      for (let s in e) {
+        let i = e[s];
+        const n = s.toLowerCase();
+        if (!(n.indexOf("size") >= 0 || n.indexOf("status") >= 0) && typeof i == "number" && i >= 0) {
+          if (i = Math.round(i), this.parent.timeKeeper && this.parent.timeKeeper.ready && t && (i = this.parent.timeKeeper.convertAbsoluteTimestamp(Math.floor(this.parent.timeKeeper.correctAbsoluteTimestamp(i)))), !u(this, c, l).call(this)) return;
+          u(this, c, p).call(this, new R(s, i, i, "document", "timing"));
+        }
+      }
+  }
+  // Tracks the events and their listener's duration on objects wrapped by wrap-events.
+  storeEvent(e, t, s, i) {
+    if (this.shouldIgnoreEvent(e, t) || !u(this, c, l).call(this) || this.prevStoredEvents.has(e)) return;
+    this.prevStoredEvents.add(e);
+    const n = new R(this.evtName(e.type), s, i, void 0, "event");
+    try {
+      n.o = F(e.target, t, this.parent.ee);
+    } catch {
+      n.o = F(null, t, this.parent.ee);
+    }
+    u(this, c, p).call(this, n);
+  }
+  shouldIgnoreEvent(e, t) {
+    if (e.type in T.global) return !0;
+    const s = F(e.target, t, this.parent.ee);
+    return T[s] && T[s].ignoreAll ? !0 : !!(T[s] && e.type in T[s]);
+  }
+  evtName(e) {
+    switch (e) {
+      case "keydown":
+      case "keyup":
+      case "keypress":
+        return "typing";
+      case "mousemove":
+      case "mouseenter":
+      case "mouseleave":
+      case "mouseover":
+      case "mouseout":
+        return "mousing";
+      case "scroll":
+        return "scrolling";
+      case "touchstart":
+      case "touchmove":
+      case "touchend":
+      case "touchcancel":
+      case "touchenter":
+      case "touchleave":
+        return "touching";
+      default:
+        return e;
+    }
+  }
+  // Tracks when the window history API specified by wrap-history is used.
+  storeHist(e, t, s) {
+    u(this, c, l).call(this) && u(this, c, p).call(this, new R("history.pushState", s, s, e, t));
+  }
+  // Processes all the PerformanceResourceTiming entries captured (by observer).
+  storeResources(e) {
+    if (!(!e || e.length === 0)) {
+      for (let t = 0; t < e.length; t++) {
+        const s = e[t];
+        if ((s.fetchStart | 0) <= M(this, S)) continue;
+        if (!u(this, c, l).call(this)) break;
+        const {
+          initiatorType: i,
+          fetchStart: n,
+          responseEnd: r,
+          entryType: a
+        } = s, {
+          protocol: o,
+          hostname: f,
+          port: O,
+          pathname: w
+        } = C(s.name), I = new R(i, n | 0, r | 0, "".concat(o, "://").concat(f, ":").concat(O).concat(w), a);
+        u(this, c, p).call(this, I);
+      }
+      y(this, S, e[e.length - 1].fetchStart | 0);
+    }
+  }
+  // JavascriptError (FEATURE) events pipes into ST here.
+  storeErrorAgg(e, t, s, i) {
+    e === "err" && u(this, c, l).call(this) && u(this, c, p).call(this, new R("error", i.time, i.time, s.message, s.stackHash));
+  }
+  // Ajax (FEATURE) events--XML & fetches--pipes into ST here.
+  storeXhrAgg(e, t, s, i) {
+    e === "xhr" && u(this, c, l).call(this) && u(this, c, p).call(this, new R("Ajax", i.time, i.time + i.duration, "".concat(s.status, " ").concat(s.method, ": ").concat(s.host).concat(s.pathname), "ajax"));
+  }
+  /* Below are the interface expected & required of whatever storage is used across all features on an individual basis. This allows a common `.events` property on Trace shared with AggregateBase.
+    Note that the usage must be in sync with the EventStoreManager class such that AggregateBase.makeHarvestPayload can run the same regardless of which storage class a feature is using. */
+  isEmpty() {
+    return this.nodeCount === 0;
+  }
+  save() {
+    y(this, v, this.trace);
+  }
+  get() {
+    return [{
+      targetApp: this.parent.agentRef.runtime.entityManager.get(),
+      data: this.takeSTNs()
+    }];
+  }
+  clear() {
+    this.trace = {}, this.nodeCount = 0, this.prevStoredEvents.clear(), this.earliestTimeStamp = 1 / 0, this.latestTimeStamp = 0;
+  }
+  reloadSave() {
+    for (const e of Object.values(M(this, v)))
+      for (const t of e) {
+        if (!u(this, c, l).call(this)) return;
+        u(this, c, p).call(this, t);
+      }
+  }
+  clearSave() {
+    y(this, v, void 0);
+  }
+}
+v = new WeakMap(), c = new WeakSet(), l = function() {
+  return !(this.parent.blocked || this.nodeCount >= D && (this.parent.mode !== m.ERROR || this.trimSTNs(V) === 0));
+}, /** Central internal function called by all the other store__ & addToTrace API to append a trace node. They MUST all have checked #canStoreNewNode before calling this func!! */
+p = function(e) {
+  this.trace[e.n] ? this.trace[e.n].push(e) : this.trace[e.n] = [e], e.s < this.earliestTimeStamp && (this.earliestTimeStamp = e.s), e.s > this.latestTimeStamp && (this.latestTimeStamp = e.s), this.nodeCount++;
+}, S = new WeakMap();
+const X = 30 * 1e3, q = 5e3;
+class Q extends P {
+  constructor(e) {
+    super(e, _), this.harvestOpts.raw = !0, this.entitled = void 0, this.everHarvested = !1, this.harvesting = !1, this.events = new W(this), this.waitForFlags(["sts", "st"]).then(([t, s]) => this.initialize(t, s));
+  }
+  /** Sets up event listeners, and initializes this module to run in the correct "mode".  Can be triggered from a few places, but makes an effort to only set up listeners once */
+  initialize(e, t, s) {
+    var i, n, r, a;
+    if (this.entitled ?? (this.entitled = t), this.entitled || (this.blocked = !0), this.blocked) return this.deregisterDrain();
+    if (this.initialized || (this.initialized = !0, this.ptid = this.agentRef.runtime.ptid, this.sessionId = (i = this.agentRef.runtime.session) == null ? void 0 : i.state.value, this.ee.on(L.RESET, () => {
+      this.blocked || this.abort(1);
+    }), this.ee.on(L.UPDATE, (o, f) => {
+      this.blocked || (this.mode !== m.FULL && (f.sessionReplayMode === m.FULL || f.sessionTraceMode === m.FULL) && this.switchToFull(), (this.sessionId !== f.value || o === "cross-tab" && f.sessionTraceMode === m.OFF) && this.abort(2));
+    }), typeof PerformanceNavigationTiming < "u" ? this.events.storeTiming((r = (n = E.performance) == null ? void 0 : n.getEntriesByType) == null ? void 0 : r.call(n, "navigation")[0]) : this.events.storeTiming((a = E.performance) == null ? void 0 : a.timing, !0)), !this.agentRef.runtime.session.isNew && !s ? this.mode = this.agentRef.runtime.session.state.sessionTraceMode : this.mode = e, this.mode === m.OFF) return this.deregisterDrain();
+    this.timeKeeper ?? (this.timeKeeper = this.agentRef.runtime.timeKeeper), d("bst", (...o) => this.events.storeEvent(...o), this.featureName, this.ee), d("bstResource", (...o) => this.events.storeResources(...o), this.featureName, this.ee), d("bstHist", (...o) => this.events.storeHist(...o), this.featureName, this.ee), d("bstXhrAgg", (...o) => this.events.storeXhrAgg(...o), this.featureName, this.ee), d("bstApi", (...o) => this.events.storeNode(...o), this.featureName, this.ee), d("trace-jserror", (...o) => this.events.storeErrorAgg(...o), this.featureName, this.ee), d("pvtAdded", (...o) => this.events.processPVT(...o), this.featureName, this.ee), this.mode !== m.FULL && d("trace-jserror", () => {
+      this.mode === m.ERROR && this.switchToFull();
+    }, this.featureName, this.ee), this.agentRef.runtime.session.write({
+      sessionTraceMode: this.mode
+    }), this.drain(), this.agentRef.runtime.harvester.triggerHarvestFor(this);
+  }
+  preHarvestChecks() {
+    var e;
+    if (!(this.blocked || this.mode !== m.FULL) && (e = this.timeKeeper) != null && e.ready && this.agentRef.runtime.session) {
+      if (this.sessionId !== this.agentRef.runtime.session.state.value || this.ptid !== this.agentRef.runtime.ptid) {
+        this.abort(3);
+        return;
+      }
+      return !0;
+    }
+  }
+  serializer({
+    stns: e
+  }) {
+    if (e.length)
+      return this.everHarvested = !0, z(e, this.obfuscator.obfuscateString.bind(this.obfuscator), "string");
+  }
+  queryStringsBuilder({
+    stns: e,
+    earliestTimeStamp: t,
+    latestTimeStamp: s
+  }) {
+    var o, f;
+    const i = !this.agentRef.runtime.session.state.traceHarvestStarted;
+    i && this.agentRef.runtime.session.write({
+      traceHarvestStarted: !0
+    });
+    const n = this.agentRef.runtime.session.state.sessionReplayMode === 1, r = this.agentRef.info.jsAttributes["enduser.id"], a = (f = (o = this.agentRef.runtime.appMetadata.agents) == null ? void 0 : o[0]) == null ? void 0 : f.entityGuid;
+    return {
+      browser_monitoring_key: this.agentRef.info.licenseKey,
+      type: "BrowserSessionChunk",
+      app_id: this.agentRef.info.applicationID,
+      protocol_version: "0",
+      timestamp: Math.floor(this.timeKeeper.correctRelativeTimestamp(t)),
+      attributes: B({
+        ...a && {
+          entityGuid: a
+        },
+        harvestId: "".concat(this.agentRef.runtime.session.state.value, "_").concat(this.agentRef.runtime.ptid, "_").concat(this.agentRef.runtime.harvestCount),
+        // 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
+        // trace payload metadata
+        "trace.firstTimestamp": Math.floor(this.timeKeeper.correctRelativeTimestamp(t)),
+        "trace.lastTimestamp": Math.floor(this.timeKeeper.correctRelativeTimestamp(s)),
+        "trace.nodes": e.length,
+        "trace.originTimestamp": this.timeKeeper.correctedOriginTime,
+        // other payload metadata
+        agentVersion: this.agentRef.runtime.version,
+        ...i && {
+          firstSessionHarvest: i
+        },
+        ...n && {
+          hasReplay: n
+        },
+        ptid: "".concat(this.ptid),
+        session: "".concat(this.sessionId),
+        // 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(j("" + location))
+        // The Query Param is being arbitrarily limited in length here.  It is also applied when estimating the size of the payload in getPayloadSize()
+      }, q).substring(1)
+      // remove the leading '&'
+    };
+  }
+  /** Switch from "off" or "error" to full mode (if entitled) */
+  switchToFull() {
+    if (this.mode === m.FULL || !this.entitled || this.blocked) return;
+    const e = this.mode;
+    if (this.mode = m.FULL, this.agentRef.runtime.session.write({
+      sessionTraceMode: this.mode
+    }), e === m.OFF || !this.initialized) return this.initialize(this.mode, this.entitled);
+    this.initialized && (this.events.trimSTNs(X), this.agentRef.runtime.harvester.triggerHarvestFor(this));
+  }
+  /** Stop running for the remainder of the page lifecycle */
+  abort(e) {
+    K(60, e), this.blocked = !0, this.mode = m.OFF, this.agentRef.runtime.session.write({
+      sessionTraceMode: this.mode
+    }), this.events.clear();
+  }
+}
+g(Q, "featureName", _);
+export {
+  Q as Aggregate
+};