RubyGems - ahoy_analytics - Versions diffs - 0.1.0 - Mend

ahoy_analytics 0.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (198) hide show

data/app/frontend/entrypoints/analytics-tracker.ts ADDED Viewed

@@ -0,0 +1,680 @@
+/**
+ * Standalone Analytics Tracker
+ *
+ * Universal tracker that works with:
+ * - Multi-page apps (traditional server-rendered navigation)
+ * - Single-page apps (React Router, Vue Router, Inertia.js, etc.)
+ * - Hybrid apps (mix of both)
+ *
+ * Similar to Plausible.io, wraps the History API to detect navigation.
+ * Usage: Add to <head> with <%= ahoy_analytics_tracking_tag %>
+ */
+interface AnalyticsConfig {
+  // Ahoy endpoints
+  eventsEndpoint: string
+  visitsEndpoint: string
+  // Filters
+  excludePaths: string[]
+  includePaths?: string[] // if provided, only paths matching any will be tracked (plausible-style)
+  excludeAssets: string[]
+  // Storage + transport
+  useCookies: boolean // true = cookies (ahoy.js style); false = cookieless (localStorage). Default: false
+  visitDurationMinutes: number // new visit after X minutes of inactivity. Default: 240 (4h)
+  useBeaconForEvents: boolean // prefer sendBeacon for events. Default: true
+  trackVisits: boolean // create visit on frontend. Default: true
+  // Routing behavior
+  hashBasedRouting?: boolean // when true, treat hash changes as navigation (off by default)
+  // Dev
+  debug?: boolean
+}
+class StandaloneAnalytics {
+  private visitToken: string | null = null
+  private visitExpiresAt: number | null = null
+  private visitorToken: string | null = null
+  private lastTrackedHref: string | null = null
+  // Dedup key for pageviews: pathname + search (or + hash if hashBasedRouting)
+  private lastTrackedPageKey: string | null = null
+  private config: AnalyticsConfig
+  private ensureVisitPromise: Promise<void> | null = null
+  // Engagement tracking state (plausible-like)
+  private listeningOnEngagement = false
+  private currentEngagementIgnored = false
+  private currentEngagementURL: string | null = null
+  private currentEngagementMaxScrollDepth = -1
+  private runningEngagementStart = 0
+  private currentEngagementTime = 0
+  private currentDocumentHeight = 0
+  private maxScrollDepthPx = 0
+  constructor() {
+    this.config = {
+      eventsEndpoint: '/ahoy/events',
+      visitsEndpoint: '/ahoy/visits',
+      // Defaults similar to our app; can be overridden by data-* attributes or window.analyticsConfig
+      // Exclude internal/system endpoints to avoid accidental tracking
+      excludePaths: ['/admin', '/.well-known', '/ahoy', '/cable'],
+      excludeAssets: [
+        '.png', '.jpg', '.jpeg', '.gif', '.svg', '.webp', '.ico',
+        '.woff', '.woff2', '.ttf', '.eot', '.otf',
+        '.pdf', '.zip', '.tar', '.gz',
+        '.mp4', '.webm', '.mp3', '.wav',
+        '.css', '.js', '.map', '.json'
+      ],
+      useCookies: false,
+      visitDurationMinutes: 30, // create a new visit after 30 minutes of inactivity (web analytics standard)
+      useBeaconForEvents: true,
+      trackVisits: true,
+      hashBasedRouting: false,
+      debug: false,
+    }
+  }
+  init(): void {
+    if (typeof window === 'undefined') return
+    // Optional runtime overrides via window.analyticsConfig
+    try {
+      const overrides = (window as any).analyticsConfig as Partial<AnalyticsConfig> | undefined
+      if (overrides && typeof overrides === 'object') {
+        this.config = { ...this.config, ...overrides }
+      }
+    } catch {}
+    // Read plausible-style include/exclude from script tag if present
+    this.readScriptAttributes()
+    // Load tokens (meta or storage) and ensure a visit exists
+    this.bootstrapIdentity()
+    if (this.config.trackVisits) this.ensureVisitPromise = this.ensureActiveVisit()
+    // Track initial page load only when the document is visible.
+    // This prevents background prerenders/prefetches from counting and avoids
+    // double pageviews when a hidden page is spun up by the browser.
+    const trackWhenVisible = () => {
+      if (document.visibilityState === 'visible') {
+        document.removeEventListener('visibilitychange', trackWhenVisible)
+        void this.trackPageview()
+      }
+    }
+    const triggerInitial = () => {
+      if (document.visibilityState === 'visible') {
+        void this.trackPageview()
+      } else {
+        document.addEventListener('visibilitychange', trackWhenVisible)
+      }
+    }
+    if (document.readyState === 'loading') {
+      document.addEventListener('DOMContentLoaded', triggerInitial)
+    } else {
+      triggerInitial()
+    }
+    // Listen for navigation events (works with both regular links and Inertia)
+    this.setupNavigationListener()
+    // Engagement and auto-capture listeners
+    this.initEngagement()
+    this.initAutoCapture()
+  }
+  private bootstrapIdentity(): void {
+    // First try meta tokens (if server provided)
+    const visitMeta = document.querySelector<HTMLMetaElement>('meta[name="ahoy-visit"]')
+    const visitorMeta = document.querySelector<HTMLMetaElement>('meta[name="ahoy-visitor"]')
+    if (visitMeta?.content) this.visitToken = visitMeta.content
+    if (visitorMeta?.content) this.visitorToken = visitorMeta.content
+    // Load from storage if missing (supports cookies or localStorage)
+    if (!this.visitorToken) this.visitorToken = this.getOrCreateVisitorToken()
+    // visit may expire; refresh if needed
+    const vt = this.getStoredVisit()
+    if (vt) {
+      this.visitToken = vt.token
+      this.visitExpiresAt = vt.expiresAt
+    }
+    if (!this.visitToken || this.isVisitExpired()) {
+      this.createNewVisitToken()
+    }
+  }
+  private setupNavigationListener(): void {
+    // Wrap history.pushState and history.replaceState to detect SPA navigation
+    // This works for ANY SPA framework (React Router, Vue Router, Inertia, etc.)
+    const originalPushState = history.pushState
+    const originalReplaceState = history.replaceState
+    if (originalPushState) {
+      history.pushState = (...args) => {
+        this.prePageview()
+        originalPushState.apply(history, args)
+        if (this.config.debug) console.debug('[analytics] pushState')
+        void this.trackPageview()
+      }
+    }
+    // Keep replaceState hook to catch rare replace-only navigations (e.g., Inertia Link with `replace`),
+    // while dedup in trackPageview() ensures we don't double count when frameworks call replaceState
+    // after pushState to update state/scroll.
+    if (originalReplaceState) {
+      history.replaceState = (...args) => {
+        this.prePageview()
+        originalReplaceState.apply(history, args)
+        if (this.config.debug) console.debug('[analytics] replaceState')
+        void this.trackPageview()
+      }
+    }
+    // Listen for popstate (back/forward buttons)
+    window.addEventListener('popstate', () => {
+      this.prePageview()
+      if (this.config.debug) console.debug('[analytics] popstate')
+      void this.trackPageview()
+    })
+    // Optional: treat hash changes as navigation (off by default)
+    if (this.config.hashBasedRouting) {
+      window.addEventListener('hashchange', () => {
+        this.prePageview()
+        if (this.config.debug) console.debug('[analytics] hashchange')
+        void this.trackPageview()
+      })
+    }
+  }
+  private async trackPageview(): Promise<void> {
+    if (typeof window === 'undefined') return
+    // Skip tracking in iframes to avoid embedded/preview contexts skewing data
+    try { if (window.top !== window.self) return } catch { /* cross-origin, treat as iframe */ return }
+    const href = window.location.href
+    const pathname = window.location.pathname
+    const pathQuery = pathname + window.location.search
+    const pageKey = this.config.hashBasedRouting ? (pathQuery + window.location.hash) : pathQuery
+    // Skip if same path+query as last tracked (ignore hash-only changes)
+    if (this.lastTrackedPageKey === pageKey) return
+    // Claim this pageKey immediately to avoid double-fire when pushState/replaceState
+    // happen back-to-back during the same navigation tick (Inertia / SPA frameworks).
+    this.lastTrackedPageKey = pageKey
+    if (this.config.debug) console.debug('[analytics] trackPageview pageKey=', pageKey)
+    // Skip excluded paths
+    if (this.shouldExclude(pathname)) {
+      this.lastTrackedHref = href
+      return
+    }
+    // Ensure the visit is created before the first pageview to avoid
+    // the server implicitly creating a visit for /ahoy/events
+    if (this.ensureVisitPromise) {
+      try { await this.ensureVisitPromise } catch {}
+    }
+    const referrer = this.lastTrackedHref || document.referrer || ''
+    // Plausible-style event name and props
+    this.sendEvent({
+      name: 'pageview',
+      page: pathQuery,
+      url: href,
+      title: document.title,
+      referrer,
+      screenSize: `${window.innerWidth}x${window.innerHeight}`
+    })
+    this.lastTrackedHref = href
+    this.postPageview({ url: href, page: pathQuery })
+  }
+  private shouldExclude(pathname: string): boolean {
+    const lowerPath = pathname.toLowerCase()
+    // Exclude admin paths
+    if (this.config.excludePaths.some(path => lowerPath.startsWith(path))) {
+      return true
+    }
+    // Exclude static assets
+    if (this.config.excludeAssets.some(ext => lowerPath.endsWith(ext))) {
+      return true
+    }
+    // Exclude special files
+    const specialFiles = [
+      '/favicon.ico',
+      '/robots.txt',
+      '/sitemap.xml',
+      '/manifest.json',
+      '/browserconfig.xml',
+      // Chrome DevTools well-known JSON
+      '/.well-known/appspecific/com.chrome.devtools.json'
+    ]
+    if (specialFiles.includes(lowerPath)) {
+      return true
+    }
+    // Exclude apple-touch-icon variants
+    if (lowerPath.includes('apple-touch-icon')) {
+      return true
+    }
+    // Apply plausible-style include/exclude rules
+    const inc = this.config.includePaths && this.config.includePaths.length > 0
+    if (inc) {
+      const pass = this.config.includePaths!.some((p) => this.pathMatches(p, lowerPath))
+      if (!pass) return true
+    }
+    if (this.config.excludePaths && this.config.excludePaths.length > 0) {
+      if (this.config.excludePaths.some((p) => this.pathMatches(p, lowerPath))) return true
+    }
+    return false
+  }
+  private sendEvent(properties: {
+    name: string
+    page: string
+    url: string
+    title: string
+    referrer: string
+    screenSize: string
+  }, extra?: Record<string, any>): void {
+    if (typeof window === 'undefined') return
+    const event = {
+      name: properties.name,
+      properties: {
+        page: properties.page,
+        url: properties.url,
+        title: properties.title,
+        referrer: properties.referrer,
+        screen_size: properties.screenSize,
+        ...(extra || {})
+      },
+      time: Date.now() / 1000
+    }
+    if (this.config.debug) {
+      try {
+        console.debug('[analytics] sendEvent', { name: event.name, page: (event as any).properties.page, url: (event as any).properties.url })
+      } catch {}
+    }
+    // Prefer sendBeacon with FormData + authenticity_token (like ahoy.js)
+    const canBeacon = this.config.useBeaconForEvents && typeof navigator.sendBeacon === 'function'
+    if (canBeacon) {
+      const data: Record<string, string> = {}
+      // Ahoy expects events_json to be a JSON string of the events array (not wrapped)
+      data['events_json'] = JSON.stringify([event])
+      // Include tokens explicitly so we can be cookieless
+      if (this.visitToken) data['visit_token'] = this.visitToken
+      if (this.visitorToken) data['visitor_token'] = this.visitorToken
+      // Rails CSRF param/name
+      const csrfParam = this.getCSRFParam()
+      const csrfToken = this.getCSRFToken()
+      if (csrfParam && csrfToken) data[csrfParam] = csrfToken
+      const form = new FormData()
+      Object.entries(data).forEach(([k, v]) => form.append(k, v))
+      navigator.sendBeacon(this.config.eventsEndpoint, form)
+      return
+    }
+    // Fallback: JSON + CSRF header via fetch
+    const headers: Record<string, string> = { 'Content-Type': 'application/json' }
+    const csrfToken = this.getCSRFToken()
+    if (csrfToken) headers['X-CSRF-Token'] = csrfToken
+    const jsonPayload = {
+      visit_token: this.visitToken,
+      visitor_token: this.visitorToken,
+      events: [event]
+    }
+    fetch(this.config.eventsEndpoint, {
+      method: 'POST',
+      headers,
+      body: JSON.stringify(jsonPayload),
+      credentials: 'same-origin',
+      keepalive: true
+    }).catch(() => { /* never block app */ })
+  }
+  private generateToken(): string {
+    // Generate random token (UUIDv4-like hex)
+    const cryptoObj = (typeof globalThis !== 'undefined' ? (globalThis as any).crypto : undefined) as Crypto | undefined
+    if (cryptoObj?.randomUUID) return cryptoObj.randomUUID().replace(/-/g, '')
+    const array = new Uint8Array(16)
+    if (cryptoObj?.getRandomValues) {
+      cryptoObj.getRandomValues(array)
+    } else {
+      // Fallback to Math.random when Web Crypto is unavailable (very rare)
+      for (let i = 0; i < array.length; i++) array[i] = Math.floor(Math.random() * 256)
+    }
+    return Array.from(array, b => b.toString(16).padStart(2, '0')).join('')
+  }
+  private getOrCreateVisitorToken(): string {
+    if (this.config.useCookies) {
+      const cookie = this.getCookie('ahoy_visitor')
+      if (cookie) return cookie
+      const token = this.generateToken()
+      this.setCookie('ahoy_visitor', token, 60 * 24 * 365 * 2) // 2 years
+      return token
+    } else {
+      const stored = localStorage.getItem('ahoy_visitor')
+      if (stored) return stored
+      const token = this.generateToken()
+      localStorage.setItem('ahoy_visitor', token)
+      return token
+    }
+  }
+  private getCSRFToken(): string | null {
+    const meta = document.querySelector<HTMLMetaElement>('meta[name="csrf-token"]')
+    return meta?.content || null
+  }
+  private getCSRFParam(): string | null {
+    const meta = document.querySelector<HTMLMetaElement>('meta[name="csrf-param"]')
+    return meta?.content || null
+  }
+  // ----- Visit lifecycle -----
+  private isVisitExpired(): boolean {
+    if (!this.visitExpiresAt) return true
+    return Date.now() > this.visitExpiresAt
+  }
+  private createNewVisitToken(): void {
+    this.visitToken = this.generateToken()
+    const ttlMs = this.config.visitDurationMinutes * 60 * 1000
+    this.visitExpiresAt = Date.now() + ttlMs
+    this.storeVisit(this.visitToken, this.visitExpiresAt)
+  }
+  private ensureActiveVisit(): Promise<void> {
+    if (!this.visitToken || this.isVisitExpired()) this.createNewVisitToken()
+    // Send visit to server (JSON + CSRF header); mirrors ahoy.js createVisit
+    const payload: Record<string, any> = {
+      visit_token: this.visitToken,
+      visitor_token: this.visitorToken,
+      platform: 'Web',
+      landing_page: window.location.href,
+      screen_width: window.innerWidth,
+      screen_height: window.innerHeight,
+      screen_size: `${window.innerWidth}x${window.innerHeight}`,
+      js: true
+    }
+    if (document.referrer) payload.referrer = document.referrer
+    // Include UTM parameters from the landing URL (Plausible-compatible behavior)
+    try {
+      const params = new URLSearchParams(window.location.search)
+      const utm_source = params.get('utm_source') || params.get('source') || params.get('ref')
+      const utm_medium = params.get('utm_medium')
+      const utm_campaign = params.get('utm_campaign')
+      const utm_content = params.get('utm_content')
+      const utm_term = params.get('utm_term')
+      if (utm_source) payload.utm_source = utm_source
+      if (utm_medium) payload.utm_medium = utm_medium
+      if (utm_campaign) payload.utm_campaign = utm_campaign
+      if (utm_content) payload.utm_content = utm_content
+      if (utm_term) payload.utm_term = utm_term
+    } catch {}
+    const headers: Record<string, string> = { 'Content-Type': 'application/json' }
+    const csrf = this.getCSRFToken()
+    if (csrf) headers['X-CSRF-Token'] = csrf
+    return fetch(this.config.visitsEndpoint, {
+      method: 'POST',
+      headers,
+      body: JSON.stringify(payload),
+      credentials: 'same-origin',
+      keepalive: true
+    }).then(() => { /* ok */ }).catch(() => { /* ignore analytics errors */ })
+  }
+  private getStoredVisit(): { token: string, expiresAt: number } | null {
+    if (this.config.useCookies) {
+      const token = this.getCookie('ahoy_visit')
+      const exp = this.getCookie('ahoy_visit_expires')
+      if (token && exp) return { token, expiresAt: parseInt(exp, 10) }
+      return null
+    } else {
+      const token = localStorage.getItem('ahoy_visit')
+      const exp = localStorage.getItem('ahoy_visit_expires')
+      if (token && exp) return { token, expiresAt: parseInt(exp, 10) }
+      return null
+    }
+  }
+  private storeVisit(token: string, expiresAt: number): void {
+    if (this.config.useCookies) {
+      this.setCookie('ahoy_visit', token, this.config.visitDurationMinutes)
+      // store absolute expiry (ms since epoch)
+      this.setCookie('ahoy_visit_expires', String(expiresAt), this.config.visitDurationMinutes)
+    } else {
+      localStorage.setItem('ahoy_visit', token)
+      localStorage.setItem('ahoy_visit_expires', String(expiresAt))
+    }
+  }
+  // ----- Cookie helpers -----
+  private setCookie(name: string, value: string, ttlMinutes: number) {
+    const d = new Date()
+    d.setTime(d.getTime() + ttlMinutes * 60 * 1000)
+    document.cookie = `${name}=${encodeURIComponent(value)}; expires=${d.toUTCString()}; path=/; samesite=lax`
+  }
+  private getCookie(name: string): string | null {
+    const match = document.cookie.match(new RegExp('(^|; )' + name.replace(/([.$?*|{}()\[\]\\/+^])/g, '\\$1') + '=([^;]*)'))
+    return match ? decodeURIComponent(match[2]) : null
+  }
+  // ----- Engagement (Plausible-like) -----
+  private initEngagement(): void {
+    this.currentDocumentHeight = this.getDocumentHeight()
+    this.maxScrollDepthPx = this.getCurrentScrollDepthPx()
+    window.addEventListener('load', () => {
+      this.currentDocumentHeight = this.getDocumentHeight()
+      let count = 0
+      const interval = setInterval(() => {
+        this.currentDocumentHeight = this.getDocumentHeight()
+        if (++count === 15) clearInterval(interval)
+      }, 200)
+    })
+    document.addEventListener('scroll', () => {
+      this.currentDocumentHeight = this.getDocumentHeight()
+      const cur = this.getCurrentScrollDepthPx()
+      if (cur > this.maxScrollDepthPx) this.maxScrollDepthPx = cur
+    })
+  }
+  private prePageview(): void {
+    if (this.listeningOnEngagement) {
+      this.triggerEngagement()
+      this.currentDocumentHeight = this.getDocumentHeight()
+      this.maxScrollDepthPx = this.getCurrentScrollDepthPx()
+    }
+  }
+  private postPageview(payload: { url: string, page: string }): void {
+    this.currentEngagementIgnored = false
+    this.currentEngagementURL = payload.url
+    this.currentEngagementMaxScrollDepth = -1
+    this.currentEngagementTime = 0
+    this.runningEngagementStart = Date.now()
+    this.registerEngagementListeners()
+  }
+  private onVisibilityChange = (): void => {
+    if (document.visibilityState === 'visible' && document.hasFocus() && this.runningEngagementStart === 0) {
+      this.runningEngagementStart = Date.now()
+    } else if (document.visibilityState === 'hidden' || !document.hasFocus()) {
+      this.currentEngagementTime = this.getEngagementTime()
+      this.runningEngagementStart = 0
+      this.triggerEngagement()
+    }
+  }
+  private registerEngagementListeners(): void {
+    if (!this.listeningOnEngagement) {
+      document.addEventListener('visibilitychange', this.onVisibilityChange)
+      window.addEventListener('blur', this.onVisibilityChange)
+      window.addEventListener('focus', this.onVisibilityChange)
+      this.listeningOnEngagement = true
+    }
+  }
+  private getEngagementTime(): number {
+    if (this.runningEngagementStart) {
+      return this.currentEngagementTime + (Date.now() - this.runningEngagementStart)
+    } else {
+      return this.currentEngagementTime
+    }
+  }
+  private triggerEngagement(): void {
+    const engagementTime = this.getEngagementTime()
+    const increasedScroll = this.currentEngagementMaxScrollDepth < this.maxScrollDepthPx
+    // Send if first engagement (maxScrollDepth=-1), or scroll increased, or >=3s engaged
+    if (!this.currentEngagementIgnored && (increasedScroll || engagementTime >= 3000 || this.currentEngagementMaxScrollDepth === -1)) {
+      this.currentEngagementMaxScrollDepth = this.maxScrollDepthPx
+      const sd = this.currentDocumentHeight > 0 ? Math.round((this.maxScrollDepthPx / this.currentDocumentHeight) * 100) : 0
+      const url = this.currentEngagementURL || window.location.href
+      this.sendEvent({
+        name: 'engagement',
+        page: window.location.pathname + window.location.search,
+        url,
+        title: document.title,
+        referrer: document.referrer || '',
+        screenSize: `${window.innerWidth}x${window.innerHeight}`
+      }, { engaged_ms: engagementTime, scroll_depth: sd })
+      // Reset timers
+      this.runningEngagementStart = 0
+      this.currentEngagementTime = 0
+    }
+  }
+  private getDocumentHeight(): number {
+    const body = document.body as HTMLElement | null
+    const el = document.documentElement as HTMLElement | null
+    const b = body || ({} as any)
+    const d = el || ({} as any)
+    return Math.max(
+      b.scrollHeight || 0,
+      b.offsetHeight || 0,
+      b.clientHeight || 0,
+      d.scrollHeight || 0,
+      d.offsetHeight || 0,
+      d.clientHeight || 0
+    )
+  }
+  private getCurrentScrollDepthPx(): number {
+    const body = document.body as HTMLElement | null
+    const el = document.documentElement as HTMLElement | null
+    const viewportHeight = window.innerHeight || (el && el.clientHeight) || 0
+    const scrollTop = window.scrollY || (el && (el as any).scrollTop) || (body && (body as any).scrollTop) || 0
+    return this.currentDocumentHeight <= viewportHeight ? this.currentDocumentHeight : (scrollTop as number) + viewportHeight
+  }
+  // ----- Auto-capture: outbound links & file downloads -----
+  private initAutoCapture(): void {
+    const handler = (event: Event) => {
+      // auxclick only for middle button
+      if (event.type === 'auxclick' && (event as MouseEvent).button !== 1) return
+      const link = this.getLinkEl(event.target as Element | null)
+      if (!link || !link.href) return
+      try {
+        const url = new URL(link.href, window.location.origin)
+        // Ignore well-known DevTools config file
+        if (url.pathname.startsWith('/.well-known/')) return
+      } catch {}
+      const hrefWithoutQuery = link.href.split('?')[0]
+      if (this.isOutboundLink(link)) {
+        this.sendEvent({ name: 'Outbound Link: Click', page: window.location.pathname + window.location.search, url: link.href, title: document.title, referrer: document.referrer || '', screenSize: `${window.innerWidth}x${window.innerHeight}` })
+        return
+      }
+      if (this.isDownloadToTrack(hrefWithoutQuery)) {
+        this.sendEvent({ name: 'File Download', page: window.location.pathname + window.location.search, url: hrefWithoutQuery, title: document.title, referrer: document.referrer || '', screenSize: `${window.innerWidth}x${window.innerHeight}` })
+      }
+    }
+    document.addEventListener('click', handler)
+    document.addEventListener('auxclick', handler)
+  }
+  // Parse plausible-style data attributes from the <script> element that loaded this file
+  private readScriptAttributes(): void {
+    try {
+      const scripts = Array.from(document.getElementsByTagName('script')) as HTMLScriptElement[]
+      // Heuristic: find a script whose src contains 'analytics' and either data-include or data-exclude set
+      const el = scripts.reverse().find((s) => (s.getAttribute('data-include') || s.getAttribute('data-exclude') || (s.src && s.src.includes('analytics'))))
+      if (!el) return
+      const includeAttr = el.getAttribute('data-include')
+      const excludeAttr = el.getAttribute('data-exclude')
+      if (includeAttr) this.config.includePaths = includeAttr.split(',').map((t) => t.trim()).filter(Boolean)
+      if (excludeAttr) this.config.excludePaths = [...this.config.excludePaths, ...excludeAttr.split(',').map((t) => t.trim()).filter(Boolean)]
+    } catch {}
+  }
+  // Wildcard matching similar to Plausible tracker
+  // Supports '*' (single segment) and '**' (any), anchored to start and end by default
+  private pathMatches(wildcardPath: string, actualPath: string): boolean {
+    const wc = wildcardPath.trim()
+    const pattern = '^' + wc
+      .replace(/\./g, '\\.')
+      .replace(/\*\*/g, '.*')
+      .replace(/([^\\])\*/g, '$1[^\\s\/]*') + '\\/?$'
+    try {
+      return new RegExp(pattern).test(actualPath)
+    } catch {
+      return false
+    }
+  }
+  private getLinkEl(node: Element | null): HTMLAnchorElement | null {
+    let el: Element | null = node
+    let depth = 0
+    while (el && depth < 5) {
+      if (el instanceof HTMLAnchorElement && el.href) return el
+      el = el.parentElement
+      depth++
+    }
+    return null
+  }
+  private isOutboundLink(link: HTMLAnchorElement): boolean {
+    try {
+      return !!link.host && link.host !== window.location.host
+    } catch { return false }
+  }
+  private isDownloadToTrack(url: string | undefined | null): boolean {
+    if (!url) return false
+    const DEFAULT_FILE_TYPES = ['pdf','xlsx','docx','txt','rtf','csv','exe','key','pps','ppt','pptx','7z','pkg','rar','gz','zip','avi','mov','mp4','mpeg','wmv','midi','mp3','wav','wma','dmg']
+    const ext = url.split('.').pop()?.toLowerCase()
+    return !!ext && DEFAULT_FILE_TYPES.includes(ext)
+  }
+}
+// Auto-initialize when script loads (singleton pattern)
+if (typeof window !== 'undefined') {
+  // Prevent multiple instances
+  if (!(window as any).__analyticsInitialized) {
+    const analytics = new StandaloneAnalytics()
+    analytics.init()
+    ;(window as any).__analyticsInitialized = true
+  }
+}