@mrrocket/sdk 0.3.0 → 0.8.0

package/dist/react-native/index.js

@@ -0,0 +1,1743 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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);
+
+// src/native/index.tsx
+var native_exports = {};
+__export(native_exports, {
+  MRRocketFlows: () => MRRocketFlows,
+  MRRocketProvider: () => MRRocketProvider,
+  SDK_VERSION: () => SDK_VERSION,
+  activeRouteName: () => activeRouteName,
+  createMRRocket: () => createMRRocket,
+  getMRRocket: () => getMRRocket,
+  useCancelFlow: () => useCancelFlow,
+  useExpoRouterTracking: () => useExpoRouterTracking,
+  useFlag: () => useFlag,
+  useFlagVariant: () => useFlagVariant,
+  useMRRocket: () => useMRRocket,
+  useNavigationTracking: () => useNavigationTracking,
+  useOnboarding: () => useOnboarding,
+  usePush: () => usePush,
+  useText: () => useText,
+  useVariant: () => useVariant
+});
+module.exports = __toCommonJS(native_exports);
+var import_react2 = require("react");
+
+// src/core.ts
+var SDK_VERSION = "0.8.0";
+var propOf = (person, name) => {
+  const want = name.trim().toLowerCase();
+  for (const [k, v] of Object.entries(person)) if (k.toLowerCase() === want) return v;
+  return void 0;
+};
+var same = (actual, value) => {
+  const a = actual.trim().toLowerCase();
+  const v = value.trim().toLowerCase();
+  return v.startsWith("@") ? a.endsWith(v) : a === v;
+};
+var matchesCondition = (c, person) => {
+  if (c.op === "in cohort") return false;
+  const raw = propOf(person, c.property);
+  const actual = raw === void 0 || raw === null ? "" : String(raw);
+  if (c.op === "\u2265") {
+    const a = Number(actual);
+    const b = Number(c.values[0]);
+    return actual !== "" && Number.isFinite(a) && Number.isFinite(b) && a >= b;
+  }
+  const hit = actual !== "" && c.values.some((v) => same(actual, v));
+  return c.op === "is" || c.op === "in" ? hit : !hit;
+};
+var evaluateFlag = (flag, distinctId, person = {}) => {
+  if (!flag.on) return false;
+  const subject = { id: distinctId, ...person };
+  const set = flag.sets.length ? flag.sets.find((s) => s.conditions.every((c) => matchesCondition(c, subject))) : { conditions: [], rollout: 100 };
+  if (!set) return false;
+  if (flagUnit(`${flag.key}:rollout:${distinctId}`) * 100 >= set.rollout) return false;
+  if (!flag.variants?.length) return true;
+  const u = flagUnit(`${flag.key}:variant:${distinctId}`) * 100;
+  let acc = 0;
+  for (const v of flag.variants) {
+    acc += v.split;
+    if (u < acc) return v.key;
+  }
+  return flag.variants[flag.variants.length - 1].key;
+};
+var flagFor = (key, config, distinctId, person = {}) => {
+  const flag = config?.flags?.find((f) => f.key === key);
+  return flag ? evaluateFlag(flag, distinctId, person) : false;
+};
+var UTM_KEYS = ["utm_source", "utm_medium", "utm_campaign", "utm_term", "utm_content"];
+var SESSION_TIMEOUT_MS = 30 * 60 * 1e3;
+var utmFrom = (get) => {
+  const out = {};
+  for (const key of UTM_KEYS) {
+    const value = get(key)?.trim();
+    if (value) out[key] = value.slice(0, 150);
+  }
+  return out;
+};
+var parseQuery = (url) => {
+  const out = {};
+  const q = url.split("#")[0];
+  const at = q.indexOf("?");
+  if (at < 0) return out;
+  const dec = (s) => {
+    try {
+      return decodeURIComponent(s.replace(/\+/g, " "));
+    } catch {
+      return s;
+    }
+  };
+  for (const pair of q.slice(at + 1).split("&")) {
+    if (!pair) continue;
+    const eq = pair.indexOf("=");
+    const k = dec(eq < 0 ? pair : pair.slice(0, eq));
+    if (k && !(k in out)) out[k] = eq < 0 ? "" : dec(pair.slice(eq + 1));
+  }
+  return out;
+};
+var hashUnit = (input) => {
+  let h2 = 2166136261;
+  for (let i = 0; i < input.length; i++) {
+    h2 ^= input.charCodeAt(i);
+    h2 = Math.imul(h2, 16777619);
+  }
+  return (h2 >>> 0) / 4294967296;
+};
+var flagUnit = (input) => {
+  let h2 = 2166136261;
+  for (let i = 0; i < input.length; i++) {
+    h2 ^= input.charCodeAt(i);
+    h2 = Math.imul(h2, 16777619);
+  }
+  h2 ^= h2 >>> 16;
+  h2 = Math.imul(h2, 2246822507);
+  h2 ^= h2 >>> 13;
+  h2 = Math.imul(h2, 3266489909);
+  h2 ^= h2 >>> 16;
+  return (h2 >>> 0) / 4294967296;
+};
+var assign = (experiment, distinctId) => {
+  const control = experiment.variants[0]?.id ?? "control";
+  if (experiment.winner) return experiment.winner;
+  if (experiment.status !== "running") return control;
+  const u = hashUnit(`${experiment.key}:${distinctId}`);
+  let acc = 0;
+  for (const v of experiment.variants) {
+    acc += v.weight;
+    if (u < acc) return v.id;
+  }
+  return experiment.variants[experiment.variants.length - 1]?.id ?? control;
+};
+var experimentsOfText = (config, id) => (config?.experiments ?? []).filter((e) => e.variants.some((v) => v.changes && id in v.changes)).map((e) => e.key);
+var resolveVariant = (key, config, distinctId, preview) => {
+  if (preview[key]) return preview[key];
+  const experiment = config?.experiments.find((e) => e.key === key);
+  return experiment ? assign(experiment, distinctId) : "control";
+};
+var textChanges = (config, distinctId, preview) => {
+  const out = { ...config?.texts ?? {} };
+  for (const experiment of config?.experiments ?? []) {
+    const id = resolveVariant(experiment.key, config, distinctId, preview);
+    if (id === (experiment.variants[0]?.id ?? "control")) continue;
+    Object.assign(out, experiment.variants.find((v) => v.id === id)?.changes ?? {});
+  }
+  return out;
+};
+var newDistinctId = () => typeof crypto !== "undefined" && "randomUUID" in crypto ? crypto.randomUUID() : `ck_${Math.random().toString(36).slice(2)}${Date.now().toString(36)}`;
+
+// src/batch.ts
+var MAX_BATCH = 100;
+var MAX_BYTES = 6e4;
+var byteLength = (s) => {
+  let n = 0;
+  for (let i = 0; i < s.length; i++) {
+    const c = s.charCodeAt(i);
+    if (c < 128) n += 1;
+    else if (c < 2048) n += 2;
+    else if (c >= 55296 && c <= 56319 && i + 1 < s.length && (s.charCodeAt(i + 1) & 64512) === 56320) {
+      n += 4;
+      i++;
+    } else n += 3;
+  }
+  return n;
+};
+var batchRequests = (key, events, sdk) => {
+  const head = `{"key":${JSON.stringify(key)},"sdk":${JSON.stringify(sdk)},"events":[`;
+  const empty = byteLength(head) + 2;
+  const out = [];
+  let chunk = [];
+  let items = [];
+  let size = empty;
+  const close = () => {
+    if (chunk.length) out.push({ body: `${head}${chunk.join(",")}]}`, events: items });
+    chunk = [];
+    items = [];
+    size = empty;
+  };
+  for (const event of events) {
+    const json = JSON.stringify(event);
+    const n = byteLength(json) + 1;
+    if (empty + n > MAX_BYTES) continue;
+    if (chunk.length === MAX_BATCH || size + n > MAX_BYTES) close();
+    chunk.push(json);
+    items.push(event);
+    size += n;
+  }
+  close();
+  return out;
+};
+
+// src/errors.ts
+var MAX_STACK = 8 * 1024;
+var clip = (s, n) => s.length > n ? `${s.slice(0, n - 1)}\u2026` : s;
+var describeError = (error) => {
+  if (error instanceof Error) return { type: error.name || "Error", message: clip(error.message || String(error), 1e3), stack: error.stack ? clip(error.stack, MAX_STACK) : void 0 };
+  if (typeof error === "string") return { type: "Error", message: clip(error, 1e3) };
+  try {
+    return { type: "Error", message: clip(JSON.stringify(error) ?? String(error), 1e3) };
+  } catch {
+    return { type: "Error", message: String(error) };
+  }
+};
+
+// src/flows.ts
+var CANCEL_EVENT = "$cancel_flow";
+var ONBOARDING_EVENT = "$onboarding";
+var INAPP_EVENT = "$inapp";
+var PLAIN_CANCEL = {
+  version: 0,
+  question: "",
+  reasons: [],
+  offers: {},
+  confirm: { title: "Cancel your subscription?", body: "You keep access until the end of the billing period.", button: "Cancel subscription" },
+  offersFor: "business"
+};
+var FAILED = "Something went wrong. Please try again.";
+var PROGRESS_KEY = "mrrocket:onboarding";
+var eventSlug = (s) => s.trim().toLowerCase().replace(/[^a-z0-9]+/g, "_").replace(/^_+|_+$/g, "");
+var SIGNUP = /* @__PURE__ */ new Set(["signed_up", "signup", "sign_up", "registered", "account_created", "user_signed_up"]);
+var matchesTrigger = (trigger, event) => {
+  const t = eventSlug(trigger);
+  const e = eventSlug(event);
+  if (!t || !e) return false;
+  return t === e || SIGNUP.has(t) && SIGNUP.has(e);
+};
+var startsOnLoad = (trigger) => /^(first (launch|visit|open|session|login|sign ?in|app open)|app (opened|launched)|on load|every visit|always)?$/i.test(trigger.trim());
+var runId = () => `cf_${Math.random().toString(36).slice(2, 10)}${Date.now().toString(36)}`;
+var discounted = (amount, percent) => Math.round(amount * (1 - percent / 100) * 100) / 100;
+var money = (amount, currency) => {
+  try {
+    return new Intl.NumberFormat(void 0, { style: "currency", currency }).format(amount);
+  } catch {
+    return `${amount.toFixed(2)} ${currency}`;
+  }
+};
+var offerButton = (o) => o.kind === "contact" ? "Send to the team" : o.kind === "pause" ? "Pause instead" : o.kind === "downgrade" ? "Switch plan" : "Accept offer";
+var safeUrl = (url) => {
+  const u = (url ?? "").trim();
+  return /^https?:\/\//i.test(u) || /^\/(?!\/)/.test(u) ? u : void 0;
+};
+var createFlows = (env) => {
+  let config = null;
+  let cancel = null;
+  let active = null;
+  let messages = [];
+  let known = false;
+  let loading = null;
+  let loadedFor;
+  let progressFor = null;
+  const progress = /* @__PURE__ */ new Map();
+  const handled = /* @__PURE__ */ new Set();
+  const shown = /* @__PURE__ */ new Set();
+  const listeners = /* @__PURE__ */ new Set();
+  const auto = env.auto !== false;
+  const flows = () => config?.onboarding ?? [];
+  const flowById = (id) => id ? flows().find((f) => f.id === id) : void 0;
+  const prog = (id) => {
+    let p = progress.get(id);
+    if (!p) progress.set(id, p = { done: /* @__PURE__ */ new Set(), dismissed: false });
+    return p;
+  };
+  const finished = (f) => {
+    const p = progress.get(f.id);
+    return !!p && (p.dismissed || f.steps.every((s) => p.done.has(s.id)));
+  };
+  const keyOf = (pid) => `${PROGRESS_KEY}:${pid ?? "visitor"}`;
+  const save = () => {
+    const store = env.storage?.();
+    if (!store) return;
+    const out = {};
+    for (const [id, p] of progress) out[id] = { done: [...p.done], ...p.dismissed ? { dismissed: true } : {} };
+    try {
+      store.set(keyOf(env.personId()), JSON.stringify(out));
+    } catch {
+    }
+  };
+  const merge = (state) => {
+    for (const [id, s] of Object.entries(state ?? {})) {
+      const p = prog(id);
+      for (const d of s.done ?? []) p.done.add(d);
+      if (s.dismissed) p.dismissed = true;
+    }
+  };
+  const onboardingView = () => {
+    const flow = flowById(active);
+    if (!flow) return null;
+    const p = prog(flow.id);
+    const at = flow.steps.findIndex((s) => !p.done.has(s.id));
+    if (at < 0 || p.dismissed) return null;
+    const step = flow.steps[at];
+    if (step.kind === "checklist") {
+      let from = at;
+      while (from > 0 && flow.steps[from - 1].kind === "checklist") from--;
+      let to = at;
+      while (to + 1 < flow.steps.length && flow.steps[to + 1].kind === "checklist") to++;
+      return { type: "checklist", flow, items: flow.steps.slice(from, to + 1).map((s) => ({ step: s, done: p.done.has(s.id) })) };
+    }
+    return { type: "step", flow, step, index: at, total: flow.steps.length, last: at === flow.steps.length - 1 };
+  };
+  const view = () => {
+    if (cancel) {
+      const offer = cancel.reason ? cancel.flow.offers[cancel.reason] : void 0;
+      return {
+        type: "cancel",
+        screen: cancel.screen,
+        flow: cancel.flow,
+        reason: cancel.reason,
+        offer: cancel.screen === "offer" ? offer : void 0,
+        price: cancel.options.price,
+        busy: cancel.busy,
+        error: cancel.error,
+        step: cancel.plain ? 1 : cancel.screen === "survey" ? 1 : cancel.screen === "offer" ? 2 : 3,
+        steps: cancel.plain ? 1 : 3
+      };
+    }
+    const ob = onboardingView();
+    if (ob) return ob;
+    if (active) active = null;
+    const m = messages.find((x) => !handled.has(x.id));
+    return m ? { type: "message", message: m } : null;
+  };
+  const emit = () => {
+    const v = view();
+    if (v?.type === "step" && !shown.has(`s:${v.step.id}`)) {
+      shown.add(`s:${v.step.id}`);
+      env.track(ONBOARDING_EVENT, { flow: v.flow.id, step: v.step.id, kind: v.step.kind, action: "shown" });
+    } else if (v?.type === "checklist") {
+      for (const i of v.items)
+        if (!i.done && !shown.has(`s:${i.step.id}`)) {
+          shown.add(`s:${i.step.id}`);
+          env.track(ONBOARDING_EVENT, { flow: v.flow.id, step: i.step.id, kind: "checklist", action: "shown" });
+        }
+    } else if (v?.type === "message" && !shown.has(`m:${v.message.id}`)) {
+      shown.add(`m:${v.message.id}`);
+      env.track(INAPP_EVENT, { message: v.message.id, journey: v.message.journey, action: "shown" });
+    }
+    for (const l of [...listeners]) {
+      try {
+        l();
+      } catch {
+      }
+    }
+  };
+  const start = (flow) => {
+    if (active === flow.id) return true;
+    if (active && flowById(active) && !finished(flowById(active))) return false;
+    active = flow.id;
+    env.track(ONBOARDING_EVENT, { flow: flow.id, action: "started" });
+    emit();
+    return true;
+  };
+  const autoStart = () => {
+    if (!auto || active || !known) return;
+    if (!env.personId() && !env.storage?.()) return;
+    const next = flows().find((f) => startsOnLoad(f.trigger) && f.steps.length && !finished(f));
+    if (next) start(next);
+  };
+  const refresh = () => {
+    const pid = env.personId();
+    if (progressFor !== null && progressFor !== pid) {
+      progress.clear();
+      handled.clear();
+      active = null;
+      loadedFor = void 0;
+    }
+    progressFor = pid;
+    const run = (async () => {
+      const store = env.storage?.();
+      if (store) {
+        try {
+          const raw = await store.get(keyOf(pid));
+          if (raw) merge(JSON.parse(raw));
+        } catch {
+        }
+      }
+      const wants = flows().length > 0 || !!config?.messages;
+      if (pid && wants && loadedFor !== pid) {
+        loadedFor = pid;
+        const state = await env.fetchInApp(pid).catch(() => null);
+        if (state && env.personId() === pid) {
+          merge(state.onboarding);
+          messages = (state.messages ?? []).filter((m) => m && m.id && m.title);
+        }
+      }
+      if (!pid) messages = [];
+      known = true;
+      autoStart();
+      emit();
+    })();
+    loading = run.finally(() => {
+      if (loading === run) loading = null;
+    });
+    return loading;
+  };
+  const result = (c, outcome, comment) => {
+    const offer = c.reason ? c.flow.offers[c.reason] : void 0;
+    return {
+      outcome,
+      run: c.run,
+      ...c.reason ? { reason: c.reason, reasonLabel: c.flow.reasons.find((r) => r.id === c.reason)?.label } : {},
+      ...outcome === "saved" && offer ? { offer } : {},
+      ...comment?.trim() ? { comment: comment.trim().slice(0, 500) } : {}
+    };
+  };
+  const finish = (c, r) => {
+    env.track(CANCEL_EVENT, {
+      action: "finished",
+      run: c.run,
+      version: c.flow.version,
+      outcome: r.outcome,
+      customer: c.options.customer ?? "consumer",
+      ...r.reason ? { reason: r.reason } : {},
+      ...r.offer ? { offer: r.offer.kind } : {},
+      ...r.comment ? { comment: r.comment } : {}
+    });
+    if (cancel === c) cancel = null;
+    c.resolve(r);
+    emit();
+  };
+  const settle = (c, outcome, comment) => {
+    if (c.busy) return;
+    const r = result(c, outcome, comment);
+    const fn = outcome === "saved" ? c.options.onSave : c.options.onCancel;
+    c.busy = true;
+    c.error = void 0;
+    emit();
+    Promise.resolve().then(() => fn?.(r)).then(
+      () => finish(c, r),
+      () => {
+        c.busy = false;
+        c.error = FAILED;
+        emit();
+      }
+    );
+  };
+  const openCancelFlow = (options = {}) => {
+    if (cancel) return cancel.promise;
+    const flow = config?.cancelFlow ?? PLAIN_CANCEL;
+    const plain = options.customer !== "business" || flow.reasons.length < 2;
+    let resolve = () => {
+    };
+    const promise = new Promise((r) => resolve = r);
+    const c = { flow, options, plain, screen: plain ? "confirm" : "survey", run: runId(), busy: false, resolve, promise };
+    cancel = c;
+    env.track(CANCEL_EVENT, { action: "shown", run: c.run, version: flow.version, customer: options.customer ?? "consumer", plain });
+    emit();
+    return promise;
+  };
+  const controller = {
+    setConfig: (c) => {
+      config = c;
+      if (active && !flowById(active)) active = null;
+      emit();
+    },
+    refresh,
+    onEvent: (name) => {
+      if (!name || name.startsWith("$")) return;
+      const flow = flowById(active);
+      let ticked = false;
+      if (flow) {
+        const p = prog(flow.id);
+        for (const s of flow.steps)
+          if (s.kind === "checklist" && s.event && !p.done.has(s.id) && matchesTrigger(s.event, name)) {
+            p.done.add(s.id);
+            ticked = true;
+            env.track(ONBOARDING_EVENT, { flow: flow.id, step: s.id, kind: s.kind, action: "completed" });
+          }
+      }
+      if (ticked) {
+        save();
+        emit();
+      }
+      if (!auto || !env.personId() && !env.storage?.()) return;
+      const next = flows().find((f) => f.steps.length && matchesTrigger(f.trigger, name) && !finished(f));
+      if (next) start(next);
+    },
+    openCancelFlow,
+    startOnboarding: (id) => {
+      const f = id ? flowById(id) : flows().find((x) => x.steps.length && !finished(x));
+      if (!f || !f.steps.length) return false;
+      const p = prog(f.id);
+      p.dismissed = false;
+      return start(f);
+    },
+    view,
+    subscribe: (l) => {
+      listeners.add(l);
+      return () => listeners.delete(l);
+    },
+    cancel: {
+      pick: (reason) => {
+        if (!cancel || cancel.busy || !cancel.flow.reasons.some((r) => r.id === reason)) return;
+        cancel.reason = reason;
+        cancel.error = void 0;
+        emit();
+      },
+      next: () => {
+        const c = cancel;
+        if (!c || c.screen !== "survey" || !c.reason) return;
+        env.track(CANCEL_EVENT, { action: "answered", run: c.run, version: c.flow.version, reason: c.reason });
+        c.screen = c.flow.offers[c.reason] ? "offer" : "confirm";
+        emit();
+      },
+      accept: (comment) => {
+        const c = cancel;
+        if (!c || c.screen !== "offer" || !c.reason) return;
+        const offer = c.flow.offers[c.reason];
+        if (!c.busy)
+          env.track(CANCEL_EVENT, {
+            action: "offer",
+            run: c.run,
+            version: c.flow.version,
+            reason: c.reason,
+            offer: offer?.kind,
+            outcome: "accepted"
+          });
+        settle(c, "saved", comment);
+      },
+      decline: () => {
+        const c = cancel;
+        if (!c || c.screen !== "offer" || c.busy) return;
+        env.track(CANCEL_EVENT, {
+          action: "offer",
+          run: c.run,
+          version: c.flow.version,
+          reason: c.reason,
+          offer: c.reason ? c.flow.offers[c.reason]?.kind : void 0,
+          outcome: "declined"
+        });
+        c.screen = "confirm";
+        c.error = void 0;
+        emit();
+      },
+      confirm: (comment) => {
+        const c = cancel;
+        if (!c || c.screen !== "confirm") return;
+        settle(c, "cancelled", comment);
+      },
+      close: () => {
+        const c = cancel;
+        if (!c || c.busy) return;
+        const r = result(c, "kept");
+        c.options.onClose?.(r);
+        finish(c, r);
+      }
+    },
+    onboarding: {
+      next: () => {
+        const v = onboardingView();
+        if (v?.type !== "step") return;
+        prog(v.flow.id).done.add(v.step.id);
+        env.track(ONBOARDING_EVENT, { flow: v.flow.id, step: v.step.id, kind: v.step.kind, action: "completed" });
+        save();
+        emit();
+      },
+      check: (stepId) => {
+        const v = onboardingView();
+        if (v?.type !== "checklist") return;
+        const item = v.items.find((i) => i.step.id === stepId);
+        if (!item || item.done) return;
+        prog(v.flow.id).done.add(stepId);
+        env.track(ONBOARDING_EVENT, { flow: v.flow.id, step: stepId, kind: "checklist", action: "completed" });
+        save();
+        emit();
+      },
+      dismiss: () => {
+        const v = onboardingView();
+        if (!v || v.type !== "step" && v.type !== "checklist") return;
+        prog(v.flow.id).dismissed = true;
+        env.track(ONBOARDING_EVENT, { flow: v.flow.id, ...v.type === "step" ? { step: v.step.id } : {}, action: "dismissed" });
+        active = null;
+        save();
+        emit();
+      }
+    },
+    message: {
+      click: () => {
+        const v = view();
+        if (v?.type !== "message") return;
+        handled.add(v.message.id);
+        env.track(INAPP_EVENT, { message: v.message.id, journey: v.message.journey, action: "clicked" });
+        const url = safeUrl(v.message.url);
+        emit();
+        if (url) env.openUrl?.(url);
+      },
+      dismiss: () => {
+        const v = view();
+        if (v?.type !== "message") return;
+        handled.add(v.message.id);
+        env.track(INAPP_EVENT, { message: v.message.id, journey: v.message.journey, action: "dismissed" });
+        emit();
+      }
+    }
+  };
+  return controller;
+};
+
+// src/referral.ts
+var REF_PARAM = "mrr_ref";
+var CLICK_PARAM = "mrr_click";
+var CODE = /^[A-Za-z0-9_-]{1,64}$/;
+var referralFrom = (get, param = "ref") => {
+  const marked = get(REF_PARAM);
+  if (marked && CODE.test(marked)) {
+    const click = get(CLICK_PARAM);
+    return { code: marked, clickId: click && CODE.test(click) ? click : null, direct: false };
+  }
+  const direct = get(param);
+  return direct && CODE.test(direct) ? { code: direct, clickId: null, direct: true } : null;
+};
+var carriesReferral = (event) => event === "$identify" || !event.startsWith("$");
+
+// src/native/client.ts
+var DEFAULT_HOST = "https://app.mrrocket.dev";
+var KEYS = {
+  id: "mrrocket:id",
+  queue: "mrrocket:queue",
+  config: "mrrocket:config",
+  installed: "mrrocket:installed",
+  referral: "mrrocket:referral"
+};
+var MAX_ERRORS = 20;
+var MAX_CRUMBS = 20;
+var MAX_BACKOFF_MS = 5 * 60 * 1e3;
+var REQUEST_TIMEOUT_MS = 15e3;
+var EAGER_COUNT = 20;
+var clip2 = (s, n) => s.length > n ? `${s.slice(0, n - 1)}\u2026` : s;
+var createClient = (options, deps) => {
+  const apiKey = (options.apiKey ?? "").trim();
+  const host = (options.host ?? DEFAULT_HOST).trim().replace(/\/+$/, "");
+  const now = deps.now ?? (() => Date.now());
+  const setIntervalFn = deps.setInterval ?? ((fn, ms) => setInterval(fn, ms));
+  const clearIntervalFn = deps.clearInterval ?? ((id) => clearInterval(id));
+  const setTimeoutFn = deps.setTimeout ?? ((fn, ms) => setTimeout(fn, ms));
+  const clearTimeoutFn = deps.clearTimeout ?? ((id) => clearTimeout(id));
+  const flushEvery = Math.max(1e3, options.flushIntervalMs ?? 1e4);
+  const maxQueue = Math.max(10, options.maxQueue ?? 1e3);
+  const errorsOn = options.errors !== false;
+  const storage = deps.storage;
+  const warned = /* @__PURE__ */ new Set();
+  const warn = (message) => {
+    if (warned.has(message)) return;
+    warned.add(message);
+    (deps.log ?? ((m) => console.warn(m)))(`[MRRocket] ${message}`);
+  };
+  const debug = (message) => {
+    if (options.debug) (deps.log ?? ((m) => console.log(m)))(`[MRRocket] ${message}`);
+  };
+  if (!apiKey) warn("No public key. Pass apiKey to MRRocketProvider; nothing is sent until then.");
+  let context = { platform: "unknown" };
+  try {
+    context = deps.context();
+  } catch {
+  }
+  const appId = (deps.appId || "app").replace(/[^A-Za-z0-9._-]/g, "") || "app";
+  const release = options.release ?? (context.appVersion ? `${context.appVersion}${context.build ? ` (${context.build})` : ""}` : void 0);
+  const sdk = { v: SDK_VERSION, errors: errorsOn, platform: context.platform };
+  let consent = options.consent ?? "anonymous";
+  let installId = null;
+  let memoryId = newDistinctId();
+  let identified;
+  let person;
+  let config = null;
+  let queue = [];
+  let session = null;
+  let utm = null;
+  let referral = null;
+  let currentScreen;
+  let loaded = false;
+  let closed = false;
+  let isReady = false;
+  let version = 0;
+  let failures = 0;
+  let backoffUntil = 0;
+  let inFlight = null;
+  let persistTimer = null;
+  let flushTimer = null;
+  let errorTimer = null;
+  let appState = deps.appState?.currentState ?? "active";
+  let backgroundSince = null;
+  const early = [];
+  const exposed = /* @__PURE__ */ new Set();
+  let textsFor = null;
+  const texts = () => {
+    const id = distinctId();
+    if (!textsFor || textsFor.config !== config || textsFor.id !== id) textsFor = { config, id, texts: textChanges(config, id, {}) };
+    return textsFor.texts;
+  };
+  const listeners = /* @__PURE__ */ new Set();
+  const crumbs = [];
+  const errorQueue = [];
+  const errorsSeen = /* @__PURE__ */ new Set();
+  let errorsSent = 0;
+  const flows = createFlows({
+    track: (event, props) => record(event, props),
+    personId: () => consent !== "off" ? identified : void 0,
+    auto: options.onboarding !== false,
+    storage: () => storage && consent === "persistent" ? {
+      get: (k) => get(k),
+      set: (k, v) => void set(k, v)
+    } : null,
+    openUrl: deps.openUrl,
+    fetchInApp: async (id) => {
+      if (!apiKey) return null;
+      const r = await deps.fetch(`${host}/api/sdk/inapp?key=${encodeURIComponent(apiKey)}&distinctId=${encodeURIComponent(id)}`, { method: "GET" });
+      return r.ok ? await r.json() : null;
+    }
+  });
+  const refreshFlows = () => {
+    if (!isReady || closed) return;
+    flows.setConfig(config);
+    void flows.refresh();
+  };
+  const changed = () => {
+    version++;
+    for (const l of [...listeners]) {
+      try {
+        l();
+      } catch {
+      }
+    }
+  };
+  const crumb = (type, message) => {
+    crumbs.push({ ts: now(), type, message: clip2(message, 120) });
+    if (crumbs.length > MAX_CRUMBS) crumbs.shift();
+  };
+  const get = async (key) => {
+    if (!storage) return null;
+    try {
+      return await storage.getItem(key);
+    } catch {
+      return null;
+    }
+  };
+  const set = async (key, value) => {
+    if (!storage) return;
+    try {
+      await storage.setItem(key, value);
+    } catch {
+      warn("Could not write to the device storage; events wait in memory only.");
+    }
+  };
+  const remove = async (key) => {
+    if (!storage) return;
+    try {
+      await storage.removeItem(key);
+    } catch {
+    }
+  };
+  const persistQueue = async () => {
+    if (persistTimer !== null) {
+      clearTimeoutFn(persistTimer);
+      persistTimer = null;
+    }
+    if (!storage || consent === "off") return;
+    if (queue.length) await set(KEYS.queue, JSON.stringify(queue));
+    else await remove(KEYS.queue);
+  };
+  const schedulePersist = () => {
+    if (!storage || persistTimer !== null) return;
+    persistTimer = setTimeoutFn(() => {
+      persistTimer = null;
+      void persistQueue();
+    }, 1e3);
+  };
+  const distinctId = () => identified ?? (consent === "persistent" && installId ? installId : memoryId);
+  const sendId = () => consent === "persistent" ? distinctId() : identified;
+  const touchSession = () => {
+    const t = now();
+    if (!session || t - session.last >= SESSION_TIMEOUT_MS) session = { id: newDistinctId(), last: t };
+    else session.last = t;
+    return session.id;
+  };
+  const urlOf = (path = currentScreen) => `app://${appId}${path ?? "/"}`;
+  const record = (event, props, ts = now()) => {
+    if (closed) return;
+    if (!loaded) {
+      early.push(() => record(event, props, ts));
+      return;
+    }
+    if (consent === "off" || !apiKey) return;
+    const sessionId = touchSession();
+    const ref = referral && carriesReferral(event) ? referral : null;
+    const size = deps.screen?.();
+    queue.push({
+      event,
+      props: ref ? { ...props, $referral: ref } : props,
+      distinctId: sendId(),
+      sessionId,
+      ts,
+      url: urlOf(),
+      ...utm && utm.session === sessionId ? utm.values : {},
+      ...size ? { screen: { w: Math.round(size.w), h: Math.round(size.h) } } : {},
+      app: context
+    });
+    if (queue.length > maxQueue) queue.splice(0, queue.length - maxQueue);
+    schedulePersist();
+    if (queue.length >= EAGER_COUNT) void flush();
+  };
+  const post = async (path, body) => {
+    const ctl = typeof AbortController !== "undefined" ? new AbortController() : null;
+    const timer = ctl ? setTimeoutFn(() => ctl.abort(), REQUEST_TIMEOUT_MS) : null;
+    try {
+      const r = await deps.fetch(`${host}${path}`, { method: "POST", headers: { "content-type": "application/json" }, body, signal: ctl?.signal });
+      return r.status;
+    } catch {
+      return 0;
+    } finally {
+      if (timer !== null) clearTimeoutFn(timer);
+    }
+  };
+  const sendQueue = async () => {
+    if (!queue.length || consent === "off" || !apiKey) return;
+    if (now() < backoffUntil) return;
+    const snapshot = queue.slice();
+    const requests = batchRequests(apiKey, snapshot, sdk);
+    const included = new Set(requests.flatMap((r) => r.events));
+    const done = /* @__PURE__ */ new Set();
+    for (const r of requests) {
+      const status = await post("/api/sdk/events", r.body);
+      if (status >= 200 && status < 300) {
+        r.events.forEach((e) => done.add(e));
+        failures = 0;
+        backoffUntil = 0;
+      } else if (status >= 400 && status < 500 && status !== 408 && status !== 429) {
+        r.events.forEach((e) => done.add(e));
+        warn(`Events were rejected with ${status}. Check the public key (MRRocket \u203A Settings \u203A Products) and the host.`);
+      } else {
+        failures++;
+        backoffUntil = now() + Math.min(MAX_BACKOFF_MS, 1e3 * 2 ** failures);
+        debug(`Sending failed (${status || "offline"}); next try in ${Math.round((backoffUntil - now()) / 1e3)} s.`);
+        break;
+      }
+    }
+    queue = queue.filter((e) => !done.has(e) && (included.has(e) || !snapshot.includes(e)));
+    await persistQueue();
+  };
+  let nextFlush = null;
+  const flush = () => {
+    if (inFlight)
+      return nextFlush ?? (nextFlush = inFlight.then(() => {
+        nextFlush = null;
+        return flush();
+      }));
+    inFlight = sendQueue().finally(() => {
+      inFlight = null;
+    });
+    return inFlight;
+  };
+  const startTimer = () => {
+    if (flushTimer !== null || closed) return;
+    flushTimer = setIntervalFn(() => void flush(), flushEvery);
+  };
+  const stopTimer = () => {
+    if (flushTimer === null) return;
+    clearIntervalFn(flushTimer);
+    flushTimer = null;
+  };
+  const sendErrors = async () => {
+    if (errorTimer !== null) {
+      clearTimeoutFn(errorTimer);
+      errorTimer = null;
+    }
+    while (errorQueue.length) {
+      const batch = errorQueue.splice(0, 4);
+      const status = await post("/api/sdk/errors", JSON.stringify({ key: apiKey, sdk, errors: batch }));
+      if (status >= 400 && status < 500 && status !== 429) warn(`Error reports were rejected with ${status}. Check the public key and the host.`);
+    }
+  };
+  const capture = (error, mechanism, fatal = false) => {
+    if (!errorsOn || closed || consent === "off" || !apiKey || errorsSent >= MAX_ERRORS) return;
+    const d = describeError(error);
+    if (/\/api\/sdk\/errors/.test(d.message)) return;
+    const mark = `${d.type}:${d.message}`;
+    if (errorsSeen.has(mark)) return;
+    errorsSeen.add(mark);
+    errorsSent++;
+    const who = sendId();
+    errorQueue.push({
+      ...d,
+      mechanism,
+      handled: mechanism === "manual",
+      url: urlOf(),
+      ts: now(),
+      crumbs: crumbs.slice(),
+      ...release ? { release } : {},
+      ...who ? { distinctId: who } : {},
+      ...session ? { sessionId: session.id } : {}
+    });
+    if (fatal) void sendErrors();
+    else if (errorTimer === null) errorTimer = setTimeoutFn(() => void sendErrors(), 2e3);
+  };
+  let previousHandler;
+  let handlerInstalled = false;
+  const installErrorHandler = () => {
+    if (!errorsOn || !deps.errorUtils || handlerInstalled) return;
+    handlerInstalled = true;
+    previousHandler = deps.errorUtils.getGlobalHandler();
+    deps.errorUtils.setGlobalHandler((error, isFatal) => {
+      try {
+        capture(error, "onerror", !!isFatal);
+      } catch {
+      }
+      previousHandler?.(error, isFatal);
+    });
+  };
+  let appStateSub;
+  const onAppState = (next) => {
+    if (closed) return;
+    const prev = appState;
+    appState = next;
+    if (next === "active" && prev !== "active") {
+      startTimer();
+      if (backgroundSince !== null) {
+        backgroundSince = null;
+        crumb("lifecycle", "app_open");
+        if (options.lifecycle !== false) record("$app_open", { cold: false });
+      }
+    } else if (next === "background" && prev !== "background") {
+      backgroundSince = now();
+      crumb("lifecycle", "app_background");
+      if (options.lifecycle !== false) record("$app_background");
+      stopTimer();
+      void persistQueue();
+      void flush();
+      if (errorQueue.length) void sendErrors();
+    }
+  };
+  const fetchConfig = async () => {
+    if (!apiKey) return;
+    try {
+      const r = await deps.fetch(`${host}/api/sdk/config?key=${encodeURIComponent(apiKey)}`, { method: "GET" });
+      if (!r.ok) {
+        warn(`Config request answered ${r.status}. Check the public key and the host.`);
+        return;
+      }
+      const c = await r.json();
+      if (c && Array.isArray(c.experiments)) {
+        config = c;
+        if (consent !== "off") await set(KEYS.config, JSON.stringify(c));
+        changed();
+      }
+    } catch {
+      debug("Config not reachable; using the cached one.");
+    }
+  };
+  let pushToken = null;
+  let pushFor;
+  let pushOff = null;
+  const opened = /* @__PURE__ */ new Set();
+  const onPushOpen = (data) => {
+    const m = data?.mrrocket;
+    if (!m?.id || opened.has(m.id)) return;
+    opened.add(m.id);
+    record("$push", { action: "opened", message: m.id });
+    if (m.url && /^[a-z][a-z0-9+.-]*:/i.test(m.url)) deps.openUrl?.(m.url);
+  };
+  const listenForOpens = () => {
+    if (pushOff || !deps.push || closed) return;
+    try {
+      pushOff = deps.push.onOpen(onPushOpen);
+      void deps.push.lastOpen?.().then(onPushOpen).catch(() => void 0);
+    } catch {
+      pushOff = null;
+    }
+  };
+  const loadedNow = () => loaded ? Promise.resolve() : new Promise((resolve) => {
+    early.push(resolve);
+  });
+  const registerForPush = async (o = {}) => {
+    if (!deps.push) return { status: "unavailable", reason: "Install expo-notifications to receive push notifications." };
+    await loadedNow();
+    if (!apiKey || consent === "off") return { status: "error", reason: !apiKey ? "No public key." : "The consent is off." };
+    if (!identified) return { status: "not-signed-in" };
+    const who = identified;
+    try {
+      const permission = await deps.push.permission(o.ask !== false);
+      if (permission !== "granted") return { status: permission === "denied" ? "denied" : "not-asked" };
+      const token = await deps.push.token(o.projectId);
+      if (!token) return { status: "unavailable", reason: "This device has no push token (a simulator, or no EAS project id)." };
+      const status = await post("/api/sdk/push", JSON.stringify({ key: apiKey, distinctId: who, platform: "expo", token, app: context }));
+      if (status < 200 || status >= 300) {
+        warn(`Push registration was rejected with ${status || "no answer"}. Check the public key and the host.`);
+        return { status: "error", reason: `MRRocket answered ${status || "nothing"}.` };
+      }
+      pushToken = token;
+      pushFor = who;
+      listenForOpens();
+      debug("Registered for push.");
+      return { status: "registered", token };
+    } catch (e) {
+      return { status: "error", reason: e instanceof Error ? e.message : String(e) };
+    }
+  };
+  const unregisterForPush = async () => {
+    const token = pushToken;
+    if (!token || !apiKey) return false;
+    pushToken = null;
+    const status = await post("/api/sdk/push", JSON.stringify({ key: apiKey, distinctId: pushFor, platform: "expo", token, remove: true }));
+    return status >= 200 && status < 300;
+  };
+  let resolveReady = () => {
+  };
+  const ready = new Promise((r) => {
+    resolveReady = r;
+  });
+  const markReady = () => {
+    if (isReady) return;
+    isReady = true;
+    resolveReady();
+    changed();
+  };
+  const start = async () => {
+    let firstOpen = false;
+    if (consent !== "off") {
+      const [id, stored, cached, installed, ref] = await Promise.all([
+        get(KEYS.id),
+        get(KEYS.queue),
+        get(KEYS.config),
+        get(KEYS.installed),
+        get(KEYS.referral)
+      ]);
+      if (consent === "persistent") {
+        installId = id || newDistinctId();
+        if (!id) await set(KEYS.id, installId);
+      } else if (id) await remove(KEYS.id);
+      try {
+        const old = stored ? JSON.parse(stored) : [];
+        if (Array.isArray(old)) queue = [...old.filter((e) => e && typeof e.event === "string"), ...queue].slice(-maxQueue);
+      } catch {
+        await remove(KEYS.queue);
+      }
+      try {
+        const c = cached ? JSON.parse(cached) : null;
+        if (c && Array.isArray(c.experiments) && !config) config = c;
+      } catch {
+        await remove(KEYS.config);
+      }
+      try {
+        const r = ref && consent === "persistent" ? JSON.parse(ref) : null;
+        if (r && typeof r.code === "string") referral = r;
+      } catch {
+      }
+      firstOpen = !!storage && !installed;
+      if (firstOpen) await set(KEYS.installed, String(now()));
+    } else {
+      await Promise.all(Object.values(KEYS).map(remove));
+    }
+    if (closed) return;
+    loaded = true;
+    if (config) markReady();
+    let install = null;
+    if (firstOpen) {
+      install = {};
+      if (options.attribution !== false && deps.initialUrl) {
+        const url = await deps.initialUrl().catch(() => null);
+        if (url) {
+          const q = parseQuery(url);
+          const values = utmFrom((k) => q[k]);
+          if (Object.keys(values).length) utm = { session: touchSession(), values };
+          const found = referralFrom((k) => q[k]);
+          if (found) {
+            referral = { code: found.code, clickId: found.clickId };
+            install.$referral = referral;
+            if (consent === "persistent") await set(KEYS.referral, JSON.stringify(referral));
+          }
+          install.link = clip2(url.split("?")[0], 300);
+        }
+      }
+    }
+    crumb("lifecycle", "app_open");
+    if (options.lifecycle !== false) record("$app_open", { cold: true });
+    if (install) record("$install", install);
+    for (const run of early.splice(0)) run();
+    if (deps.appState) appStateSub = deps.appState.addEventListener("change", onAppState);
+    installErrorHandler();
+    listenForOpens();
+    if (appState === "active" || !deps.appState) startTimer();
+    if (queue.length) void flush();
+    await fetchConfig();
+    markReady();
+    refreshFlows();
+  };
+  void start().catch(() => {
+    loaded = true;
+    markReady();
+  });
+  const client = {
+    track: (event, props) => {
+      if (typeof event !== "string" || !event) return;
+      record(event, props);
+      flows.onEvent(event);
+    },
+    screen: (name, props) => {
+      if (typeof name !== "string" || !name.trim()) return;
+      const path = (name.startsWith("/") ? name : `/${name}`).slice(0, 300);
+      if (path === currentScreen && !props) return;
+      const previous = currentScreen;
+      currentScreen = path;
+      crumb("navigation", path);
+      record("$screen", { ...props, path, screen: name, ...previous ? { previous } : {} });
+    },
+    identify: (id, props) => {
+      if (typeof id !== "string" || !id) return;
+      if (!loaded) {
+        early.push(() => client.identify(id, props));
+        return;
+      }
+      const previous = sendId();
+      identified = id;
+      person = { ...props, id };
+      record("$identify", { ...props, id, ...previous && previous !== id ? { previousId: previous } : {} });
+      if (consent === "persistent") void set(KEYS.id, id);
+      changed();
+      refreshFlows();
+    },
+    reset: () => {
+      if (!loaded) {
+        early.push(() => client.reset());
+        return;
+      }
+      if (pushToken) void unregisterForPush();
+      identified = void 0;
+      person = void 0;
+      session = null;
+      utm = null;
+      exposed.clear();
+      memoryId = newDistinctId();
+      if (consent === "persistent") {
+        installId = newDistinctId();
+        void set(KEYS.id, installId);
+      }
+      changed();
+      refreshFlows();
+    },
+    setConsent: (next) => {
+      if (next !== "anonymous" && next !== "persistent" && next !== "off") {
+        warn(`setConsent: "${String(next)}" is not a consent mode. Use "anonymous", "persistent" or "off".`);
+        return;
+      }
+      if (!loaded) {
+        early.push(() => client.setConsent(next));
+        return;
+      }
+      if (next === consent) return;
+      const before = consent;
+      consent = next;
+      if (next === "off") {
+        queue = [];
+        session = null;
+        errorQueue.length = 0;
+        void Promise.all(Object.values(KEYS).map(remove));
+      } else if (next === "anonymous") {
+        installId = null;
+        void remove(KEYS.id);
+        void remove(KEYS.referral);
+      } else {
+        installId = identified ?? newDistinctId();
+        void set(KEYS.id, installId);
+        if (referral) void set(KEYS.referral, JSON.stringify(referral));
+      }
+      if (before === "off" && currentScreen && loaded) record("$screen", { path: currentScreen, screen: currentScreen });
+      changed();
+      refreshFlows();
+    },
+    captureError: (error) => capture(error, "manual"),
+    getFlag: (key) => flagFor(key, config, distinctId(), { ...person }) !== false,
+    getFlagVariant: (key) => {
+      const v = flagFor(key, config, distinctId(), { ...person });
+      return typeof v === "string" ? v : null;
+    },
+    getVariant: (key) => {
+      const variant = resolveVariant(key, config, distinctId(), {});
+      client.expose(key, variant);
+      return variant;
+    },
+    peekVariant: (key) => resolveVariant(key, config, distinctId(), {}),
+    expose: (key, variant) => {
+      if (!config || consent === "off") return;
+      const mark = `${currentScreen ?? "/"}|${key}`;
+      if (exposed.has(mark)) return;
+      exposed.add(mark);
+      record("$exposure", { experiment: key, variant });
+    },
+    getText: (id, fallback) => {
+      client.exposeText(id);
+      return client.peekText(id) ?? fallback;
+    },
+    peekText: (id) => texts()[id],
+    exposeText: (id) => {
+      for (const key of experimentsOfText(config, id)) client.expose(key, resolveVariant(key, config, distinctId(), {}));
+    },
+    openCancelFlow: (o) => flows.openCancelFlow(o),
+    startOnboarding: (id) => flows.startOnboarding(id),
+    registerForPush,
+    unregisterForPush,
+    flows,
+    flush,
+    ready,
+    isReady: () => isReady,
+    getDistinctId: distinctId,
+    getConsent: () => consent,
+    getConfig: () => config,
+    subscribe: (listener) => {
+      listeners.add(listener);
+      return () => listeners.delete(listener);
+    },
+    getVersion: () => version,
+    close: async () => {
+      if (closed) return;
+      stopTimer();
+      appStateSub?.remove();
+      pushOff?.();
+      pushOff = null;
+      if (handlerInstalled && deps.errorUtils && previousHandler) deps.errorUtils.setGlobalHandler(previousHandler);
+      await flush();
+      await sendErrors();
+      await persistQueue();
+      closed = true;
+    },
+    queued: () => queue
+  };
+  return client;
+};
+var activeRouteName = (state) => {
+  let s = state;
+  let name;
+  for (let depth = 0; s && Array.isArray(s.routes) && s.routes.length && depth < 20; depth++) {
+    const route = s.routes[typeof s.index === "number" ? s.index : s.routes.length - 1];
+    if (!route) break;
+    name = route.name ?? name;
+    s = route.state;
+  }
+  return name;
+};
+
+// src/native/flows-view.ts
+var import_react = require("react");
+var RN = require("react-native");
+var LIGHT = { bg: "#ffffff", fg: "#1c1d20", muted: "#5d6068", soft: "#f4f5f7", line: "#e4e5e8" };
+var DARK = { bg: "#17181b", fg: "#f1f2f4", muted: "#a9acb3", soft: "#232428", line: "#2e2f35" };
+var months = (n) => `${n} ${n === 1 ? "month" : "months"}`;
+var MRRocketFlows = ({ flows, appearance = {} }) => {
+  const scheme = RN.useColorScheme?.();
+  const dark = appearance.theme === "dark" || (appearance.theme ?? "auto") === "auto" && scheme === "dark";
+  const p = { ...dark ? DARK : LIGHT, accent: appearance.accent ?? "#3f76ff", danger: "#d92d20" };
+  const [, setTick] = (0, import_react.useState)(0);
+  (0, import_react.useEffect)(() => flows.subscribe(() => setTick((t) => t + 1)), [flows]);
+  const v = flows.view();
+  const [comment, setComment] = (0, import_react.useState)("");
+  const screen = v?.type === "cancel" ? v.screen : null;
+  (0, import_react.useEffect)(() => {
+    if (!screen) setComment("");
+  }, [screen]);
+  if (!v) return null;
+  const text2 = (children, style = {}) => (0, import_react.createElement)(RN.Text, { style: { color: p.fg, fontSize: 15, ...style } }, children);
+  const muted = (children, style = {}) => text2(children, { color: p.muted, fontSize: 13, ...style });
+  const title = (children) => (0, import_react.createElement)(RN.Text, { accessibilityRole: "header", style: { color: p.fg, fontSize: 18, fontWeight: "700" } }, children);
+  const btn = (label, kind, onPress, disabled = false) => (0, import_react.createElement)(
+    RN.Pressable,
+    {
+      key: label,
+      onPress,
+      disabled,
+      accessibilityRole: "button",
+      accessibilityState: { disabled },
+      style: {
+        height: kind === "quiet" ? 36 : 44,
+        borderRadius: 10,
+        alignItems: "center",
+        justifyContent: "center",
+        opacity: disabled ? 0.55 : 1,
+        backgroundColor: kind === "primary" ? p.accent : kind === "danger" ? p.danger : kind === "secondary" ? p.bg : "transparent",
+        borderWidth: kind === "secondary" ? 1 : 0,
+        borderColor: p.line
+      }
+    },
+    text2(label, {
+      color: kind === "primary" || kind === "danger" ? "#ffffff" : kind === "quiet" ? p.muted : p.fg,
+      fontWeight: kind === "quiet" ? "500" : "600"
+    })
+  );
+  const close = (label, onPress) => (0, import_react.createElement)(
+    RN.Pressable,
+    { onPress, accessibilityRole: "button", accessibilityLabel: label, hitSlop: 12, style: { marginLeft: "auto", padding: 4 } },
+    text2("\xD7", { fontSize: 22, color: p.muted })
+  );
+  const card = (children, style = {}) => (0, import_react.createElement)(
+    RN.View,
+    {
+      style: {
+        backgroundColor: p.bg,
+        borderRadius: 16,
+        padding: 20,
+        gap: 12,
+        shadowColor: "#000",
+        shadowOpacity: 0.18,
+        shadowRadius: 20,
+        elevation: 8,
+        ...style
+      }
+    },
+    ...children
+  );
+  const sheet = (children, onClose) => (0, import_react.createElement)(
+    RN.Modal,
+    { visible: true, transparent: true, animationType: "fade", onRequestClose: onClose },
+    (0, import_react.createElement)(
+      RN.View,
+      { style: { flex: 1, backgroundColor: "rgba(0,0,0,0.4)", justifyContent: "flex-end" } },
+      card(children, { borderBottomLeftRadius: 0, borderBottomRightRadius: 0, paddingBottom: 34 })
+    )
+  );
+  const input = (placeholder) => (0, import_react.createElement)(RN.TextInput, {
+    value: comment,
+    onChangeText: setComment,
+    placeholder,
+    placeholderTextColor: p.muted,
+    multiline: true,
+    maxLength: 500,
+    accessibilityLabel: placeholder,
+    style: { minHeight: 72, borderWidth: 1, borderColor: p.line, borderRadius: 10, padding: 10, color: p.fg, textAlignVertical: "top" }
+  });
+  if (v.type === "cancel") {
+    const top = (0, import_react.createElement)(
+      RN.View,
+      { style: { flexDirection: "row", alignItems: "center", gap: 4 } },
+      ...v.steps > 1 ? Array.from(
+        { length: v.steps },
+        (_, i) => (0, import_react.createElement)(RN.View, { key: i, style: { width: 16, height: 4, borderRadius: 4, backgroundColor: i < v.step ? p.accent : p.line } })
+      ) : [],
+      close("Close", flows.cancel.close)
+    );
+    const error = v.error ? text2(v.error, { color: p.danger, fontSize: 13 }) : null;
+    let body = [];
+    if (v.screen === "survey")
+      body = [
+        title(v.flow.question || "Why are you leaving?"),
+        (0, import_react.createElement)(
+          RN.ScrollView,
+          { style: { maxHeight: 320 }, contentContainerStyle: { gap: 6 }, accessibilityRole: "radiogroup" },
+          ...v.flow.reasons.map(
+            (r) => (0, import_react.createElement)(
+              RN.Pressable,
+              {
+                key: r.id,
+                onPress: () => flows.cancel.pick(r.id),
+                accessibilityRole: "radio",
+                accessibilityState: { checked: v.reason === r.id },
+                style: {
+                  minHeight: 44,
+                  paddingHorizontal: 12,
+                  borderRadius: 10,
+                  borderWidth: 1,
+                  borderColor: v.reason === r.id ? p.accent : p.line,
+                  backgroundColor: v.reason === r.id ? p.soft : p.bg,
+                  justifyContent: "center"
+                }
+              },
+              text2(r.label, { fontWeight: "500" })
+            )
+          )
+        ),
+        btn("Continue", "primary", flows.cancel.next, !v.reason),
+        btn("Never mind, keep my plan", "quiet", flows.cancel.close)
+      ];
+    else if (v.screen === "offer" && v.offer) {
+      const o = v.offer;
+      const label = v.flow.reasons.find((r) => r.id === v.reason)?.label;
+      const detail = o.kind === "discount" && o.percent ? v.price ? `${money(discounted(v.price.amount, o.percent), v.price.currency)} instead of ${money(v.price.amount, v.price.currency)}${o.months ? ` for ${months(o.months)}` : ""}` : `${o.percent}% off${o.months ? ` for ${months(o.months)}` : ""}` : o.kind === "pause" && o.months ? `Pause for up to ${months(o.months)}. Your data stays.` : o.kind === "downgrade" && o.planName ? o.planName : null;
+      body = [
+        label ? muted(`You said: ${label}`) : null,
+        title(o.headline),
+        detail ? (0, import_react.createElement)(RN.View, { style: { backgroundColor: p.soft, borderRadius: 10, padding: 12 } }, text2(detail, { fontWeight: "600" })) : null,
+        o.kind === "contact" ? input("What would make you stay?") : null,
+        btn(v.busy ? "One moment\u2026" : offerButton(o), "primary", () => flows.cancel.accept(comment), v.busy),
+        btn("No thanks, continue cancelling", "quiet", flows.cancel.decline, v.busy)
+      ];
+    } else
+      body = [
+        title(v.flow.confirm.title),
+        v.flow.confirm.body ? muted(v.flow.confirm.body, { fontSize: 15 }) : null,
+        v.steps > 1 ? input("Anything else we should know? (optional)") : null,
+        btn(v.busy ? "One moment\u2026" : v.flow.confirm.button, "danger", () => flows.cancel.confirm(comment), v.busy),
+        btn("Keep my plan", "secondary", flows.cancel.close, v.busy)
+      ];
+    return sheet([top, ...body, error], flows.cancel.close);
+  }
+  if (v.type === "step")
+    return sheet(
+      [
+        (0, import_react.createElement)(
+          RN.View,
+          { style: { flexDirection: "row", alignItems: "center" } },
+          v.total > 1 ? muted(`Step ${v.index + 1} of ${v.total}`) : null,
+          close("Close the tour", flows.onboarding.dismiss)
+        ),
+        title(v.step.title),
+        v.step.body ? muted(v.step.body, { fontSize: 15 }) : null,
+        btn(v.step.button || (v.last ? "Done" : "Next"), "primary", flows.onboarding.next)
+      ],
+      flows.onboarding.dismiss
+    );
+  if (v.type === "checklist") {
+    const done = v.items.filter((i) => i.done).length;
+    return (0, import_react.createElement)(
+      RN.View,
+      { pointerEvents: "box-none", style: { position: "absolute", left: 12, right: 12, bottom: 28 } },
+      card([
+        (0, import_react.createElement)(
+          RN.View,
+          { key: "t", style: { flexDirection: "row", alignItems: "center" } },
+          title(v.flow.name),
+          close("Hide the checklist", flows.onboarding.dismiss)
+        ),
+        muted(`${done} of ${v.items.length} done`),
+        ...v.items.map(
+          ({ step, done: d }) => (0, import_react.createElement)(
+            RN.Pressable,
+            {
+              key: step.id,
+              disabled: d || !!step.event,
+              onPress: () => flows.onboarding.check(step.id),
+              accessibilityRole: "checkbox",
+              accessibilityState: { checked: d },
+              style: { flexDirection: "row", gap: 10, alignItems: "flex-start", paddingVertical: 6 }
+            },
+            (0, import_react.createElement)(
+              RN.View,
+              {
+                style: {
+                  width: 20,
+                  height: 20,
+                  borderRadius: 10,
+                  borderWidth: 1.5,
+                  borderColor: d ? p.accent : p.line,
+                  backgroundColor: d ? p.accent : "transparent",
+                  alignItems: "center",
+                  justifyContent: "center"
+                }
+              },
+              d ? text2("\u2713", { color: "#fff", fontSize: 12 }) : null
+            ),
+            (0, import_react.createElement)(
+              RN.View,
+              { style: { flex: 1 } },
+              text2(step.title, { fontWeight: "600", color: d ? p.muted : p.fg, textDecorationLine: d ? "line-through" : "none" }),
+              step.body ? muted(step.body) : null
+            )
+          )
+        )
+      ])
+    );
+  }
+  const m = v.message;
+  if (m.style === "banner")
+    return (0, import_react.createElement)(
+      RN.View,
+      { pointerEvents: "box-none", style: { position: "absolute", left: 12, right: 12, top: 56 } },
+      card([
+        (0, import_react.createElement)(
+          RN.View,
+          { key: "t", style: { flexDirection: "row", alignItems: "center", gap: 8 } },
+          (0, import_react.createElement)(RN.View, { style: { flex: 1 } }, text2(m.title, { fontWeight: "700" }), m.body ? muted(m.body) : null),
+          close("Dismiss", flows.message.dismiss)
+        ),
+        m.button ? btn(m.button, "primary", flows.message.click) : null
+      ])
+    );
+  return sheet(
+    [
+      (0, import_react.createElement)(RN.View, { key: "t", style: { flexDirection: "row" } }, close("Dismiss", flows.message.dismiss)),
+      title(m.title),
+      m.body ? muted(m.body, { fontSize: 15 }) : null,
+      m.button ? btn(m.button, "primary", flows.message.click) : null
+    ],
+    flows.message.dismiss
+  );
+};
+
+// src/native/platform.ts
+var RN2 = require("react-native");
+var asyncStorageModule = null;
+try {
+  asyncStorageModule = require("@react-native-async-storage/async-storage");
+} catch {
+  asyncStorageModule = null;
+}
+var expoDevice = null;
+try {
+  expoDevice = require("expo-device");
+} catch {
+  expoDevice = null;
+}
+var expoApplication = null;
+try {
+  expoApplication = require("expo-application");
+} catch {
+  expoApplication = null;
+}
+var expoLocalization = null;
+try {
+  expoLocalization = require("expo-localization");
+} catch {
+  expoLocalization = null;
+}
+var expoNotifications = null;
+try {
+  expoNotifications = require("expo-notifications");
+} catch {
+  expoNotifications = null;
+}
+var expoConstants = {};
+try {
+  expoConstants = require("expo-constants");
+} catch {
+  expoConstants = {};
+}
+var dataOf = (r) => r?.notification?.request?.content?.data ?? null;
+var expoPush = () => {
+  const n = expoNotifications;
+  if (!n || typeof n.getExpoPushTokenAsync !== "function") return null;
+  const constants = expoConstants.default ?? expoConstants;
+  return {
+    permission: async (ask) => {
+      const now = await n.getPermissionsAsync();
+      if (now.granted || now.status === "granted") return "granted";
+      if (now.status === "denied" || !ask) return now.status === "denied" ? "denied" : "undetermined";
+      const asked = await n.requestPermissionsAsync();
+      return asked.granted || asked.status === "granted" ? "granted" : asked.status === "denied" ? "denied" : "undetermined";
+    },
+    token: async (projectId) => {
+      if (RN2.Platform.OS === "android" && n.setNotificationChannelAsync)
+        await n.setNotificationChannelAsync("default", { name: "Default", importance: n.AndroidImportance?.HIGH ?? 4 });
+      const id = projectId ?? constants.expoConfig?.extra?.eas?.projectId ?? constants.easConfig?.projectId;
+      const t = await n.getExpoPushTokenAsync(id ? { projectId: id } : void 0);
+      return typeof t?.data === "string" && t.data ? t.data : null;
+    },
+    onOpen: (listener) => {
+      const sub = n.addNotificationResponseReceivedListener((r) => listener(dataOf(r) ?? {}));
+      return () => sub.remove();
+    },
+    lastOpen: async () => dataOf(await n.getLastNotificationResponseAsync?.())
+  };
+};
+var asyncStorage = () => {
+  const m = asyncStorageModule;
+  const s = m?.default ?? m;
+  return s && typeof s.getItem === "function" && typeof s.setItem === "function" && typeof s.removeItem === "function" ? s : null;
+};
+var DEVICE_TYPES = { 1: "phone", 2: "tablet", 3: "desktop", 4: "tv" };
+var text = (v, max = 80) => typeof v === "string" && v.trim() ? v.trim().slice(0, max) : typeof v === "number" ? String(v) : void 0;
+var readContext = () => {
+  const p = RN2.Platform;
+  let locale;
+  try {
+    locale = text(expoLocalization?.getLocales?.()[0]?.languageTag, 35);
+  } catch {
+    locale = void 0;
+  }
+  if (!locale) {
+    try {
+      locale = text(Intl.DateTimeFormat().resolvedOptions().locale, 35);
+    } catch {
+      locale = void 0;
+    }
+  }
+  const ctx = {
+    platform: p.OS,
+    appVersion: text(expoApplication?.nativeApplicationVersion),
+    build: text(expoApplication?.nativeBuildVersion),
+    osVersion: text(expoDevice?.osVersion) ?? text(p.Version),
+    deviceModel: text(expoDevice?.modelName) ?? text(p.constants?.Model),
+    deviceType: (expoDevice?.deviceType ? DEVICE_TYPES[expoDevice.deviceType] : void 0) ?? (p.isPad ? "tablet" : void 0),
+    locale
+  };
+  for (const k of Object.keys(ctx)) if (ctx[k] === void 0) delete ctx[k];
+  return ctx;
+};
+var nativeDeps = (overrides = {}) => ({
+  storage: overrides.storage !== void 0 ? overrides.storage : asyncStorage(),
+  fetch: ((url, init) => fetch(url, init)),
+  appState: RN2.AppState,
+  errorUtils: globalThis.ErrorUtils ?? null,
+  context: readContext,
+  appId: text(expoApplication?.applicationId, 150),
+  screen: () => {
+    const s = RN2.Dimensions.get("screen");
+    return s ? { w: s.width, h: s.height } : void 0;
+  },
+  initialUrl: () => RN2.Linking.getInitialURL(),
+  openUrl: (url) => void RN2.Linking.openURL(url).catch(() => void 0),
+  push: expoPush()
+});
+var optionalModules = () => ({
+  asyncStorage: !!asyncStorage(),
+  expoDevice: !!expoDevice,
+  expoApplication: !!expoApplication,
+  expoLocalization: !!expoLocalization,
+  expoNotifications: !!expoNotifications
+});
+
+// src/native/index.tsx
+var shared = null;
+var sharedKey = "";
+var createMRRocket = (options) => {
+  if (shared) {
+    if (sharedKey !== options.apiKey) console.warn("[MRRocket] The SDK is already running with another key; keeping the first one.");
+    return shared;
+  }
+  const { storage, ...rest } = options;
+  const deps = nativeDeps({ storage });
+  shared = createClient(rest, deps);
+  sharedKey = options.apiKey;
+  if (options.debug) console.log("[MRRocket] optional modules", JSON.stringify(optionalModules()));
+  return shared;
+};
+var getMRRocket = () => shared;
+var Ctx = (0, import_react2.createContext)(null);
+var MRRocketProvider = ({ client: given, children, consent, flows = true, appearance, ...options }) => {
+  const [client] = (0, import_react2.useState)(() => given ?? createMRRocket({ ...options, consent }));
+  (0, import_react2.useEffect)(() => {
+    if (consent) client.setConsent(consent);
+  }, [client, consent]);
+  return (0, import_react2.createElement)(Ctx.Provider, { value: client }, children, flows ? (0, import_react2.createElement)(MRRocketFlows, { flows: client.flows, appearance }) : null);
+};
+var useClient = () => {
+  const c = (0, import_react2.useContext)(Ctx);
+  if (!c) throw new Error("MRRocket: wrap your app in <MRRocketProvider apiKey=\u2026>.");
+  return c;
+};
+var useVersion = (client) => (0, import_react2.useSyncExternalStore)(client.subscribe, client.getVersion, client.getVersion);
+var useMRRocket = () => {
+  const client = useClient();
+  useVersion(client);
+  return {
+    track: client.track,
+    screen: client.screen,
+    identify: client.identify,
+    reset: client.reset,
+    setConsent: client.setConsent,
+    captureError: client.captureError,
+    flush: client.flush,
+    distinctId: client.getDistinctId(),
+    consent: client.getConsent(),
+    ready: client.isReady()
+  };
+};
+var useCancelFlow = () => {
+  const client = useClient();
+  return { open: client.openCancelFlow };
+};
+var usePush = () => {
+  const client = useClient();
+  return { register: client.registerForPush, unregister: client.unregisterForPush };
+};
+var useOnboarding = () => {
+  const client = useClient();
+  return { start: client.startOnboarding };
+};
+var useFlag = (key) => {
+  const client = useClient();
+  useVersion(client);
+  return client.getFlag(key);
+};
+var useFlagVariant = (key) => {
+  const client = useClient();
+  useVersion(client);
+  return client.getFlagVariant(key);
+};
+var useVariant = (key) => {
+  const client = useClient();
+  useVersion(client);
+  const config = client.getConfig();
+  const variant = client.peekVariant(key);
+  (0, import_react2.useEffect)(() => {
+    if (config) client.expose(key, variant);
+  }, [client, config, key, variant]);
+  return variant;
+};
+var useText = (id, fallback) => {
+  const client = useClient();
+  useVersion(client);
+  const config = client.getConfig();
+  const text2 = client.peekText(id);
+  const person = client.getDistinctId();
+  (0, import_react2.useEffect)(() => {
+    if (config) client.exposeText(id);
+  }, [client, config, id, person]);
+  return text2 ?? fallback;
+};
+var expoRouter;
+var loadExpoRouter = () => {
+  if (expoRouter !== void 0) return expoRouter;
+  try {
+    expoRouter = require("expo-router");
+  } catch {
+    expoRouter = null;
+  }
+  return expoRouter;
+};
+var noPathname = () => void 0;
+var routerWarned = false;
+var useExpoRouterTracking = () => {
+  const client = useClient();
+  const router = loadExpoRouter();
+  if (router === null && !routerWarned) {
+    routerWarned = true;
+    console.warn("[MRRocket] useExpoRouterTracking needs expo-router. With React Navigation use useNavigationTracking.");
+  }
+  const pathname = (router?.usePathname ?? noPathname)();
+  (0, import_react2.useEffect)(() => {
+    if (pathname) client.screen(pathname);
+  }, [client, pathname]);
+};
+var useNavigationTracking = () => {
+  const client = useClient();
+  return (0, import_react2.useCallback)(
+    (state) => {
+      const name = activeRouteName(state);
+      if (name) client.screen(name);
+    },
+    [client]
+  );
+};
+//# sourceMappingURL=index.js.map