@sonordev/site-kit 6.5.0 → 7.0.0

package/dist/SignalCore-S6DO3VQV.js

@@ -0,0 +1,322 @@
+'use client';
+import { getOrCreateVisitorId, getOrCreateSessionId } from './chunk-24QZEO3Q.js';
+import { onPageLeave } from './chunk-L2V5PUFN.js';
+import './chunk-GJWI74ZZ.js';
+import { sonorFetch } from './chunk-4WI3FU5L.js';
+import { getFreshCredential, isSiteToken } from './chunk-HPUXKMNR.js';
+import './chunk-7ZHJIRM3.js';
+import './chunk-PKBMQBKP.js';
+import { useState, useRef, useEffect, useCallback } from 'react';
+
+function getApiConfig() {
+  const apiUrl = typeof window !== "undefined" ? window.__SITE_KIT_API_URL__ || "https://api.sonor.io" : "https://api.sonor.io";
+  const apiKey = typeof window !== "undefined" ? window.__SITE_KIT_API_KEY__ : void 0;
+  return { apiUrl, apiKey };
+}
+function isDebug() {
+  return typeof window !== "undefined" && !!window.__SITE_KIT_DEBUG__;
+}
+function getDeviceType() {
+  if (typeof window === "undefined") return "desktop";
+  const ua = navigator.userAgent;
+  if (/tablet|ipad|playbook|silk/i.test(ua)) return "tablet";
+  if (/mobile|iphone|ipod|android|blackberry|opera mini|iemobile/i.test(ua)) return "mobile";
+  return "desktop";
+}
+function getBrowser() {
+  if (typeof window === "undefined") return "unknown";
+  const ua = navigator.userAgent;
+  if (ua.includes("Firefox")) return "Firefox";
+  if (ua.includes("Edg")) return "Edge";
+  if (ua.includes("Chrome")) return "Chrome";
+  if (ua.includes("Safari")) return "Safari";
+  return "Other";
+}
+function getOS() {
+  if (typeof window === "undefined") return "unknown";
+  const ua = navigator.userAgent;
+  if (ua.includes("Windows")) return "Windows";
+  if (ua.includes("Mac")) return "macOS";
+  if (ua.includes("iPhone") || ua.includes("iPad")) return "iOS";
+  if (ua.includes("Android")) return "Android";
+  if (ua.includes("Linux")) return "Linux";
+  return "Other";
+}
+function SignalCore({
+  enabled,
+  realtime,
+  experiments,
+  behaviorTracking,
+  externalVisitorId,
+  externalSessionId,
+  pageMetadataRef,
+  onRegister,
+  onState
+}) {
+  const [config, setConfig] = useState(null);
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState(null);
+  const eventSourceRef = useRef(null);
+  const eventQueueRef = useRef([]);
+  const flushTimeoutRef = useRef(null);
+  const assignmentsRef = useRef(/* @__PURE__ */ new Map());
+  const pageLoadTimeRef = useRef(Date.now());
+  const scrollDepthRef = useRef(0);
+  const clickCountRef = useRef(0);
+  const { apiUrl, apiKey } = getApiConfig();
+  const resolvedVisitorId = externalVisitorId || getOrCreateVisitorId();
+  const resolvedSessionId = externalSessionId || getOrCreateSessionId();
+  useEffect(() => {
+    onState({ config, loading, error });
+  }, [config, loading, error, onState]);
+  const loadExperimentAssignment = useCallback(async (experimentId) => {
+    const storageKey = `_signal_exp_${experimentId}`;
+    const stored = localStorage.getItem(storageKey);
+    if (stored) {
+      try {
+        const assignment = JSON.parse(stored);
+        if (assignment.expires > Date.now()) {
+          assignmentsRef.current.set(experimentId, assignment);
+          return assignment;
+        }
+      } catch {
+      }
+    }
+    try {
+      const response = await sonorFetch(
+        `${apiUrl}/api/public/signal/experiment/${experimentId}`,
+        {
+          headers: {
+            "x-visitor-id": resolvedVisitorId
+          }
+        },
+        { apiKey }
+      );
+      if (!response.ok) return null;
+      const assignment = await response.json();
+      localStorage.setItem(storageKey, JSON.stringify(assignment));
+      assignmentsRef.current.set(experimentId, assignment);
+      return assignment;
+    } catch (err) {
+      if (isDebug()) console.error("[Signal] Experiment assignment error:", err);
+      return null;
+    }
+  }, [apiUrl, apiKey]);
+  const getExperiment = useCallback((experimentId) => {
+    return assignmentsRef.current.get(experimentId) || null;
+  }, []);
+  const fetchConfig = useCallback(async () => {
+    if (!apiKey || !enabled) {
+      setLoading(false);
+      return;
+    }
+    try {
+      const response = await sonorFetch(
+        `${apiUrl}/api/public/signal/config`,
+        {
+          headers: {
+            "x-visitor-id": resolvedVisitorId
+          }
+        },
+        { apiKey }
+      );
+      if (!response.ok) {
+        throw new Error(`Failed to fetch Signal config: ${response.statusText}`);
+      }
+      const data = await response.json();
+      setConfig(data.config);
+      setError(null);
+      if (experiments && data.config?.experiments) {
+        for (const exp of data.config.experiments) {
+          if (exp.status === "running") {
+            await loadExperimentAssignment(exp.id);
+          }
+        }
+      }
+    } catch (err) {
+      if (isDebug()) console.error("[Signal] Config fetch error:", err);
+      setError(err);
+    } finally {
+      setLoading(false);
+    }
+  }, [apiUrl, apiKey, enabled, experiments, resolvedVisitorId, loadExperimentAssignment]);
+  const connectSSE = useCallback(() => {
+    if (!apiKey || !enabled || !realtime) return;
+    if (eventSourceRef.current) {
+      eventSourceRef.current.close();
+      eventSourceRef.current = null;
+    }
+    void (async () => {
+      const credential = await getFreshCredential(apiKey);
+      if (!credential || !isSiteToken(credential)) {
+        if (isDebug()) {
+          console.warn("[Signal] Realtime stream disabled: requires site-token mode (raw keys never go in URLs)");
+        }
+        return;
+      }
+      if (eventSourceRef.current) return;
+      const url = `${apiUrl}/api/public/signal/stream?token=${encodeURIComponent(credential)}`;
+      connectEventSource(url);
+    })();
+    function connectEventSource(url) {
+      const eventSource = new EventSource(url);
+      eventSource.addEventListener("config_update", (e) => {
+        try {
+          const { config: newConfig, version } = JSON.parse(e.data);
+          setConfig((prev) => {
+            if (prev?.version !== version) {
+              if (isDebug()) console.log("[Signal] Config updated to version:", version);
+              return newConfig;
+            }
+            return prev;
+          });
+        } catch (err) {
+          if (isDebug()) console.error("[Signal] SSE parse error:", err);
+        }
+      });
+      eventSource.addEventListener("experiment_update", (e) => {
+        try {
+          const { experiment_id, action } = JSON.parse(e.data);
+          if (action === "started" || action === "updated") {
+            loadExperimentAssignment(experiment_id);
+          } else if (action === "stopped") {
+            assignmentsRef.current.delete(experiment_id);
+          }
+        } catch (err) {
+          if (isDebug()) console.error("[Signal] Experiment update error:", err);
+        }
+      });
+      eventSource.onerror = () => {
+        if (isDebug()) console.warn("[Signal] SSE connection error, reconnecting...");
+        eventSource.close();
+        if (eventSourceRef.current === eventSource) {
+          eventSourceRef.current = null;
+        }
+        setTimeout(connectSSE, 5e3);
+      };
+      eventSourceRef.current = eventSource;
+    }
+  }, [apiUrl, apiKey, enabled, realtime, loadExperimentAssignment]);
+  const flushEvents = useCallback(async () => {
+    if (eventQueueRef.current.length === 0) return;
+    const events = [...eventQueueRef.current];
+    eventQueueRef.current = [];
+    try {
+      await sonorFetch(
+        `${apiUrl}/api/public/signal/events`,
+        {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({
+            visitor_id: resolvedVisitorId,
+            session_id: resolvedSessionId,
+            events
+          })
+        },
+        { apiKey, retries: 0 }
+      );
+    } catch (err) {
+      eventQueueRef.current = [...events, ...eventQueueRef.current];
+      if (isDebug()) console.error("[Signal] Event flush error:", err);
+    }
+  }, [apiUrl, apiKey]);
+  const trackEvent = useCallback((event) => {
+    if (!enabled || !apiKey) return;
+    const enrichedEvent = {
+      ...event,
+      page_url: window.location.href,
+      page_path: window.location.pathname,
+      referrer: document.referrer,
+      device_type: getDeviceType(),
+      browser: getBrowser(),
+      os: getOS(),
+      viewport_width: window.innerWidth,
+      viewport_height: window.innerHeight,
+      time_on_page: Date.now() - pageLoadTimeRef.current,
+      scroll_depth: scrollDepthRef.current,
+      click_count: clickCountRef.current,
+      experiments: Array.from(assignmentsRef.current.values()).map((a) => ({
+        experiment_id: a.experiment_id,
+        variant_key: a.variant_key
+      })),
+      // Merge page metadata from Analytics if available
+      page_metadata: pageMetadataRef?.current ?? void 0,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    eventQueueRef.current.push(enrichedEvent);
+    if (flushTimeoutRef.current) {
+      clearTimeout(flushTimeoutRef.current);
+    }
+    flushTimeoutRef.current = setTimeout(flushEvents, 1e3);
+  }, [enabled, apiKey, flushEvents]);
+  const trackOutcome = useCallback(async (outcome) => {
+    if (!enabled || !apiKey) return;
+    try {
+      await sonorFetch(
+        `${apiUrl}/api/public/signal/outcome`,
+        {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({
+            ...outcome,
+            visitor_id: resolvedVisitorId,
+            session_id: resolvedSessionId,
+            experiments: Array.from(assignmentsRef.current.keys()),
+            page_url: window.location.href,
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          })
+        },
+        { apiKey, retries: 0 }
+      );
+    } catch (err) {
+      if (isDebug()) console.error("[Signal] Outcome tracking error:", err);
+    }
+  }, [apiUrl, apiKey, enabled]);
+  useEffect(() => {
+    if (!behaviorTracking || typeof window === "undefined") return;
+    const handleScroll = () => {
+      const scrollTop = window.scrollY;
+      const docHeight = document.documentElement.scrollHeight - window.innerHeight;
+      const depth = docHeight > 0 ? Math.round(scrollTop / docHeight * 100) : 0;
+      scrollDepthRef.current = Math.max(scrollDepthRef.current, depth);
+    };
+    const handleClick = () => {
+      clickCountRef.current++;
+    };
+    window.addEventListener("scroll", handleScroll, { passive: true });
+    window.addEventListener("click", handleClick);
+    const stopLeaveListener = onPageLeave(flushEvents);
+    return () => {
+      window.removeEventListener("scroll", handleScroll);
+      window.removeEventListener("click", handleClick);
+      stopLeaveListener();
+    };
+  }, [behaviorTracking, flushEvents]);
+  useEffect(() => {
+    fetchConfig();
+  }, [fetchConfig]);
+  useEffect(() => {
+    if (config && realtime) {
+      connectSSE();
+    }
+    return () => {
+      if (eventSourceRef.current) {
+        eventSourceRef.current.close();
+      }
+    };
+  }, [config, realtime, connectSSE]);
+  useEffect(() => {
+    onRegister({
+      trackEvent,
+      trackOutcome: (outcome) => {
+        void trackOutcome(outcome);
+      },
+      getExperiment,
+      refreshConfig: fetchConfig
+    });
+    return () => onRegister(null);
+  }, [onRegister, trackEvent, trackOutcome, getExperiment, fetchConfig]);
+  return null;
+}
+
+export { SignalCore };

package/dist/SiteDesignReporter-2WZVWJMA.js

@@ -0,0 +1,11 @@
+export { SiteDesignReporter } from './chunk-6ZB3XNAT.js';
+import './chunk-MZFF5F7R.js';
+import './chunk-IHG36STL.js';
+import './chunk-YC7ELZS3.js';
+import './chunk-S22FSH7C.js';
+import './chunk-43OCZ3JA.js';
+import './chunk-EKBEOXTH.js';
+import './chunk-4WI3FU5L.js';
+import './chunk-HPUXKMNR.js';
+import './chunk-7ZHJIRM3.js';
+import './chunk-PKBMQBKP.js';

package/dist/SitemapSync-IKNKPT2G.js

@@ -0,0 +1,8 @@
+export { SitemapSync } from './chunk-R3TOKUDJ.js';
+import './chunk-YVKRYQRG.js';
+import './chunk-43OCZ3JA.js';
+import './chunk-EKBEOXTH.js';
+import './chunk-4WI3FU5L.js';
+import './chunk-HPUXKMNR.js';
+import './chunk-7ZHJIRM3.js';
+import './chunk-PKBMQBKP.js';

package/dist/SitemapSync.d.ts

@@ -29,4 +29,3 @@ interface SitemapSyncProps extends AnalyticsGateOptions {
 }
 export declare function SitemapSync({ sitemapUrl, syncInterval, debug, mode, apiUrl: propApiUrl, apiKey: propApiKey, allowInFrame, allowLocalhost, }: SitemapSyncProps): null;
 export {};
-//# sourceMappingURL=SitemapSync.d.ts.map

package/dist/_client/booking-widget.d.ts

@@ -0,0 +1,4 @@
+import * as React from 'react';
+import type { BookingWidgetProps } from '../sync/types';
+export declare function BookingWidget({ orgSlug, apiKey: propApiKey, apiUrl: propApiUrl, bookingTypeSlug, timezone: propTimezone, className, daysToShow, onBookingComplete, onError, hideTypeSelector, autoSelectFirstDay, styles, }: BookingWidgetProps): React.JSX.Element;
+export default BookingWidget;

package/dist/_client/booking-widget.js

@@ -0,0 +1,7 @@
+'use client';
+export { BookingWidget, BookingWidget_default as default } from '../chunk-OO2GZ272.js';
+import '../chunk-M4ZY2FVB.js';
+import '../chunk-4WI3FU5L.js';
+import '../chunk-HPUXKMNR.js';
+import '../chunk-7ZHJIRM3.js';
+import '../chunk-PKBMQBKP.js';

package/dist/_client/testimonial-section.d.ts

@@ -0,0 +1,11 @@
+/**
+ * @sonordev/site-kit/reputation - Testimonial Section
+ *
+ * Displays client reviews in a rotating carousel
+ * Fetches published reviews from Portal API public endpoint
+ *
+ * Minimal styling - let site CSS control appearance
+ */
+import React from 'react';
+import type { TestimonialSectionProps } from '../reputation/types';
+export declare function TestimonialSection({ title, subtitle, autoplay, autoplayInterval, showRating, maxReviews, featuredOnly, service, className, }: TestimonialSectionProps): React.JSX.Element | null;

package/dist/_client/testimonial-section.js

@@ -0,0 +1,5 @@
+'use client';
+export { TestimonialSection } from '../chunk-BR4ZKUHH.js';
+import '../chunk-EDYHROQ7.js';
+import '../chunk-MH2DSGC6.js';
+import '../chunk-PKBMQBKP.js';

package/dist/admin-auth/index.d.ts

@@ -114,4 +114,3 @@ export declare function createSonorSso(config: SonorSsoConfig): {
     homePath: string;
 };
 export type SonorSso = ReturnType<typeof createSonorSso>;
-//# sourceMappingURL=index.d.ts.map

package/dist/admin-auth/session.d.ts

@@ -29,4 +29,3 @@ export declare function signSession(identity: {
  * misconfigured deploy sends people to the login page instead of 500-ing.
  */
 export declare function verifySessionToken(token: string | null | undefined, secret: string | undefined, now?: number): Promise<SonorSession | null>;
-//# sourceMappingURL=session.d.ts.map

package/dist/affiliates/AffiliatesWidget.d.ts

@@ -59,4 +59,3 @@ export interface AffiliatesWidgetProps {
  * ```
  */
 export declare function AffiliatesWidget({ className, loadingComponent, emptyComponent, errorComponent, showOffers, renderAffiliate, limit, }: AffiliatesWidgetProps): string | number | bigint | true | React.JSX.Element | Iterable<React.ReactNode> | Promise<string | number | bigint | boolean | Iterable<React.ReactNode> | React.ReactElement<unknown, string | React.JSXElementConstructor<any>> | React.ReactPortal | null | undefined> | null;
-//# sourceMappingURL=AffiliatesWidget.d.ts.map

package/dist/affiliates/api.d.ts

@@ -25,4 +25,3 @@ export declare function fetchAffiliates(options?: FetchAffiliatesOptions): Promi
  * ```
  */
 export declare function getTrackingUrl(affiliateId: string, offerId: string): string;
-//# sourceMappingURL=api.d.ts.map

package/dist/affiliates/index.d.ts

@@ -9,4 +9,3 @@ export { useAffiliates } from './useAffiliates';
 export type { UseAffiliatesResult } from './useAffiliates';
 export { AffiliatesWidget, AffiliateCard } from './AffiliatesWidget';
 export type { AffiliatesWidgetProps, AffiliateCardProps } from './AffiliatesWidget';
-//# sourceMappingURL=index.d.ts.map

package/dist/affiliates/index.js

@@ -0,0 +1,149 @@
+'use client';
+import { sonorFetch } from '../chunk-4WI3FU5L.js';
+import '../chunk-HPUXKMNR.js';
+import '../chunk-7ZHJIRM3.js';
+import '../chunk-PKBMQBKP.js';
+import { useState, useEffect } from 'react';
+import { jsx, jsxs } from 'react/jsx-runtime';
+
+// src/affiliates/api.ts
+function getApiConfig() {
+  const apiUrl = typeof window !== "undefined" ? window.__SITE_KIT_API_URL__ || "https://api.sonor.io" : "https://api.sonor.io";
+  const apiKey = typeof window !== "undefined" ? window.__SITE_KIT_API_KEY__ || "" : "";
+  return { apiUrl, apiKey };
+}
+async function apiGet(endpoint) {
+  const { apiUrl, apiKey } = getApiConfig();
+  if (!apiKey) {
+    console.error("[Affiliates] No API key configured");
+    return null;
+  }
+  try {
+    const response = await sonorFetch(
+      `${apiUrl}${endpoint}`,
+      { method: "GET" },
+      { apiKey, retries: 0 }
+    );
+    if (!response.ok) {
+      console.error(`[Affiliates] API error: ${response.statusText}`);
+      return null;
+    }
+    return await response.json();
+  } catch (error) {
+    console.error("[Affiliates] Network error:", error);
+    return null;
+  }
+}
+async function fetchAffiliates(options = {}) {
+  const result = await apiGet(
+    "/api/public/affiliates"
+  );
+  return result?.affiliates || [];
+}
+function getTrackingUrl(affiliateId, offerId) {
+  const { apiUrl } = getApiConfig();
+  return `${apiUrl}/a/${affiliateId}/${offerId}`;
+}
+function useAffiliates() {
+  const [affiliates, setAffiliates] = useState([]);
+  const [isLoading, setIsLoading] = useState(true);
+  const [error, setError] = useState(null);
+  useEffect(() => {
+    async function load() {
+      try {
+        setIsLoading(true);
+        setError(null);
+        const data = await fetchAffiliates();
+        setAffiliates(data);
+      } catch (err) {
+        setError(err instanceof Error ? err.message : "Failed to load affiliates");
+      } finally {
+        setIsLoading(false);
+      }
+    }
+    load();
+  }, []);
+  return {
+    affiliates,
+    isLoading,
+    error,
+    getTrackingUrl
+  };
+}
+function AffiliateCard({
+  affiliate,
+  className = "",
+  renderLogo,
+  showOffers = false
+}) {
+  const { getTrackingUrl: getTrackingUrl2 } = useAffiliates();
+  const defaultLogo = /* @__PURE__ */ jsx("div", { "data-affiliate-logo": true, className: "affiliate-logo", children: affiliate.logo_url ? /* @__PURE__ */ jsx(
+    "img",
+    {
+      src: affiliate.logo_url,
+      alt: affiliate.name,
+      loading: "lazy"
+    }
+  ) : /* @__PURE__ */ jsx("span", { children: affiliate.name.charAt(0) }) });
+  return /* @__PURE__ */ jsxs("div", { className, "data-affiliate-card": true, "data-affiliate-id": affiliate.id, children: [
+    renderLogo ? renderLogo(affiliate) : defaultLogo,
+    /* @__PURE__ */ jsx("div", { "data-affiliate-name": true, className: "affiliate-name", children: affiliate.name }),
+    affiliate.website_url && /* @__PURE__ */ jsx(
+      "a",
+      {
+        href: affiliate.website_url,
+        target: "_blank",
+        rel: "noopener noreferrer sponsored",
+        "data-affiliate-website": true,
+        className: "affiliate-website",
+        children: "Visit Website"
+      }
+    ),
+    showOffers && affiliate.offers && affiliate.offers.length > 0 && /* @__PURE__ */ jsx("div", { "data-affiliate-offers": true, className: "affiliate-offers", children: affiliate.offers.map((offer) => /* @__PURE__ */ jsx(
+      "a",
+      {
+        href: getTrackingUrl2(affiliate.id, offer.id),
+        target: "_blank",
+        rel: "noopener noreferrer sponsored",
+        "data-affiliate-offer": true,
+        "data-offer-id": offer.id,
+        className: "affiliate-offer",
+        children: offer.name
+      },
+      offer.id
+    )) })
+  ] });
+}
+function AffiliatesWidget({
+  className = "",
+  loadingComponent,
+  emptyComponent,
+  errorComponent,
+  showOffers = false,
+  renderAffiliate,
+  limit
+}) {
+  const { affiliates, isLoading, error, getTrackingUrl: getTrackingUrl2 } = useAffiliates();
+  if (isLoading) {
+    return loadingComponent || /* @__PURE__ */ jsx("div", { "data-affiliates-loading": true, children: "Loading affiliates..." });
+  }
+  if (error) {
+    return errorComponent || /* @__PURE__ */ jsx("div", { "data-affiliates-error": true, children: error });
+  }
+  const displayAffiliates = limit ? affiliates.slice(0, limit) : affiliates;
+  if (displayAffiliates.length === 0) {
+    return emptyComponent || null;
+  }
+  return /* @__PURE__ */ jsx("div", { className, "data-affiliates-widget": true, children: displayAffiliates.map(
+    (affiliate) => renderAffiliate ? renderAffiliate(affiliate) : /* @__PURE__ */ jsx(
+      AffiliateCard,
+      {
+        affiliate,
+        showOffers
+      },
+      affiliate.id
+    )
+  ) });
+}
+
+export { AffiliateCard, AffiliatesWidget, fetchAffiliates, getTrackingUrl, useAffiliates };

package/dist/affiliates/types.d.ts

@@ -30,4 +30,3 @@ export interface FetchAffiliatesOptions {
     status?: 'active' | 'paused';
     includeOffers?: boolean;
 }
-//# sourceMappingURL=types.d.ts.map

package/dist/affiliates/useAffiliates.d.ts

@@ -31,4 +31,3 @@ export interface UseAffiliatesResult {
  * ```
  */
 export declare function useAffiliates(): UseAffiliatesResult;
-//# sourceMappingURL=useAffiliates.d.ts.map

package/dist/analytics/AnalyticsProvider.d.ts

@@ -60,4 +60,3 @@ export declare function useTrackEvent(): {
     trackConversion: (options: TrackConversionOptions) => void;
 };
 export {};
-//# sourceMappingURL=AnalyticsProvider.d.ts.map

package/dist/analytics/WebVitals.d.ts

@@ -41,4 +41,3 @@ interface WebVitalsProps {
 }
 export declare function WebVitals({ apiUrl: propApiUrl, apiKey: propApiKey, site: propSite, allowInFrame, allowLocalhost, debug, visitorId, sessionId, sessionTimeout, }: WebVitalsProps): null;
 export {};
-//# sourceMappingURL=WebVitals.d.ts.map

package/dist/analytics/dispatch.d.ts

@@ -32,4 +32,3 @@ export declare function trackEvent(options: TrackEventOptions): void;
 /** Conversion twin of {@link trackEvent}. */
 export declare function trackConversion(options: TrackConversionOptions): void;
 export {};
-//# sourceMappingURL=dispatch.d.ts.map

package/dist/analytics/index.d.ts

@@ -9,4 +9,3 @@ export { WebVitals } from './WebVitals';
 export { isCrossOriginFrame, isFramed, isTopFrameSameOrigin } from './send-gate';
 export { useContactTracking, ContactTracking } from './useContactTracking';
 export * from './types';
-//# sourceMappingURL=index.d.ts.map