@lapwy/js 0.0.0-stage → 0.1.0

package/dist/index.js

@@ -0,0 +1,710 @@
+// src/core.ts
+var DEFAULT_ENDPOINT = "https://in.lapwy.com/e";
+var noop = { track() {
+}, page() {
+}, consent() {
+}, notFound() {
+} };
+function start(options) {
+  if (typeof window === "undefined" || typeof document === "undefined" || !options.site) return noop;
+  const w = window;
+  const d = document;
+  const loc = w.location;
+  const nav = w.navigator;
+  const key = options.site;
+  const endpoint = options.endpoint || DEFAULT_ENDPOINT;
+  const release = options.release || "";
+  const sdk = options.sdk || "web-0.1";
+  const cookieMode = options.cookie === "always" || options.cookie === "consent" ? options.cookie : "";
+  const ID = "lapwy_id";
+  let vid = "";
+  let queue = [];
+  let timer = 0;
+  let backoff = 0;
+  let pageId = "";
+  let pageUrl = "";
+  let rawUrl = "";
+  const patterns = (options.pages || []).map((p) => p.split("/"));
+  function grouped(url) {
+    try {
+      const u = new URL(url);
+      let path = u.pathname;
+      if (options.path) {
+        path = String(options.path(path) || path);
+        if (path[0] !== "/") path = "/" + path;
+      } else {
+        const parts = path.split("/");
+        if (parts.length > 2 && !parts[parts.length - 1]) parts.pop();
+        for (const p of patterns) {
+          const last = p.length - 1;
+          const star = p[last] === "*";
+          if (star ? parts.length < p.length : parts.length !== p.length) continue;
+          let fits = true;
+          for (let i = 0; fits && i <= last; i++) fits = star && i === last || (p[i][0] === ":" ? !!parts[i] : p[i] === parts[i]);
+          if (fits) {
+            path = p.join("/");
+            break;
+          }
+        }
+      }
+      return u.origin + path + u.search;
+    } catch {
+      return url;
+    }
+  }
+  const Q = "lapwy_q";
+  let kept = false;
+  function keep() {
+    try {
+      if (queue.length) w.localStorage.setItem(Q, JSON.stringify(queue.slice(0, 200)));
+      else w.localStorage.removeItem(Q);
+    } catch {
+    }
+    kept = queue.length > 0;
+  }
+  let shownAt = 0;
+  let engaged = 0;
+  let lastRef = d.referrer || "";
+  const rawFetch = w.fetch ? w.fetch.bind(w) : null;
+  function hex(n) {
+    const a = new Uint8Array(n);
+    let s = "";
+    (w.crypto || w.msCrypto).getRandomValues(a);
+    for (let i = 0; i < n; i++) s += (a[i] + 256).toString(16).slice(1);
+    return s;
+  }
+  function uuid() {
+    const h = hex(16);
+    return h.slice(0, 8) + "-" + h.slice(8, 12) + "-4" + h.slice(13, 16) + "-a" + h.slice(17, 20) + "-" + h.slice(20);
+  }
+  function add(kind, extra) {
+    const e = { id: uuid(), t: Date.now(), k: kind, u: pageUrl, p: pageId };
+    for (const k in extra) e[k] = extra[k];
+    queue.push(e);
+    if (!timer) timer = setTimeout(flush, 800);
+  }
+  function readId() {
+    const m = d.cookie.match(/(?:^|; )lapwy_id=([0-9a-f]{16,64})/);
+    let v = m ? m[1] : "";
+    try {
+      v = v || w.localStorage.getItem(ID) || "";
+    } catch {
+    }
+    return /^[0-9a-f]{16,64}$/.test(v) ? v : "";
+  }
+  function keepId() {
+    vid = readId() || hex(16);
+    d.cookie = ID + "=" + vid + "; Max-Age=34164000; Path=/; SameSite=Lax" + (loc.protocol === "https:" ? "; Secure" : "");
+    try {
+      w.localStorage.setItem(ID, vid);
+    } catch {
+    }
+  }
+  function dropId() {
+    vid = "";
+    d.cookie = ID + "=; Max-Age=0; Path=/; SameSite=Lax";
+    try {
+      w.localStorage.removeItem(ID);
+    } catch {
+    }
+  }
+  let input = 128;
+  [
+    ["pointermove", 1],
+    ["mousemove", 1],
+    ["pointerdown", 2],
+    ["click", 2],
+    ["keydown", 4],
+    ["wheel", 8],
+    ["touchstart", 16]
+  ].forEach(
+    ([type, bit]) => w.addEventListener(
+      type,
+      (ev) => {
+        if (ev.isTrusted) input |= bit;
+      },
+      { capture: true, passive: true }
+    )
+  );
+  let moves = 0;
+  let press = 0;
+  let downAt = 0;
+  w.addEventListener(
+    "pointermove",
+    (ev) => {
+      if (ev.isTrusted && ev.pointerType !== "touch" && moves < 255) moves++;
+    },
+    { capture: true, passive: true }
+  );
+  w.addEventListener(
+    "pointerdown",
+    (ev) => {
+      downAt = ev.isTrusted && ev.pointerType === "mouse" ? w.performance.now() : 0;
+    },
+    { capture: true, passive: true }
+  );
+  w.addEventListener(
+    "pointerup",
+    (ev) => {
+      if (!downAt || !ev.isTrusted || ev.pointerType !== "mouse") return;
+      const held = Math.min(Math.max(Math.round(w.performance.now() - downAt), 1), 6e4);
+      if (!press || held < press) press = held;
+      downAt = 0;
+    },
+    { capture: true, passive: true }
+  );
+  function odd() {
+    let b = 0;
+    try {
+      const g = w;
+      if (!nav.languages || !nav.languages.length) b |= 1;
+      if (/Chrome\//.test(nav.userAgent) && !/Edg|OPR/.test(nav.userAgent) && !g.chrome) b |= 2;
+      if (!g.outerWidth || !g.outerHeight) b |= 4;
+    } catch {
+    }
+    return b;
+  }
+  function automated() {
+    let b = 0;
+    try {
+      const g = w;
+      if (nav.webdriver) b |= 1;
+      if (g.callPhantom || g._phantom || g.__nightmare || g.__playwright__binding__ || g.__pwInitScripts || g.domAutomation || g.domAutomationController || d.documentElement.getAttribute("webdriver") !== null) b |= 2;
+    } catch {
+    }
+    return b;
+  }
+  let sg = {};
+  let sgStart = 0;
+  let sgOn = false;
+  let sgTimer = 0;
+  let sgX = -1;
+  let sgY = 0;
+  let sgSlot = -1;
+  let sgKeyAt = 0;
+  let sgScrollY = 0;
+  let sgMoved = false;
+  let sgDownAt = 0;
+  const clock = () => w.performance.now();
+  const bump = (k, by = 1) => {
+    sg[k] = (sg[k] || 0) + by;
+  };
+  const lowest = (k, v) => {
+    if (!(k in sg) || v < sg[k]) sg[k] = v;
+  };
+  const firstInput = () => {
+    if (!("fi" in sg)) sg.fi = clock() - sgStart;
+  };
+  const watch = (type, fn) => w.addEventListener(
+    type,
+    (ev) => {
+      try {
+        if (ev.isTrusted) fn(ev);
+      } catch {
+      }
+    },
+    { capture: true, passive: true }
+  );
+  watch("pointermove", (ev) => {
+    if (ev.pointerType === "touch") return;
+    bump("mv");
+    if (sgX >= 0) bump("md", Math.hypot(ev.clientX - sgX, ev.clientY - sgY));
+    sgX = ev.clientX;
+    sgY = ev.clientY;
+    const slot = Math.floor(clock() / 100);
+    if (slot !== sgSlot) bump("mb");
+    sgSlot = slot;
+    sgMoved = true;
+    firstInput();
+  });
+  watch("pointerdown", (ev) => {
+    bump("ck");
+    if (ev.pointerType === "mouse") {
+      if (!sgMoved) bump("cj");
+      sgMoved = false;
+      sgDownAt = clock();
+    }
+    firstInput();
+  });
+  watch("pointerup", (ev) => {
+    if (ev.pointerType !== "mouse" || !sgDownAt) return;
+    const held = clock() - sgDownAt;
+    sgDownAt = 0;
+    bump("pn");
+    bump("ps", held);
+    lowest("pmin", held);
+  });
+  watch("keydown", () => {
+    bump("kd");
+    const at = clock();
+    if (sgKeyAt && at - sgKeyAt < 5e3) {
+      bump("kn");
+      bump("ks", at - sgKeyAt);
+      lowest("kmin", at - sgKeyAt);
+    }
+    sgKeyAt = at;
+    firstInput();
+  });
+  watch("wheel", () => {
+    bump("wh");
+    firstInput();
+  });
+  watch("touchstart", () => {
+    bump("tc");
+    firstInput();
+  });
+  watch("touchmove", () => bump("tm"));
+  w.addEventListener(
+    "scroll",
+    () => {
+      try {
+        bump("sc");
+        bump("sd", Math.abs(w.scrollY - sgScrollY));
+        sgScrollY = w.scrollY;
+        const reached = (w.scrollY + w.innerHeight) / Math.max(d.documentElement.scrollHeight, 1) * 100;
+        if (!(sg.sp >= reached)) sg.sp = Math.min(reached, 100);
+      } catch {
+      }
+    },
+    { capture: true, passive: true }
+  );
+  function sendSignals(final) {
+    if (!pageId || !sgOn) return;
+    const n = nav;
+    const p = {
+      final,
+      age: Math.round(clock() - sgStart),
+      vis: engaged + (shownAt ? Date.now() - shownAt : 0),
+      wd: automated(),
+      odd: odd(),
+      hw: n.hardwareConcurrency || 0,
+      mem: n.deviceMemory || 0,
+      tp: n.maxTouchPoints || 0,
+      dpr: w.devicePixelRatio || 0,
+      ow: w.outerWidth || 0,
+      oh: w.outerHeight || 0,
+      pl: n.plugins && n.plugins.length || 0,
+      lg: n.languages && n.languages.length || 0,
+      cd: w.screen.colorDepth || 0,
+      tzo: (/* @__PURE__ */ new Date()).getTimezoneOffset()
+    };
+    for (const k in sg) p[k] = Math.round(sg[k]);
+    add("signals", { props: p });
+  }
+  function startSignals() {
+    sg = {};
+    sgOn = true;
+    sgStart = clock();
+    sgX = -1;
+    sgSlot = -1;
+    sgKeyAt = 0;
+    sgMoved = false;
+    sgScrollY = w.scrollY || 0;
+    if (sgTimer) clearTimeout(sgTimer);
+    sgTimer = setTimeout(() => sendSignals(false), 5e3);
+  }
+  function body(events) {
+    return JSON.stringify({
+      k: key,
+      v: vid || void 0,
+      sdk,
+      now: Date.now(),
+      c: { sw: w.screen.width, sh: w.screen.height, vw: w.innerWidth, vh: w.innerHeight, l: nav.language || "", rel: release, in: input, bot: automated() || void 0, mv: moves || void 0, pr: press || void 0, odd: odd() || void 0 },
+      e: events
+    });
+  }
+  function flush(leaving2) {
+    drainCalls();
+    if (timer) clearTimeout(timer);
+    timer = 0;
+    if (!queue.length || !rawFetch) return;
+    for (const e of queue) {
+      if (e.k !== "pageview" || e.p !== pageId) continue;
+      e.ti = d.title;
+      const props = e.props || {};
+      if (!props.status && /(^|\W)404(\W|$)|not found/i.test(d.title)) e.props = { ...props, status: 404, soft: true };
+    }
+    if (leaving2 === true && backoff) {
+      keep();
+      return;
+    }
+    const events = queue.splice(0, 50);
+    const payload = body(events);
+    if (leaving2 === true && nav.sendBeacon && nav.sendBeacon(endpoint, new Blob([payload], { type: "text/plain" }))) {
+      if (kept) keep();
+      return;
+    }
+    rawFetch(endpoint, { method: "POST", body: payload, headers: { "Content-Type": "text/plain" }, keepalive: true, credentials: "omit" }).then((r) => {
+      if (r.status === 429 || r.status >= 500) throw 0;
+      backoff = 0;
+      if (kept) keep();
+      if (queue.length && !timer) timer = setTimeout(flush, 200);
+    }).catch(() => {
+      queue = events.concat(queue).slice(0, 200);
+      keep();
+      if (timer) clearTimeout(timer);
+      timer = setTimeout(flush, Math.min(2e3 * Math.pow(2, backoff++), 3e5) + Math.random() * 1e3);
+    });
+  }
+  const visible = () => d.visibilityState !== "hidden";
+  function sendEngagement() {
+    if (shownAt) {
+      engaged += Date.now() - shownAt;
+      shownAt = 0;
+    }
+    if (pageId && engaged >= 1e3) add("engagement", { v: engaged });
+    engaged = 0;
+  }
+  function page2(props) {
+    const raw = loc.href.split("#")[0];
+    if (raw === rawUrl && !props) return;
+    const url = grouped(raw);
+    sendSignals(true);
+    sendEngagement();
+    if (pageUrl) timeNav(pageUrl);
+    pageId = hex(8);
+    startSignals();
+    pageUrl = url;
+    rawUrl = raw;
+    shownAt = visible() ? Date.now() : 0;
+    add("pageview", { r: lastRef, ti: d.title, props });
+    if (timer) clearTimeout(timer);
+    timer = setTimeout(flush, 800);
+    lastRef = url;
+  }
+  function notFound2(status) {
+    const code = status && status >= 400 && status < 600 ? Math.floor(status) : 404;
+    for (const e of queue) {
+      if (e.k === "pageview" && e.p === pageId) {
+        e.props = { ...e.props || {}, status: code, soft: false };
+        return;
+      }
+    }
+    add("deadend", { v: code });
+  }
+  function track2(name, props) {
+    if (typeof name === "string" && name) add("custom", { n: name.slice(0, 100), props });
+  }
+  ["pushState", "replaceState"].forEach((m) => {
+    const orig = w.history[m];
+    w.history[m] = function(...args) {
+      const r = orig.apply(this, args);
+      setTimeout(page2, 0);
+      return r;
+    };
+  });
+  w.addEventListener("popstate", () => setTimeout(page2, 0));
+  d.addEventListener("visibilitychange", () => {
+    if (visible()) shownAt = Date.now();
+    else {
+      sendVitals();
+      sendSignals(true);
+      sendEngagement();
+      flush(true);
+    }
+  });
+  w.addEventListener("pagehide", () => {
+    sendVitals();
+    sendSignals(true);
+    sendEngagement();
+    flush(true);
+  });
+  d.addEventListener(
+    "click",
+    (ev) => {
+      const target = ev.target;
+      const el = target && target.closest ? target.closest("[data-lapwy-event]") : null;
+      if (!el) return;
+      const props = {};
+      for (const at of Array.from(el.attributes)) {
+        if (at.name.indexOf("data-lapwy-") === 0 && at.name !== "data-lapwy-event") props[at.name.slice(11)] = at.value;
+      }
+      track2(el.getAttribute("data-lapwy-event") || "", props);
+    },
+    true
+  );
+  let loadUrl = "";
+  let loadPage = "";
+  const sent = {};
+  function vital(name, value) {
+    if (sent[name] || !loadPage || !(value >= 0)) return;
+    sent[name] = 1;
+    add("vital", { n: name, v: Math.round(value * 1e3) / 1e3, u: loadUrl, p: loadPage });
+  }
+  function observe(type, fn, opts) {
+    try {
+      new PerformanceObserver((l) => l.getEntries().forEach(fn)).observe({ type, buffered: true, ...opts });
+    } catch {
+    }
+  }
+  let lcp = -1;
+  let cls = 0;
+  let clsWin = 0;
+  let clsStart = 0;
+  let clsLast = 0;
+  const inter = {};
+  let hiddenAt = visible() ? Infinity : 0;
+  d.addEventListener(
+    "visibilitychange",
+    () => {
+      if (!visible() && hiddenAt === Infinity) hiddenAt = w.performance.now();
+    },
+    true
+  );
+  observe("largest-contentful-paint", (e) => {
+    if (e.startTime < hiddenAt) lcp = e.startTime;
+  });
+  observe("layout-shift", (e) => {
+    if (e.hadRecentInput) return;
+    if (clsWin && e.startTime - clsLast < 1e3 && e.startTime - clsStart < 5e3) clsWin += e.value;
+    else {
+      clsWin = e.value;
+      clsStart = e.startTime;
+    }
+    clsLast = e.startTime;
+    if (clsWin > cls) cls = clsWin;
+  });
+  observe(
+    "event",
+    (e) => {
+      if (!e.interactionId) return;
+      const was = inter[e.interactionId];
+      if (was === void 0 || e.duration > was) inter[e.interactionId] = e.duration;
+    },
+    { durationThreshold: 40 }
+  );
+  function sendVitals() {
+    try {
+      const timing = w.performance.getEntriesByType("navigation")[0];
+      if (timing && timing.responseStart > 0) vital("TTFB", timing.responseStart);
+    } catch {
+    }
+    if (lcp >= 0) vital("LCP", lcp);
+    const worst = Object.keys(inter).map((k) => inter[Number(k)]);
+    if (worst.length) {
+      worst.sort((a, b) => b - a);
+      vital("INP", worst[Math.min(worst.length - 1, Math.floor(worst.length / 50))]);
+    }
+    if (w.LayoutShift) vital("CLS", cls);
+  }
+  let navBusy = false;
+  function timeNav(from) {
+    if (navBusy || typeof MutationObserver === "undefined" || !d.body) return;
+    navBusy = true;
+    const t0 = Date.now();
+    let last = t0;
+    const mo = new MutationObserver(() => {
+      last = Date.now();
+    });
+    mo.observe(d.body, { childList: true, subtree: true, attributes: true, characterData: true });
+    const iv = setInterval(() => {
+      const now = Date.now();
+      if (now - last < 150 && now - t0 < 1e4) return;
+      mo.disconnect();
+      clearInterval(iv);
+      navBusy = false;
+      let path = "";
+      try {
+        path = new URL(from).pathname;
+      } catch {
+      }
+      add("nav", { v: Math.max(last - t0, 1), props: { from: path } });
+    }, 50);
+  }
+  let errs = 0;
+  const seenErr = {};
+  function report(rawType, rawMsg, src, line) {
+    const type = String(rawType || "Error").slice(0, 60);
+    let msg = String(rawMsg || "");
+    if (msg.indexOf(type + ": ") === 0) msg = msg.slice(type.length + 2);
+    msg = msg.slice(0, 300);
+    if (!msg || seenErr[msg] || errs >= 10) return;
+    seenErr[msg] = 1;
+    errs++;
+    const props = { msg };
+    if (src) {
+      try {
+        props.src = new URL(src).pathname.slice(-120);
+      } catch {
+      }
+    }
+    if (line) props.line = line;
+    add("error", { n: type, props });
+  }
+  w.addEventListener("error", (ev) => {
+    if (ev.message) report(ev.error && ev.error.name, ev.message.replace(/^Uncaught /, ""), ev.filename, ev.lineno);
+  });
+  w.addEventListener("unhandledrejection", (ev) => {
+    const r = ev.reason;
+    report(r && r.name || "UnhandledRejection", r && r.message || r);
+  });
+  let calls = {};
+  let endpoints = 0;
+  let leaving = false;
+  const apiHosts = options.api ? options.api.map((h) => String(h).toLowerCase()) : [];
+  let ownUrl = "";
+  try {
+    ownUrl = new URL(endpoint, loc.href).href;
+  } catch {
+  }
+  function tidy(path) {
+    return path.split("/").map((s) => /^\d+$/.test(s) || /^[0-9a-f]{8}-[0-9a-f]{4}-/i.test(s) || /^[0-9a-f]{16,}$/i.test(s) || s.length >= 20 && /\d/.test(s) ? ":id" : s).join("/").slice(0, 120);
+  }
+  function called(method, rawUrl2, status, ms) {
+    try {
+      const u = new URL(String(rawUrl2), loc.href);
+      const same = u.host === loc.host;
+      if (u.protocol !== "http:" && u.protocol !== "https:" || u.href.split("?")[0] === ownUrl) return;
+      if (!same && apiHosts.indexOf(u.hostname.toLowerCase()) < 0) return;
+      if (/\.(js|mjs|css|map|png|jpe?g|gif|svg|webp|avif|ico|woff2?|ttf|html?|txt)$/i.test(u.pathname)) return;
+      const failed = status >= 500 || status === 0 && !leaving && visible();
+      if (status === 0 && !failed) return;
+      const name = (String(method || "GET").toUpperCase().slice(0, 7) + " " + (same ? "" : u.hostname) + tidy(u.pathname)).slice(0, 100);
+      let c = calls[name];
+      if (!c) {
+        if (endpoints >= 20) return;
+        endpoints++;
+        c = calls[name] = { n: 0, fail: 0, ms: 0 };
+      }
+      c.n++;
+      c.ms += Math.max(ms, 0);
+      if (failed) c.fail++;
+      if (!timer) timer = setTimeout(flush, 3e3);
+    } catch {
+    }
+  }
+  function drainCalls() {
+    const waiting = calls;
+    calls = {};
+    endpoints = 0;
+    for (const name in waiting) {
+      const c = waiting[name];
+      add("api", { n: name, v: Math.round(c.ms), props: { calls: c.n, failed: c.fail } });
+    }
+  }
+  if (options.api !== false) {
+    try {
+      if (rawFetch) {
+        const orig = w.fetch;
+        w.fetch = function(input2, init2) {
+          const t0 = Date.now();
+          const p = orig.apply(this, [input2, init2]);
+          try {
+            const req = input2;
+            const url = typeof input2 === "string" ? input2 : input2 instanceof URL ? input2.href : req.url;
+            const method = init2 && init2.method || typeof input2 === "object" && "method" in input2 && req.method || "GET";
+            p.then(
+              (r) => {
+                if (r.type !== "opaque") called(method, url, r.status, Date.now() - t0);
+              },
+              (e) => {
+                if (!e || e.name !== "AbortError") called(method, url, 0, Date.now() - t0);
+              }
+            );
+          } catch {
+          }
+          return p;
+        };
+      }
+      const X = w.XMLHttpRequest;
+      if (X) {
+        const open = X.prototype.open;
+        const send = X.prototype.send;
+        X.prototype.open = function(method, url, ...rest) {
+          this.__lapwy = [method, String(url)];
+          return open.apply(this, [method, url, ...rest]);
+        };
+        X.prototype.send = function(...args) {
+          const m = this.__lapwy;
+          if (m) {
+            const t0 = Date.now();
+            let aborted = false;
+            this.addEventListener("abort", () => aborted = true);
+            this.addEventListener("loadend", () => {
+              if (!aborted) called(m[0], m[1], this.status, Date.now() - t0);
+            });
+          }
+          return send.apply(this, args);
+        };
+      }
+    } catch {
+    }
+  }
+  w.addEventListener("pagehide", () => leaving = true);
+  w.addEventListener("pageshow", () => leaving = false);
+  function consent2(granted) {
+    if (!cookieMode) return;
+    if (granted) keepId();
+    else dropId();
+  }
+  if (cookieMode === "always") keepId();
+  else if (cookieMode === "consent" && readId()) keepId();
+  try {
+    const old = JSON.parse(w.localStorage.getItem(Q) || "[]");
+    const from = Date.now() - 6048e5;
+    queue = old.filter((e) => e && e.id && e.k && e.t > from).slice(0, 200);
+    kept = old.length > 0;
+    if (queue.length) timer = setTimeout(flush, 800);
+  } catch {
+  }
+  let loaded;
+  try {
+    const status = w.performance.getEntriesByType("navigation")[0].responseStatus;
+    if (status && status >= 400) loaded = { status, soft: false };
+  } catch {
+  }
+  page2(loaded);
+  loadUrl = pageUrl;
+  loadPage = pageId;
+  return { track: track2, page: page2, consent: consent2, notFound: notFound2 };
+}
+
+// src/index.ts
+var shared = () => window;
+function init(options) {
+  var _a;
+  if (typeof window === "undefined") return api;
+  const w = shared();
+  if (!w.lapwy) w.lapwy = start(options);
+  const waiting = (_a = w.__lapwyEarly) != null ? _a : [];
+  w.__lapwyEarly = [];
+  waiting.forEach((run) => run(w.lapwy));
+  return api;
+}
+function later(run) {
+  var _a;
+  if (typeof window === "undefined") return;
+  const w = shared();
+  if (w.lapwy) run(w.lapwy);
+  else {
+    const q = (_a = w.__lapwyEarly) != null ? _a : w.__lapwyEarly = [];
+    if (q.length < 100) q.push(run);
+  }
+}
+function track(name, props) {
+  later((t) => t.track(name, props));
+}
+function page(props) {
+  later((t) => t.page(props));
+}
+function consent(granted) {
+  later((t) => t.consent(granted));
+}
+function notFound(status) {
+  later((t) => t.notFound(status));
+}
+var api = { track, page, consent, notFound };
+function reset() {
+  if (typeof window === "undefined") return;
+  delete shared().lapwy;
+  delete shared().__lapwyEarly;
+}
+export {
+  DEFAULT_ENDPOINT,
+  consent,
+  init,
+  notFound,
+  page,
+  reset,
+  track
+};