@refraction-ui/react 0.19.1 → 0.20.0

package/dist/react-analytics.js

@@ -0,0 +1,1698 @@
+import {
+  devWarn
+} from "./chunk-ZF3OHCGV.js";
+
+// ../react-analytics/dist/index.js
+import * as React from "react";
+
+// ../analytics/dist/index.js
+var SCHEMA_VERSION = 1;
+function uuidv4() {
+  const c = typeof globalThis !== "undefined" ? globalThis.crypto : void 0;
+  if (c && typeof c.randomUUID === "function") {
+    return c.randomUUID();
+  }
+  const bytes = new Uint8Array(16);
+  if (c && typeof c.getRandomValues === "function") {
+    c.getRandomValues(bytes);
+  } else {
+    for (let i = 0; i < 16; i++) bytes[i] = Math.floor(Math.random() * 256);
+  }
+  bytes[6] = bytes[6] & 15 | 64;
+  bytes[8] = bytes[8] & 63 | 128;
+  const hex = [];
+  for (let i = 0; i < 256; i++) hex.push((i + 256).toString(16).slice(1));
+  return hex[bytes[0]] + hex[bytes[1]] + hex[bytes[2]] + hex[bytes[3]] + "-" + hex[bytes[4]] + hex[bytes[5]] + "-" + hex[bytes[6]] + hex[bytes[7]] + "-" + hex[bytes[8]] + hex[bytes[9]] + "-" + hex[bytes[10]] + hex[bytes[11]] + hex[bytes[12]] + hex[bytes[13]] + hex[bytes[14]] + hex[bytes[15]];
+}
+var UUID_V4_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+function isUuidV4(value) {
+  return typeof value === "string" && UUID_V4_RE.test(value);
+}
+function createMemoryStorage() {
+  const map = /* @__PURE__ */ new Map();
+  return {
+    get: (k) => map.has(k) ? map.get(k) : null,
+    set: (k, v) => {
+      map.set(k, v);
+    },
+    remove: (k) => {
+      map.delete(k);
+    }
+  };
+}
+function createLocalStorageAdapter(ls) {
+  return {
+    get: (k) => {
+      try {
+        return ls.getItem(k);
+      } catch {
+        return null;
+      }
+    },
+    set: (k, v) => {
+      try {
+        ls.setItem(k, v);
+      } catch {
+      }
+    },
+    remove: (k) => {
+      try {
+        ls.removeItem(k);
+      } catch {
+      }
+    }
+  };
+}
+function createCookieAdapter(doc, maxAgeSeconds = 60 * 60 * 24 * 365) {
+  const read = (k) => {
+    const target = encodeURIComponent(k) + "=";
+    const parts = doc.cookie ? doc.cookie.split(";") : [];
+    for (const part of parts) {
+      const c = part.trim();
+      if (c.startsWith(target)) {
+        return decodeURIComponent(c.slice(target.length));
+      }
+    }
+    return null;
+  };
+  return {
+    get: read,
+    set: (k, v) => {
+      doc.cookie = `${encodeURIComponent(k)}=${encodeURIComponent(
+        v
+      )}; path=/; max-age=${maxAgeSeconds}; SameSite=Lax`;
+    },
+    remove: (k) => {
+      doc.cookie = `${encodeURIComponent(k)}=; path=/; max-age=0; SameSite=Lax`;
+    }
+  };
+}
+function resolveStorage(override) {
+  if (override) return override;
+  const g = globalThis;
+  if (g.localStorage) {
+    try {
+      const probe = "__rfx_a_probe__";
+      g.localStorage.setItem(probe, "1");
+      g.localStorage.removeItem(probe);
+      return createLocalStorageAdapter(g.localStorage);
+    } catch {
+    }
+  }
+  if (g.document && typeof g.document.cookie === "string") {
+    return createCookieAdapter(g.document);
+  }
+  return createMemoryStorage();
+}
+var DEFAULT_SESSION_TIMEOUT_MS = 30 * 60 * 1e3;
+var DEFAULT_KEY = "rfx:analytics:session";
+var CAMPAIGN_PARAMS = [
+  "utm_source",
+  "utm_medium",
+  "utm_campaign",
+  "utm_term",
+  "utm_content",
+  "gclid",
+  "fbclid",
+  "msclkid"
+];
+function campaignFingerprint(search) {
+  if (!search) return void 0;
+  let qs = search;
+  const q = qs.indexOf("?");
+  if (q !== -1) qs = qs.slice(q + 1);
+  let params;
+  try {
+    params = new URLSearchParams(qs);
+  } catch {
+    return void 0;
+  }
+  const pairs = [];
+  for (const p of CAMPAIGN_PARAMS) {
+    const v = params.get(p);
+    if (v) pairs.push(`${p}=${v}`);
+  }
+  return pairs.length ? pairs.join("&") : void 0;
+}
+function createSession(config, now = () => Date.now()) {
+  const storage = resolveStorage(config?.storage);
+  const key = config?.storageKey ?? DEFAULT_KEY;
+  const timeoutMs = config?.timeoutMs ?? DEFAULT_SESSION_TIMEOUT_MS;
+  const resetOnCampaign = config?.resetOnCampaign ?? true;
+  function read() {
+    const raw = storage.get(key);
+    if (!raw) return null;
+    try {
+      const parsed = JSON.parse(raw);
+      if (parsed && typeof parsed.id === "string") return parsed;
+    } catch {
+    }
+    return null;
+  }
+  function write(s) {
+    storage.set(key, JSON.stringify(s));
+  }
+  function mint(campaign) {
+    const s = {
+      id: uuidv4(),
+      lastActivity: now(),
+      campaign
+    };
+    write(s);
+    return s;
+  }
+  function ensure(campaign) {
+    const existing = read();
+    const t = now();
+    if (!existing) return mint(campaign);
+    if (t - existing.lastActivity > timeoutMs) {
+      return mint(campaign);
+    }
+    if (resetOnCampaign && campaign !== void 0 && existing.campaign !== campaign) {
+      return mint(campaign);
+    }
+    return existing;
+  }
+  return {
+    /** Get the current session id, rotating if expired. */
+    id(campaign) {
+      return ensure(campaign).id;
+    },
+    /** Force a brand-new session. */
+    start(campaign) {
+      return mint(campaign).id;
+    },
+    /** End the current session (next id() mints a fresh one). */
+    end() {
+      storage.remove(key);
+    },
+    /** Touch activity so the inactivity window slides forward. */
+    touch(campaign) {
+      const s = ensure(campaign);
+      s.lastActivity = now();
+      write(s);
+      return s.id;
+    },
+    /** Attach/merge session-scoped properties. */
+    set(props) {
+      const s = ensure();
+      s.props = { ...s.props ?? {}, ...props };
+      write(s);
+    },
+    /** Read session-scoped properties (undefined when none). */
+    props() {
+      return read()?.props;
+    }
+  };
+}
+var DEFAULT_KEY2 = "rfx:analytics:anon";
+function createIdentity(config) {
+  const storage = resolveStorage(config?.storage);
+  const key = config?.storageKey ?? DEFAULT_KEY2;
+  let userId;
+  function loadOrMintAnon() {
+    const existing = storage.get(key);
+    if (isUuidV4(existing)) return existing;
+    const fresh = uuidv4();
+    storage.set(key, fresh);
+    return fresh;
+  }
+  let anonymousId = loadOrMintAnon();
+  return {
+    anonymousId() {
+      return anonymousId;
+    },
+    userId() {
+      return userId;
+    },
+    /** identify(): bind an opaque app user id (no validation, no persistence). */
+    setUserId(id) {
+      userId = id;
+    },
+    /**
+     * alias(): returns the stitch pair for the envelope. `previousId`
+     * defaults to the current user or anonymous id.
+     */
+    alias(nextUserId, previousId) {
+      const prev = previousId ?? userId ?? anonymousId;
+      userId = nextUserId;
+      return { userId: nextUserId, previousId: prev };
+    },
+    /**
+     * reset(): privacy-safe logout. Drops the user binding and mints a brand
+     * new anonymousId so the next visitor is not stitched to the old one.
+     */
+    reset() {
+      userId = void 0;
+      anonymousId = uuidv4();
+      storage.set(key, anonymousId);
+      return anonymousId;
+    }
+  };
+}
+function createConsent(config) {
+  const granted = new Set(config?.granted ?? []);
+  return {
+    strict: config?.strict ?? false,
+    grant(...categories) {
+      for (const c of categories) granted.add(c);
+    },
+    revoke(...categories) {
+      for (const c of categories) granted.delete(c);
+    },
+    granted() {
+      return [...granted];
+    },
+    isGranted(category) {
+      return granted.has(category);
+    },
+    allows(required) {
+      if (!required || required.length === 0) return true;
+      return required.every((c) => granted.has(c));
+    }
+  };
+}
+var PII_DENY_LIST = [
+  "email",
+  "phone",
+  "mobile",
+  "firstname",
+  "lastname",
+  "fullname",
+  "givenname",
+  "surname",
+  "password",
+  "passwd",
+  "ssn",
+  "creditcard",
+  "cardnumber",
+  "cvv",
+  "dob",
+  "dateofbirth",
+  "address"
+];
+var PII_EXACT_KEYS = ["name"];
+var REDACTED = "[REDACTED]";
+function normalize(key) {
+  return key.toLowerCase().replace(/[_\-\s]/g, "");
+}
+function createRedactor(extraKeys = []) {
+  const exact = /* @__PURE__ */ new Set([
+    ...extraKeys.map(normalize),
+    ...PII_EXACT_KEYS.map(normalize)
+  ]);
+  const deny = PII_DENY_LIST.map(normalize);
+  const shouldRedact = (key) => {
+    const n = normalize(key);
+    if (exact.has(n)) return true;
+    return deny.some((d) => n.includes(d));
+  };
+  const walk = (value) => {
+    if (Array.isArray(value)) return value.map(walk);
+    if (value && typeof value === "object") {
+      const out = {};
+      for (const [k, v] of Object.entries(value)) {
+        out[k] = shouldRedact(k) ? REDACTED : walk(v);
+      }
+      return out;
+    }
+    return value;
+  };
+  return {
+    shouldRedact,
+    /** Redact a properties/traits bag (returns a new object). */
+    redact(props) {
+      if (!props) return props;
+      return walk(props);
+    }
+  };
+}
+var NO_RETRY = /* @__PURE__ */ new Set([400, 401, 413]);
+function base64(input) {
+  const g = globalThis;
+  if (typeof g.btoa === "function") {
+    return g.btoa(input);
+  }
+  if (g.Buffer) {
+    return g.Buffer.from(input, "utf-8").toString("base64");
+  }
+  throw new Error("No base64 implementation available (btoa/Buffer)");
+}
+function byteLength(s) {
+  const g = globalThis;
+  if (g.TextEncoder) return new g.TextEncoder().encode(s).length;
+  return unescape(encodeURIComponent(s)).length;
+}
+var sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+function splitBatch(batch, maxBatchBytes, maxEventBytes) {
+  const batches = [];
+  const dropped = [];
+  let current = [];
+  let currentBytes = 2;
+  for (const ev of batch) {
+    const evBytes = byteLength(JSON.stringify(ev));
+    if (evBytes > maxEventBytes) {
+      dropped.push(ev);
+      continue;
+    }
+    if (current.length && currentBytes + evBytes + 1 > maxBatchBytes) {
+      batches.push(current);
+      current = [];
+      currentBytes = 2;
+    }
+    current.push(ev);
+    currentBytes += evBytes + 1;
+  }
+  if (current.length) batches.push(current);
+  return { batches, dropped };
+}
+function createHttpSink(options) {
+  const {
+    endpoint,
+    writeKey,
+    maxRetries = 3,
+    backoffBaseMs = 500,
+    consentCategories = ["analytics"],
+    maxBatchBytes = 5e5,
+    maxEventBytes = 32e3
+  } = options;
+  const base = endpoint.replace(/\/+$/, "");
+  const url = `${base}/v${SCHEMA_VERSION}/batch`;
+  const authHeader = `Basic ${base64(`${writeKey}:`)}`;
+  const now = options.now ?? (() => /* @__PURE__ */ new Date());
+  const resolveFetch2 = () => {
+    if (options.fetchImpl) return options.fetchImpl;
+    const f = globalThis.fetch;
+    if (!f) throw new Error("No fetch implementation available");
+    return f;
+  };
+  const resolveBeacon = () => {
+    if (options.beaconImpl) return options.beaconImpl;
+    const nav = globalThis.navigator;
+    if (nav && typeof nav.sendBeacon === "function") {
+      return (u, body) => nav.sendBeacon(u, body);
+    }
+    return void 0;
+  };
+  function envelope(batch) {
+    return {
+      batch,
+      sentAt: now().toISOString(),
+      batchId: uuidv4()
+    };
+  }
+  function sendViaBeacon(batch) {
+    const beacon = resolveBeacon();
+    if (!beacon) return false;
+    const beaconUrl = `${url}?writeKey=${encodeURIComponent(writeKey)}`;
+    return beacon(beaconUrl, JSON.stringify(envelope(batch)));
+  }
+  async function sendViaFetch(batch) {
+    const doFetch = resolveFetch2();
+    const body = JSON.stringify(envelope(batch));
+    for (let attempt = 0; ; attempt++) {
+      let status;
+      try {
+        const res = await doFetch(url, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json",
+            Authorization: authHeader
+          },
+          body,
+          keepalive: true
+        });
+        status = res.status;
+      } catch {
+        status = 0;
+      }
+      if (status >= 200 && status < 300) return;
+      if (NO_RETRY.has(status)) return;
+      if (attempt >= maxRetries) return;
+      const delay = backoffBaseMs * 2 ** attempt;
+      await sleep(delay);
+    }
+  }
+  return {
+    name: "http",
+    consentCategories,
+    async deliver(batch, ctx) {
+      if (batch.length === 0) return;
+      const { batches } = splitBatch(
+        batch,
+        maxBatchBytes,
+        maxEventBytes
+      );
+      for (const part of batches) {
+        if (ctx.unload) {
+          if (sendViaBeacon(part)) continue;
+          void sendViaFetch(part);
+        } else {
+          await sendViaFetch(part);
+        }
+      }
+    }
+  };
+}
+function createConsoleSink(options = {}) {
+  const logger = options.logger ?? globalThis.console;
+  return {
+    name: "console",
+    consentCategories: options.consentCategories,
+    deliver(batch) {
+      for (const ev of batch) {
+        const label = `[analytics] ${ev.type}${ev.event ? ` ${ev.event}` : ""}`;
+        if (typeof logger.groupCollapsed === "function") {
+          logger.groupCollapsed(label);
+          logger.log(ev);
+          logger.groupEnd?.();
+        } else {
+          logger.log(label, ev);
+        }
+      }
+    }
+  };
+}
+function createNoopAnalytics() {
+  const sessionId = "00000000-0000-4000-8000-000000000000";
+  const noop = () => {
+  };
+  const api = {
+    track: noop,
+    identify: noop,
+    page: noop,
+    screen: noop,
+    group: noop,
+    alias: noop,
+    session: {
+      id: () => sessionId,
+      start: () => sessionId,
+      end: noop,
+      set: noop
+    },
+    consent: {
+      grant: noop,
+      revoke: noop,
+      granted: () => [],
+      isGranted: () => false
+    },
+    anonymousId: () => sessionId,
+    userId: () => void 0,
+    with: () => api,
+    addSink: noop,
+    removeSink: noop,
+    get sinks() {
+      return [];
+    },
+    flush: async () => {
+    },
+    reset: noop,
+    enabled: false
+  };
+  return api;
+}
+var LIBRARY = {
+  name: "@refraction-ui/analytics",
+  version: "0.1.0"
+};
+function readPage() {
+  const g = globalThis;
+  if (!g.location && !g.document) return void 0;
+  return {
+    path: g.location?.pathname,
+    url: g.location?.href,
+    search: g.location?.search,
+    title: g.document?.title,
+    referrer: g.document?.referrer
+  };
+}
+function createAnalytics(config) {
+  if (config.enabled === false) {
+    return createNoopAnalytics();
+  }
+  const { app, env } = config;
+  const preset = config.preset ?? (env === "production" ? "prod" : "dev");
+  const sampleRate = config.sampleRate ?? 1;
+  const batchSize = config.batchSize ?? 20;
+  const flushIntervalMs = config.flushIntervalMs ?? 1e4;
+  const now = config.now ?? (() => /* @__PURE__ */ new Date());
+  const random = config.random ?? (() => Math.random());
+  const session = createSession(config.session);
+  const identity = createIdentity(config.identity);
+  const consent = createConsent(config.consent);
+  const redactor = createRedactor(config.redactKeys);
+  const sinks = /* @__PURE__ */ new Map();
+  const sinkOrder = [];
+  const initialized = /* @__PURE__ */ new Set();
+  function registerSink(sink) {
+    if (!sinks.has(sink.name)) sinkOrder.push(sink.name);
+    sinks.set(sink.name, sink);
+  }
+  if (config.endpoint) {
+    registerSink(
+      createHttpSink({
+        endpoint: config.endpoint,
+        writeKey: config.writeKey ?? "",
+        // One clock for the whole manager: the auto sink stamps sentAt with it too.
+        now
+      })
+    );
+  }
+  if (preset === "dev") {
+    registerSink(createConsoleSink());
+  }
+  for (const s of config.sinks ?? []) registerSink(s);
+  function ensureInit(sink) {
+    if (initialized.has(sink.name)) return;
+    initialized.add(sink.name);
+    if (sink.init) {
+      return sink.init({ app, env, endpoint: config.endpoint });
+    }
+  }
+  const buffer = [];
+  let timer;
+  function startTimer() {
+    if (preset !== "prod" || timer) return;
+    timer = setInterval(() => {
+      void flush(false);
+    }, flushIntervalMs);
+    timer.unref?.();
+  }
+  function deliverToSinks(batch, unload) {
+    if (batch.length === 0) return;
+    const ctx = { unload };
+    const pending = [];
+    for (const name of sinkOrder) {
+      const sink = sinks.get(name);
+      if (!sink) continue;
+      if (!consent.allows(sink.consentCategories)) continue;
+      const inited = ensureInit(sink);
+      if (inited && typeof inited.then === "function") {
+        pending.push(
+          inited.then(() => sink.deliver(batch, ctx))
+        );
+      } else {
+        const r = sink.deliver(batch, ctx);
+        if (r && typeof r.then === "function") {
+          pending.push(r);
+        }
+      }
+    }
+    if (pending.length) return Promise.all(pending).then(() => void 0);
+  }
+  async function flush(unload = false) {
+    const batch = buffer.splice(0, buffer.length);
+    await deliverToSinks(batch, unload);
+    for (const name of sinkOrder) {
+      const sink = sinks.get(name);
+      if (sink?.flush && consent.allows(sink.consentCategories)) {
+        await sink.flush();
+      }
+    }
+  }
+  function bindUnload() {
+    if (preset !== "prod") return;
+    const g = globalThis;
+    if (typeof g.addEventListener !== "function") return;
+    const onUnload = () => {
+      void deliverToSinks(buffer.splice(0, buffer.length), true);
+    };
+    g.addEventListener("pagehide", onUnload);
+    g.addEventListener("visibilitychange", () => {
+      if (g.document?.visibilityState === "hidden") onUnload();
+    });
+  }
+  startTimer();
+  bindUnload();
+  function buildContext(extra, childCtx) {
+    const page = readPage();
+    return {
+      app,
+      env,
+      ...page ? { page } : {},
+      ...childCtx,
+      ...extra,
+      library: LIBRARY
+    };
+  }
+  function sampled() {
+    if (sampleRate >= 1) return true;
+    if (sampleRate <= 0) return false;
+    return random() < sampleRate;
+  }
+  function enqueue(ev) {
+    if (preset === "dev") {
+      void deliverToSinks([ev], false);
+      return;
+    }
+    buffer.push(ev);
+    if (buffer.length >= batchSize) {
+      void flush(false);
+    }
+  }
+  function emit(type, fields, childCtx, opts) {
+    if (!sampled()) return;
+    const page = readPage();
+    const campaign = campaignFingerprint(page?.search);
+    const sessionId = session.touch(campaign);
+    const sessionProps = session.props();
+    const ev = {
+      type,
+      messageId: uuidv4(),
+      anonymousId: identity.anonymousId(),
+      userId: identity.userId(),
+      sessionId,
+      context: buildContext(opts?.context, childCtx),
+      timestamp: opts?.timestamp ?? now().toISOString(),
+      schemaVersion: SCHEMA_VERSION,
+      ...fields
+    };
+    if (sessionProps && (ev.properties || type === "track" || type === "page" || type === "screen")) {
+      ev.properties = { ...sessionProps, ...ev.properties ?? {} };
+    }
+    enqueue(ev);
+  }
+  function makeApi(childCtx) {
+    const api = {
+      track(event, properties, opts) {
+        emit(
+          "track",
+          { event, properties: redactor.redact(properties) },
+          childCtx,
+          opts
+        );
+      },
+      identify(userId, traits, opts) {
+        identity.setUserId(userId);
+        emit("identify", { traits: redactor.redact(traits) }, childCtx, opts);
+      },
+      page(name, properties, opts) {
+        emit(
+          "page",
+          { event: name, properties: redactor.redact(properties) },
+          childCtx,
+          opts
+        );
+      },
+      screen(name, properties, opts) {
+        emit(
+          "screen",
+          { event: name, properties: redactor.redact(properties) },
+          childCtx,
+          opts
+        );
+      },
+      group(groupId, traits, opts) {
+        emit(
+          "group",
+          { groupId, traits: redactor.redact(traits) },
+          childCtx,
+          opts
+        );
+      },
+      alias(userId, previousId, opts) {
+        const stitch = identity.alias(userId, previousId);
+        emit(
+          "alias",
+          { userId: stitch.userId, previousId: stitch.previousId },
+          childCtx,
+          opts
+        );
+      },
+      session: {
+        id: () => session.id(),
+        start: () => session.start(),
+        end: () => session.end(),
+        set: (props) => session.set(props)
+      },
+      consent: {
+        grant: (...c) => consent.grant(...c),
+        revoke: (...c) => consent.revoke(...c),
+        granted: () => consent.granted(),
+        isGranted: (c) => consent.isGranted(c)
+      },
+      anonymousId: () => identity.anonymousId(),
+      userId: () => identity.userId(),
+      with(extra) {
+        return makeApi({ ...childCtx, ...extra });
+      },
+      addSink(sink) {
+        registerSink(sink);
+      },
+      removeSink(name) {
+        if (sinks.has(name)) {
+          sinks.delete(name);
+          const i = sinkOrder.indexOf(name);
+          if (i !== -1) sinkOrder.splice(i, 1);
+          initialized.delete(name);
+        }
+      },
+      get sinks() {
+        return [...sinkOrder];
+      },
+      async flush() {
+        await flush(false);
+      },
+      reset() {
+        identity.reset();
+        session.end();
+      },
+      enabled: true
+    };
+    return api;
+  }
+  return makeApi();
+}
+
+// ../analytics-sink-ga4/dist/index.js
+var GA4_RESERVED_PREFIXES = ["google_", "ga_", "firebase_"];
+function toGa4Name(name) {
+  const snake = name.trim().replace(/['"]/g, "").replace(/[^a-zA-Z0-9]+/g, "_").replace(/([a-z0-9])([A-Z])/g, "$1_$2").replace(/_+/g, "_").replace(/^_+|_+$/g, "").toLowerCase();
+  const safe = /^[a-z]/.test(snake) ? snake : `e_${snake}`;
+  return GA4_RESERVED_PREFIXES.some((p) => safe.startsWith(p)) ? `x_${safe}` : safe;
+}
+function ga4EventName(ev) {
+  switch (ev.type) {
+    case "identify":
+      return void 0;
+    case "page":
+      return "page_view";
+    case "screen":
+      return "screen_view";
+    case "group":
+      return "group";
+    case "alias":
+      return "alias";
+    case "track":
+      return ev.event ? toGa4Name(ev.event) : "track";
+    default:
+      return void 0;
+  }
+}
+function toUserProperties(traits) {
+  if (!traits) return void 0;
+  const out = {};
+  let any = false;
+  for (const [k, v] of Object.entries(traits)) {
+    if (v === void 0) continue;
+    out[toGa4Name(k)] = { value: v };
+    any = true;
+  }
+  return any ? out : void 0;
+}
+function toParams(ev) {
+  const params = {};
+  for (const [k, v] of Object.entries(ev.properties ?? {})) {
+    if (v === void 0) continue;
+    params[toGa4Name(k)] = v;
+  }
+  params.session_id = ev.sessionId;
+  params.engagement_time_msec = params.engagement_time_msec ?? 1;
+  const page = ev.context.page;
+  if (ev.type === "page" || ev.type === "screen") {
+    if (ev.event) {
+      if (ev.type === "screen") params.screen_name = ev.event;
+      else params.page_title = params.page_title ?? ev.event;
+    }
+    if (page?.url && params.page_location === void 0) {
+      params.page_location = page.url;
+    }
+    if (page?.path && params.page_path === void 0) {
+      params.page_path = page.path;
+    }
+    if (page?.referrer && params.page_referrer === void 0) {
+      params.page_referrer = page.referrer;
+    }
+    if (page?.title && params.page_title === void 0) {
+      params.page_title = page.title;
+    }
+  }
+  if (ev.type === "group" && ev.groupId) {
+    params.group_id = ev.groupId;
+  }
+  if (ev.type === "alias") {
+    if (ev.userId) params.user_id = ev.userId;
+    if (ev.previousId) params.previous_id = ev.previousId;
+  }
+  return params;
+}
+function mapEvent(ev) {
+  const name = ga4EventName(ev);
+  const mapped = {
+    clientId: ev.anonymousId
+  };
+  if (ev.userId) mapped.userId = ev.userId;
+  if (ev.type === "identify" || ev.type === "group") {
+    const up = toUserProperties(ev.traits);
+    if (up) mapped.userProperties = up;
+  }
+  if (name) {
+    mapped.event = { name, params: toParams(ev) };
+  }
+  return mapped;
+}
+var DEFAULT_ENDPOINT = "https://www.google-analytics.com";
+var MAX_EVENTS_PER_REQUEST = 25;
+function resolveFetch(opts) {
+  if (opts.fetchImpl) return opts.fetchImpl;
+  const f = globalThis.fetch;
+  if (!f) throw new Error("GA4 http sink: no fetch implementation available");
+  return f;
+}
+function buildPayloads(batch) {
+  const payloads = [];
+  for (const ev of batch) {
+    const m = mapEvent(ev);
+    const last = payloads[payloads.length - 1];
+    const sameIdentity = last && last.client_id === m.clientId && last.user_id === m.userId && last.events.length < MAX_EVENTS_PER_REQUEST && // user_properties must not silently differ within one request
+    JSON.stringify(last.user_properties) === JSON.stringify(m.userProperties);
+    const target = sameIdentity ? last : (() => {
+      const p = { client_id: m.clientId, events: [] };
+      if (m.userId) p.user_id = m.userId;
+      if (m.userProperties) p.user_properties = m.userProperties;
+      payloads.push(p);
+      return p;
+    })();
+    if (m.event) {
+      target.events.push(m.event);
+    }
+  }
+  return payloads.filter(
+    (p) => p.events.length > 0 || p.user_id !== void 0 || p.user_properties !== void 0
+  );
+}
+function createGA4HttpSink(options) {
+  const {
+    measurementId,
+    apiSecret,
+    consentCategories = ["analytics"],
+    name = "ga4",
+    debug = false
+  } = options;
+  const base = (options.endpoint ?? DEFAULT_ENDPOINT).replace(/\/+$/, "");
+  const path = debug ? "/debug/mp/collect" : "/mp/collect";
+  const url = `${base}${path}?measurement_id=${encodeURIComponent(measurementId)}&api_secret=${encodeURIComponent(apiSecret)}`;
+  return {
+    name,
+    consentCategories,
+    init(_ctx) {
+    },
+    async deliver(batch) {
+      if (batch.length === 0) return;
+      const payloads = buildPayloads(batch);
+      if (payloads.length === 0) return;
+      const doFetch = resolveFetch(options);
+      for (const payload of payloads) {
+        try {
+          await doFetch(url, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify(payload),
+            keepalive: true
+          });
+        } catch {
+        }
+      }
+    }
+  };
+}
+var DEFAULT_SRC_BASE = "https://www.googletagmanager.com/gtag/js";
+function defaultScriptLoader(src) {
+  const g = globalThis;
+  const doc = g.document;
+  if (!doc || typeof doc.createElement !== "function") {
+    return Promise.reject(
+      new Error("GA4 client-sdk sink: no DOM to inject gtag.js")
+    );
+  }
+  return new Promise((resolve, reject) => {
+    const el = doc.createElement("script");
+    el.async = true;
+    el.src = src;
+    el.onload = () => resolve();
+    el.onerror = () => reject(new Error("GA4 client-sdk: gtag.js failed"));
+    if (doc.head?.appendChild) {
+      doc.head.appendChild(el);
+    } else {
+      const first = doc.getElementsByTagName("script")[0];
+      first?.parentNode?.insertBefore(el, first);
+    }
+  });
+}
+function createGA4ClientSdkSink(options) {
+  const {
+    measurementId,
+    consentCategories = ["analytics"],
+    name = "ga4",
+    consentMode
+  } = options;
+  const g = globalThis;
+  let gtag = options.gtag;
+  let loaded = false;
+  let loadPromise;
+  function ensureGtagStub() {
+    if (gtag) return gtag;
+    g.dataLayer = g.dataLayer ?? [];
+    const dl = g.dataLayer;
+    const fn = (...args) => {
+      dl.push(args);
+    };
+    g.gtag = g.gtag ?? fn;
+    gtag = g.gtag;
+    return gtag;
+  }
+  function pushConsentDefault() {
+    if (!consentMode?.default || !gtag) return;
+    gtag("consent", "default", { ...consentMode.default });
+  }
+  function pushConsentUpdate() {
+    if (!consentMode?.map || !gtag) return;
+    const update = {};
+    for (const cat of consentCategories) {
+      for (const ga4Type of consentMode.map[cat] ?? []) {
+        update[ga4Type] = "granted";
+      }
+    }
+    if (Object.keys(update).length > 0) {
+      gtag("consent", "update", update);
+    }
+  }
+  function ensureLoaded() {
+    if (loaded) return Promise.resolve();
+    if (loadPromise) return loadPromise;
+    ensureGtagStub();
+    pushConsentDefault();
+    if (options.gtag) {
+      gtag("js", /* @__PURE__ */ new Date());
+      gtag("config", measurementId, { send_page_view: false });
+      loaded = true;
+      return Promise.resolve();
+    }
+    const base = options.gtagSrcBase ?? DEFAULT_SRC_BASE;
+    const src = `${base}?id=${encodeURIComponent(measurementId)}`;
+    const load = options.scriptLoader ?? defaultScriptLoader;
+    loadPromise = load(src).then(() => {
+      gtag("js", /* @__PURE__ */ new Date());
+      gtag("config", measurementId, { send_page_view: false });
+      loaded = true;
+    });
+    return loadPromise;
+  }
+  return {
+    name,
+    consentCategories,
+    init(_ctx) {
+      ensureGtagStub();
+      pushConsentDefault();
+    },
+    async deliver(batch) {
+      if (batch.length === 0) return;
+      await ensureLoaded();
+      const send = gtag;
+      pushConsentUpdate();
+      for (const ev of batch) {
+        const m = mapEvent(ev);
+        if (m.userId) {
+          send("set", { user_id: m.userId });
+        }
+        if (m.userProperties) {
+          const flat = {};
+          for (const [k, v] of Object.entries(m.userProperties)) {
+            flat[k] = v.value;
+          }
+          send("set", "user_properties", flat);
+        }
+        if (m.event) {
+          send("event", m.event.name, m.event.params);
+        }
+      }
+    }
+  };
+}
+function createGA4Sink(options) {
+  if (options.mode === "client-sdk") {
+    return createGA4ClientSdkSink(options);
+  }
+  return createGA4HttpSink(options);
+}
+
+// ../analytics-sink-app-insights/dist/index.js
+var FALLBACK_TRACK_NAME = "track";
+function eventName(ev) {
+  switch (ev.type) {
+    case "page":
+      return `Page View: ${ev.event ?? ev.context.page?.path ?? "(unknown)"}`;
+    case "screen":
+      return `Screen: ${ev.event ?? "(unknown)"}`;
+    case "identify":
+      return "Identify";
+    case "group":
+      return "Group";
+    case "alias":
+      return "Alias";
+    case "track":
+    default:
+      return ev.event ?? FALLBACK_TRACK_NAME;
+  }
+}
+function isMeasurement(value) {
+  return typeof value === "number" && Number.isFinite(value);
+}
+function stringify(value) {
+  if (typeof value === "string") return value;
+  if (typeof value === "boolean" || typeof value === "bigint") {
+    return String(value);
+  }
+  if (typeof value === "number") return String(value);
+  try {
+    return JSON.stringify(value) ?? String(value);
+  } catch {
+    return String(value);
+  }
+}
+function splitBag(bag, prefix, properties, measurements) {
+  if (!bag) return;
+  for (const [key, value] of Object.entries(bag)) {
+    if (value === void 0 || value === null) continue;
+    const flatKey = prefix ? `${prefix}.${key}` : key;
+    if (isMeasurement(value)) {
+      measurements[flatKey] = value;
+      continue;
+    }
+    if (typeof value === "object" && !Array.isArray(value) && value.constructor === Object) {
+      splitBag(
+        value,
+        flatKey,
+        properties,
+        measurements
+      );
+      continue;
+    }
+    properties[flatKey] = stringify(value);
+  }
+}
+function mapEvent2(ev) {
+  const properties = {};
+  const measurements = {};
+  if (ev.userId !== void 0) {
+    properties.authenticatedUserId = ev.userId;
+    properties.anonymous = "false";
+  } else {
+    properties.anonymous = "true";
+  }
+  properties.messageId = ev.messageId;
+  properties.anonymousId = ev.anonymousId;
+  properties.sessionId = ev.sessionId;
+  properties.eventType = ev.type;
+  properties.timestamp = ev.timestamp;
+  measurements.schemaVersion = ev.schemaVersion;
+  if (ev.groupId !== void 0) properties.groupId = ev.groupId;
+  if (ev.previousId !== void 0) properties.previousId = ev.previousId;
+  if (ev.event !== void 0) properties.eventName = ev.event;
+  properties.app = ev.context.app;
+  properties.env = ev.context.env;
+  properties.libraryName = ev.context.library.name;
+  properties.libraryVersion = ev.context.library.version;
+  if (ev.context.page) {
+    splitBag(
+      ev.context.page,
+      "page",
+      properties,
+      measurements
+    );
+  }
+  splitBag(ev.properties, "", properties, measurements);
+  splitBag(ev.traits, "", properties, measurements);
+  return { name: eventName(ev), properties, measurements };
+}
+var DEFAULT_INGEST_ENDPOINT = "https://dc.services.visualstudio.com";
+var NO_RETRY2 = /* @__PURE__ */ new Set([400, 401, 403, 413]);
+var sleep2 = (ms) => new Promise((r) => setTimeout(r, ms));
+var appInsightsWebSpecifier = "@microsoft/applicationinsights-web";
+function createClientSdkSink(opts) {
+  const name = opts.name ?? "app-insights";
+  let instance = opts.appInsights;
+  let loading;
+  async function resolveSdk() {
+    if (instance) return instance;
+    if (loading) return loading;
+    loading = (async () => {
+      if (opts.loadSdk) {
+        instance = await opts.loadSdk({
+          connectionString: opts.connectionString,
+          instrumentationKey: opts.instrumentationKey
+        });
+        return instance;
+      }
+      const mod = await import(appInsightsWebSpecifier);
+      const ai = new mod.ApplicationInsights({
+        config: {
+          connectionString: opts.connectionString,
+          instrumentationKey: opts.instrumentationKey
+        }
+      });
+      ai.loadAppInsights?.();
+      instance = ai;
+      return ai;
+    })();
+    return loading;
+  }
+  let lastAuthUserId;
+  return {
+    name,
+    consentCategories: opts.consentCategories ?? ["analytics"],
+    async deliver(batch) {
+      if (batch.length === 0) return;
+      const ai = await resolveSdk();
+      for (const ev of batch) {
+        if (ev.userId !== void 0 && ev.userId !== lastAuthUserId) {
+          ai.setAuthenticatedUserContext?.(ev.userId);
+          lastAuthUserId = ev.userId;
+        }
+        if (ev.type === "identify" && ev.userId === void 0 && lastAuthUserId !== void 0) {
+          ai.clearAuthenticatedUserContext?.();
+          lastAuthUserId = void 0;
+        }
+        const mapped = mapEvent2(ev);
+        const merged = {
+          ...mapped.properties,
+          ...mapped.measurements
+        };
+        if (ev.type === "page") {
+          ai.trackPageView({
+            name: ev.event ?? ev.context.page?.path,
+            uri: ev.context.page?.url,
+            properties: mapped.properties,
+            measurements: mapped.measurements
+          });
+        } else {
+          ai.trackEvent({ name: mapped.name }, merged);
+        }
+      }
+    },
+    async flush() {
+      if (instance?.flush) instance.flush(false);
+    },
+    shutdown() {
+      instance = void 0;
+      loading = void 0;
+      lastAuthUserId = void 0;
+    }
+  };
+}
+function buildIngestEnvelope(ev, iKey) {
+  const mapped = mapEvent2(ev);
+  const isPage = ev.type === "page";
+  const tags = {
+    "ai.session.id": ev.sessionId,
+    "ai.user.id": ev.anonymousId,
+    "ai.operation.id": ev.messageId,
+    "ai.internal.sdkVersion": `refraction-ui-analytics-app-insights:0.1.0`,
+    "ai.application.ver": ev.context.library.version,
+    "ai.cloud.role": ev.context.app,
+    "ai.cloud.roleInstance": ev.context.env
+  };
+  if (ev.userId !== void 0) tags["ai.user.authUserId"] = ev.userId;
+  return {
+    name: isPage ? "Microsoft.ApplicationInsights.PageView" : "Microsoft.ApplicationInsights.Event",
+    time: ev.timestamp,
+    iKey,
+    tags,
+    data: {
+      baseType: isPage ? "PageViewData" : "EventData",
+      baseData: {
+        ver: 2,
+        name: isPage ? eventName(ev) : mapped.name,
+        properties: mapped.properties,
+        measurements: mapped.measurements
+      }
+    }
+  };
+}
+function createHttpSink2(opts) {
+  const name = opts.name ?? "app-insights";
+  const {
+    instrumentationKey,
+    maxRetries = 3,
+    backoffBaseMs = 500
+  } = opts;
+  const base = (opts.endpoint ?? DEFAULT_INGEST_ENDPOINT).replace(/\/+$/, "");
+  const url = `${base}/v2/track`;
+  const resolveFetch2 = () => {
+    if (opts.fetchImpl) return opts.fetchImpl;
+    const f = globalThis.fetch;
+    if (!f) throw new Error("No fetch implementation available");
+    return f;
+  };
+  async function send(body) {
+    const doFetch = resolveFetch2();
+    for (let attempt = 0; ; attempt++) {
+      let status;
+      try {
+        const res = await doFetch(url, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body,
+          keepalive: true
+        });
+        status = res.status;
+      } catch {
+        status = 0;
+      }
+      if (status >= 200 && status < 300) return;
+      if (NO_RETRY2.has(status)) return;
+      if (attempt >= maxRetries) return;
+      await sleep2(backoffBaseMs * 2 ** attempt);
+    }
+  }
+  return {
+    name,
+    consentCategories: opts.consentCategories ?? ["analytics"],
+    async deliver(batch, _ctx) {
+      if (batch.length === 0) return;
+      const envelopes = batch.map(
+        (ev) => buildIngestEnvelope(ev, instrumentationKey)
+      );
+      await send(JSON.stringify(envelopes));
+    }
+  };
+}
+function createAppInsightsSink(options) {
+  return options.mode === "http" ? createHttpSink2(options) : createClientSdkSink(options);
+}
+
+// ../analytics-sink-posthog/dist/index.js
+function distinctId(ev) {
+  return ev.userId ?? ev.anonymousId;
+}
+function contextProperties(ev) {
+  const ctx = ev.context;
+  const props = {
+    $lib: ctx.library?.name,
+    $lib_version: ctx.library?.version,
+    app: ctx.app,
+    env: ctx.env,
+    $session_id: ev.sessionId,
+    // Keep the canonical anonymous id addressable in PostHog too.
+    anonymousId: ev.anonymousId
+  };
+  const page = ctx.page;
+  if (page) {
+    if (page.url !== void 0) props.$current_url = page.url;
+    if (page.path !== void 0) props.$pathname = page.path;
+    if (page.referrer !== void 0) props.$referrer = page.referrer;
+    if (page.title !== void 0) props.title = page.title;
+    if (page.search !== void 0) props.$search = page.search;
+  }
+  return props;
+}
+function toPostHogEvent(ev) {
+  const base = {
+    distinct_id: distinctId(ev),
+    timestamp: ev.timestamp,
+    uuid: ev.messageId
+  };
+  const props = contextProperties(ev);
+  switch (ev.type) {
+    case "identify": {
+      return {
+        ...base,
+        event: "$identify",
+        properties: {
+          ...props,
+          $set: { ...ev.traits ?? {} },
+          // Stitch the pre-identify anonymous history onto this person.
+          $anon_distinct_id: ev.anonymousId
+        }
+      };
+    }
+    case "group": {
+      const groupType = ev.properties?.groupType ?? "company";
+      return {
+        ...base,
+        event: "$groupidentify",
+        properties: {
+          ...props,
+          $group_type: groupType,
+          $group_key: ev.groupId,
+          $group_set: { ...ev.traits ?? {} }
+        }
+      };
+    }
+    case "alias": {
+      return {
+        ...base,
+        event: "$create_alias",
+        properties: {
+          ...props,
+          // PostHog links `alias` to the current `distinct_id`.
+          alias: ev.previousId
+        }
+      };
+    }
+    case "page": {
+      return {
+        ...base,
+        event: "$pageview",
+        properties: { ...props, ...ev.properties ?? {} }
+      };
+    }
+    case "screen": {
+      return {
+        ...base,
+        event: "$screen",
+        properties: {
+          ...props,
+          $screen_name: ev.event,
+          ...ev.properties ?? {}
+        }
+      };
+    }
+    case "track":
+    default: {
+      return {
+        ...base,
+        event: ev.event ?? "track",
+        properties: { ...props, ...ev.properties ?? {} }
+      };
+    }
+  }
+}
+function toPostHogBatch(batch) {
+  return batch.map(toPostHogEvent);
+}
+var NO_RETRY3 = /* @__PURE__ */ new Set([400, 401, 403, 413]);
+var sleep3 = (ms) => new Promise((r) => setTimeout(r, ms));
+function byteLength2(s) {
+  const g = globalThis;
+  if (g.TextEncoder) return new g.TextEncoder().encode(s).length;
+  return unescape(encodeURIComponent(s)).length;
+}
+function splitBatch2(items, maxBatchBytes, maxEventBytes) {
+  const batches = [];
+  let current = [];
+  let currentBytes = 2;
+  for (const item of items) {
+    const itemBytes = byteLength2(JSON.stringify(item));
+    if (itemBytes > maxEventBytes) continue;
+    if (current.length && currentBytes + itemBytes + 1 > maxBatchBytes) {
+      batches.push(current);
+      current = [];
+      currentBytes = 2;
+    }
+    current.push(item);
+    currentBytes += itemBytes + 1;
+  }
+  if (current.length) batches.push(current);
+  return batches;
+}
+function createPostHogHttpSink(options) {
+  const {
+    apiKey,
+    host = "https://us.i.posthog.com",
+    name = "posthog",
+    consentCategories = ["analytics"],
+    maxRetries = 3,
+    backoffBaseMs = 500,
+    maxBatchBytes = 1e6,
+    maxEventBytes = 32e3
+  } = options;
+  const base = host.replace(/\/+$/, "");
+  const captureUrl = `${base}/capture/`;
+  const batchUrl = `${base}/batch/`;
+  const resolveFetch2 = () => {
+    if (options.fetchImpl) return options.fetchImpl;
+    const f = globalThis.fetch;
+    if (!f) throw new Error("No fetch implementation available");
+    return f;
+  };
+  const resolveBeacon = () => {
+    if (options.beaconImpl) return options.beaconImpl;
+    const nav = globalThis.navigator;
+    if (nav && typeof nav.sendBeacon === "function") {
+      return (u, body) => nav.sendBeacon(u, body);
+    }
+    return void 0;
+  };
+  function payload(part) {
+    if (part.length === 1) {
+      return {
+        url: captureUrl,
+        body: JSON.stringify({ api_key: apiKey, ...part[0] })
+      };
+    }
+    return {
+      url: batchUrl,
+      body: JSON.stringify({ api_key: apiKey, batch: part })
+    };
+  }
+  async function sendViaFetch(part) {
+    const doFetch = resolveFetch2();
+    const { url, body } = payload(part);
+    for (let attempt = 0; ; attempt++) {
+      let status;
+      try {
+        const res = await doFetch(url, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body,
+          keepalive: true
+        });
+        status = res.status;
+      } catch {
+        status = 0;
+      }
+      if (status >= 200 && status < 300) return;
+      if (NO_RETRY3.has(status)) return;
+      if (attempt >= maxRetries) return;
+      await sleep3(backoffBaseMs * 2 ** attempt);
+    }
+  }
+  function sendViaBeacon(part) {
+    const beacon = resolveBeacon();
+    if (!beacon) return false;
+    const { url, body } = payload(part);
+    return beacon(url, body);
+  }
+  return {
+    name,
+    consentCategories,
+    async deliver(batch, ctx) {
+      if (batch.length === 0) return;
+      const items = toPostHogBatch(batch);
+      const parts = splitBatch2(items, maxBatchBytes, maxEventBytes);
+      for (const part of parts) {
+        if (part.length === 0) continue;
+        if (ctx.unload) {
+          if (sendViaBeacon(part)) continue;
+          void sendViaFetch(part);
+        } else {
+          await sendViaFetch(part);
+        }
+      }
+    }
+  };
+}
+var posthogJsSpecifier = "posthog-js";
+async function defaultLoad() {
+  const mod = await import(posthogJsSpecifier);
+  return "default" in mod ? mod.default : mod;
+}
+function createPostHogClientSdkSink(options) {
+  const {
+    apiKey,
+    host = "https://us.i.posthog.com",
+    name = "posthog",
+    consentCategories = ["analytics"],
+    posthogOptions = {}
+  } = options;
+  let ph;
+  let loading;
+  async function ensure() {
+    if (ph) return ph;
+    if (!loading) {
+      const load = options.loadPostHog ? async () => {
+        const m = await options.loadPostHog();
+        return "default" in m ? m.default : m;
+      } : defaultLoad;
+      loading = load().then((instance) => {
+        instance.init(apiKey, {
+          api_host: host,
+          // The canonical router owns the event path — disable PostHog's
+          // own auto-capture and pageview, and never start replay here.
+          autocapture: false,
+          capture_pageview: false,
+          disable_session_recording: true,
+          ...posthogOptions
+        });
+        ph = instance;
+        return instance;
+      });
+    }
+    return loading;
+  }
+  return {
+    name,
+    consentCategories,
+    async init(_ctx) {
+      await ensure();
+    },
+    async deliver(batch) {
+      if (batch.length === 0) return;
+      const client = await ensure();
+      for (const ev of batch) {
+        const did = distinctId(ev);
+        switch (ev.type) {
+          case "identify":
+            client.identify(did, { ...ev.traits ?? {} });
+            break;
+          case "alias":
+            if (ev.previousId) client.alias(ev.previousId, did);
+            break;
+          case "group":
+            client.group(
+              ev.properties?.groupType ?? "company",
+              ev.groupId ?? "",
+              { ...ev.traits ?? {} }
+            );
+            break;
+          case "page":
+            client.capture("$pageview", { ...ev.properties ?? {} });
+            break;
+          case "screen":
+            client.capture("$screen", {
+              $screen_name: ev.event,
+              ...ev.properties ?? {}
+            });
+            break;
+          case "track":
+          default:
+            client.capture(ev.event ?? "track", { ...ev.properties ?? {} });
+            break;
+        }
+      }
+    },
+    shutdown() {
+      ph?.reset();
+    }
+  };
+}
+function createPostHogSink(options) {
+  if (options.mode === "client-sdk") {
+    return createPostHogClientSdkSink(options);
+  }
+  return createPostHogHttpSink(options);
+}
+
+// ../analytics-sink-posthog/dist/replay.js
+var posthogJsSpecifier2 = "posthog-js";
+async function defaultLoad2() {
+  const mod = await import(posthogJsSpecifier2);
+  return "default" in mod ? mod.default : mod;
+}
+async function startSessionReplay(options) {
+  const {
+    apiKey,
+    host = "https://us.i.posthog.com",
+    hasConsent,
+    maskAllText = true,
+    maskAllInputs = true,
+    recordingOptions = {}
+  } = options;
+  const consented = () => typeof hasConsent === "function" ? hasConsent() === true : false;
+  const slot = {};
+  let recording = false;
+  const stop = () => {
+    if (slot.ph && recording) {
+      slot.ph.stopSessionRecording();
+    }
+    recording = false;
+  };
+  const handle = {
+    get recording() {
+      return recording;
+    },
+    enforceConsent() {
+      if (!consented()) stop();
+    },
+    stop
+  };
+  if (!consented()) return handle;
+  const load = options.loadPostHog ? async () => {
+    const m = await options.loadPostHog();
+    return "default" in m ? m.default : m;
+  } : defaultLoad2;
+  slot.ph = await load();
+  slot.ph.init(apiKey, {
+    api_host: host,
+    autocapture: false,
+    capture_pageview: false,
+    // Start with replay disabled, then opt in explicitly below.
+    disable_session_recording: true,
+    session_recording: {
+      maskAllInputs,
+      maskTextSelector: maskAllText ? "*" : void 0,
+      ...recordingOptions
+    }
+  });
+  if (!consented()) return handle;
+  slot.ph.startSessionRecording();
+  recording = slot.ph.sessionRecordingStarted?.() ?? true;
+  return handle;
+}
+
+// ../react-analytics/dist/index.js
+var AnalyticsContext = React.createContext(null);
+var noopAnalytics = null;
+function getNoopAnalytics() {
+  return noopAnalytics ??= createNoopAnalytics();
+}
+function AnalyticsProvider({ children, value }) {
+  const analyticsRef = React.useRef(null);
+  if (!analyticsRef.current) {
+    analyticsRef.current = value;
+  }
+  return React.createElement(
+    AnalyticsContext.Provider,
+    { value: analyticsRef.current },
+    children
+  );
+}
+function useAnalytics(options) {
+  const ctx = React.useContext(AnalyticsContext);
+  let base = ctx;
+  if (!base) {
+    devWarn(
+      "react-analytics/use-analytics-outside-provider",
+      "useAnalytics() (or useTrackEvent()) was called outside an <AnalyticsProvider>. Analytics is a no-op here; wrap your app (or the consuming subtree) in <AnalyticsProvider> to enable it."
+    );
+    base = getNoopAnalytics();
+  }
+  const scope = options?.scope;
+  return React.useMemo(
+    () => scope ? base.with(scope) : base,
+    [base, scope]
+  );
+}
+function useTrackEvent(options) {
+  const analytics = useAnalytics(options);
+  return React.useCallback(
+    (event, properties, opts) => analytics.track(event, properties, opts),
+    [analytics]
+  );
+}
+export {
+  AnalyticsProvider,
+  createAnalytics,
+  createAppInsightsSink,
+  createGA4ClientSdkSink,
+  createGA4HttpSink,
+  createGA4Sink,
+  createPostHogClientSdkSink,
+  createPostHogHttpSink,
+  createPostHogSink,
+  startSessionReplay,
+  useAnalytics,
+  useTrackEvent
+};
+//# sourceMappingURL=react-analytics.js.map