@anyreplay/browser 0.1.0

package/dist/index.cjs

@@ -0,0 +1,660 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  ConfigError: () => ConfigError,
+  DEFAULTS: () => DEFAULTS,
+  EVENT_NAME_PATTERN: () => EVENT_NAME_PATTERN,
+  MAX_PROPERTIES_BYTES: () => MAX_PROPERTIES_BYTES,
+  NAVIGATE_TAG: () => NAVIGATE_TAG,
+  TRACK_TAG: () => TRACK_TAG,
+  Transport: () => Transport,
+  createRecorder: () => createRecorder,
+  hashToUnitInterval: () => hashToUnitInterval,
+  isSampledIn: () => isSampledIn,
+  resolveIdentity: () => resolveIdentity,
+  resolveOptions: () => resolveOptions,
+  safeStorage: () => safeStorage,
+  uuidv4: () => uuidv4,
+  validateTrack: () => validateTrack
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/recorder.ts
+var import_rrweb = require("rrweb");
+
+// src/config.ts
+var DEFAULTS = {
+  ingestUrl: "https://in.anyreplay.com",
+  sampleRate: 1,
+  // Default-deny. Recording a customer's password field once is a breach; the
+  // cost of the safe default is a configuration line for the rare field that
+  // genuinely needs to be visible.
+  maskAllInputs: true,
+  maskClass: "ar-mask",
+  blockClass: "ar-block",
+  requireConsent: false,
+  maxEventsPerChunk: 200,
+  flushIntervalMs: 5e3,
+  maxConsecutiveFailures: 5,
+  debug: false
+};
+var ConfigError = class extends Error {
+};
+var KEY_PATTERN = /^ar_pk_(live|test)_[0-9a-f]{24}$/;
+var MAX_SESSION_CAP = 1e6;
+function resolveOptions(input) {
+  var _a, _b, _c;
+  if (!input || typeof input !== "object") throw new ConfigError("anyreplay: options object required");
+  if (!KEY_PATTERN.test((_a = input.projectKey) != null ? _a : "")) {
+    throw new ConfigError("anyreplay: projectKey looks wrong \u2014 copy it from the dashboard");
+  }
+  const sampleRate = (_b = input.sampleRate) != null ? _b : DEFAULTS.sampleRate;
+  if (!(sampleRate >= 0 && sampleRate <= 1)) {
+    throw new ConfigError("anyreplay: sampleRate must be between 0 and 1");
+  }
+  const cap = input.maxSessionsPerMonth;
+  if (cap !== void 0 && !(Number.isInteger(cap) && cap >= 1 && cap <= MAX_SESSION_CAP)) {
+    throw new ConfigError(`anyreplay: maxSessionsPerMonth must be a whole number between 1 and ${MAX_SESSION_CAP}`);
+  }
+  return {
+    ...DEFAULTS,
+    ...input,
+    projectKey: input.projectKey,
+    sampleRate,
+    ingestUrl: ((_c = input.ingestUrl) != null ? _c : DEFAULTS.ingestUrl).replace(/\/+$/, ""),
+    // A caller who explicitly passes false gets what they asked for; anything
+    // else (including undefined) keeps masking on.
+    maskAllInputs: input.maskAllInputs === false ? false : true
+  };
+}
+
+// src/events.ts
+var TRACK_TAG = "anyreplay.track";
+var NAVIGATE_TAG = "anyreplay.navigate";
+var EVENT_NAME_PATTERN = /^[A-Za-z0-9_.:-]{1,64}$/;
+var MAX_PROPERTIES_BYTES = 4 * 1024;
+function validateTrack(name, properties) {
+  if (typeof name !== "string" || !EVENT_NAME_PATTERN.test(name)) {
+    return `event name must be 1-64 characters of [A-Za-z0-9_.:-], got ${JSON.stringify(name)}`;
+  }
+  if (properties === void 0 || properties === null) return { name, properties: {} };
+  if (typeof properties !== "object" || Array.isArray(properties)) {
+    return `properties for "${name}" must be a plain object`;
+  }
+  let serialised;
+  try {
+    serialised = JSON.stringify(properties);
+  } catch (e) {
+    return `properties for "${name}" are not JSON-serialisable`;
+  }
+  if (serialised === void 0 || byteLength(serialised) > MAX_PROPERTIES_BYTES) {
+    return `properties for "${name}" exceed ${MAX_PROPERTIES_BYTES} bytes once serialised`;
+  }
+  return { name, properties: JSON.parse(serialised) };
+}
+function byteLength(text) {
+  return typeof TextEncoder === "function" ? new TextEncoder().encode(text).length : text.length * 3;
+}
+
+// src/sampling.ts
+function hashToUnitInterval(input) {
+  let hash = 2166136261;
+  for (let i = 0; i < input.length; i += 1) {
+    hash ^= input.charCodeAt(i);
+    hash = Math.imul(hash, 16777619) >>> 0;
+  }
+  return hash / 4294967295;
+}
+function isSampledIn(visitorId, sampleRate) {
+  if (sampleRate >= 1) return true;
+  if (sampleRate <= 0) return false;
+  return hashToUnitInterval(visitorId) < sampleRate;
+}
+
+// src/transport.ts
+var MAX_STALE_RECOVERIES = 3;
+async function staleSeqHint(response, sent) {
+  try {
+    if (typeof response.json !== "function") return void 0;
+    const reply = await response.json();
+    if (reply.duplicate !== true) return void 0;
+    const next = reply.nextSeq;
+    return typeof next === "number" && Number.isInteger(next) && next > sent ? next : void 0;
+  } catch (e) {
+    return void 0;
+  }
+}
+var KEEPALIVE_BODY_LIMIT_BYTES = 56 * 1024;
+function withinKeepaliveLimit(payload) {
+  const bytes = typeof TextEncoder === "function" ? new TextEncoder().encode(payload).length : payload.length * 3;
+  return bytes <= KEEPALIVE_BODY_LIMIT_BYTES;
+}
+var Transport = class {
+  constructor(options, context, hooks = {}) {
+    this.options = options;
+    this.context = context;
+    this.hooks = hooks;
+    __publicField(this, "buffer", []);
+    __publicField(this, "seq", 0);
+    __publicField(this, "consecutiveFailures", 0);
+    __publicField(this, "state", "open");
+    __publicField(this, "timer");
+    __publicField(this, "pendingMeta");
+    __publicField(this, "flags", {});
+    __publicField(this, "inFlight", false);
+    /** The chunk number of the last request that left, to tell a retry from a first attempt. */
+    __publicField(this, "lastAttemptedSeq", -1);
+    __publicField(this, "staleRecoveries", 0);
+    var _a;
+    this.seq = (_a = context.initialSeq) != null ? _a : 0;
+  }
+  get isStopped() {
+    return this.state === "stopped";
+  }
+  get bufferedCount() {
+    return this.buffer.length;
+  }
+  get sentChunks() {
+    return this.seq;
+  }
+  /** Attaches metadata to the next chunk. Sent once, with the session's first chunk. */
+  setMeta(meta) {
+    this.pendingMeta = meta;
+  }
+  mergeFlags(flags) {
+    this.flags = { ...this.flags, ...flags };
+  }
+  start() {
+    var _a, _b;
+    if (this.timer) return;
+    this.timer = setInterval(() => void this.flush(), this.options.flushIntervalMs);
+    (_b = (_a = this.timer).unref) == null ? void 0 : _b.call(_a);
+  }
+  stop(reason) {
+    var _a, _b;
+    this.state = "stopped";
+    if (this.timer) clearInterval(this.timer);
+    this.timer = void 0;
+    this.buffer = [];
+    (_b = (_a = this.hooks).onStopped) == null ? void 0 : _b.call(_a, reason);
+  }
+  push(event) {
+    if (this.state === "stopped") return;
+    this.buffer.push(event);
+    if (this.buffer.length >= this.options.maxEventsPerChunk) void this.flush();
+  }
+  body(events) {
+    return JSON.stringify({
+      projectKey: this.context.projectKey,
+      sessionId: this.context.sessionId,
+      visitorId: this.context.visitorId,
+      seq: this.seq,
+      events,
+      ...this.pendingMeta ? { meta: this.pendingMeta } : {},
+      ...Object.keys(this.flags).length > 0 ? { flags: this.flags } : {}
+    });
+  }
+  /** Sends whatever is buffered. Safe to call when there is nothing to send. */
+  async flush() {
+    var _a, _b, _c, _d;
+    if (this.state === "stopped" || this.inFlight || this.buffer.length === 0) return;
+    this.inFlight = true;
+    const events = this.buffer;
+    this.buffer = [];
+    let resend = false;
+    try {
+      const retry = this.lastAttemptedSeq === this.seq;
+      this.lastAttemptedSeq = this.seq;
+      (_b = (_a = this.hooks).onSeqReserved) == null ? void 0 : _b.call(_a, this.seq + 1);
+      const payload = this.body(events);
+      const response = await fetch(`${this.options.ingestUrl}/v1/ingest/events`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: payload,
+        // Ingest is unauthenticated by design; sending credentials would be a
+        // cross-site cookie leak for no benefit.
+        credentials: "omit",
+        keepalive: withinKeepaliveLimit(payload)
+      });
+      if (response.ok) {
+        const nextSeq = retry ? void 0 : await staleSeqHint(response, this.seq);
+        if (nextSeq !== void 0 && this.staleRecoveries < MAX_STALE_RECOVERIES) {
+          this.staleRecoveries += 1;
+          this.seq = nextSeq;
+          this.requeue(events);
+          resend = true;
+          return;
+        }
+        this.staleRecoveries = 0;
+        this.seq += 1;
+        this.pendingMeta = void 0;
+        this.consecutiveFailures = 0;
+        (_d = (_c = this.hooks).onSent) == null ? void 0 : _d.call(_c, this.seq - 1, events.length);
+        return;
+      }
+      if (response.status >= 400 && response.status < 500 && response.status !== 429) {
+        this.stop(`rejected_${response.status}`);
+        return;
+      }
+      this.requeue(events);
+      this.registerFailure();
+    } catch (e) {
+      this.requeue(events);
+      this.registerFailure();
+    } finally {
+      this.inFlight = false;
+      if (resend) void this.flush();
+    }
+  }
+  /**
+   * Puts a failed batch back at the front of the queue.
+   *
+   * Bounded on purpose: a long offline period must not grow the buffer until
+   * the tab runs out of memory. Older events are dropped first — a replay
+   * missing its beginning is still useful; a crashed page is not.
+   */
+  requeue(events) {
+    const limit = this.options.maxEventsPerChunk * 10;
+    this.buffer = [...events, ...this.buffer].slice(-limit);
+  }
+  registerFailure() {
+    this.consecutiveFailures += 1;
+    if (this.consecutiveFailures >= this.options.maxConsecutiveFailures) {
+      this.stop("too_many_failures");
+    }
+  }
+  /**
+   * Last-gasp send when the page is going away.
+   *
+   * `fetch` is cancelled once the document unloads, so the tail of every
+   * session would be lost. `sendBeacon` hands the payload to the browser, which
+   * delivers it after the page is gone.
+   */
+  flushWithBeacon() {
+    var _a, _b;
+    if (this.state === "stopped" || this.buffer.length === 0) return false;
+    const events = this.buffer;
+    const payload = this.body(events);
+    this.buffer = [];
+    try {
+      if (typeof navigator !== "undefined" && typeof navigator.sendBeacon === "function") {
+        (_b = (_a = this.hooks).onSeqReserved) == null ? void 0 : _b.call(_a, this.seq + 1);
+        const blob = new Blob([payload], { type: "text/plain;charset=UTF-8" });
+        const queued = navigator.sendBeacon(`${this.options.ingestUrl}/v1/ingest/events`, blob);
+        if (queued) {
+          this.seq += 1;
+          this.pendingMeta = void 0;
+          return true;
+        }
+      }
+    } catch (e) {
+    }
+    this.buffer = events;
+    return false;
+  }
+};
+
+// src/visitor.ts
+var VISITOR_KEY = "anyreplay.vid";
+var SESSION_KEY = "anyreplay.sid";
+var SESSION_TS_KEY = "anyreplay.sts";
+var SEQ_KEY = "anyreplay.seq";
+var PAGE_KEY = "anyreplay.pc";
+var COOLDOWN_KEY = "anyreplay.cd";
+var QUOTA_COOLDOWN_MS = 2 * 60 * 1e3;
+var SESSION_IDLE_MS = 30 * 60 * 1e3;
+function randomId(bytes = 16) {
+  const array = new Uint8Array(bytes);
+  if (typeof crypto !== "undefined" && crypto.getRandomValues) {
+    crypto.getRandomValues(array);
+  } else {
+    for (let i = 0; i < bytes; i += 1) array[i] = Math.floor(Math.random() * 256);
+  }
+  return Array.from(array, (b) => b.toString(16).padStart(2, "0")).join("");
+}
+function uuidv4() {
+  if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
+    return crypto.randomUUID();
+  }
+  const hex = randomId(16).split("");
+  hex[12] = "4";
+  hex[16] = (parseInt(hex[16], 16) & 3 | 8).toString(16);
+  const s = hex.join("");
+  return `${s.slice(0, 8)}-${s.slice(8, 12)}-${s.slice(12, 16)}-${s.slice(16, 20)}-${s.slice(20)}`;
+}
+function safeStorage(source) {
+  const read = () => {
+    try {
+      return source();
+    } catch (e) {
+      return void 0;
+    }
+  };
+  return {
+    get: (key) => {
+      var _a, _b;
+      try {
+        return (_b = (_a = read()) == null ? void 0 : _a.getItem(key)) != null ? _b : null;
+      } catch (e) {
+        return null;
+      }
+    },
+    set: (key, value) => {
+      var _a;
+      try {
+        (_a = read()) == null ? void 0 : _a.setItem(key, value);
+      } catch (e) {
+      }
+    },
+    remove: (key) => {
+      var _a;
+      try {
+        (_a = read()) == null ? void 0 : _a.removeItem(key);
+      } catch (e) {
+      }
+    }
+  };
+}
+function resolveIdentity(local, session, now = Date.now()) {
+  var _a;
+  let visitorId = local.get(VISITOR_KEY);
+  if (!visitorId || !/^[A-Za-z0-9_-]{8,64}$/.test(visitorId)) {
+    visitorId = `v${randomId(12)}`;
+    local.set(VISITOR_KEY, visitorId);
+  }
+  const previousId = session.get(SESSION_KEY);
+  const previousTs = Number((_a = session.get(SESSION_TS_KEY)) != null ? _a : 0);
+  const expired = !previousId || !previousTs || now - previousTs > SESSION_IDLE_MS;
+  const sessionId = expired ? uuidv4() : previousId;
+  session.set(SESSION_KEY, sessionId);
+  session.set(SESSION_TS_KEY, String(now));
+  const storedSeq = Number(session.get(SEQ_KEY));
+  const nextSeq = !expired && Number.isInteger(storedSeq) && storedSeq > 0 ? storedSeq : 0;
+  session.set(SEQ_KEY, String(nextSeq));
+  const storedPages = Number(session.get(PAGE_KEY));
+  const pageCount = !expired && Number.isInteger(storedPages) && storedPages > 0 ? storedPages + 1 : 1;
+  session.set(PAGE_KEY, String(pageCount));
+  return { visitorId, sessionId, isNewSession: expired, nextSeq, pageCount };
+}
+function notePageCount(session, count) {
+  session.set(PAGE_KEY, String(count));
+}
+function inCooldown(session, now = Date.now()) {
+  const until = Number(session.get(COOLDOWN_KEY));
+  return Number.isFinite(until) && until > now;
+}
+function startCooldown(session, now = Date.now()) {
+  session.set(COOLDOWN_KEY, String(now + QUOTA_COOLDOWN_MS));
+}
+function reserveSeq(session, next) {
+  session.set(SEQ_KEY, String(next));
+}
+function touchSession(session, now = Date.now()) {
+  session.set(SESSION_TS_KEY, String(now));
+}
+
+// src/recorder.ts
+var RAGE_CLICK_COUNT = 3;
+var RAGE_CLICK_WINDOW_MS = 1e3;
+var RAGE_CLICK_RADIUS_PX = 30;
+var MAX_PENDING_EVENTS = 32;
+function createRecorder(rawOptions) {
+  const options = resolveOptions(rawOptions);
+  const local = safeStorage(() => globalThis.localStorage);
+  const session = safeStorage(() => globalThis.sessionStorage);
+  const identity = resolveIdentity(local, session);
+  let status = "idle";
+  let stopRecording;
+  let pageCount = identity.pageCount;
+  if (!isSampledIn(identity.visitorId, options.sampleRate)) {
+    return inertHandle("sampled-out", identity.sessionId);
+  }
+  if (inCooldown(session)) {
+    if (options.debug) console.warn("[anyreplay] not recording: ingest refused a new session recently");
+    return inertHandle("stopped", identity.sessionId);
+  }
+  const transport = new Transport(
+    options,
+    {
+      projectKey: options.projectKey,
+      sessionId: identity.sessionId,
+      visitorId: identity.visitorId,
+      initialSeq: identity.nextSeq
+    },
+    {
+      onSeqReserved: (next) => reserveSeq(session, next),
+      onStopped: (reason) => {
+        status = "stopped";
+        stopRecording == null ? void 0 : stopRecording();
+        stopRecording = void 0;
+        if (reason === "rejected_402") startCooldown(session);
+        if (options.debug) console.warn(`[anyreplay] recording stopped: ${reason}`);
+      }
+    }
+  );
+  const collectMeta = () => ({
+    startedAt: Date.now(),
+    url: safeLocation(),
+    lang: typeof navigator !== "undefined" ? navigator.language : void 0,
+    userAgent: typeof navigator !== "undefined" ? navigator.userAgent : void 0,
+    screenWidth: typeof window !== "undefined" ? window.innerWidth : void 0,
+    screenHeight: typeof window !== "undefined" ? window.innerHeight : void 0,
+    referrer: typeof document !== "undefined" ? document.referrer || void 0 : void 0,
+    // The cap is a decision about starting a session, so it goes only where
+    // ingest makes that decision: chunk 0. A resumed page starts later.
+    ...options.maxSessionsPerMonth !== void 0 && identity.nextSeq === 0 ? { sessionCap: options.maxSessionsPerMonth } : {}
+  });
+  const recentClicks = [];
+  const noteInteraction = (event) => {
+    var _a;
+    const data = event.data;
+    if (event.type !== 3 || (data == null ? void 0 : data.source) !== 2 || typeof data.x !== "number") return;
+    const now = event.timestamp;
+    recentClicks.push({ x: data.x, y: (_a = data.y) != null ? _a : 0, t: now });
+    while (recentClicks.length > 0 && now - recentClicks[0].t > RAGE_CLICK_WINDOW_MS) recentClicks.shift();
+    if (recentClicks.length >= RAGE_CLICK_COUNT) {
+      const first = recentClicks[0];
+      const clustered = recentClicks.every(
+        (c) => Math.abs(c.x - first.x) < RAGE_CLICK_RADIUS_PX && Math.abs(c.y - first.y) < RAGE_CLICK_RADIUS_PX
+      );
+      if (clustered) transport.mergeFlags({ hasRageClick: true });
+    }
+  };
+  const pending = [];
+  let draining = false;
+  let drainScheduled = false;
+  const drainPending = () => {
+    if (draining || pending.length === 0) return;
+    draining = true;
+    try {
+      while (pending.length > 0) {
+        const next = pending[0];
+        import_rrweb.record.addCustomEvent(next.tag, next.payload);
+        pending.shift();
+      }
+    } catch (e) {
+      if (!drainScheduled && status === "recording") {
+        drainScheduled = true;
+        setTimeout(() => {
+          drainScheduled = false;
+          drainPending();
+        }, 50);
+      }
+    } finally {
+      draining = false;
+    }
+  };
+  const emitCustom = (tag, payload) => {
+    if (status === "stopped") return;
+    if (status === "recording") {
+      try {
+        import_rrweb.record.addCustomEvent(tag, payload);
+        return;
+      } catch (e) {
+      }
+    }
+    if (pending.length >= MAX_PENDING_EVENTS) {
+      if (options.debug) console.warn(`[anyreplay] dropped ${tag}: too many events before recording started`);
+      return;
+    }
+    pending.push({ tag, payload });
+  };
+  let lastUrl = safeLocation();
+  const noteNavigation = () => {
+    const url = safeLocation();
+    if (!url || url === lastUrl) return;
+    lastUrl = url;
+    pageCount += 1;
+    notePageCount(session, pageCount);
+    transport.mergeFlags({ pageCount });
+    emitCustom(NAVIGATE_TAG, { url, title: typeof document !== "undefined" ? document.title : "" });
+  };
+  const begin = () => {
+    if (status === "recording" || status === "stopped") return;
+    status = "recording";
+    transport.setMeta(collectMeta());
+    transport.mergeFlags({ pageCount });
+    transport.start();
+    stopRecording = (0, import_rrweb.record)({
+      emit: (event) => {
+        const typed = event;
+        noteInteraction(typed);
+        touchSession(session, typed.timestamp);
+        transport.push(typed);
+        drainPending();
+      },
+      maskAllInputs: options.maskAllInputs,
+      maskTextClass: options.maskClass,
+      blockClass: options.blockClass,
+      // Passwords are never recorded, regardless of configuration.
+      maskInputOptions: { password: true, email: true, tel: true },
+      // Canvas capture is expensive and off unless a customer opts in later.
+      recordCanvas: false,
+      collectFonts: false
+    });
+    drainPending();
+    attachLifecycleHooks();
+  };
+  const attachLifecycleHooks = () => {
+    if (typeof window === "undefined") return;
+    window.addEventListener("pagehide", () => {
+      transport.flushWithBeacon();
+    }, { capture: true });
+    document.addEventListener("visibilitychange", () => {
+      if (document.visibilityState === "hidden") transport.flushWithBeacon();
+    });
+    window.addEventListener("error", () => transport.mergeFlags({ hasError: true }));
+    window.addEventListener("unhandledrejection", () => transport.mergeFlags({ hasError: true }));
+    const patch = (method) => {
+      const original = history[method].bind(history);
+      history[method] = function patched(...args) {
+        const result = original(...args);
+        noteNavigation();
+        return result;
+      };
+    };
+    patch("pushState");
+    patch("replaceState");
+    window.addEventListener("popstate", noteNavigation);
+  };
+  if (options.requireConsent) {
+    status = "awaiting-consent";
+  } else {
+    begin();
+  }
+  return {
+    status: () => status,
+    sessionId: () => identity.sessionId,
+    consent: (granted) => {
+      if (granted) begin();
+      else transport.stop("consent_withdrawn");
+    },
+    identify: (traits) => {
+      if (!traits.userId && !traits.email) return;
+      void fetch(`${options.ingestUrl}/v1/ingest/identify`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        credentials: "omit",
+        body: JSON.stringify({
+          projectKey: options.projectKey,
+          sessionId: identity.sessionId,
+          ...traits
+        })
+      }).catch(() => {
+      });
+    },
+    track: (name, properties) => {
+      const payload = validateTrack(name, properties);
+      if (typeof payload === "string") {
+        if (options.debug) console.warn(`[anyreplay] track() ignored: ${payload}`);
+        return;
+      }
+      emitCustom(TRACK_TAG, payload);
+    },
+    stop: () => transport.stop("stopped_by_page"),
+    flush: () => transport.flush()
+  };
+}
+function safeLocation() {
+  try {
+    return typeof location !== "undefined" ? location.href : void 0;
+  } catch (e) {
+    return void 0;
+  }
+}
+function inertHandle(status, sessionId) {
+  return {
+    status: () => status,
+    sessionId: () => sessionId,
+    consent: () => {
+    },
+    identify: () => {
+    },
+    track: () => {
+    },
+    stop: () => {
+    },
+    flush: async () => {
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ConfigError,
+  DEFAULTS,
+  EVENT_NAME_PATTERN,
+  MAX_PROPERTIES_BYTES,
+  NAVIGATE_TAG,
+  TRACK_TAG,
+  Transport,
+  createRecorder,
+  hashToUnitInterval,
+  isSampledIn,
+  resolveIdentity,
+  resolveOptions,
+  safeStorage,
+  uuidv4,
+  validateTrack
+});
+//# sourceMappingURL=index.cjs.map