@snapkyc-ooru/consent-handoff-react 0.1.0

package/dist/index.cjs

@@ -0,0 +1,1395 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  API_ORIGIN: () => API_ORIGIN,
+  DEFAULT_SNAP_CONSENT_THEME: () => DEFAULT_SNAP_CONSENT_THEME,
+  SnapConsentHandoffFlow: () => SnapConsentHandoffFlow,
+  SnapSdkHttpError: () => SnapSdkHttpError,
+  demographicAccordionSections: () => demographicAccordionSections,
+  demographicFieldsForDisplay: () => demographicFieldsForDisplay,
+  extractDemographicData: () => extractDemographicData,
+  formatDisplayValue: () => formatDisplayValue,
+  formatPurposeLabel: () => formatPurposeLabel,
+  hasDisplayableDemographics: () => hasDisplayableDemographics,
+  normalizeTxnStatusPayload: () => normalizeTxnStatusPayload,
+  openSnapConsentHandoffFlow: () => openSnapConsentHandoffFlow,
+  openSnapConsentQrFlow: () => openSnapConsentQrFlow,
+  parseDemographicPayload: () => parseDemographicPayload,
+  resolveSnapConsentTheme: () => resolveSnapConsentTheme,
+  themeToCssProperties: () => themeToCssProperties
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/http/errors.ts
+var SnapSdkHttpError = class extends Error {
+  constructor(url, status, message, bodyText) {
+    super(message);
+    this.url = url;
+    this.status = status;
+    this.bodyText = bodyText;
+  }
+  url;
+  status;
+  bodyText;
+  name = "SnapSdkHttpError";
+};
+
+// src/theme.ts
+var DEFAULT_SNAP_CONSENT_THEME = {
+  fontFamily: `system-ui, -apple-system, "Segoe UI", Roboto, sans-serif`,
+  primary: "#E87D43",
+  onPrimary: "#ffffff",
+  canvas: "#FAFAF9",
+  surface: "#ffffff",
+  surfaceMuted: "#FFF7ED",
+  text: "#1c1917",
+  textMuted: "#57534e",
+  border: "#e7e5e4",
+  borderActive: "#E87D43",
+  modalOverlay: "rgba(28, 25, 23, 0.55)",
+  danger: "#b91c1c",
+  radius: "12px",
+  gap: "12px",
+  maxWidth: "720px",
+  modalZ: "10000",
+  success: "#16a34a",
+  successStatusSurface: "#fff5f0",
+  successPurposesSurface: "#f0f2ff",
+  successAccordionBorder: "#e0d7d0"
+};
+function resolveSnapConsentTheme(partial) {
+  const merged = { ...DEFAULT_SNAP_CONSENT_THEME, ...partial };
+  if (partial?.primary !== void 0 && partial.borderActive === void 0) {
+    merged.borderActive = partial.primary;
+  }
+  return merged;
+}
+function themeToCssProperties(theme) {
+  return {
+    "--snap-consent-font-family": theme.fontFamily,
+    "--snap-consent-text": theme.text,
+    "--snap-consent-muted": theme.textMuted,
+    "--snap-consent-bg": theme.canvas,
+    "--snap-consent-surface": theme.surface,
+    "--snap-consent-surface-muted": theme.surfaceMuted,
+    "--snap-consent-border": theme.border,
+    "--snap-consent-border-active": theme.borderActive,
+    "--snap-consent-overlay": theme.modalOverlay,
+    "--snap-consent-accent": theme.primary,
+    "--snap-consent-on-primary": theme.onPrimary,
+    "--snap-consent-danger": theme.danger,
+    "--snap-consent-radius": theme.radius,
+    "--snap-consent-gap": theme.gap,
+    "--snap-consent-max-width": theme.maxWidth,
+    "--snap-consent-modal-z": theme.modalZ,
+    "--snap-consent-success": theme.success,
+    "--snap-consent-success-status-bg": theme.successStatusSurface,
+    "--snap-consent-success-purposes-bg": theme.successPurposesSurface,
+    "--snap-consent-success-accordion-border": theme.successAccordionBorder
+  };
+}
+
+// src/http/normalizeStatus.ts
+function parseJsonObject(raw) {
+  if (raw == null) return null;
+  if (typeof raw === "string") {
+    const trimmed = raw.trim();
+    if (!trimmed) return null;
+    try {
+      const parsed = JSON.parse(trimmed);
+      return parseJsonObject(parsed);
+    } catch {
+      return null;
+    }
+  }
+  if (Array.isArray(raw) || typeof raw !== "object") return null;
+  return raw;
+}
+function parseDemographicPayload(raw) {
+  const obj = parseJsonObject(raw);
+  if (!obj) return null;
+  return obj;
+}
+function parseEvidencePayload(raw) {
+  const obj = parseJsonObject(raw);
+  if (!obj) return void 0;
+  const demographic = parseDemographicPayload(obj.demographic_data) ?? parseDemographicPayload(obj.demographicData);
+  return {
+    ...obj,
+    aadhaar_uuid: typeof obj.aadhaar_uuid === "string" ? obj.aadhaar_uuid : void 0,
+    sd_jwt: typeof obj.sd_jwt === "string" ? obj.sd_jwt : void 0,
+    disclosures: Array.isArray(obj.disclosures) ? obj.disclosures : void 0,
+    demographic_data: demographic ?? void 0
+  };
+}
+function parsePurposes(raw) {
+  if (!Array.isArray(raw)) return [];
+  return raw.map((item) => {
+    if (!item || typeof item !== "object") return null;
+    const row = item;
+    const id = typeof row.id === "string" ? row.id : "";
+    const name = typeof row.name === "string" ? row.name : "";
+    if (!id && !name) return null;
+    return { id: id || name, name: name || id };
+  }).filter((row) => row != null);
+}
+function normalizeTxnStatusPayload(input) {
+  const root = parseJsonObject(input);
+  if (!root) {
+    return { txn_id: "", status: "UNKNOWN" };
+  }
+  if (root.data && typeof root.data === "object" && !Array.isArray(root.data) && ("txn_id" in root.data || "status" in root.data)) {
+    return normalizeTxnStatusPayload(root.data);
+  }
+  const txn_id = typeof root.txn_id === "string" ? root.txn_id : typeof root.txnId === "string" ? root.txnId : "";
+  const status = typeof root.status === "string" ? root.status : String(root.status ?? "UNKNOWN");
+  const created_at = typeof root.created_at === "string" ? root.created_at : void 0;
+  const purposes = parsePurposes(root.purposes);
+  let evidence = parseEvidencePayload(root.evidence);
+  const flatDemo = parseDemographicPayload(root.demographic_data) ?? parseDemographicPayload(root.demographicData);
+  if (flatDemo) {
+    evidence = { ...evidence ?? {}, demographic_data: flatDemo };
+  }
+  return {
+    ...root,
+    txn_id,
+    status,
+    created_at,
+    purposes,
+    evidence
+  };
+}
+
+// src/demographicDisplay.ts
+var SKIP_DEMOGRAPHIC_KEYS = /* @__PURE__ */ new Set(["resident_image"]);
+var PERSONAL_DETAIL_KEYS = /* @__PURE__ */ new Set([
+  "resident_name",
+  "resident_name_local_language",
+  "date_of_birth",
+  "gender",
+  "care_of",
+  "care_of_local_language",
+  "is_age_above_18",
+  "is_age_above_50",
+  "is_age_above_60",
+  "is_age_above_75",
+  "is_non_resident_indian"
+]);
+var CONTACT_DETAIL_KEYS = /* @__PURE__ */ new Set([
+  "mobile_number",
+  "masked_mobile_number",
+  "email_address",
+  "masked_email_address"
+]);
+var ADDRESS_DETAIL_KEYS = /* @__PURE__ */ new Set([
+  "full_address",
+  "regional_address",
+  "building",
+  "street",
+  "locality",
+  "landmark",
+  "village_town_city",
+  "sub_district",
+  "district",
+  "state",
+  "postal_code",
+  "post_office_name"
+]);
+var GROUPED_DETAIL_KEYS = /* @__PURE__ */ new Set([
+  ...PERSONAL_DETAIL_KEYS,
+  ...CONTACT_DETAIL_KEYS,
+  ...ADDRESS_DETAIL_KEYS
+]);
+var MAX_RESIDENT_IMAGE_B64_CHARS = 15e4;
+var DEMOGRAPHIC_KEY_ORDER = [
+  "resident_name",
+  "resident_name_local_language",
+  "date_of_birth",
+  "gender",
+  "care_of",
+  "care_of_local_language",
+  "mobile_number",
+  "masked_mobile_number",
+  "email_address",
+  "masked_email_address",
+  "full_address",
+  "regional_address",
+  "building",
+  "street",
+  "locality",
+  "landmark",
+  "village_town_city",
+  "sub_district",
+  "district",
+  "state",
+  "postal_code",
+  "post_office_name",
+  "enrolment_date",
+  "enrolment_number",
+  "credential_issuing_date",
+  "is_age_above_18",
+  "is_age_above_50",
+  "is_age_above_60",
+  "is_age_above_75",
+  "is_non_resident_indian"
+];
+function extractDemographicData(status) {
+  if (!status || typeof status !== "object") return null;
+  const fromEvidence = parseDemographicPayload(status.evidence?.demographic_data);
+  if (fromEvidence) return fromEvidence;
+  return parseDemographicPayload(status.demographic_data);
+}
+function hasDisplayableDemographics(status) {
+  const data = extractDemographicData(status);
+  if (!data) return false;
+  if (demographicFieldsForDisplay(data).length > 0) return true;
+  const raw = data.resident_image;
+  if (typeof raw !== "string" || !raw.trim()) return false;
+  return raw.trim().length <= MAX_RESIDENT_IMAGE_B64_CHARS;
+}
+function formatDisplayValue(value) {
+  if (value === null || value === void 0) return "null";
+  if (typeof value === "string") return value.trim() === "" ? "null" : value;
+  if (typeof value === "object") return "null";
+  return String(value);
+}
+function humanizeDemographicKey(key) {
+  return key.replace(/_/g, " ").replace(/\b\w/g, (ch) => ch.toUpperCase());
+}
+function orderedDemographicKeys(data) {
+  const keys = Object.keys(data).filter((k) => !SKIP_DEMOGRAPHIC_KEYS.has(k));
+  const rank = new Map(DEMOGRAPHIC_KEY_ORDER.map((k, i) => [k, i]));
+  return keys.sort((a, b) => {
+    const ra = rank.get(a) ?? Number.MAX_SAFE_INTEGER;
+    const rb = rank.get(b) ?? Number.MAX_SAFE_INTEGER;
+    if (ra !== rb) return ra - rb;
+    return a.localeCompare(b);
+  });
+}
+function demographicFieldsForDisplay(data) {
+  return orderedDemographicKeys(data).map((key) => ({
+    key,
+    label: humanizeDemographicKey(key),
+    value: formatDisplayValue(data[key])
+  }));
+}
+function demographicAccordionSections(data, options) {
+  const all = demographicFieldsForDisplay(data);
+  const byKey = (keys) => all.filter((f) => keys.has(f.key));
+  const personalFields = byKey(PERSONAL_DETAIL_KEYS);
+  const contactFields = byKey(CONTACT_DETAIL_KEYS);
+  const addressFields = byKey(ADDRESS_DETAIL_KEYS);
+  const additionalFields = all.filter((f) => !GROUPED_DETAIL_KEYS.has(f.key));
+  const sections = [];
+  if (personalFields.length > 0 || options.includePhoto) {
+    sections.push({
+      id: "personal",
+      title: "Personal Details",
+      fields: personalFields,
+      includePhoto: options.includePhoto
+    });
+  }
+  if (contactFields.length > 0) {
+    sections.push({
+      id: "contact",
+      title: "Contact Information",
+      fields: contactFields,
+      includePhoto: false
+    });
+  }
+  if (addressFields.length > 0) {
+    sections.push({
+      id: "address",
+      title: "Address Details",
+      fields: addressFields,
+      includePhoto: false
+    });
+  }
+  if (additionalFields.length > 0) {
+    sections.push({
+      id: "additional",
+      title: "Additional details",
+      fields: additionalFields,
+      includePhoto: false
+    });
+  }
+  return sections;
+}
+function residentImageDataUrl(data) {
+  const raw = data.resident_image;
+  if (typeof raw !== "string" || !raw.trim()) return null;
+  const b64 = raw.trim();
+  if (b64.length > MAX_RESIDENT_IMAGE_B64_CHARS) return null;
+  if (b64.startsWith("data:")) return b64;
+  return `data:image/jpeg;base64,${b64}`;
+}
+function formatPurposeLabel(name) {
+  if (typeof name !== "string" || !name.trim()) return "Purpose";
+  return name.split("_").map((part) => part.charAt(0) + part.slice(1).toLowerCase()).join(" ");
+}
+
+// src/react/SnapConsentHandoffFlow.tsx
+var import_dompurify = __toESM(require("dompurify"), 1);
+var import_react3 = require("react");
+
+// src/device/detectIntentPlatform.ts
+function detectIntentPlatform(userAgent) {
+  const uaRaw = userAgent ?? (typeof navigator !== "undefined" ? navigator.userAgent : "");
+  const ua = uaRaw.toLowerCase();
+  if (!ua) return { kind: "ambiguous", reason: "missing-user-agent" };
+  const isAndroid = /android/.test(ua);
+  const touchPoints = typeof navigator !== "undefined" ? Number(navigator.maxTouchPoints ?? 0) : 0;
+  const isIOSDevice = /iphone|ipad|ipod/.test(ua) || ua.includes("macintosh") && touchPoints > 1;
+  if (isAndroid && !isIOSDevice) return { kind: "resolved", platform: "android" };
+  if (!isAndroid && isIOSDevice) return { kind: "resolved", platform: "ios" };
+  return { kind: "ambiguous", reason: "ambiguous-or-non-mobile" };
+}
+
+// src/config.ts
+var API_ORIGIN = "https://staging-api.snapkyc.com/";
+var paths = {
+  agreement: () => `${API_ORIGIN}/api/integrations/agreement`,
+  txnInitiate: () => `${API_ORIGIN}/api/integrations/transactions/initiate`,
+  generateQr: () => `${API_ORIGIN}/api/integrations/generate-qr`,
+  generateIntent: (platform) => `${API_ORIGIN}/api/integrations/generate-intent?platform=${platform}`,
+  txnStatus: (txnId) => `${API_ORIGIN}/api/integrations/transactions/${encodeURIComponent(txnId)}/status`
+};
+
+// src/http/envelope.ts
+function unwrapEnvelope(envelope, fallbackMessage = "API error") {
+  if (envelope.error || envelope.data == null) {
+    const detail = typeof envelope.error_message === "string" ? envelope.error_message : envelope.error_message != null ? JSON.stringify(envelope.error_message) : envelope.message;
+    throw new Error(detail || fallbackMessage);
+  }
+  return envelope.data;
+}
+
+// src/http/auth.ts
+function authorizationHeaders(integrationToken) {
+  return {
+    Authorization: `Token ${integrationToken}`
+  };
+}
+
+// src/http/client.ts
+async function assertOk(res, url) {
+  if (!res.ok) {
+    const text = await res.text().catch(() => "");
+    const err = new SnapSdkHttpError(url, res.status, `HTTP ${res.status} calling ${url}`, text);
+    throw err;
+  }
+}
+async function fetchJson(options) {
+  const { url, integrationToken, method = "GET", body, signal, headers = {} } = options;
+  const res = await fetch(url, {
+    method,
+    signal,
+    headers: {
+      ...authorizationHeaders(integrationToken),
+      Accept: "application/json",
+      ...body !== void 0 ? { "Content-Type": "application/json" } : {},
+      ...headers
+    },
+    body: body === void 0 ? void 0 : JSON.stringify(body)
+  }).catch((e) => {
+    throw e;
+  });
+  await assertOk(res, url);
+  return await res.json();
+}
+async function fetchBlob(options) {
+  const { url, integrationToken, method = "POST", body, signal } = options;
+  const res = await fetch(url, {
+    method,
+    signal,
+    headers: {
+      ...authorizationHeaders(integrationToken),
+      Accept: "image/png,*/*",
+      ...body !== void 0 ? { "Content-Type": "application/json" } : {}
+    },
+    body: body === void 0 ? void 0 : JSON.stringify(body)
+  }).catch((e) => {
+    throw e;
+  });
+  await assertOk(res, url);
+  return await res.blob();
+}
+
+// src/http/endpoints.ts
+async function getAgreement(options) {
+  return fetchJson({
+    url: paths.agreement(),
+    integrationToken: options.integrationToken,
+    method: "GET",
+    signal: options.signal,
+    headers: options.acceptLanguage ? {
+      "Accept-Language": options.acceptLanguage
+    } : {}
+  });
+}
+async function initiateTxn(options) {
+  const envelope = await fetchJson({
+    url: paths.txnInitiate(),
+    integrationToken: options.integrationToken,
+    method: "POST",
+    body: options.body,
+    signal: options.signal
+  });
+  return unwrapEnvelope(envelope, "Transaction initiate failed");
+}
+async function generateQr(options) {
+  return fetchBlob({
+    url: paths.generateQr(),
+    integrationToken: options.integrationToken,
+    body: {
+      txn_id: options.txnId,
+      size: options.size ?? 376
+    },
+    signal: options.signal
+  });
+}
+async function createIntent(options) {
+  const envelope = await fetchJson({
+    url: paths.generateIntent(options.platform),
+    integrationToken: options.integrationToken,
+    method: "POST",
+    body: { txn_id: options.txnId },
+    signal: options.signal
+  });
+  return unwrapEnvelope(envelope, "Intent generation failed");
+}
+async function pollTxnStatus(options) {
+  const envelope = await fetchJson({
+    url: paths.txnStatus(options.txnId),
+    integrationToken: options.integrationToken,
+    method: "GET",
+    signal: options.signal
+  });
+  return normalizeTxnStatusPayload(unwrapEnvelope(envelope, "Transaction status fetch failed"));
+}
+
+// src/http/pollTxn.ts
+var successStatusesLower = /* @__PURE__ */ new Set(["success", "completed", "complete"]);
+var pendingHintsLower = /* @__PURE__ */ new Set([
+  "pending",
+  "in_progress",
+  "processing",
+  "initiated",
+  "waiting",
+  "started"
+]);
+var failureStatusesLower = /* @__PURE__ */ new Set(["failed", "failure", "error", "rejected", "expired"]);
+var DEMOGRAPHIC_WAIT_AFTER_SUCCESS_MS = 15e3;
+function normalizeStatus(raw) {
+  return typeof raw === "string" ? raw.trim().toLowerCase() : "";
+}
+function classifyTxnStatus(raw) {
+  const s = normalizeStatus(raw);
+  if (!s) return "pending";
+  if (successStatusesLower.has(s)) return "success";
+  if (failureStatusesLower.has(s)) return "failure";
+  if (pendingHintsLower.has(s)) return "pending";
+  return "pending";
+}
+async function delay(ms, signal) {
+  await new Promise((resolve, reject) => {
+    if (signal.aborted) {
+      reject(new DOMException("Aborted", "AbortError"));
+      return;
+    }
+    const timer = globalThis.setTimeout(() => resolve(), ms);
+    signal.addEventListener(
+      "abort",
+      () => {
+        globalThis.clearTimeout(timer);
+        reject(new DOMException("Aborted", "AbortError"));
+      },
+      { once: true }
+    );
+  });
+}
+async function pollTxnUntilTerminal(options) {
+  const start = Date.now();
+  let successAt = null;
+  let lastSuccess = null;
+  while (true) {
+    if (options.signal.aborted) {
+      throw new DOMException("Aborted", "AbortError");
+    }
+    if (Date.now() - start > options.deadlineMs) {
+      if (lastSuccess) return lastSuccess;
+      throw new Error(`Txn polling timed out after ${options.deadlineMs}ms`);
+    }
+    const latest = await pollTxnStatus({
+      integrationToken: options.integrationToken,
+      txnId: options.txnId,
+      signal: options.signal
+    });
+    const bucket = classifyTxnStatus(latest.status);
+    if (bucket === "success") {
+      lastSuccess = latest;
+      if (successAt == null) successAt = Date.now();
+      if (hasDisplayableDemographics(latest)) return latest;
+      if (Date.now() - successAt >= DEMOGRAPHIC_WAIT_AFTER_SUCCESS_MS) return latest;
+    } else {
+      successAt = null;
+      lastSuccess = null;
+      if (bucket === "failure") {
+        throw new Error(`Txn failed with terminal status '${String(latest.status)}'`);
+      }
+    }
+    await delay(options.pollIntervalMs, options.signal);
+  }
+}
+
+// src/purposeSelection.ts
+function buildSelectablePurposes(data) {
+  return (data.purposes ?? []).map((purpose) => ({
+    id: purpose.id,
+    label: purpose.description?.en ?? purpose.name
+  }));
+}
+
+// src/uiHelpers.ts
+function agreementTextHtml(data, acceptLanguage) {
+  const texts = data.agreement_text ?? {};
+  const preferredLang = acceptLanguage?.split(",")[0]?.trim();
+  const key = preferredLang && texts[preferredLang] ? preferredLang : texts.en ? "en" : Object.keys(texts)[0];
+  const raw = key ? texts[key] : "";
+  const text = typeof raw === "string" ? raw.trim() : "";
+  if (!text) return null;
+  const escaped = text.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
+  return escaped.replace(/\n/g, "<br />");
+}
+function coerceForcedIntentOs(props) {
+  return props._dangerouslyForceIntentPlatform ?? props.dangerousForceIntentPlatform ?? props.intentPlatformOverride;
+}
+
+// src/react/FlowErrorBoundary.tsx
+var import_react = require("react");
+var import_jsx_runtime = require("react/jsx-runtime");
+var FlowErrorBoundary = class extends import_react.Component {
+  state = { error: null };
+  static getDerivedStateFromError(error) {
+    return { error };
+  }
+  componentDidCatch(error, info) {
+    console.error("[snap-consent-handoff] render error", error, info.componentStack);
+  }
+  render() {
+    if (this.state.error) {
+      return this.props.fallback ?? /* @__PURE__ */ (0, import_jsx_runtime.jsxs)("div", { className: "snap-consent-handoff_err", role: "alert", children: [
+        "Something went wrong displaying the verification result. Please check the browser console or use the data returned in ",
+        /* @__PURE__ */ (0, import_jsx_runtime.jsx)("code", { children: "onSuccess" }),
+        "."
+      ] });
+    }
+    return this.props.children;
+  }
+};
+
+// src/assets/snapkycog.svg
+var snapkycog_default = 'data:image/svg+xml,<svg width="1007" height="518" viewBox="0 0 1007 518" fill="none" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink">%0A<rect width="1007" height="518" fill="url(%23pattern0_60_2)"/>%0A<defs>%0A<pattern id="pattern0_60_2" patternContentUnits="objectBoundingBox" width="1" height="1">%0A<use xlink:href="%23image0_60_2" transform="scale(0.000350408 0.000681199)"/>%0A</pattern>%0A<image id="image0_60_2" width="2854" height="1468" preserveAspectRatio="none" xlink:href="data:image/png;base64,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"/>%0A</defs>%0A</svg>%0A';
+
+// src/react/PoweredBySnapKyc.tsx
+var import_jsx_runtime2 = require("react/jsx-runtime");
+function PoweredBySnapKyc() {
+  return /* @__PURE__ */ (0, import_jsx_runtime2.jsxs)("footer", { className: "snap-consent-handoff_powered", "data-testid": "snap-consent-handoff-powered", children: [
+    /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("span", { className: "snap-consent-handoff_poweredLabel", children: "Powered by" }),
+    /* @__PURE__ */ (0, import_jsx_runtime2.jsx)("img", { className: "snap-consent-handoff_poweredLogo", src: snapkycog_default, alt: "snapkyc" })
+  ] });
+}
+
+// src/react/TxnSuccessPanel.tsx
+var import_react2 = require("react");
+var import_jsx_runtime3 = require("react/jsx-runtime");
+function SuccessShieldIcon() {
+  return /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)("svg", { width: "24", height: "24", viewBox: "0 0 24 24", fill: "none", xmlns: "http://www.w3.org/2000/svg", "aria-hidden": true, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(
+      "path",
+      {
+        d: "M12 22s8-4 8-10V5l-8-3-8 3v7c0 6 8 10 8 10z",
+        stroke: "currentColor",
+        strokeWidth: "2",
+        strokeLinecap: "round",
+        strokeLinejoin: "round"
+      }
+    ),
+    /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(
+      "path",
+      {
+        d: "m9 12 2 2 4-4",
+        stroke: "currentColor",
+        strokeWidth: "2",
+        strokeLinecap: "round",
+        strokeLinejoin: "round"
+      }
+    )
+  ] });
+}
+function SmallCheckIcon() {
+  return /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("svg", { width: "16", height: "16", viewBox: "0 0 16 16", fill: "none", xmlns: "http://www.w3.org/2000/svg", "aria-hidden": true, children: /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(
+    "path",
+    {
+      d: "M3.5 8.2 6.3 11l6.2-6.2",
+      stroke: "currentColor",
+      strokeWidth: "2",
+      strokeLinecap: "round",
+      strokeLinejoin: "round"
+    }
+  ) });
+}
+function SectionListIcon() {
+  return /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)("svg", { width: "18", height: "18", viewBox: "0 0 24 24", fill: "none", xmlns: "http://www.w3.org/2000/svg", "aria-hidden": true, children: [
+    /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("path", { d: "M8 6h13M8 12h13M8 18h13", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round" }),
+    /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(
+      "path",
+      {
+        d: "M3.5 6l1 1-1 1M3.5 12l1 1-1 1M3.5 18l1 1-1 1",
+        stroke: "currentColor",
+        strokeWidth: "1.5",
+        strokeLinecap: "round",
+        strokeLinejoin: "round"
+      }
+    )
+  ] });
+}
+function SectionUserIcon() {
+  return /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("svg", { width: "18", height: "18", viewBox: "0 0 24 24", fill: "none", xmlns: "http://www.w3.org/2000/svg", "aria-hidden": true, children: /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(
+    "path",
+    {
+      d: "M12 11a3 3 0 1 0-3-3 3 3 0 0 0 3 3zm0 2c-3.3 0-6 1.6-6 3.5V19h12v-2.5C18 14.6 15.3 13 12 13z",
+      fill: "currentColor"
+    }
+  ) });
+}
+function AccordionChevron({ open }) {
+  return /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(
+    "span",
+    {
+      className: open ? "snap-consent-handoff_accordionChevron snap-consent-handoff_accordionChevron--open" : "snap-consent-handoff_accordionChevron",
+      "aria-hidden": true,
+      children: /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("svg", { width: "20", height: "20", viewBox: "0 0 24 24", fill: "none", xmlns: "http://www.w3.org/2000/svg", children: /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("path", { d: "M6 9l6 6 6-6", stroke: "currentColor", strokeWidth: "2", strokeLinecap: "round", strokeLinejoin: "round" }) })
+    }
+  );
+}
+function TxnSuccessPanel({ status }) {
+  const normalized = (0, import_react2.useMemo)(() => normalizeTxnStatusPayload(status), [status]);
+  const demographics = (0, import_react2.useMemo)(() => extractDemographicData(normalized), [normalized]);
+  const photoUrl = demographics ? residentImageDataUrl(demographics) : null;
+  const photoOmitted = Boolean(
+    demographics && typeof demographics.resident_image === "string" && demographics.resident_image.trim().length > 0 && !photoUrl
+  );
+  const accordionSections = (0, import_react2.useMemo)(() => {
+    if (!demographics) return [];
+    return demographicAccordionSections(demographics, {
+      includePhoto: Boolean(photoUrl || photoOmitted)
+    });
+  }, [demographics, photoUrl, photoOmitted]);
+  const defaultOpenId = (0, import_react2.useMemo)(() => {
+    const personal = accordionSections.find((s) => s.id === "personal");
+    return personal?.id ?? accordionSections[0]?.id ?? "";
+  }, [accordionSections]);
+  const [openAccordionId, setOpenAccordionId] = (0, import_react2.useState)(defaultOpenId);
+  (0, import_react2.useEffect)(() => {
+    setOpenAccordionId(defaultOpenId);
+  }, [defaultOpenId]);
+  const purposes = Array.isArray(normalized.purposes) ? normalized.purposes : [];
+  const hasSummaryPayload = Boolean(normalized.txn_id || normalized.status);
+  if (!hasSummaryPayload) {
+    return /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("p", { className: "snap-consent-handoff_muted", style: { marginTop: "12px" }, children: "Verification completed, but no status payload was available to display." });
+  }
+  const showDemographicsBlock = demographics && (accordionSections.length > 0 || photoOmitted);
+  function toggleAccordion(id) {
+    setOpenAccordionId((prev) => prev === id ? "" : id);
+  }
+  return /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)("div", { className: "snap-consent-handoff_successBody", "data-testid": "snap-consent-handoff-success-body", children: [
+    /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)("div", { className: "snap-consent-handoff_successHero", children: [
+      /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("div", { className: "snap-consent-handoff_successBadge", children: /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(SuccessShieldIcon, {}) }),
+      /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)("div", { className: "snap-consent-handoff_successHeroText", children: [
+        /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("h2", { className: "snap-consent-handoff_successTitle", children: "Verification successful" }),
+        /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("p", { className: "snap-consent-handoff_successSubtitle", children: "Identity has been verified successfully." })
+      ] })
+    ] }),
+    /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)("section", { className: "snap-consent-handoff_statusStrip", "aria-label": "Transaction summary", children: [
+      /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)("div", { className: "snap-consent-handoff_statusStripCol", children: [
+        /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("p", { className: "snap-consent-handoff_statusLabel", children: "Status" }),
+        /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)("p", { className: "snap-consent-handoff_statusValue", children: [
+          /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("span", { className: "snap-consent-handoff_statusCheck", "aria-hidden": true, children: /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(SmallCheckIcon, {}) }),
+          formatDisplayValue(normalized.status)
+        ] })
+      ] }),
+      /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)("div", { className: "snap-consent-handoff_statusStripCol snap-consent-handoff_statusStripCol--end", children: [
+        /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("p", { className: "snap-consent-handoff_statusLabel snap-consent-handoff_statusLabel--neutral", children: "Completed at" }),
+        /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("p", { className: "snap-consent-handoff_statusMeta", children: formatDisplayValue(normalized.created_at) })
+      ] })
+    ] }),
+    purposes.length > 0 ? /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)("section", { className: "snap-consent-handoff_purposeCard", "data-testid": "snap-consent-handoff-purposes", children: [
+      /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)("h3", { className: "snap-consent-handoff_successSectionTitle", children: [
+        /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("span", { className: "snap-consent-handoff_successSectionIcon", "aria-hidden": true, children: /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(SectionListIcon, {}) }),
+        "Confirmed purposes"
+      ] }),
+      /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("ul", { className: "snap-consent-handoff_purposeGrid", children: purposes.map((purpose, index) => /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)("li", { className: "snap-consent-handoff_purposeGridItem", children: [
+        /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("span", { className: "snap-consent-handoff_purposeCheck", "aria-hidden": true, children: /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(SmallCheckIcon, {}) }),
+        /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("span", { children: formatPurposeLabel(purpose?.name) })
+      ] }, purpose?.id ?? `purpose-${index}`)) })
+    ] }) : null,
+    showDemographicsBlock ? /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)("section", { className: "snap-consent-handoff_demographics", "data-testid": "snap-consent-handoff-demographics", children: [
+      /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)("h3", { className: "snap-consent-handoff_successSectionTitle", children: [
+        /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("span", { className: "snap-consent-handoff_successSectionIcon", "aria-hidden": true, children: /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(SectionUserIcon, {}) }),
+        "Demographic data"
+      ] }),
+      /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("div", { className: "snap-consent-handoff_accordionList", children: accordionSections.map((section) => /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(
+        DemographicAccordion,
+        {
+          section,
+          photoUrl: section.includePhoto ? photoUrl : null,
+          photoOmitted: section.includePhoto ? photoOmitted : false,
+          expanded: openAccordionId === section.id,
+          onToggle: () => toggleAccordion(section.id)
+        },
+        section.id
+      )) })
+    ] }) : /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("p", { className: "snap-consent-handoff_muted snap-consent-handoff_successNoDemo", children: "No demographic details were returned for this transaction." })
+  ] });
+}
+function DemographicAccordion({
+  section,
+  photoUrl,
+  photoOmitted,
+  expanded,
+  onToggle
+}) {
+  const panelId = `snap-demo-accordion-${section.id}`;
+  const headerId = `snap-demo-accordion-h-${section.id}`;
+  return /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)("div", { className: "snap-consent-handoff_accordion", children: [
+    /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)(
+      "button",
+      {
+        type: "button",
+        id: headerId,
+        className: "snap-consent-handoff_accordionHeader",
+        "aria-expanded": expanded,
+        "aria-controls": panelId,
+        onClick: onToggle,
+        children: [
+          /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("span", { className: "snap-consent-handoff_accordionTitle", children: section.title }),
+          /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(AccordionChevron, { open: expanded })
+        ]
+      }
+    ),
+    /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)(
+      "div",
+      {
+        id: panelId,
+        role: "region",
+        "aria-labelledby": headerId,
+        className: expanded ? "snap-consent-handoff_accordionPanel snap-consent-handoff_accordionPanel--open" : "snap-consent-handoff_accordionPanel",
+        children: [
+          photoOmitted ? /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("p", { className: "snap-consent-handoff_muted snap-consent-handoff_accordionNote", children: "Photo omitted (too large to preview in the browser)." }) : null,
+          /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)(
+            "div",
+            {
+              className: photoUrl ? "snap-consent-handoff_accordionBody snap-consent-handoff_accordionBody--withPhoto" : "snap-consent-handoff_accordionBody",
+              children: [
+                photoUrl ? /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("div", { className: "snap-consent-handoff_accordionPhoto", children: /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("img", { src: photoUrl, alt: "Resident", loading: "lazy", decoding: "async" }) }) : null,
+                section.fields.length > 0 ? /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("dl", { className: "snap-consent-handoff_successFields", children: section.fields.map((row) => /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)("div", { className: "snap-consent-handoff_successField", children: [
+                  /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("dt", { children: row.label }),
+                  /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("dd", { children: row.value })
+                ] }, row.key)) }) : photoUrl || photoOmitted ? null : /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("p", { className: "snap-consent-handoff_muted", children: "No fields in this category." })
+              ]
+            }
+          )
+        ]
+      }
+    )
+  ] });
+}
+
+// src/react/SnapConsentHandoffFlow.tsx
+var import_jsx_runtime4 = require("react/jsx-runtime");
+var defaultQrSize = 376;
+function emitEvt(onFlowEvent, evt) {
+  try {
+    onFlowEvent?.(evt);
+  } catch {
+  }
+}
+function SnapConsentHandoffFlow(props) {
+  const {
+    integrationToken,
+    rpContext,
+    agreementId: _agreementIdProp,
+    acceptLanguage,
+    handoffMode,
+    qrRequestBody,
+    pollIntervalMs = 1500,
+    pollDeadlineMs = 12e4,
+    onFlowEvent,
+    onSuccess,
+    onError,
+    onRequestClose,
+    displayMode = "modal",
+    title,
+    userAgent,
+    theme: themePartial
+  } = props;
+  const themeCss = (0, import_react3.useMemo)(() => themeToCssProperties(resolveSnapConsentTheme(themePartial)), [themePartial]);
+  const forcedOs = coerceForcedIntentOs(props);
+  const flowAbortRef = (0, import_react3.useRef)(new AbortController());
+  (0, import_react3.useEffect)(() => {
+    flowAbortRef.current.abort();
+    flowAbortRef.current = new AbortController();
+    return () => {
+      flowAbortRef.current.abort();
+    };
+  }, [integrationToken, handoffMode]);
+  const qrObjectUrlRef = (0, import_react3.useRef)(null);
+  const sheetRef = (0, import_react3.useRef)(null);
+  (0, import_react3.useEffect)(() => {
+    return () => {
+      if (qrObjectUrlRef.current) URL.revokeObjectURL(qrObjectUrlRef.current);
+      qrObjectUrlRef.current = null;
+    };
+  }, []);
+  const signal = () => flowAbortRef.current.signal;
+  const [fatalError, setFatalError] = (0, import_react3.useState)(null);
+  const [agreementEnvelope, setAgreementEnvelope] = (0, import_react3.useState)(null);
+  const [loadingAgreement, setLoadingAgreement] = (0, import_react3.useState)(true);
+  const [busyConsent, setBusyConsent] = (0, import_react3.useState)(false);
+  const [txnIdDisplay, setTxnIdDisplay] = (0, import_react3.useState)(null);
+  const [intentUrl, setIntentUrl] = (0, import_react3.useState)(null);
+  const [intentNeedsPick, setIntentNeedsPick] = (0, import_react3.useState)(false);
+  const [qrObjectUrl, setQrObjectUrl] = (0, import_react3.useState)(null);
+  const [busyPolling, setBusyPolling] = (0, import_react3.useState)(false);
+  const [completed, setCompleted] = (0, import_react3.useState)(null);
+  const [flowDismissed, setFlowDismissed] = (0, import_react3.useState)(false);
+  (0, import_react3.useEffect)(() => {
+    setFlowDismissed(false);
+  }, [integrationToken, handoffMode]);
+  const selectable = (0, import_react3.useMemo)(() => {
+    if (!agreementEnvelope) return [];
+    return buildSelectablePurposes(agreementEnvelope.data);
+  }, [agreementEnvelope]);
+  const [selectedPurposesMap, setSelectedPurposesMap] = (0, import_react3.useState)({});
+  (0, import_react3.useEffect)(() => {
+    setSelectedPurposesMap((prev) => {
+      const next = {};
+      for (const row of selectable) {
+        next[row.id] = prev[row.id] ?? false;
+      }
+      return next;
+    });
+  }, [selectable]);
+  const hydrateAgreementHtml = (0, import_react3.useCallback)(
+    (data) => {
+      const html = agreementTextHtml(data, acceptLanguage);
+      if (!html) return null;
+      return import_dompurify.default.sanitize(html, { ALLOWED_TAGS: ["br"], ALLOWED_ATTR: [] });
+    },
+    [acceptLanguage]
+  );
+  const agreementHtml = (0, import_react3.useMemo)(() => {
+    if (!agreementEnvelope) return null;
+    return hydrateAgreementHtml(agreementEnvelope.data);
+  }, [agreementEnvelope, hydrateAgreementHtml]);
+  const revokeQrIfAny = () => {
+    if (qrObjectUrlRef.current) URL.revokeObjectURL(qrObjectUrlRef.current);
+    qrObjectUrlRef.current = null;
+    setQrObjectUrl(null);
+  };
+  const finishWithSuccess = (0, import_react3.useCallback)(
+    (raw, txnIdHint) => {
+      const normalized = normalizeTxnStatusPayload(raw);
+      revokeQrIfAny();
+      setIntentUrl(null);
+      setIntentNeedsPick(false);
+      setTxnIdDisplay(null);
+      setBusyPolling(false);
+      setBusyConsent(false);
+      const completion = {
+        txn_id: normalized.txn_id || txnIdHint,
+        status: normalized.status,
+        raw: normalized
+      };
+      setCompleted(completion);
+      emitEvt(onFlowEvent, { phase: "completed", txnId: completion.txn_id });
+      queueMicrotask(() => {
+        onSuccess?.(completion);
+      });
+    },
+    [onFlowEvent, onSuccess]
+  );
+  (0, import_react3.useEffect)(() => {
+    if (!completed) return;
+    sheetRef.current?.scrollTo({ top: 0, behavior: "smooth" });
+  }, [completed]);
+  (0, import_react3.useEffect)(() => {
+    emitEvt(onFlowEvent, { phase: "agreement-loading" });
+    let cancelled = false;
+    async function bootstrap() {
+      try {
+        setLoadingAgreement(true);
+        setFatalError(null);
+        const env = await getAgreement({
+          integrationToken,
+          signal: signal(),
+          acceptLanguage
+        });
+        if (cancelled) return;
+        if (env.error) throw new Error(env.error_message ?? env.message ?? "Agreement fetch error");
+        setAgreementEnvelope(env);
+        emitEvt(onFlowEvent, { phase: "agreement-ready" });
+      } catch (e) {
+        if (e?.name === "AbortError") return;
+        const msg = e instanceof Error ? e.message : String(e);
+        setFatalError(msg);
+        emitEvt(onFlowEvent, { phase: "failed", error: e });
+        onError?.(e);
+      } finally {
+        if (!cancelled) setLoadingAgreement(false);
+      }
+    }
+    void bootstrap();
+    return () => {
+      cancelled = true;
+    };
+  }, [integrationToken, acceptLanguage]);
+  async function finalizeIntentAndPoll(currentTxnId, platform) {
+    revokeQrIfAny();
+    emitEvt(onFlowEvent, {
+      phase: "handoff-loading",
+      txnId: currentTxnId,
+      meta: { kind: "ambiguous-choice", chosen: platform }
+    });
+    try {
+      setIntentNeedsPick(false);
+      setFatalError(null);
+      const res = await createIntent({
+        integrationToken,
+        txnId: currentTxnId,
+        platform,
+        signal: signal()
+      });
+      setIntentUrl(res.intent_url);
+      emitEvt(onFlowEvent, {
+        phase: "handoff-ready",
+        txnId: currentTxnId,
+        meta: { kind: "ambiguous-choice", chosen: platform }
+      });
+      emitEvt(onFlowEvent, { phase: "polling", txnId: currentTxnId });
+      setBusyPolling(true);
+      const raw = await pollTxnUntilTerminal({
+        integrationToken,
+        txnId: currentTxnId,
+        signal: signal(),
+        pollIntervalMs,
+        deadlineMs: pollDeadlineMs
+      });
+      finishWithSuccess(raw, currentTxnId);
+    } catch (e) {
+      setBusyPolling(false);
+      if (e?.name === "AbortError") return;
+      const msg = e instanceof Error ? e.message : String(e);
+      setFatalError(msg);
+      emitEvt(onFlowEvent, { phase: "failed", txnId: currentTxnId, error: e });
+      onError?.(e);
+    }
+  }
+  async function runQrHandoff(currentTxnId) {
+    emitEvt(onFlowEvent, { phase: "handoff-loading", txnId: currentTxnId });
+    revokeQrIfAny();
+    const blob = await generateQr({
+      integrationToken,
+      txnId: currentTxnId,
+      size: qrRequestBody?.size ?? defaultQrSize,
+      signal: signal()
+    });
+    const url = URL.createObjectURL(blob);
+    qrObjectUrlRef.current = url;
+    setQrObjectUrl(url);
+    emitEvt(onFlowEvent, { phase: "handoff-ready", txnId: currentTxnId });
+  }
+  async function runIntentHandoff(currentTxnId, platform) {
+    emitEvt(onFlowEvent, {
+      phase: "handoff-loading",
+      txnId: currentTxnId,
+      meta: forcedOs ? { kind: "forced", platform } : { kind: "resolved", platform }
+    });
+    const res = await createIntent({
+      integrationToken,
+      txnId: currentTxnId,
+      platform,
+      signal: signal()
+    });
+    setIntentUrl(res.intent_url);
+    emitEvt(onFlowEvent, {
+      phase: "handoff-ready",
+      txnId: currentTxnId,
+      meta: forcedOs ? { kind: "forced", platform } : { kind: "resolved", platform }
+    });
+  }
+  const handleContinueConsent = async () => {
+    if (!agreementEnvelope) return;
+    emitEvt(onFlowEvent, { phase: "txn-initiating" });
+    revokeQrIfAny();
+    setIntentUrl(null);
+    setIntentNeedsPick(false);
+    setCompleted(null);
+    try {
+      setBusyConsent(true);
+      setFatalError(null);
+      const purposeIds = selectable.filter((item) => selectedPurposesMap[item.id]).map((item) => item.id);
+      if (!purposeIds.length) throw new Error("Please select at least one purpose.");
+      const txn = await initiateTxn({
+        integrationToken,
+        body: {
+          purpose_ids: purposeIds,
+          rp_context: {
+            ref_id: rpContext.reference_id
+          }
+        },
+        signal: signal()
+      });
+      setTxnIdDisplay(txn.txn_id);
+      emitEvt(onFlowEvent, { phase: "txn-created", txnId: txn.txn_id });
+      if (handoffMode === "qr") {
+        await runQrHandoff(txn.txn_id);
+        emitEvt(onFlowEvent, { phase: "polling", txnId: txn.txn_id });
+        setBusyPolling(true);
+        try {
+          const raw = await pollTxnUntilTerminal({
+            integrationToken,
+            txnId: txn.txn_id,
+            signal: signal(),
+            pollIntervalMs,
+            deadlineMs: pollDeadlineMs
+          });
+          finishWithSuccess(raw, txn.txn_id);
+        } catch (pollErr) {
+          setBusyPolling(false);
+          throw pollErr;
+        }
+      } else {
+        if (forcedOs) {
+          setIntentNeedsPick(false);
+          await runIntentHandoff(txn.txn_id, forcedOs);
+          emitEvt(onFlowEvent, { phase: "polling", txnId: txn.txn_id });
+          setBusyPolling(true);
+          try {
+            const raw = await pollTxnUntilTerminal({
+              integrationToken,
+              txnId: txn.txn_id,
+              signal: signal(),
+              pollIntervalMs,
+              deadlineMs: pollDeadlineMs
+            });
+            finishWithSuccess(raw, txn.txn_id);
+          } catch (pollErr) {
+            setBusyPolling(false);
+            throw pollErr;
+          }
+        } else {
+          const inferred = detectIntentPlatform(userAgent);
+          if (inferred.kind === "resolved") {
+            setIntentNeedsPick(false);
+            emitEvt(onFlowEvent, {
+              phase: "txn-created",
+              txnId: txn.txn_id,
+              meta: { kind: "resolved", platform: inferred.platform }
+            });
+            await runIntentHandoff(txn.txn_id, inferred.platform);
+            emitEvt(onFlowEvent, { phase: "polling", txnId: txn.txn_id });
+            setBusyPolling(true);
+            try {
+              const raw = await pollTxnUntilTerminal({
+                integrationToken,
+                txnId: txn.txn_id,
+                signal: signal(),
+                pollIntervalMs,
+                deadlineMs: pollDeadlineMs
+              });
+              finishWithSuccess(raw, txn.txn_id);
+            } catch (pollErr) {
+              setBusyPolling(false);
+              throw pollErr;
+            }
+          } else {
+            emitEvt(onFlowEvent, {
+              phase: "txn-created",
+              txnId: txn.txn_id,
+              meta: { kind: "ambiguous-choice" }
+            });
+            setIntentNeedsPick(true);
+          }
+        }
+      }
+      setBusyConsent(false);
+    } catch (e) {
+      setBusyConsent(false);
+      setBusyPolling(false);
+      if (e?.name === "AbortError") return;
+      const msg = e instanceof Error ? e.message : String(e);
+      setFatalError(msg);
+      emitEvt(onFlowEvent, { phase: "failed", error: e });
+      onError?.(e);
+    }
+  };
+  const handlePickIntent = (os) => async () => {
+    if (!txnIdDisplay) return;
+    await finalizeIntentAndPoll(txnIdDisplay, os);
+  };
+  const handleCopyIntent = async () => {
+    try {
+      if (!intentUrl) return;
+      await navigator.clipboard.writeText(intentUrl);
+    } catch {
+    }
+  };
+  const handleClosePressed = () => {
+    emitEvt(onFlowEvent, { phase: "cancelled" });
+    flowAbortRef.current.abort();
+    const close = onRequestClose;
+    queueMicrotask(() => {
+      close?.();
+      if (close === void 0) {
+        setFlowDismissed(true);
+      }
+    });
+  };
+  const shellClass = displayMode === "modal" ? "snap-consent-handoff_overlay" : "snap-consent-handoff_inline";
+  const headingFallback = agreementEnvelope?.data.name ?? "Consent";
+  if (flowDismissed) {
+    return null;
+  }
+  return /* @__PURE__ */ (0, import_jsx_runtime4.jsx)("div", { className: "snap-consent-handoff", style: themeCss, children: /* @__PURE__ */ (0, import_jsx_runtime4.jsx)("div", { className: shellClass, "data-testid": "snap-consent-handoff-shell", children: /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)("div", { className: "snap-consent-handoff_body", children: [
+    /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)(
+      "div",
+      {
+        ref: sheetRef,
+        className: "snap-consent-handoff_sheet",
+        role: "dialog",
+        "aria-modal": displayMode === "modal",
+        children: [
+          /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)("header", { className: "snap-consent-handoff_hdr", children: [
+            /* @__PURE__ */ (0, import_jsx_runtime4.jsx)("h2", { className: "snap-consent-handoff_title", children: title ?? headingFallback }),
+            displayMode === "modal" ? /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(
+              "button",
+              {
+                type: "button",
+                className: "snap-consent-handoff_btnIcon",
+                "aria-label": "Close",
+                "data-testid": "snap-consent-handoff-close",
+                onClick: handleClosePressed,
+                children: "\xD7"
+              }
+            ) : null
+          ] }),
+          completed ? /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)("div", { className: "snap-consent-handoff_done", "data-testid": "snap-consent-handoff-done", children: [
+            /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(FlowErrorBoundary, { children: /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(TxnSuccessPanel, { status: normalizeTxnStatusPayload(completed.raw) }) }),
+            /* @__PURE__ */ (0, import_jsx_runtime4.jsx)("div", { className: "snap-consent-handoff_actions", children: /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(
+              "button",
+              {
+                type: "button",
+                className: "snap-consent-handoff_btnPrimary",
+                "data-testid": "snap-consent-handoff-done-button",
+                onClick: handleClosePressed,
+                children: "Done"
+              }
+            ) })
+          ] }) : null,
+          !completed && fatalError ? /* @__PURE__ */ (0, import_jsx_runtime4.jsx)("div", { className: "snap-consent-handoff_err", children: fatalError }) : null,
+          !completed && loadingAgreement ? /* @__PURE__ */ (0, import_jsx_runtime4.jsx)("div", { "aria-busy": true, children: "Loading agreement\u2026" }) : null,
+          !completed && agreementEnvelope ? /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)("div", { "aria-live": "polite", children: [
+            agreementHtml ? (
+              // eslint-disable-next-line react/no-danger -- sanitized via DOMPurify
+              /* @__PURE__ */ (0, import_jsx_runtime4.jsx)("article", { className: "snap-consent-handoff_notice", dangerouslySetInnerHTML: { __html: agreementHtml } })
+            ) : null,
+            !txnIdDisplay ? /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)("section", { children: [
+              /* @__PURE__ */ (0, import_jsx_runtime4.jsx)("h3", { className: "snap-consent-handoff_headingSm", children: "Consent Required" }),
+              /* @__PURE__ */ (0, import_jsx_runtime4.jsx)("div", { className: "snap-consent-handoff_list", children: selectable.map((row) => {
+                const rowDisabled = busyConsent || busyPolling || loadingAgreement;
+                return /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)(
+                  "label",
+                  {
+                    className: [
+                      "snap-consent-handoff_row",
+                      selectedPurposesMap[row.id] ? "snap-consent-handoff_row--selected" : "",
+                      rowDisabled ? "snap-consent-handoff_row--disabled" : ""
+                    ].filter(Boolean).join(" "),
+                    htmlFor: `purpose-${row.id}`,
+                    children: [
+                      /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(
+                        "input",
+                        {
+                          id: `purpose-${row.id}`,
+                          type: "checkbox",
+                          checked: Boolean(selectedPurposesMap[row.id]),
+                          disabled: busyConsent || busyPolling || loadingAgreement,
+                          onChange: (e) => setSelectedPurposesMap((prev) => ({
+                            ...prev,
+                            [row.id]: e.target.checked
+                          }))
+                        }
+                      ),
+                      /* @__PURE__ */ (0, import_jsx_runtime4.jsx)("div", { style: { fontWeight: 600 }, children: row.label })
+                    ]
+                  },
+                  row.id
+                );
+              }) }),
+              /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)("div", { className: "snap-consent-handoff_actions snap-consent-handoff_actions--split", children: [
+                /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(
+                  "button",
+                  {
+                    type: "button",
+                    className: "snap-consent-handoff_btnSecondary",
+                    "data-testid": "snap-consent-handoff-cancel",
+                    disabled: busyConsent || busyPolling || loadingAgreement,
+                    onClick: handleClosePressed,
+                    children: "Cancel"
+                  }
+                ),
+                /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(
+                  "button",
+                  {
+                    type: "button",
+                    className: "snap-consent-handoff_btnPrimary",
+                    "data-testid": "snap-consent-handoff-submit",
+                    disabled: busyConsent || busyPolling || loadingAgreement,
+                    onClick: () => void handleContinueConsent(),
+                    children: "I Agree"
+                  }
+                )
+              ] })
+            ] }) : null,
+            txnIdDisplay ? /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)("section", { style: { marginTop: "14px" }, "data-testid": "snap-consent-handoff-active-txn", children: [
+              handoffMode === "intent" ? /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(import_jsx_runtime4.Fragment, { children: intentNeedsPick ? /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)("div", { className: "snap-consent-handoff_intents", role: "group", "aria-label": "Choose OS", children: [
+                /* @__PURE__ */ (0, import_jsx_runtime4.jsx)("p", { className: "snap-consent-handoff_muted", children: "Automatic platform detection couldn\u2019t confidently choose Android vs iOS. Pick yours:" }),
+                /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(
+                  "button",
+                  {
+                    type: "button",
+                    className: "snap-consent-handoff_btnPrimary",
+                    onClick: () => void handlePickIntent("android")(),
+                    disabled: busyConsent || busyPolling,
+                    children: "Continue with Android"
+                  }
+                ),
+                /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(
+                  "button",
+                  {
+                    type: "button",
+                    className: "snap-consent-handoff_btnPrimary",
+                    onClick: () => void handlePickIntent("ios")(),
+                    disabled: busyConsent || busyPolling,
+                    children: "Continue with iPhone / iPad"
+                  }
+                )
+              ] }) : intentUrl ? /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)("div", { children: [
+                /* @__PURE__ */ (0, import_jsx_runtime4.jsx)("textarea", { readOnly: true, value: intentUrl, className: "snap-consent-handoff_codeBox" }),
+                /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)("div", { className: "snap-consent-handoff_actions", children: [
+                  /* @__PURE__ */ (0, import_jsx_runtime4.jsx)("button", { type: "button", className: "snap-consent-handoff_btnSecondary", onClick: () => void handleCopyIntent(), children: "Copy deeplink" }),
+                  /* @__PURE__ */ (0, import_jsx_runtime4.jsx)("a", { className: "snap-consent-handoff_btnSecondary", href: intentUrl, style: { textDecoration: "none" }, children: "Open app" })
+                ] }),
+                /* @__PURE__ */ (0, import_jsx_runtime4.jsx)("p", { className: "snap-consent-handoff_muted", style: { fontSize: "12px" }, children: "Some in-app browsers block custom-url schemes \u2014 use Safari/Chrome where possible." }),
+                (busyConsent || busyPolling) && intentUrl ? /* @__PURE__ */ (0, import_jsx_runtime4.jsx)("div", { className: "snap-consent-handoff_notice", "aria-live": "polite", children: busyPolling ? "Polling transaction status..." : "" }) : null
+              ] }) : busyConsent ? /* @__PURE__ */ (0, import_jsx_runtime4.jsx)("div", { children: "Preparing app link..." }) : busyPolling ? /* @__PURE__ */ (0, import_jsx_runtime4.jsx)("div", { children: "Waiting on device handshake..." }) : null }) : null,
+              handoffMode === "qr" ? qrObjectUrl ? /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)("figure", { className: "snap-consent-handoff_qr", "data-testid": "snap-consent-handoff-qr", children: [
+                /* @__PURE__ */ (0, import_jsx_runtime4.jsx)("img", { alt: "QR code", src: qrObjectUrl }),
+                /* @__PURE__ */ (0, import_jsx_runtime4.jsxs)("figcaption", { className: "snap-consent-handoff_muted", children: [
+                  "Scan with your authorised app to proceed.",
+                  busyPolling ? " Listening for confirmation..." : null
+                ] })
+              ] }) : busyConsent ? /* @__PURE__ */ (0, import_jsx_runtime4.jsx)("div", { children: "Generating QR..." }) : busyPolling ? /* @__PURE__ */ (0, import_jsx_runtime4.jsx)("div", { children: "Waiting for scanned confirmation..." }) : null : null
+            ] }) : null
+          ] }) : null
+        ]
+      }
+    ),
+    /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(PoweredBySnapKyc, {})
+  ] }) }) });
+}
+
+// src/react/openSnapConsentHandoffFlow.tsx
+var import_react4 = require("react");
+var import_client2 = require("react-dom/client");
+var import_jsx_runtime5 = require("react/jsx-runtime");
+function openSnapConsentHandoffFlow(options) {
+  if (typeof document === "undefined") {
+    throw new Error("openSnapConsentHandoffFlow requires a browser environment");
+  }
+  const { strict = false, displayMode = "modal", ...flowProps } = options;
+  const mount = document.createElement("div");
+  mount.setAttribute("data-snap-consent-handoff-host", "");
+  const root = (0, import_client2.createRoot)(mount);
+  document.body.appendChild(mount);
+  let disposed = false;
+  function dispose() {
+    if (disposed) return;
+    disposed = true;
+    try {
+      root.unmount();
+    } finally {
+      mount.remove();
+    }
+  }
+  const element = /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(SnapConsentHandoffFlow, { ...flowProps, displayMode, onRequestClose: () => dispose() });
+  try {
+    root.render(strict ? /* @__PURE__ */ (0, import_jsx_runtime5.jsx)(import_react4.StrictMode, { children: element }) : element);
+  } catch (e) {
+    dispose();
+    throw e instanceof Error ? e : new Error(String(e));
+  }
+  return { dispose };
+}
+var openSnapConsentQrFlow = openSnapConsentHandoffFlow;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  API_ORIGIN,
+  DEFAULT_SNAP_CONSENT_THEME,
+  SnapConsentHandoffFlow,
+  SnapSdkHttpError,
+  demographicAccordionSections,
+  demographicFieldsForDisplay,
+  extractDemographicData,
+  formatDisplayValue,
+  formatPurposeLabel,
+  hasDisplayableDemographics,
+  normalizeTxnStatusPayload,
+  openSnapConsentHandoffFlow,
+  openSnapConsentQrFlow,
+  parseDemographicPayload,
+  resolveSnapConsentTheme,
+  themeToCssProperties
+});
+//# sourceMappingURL=index.cjs.map