cdp-edge 2.3.9 → 2.5.2

package/dist/sdk/cdpTrack.js

@@ -0,0 +1,2095 @@
+/*!
+ * CDP Edge SDK v2.5.1
+ * (c) 2026 CDP Edge — Quantum Tracking
+ * Gerado em: 2026-04-15T01:32:42.616Z
+ * Endpoint padrão: /track (mesmo domínio — anti-adblock)
+ */
+"use strict";
+var cdpTrack = (() => {
+  var __defProp = Object.defineProperty;
+  var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+  var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __esm = (fn, res) => function __init() {
+    return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+  };
+  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);
+
+  // models/scenarios/behavior-engine.js
+  var behavior_engine_exports = {};
+  __export(behavior_engine_exports, {
+    default: () => behavior_engine_default
+  });
+  var BehaviorEngine, behavior_engine_default;
+  var init_behavior_engine = __esm({
+    "models/scenarios/behavior-engine.js"() {
+      "use strict";
+      BehaviorEngine = {
+        config: {
+          rageClickThreshold: 3,
+          rageClickTime: 700,
+          // ms
+          idleThreshold: 6e4,
+          // 60s
+          scoreThresholds: {
+            engaged: 40,
+            highIntent: 80
+          }
+        },
+        state: {
+          clickHistory: [],
+          startTime: Date.now(),
+          lastActivity: Date.now(),
+          lastPulse: Date.now(),
+          isIdle: false,
+          formStartTime: {},
+          userScore: 0,
+          firedScoreEvents: /* @__PURE__ */ new Set(),
+          abVariant: null
+        },
+        init() {
+          this.setupRageClicks();
+          this.setupVisibility();
+          this.setupHeartbeat();
+          this.setupScroll();
+          this.setupVideoTracking();
+          this.setupFormAnalytics();
+          this.setupFormAbandonment();
+          this.setupCopyPaste();
+          this.setupExitIntent();
+          this.setupOutboundLinks();
+          this.setupErrorTracking();
+          this.setupIdleDetection();
+          this.setupScoring();
+          this.setupABTesting();
+          console.log("[CDP Edge] Enterprise Behavior Engine Initialized");
+        },
+        // 0.1 A/B Testing (Mode 1 - Edge Sync)
+        setupABTesting() {
+          const getCookie = (name) => {
+            const value = `; ${document.cookie}`;
+            const parts = value.split(`; ${name}=`);
+            if (parts.length === 2) return parts.pop().split(";").shift();
+          };
+          const urlParams = new URLSearchParams(window.location.search);
+          this.state.abVariant = urlParams.get("cdp_variant") || getCookie("cdp_ab_variant") || "original";
+          console.log(`[CDP Edge] A/B Variant Detected: ${this.state.abVariant}`);
+          const originalTrack = cdpTrack.track;
+          cdpTrack.track = (eventName, eventParams = {}) => {
+            const enrichedParams = {
+              ...eventParams,
+              ab_test_variant: this.state.abVariant,
+              user_score: this.state.userScore
+            };
+            return originalTrack.apply(cdpTrack, [eventName, enrichedParams]);
+          };
+        },
+        // 0. Scoring Engine (Internal)
+        setupScoring() {
+          console.log("[CDP Edge] Scoring Engine Online");
+        },
+        addScore(points, reason) {
+          this.state.userScore = Math.min(100, Math.max(0, this.state.userScore + points));
+          console.log(`[CDP Edge] Score Update: +${points} (${reason}) | Total: ${this.state.userScore}`);
+          if (this.state.userScore >= this.config.scoreThresholds.highIntent && !this.state.firedScoreEvents.has("highIntent")) {
+            this.state.firedScoreEvents.add("highIntent");
+            cdpTrack.track("High_Intent_Lead", { score: this.state.userScore, meta_intensity: "high" });
+          } else if (this.state.userScore >= this.config.scoreThresholds.engaged && !this.state.firedScoreEvents.has("engaged")) {
+            this.state.firedScoreEvents.add("engaged");
+            cdpTrack.track("Engaged_User", { score: this.state.userScore, meta_intensity: "medium" });
+          }
+        },
+        // 1. Rage Click Detector
+        setupRageClicks() {
+          document.addEventListener("click", (e) => {
+            const now = Date.now();
+            this.state.clickHistory.push(now);
+            this.state.clickHistory = this.state.clickHistory.filter((t) => now - t < this.config.rageClickTime);
+            if (this.state.clickHistory.length >= this.config.rageClickThreshold) {
+              cdpTrack.track("rage_click", {
+                element_id: e.target.id || "",
+                element_class: e.target.className || "",
+                x: e.pageX,
+                y: e.pageY,
+                meta_intensity: "low"
+                // Envia sinal leve para Meta
+              });
+              this.addScore(-10, "rage_click");
+              this.state.clickHistory = [];
+            }
+          });
+        },
+        // 1.2 Scroll Depth (Quantum Tier)
+        setupScroll() {
+          const markers = [25, 50, 75, 90];
+          const fired = /* @__PURE__ */ new Set();
+          window.addEventListener("scroll", () => {
+            const scrollPct = Math.round(window.scrollY / (document.documentElement.scrollHeight - window.innerHeight) * 100);
+            markers.forEach((m) => {
+              if (scrollPct >= m && !fired.has(m)) {
+                fired.add(m);
+                this.addScore(m === 25 ? 5 : m === 50 ? 5 : 10, `scroll_${m}%`);
+                cdpTrack.track("scroll_depth", {
+                  percent: m,
+                  meta_intensity: m >= 50 ? "medium" : "low"
+                  // Envia como sinal mais forte após 50%
+                });
+              }
+            });
+          }, { passive: true });
+        },
+        // 2. Tab Visibility (VSL Focus)
+        setupVisibility() {
+          document.addEventListener("visibilitychange", () => {
+            const status = document.visibilityState;
+            cdpTrack.track("tab_visibility_change", {
+              status,
+              time_since_start: Math.floor((Date.now() - this.state.startTime) / 1e3),
+              meta_intensity: status === "visible" ? "high" : "low"
+            });
+          });
+        },
+        // 3. Click Heatmap (D1 Only)
+        setupHeatmap() {
+          document.addEventListener("click", (e) => {
+            if (typeof cdpTrack.sendServerEvent === "function") {
+              cdpTrack.sendServerEvent("click_heatmap", null, {
+                x: e.pageX,
+                y: e.pageY,
+                element: e.target.tagName.toLowerCase(),
+                id: e.target.id || "",
+                classes: e.target.className || ""
+              });
+            }
+          });
+        },
+        // 4. Retention Pulse (Heartbeat)
+        setupHeartbeat() {
+          setInterval(() => {
+            const activeTime = Math.floor((Date.now() - this.state.startTime) / 1e3);
+            cdpTrack.track("pulse_heartbeat", {
+              duration_seconds: activeTime,
+              is_visible: document.visibilityState === "visible"
+            });
+          }, this.config.heartbeatInterval);
+        },
+        // 5. VSL / Video Tracking (YouTube & Vimeo)
+        setupVideoTracking() {
+          const iframes = document.querySelectorAll("iframe");
+          const fired = /* @__PURE__ */ new Set();
+          iframes.forEach((iframe) => {
+            const src = iframe.src || "";
+            const isYT = src.includes("youtube.com/embed");
+            const isVimeo = src.includes("vimeo.com/video");
+            if (isYT || isVimeo) {
+              window.addEventListener("message", (event) => {
+                try {
+                  const data = typeof event.data === "string" ? JSON.parse(event.data) : event.data;
+                  if (isYT && data.event === "infoDelivery" && data.info && data.info.currentTime) {
+                    this.handleVideoProgress(iframe, data.info.currentTime, data.info.duration, fired, "YouTube");
+                  }
+                  if (isVimeo && data.event === "timeupdate") {
+                    this.handleVideoProgress(iframe, data.data.seconds, data.data.duration, fired, "Vimeo");
+                  }
+                } catch (e) {
+                }
+              });
+              if (isYT && !src.includes("enablejsapi=1")) {
+                const url = new URL(src);
+                url.searchParams.set("enablejsapi", "1");
+                iframe.src = url.toString();
+              }
+            }
+          });
+        },
+        handleVideoProgress(iframe, current, total, firedSet, platform) {
+          if (!total) return;
+          const pct = Math.floor(current / total * 100);
+          const milestones = [25, 50, 75, 100];
+          const videoId = iframe.id || iframe.src.split("/").pop().split("?")[0];
+          milestones.forEach((m) => {
+            const key = `${videoId}_${m}`;
+            if (pct >= m && !firedSet.has(key)) {
+              firedSet.add(key);
+              this.addScore(m === 25 ? 10 : m === 50 ? 15 : 25, `vsl_${m}%`);
+              cdpTrack.track("video_milestone", {
+                video_id: videoId,
+                platform,
+                percent: m,
+                meta_intensity: m >= 50 ? "high" : "medium"
+              });
+            }
+          });
+        },
+        // 6. Form Analytics (Friction & Abandonment)
+        setupFormAnalytics() {
+          const inputs = document.querySelectorAll("input, select, textarea");
+          inputs.forEach((input) => {
+            input.addEventListener("focus", () => {
+              const name = input.name || input.id;
+              if (!this.state.formStartTime[name]) {
+                this.state.formStartTime[name] = Date.now();
+                this.addScore(10, `form_interaction_${name}`);
+                cdpTrack.track("form_field_focus", { field: name });
+              }
+            });
+            input.addEventListener("blur", () => {
+              const name = input.name || input.id;
+              const duration = Math.round((Date.now() - this.state.formStartTime[name]) / 1e3);
+              if (duration > 0) {
+                cdpTrack.track("form_field_blur", { field: name, duration_sec: duration });
+              }
+            });
+          });
+        },
+        // 6.1 Form Abandonment — saiu da página após interagir com formulário sem submeter
+        setupFormAbandonment() {
+          const formInteracted = /* @__PURE__ */ new Set();
+          let formSubmitted = false;
+          document.addEventListener("focusin", (e) => {
+            const el = e.target;
+            if (el.tagName === "INPUT" || el.tagName === "TEXTAREA" || el.tagName === "SELECT") {
+              const name = el.name || el.id || el.type;
+              if (name) formInteracted.add(name);
+            }
+          }, true);
+          document.addEventListener("submit", () => {
+            formSubmitted = true;
+          }, true);
+          document.addEventListener("visibilitychange", () => {
+            if (document.visibilityState === "hidden" && formInteracted.size > 0 && !formSubmitted) {
+              this.addScore(-5, "form_abandonment");
+              cdpTrack.track("form_abandonment", {
+                fields_interacted: Array.from(formInteracted),
+                fields_count: formInteracted.size,
+                meta_intensity: "medium",
+                time_on_page: Math.floor((Date.now() - this.state.startTime) / 1e3)
+              });
+            }
+          });
+          window.addEventListener("beforeunload", () => {
+            if (formInteracted.size > 0 && !formSubmitted) {
+              if (navigator.sendBeacon && typeof cdpTrack !== "undefined") {
+                const data = JSON.stringify({
+                  eventName: "form_abandonment",
+                  behavioral_data: { user_score: this.state.userScore },
+                  fields_interacted: Array.from(formInteracted),
+                  fields_count: formInteracted.size,
+                  meta_intensity: "medium"
+                });
+                navigator.sendBeacon("/api/tracking", new Blob([data], { type: "application/json" }));
+              }
+            }
+          });
+        },
+        // 6.2 Exit Intent — mouse saindo pelo topo da viewport
+        setupExitIntent() {
+          let exitFired = false;
+          document.addEventListener("mousemove", (e) => {
+            if (e.clientY < 20 && !exitFired) {
+              exitFired = true;
+              this.addScore(15, "exit_intent");
+              cdpTrack.track("exit_intent", {
+                mouse_y: e.clientY,
+                time_on_page: Math.floor((Date.now() - this.state.startTime) / 1e3),
+                user_score: this.state.userScore,
+                meta_intensity: "high"
+                // Alta intenção — usuário está prestes a sair
+              });
+              setTimeout(() => {
+                exitFired = false;
+              }, 3e4);
+            }
+          }, { passive: true });
+          let mobileExitFired = false;
+          document.addEventListener("visibilitychange", () => {
+            if (document.visibilityState === "hidden" && !mobileExitFired) {
+              const timeOnPage = Math.floor((Date.now() - this.state.startTime) / 1e3);
+              if (timeOnPage > 5) {
+                mobileExitFired = true;
+                cdpTrack.track("exit_intent_mobile", {
+                  time_on_page: timeOnPage,
+                  user_score: this.state.userScore,
+                  meta_intensity: "medium"
+                });
+              }
+            }
+          });
+        },
+        // 7. Copy-Paste Intent (High Conv.)
+        setupCopyPaste() {
+          document.addEventListener("copy", () => {
+            const selectedText = window.getSelection().toString();
+            if (selectedText.length > 0) {
+              this.addScore(20, "text_copy");
+              cdpTrack.track("content_copy", {
+                text_length: selectedText.length,
+                meta_intensity: "medium"
+              });
+            }
+          });
+        },
+        // 8. Outbound Link Tracking (Whitelist: WhatsApp/Checkouts)
+        setupOutboundLinks() {
+          document.addEventListener("click", (e) => {
+            const link = e.target.closest("a");
+            if (link && link.href) {
+              const url = link.href;
+              const isExternal = !url.includes(window.location.hostname);
+              const isWhitelisted = url.includes("wa.me") || url.includes("hotmart.com") || url.includes("kiwify.com") || url.includes("checkout");
+              if (isExternal && isWhitelisted) {
+                this.addScore(100, "outbound_conversion_intent");
+                cdpTrack.track("outbound_click", {
+                  destination: url,
+                  meta_intensity: "high"
+                });
+              }
+            }
+          });
+        },
+        // 9. JS Error Tracking (D1 Only)
+        setupErrorTracking() {
+          window.addEventListener("error", (event) => {
+            if (typeof cdpTrack.sendServerEvent === "function") {
+              cdpTrack.sendServerEvent("js_error", null, {
+                message: event.message,
+                source: event.filename,
+                lineno: event.lineno,
+                colno: event.colno
+              });
+            }
+          });
+        },
+        // 10. Idle Detection (Active Time)
+        setupIdleDetection() {
+          const activityEvents = ["mousedown", "mousemove", "keydown", "scroll", "touchstart"];
+          activityEvents.forEach((evt) => {
+            document.addEventListener(evt, () => {
+              this.state.lastActivity = Date.now();
+              if (this.state.isIdle) {
+                this.state.isIdle = false;
+                cdpTrack.track("user_active", { status: "back_online" });
+              }
+            }, { passive: true });
+          });
+          setInterval(() => {
+            if (Date.now() - this.state.lastActivity > this.config.idleThreshold && !this.state.isIdle) {
+              this.state.isIdle = true;
+              cdpTrack.track("user_idle", { idle_duration: this.config.idleThreshold / 1e3 });
+            }
+          }, 1e4);
+        }
+      };
+      if (typeof cdpTrack !== "undefined") {
+        BehaviorEngine.init();
+      }
+      behavior_engine_default = BehaviorEngine;
+    }
+  });
+
+  // cdpTrack.js
+  var cdpTrack_exports = {};
+  __export(cdpTrack_exports, {
+    generateId: () => generateId,
+    getSessionId: () => getSessionId,
+    getUTMs: () => getUTMs,
+    getUTMsWithFallback: () => getUTMsWithFallback,
+    getUserId: () => getUserId,
+    getUserIdWithFallback: () => getUserIdWithFallback,
+    init: () => init,
+    passCheckoutParams: () => passCheckoutParams,
+    setupAutoFormCapture: () => setupAutoFormCapture,
+    track: () => track,
+    trackAddToCart: () => trackAddToCart,
+    trackLead: () => trackLead,
+    trackPurchase: () => trackPurchase,
+    trackViewContent: () => trackViewContent,
+    updateConsent: () => updateConsent
+  });
+
+  // tracking.config.js
+  var CONFIG = {
+    // ── Endpoint do Cloudflare Worker ────────────────────────────────────────────
+    // Same-domain: evita ad-blockers e CORS.
+    // Em produção: seu-dominio.com.br/track (Worker roteado via Custom Domain)
+    // Em dev: use o URL do Worker diretamente (ex: https://worker.seu-dominio.workers.dev/track)
+    endpoint: "/track",
+    // ── Plataformas de checkout habilitadas ──────────────────────────────────────
+    // Controla quais plataformas recebem passCheckoutParams() automaticamente.
+    // Adicione apenas as plataformas usadas no projeto.
+    platforms: ["hotmart", "kiwify", "eduzz", "monetizze", "cartpanda", "ticto"],
+    // ── Domínio do site ──────────────────────────────────────────────────────────
+    // Usado para cookies first-party e CORS.
+    siteDomain: "",
+    // Ex: 'meusite.com.br' — deixar vazio para auto-detect
+    // ── Debug mode ───────────────────────────────────────────────────────────────
+    // true = loga todos os eventos no console
+    // false = silencioso em produção
+    debug: false,
+    // ── Consent Mode v2 (LGPD/GDPR) ─────────────────────────────────────────────
+    // Padrão: tudo negado. Sites devem chamar cdpTrack.updateConsent() após
+    // o usuário aceitar o banner de cookies.
+    consent: {
+      defaultDenied: true,
+      // inicializa com ad_storage=denied
+      urlPassthrough: true,
+      // preserva gclid/fbclid mesmo sem consent
+      waitForUpdate: 500
+      // ms aguardando CMP antes de disparar hits
+    },
+    // ── Comportamentos automáticos ───────────────────────────────────────────────
+    autoCaptureForms: true,
+    // intercepta formulários de lead automaticamente
+    passCheckoutParams: true,
+    // adiciona UTMs + userId nos links de checkout
+    initBehaviorEngine: true
+    // carrega rage-click, exit intent, form abandonment
+  };
+  var tracking_config_default = CONFIG;
+
+  // micro-events.js
+  var isBrowser = typeof window !== "undefined";
+  var SCROLL_CONFIG = {
+    thresholds: [25, 50, 75, 100],
+    signalStrength: {
+      "25%": 1.5,
+      "50%": 2,
+      "75%": 3,
+      "100%": 4
+    }
+  };
+  var TIME_CONFIG = {
+    thresholds: {
+      curioso: 1e4,
+      // 10 segundos
+      interessado: 6e4,
+      // 60 segundos
+      comprador: 18e4,
+      // 180 segundos (3 minutos)
+      profundao: 60
+    },
+    signalStrength: {
+      curioso: 1,
+      interessado: 2.5,
+      comprador: 4,
+      profundao: 3.5
+    },
+    intentionLevels: {
+      curioso: "curioso",
+      interessado: "interessado",
+      comprador: "comprador",
+      profundao: "profundo"
+    }
+  };
+  var VIDEO_CONFIG = {
+    progressThresholds: [25, 50, 75, 100],
+    // Dropout: captura o segundo exato em que o usuário parou de assistir
+    dropoutEnabled: true,
+    signalStrength: {
+      play: 2,
+      progress25: 3,
+      progress50: 4,
+      progress75: 5,
+      complete: 5,
+      pause: 1,
+      resume: 1.5,
+      seek: 0.5,
+      dropout: 2.5
+      // pausa final — não retomou até sair da página
+    }
+  };
+  var CLICK_CONFIG = {
+    maxRapidClicks: 3,
+    rapidClickWindow: 1e3,
+    // 1 segundo
+    clickCategories: ["button", "link", "input", "cta", "price", "generic"],
+    signalStrength: {
+      button: 2,
+      link: 1.5,
+      cta: 2.5,
+      input: 1,
+      price: 2,
+      generic: 0.5
+    }
+  };
+  var CTA_HOVER_CONFIG = {
+    minHoverTimeForSignal: 3e3,
+    // 3 segundos
+    maxHoverTime: 3e4,
+    // 30 segundos (para evitar overflow)
+    signalStrength: 3
+  };
+  var state = {
+    pageLoadTime: Date.now(),
+    scrollTracking: {
+      lastScrollPercent: 0,
+      trackedThresholds: /* @__PURE__ */ new Set()
+    },
+    timeTracking: {
+      lastCheckTime: Date.now(),
+      currentLevel: "curioso",
+      timeOnPage: 0
+    },
+    // videoTracking: { [videoId]: { playTime, totalWatchTime, lastProgress, started, paused, dropoutPercent, dropoutSecond } }
+    videoTracking: {},
+    // Resumo agregado de todos os vídeos na página (para páginas VSL com múltiplos vídeos)
+    videoSummary: {
+      totalVideos: 0,
+      startedCount: 0,
+      completedCount: 0,
+      maxProgress: 0
+      // maior % atingida entre todos os vídeos
+    },
+    clickTracking: {
+      clicks: [],
+      lastClickTime: 0,
+      rapidClickDetected: false
+    },
+    ctaHoverTracking: {
+      hoverStartTime: null,
+      hoveredElement: null
+    }
+  };
+  function initScrollTracking() {
+    if (!isBrowser) return;
+    const observer = new IntersectionObserver((entries) => {
+      entries.forEach((entry) => {
+        if (!entry.isIntersecting) return;
+        const scrollPercent = Math.round(
+          (window.scrollY + window.innerHeight) / document.body.scrollHeight * 100
+        );
+        SCROLL_CONFIG.thresholds.forEach((threshold) => {
+          const key = `scroll_${threshold}`;
+          if (scrollPercent >= threshold && !state.scrollTracking.trackedThresholds.has(key)) {
+            const signal = SCROLL_CONFIG.signalStrength[`${threshold}%`] || 0;
+            dispatchEvent("Scroll", {
+              scroll_depth: threshold,
+              scroll_percent: scrollPercent,
+              signal_strength: signal,
+              engagement_type: "scroll",
+              time_on_page: Math.round((Date.now() - state.pageLoadTime) / 1e3)
+            });
+            state.scrollTracking.trackedThresholds.add(key);
+          }
+        });
+      });
+    }, { threshold: SCROLL_CONFIG.thresholds.map((t) => t / 100) });
+    observer.observe(document.body);
+  }
+  function initTimeOnPageTracking() {
+    if (!isBrowser) return;
+    setInterval(() => {
+      const elapsed = Date.now() - state.pageLoadTime;
+      const timeOnPage = Math.round(elapsed / 1e3);
+      let currentLevel = state.timeTracking.currentLevel;
+      let signal = state.timeTracking.currentLevel;
+      if (timeOnPage >= TIME_CONFIG.thresholds.comprador) {
+        currentLevel = "comprador";
+        signal = TIME_CONFIG.signalStrength.comprador;
+      } else if (timeOnPage >= TIME_CONFIG.thresholds.interessado) {
+        currentLevel = "interessado";
+        signal = TIME_CONFIG.signalStrength.interessado;
+      } else if (timeOnPage >= TIME_CONFIG.thresholds.curioso) {
+        currentLevel = "curioso";
+        signal = TIME_CONFIG.signalStrength.curioso;
+      }
+      if (currentLevel !== state.timeTracking.currentLevel) {
+        state.timeTracking.currentLevel = currentLevel;
+        dispatchEvent("TimeOnPage", {
+          time_on_page: timeOnPage,
+          intention_level: currentLevel,
+          signal_strength: signal,
+          engagement_type: "time",
+          previous_level: state.timeTracking.previousLevel
+        });
+        state.timeTracking.previousLevel = currentLevel;
+      }
+    }, 5e3);
+  }
+  function _createVideoState() {
+    return {
+      playTime: 0,
+      totalWatchTime: 0,
+      lastProgress: -1,
+      // -1 = nenhum threshold disparado ainda (fix do bug original)
+      lastSecond: 0,
+      // segundo exato do último timeupdate (para dropout heatmap)
+      started: false,
+      paused: false,
+      completed: false,
+      dropoutPercent: null,
+      // % onde parou definitivamente
+      dropoutSecond: null
+      // segundo onde parou definitivamente
+    };
+  }
+  function _updateVideoSummary(videoId) {
+    const s = state.videoTracking[videoId];
+    const sum = state.videoSummary;
+    sum.totalVideos = Object.keys(state.videoTracking).length;
+    sum.startedCount = Object.values(state.videoTracking).filter((v) => v.started).length;
+    sum.completedCount = Object.values(state.videoTracking).filter((v) => v.completed).length;
+    sum.maxProgress = Math.max(...Object.values(state.videoTracking).map((v) => v.lastProgress < 0 ? 0 : v.lastProgress));
+  }
+  function _recordDropout(videoId, percent, second) {
+    const v = state.videoTracking[videoId];
+    if (!v || v.completed) return;
+    v.dropoutPercent = percent;
+    v.dropoutSecond = second;
+    if (VIDEO_CONFIG.dropoutEnabled) {
+      dispatchEvent("VideoDropout", {
+        video_id: videoId,
+        dropout_percent: percent,
+        dropout_second: second,
+        engagement_score: VIDEO_CONFIG.signalStrength.dropout,
+        engagement_type: "video",
+        video_summary: { ...state.videoSummary }
+      });
+    }
+  }
+  function initVideoTracking() {
+    if (!isBrowser) return;
+    const videos = document.querySelectorAll('video, iframe[src*="youtube"], iframe[src*="vimeo"]');
+    videos.forEach((video, index) => {
+      const videoId = video.id || video.getAttribute("data-video-id") || `video_${index}`;
+      state.videoTracking[videoId] = _createVideoState();
+      _updateVideoSummary(videoId);
+      if (video.tagName === "IFRAME" && video.src.includes("youtube")) {
+        initYouTubeTracking(video, videoId);
+        return;
+      }
+      if (video.tagName === "IFRAME" && video.src.includes("vimeo")) {
+        initVimeoTracking(video, videoId);
+        return;
+      }
+      _attachHtml5Tracking(video, videoId);
+    });
+    window.addEventListener("beforeunload", () => {
+      Object.entries(state.videoTracking).forEach(([videoId, v]) => {
+        if (v.started && !v.completed) {
+          _recordDropout(videoId, v.lastProgress < 0 ? 0 : v.lastProgress, v.lastSecond);
+        }
+      });
+    });
+  }
+  function _attachHtml5Tracking(video, videoId) {
+    const v = () => state.videoTracking[videoId];
+    video.addEventListener("play", () => {
+      v().started = true;
+      v().paused = false;
+      if (!v().playTime) v().playTime = Date.now();
+      _updateVideoSummary(videoId);
+      dispatchEvent("VideoPlay", {
+        video_id: videoId,
+        video_platform: "html5",
+        progress_percent: calculateVideoProgress(video),
+        engagement_score: VIDEO_CONFIG.signalStrength.play,
+        engagement_type: "video"
+      });
+    });
+    video.addEventListener("pause", () => {
+      v().paused = true;
+      const progress = calculateVideoProgress(video);
+      const second = Math.round(video.currentTime);
+      dispatchEvent("VideoPause", {
+        video_id: videoId,
+        video_platform: "html5",
+        progress_percent: progress,
+        pause_second: second,
+        engagement_score: VIDEO_CONFIG.signalStrength.pause,
+        engagement_type: "video"
+      });
+      _recordDropout(videoId, progress, second);
+    });
+    video.addEventListener("play", () => {
+      v().dropoutPercent = null;
+      v().dropoutSecond = null;
+    });
+    video.addEventListener("seeked", () => {
+      dispatchEvent("VideoSeek", {
+        video_id: videoId,
+        video_platform: "html5",
+        progress_percent: calculateVideoProgress(video),
+        seek_to_second: Math.round(video.currentTime),
+        engagement_score: VIDEO_CONFIG.signalStrength.seek,
+        engagement_type: "video"
+      });
+    });
+    video.addEventListener("timeupdate", () => {
+      if (video.paused || video.ended) return;
+      const progress = calculateVideoProgress(video);
+      const second = Math.round(video.currentTime);
+      v().lastSecond = second;
+      VIDEO_CONFIG.progressThresholds.forEach((threshold) => {
+        if (progress >= threshold && v().lastProgress < threshold) {
+          v().lastProgress = threshold;
+          dispatchEvent("VideoProgress", {
+            video_id: videoId,
+            video_platform: "html5",
+            progress_percent: threshold,
+            progress_second: second,
+            engagement_score: VIDEO_CONFIG.signalStrength[`progress${threshold}`] || 0,
+            engagement_type: "video",
+            video_summary: { ...state.videoSummary }
+          });
+          _updateVideoSummary(videoId);
+        }
+      });
+    });
+    video.addEventListener("ended", () => {
+      v().paused = false;
+      v().completed = true;
+      v().dropoutPercent = null;
+      v().dropoutSecond = null;
+      const totalTime = v().playTime ? Math.round((Date.now() - v().playTime) / 1e3) : 0;
+      _updateVideoSummary(videoId);
+      dispatchEvent("VideoComplete", {
+        video_id: videoId,
+        video_platform: "html5",
+        progress_percent: 100,
+        total_watch_time: totalTime,
+        engagement_score: VIDEO_CONFIG.signalStrength.complete,
+        engagement_type: "video",
+        video_summary: { ...state.videoSummary }
+      });
+    });
+  }
+  function calculateVideoProgress(video) {
+    if (!video.duration || video.duration === 0) return 0;
+    return Math.round(video.currentTime / video.duration * 100);
+  }
+  function initYouTubeTracking(iframe, videoId) {
+    try {
+      const url = new URL(iframe.src);
+      if (!url.searchParams.get("enablejsapi")) {
+        url.searchParams.set("enablejsapi", "1");
+        iframe.src = url.toString();
+      }
+    } catch (e) {
+    }
+    if (!window._ytApiLoading) {
+      window._ytApiLoading = true;
+      const tag = document.createElement("script");
+      tag.src = "https://www.youtube.com/iframe_api";
+      document.head.appendChild(tag);
+    }
+    const initPlayer = () => {
+      if (typeof YT === "undefined" || !YT.Player) {
+        setTimeout(initPlayer, 300);
+        return;
+      }
+      const v = () => state.videoTracking[videoId];
+      let progressInterval = null;
+      new YT.Player(iframe, {
+        events: {
+          onStateChange: (event) => {
+            const YTState = YT.PlayerState;
+            const player = event.target;
+            const duration = player.getDuration() || 0;
+            const currentTime = player.getCurrentTime() || 0;
+            const progress = duration > 0 ? Math.round(currentTime / duration * 100) : 0;
+            const second = Math.round(currentTime);
+            if (event.data === YTState.PLAYING) {
+              v().started = true;
+              v().paused = false;
+              if (!v().playTime) v().playTime = Date.now();
+              v().dropoutPercent = null;
+              v().dropoutSecond = null;
+              _updateVideoSummary(videoId);
+              dispatchEvent("VideoPlay", {
+                video_id: videoId,
+                video_platform: "youtube",
+                progress_percent: progress,
+                engagement_score: VIDEO_CONFIG.signalStrength.play,
+                engagement_type: "video"
+              });
+              clearInterval(progressInterval);
+              progressInterval = setInterval(() => {
+                if (!player || typeof player.getPlayerState !== "function") return;
+                if (player.getPlayerState() !== YTState.PLAYING) return;
+                const ct = player.getCurrentTime() || 0;
+                const dur = player.getDuration() || 0;
+                const pct = dur > 0 ? Math.round(ct / dur * 100) : 0;
+                v().lastSecond = Math.round(ct);
+                VIDEO_CONFIG.progressThresholds.forEach((threshold) => {
+                  if (pct >= threshold && v().lastProgress < threshold) {
+                    v().lastProgress = threshold;
+                    dispatchEvent("VideoProgress", {
+                      video_id: videoId,
+                      video_platform: "youtube",
+                      progress_percent: threshold,
+                      progress_second: Math.round(ct),
+                      engagement_score: VIDEO_CONFIG.signalStrength[`progress${threshold}`] || 0,
+                      engagement_type: "video",
+                      video_summary: { ...state.videoSummary }
+                    });
+                    _updateVideoSummary(videoId);
+                  }
+                });
+              }, 2e3);
+            } else if (event.data === YTState.PAUSED) {
+              clearInterval(progressInterval);
+              v().paused = true;
+              dispatchEvent("VideoPause", {
+                video_id: videoId,
+                video_platform: "youtube",
+                progress_percent: progress,
+                pause_second: second,
+                engagement_score: VIDEO_CONFIG.signalStrength.pause,
+                engagement_type: "video"
+              });
+              _recordDropout(videoId, progress, second);
+            } else if (event.data === YTState.ENDED) {
+              clearInterval(progressInterval);
+              v().completed = true;
+              v().dropoutPercent = null;
+              v().dropoutSecond = null;
+              const totalTime = v().playTime ? Math.round((Date.now() - v().playTime) / 1e3) : 0;
+              _updateVideoSummary(videoId);
+              dispatchEvent("VideoComplete", {
+                video_id: videoId,
+                video_platform: "youtube",
+                progress_percent: 100,
+                total_watch_time: totalTime,
+                engagement_score: VIDEO_CONFIG.signalStrength.complete,
+                engagement_type: "video",
+                video_summary: { ...state.videoSummary }
+              });
+            }
+          }
+        }
+      });
+    };
+    if (typeof YT !== "undefined" && YT.Player) {
+      initPlayer();
+    } else {
+      const prev = window.onYouTubeIframeAPIReady;
+      window.onYouTubeIframeAPIReady = () => {
+        if (prev) prev();
+        initPlayer();
+      };
+    }
+  }
+  function initVimeoTracking(iframe, videoId) {
+    const v = () => state.videoTracking[videoId];
+    let duration = 0;
+    const send = (method, value) => {
+      iframe.contentWindow.postMessage(JSON.stringify({ method, value }), "https://player.vimeo.com");
+    };
+    const enableListeners = () => {
+      ["play", "pause", "ended", "timeupdate", "seeked"].forEach((evt) => {
+        send("addEventListener", evt);
+      });
+      send("getDuration");
+    };
+    window.addEventListener("message", (event) => {
+      var _a;
+      if (!event.origin.includes("vimeo.com")) return;
+      let data;
+      try {
+        data = JSON.parse(event.data);
+      } catch (e) {
+        return;
+      }
+      if (!data || data.player_id !== iframe.id) return;
+      if (data.event === "ready") {
+        enableListeners();
+        return;
+      }
+      if (data.method === "getDuration") {
+        duration = data.value || 0;
+        return;
+      }
+      const currentTime = ((_a = data.data) == null ? void 0 : _a.seconds) || 0;
+      const progress = duration > 0 ? Math.round(currentTime / duration * 100) : 0;
+      const second = Math.round(currentTime);
+      if (data.event === "play") {
+        v().started = true;
+        v().paused = false;
+        if (!v().playTime) v().playTime = Date.now();
+        v().dropoutPercent = null;
+        v().dropoutSecond = null;
+        _updateVideoSummary(videoId);
+        dispatchEvent("VideoPlay", {
+          video_id: videoId,
+          video_platform: "vimeo",
+          progress_percent: progress,
+          engagement_score: VIDEO_CONFIG.signalStrength.play,
+          engagement_type: "video"
+        });
+      } else if (data.event === "pause") {
+        v().paused = true;
+        v().lastSecond = second;
+        dispatchEvent("VideoPause", {
+          video_id: videoId,
+          video_platform: "vimeo",
+          progress_percent: progress,
+          pause_second: second,
+          engagement_score: VIDEO_CONFIG.signalStrength.pause,
+          engagement_type: "video"
+        });
+        _recordDropout(videoId, progress, second);
+      } else if (data.event === "timeupdate") {
+        v().lastSecond = second;
+        VIDEO_CONFIG.progressThresholds.forEach((threshold) => {
+          if (progress >= threshold && v().lastProgress < threshold) {
+            v().lastProgress = threshold;
+            dispatchEvent("VideoProgress", {
+              video_id: videoId,
+              video_platform: "vimeo",
+              progress_percent: threshold,
+              progress_second: second,
+              engagement_score: VIDEO_CONFIG.signalStrength[`progress${threshold}`] || 0,
+              engagement_type: "video",
+              video_summary: { ...state.videoSummary }
+            });
+            _updateVideoSummary(videoId);
+          }
+        });
+      } else if (data.event === "ended") {
+        v().completed = true;
+        v().dropoutPercent = null;
+        v().dropoutSecond = null;
+        const totalTime = v().playTime ? Math.round((Date.now() - v().playTime) / 1e3) : 0;
+        _updateVideoSummary(videoId);
+        dispatchEvent("VideoComplete", {
+          video_id: videoId,
+          video_platform: "vimeo",
+          progress_percent: 100,
+          total_watch_time: totalTime,
+          engagement_score: VIDEO_CONFIG.signalStrength.complete,
+          engagement_type: "video",
+          video_summary: { ...state.videoSummary }
+        });
+      } else if (data.event === "seeked") {
+        dispatchEvent("VideoSeek", {
+          video_id: videoId,
+          video_platform: "vimeo",
+          progress_percent: progress,
+          seek_to_second: second,
+          engagement_score: VIDEO_CONFIG.signalStrength.seek,
+          engagement_type: "video"
+        });
+      }
+    });
+    if (iframe.contentDocument) {
+      enableListeners();
+    } else {
+      iframe.addEventListener("load", enableListeners);
+    }
+  }
+  function initClickHeatmapTracking() {
+    if (!isBrowser) return;
+    document.addEventListener("click", (e) => {
+      const target = e.target;
+      const clickCategory = categorizeClick(target);
+      const position = calculateClickPosition(e);
+      const timeOnPage = Math.round((Date.now() - state.pageLoadTime) / 1e3);
+      const now = Date.now();
+      const timeSinceLastClick = now - state.clickTracking.lastClickTime;
+      if (timeSinceLastClick < CLICK_CONFIG.rapidClickWindow) {
+        state.clickTracking.clicks.push({
+          time: now,
+          target
+        });
+      }
+      setTimeout(() => {
+        const recentClicks = state.clickTracking.clicks.filter(
+          (c) => now - c.time < CLICK_CONFIG.rapidClickWindow
+        );
+        if (recentClicks.length >= CLICK_CONFIG.maxRapidClicks) {
+          state.clickTracking.rapidClickDetected = true;
+          dispatchEvent("RapidClicks", {
+            click_count: recentClicks.length,
+            time_window: CLICK_CONFIG.rapidClickWindow,
+            behavior: "nervous",
+            engagement_score: 3,
+            engagement_type: "clicks",
+            time_on_page: timeOnPage,
+            description: `Usu\xE1rio clicou ${recentClicks.length} vezes em ${CLICK_CONFIG.rapidClickWindow / 1e3} segundos`
+          });
+        } else {
+          state.clickTracking.rapidClickDetected = false;
+          state.clickTracking.clicks = [];
+        }
+      }, CLICK_CONFIG.rapidClickWindow);
+      state.clickTracking.lastClickTime = now;
+      dispatchEvent("Click", {
+        click_category: clickCategory,
+        target_info: extractTargetInfo(target),
+        position,
+        time_on_page: timeOnPage,
+        click_heatmap: true,
+        engagement_score: calculateClickEngagementScore(clickCategory, position),
+        engagement_type: "clicks"
+      });
+    }, true);
+  }
+  function categorizeClick(target) {
+    const closest = (selector) => target.closest(selector);
+    const className = target.className || "";
+    if (closest("button") || className.includes("btn")) return "button";
+    if (closest("a")) return "link";
+    if (closest("input")) return "input";
+    if (closest(".cta") || className.includes("cta")) return "cta";
+    if (closest(".price") || className.includes("price")) return "price";
+    if (closest(".whatsapp") || className.includes("whatsapp")) return "whatsapp";
+    if (closest(".email") || className.includes("email")) return "email";
+    if (closest(".phone") || className.includes("phone")) return "phone";
+    return "generic";
+  }
+  function calculateClickPosition(e) {
+    return {
+      x: Math.round(e.clientX),
+      y: Math.round(e.clientY),
+      relativeX: Math.round(e.clientX / window.innerWidth * 100),
+      relativeY: Math.round(e.clientY / window.innerHeight * 100),
+      viewportWidth: window.innerWidth,
+      viewportHeight: window.innerHeight
+    };
+  }
+  function extractTargetInfo(target) {
+    var _a;
+    return {
+      tag: target.tagName,
+      class: target.className,
+      id: target.id,
+      text: ((_a = target.textContent) == null ? void 0 : _a.substring(0, 30)) || "",
+      attributes: Array.from(target.attributes).map((a) => `${a.name}="${a.value}"`).join(" ")
+    };
+  }
+  function calculateClickEngagementScore(clickCategory, position) {
+    const baseScore = CLICK_CONFIG.signalStrength[clickCategory] || 0.5;
+    const timeScore = Math.min(position.timeOnPage / 60, 2);
+    const depthBonus = Math.min(position.scrollDepth / 100, 0.5);
+    return baseScore + timeScore + depthBonus;
+  }
+  function initCTAHoverTracking() {
+    if (!isBrowser) return;
+    const ctaSelectors = [
+      'a[href*="checkout"]',
+      'a[href*="comprar"]',
+      "button.cta",
+      ".btn-comprar",
+      ".btn-checkout",
+      ".cta-button",
+      '[data-cta="true"]',
+      'button[type="submit"]'
+    ];
+    ctaSelectors.forEach((selector) => {
+      document.querySelectorAll(selector).forEach((element) => {
+        element.addEventListener("mouseenter", (e) => {
+          const ctaElement = e.target.closest(selector);
+          if (!ctaElement) return;
+          state.ctaHoverTracking.hoverStartTime = Date.now();
+          state.ctaHoverTracking.hoveredElement = selector;
+        });
+        element.addEventListener("mouseleave", () => {
+          if (state.ctaHoverTracking.hoverStartTime) {
+            const hoverTime = Date.now() - state.ctaHoverTracking.hoverStartTime;
+            if (hoverTime >= CTA_HOVER_CONFIG.minHoverTimeForSignal) {
+              dispatchEvent("CTAHover", {
+                cta_selector: selector,
+                hover_time_seconds: Math.round(hoverTime / 1e3),
+                engagement_score: CTA_HOVER_CONFIG.signalStrength,
+                engagement_type: "hover",
+                time_on_page: Math.round((Date.now() - state.pageLoadTime) / 1e3)
+              });
+            }
+          }
+          state.ctaHoverTracking.hoverStartTime = null;
+          state.ctaHoverTracking.hoveredElement = null;
+        });
+      });
+    });
+  }
+  function dispatchEvent(eventName, data = {}) {
+    if (typeof cdpTrack !== "undefined" && cdpTrack.track) {
+      cdpTrack.track(eventName, data);
+    } else {
+      console.warn("cdpTrack n\xE3o dispon\xEDvel - evento n\xE3o enviado:", eventName, data);
+    }
+  }
+  function initMicroEvents() {
+    if (!isBrowser) return;
+    state.pageLoadTime = Date.now();
+    initScrollTracking();
+    initTimeOnPageTracking();
+    initVideoTracking();
+    initClickHeatmapTracking();
+    initCTAHoverTracking();
+    console.log("\u2705 Micro-Events inicializados");
+  }
+
+  // engagement-scoring.js
+  var ENGAGEMENT_CONFIG = {
+    timeWeights: {
+      "curioso": 1,
+      // < 10s: score base 1.0
+      "interessado": 2.5,
+      // 10-60s: score base 2.5
+      "comprador": 4
+      // > 60s: score base 4.0
+    },
+    scrollWeights: {
+      "baixo": 1,
+      // < 25%: score base 1.0
+      "medio": 2,
+      // 25-75%: score base 2.0
+      "alto": 3
+      // > 75%: score base 3.0
+    },
+    clickWeights: {
+      "generico": 1,
+      // clique sem categoria
+      "cta": 2.5,
+      // clique em CTA
+      "button": 2,
+      // clique em botão
+      "link": 1.5,
+      // clique em link
+      "input": 0.5
+      // clique em input
+    },
+    videoWeights: {
+      "play": 1.5,
+      // vídeo iniciou
+      "progress25": 2,
+      // 25% assistido
+      "progress50": 3,
+      // 50% assistido
+      "progress75": 4,
+      // 75% assistido
+      "complete": 5
+      // vídeo completo
+    },
+    hoverWeights: {
+      "curto": 1,
+      // < 3s: hover curto
+      "medio": 2,
+      // 3-10s: hover médio
+      "longo": 3
+      // > 10s: hover longo
+    }
+  };
+  var engagementState = {
+    timeOnPage: 0,
+    scrollDepth: 0,
+    clicksCount: 0,
+    videoEngagement: 0,
+    ctaHoverTime: 0,
+    lastActivityTime: Date.now()
+  };
+  function calculateTimeScore(timeOnPage) {
+    let level = "curioso";
+    let score = ENGAGEMENT_CONFIG.timeWeights.curioso;
+    if (timeOnPage >= 10 && timeOnPage < 60) {
+      level = "interessado";
+      score = ENGAGEMENT_CONFIG.timeWeights.interessado;
+    } else if (timeOnPage >= 60) {
+      level = "comprador";
+      score = ENGAGEMENT_CONFIG.timeWeights.comprador;
+    }
+    return { score, level };
+  }
+  function calculateScrollScore(scrollDepth) {
+    let level = "baixo";
+    let score = ENGAGEMENT_CONFIG.scrollWeights.baixo;
+    if (scrollDepth >= 25 && scrollDepth < 75) {
+      level = "medio";
+      score = ENGAGEMENT_CONFIG.scrollWeights.medio;
+    } else if (scrollDepth >= 75) {
+      level = "alto";
+      score = ENGAGEMENT_CONFIG.scrollWeights.alto;
+    }
+    return { score, level };
+  }
+  function calculateClickScore(clicksCount, clickCategory) {
+    const baseScore = ENGAGEMENT_CONFIG.clickWeights.generico;
+    const categoryBonus = ENGAGEMENT_CONFIG.clickWeights[clickCategory] || 1;
+    const clickPenalty = Math.max(0, 1 - clicksCount / 50);
+    return baseScore + categoryBonus;
+  }
+  function calculateHoverScore(hoverTime) {
+    let level = "curto";
+    let score = ENGAGEMENT_CONFIG.hoverWeights.curto;
+    if (hoverTime >= 3 && hoverTime < 10) {
+      level = "medio";
+      score = ENGAGEMENT_CONFIG.hoverWeights.medio;
+    } else if (hoverTime >= 10) {
+      level = "longo";
+      score = ENGAGEMENT_CONFIG.hoverWeights.longo;
+    }
+    return { score, level };
+  }
+  function calculateEngagementScore() {
+    const { score: timeScore, level: timeLevel } = calculateTimeScore(engagementState.timeOnPage);
+    const { score: scrollScore } = calculateScrollScore(engagementState.scrollDepth);
+    const clickScore = engagementState.clicksCount > 0 ? calculateClickScore(engagementState.clicksCount, "generico") : 0;
+    const videoScore = engagementState.videoEngagement;
+    const hoverScore = engagementState.ctaHoverTime > 0 ? calculateHoverScore(engagementState.ctaHoverTime / 1e3) : 0;
+    const totalScore = timeScore * 0.3 + // 30% peso para tempo
+    scrollScore * 0.2 + // 20% peso para scroll
+    clickScore * 0.15 + // 15% peso para cliques
+    videoScore * 0.25 + // 25% peso para vídeo
+    hoverScore * 0.1;
+    let intentionLevel = timeLevel;
+    if (totalScore < 1.5) {
+      intentionLevel = "curioso";
+    } else if (totalScore < 2.5) {
+      intentionLevel = "interessado";
+    } else {
+      intentionLevel = "comprador";
+    }
+    return {
+      totalScore: Math.min(totalScore, 5),
+      timeScore,
+      scrollScore,
+      clickScore,
+      videoScore,
+      hoverScore,
+      intentionLevel,
+      components: {
+        timeOnPage: engagementState.timeOnPage,
+        scrollDepth: engagementState.scrollDepth,
+        clicksCount: engagementState.clicksCount,
+        videoEngagement: engagementState.videoEngagement,
+        ctaHoverTime: engagementState.ctaHoverTime
+      }
+    };
+  }
+  function updateEngagementState(component, value) {
+    engagementState[component] = value;
+    engagementState.lastActivityTime = Date.now();
+  }
+
+  // advanced-matching.js
+  var NORMALIZATION_CONFIG = {
+    email: {
+      trim: true,
+      lowercase: true,
+      removeDots: false,
+      // Gmail: user.name@gmail.com vs username@gmail.com (diferentes)
+      removePlus: true
+      // Gmail: user+tag@gmail.com = user@gmail.com (mesmo)
+    },
+    phone: {
+      keepOnlyDigits: true,
+      addCountryCode: true,
+      // Adiciona DDI se não tiver (55 para Brasil)
+      defaultCountryCode: "55"
+    },
+    name: {
+      trim: true,
+      lowercase: true,
+      removeAccents: true,
+      removeExtraSpaces: true,
+      maxLength: 100
+    },
+    city: {
+      trim: true,
+      lowercase: true,
+      removeAccents: true,
+      maxLength: 50
+    },
+    state: {
+      trim: true,
+      lowercase: true,
+      removeAccents: true,
+      maxLength: 50
+    },
+    zip: {
+      trim: true,
+      keepOnlyDigits: true,
+      maxLength: 10
+    }
+  };
+  function normalizeEmail(email) {
+    if (!email || typeof email !== "string") return "";
+    let normalized = email.trim();
+    if (normalized.includes("@gmail.com")) {
+      normalized = normalized.split("+")[0] + "@gmail.com";
+    }
+    if (normalized.includes("@googlemail.com")) {
+      normalized = normalized.split("+")[0] + "@googlemail.com";
+    }
+    return normalized.toLowerCase();
+  }
+  function normalizePhone(phone) {
+    if (!phone || typeof phone !== "string") return "";
+    let normalized = phone.replace(/\D/g, "");
+    if (normalized.length === 11 || normalized.length === 10) {
+      normalized = "55" + normalized;
+    }
+    return normalized.substring(0, 15);
+  }
+  function normalizeName(name) {
+    if (!name || typeof name !== "string") return "";
+    let normalized = name.trim();
+    normalized = normalized.normalize("NFD").replace(/[\u0300-\u036f]/g, "");
+    normalized = normalized.toLowerCase();
+    normalized = normalized.replace(/\s+/g, " ");
+    return normalized.substring(0, NORMALIZATION_CONFIG.name.maxLength);
+  }
+  function normalizeCity(city) {
+    if (!city || typeof city !== "string") return "";
+    let normalized = city.trim();
+    normalized = normalized.normalize("NFD").replace(/[\u0300-\u036f]/g, "");
+    normalized = normalized.toLowerCase();
+    normalized = normalized.replace(/\s+/g, " ");
+    return normalized.substring(0, NORMALIZATION_CONFIG.city.maxLength);
+  }
+  function normalizeState(state2) {
+    if (!state2 || typeof state2 !== "string") return "";
+    let normalized = state2.trim();
+    normalized = normalized.normalize("NFD").replace(/[\u0300-\u036f]/g, "");
+    normalized = normalized.toLowerCase();
+    return normalized.substring(0, NORMALIZATION_CONFIG.state.maxLength);
+  }
+  function normalizeZip(zip) {
+    if (!zip || typeof zip !== "string") return "";
+    const normalized = zip.replace(/\D/g, "");
+    return normalized.substring(0, NORMALIZATION_CONFIG.zip.maxLength);
+  }
+  function normalizeDOB(dob) {
+    if (!dob || typeof dob !== "string") return "";
+    const formats = [
+      /(\d{4})-(\d{2})-(\d{2})/,
+      // YYYY-MM-DD
+      /(\d{2})\/(\d{2})\/(\d{4})/,
+      // DD/MM/YYYY
+      /(\d{2})-(\d{2})-(\d{4})/
+      // DD-MM-YYYY
+    ];
+    for (const format of formats) {
+      const match = dob.match(format);
+      if (match) {
+        let year, month, day;
+        if (match[1].length === 4) {
+          [year, month, day] = [match[1], match[2], match[3]];
+        } else {
+          [day, month, year] = [match[1], match[2], match[3]];
+        }
+        return `${year}${month}${day}`;
+      }
+    }
+    return "";
+  }
+  function extractFormPII(form) {
+    if (!form || typeof form.elements !== "object") return {};
+    const formData = new FormData(form);
+    const piiData = {};
+    const email = formData.get("email") || formData.get("user_email") || formData.get("useremail");
+    if (email) piiData.email = normalizeEmail(email);
+    const phone = formData.get("phone") || formData.get("telephone") || formData.get("telefone") || formData.get("celular");
+    if (phone) piiData.phone = normalizePhone(phone);
+    const firstName = formData.get("first_name") || formData.get("nome") || formData.get("firstname");
+    const lastName = formData.get("last_name") || formData.get("sobrenome") || formData.get("lastname");
+    const fullName = formData.get("name") || formData.get("fullname") || formData.get("nome_completo");
+    if (fullName) {
+      const names = fullName.split(" ");
+      piiData.first_name = normalizeName(names[0]);
+      piiData.last_name = normalizeName(names.slice(1).join(" "));
+    } else {
+      if (firstName) piiData.first_name = normalizeName(firstName);
+      if (lastName) piiData.last_name = normalizeName(lastName);
+    }
+    const city = formData.get("city") || formData.get("cidade");
+    if (city) piiData.city = normalizeCity(city);
+    const state2 = formData.get("state") || formData.get("estado") || formData.get("uf");
+    if (state2) piiData.state = normalizeState(state2);
+    const zip = formData.get("zip") || formData.get("cep") || formData.get("postalcode");
+    if (zip) piiData.zip = normalizeZip(zip);
+    const dob = formData.get("dob") || formData.get("date_of_birth") || formData.get("nascimento");
+    if (dob) piiData.dob = normalizeDOB(dob);
+    return piiData;
+  }
+  function isValidPII(piiData) {
+    if (!piiData || typeof piiData !== "object") return false;
+    const hasEmail = piiData.email && piiData.email.includes("@");
+    const hasPhone = piiData.phone && piiData.phone.length >= 10;
+    return hasEmail || hasPhone;
+  }
+
+  // anti-blocking.js
+  var isBrowser2 = typeof window !== "undefined";
+  var ANTI_BLOCKING_CONFIG = {
+    // Mesmo domínio evita bloqueios de CORS e ad-blockers
+    endpoint: "/track",
+    // Retries com exponential backoff
+    maxRetries: 3,
+    retryDelays: [1e3, 3e3, 6e3],
+    // 1s, 3s, 6s
+    // Fallback para Beacon API (quando fetch falha)
+    useBeaconFallback: true,
+    // First-party cookies (ad-block proof)
+    cookieDuration: 60 * 60 * 24 * 365,
+    // 365 dias
+    cookieDomain: "",
+    // Será definido dinamicamente
+    // Detectar ad-blockers
+    detectAdBlocker: true,
+    adBlockerBaitClass: "adsbox adbanner pub_300x250",
+    // Lightweight code (evitar patterns de bloqueio)
+    minify: false,
+    // Opcional: usar código minificado em produção
+    noConsoleLogs: false
+    // Opcional: remover console.logs em produção
+  };
+  function detectAdBlocker() {
+    if (!isBrowser2 || !ANTI_BLOCKING_CONFIG.detectAdBlocker) return false;
+    const baitElement = document.createElement("div");
+    baitElement.innerHTML = "&nbsp;";
+    baitElement.className = ANTI_BLOCKING_CONFIG.adBlockerBaitClass;
+    baitElement.style.cssText = "position: absolute; top: -1000px; left: -1000px;";
+    document.body.appendChild(baitElement);
+    const isBlocked = getComputedStyle(baitElement).display === "none";
+    document.body.removeChild(baitElement);
+    try {
+      const testPixel = new Image();
+      testPixel.src = "/pixel-test.png?t=" + Date.now();
+      testPixel.onload = () => console.log("\u2705 Pixel n\xE3o bloqueado");
+      testPixel.onerror = () => console.warn("\u26A0\uFE0F Pixel pode estar bloqueado");
+    } catch (error) {
+      console.warn("\u26A0\uFE0F Erro ao testar pixel:", error);
+    }
+    return isBlocked;
+  }
+  async function sendWithRetry(data, endpoint = ANTI_BLOCKING_CONFIG.endpoint) {
+    if (!isBrowser2) return { success: false, error: "Not in browser" };
+    let lastError = null;
+    for (let attempt = 0; attempt < ANTI_BLOCKING_CONFIG.maxRetries; attempt++) {
+      try {
+        const response = await fetch(endpoint, {
+          method: "POST",
+          headers: {
+            "Content-Type": "application/json"
+          },
+          body: JSON.stringify(data),
+          keepalive: true,
+          // Garante envio mesmo se usuário fechar aba
+          credentials: "same-origin",
+          // First-party cookies
+          cache: "no-cache"
+          // Evitar cache de requests de tracking
+        });
+        if (response.ok) {
+          console.log(`\u2705 Envio bem-sucedido (tentativa ${attempt + 1})`);
+          return await response.json();
+        } else {
+          const errorText = await response.text();
+          throw new Error(`HTTP ${response.status}: ${errorText}`);
+        }
+      } catch (error) {
+        lastError = error;
+        console.warn(`\u26A0\uFE0F Tentativa ${attempt + 1} falhou:`, error.message);
+        if (attempt < ANTI_BLOCKING_CONFIG.maxRetries - 1) {
+          const delay = ANTI_BLOCKING_CONFIG.retryDelays[attempt];
+          console.log(`\u23F3 Aguardando ${delay}ms antes de retry...`);
+          await sleep(delay);
+        }
+      }
+    }
+    console.error("\u274C Todas as tentativas de envio falharam:", lastError);
+    if (ANTI_BLOCKING_CONFIG.useBeaconFallback && navigator.sendBeacon) {
+      console.log("\u{1F504} Tentando Beacon API como fallback...");
+      const beaconSuccess = navigator.sendBeacon(endpoint, JSON.stringify(data));
+      if (beaconSuccess) {
+        console.log("\u2705 Beacon API bem-sucedido");
+        return { success: true, method: "beacon" };
+      } else {
+        console.error("\u274C Beacon API tamb\xE9m falhou");
+      }
+    }
+    return { success: false, error: lastError == null ? void 0 : lastError.message, attempts: ANTI_BLOCKING_CONFIG.maxRetries };
+  }
+  function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+  function setFirstPartyCookie(name, value, maxAge = ANTI_BLOCKING_CONFIG.cookieDuration) {
+    if (!isBrowser2) return;
+    const currentDomain = window.location.hostname;
+    const rootDomain = currentDomain.split(".").slice(-2).join(".");
+    const cookieOptions = [
+      `${name}=${value}`,
+      `max-age=${maxAge}`,
+      "path=/",
+      `domain=.${rootDomain}`,
+      // Umbrella domain para subdomínios
+      "SameSite=Lax",
+      "Secure"
+    ].join("; ");
+    document.cookie = cookieOptions;
+  }
+  function getFirstPartyCookie(name) {
+    if (!isBrowser2) return null;
+    const value = `; ${document.cookie}`;
+    const parts = value.split(`; ${name}=`);
+    if (parts.length === 2) {
+      return parts.pop().split(";").shift();
+    }
+    return null;
+  }
+  function configureConsoleLogs(remove = ANTI_BLOCKING_CONFIG.noConsoleLogs) {
+    if (!isBrowser2 || !remove) return;
+    const noop = () => {
+    };
+    console.log = noop;
+    console.warn = noop;
+    console.error = noop;
+  }
+  function initAntiBlocking() {
+    if (!isBrowser2) return;
+    console.log("\u{1F6E1}\uFE0F Inicializando Anti-Blocking System...");
+    const adBlockerActive = detectAdBlocker();
+    if (adBlockerActive) {
+      console.warn("\u26A0\uFE0F Ad-Blocker detectado - usando estrat\xE9gias de resili\xEAncia");
+      if (typeof cdpTrack !== "undefined" && cdpTrack.track) {
+        cdpTrack.track("adblocker_detected", {
+          user_agent: navigator.userAgent,
+          timestamp: Date.now()
+        });
+      }
+    }
+    const userId = getFirstPartyCookie("_cdp_uid");
+    if (!userId) {
+      const newUserId = `${Date.now()}_${Math.random().toString(36).slice(2, 11)}`;
+      setFirstPartyCookie("_cdp_uid", newUserId);
+    }
+    if (ANTI_BLOCKING_CONFIG.noConsoleLogs) {
+      configureConsoleLogs(true);
+    }
+    console.log("\u2705 Anti-Blocking System inicializado");
+  }
+
+  // route-intent-capture.js
+  var isBrowser3 = typeof window !== "undefined";
+  function initRouteIntentCapture(options = {}) {
+    if (!isBrowser3) return;
+    const {
+      whatsappNumber,
+      propertyName = "o im\xF3vel",
+      propertyId = null,
+      propertyLat = null,
+      propertyLng = null,
+      routeSelector = '[data-route-intent], a[href*="maps/dir"], a[href*="maps?q="]',
+      distanceBucket = null,
+      distanceKm = null,
+      metaSignalBucket = null,
+      brokerName = null
+    } = options;
+    if (!whatsappNumber) {
+      console.warn("[RouteIntent] whatsappNumber \xE9 obrigat\xF3rio.");
+      return;
+    }
+    _injectStyles();
+    document.addEventListener("click", (e) => {
+      const btn = e.target.closest(routeSelector);
+      if (!btn) return;
+      _showWidget(btn, { whatsappNumber, propertyName, propertyId, propertyLat, propertyLng, distanceBucket, distanceKm, metaSignalBucket, brokerName });
+    }, true);
+  }
+  function _showWidget(anchorEl, opts) {
+    var _a;
+    (_a = document.getElementById("cdp-ri-widget")) == null ? void 0 : _a.remove();
+    const travelMinutes = _estimateTravelMinutes(opts.distanceKm);
+    const travelText = travelMinutes ? `<p class="cdp-ri-travel">\u{1F4CD} Voc\xEA est\xE1 a cerca de <strong>${travelMinutes} min</strong> daqui</p>` : "";
+    const brokerLine = opts.brokerName ? `<p class="cdp-ri-broker">Ao chegar, pergunte pelo <strong>${opts.brokerName}</strong> \u2014 ele vai estar te aguardando com tudo pronto \u{1F91D}</p>` : "";
+    const widget = document.createElement("div");
+    widget.id = "cdp-ri-widget";
+    widget.innerHTML = `
+    <div class="cdp-ri-inner">
+      ${travelText}
+      <p class="cdp-ri-headline">Vi que voc\xEA quer visitar o local! Confirme sua vinda enviando a mensagem abaixo \u2014 nossa equipe j\xE1 fica de prontid\xE3o pra te receber \u{1F447}</p>
+      ${brokerLine}
+      <button id="cdp-ri-btn" type="button">
+        ${_waIcon()} Confirmar minha visita
+      </button>
+      <button id="cdp-ri-dismiss" type="button" class="cdp-ri-dismiss">Agora n\xE3o</button>
+    </div>
+  `;
+    anchorEl.insertAdjacentElement("afterend", widget);
+    setTimeout(() => widget.scrollIntoView({ behavior: "smooth", block: "nearest" }), 150);
+    document.getElementById("cdp-ri-btn").addEventListener("click", () => _handleClick(widget, opts));
+    document.getElementById("cdp-ri-dismiss").addEventListener("click", () => {
+      var _a2, _b;
+      (_b = (_a2 = window.cdpTrack) == null ? void 0 : _a2.track) == null ? void 0 : _b.call(_a2, "ViewContent", {
+        content_name: "rota_dispensada",
+        property_id: opts.propertyId,
+        funnel_stage: "route_dismiss",
+        intent_score: "medium",
+        distance_bucket: opts.distanceBucket || void 0,
+        meta_signal_bucket: opts.metaSignalBucket || void 0
+      });
+      widget.remove();
+    });
+  }
+  async function _handleClick(widget, opts) {
+    var _a, _b;
+    const btn = document.getElementById("cdp-ri-btn");
+    if (btn) btn.disabled = true;
+    (_b = (_a = window.cdpTrack) == null ? void 0 : _a.track) == null ? void 0 : _b.call(_a, "Contact", {
+      content_name: "aviso_chegada_whatsapp",
+      property_id: opts.propertyId,
+      property_lat: opts.propertyLat,
+      property_lng: opts.propertyLng,
+      funnel_stage: "route_click",
+      intent_score: "high",
+      distance_bucket: opts.distanceBucket || void 0,
+      meta_signal_bucket: opts.metaSignalBucket || void 0
+    });
+    const travelMinutes = _estimateTravelMinutes(opts.distanceKm);
+    const travelLine = travelMinutes ? `Estou a cerca de ${travelMinutes} minutos da\xED.` : "";
+    const brokerLine = opts.brokerName ? `Vou procurar pelo ${opts.brokerName} ao chegar.` : "";
+    const msg = [
+      `Oi! Estou interessado(a) em visitar o ${opts.propertyName} e gostaria de confirmar minha visita.`,
+      travelLine,
+      brokerLine || `Voc\xEAs conseguem me receber agora ou preciso marcar hor\xE1rio?`
+    ].filter(Boolean).join(" ");
+    _showSuccess(widget, opts.whatsappNumber, msg);
+  }
+  function _showSuccess(widget, whatsappNumber, msg) {
+    widget.innerHTML = `
+    <div class="cdp-ri-inner cdp-ri-ok">
+      <span class="cdp-ri-check">\u2705</span>
+      <p><strong>Abrindo WhatsApp...</strong><br><span>A equipe j\xE1 foi avisada!</span></p>
+    </div>
+  `;
+    setTimeout(() => {
+      window.open(`https://wa.me/${whatsappNumber}?text=${encodeURIComponent(msg)}`, "_blank");
+      setTimeout(() => widget == null ? void 0 : widget.remove(), 3500);
+    }, 600);
+  }
+  function _estimateTravelMinutes(distanceKm) {
+    if (!distanceKm || distanceKm <= 0) return null;
+    return Math.max(5, Math.round(distanceKm * 60 / 25 / 5) * 5);
+  }
+  function _waIcon() {
+    return `<svg width="18" height="18" viewBox="0 0 24 24" fill="currentColor" aria-hidden="true">
+    <path d="M17.472 14.382c-.297-.149-1.758-.867-2.03-.967-.273-.099-.471-.148-.67.15-.197.297-.767.966-.94 1.164-.173.199-.347.223-.644.075-.297-.15-1.255-.463-2.39-1.475-.883-.788-1.48-1.761-1.653-2.059-.173-.297-.018-.458.13-.606.134-.133.298-.347.446-.52.149-.174.198-.298.298-.497.099-.198.05-.371-.025-.52-.075-.149-.669-1.612-.916-2.207-.242-.579-.487-.5-.669-.51-.173-.008-.371-.01-.57-.01-.198 0-.52.074-.792.372-.272.297-1.04 1.016-1.04 2.479 0 1.462 1.065 2.875 1.213 3.074.149.198 2.096 3.2 5.077 4.487.709.306 1.262.489 1.694.625.712.227 1.36.195 1.871.118.571-.085 1.758-.719 2.006-1.413.248-.694.248-1.289.173-1.413-.074-.124-.272-.198-.57-.347z"/>
+    <path d="M12 0C5.373 0 0 5.373 0 12c0 2.122.554 4.118 1.528 5.852L0 24l6.335-1.513A11.933 11.933 0 0012 24c6.627 0 12-5.373 12-12S18.627 0 12 0zm0 21.818a9.818 9.818 0 01-5.002-1.368l-.359-.213-3.722.888.924-3.617-.234-.372A9.818 9.818 0 012.182 12C2.182 6.57 6.57 2.182 12 2.182S21.818 6.57 21.818 12 17.43 21.818 12 21.818z"/>
+  </svg>`;
+  }
+  function _injectStyles() {
+    if (document.getElementById("cdp-ri-styles")) return;
+    const s = document.createElement("style");
+    s.id = "cdp-ri-styles";
+    s.textContent = `
+    #cdp-ri-widget {
+      margin-top: 12px;
+      padding: 16px 18px;
+      background: #f0fdf4;
+      border: 1.5px solid #22c55e;
+      border-radius: 12px;
+      font-family: Arial, sans-serif;
+      animation: cdp-ri-in .25s ease;
+    }
+    @keyframes cdp-ri-in {
+      from { opacity: 0; transform: translateY(-8px); }
+      to   { opacity: 1; transform: translateY(0); }
+    }
+    .cdp-ri-inner         { display: flex; flex-direction: column; gap: 10px; }
+    .cdp-ri-travel        { margin: 0; font-size: 13px; color: #555; }
+    .cdp-ri-travel strong { color: #0f766e; }
+    .cdp-ri-headline      { margin: 0; font-size: 14px; color: #15803d; font-weight: bold; line-height: 1.4; }
+    .cdp-ri-broker        { margin: 0; font-size: 13px; color: #555; line-height: 1.4; }
+    .cdp-ri-broker strong { color: #0f766e; }
+    #cdp-ri-btn {
+      display: flex; align-items: center; justify-content: center; gap: 8px;
+      width: 100%; padding: 13px 16px;
+      background: #25D366; color: #fff;
+      border: none; border-radius: 10px;
+      font-size: 15px; font-weight: bold; cursor: pointer;
+    }
+    #cdp-ri-btn:hover    { background: #1ebe5a; }
+    #cdp-ri-btn:disabled { background: #86efac; cursor: not-allowed; }
+    .cdp-ri-dismiss {
+      background: none; border: none;
+      color: #aaa; font-size: 12px;
+      cursor: pointer; padding: 2px 0; text-align: center;
+    }
+    .cdp-ri-dismiss:hover { color: #666; }
+    .cdp-ri-ok   { align-items: center; text-align: center; gap: 8px; }
+    .cdp-ri-check { font-size: 28px; }
+    .cdp-ri-ok p  { margin: 0; font-size: 14px; color: #15803d; line-height: 1.5; }
+    .cdp-ri-ok span { font-size: 13px; color: #555; }
+  `;
+    document.head.appendChild(s);
+  }
+
+  // cdpTrack.js
+  var isBrowser4 = typeof window !== "undefined";
+  var CONSENT_KEY = "_cdp_consent";
+  var _defaultConsent = {
+    ad_storage: "denied",
+    analytics_storage: "denied",
+    ad_user_data: "denied",
+    ad_personalization: "denied"
+  };
+  function _readStoredConsent() {
+    if (!isBrowser4) return null;
+    try {
+      const raw = localStorage.getItem(CONSENT_KEY);
+      return raw ? JSON.parse(raw) : null;
+    } catch (e) {
+      return null;
+    }
+  }
+  function initConsentMode() {
+    var _a, _b, _c, _d;
+    if (!isBrowser4) return;
+    if (((_a = tracking_config_default.consent) == null ? void 0 : _a.defaultDenied) === false) return;
+    window.dataLayer = window.dataLayer || [];
+    function gtag() {
+      window.dataLayer.push(arguments);
+    }
+    const waitForUpdate = (_c = (_b = tracking_config_default.consent) == null ? void 0 : _b.waitForUpdate) != null ? _c : 500;
+    gtag("consent", "default", {
+      ..._defaultConsent,
+      wait_for_update: waitForUpdate
+    });
+    if (((_d = tracking_config_default.consent) == null ? void 0 : _d.urlPassthrough) !== false) {
+      gtag("set", "url_passthrough", true);
+    }
+    const stored = _readStoredConsent();
+    if (stored) {
+      gtag("consent", "update", stored);
+      if (tracking_config_default.debug) console.log("\u2705 Consent Mode: consentimento anterior restaurado");
+    }
+  }
+  function updateConsent(params = {}) {
+    if (!isBrowser4) return;
+    window.dataLayer = window.dataLayer || [];
+    function gtag() {
+      window.dataLayer.push(arguments);
+    }
+    const analyticsGranted = params.analytics === true ? "granted" : "denied";
+    const adsGranted = params.ads === true ? "granted" : "denied";
+    const consentUpdate = {
+      analytics_storage: analyticsGranted,
+      ad_storage: adsGranted,
+      ad_user_data: adsGranted,
+      ad_personalization: adsGranted
+    };
+    gtag("consent", "update", consentUpdate);
+    try {
+      localStorage.setItem(CONSENT_KEY, JSON.stringify(consentUpdate));
+    } catch (e) {
+    }
+    console.log("\u2705 Consent Mode atualizado:", consentUpdate);
+  }
+  var _urlParams = isBrowser4 ? new URLSearchParams(window.location.search) : new URLSearchParams();
+  var _fbclid = _urlParams.get("fbclid") || "";
+  var _gclid = _urlParams.get("gclid") || "";
+  var _wbraid = _urlParams.get("wbraid") || "";
+  var _gbraid = _urlParams.get("gbraid") || "";
+  var _ttclid = _urlParams.get("ttclid") || "";
+  var _utms = {
+    utm_source: _urlParams.get("utm_source") || "",
+    utm_medium: _urlParams.get("utm_medium") || "",
+    utm_campaign: _urlParams.get("utm_campaign") || "",
+    utm_content: _urlParams.get("utm_content") || "",
+    utm_term: _urlParams.get("utm_term") || ""
+  };
+  var _getUserId = () => {
+    var _a;
+    if (!isBrowser4) return "";
+    const KEY = "_cdp_uid";
+    let uid = (_a = document.cookie.match(new RegExp(`${KEY}=([^;]+)`))) == null ? void 0 : _a[1];
+    if (!uid) {
+      uid = `${Date.now()}_${Math.random().toString(36).slice(2, 11)}`;
+      document.cookie = `${KEY}=${uid}; max-age=${60 * 60 * 24 * 365}; path=/; SameSite=Lax`;
+    }
+    return uid;
+  };
+  var _userId = isBrowser4 ? _getUserId() : "";
+  var _getSessionId = () => {
+    if (!isBrowser4) return "";
+    const sessionId = "cdp_session";
+    let sid = sessionStorage.getItem(sessionId);
+    if (!sid) {
+      sid = `${Date.now()}_${Math.random().toString(36).slice(2, 11)}`;
+      sessionStorage.setItem(sessionId, sid);
+    }
+    return sid;
+  };
+  var _sessionId = isBrowser4 ? _getSessionId() : "";
+  var getUTMs = () => ({ ..._utms });
+  var getUserId = () => _userId;
+  var getSessionId = () => _sessionId;
+  var generateId = () => {
+    return `${Date.now()}_${Math.random().toString(36).slice(2, 11)}`;
+  };
+  var _getClickIDs = () => {
+    var _a, _b, _c;
+    return {
+      fbp: ((_a = document.cookie.match(/_fbp=([^;]+)/)) == null ? void 0 : _a[1]) || void 0,
+      fbc: ((_b = document.cookie.match(/_fbc=([^;]+)/)) == null ? void 0 : _b[1]) || void 0,
+      fbclid: _fbclid || void 0,
+      // click ID Meta → Worker gera fbc se cookie _fbc ausente
+      gclid: _gclid || void 0,
+      gbraid: _gbraid || void 0,
+      wbraid: _wbraid || void 0,
+      ttclid: _ttclid || void 0,
+      ttp: ((_c = document.cookie.match(/_ttp=([^;]+)/)) == null ? void 0 : _c[1]) || void 0,
+      // TikTok Pixel cookie — EMQ TikTok
+      rclid: _urlParams.get("rclid") || void 0
+    };
+  };
+  var passCheckoutParams = (options = {}) => {
+    if (!isBrowser4) return;
+    const {
+      platforms = ["hotmart", "kiwify", "eduzz", "monetizze", "cartpanda", "ticto"],
+      domains = []
+    } = options;
+    const utms = getUTMs();
+    const userId = getUserId();
+    const PLATFORM_DOMAINS = {
+      hotmart: ["hotmart.com", "pay.hotmart.com", "payment.hotmart.com"],
+      kiwify: ["kiwify.com.br", "checkout.kiwify.com.br"],
+      eduzz: ["eduzz.com", "sun.eduzz.com"],
+      monetizze: ["monetizze.com.br"],
+      cartpanda: ["cartpanda.com", "pay.cartpanda.com"],
+      ticto: ["ticto.app", "pay.ticto.app", "checkout.ticto.app"]
+    };
+    const buildSck = () => [utms.utm_source, utms.utm_medium, utms.utm_campaign, utms.utm_content, utms.utm_term].map((v) => v || "direto").join("|");
+    const getParamsForUrl = (href) => {
+      const params = { ...domains };
+      const url = href.toLowerCase();
+      const isMatch = (list) => list.some((d) => url.includes(d));
+      if (platforms.includes("hotmart") && isMatch(PLATFORM_DOMAINS.hotmart)) {
+        if (userId) params.xcod = userId;
+        if (utms.utm_source) params.sck = buildSck();
+      } else if (platforms.includes("kiwify") && isMatch(PLATFORM_DOMAINS.kiwify)) {
+        if (utms.utm_source) params.src = utms.utm_source;
+        if (utms.utm_medium) params.utm_medium = utms.utm_medium;
+        if (utms.utm_campaign) params.utm_campaign = utms.utm_campaign;
+      } else if (platforms.includes("eduzz") && isMatch(PLATFORM_DOMAINS.eduzz)) {
+        if (utms.utm_source) params.src = utms.utm_source;
+      } else if (platforms.includes("monetizze") && isMatch(PLATFORM_DOMAINS.monetizze)) {
+        if (utms.utm_source) params.src = utms.utm_source;
+      } else if (platforms.includes("cartpanda") && isMatch(PLATFORM_DOMAINS.cartpanda)) {
+        Object.entries(utms).forEach(([k, v]) => {
+          if (v) params[k] = v;
+        });
+      } else if (platforms.includes("ticto") && isMatch(PLATFORM_DOMAINS.ticto)) {
+        Object.entries(utms).forEach(([k, v]) => {
+          if (v) params[k] = v;
+        });
+        if (userId) params.user_id = userId;
+      } else {
+        const allDomains = Object.values(PLATFORM_DOMAINS).flat().concat(domains);
+        if (!isMatch(allDomains)) return null;
+        Object.entries(utms).forEach(([k, v]) => {
+          if (v) params[k] = v;
+        });
+        if (userId) params.user_id = userId;
+      }
+      return Object.keys(params).length ? params : null;
+    };
+    const applyParams = (link) => {
+      if (!link.href || link.href.startsWith("javascript")) return;
+      const p = getParamsForUrl(link);
+      if (!p) return;
+      try {
+        const url = new URL(link.href);
+        Object.entries(p).forEach(([k, v]) => url.searchParams.set(k, v));
+        link.href = url.toString();
+      } catch (e) {
+      }
+    };
+    document.querySelectorAll("a[href]").forEach(applyParams);
+    new MutationObserver((mutations) => {
+      mutations.forEach((m) => m.addedNodes.forEach((node) => {
+        var _a;
+        if (node.nodeType !== 1) return;
+        if (node.tagName === "A") applyParams(node);
+        (_a = node.querySelectorAll) == null ? void 0 : _a.call(node, "a[href]").forEach(applyParams);
+      }));
+    }).observe(document.body, { childList: true, subtree: true });
+    console.log("\u2705 PassCheckoutParams inicializado");
+  };
+  var _AFFILIATE_STORAGE_KEY = "_cdp_aff";
+  function _saveAffiliateContext() {
+    if (!isBrowser4) return;
+    try {
+      const hasUtms = Object.values(_utms).some((v) => !!v);
+      const existing = _loadAffiliateContext();
+      if (hasUtms || !existing) {
+        localStorage.setItem(_AFFILIATE_STORAGE_KEY, JSON.stringify({
+          uid: _userId,
+          utms: _utms,
+          ts: Date.now()
+        }));
+      }
+    } catch (e) {
+    }
+  }
+  function _loadAffiliateContext() {
+    if (!isBrowser4) return null;
+    try {
+      const raw = localStorage.getItem(_AFFILIATE_STORAGE_KEY);
+      if (!raw) return null;
+      const ctx = JSON.parse(raw);
+      if (Date.now() - ctx.ts > 30 * 24 * 60 * 60 * 1e3) {
+        localStorage.removeItem(_AFFILIATE_STORAGE_KEY);
+        return null;
+      }
+      return ctx;
+    } catch (e) {
+      return null;
+    }
+  }
+  function getUTMsWithFallback() {
+    const live = getUTMs();
+    if (Object.values(live).some((v) => !!v)) return live;
+    const stored = _loadAffiliateContext();
+    if ((stored == null ? void 0 : stored.utms) && Object.values(stored.utms).some((v) => !!v)) {
+      if (tracking_config_default.debug) console.log("\u2139\uFE0F UTMs restaurados do localStorage (affiliate fallback)");
+      return stored.utms;
+    }
+    return live;
+  }
+  function getUserIdWithFallback() {
+    var _a;
+    return _userId || ((_a = _loadAffiliateContext()) == null ? void 0 : _a.uid) || "";
+  }
+  async function track(eventName, data = {}, options = {}) {
+    if (!isBrowser4) {
+      console.warn("\u26A0\uFE0F cdpTrack.track() deve ser chamado no browser");
+      return { success: false, error: "Not in browser" };
+    }
+    const event_id = generateId();
+    const utms = getUTMs();
+    const clickIds = _getClickIDs();
+    const userId = getUserId();
+    const sessionId = getSessionId();
+    const timestamp = Date.now();
+    const engagementScore = calculateEngagementScore();
+    const { totalScore, timeLevel, scrollScore, clickScore, videoScore, hoverScore, intentionLevel } = engagementScore;
+    const payload = {
+      event_id,
+      event_name: eventName,
+      user_id: userId,
+      session_id: sessionId,
+      utms,
+      click_ids: clickIds,
+      timestamp,
+      page_url: window.location.href,
+      referrer: document.referrer,
+      user_agent: navigator.userAgent,
+      behavioral_data: {
+        ...data,
+        engagement_score: totalScore,
+        time_level: timeLevel,
+        scroll_score: scrollScore,
+        click_score: clickScore,
+        video_score: videoScore,
+        hover_score: hoverScore,
+        intention_level: intentionLevel
+      },
+      ...options
+    };
+    try {
+      const result = await sendWithRetry(payload, "/track");
+      if (result.success) {
+        console.log(`\u2705 Evento ${eventName} enviado com sucesso:`, event_id, result);
+        updateEngagementState("timeOnPage", Math.round((Date.now() - timestamp) / 1e3));
+        updateEngagementState("totalScore", totalScore);
+        return { success: true, event_id, result };
+      } else {
+        throw new Error(result.error || "Envio falhou ap\xF3s todas as tentativas");
+      }
+    } catch (error) {
+      console.error(`\u274C Erro ao enviar evento ${eventName}:`, error);
+      return { success: false, error: error.message, event_id, attempts: ANTI_BLOCKING_CONFIG.maxRetries };
+    }
+  }
+  async function trackLead(userData, form = null) {
+    let piiData = { ...userData };
+    if (form) {
+      const formPII = extractFormPII(form);
+      piiData = { ...piiData, ...formPII };
+    }
+    return track("Lead", piiData);
+  }
+  async function trackPurchase(orderData, form = null) {
+    let purchaseData = { ...orderData };
+    if (form) {
+      const formPII = extractFormPII(form);
+      purchaseData = { ...purchaseData, ...formPII };
+    }
+    return track("Purchase", purchaseData);
+  }
+  function setupAutoFormCapture() {
+    if (!isBrowser4) return;
+    document.addEventListener("submit", async (e) => {
+      const form = e.target;
+      const hasEmailField = form.querySelector('[name*="email"]');
+      const hasPhoneField = form.querySelector('[name*="phone"], [name*="telefone"], [name*="celular"]');
+      if (hasEmailField || hasPhoneField) {
+        e.preventDefault();
+        const piiData = extractFormPII(form);
+        if (isValidPII(piiData)) {
+          await trackLead(piiData, form);
+          console.log("\u2705 Lead capturado automaticamente com Advanced Matching:", piiData);
+        }
+        setTimeout(() => form.submit(), 100);
+      }
+    }, true);
+  }
+  async function trackViewContent(contentData) {
+    return track("ViewContent", contentData);
+  }
+  async function trackAddToCart(cartData) {
+    return track("AddToCart", cartData);
+  }
+  async function init() {
+    var _a, _b;
+    if (!isBrowser4) return;
+    if (tracking_config_default.debug) console.log("\u{1F680} Inicializando cdpTrack SDK...");
+    initConsentMode();
+    initAntiBlocking();
+    _saveAffiliateContext();
+    initMicroEvents();
+    if (tracking_config_default.autoCaptureForms !== false) {
+      setupAutoFormCapture();
+    }
+    window.cdpTrack = { track, trackLead, trackPurchase, trackViewContent, trackAddToCart, getUserId, getUserIdWithFallback, getSessionId, getUTMs, getUTMsWithFallback, updateConsent };
+    if (tracking_config_default.initBehaviorEngine !== false) {
+      try {
+        const behaviorModule = await Promise.resolve().then(() => (init_behavior_engine(), behavior_engine_exports));
+        const BehaviorEngine2 = behaviorModule.default;
+        if (BehaviorEngine2 && typeof BehaviorEngine2.init === "function") {
+          BehaviorEngine2.init();
+          if (tracking_config_default.debug) console.log("\u2705 Behavior Engine inicializado");
+        }
+      } catch (error) {
+        if (tracking_config_default.debug) console.info("\u2139\uFE0F Behavior Engine n\xE3o dispon\xEDvel:", error.message);
+      }
+    }
+    if (tracking_config_default.passCheckoutParams !== false && ((_a = tracking_config_default.platforms) == null ? void 0 : _a.length) > 0) {
+      passCheckoutParams({ platforms: tracking_config_default.platforms });
+    }
+    if ((_b = tracking_config_default.routeIntent) == null ? void 0 : _b.whatsappNumber) {
+      initRouteIntentCapture(tracking_config_default.routeIntent);
+    }
+    if (tracking_config_default.debug) console.log("\u2705 cdpTrack SDK inicializado (Quantum Tier)");
+  }
+  if (isBrowser4) {
+    window.addEventListener("DOMContentLoaded", init);
+  }
+  return __toCommonJS(cdpTrack_exports);
+})();