@stacksjs/ts-analytics 0.1.6

package/dist/batching.d.ts

@@ -0,0 +1,93 @@
+import type { CustomEvent, PageView, Session } from './types';
+/**
+ * Create a batch processor for processing events in bulk
+ */
+export declare function createBatchProcessor<T>(processor: (batch: T[]) => Promise<void>, options?: { batchSize?: number, delayMs?: number }): {
+    add: (item: T) => void
+    flush: () => Promise<void>
+    size: () => number
+  };
+/**
+ * Retry helper with exponential backoff
+ */
+export declare function withRetry<T>(fn: () => Promise<T>, options?: { maxRetries?: number, baseDelayMs?: number }): Promise<T>;
+/**
+ * Chunk an array into smaller arrays
+ */
+export declare function chunk<T>(array: T[], size: number): T[][];
+/**
+ * Process items in parallel with concurrency limit
+ */
+export declare function parallelProcess<T, R>(items: T[], processor: (item: T) => Promise<R>, concurrency?: number): Promise<R[]>;
+// ============================================================================
+// Types
+// ============================================================================
+export declare interface BatchItem {
+  type: 'pageview' | 'session' | 'event'
+  data: PageView | Session | CustomEvent
+}
+export declare interface BatchWriteResult {
+  successful: number
+  failed: number
+  unprocessedItems: BatchItem[]
+}
+export declare interface BatchQueueOptions {
+  maxBatchSize?: number
+  flushIntervalMs?: number
+  maxQueueSize?: number
+  onError?: (error: Error, items: BatchItem[]) => void
+  onFlush?: (result: BatchWriteResult) => void
+}
+export declare interface DynamoDBBatchClient {
+  batchWriteItem: (input: BatchWriteInput) => Promise<BatchWriteOutput>
+}
+declare interface BatchWriteInput {
+  RequestItems: Record<string, WriteRequest[]>
+}
+declare interface BatchWriteOutput {
+  UnprocessedItems?: Record<string, WriteRequest[]>
+}
+declare interface WriteRequest {
+  PutRequest?: {
+    Item: Record<string, AttributeValue>
+  }
+}
+declare interface AttributeValue {
+  S?: string
+  N?: string
+  BOOL?: boolean
+  L?: AttributeValue[]
+  M?: Record<string, AttributeValue>
+}
+/**
+ * High-performance event batch queue
+ *
+ * @example
+ * ```ts
+ * const queue = new EventBatchQueue(dynamoClient, {
+ *   maxBatchSize: 25,
+ *   flushIntervalMs: 5000,
+ *   onFlush: (result) => console.log(`Flushed ${result.successful} items`),
+ * })
+ *
+ * // Add events (auto-batched)
+ * queue.addPageView(pageView)
+ * queue.addSession(session)
+ *
+ * // Manual flush if needed
+ * await queue.flush()
+ *
+ * // Shutdown gracefully
+ * await queue.close()
+ * ```
+ */
+export declare class EventBatchQueue {
+  constructor(client: DynamoDBBatchClient, options?: BatchQueueOptions);
+  addPageView(pageView: PageView): void;
+  addSession(session: Session): void;
+  addEvent(event: CustomEvent): void;
+  add(item: BatchItem): void;
+  flush(): Promise<BatchWriteResult>;
+  close(): Promise<void>;
+  get size(): number;
+}

package/dist/chunk-2mx7fq49.js

@@ -0,0 +1,4 @@
+// @bun
+var __require = import.meta.require;
+
+export { __require };

package/dist/chunk-3z29508k.js

@@ -0,0 +1,204 @@
+// @bun
+// src/config.ts
+var defaultSingleTableConfig = {
+  enabled: true,
+  partitionKeyName: "pk",
+  sortKeyName: "sk",
+  gsi1pkName: "gsi1pk",
+  gsi1skName: "gsi1sk",
+  gsi2pkName: "gsi2pk",
+  gsi2skName: "gsi2sk",
+  entityTypeAttribute: "_et",
+  pkPrefix: "{ENTITY}#",
+  skPrefix: "{ENTITY}#",
+  gsiCount: 2,
+  keyDelimiter: "#"
+};
+var defaultGSIs = [
+  {
+    name: "gsi1",
+    partitionKey: "gsi1pk",
+    sortKey: "gsi1sk",
+    projection: { type: "ALL" }
+  },
+  {
+    name: "gsi2",
+    partitionKey: "gsi2pk",
+    sortKey: "gsi2sk",
+    projection: { type: "ALL" }
+  }
+];
+var defaultAnalyticsConfig = {
+  tableName: "AnalyticsTable",
+  billingMode: "PAY_PER_REQUEST",
+  singleTable: defaultSingleTableConfig,
+  globalSecondaryIndexes: defaultGSIs,
+  localSecondaryIndexes: [],
+  ttlAttributeName: "ttl"
+};
+var ONE_DAY = 24 * 60 * 60;
+var THIRTY_DAYS = 30 * ONE_DAY;
+var NINETY_DAYS = 90 * ONE_DAY;
+var TWO_YEARS = 2 * 365 * ONE_DAY;
+var defaultConfig = {
+  table: defaultAnalyticsConfig,
+  region: "us-east-1",
+  endpoint: undefined,
+  retention: {
+    rawEventTtl: THIRTY_DAYS,
+    hourlyAggregateTtl: NINETY_DAYS,
+    dailyAggregateTtl: TWO_YEARS,
+    monthlyAggregateTtl: undefined
+  },
+  privacy: {
+    hashVisitorIds: true,
+    collectGeolocation: false,
+    honorDnt: true,
+    ipAnonymization: "partial"
+  },
+  tracking: {
+    trackReferrers: true,
+    trackUtmParams: true,
+    trackDeviceType: true,
+    trackHashChanges: false,
+    trackOutboundLinks: true,
+    excludedIps: [],
+    excludedPaths: []
+  },
+  api: {
+    basePath: "/api/analytics",
+    corsOrigins: ["*"]
+  },
+  aggregation: {
+    batchSize: 100,
+    hourlyEnabled: true,
+    dailyEnabled: true,
+    monthlyEnabled: true
+  },
+  scale: {
+    sqsBuffering: {
+      enabled: false,
+      queueUrl: undefined,
+      deadLetterQueueUrl: undefined,
+      maxRetries: 3
+    },
+    daxCaching: {
+      enabled: false,
+      endpoint: undefined,
+      ttlSeconds: 300
+    },
+    partitionSharding: {
+      enabled: false,
+      shardCount: 10,
+      enabledSiteIds: []
+    },
+    writeCoalescing: {
+      enabled: true,
+      windowMs: 100
+    },
+    batchWrites: {
+      enabled: true,
+      maxBatchSize: 25,
+      flushIntervalMs: 1000
+    }
+  }
+};
+function defineConfig(userConfig = {}) {
+  return {
+    table: {
+      ...defaultConfig.table,
+      ...userConfig.table,
+      singleTable: {
+        ...defaultConfig.table.singleTable,
+        ...userConfig.table?.singleTable
+      },
+      globalSecondaryIndexes: userConfig.table?.globalSecondaryIndexes ?? defaultConfig.table.globalSecondaryIndexes,
+      localSecondaryIndexes: userConfig.table?.localSecondaryIndexes ?? defaultConfig.table.localSecondaryIndexes
+    },
+    region: userConfig.region ?? defaultConfig.region,
+    endpoint: userConfig.endpoint ?? defaultConfig.endpoint,
+    retention: {
+      ...defaultConfig.retention,
+      ...userConfig.retention
+    },
+    privacy: {
+      ...defaultConfig.privacy,
+      ...userConfig.privacy
+    },
+    tracking: {
+      ...defaultConfig.tracking,
+      ...userConfig.tracking
+    },
+    api: {
+      ...defaultConfig.api,
+      ...userConfig.api
+    },
+    aggregation: {
+      ...defaultConfig.aggregation,
+      ...userConfig.aggregation
+    },
+    scale: {
+      sqsBuffering: {
+        ...defaultConfig.scale.sqsBuffering,
+        ...userConfig.scale?.sqsBuffering
+      },
+      daxCaching: {
+        ...defaultConfig.scale.daxCaching,
+        ...userConfig.scale?.daxCaching
+      },
+      partitionSharding: {
+        ...defaultConfig.scale.partitionSharding,
+        ...userConfig.scale?.partitionSharding
+      },
+      writeCoalescing: {
+        ...defaultConfig.scale.writeCoalescing,
+        ...userConfig.scale?.writeCoalescing
+      },
+      batchWrites: {
+        ...defaultConfig.scale.batchWrites,
+        ...userConfig.scale?.batchWrites
+      }
+    }
+  };
+}
+function getTableConfig(config) {
+  return {
+    tableName: config.table.tableName,
+    billingMode: config.table.billingMode,
+    partitionKey: config.table.singleTable.partitionKeyName,
+    sortKey: config.table.singleTable.sortKeyName,
+    gsis: config.table.globalSecondaryIndexes,
+    ttlAttribute: config.table.ttlAttributeName
+  };
+}
+function getTtlForEntity(config, entityType) {
+  const now = Math.floor(Date.now() / 1000);
+  switch (entityType) {
+    case "raw":
+      return now + config.retention.rawEventTtl;
+    case "hourly":
+      return now + config.retention.hourlyAggregateTtl;
+    case "daily":
+      return now + config.retention.dailyAggregateTtl;
+    case "monthly":
+      return config.retention.monthlyAggregateTtl ? now + config.retention.monthlyAggregateTtl : undefined;
+    default:
+      return;
+  }
+}
+var _config = null;
+function setConfig(config) {
+  _config = defineConfig(config);
+  return _config;
+}
+function getConfig() {
+  if (!_config) {
+    _config = defaultConfig;
+  }
+  return _config;
+}
+function resetConfig() {
+  _config = null;
+}
+
+export { defaultSingleTableConfig, defaultGSIs, defaultAnalyticsConfig, defaultConfig, defineConfig, getTableConfig, getTtlForEntity, setConfig, getConfig, resetConfig };

package/dist/chunk-deephkz6.js

@@ -0,0 +1,56 @@
+// @bun
+// src/lib/crypto-random.ts
+var DEFAULT_CHARS = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
+function randomToken(length, chars = DEFAULT_CHARS) {
+  if (length <= 0)
+    return "";
+  const limit = Math.floor(256 / chars.length) * chars.length;
+  let out = "";
+  const buf = new Uint8Array(length * 2);
+  while (out.length < length) {
+    crypto.getRandomValues(buf);
+    for (let i = 0;i < buf.length && out.length < length; i++) {
+      if (buf[i] < limit)
+        out += chars[buf[i] % chars.length];
+    }
+  }
+  return out;
+}
+var APP_ID_CHARS = "ABCDEFGHJKLMNPQRSTUVWXYZ23456789";
+function generateAppId(length = 8) {
+  return randomToken(length, APP_ID_CHARS);
+}
+
+// src/integrations/stx.ts
+var DEFAULT_API_ENDPOINT = "http://localhost:2027";
+function resolveApiEndpoint(explicit) {
+  const raw = (explicit ?? process.env.TS_ANALYTICS_ENDPOINT ?? DEFAULT_API_ENDPOINT).trim();
+  return raw.replace(/\/+$/, "");
+}
+function tsAnalytics(options) {
+  const appId = options?.appId?.trim();
+  if (!appId)
+    return [];
+  const origin = resolveApiEndpoint(options?.apiEndpoint);
+  if (!origin)
+    return [];
+  const rawPath = options.scriptPath ?? "/script.js";
+  const path = rawPath.startsWith("/") ? rawPath : `/${rawPath}`;
+  const src = `${origin}${path}${options.stealth ? "?stealth=true" : ""}`;
+  return [
+    {
+      src,
+      defer: true,
+      "data-site": appId
+    }
+  ];
+}
+function tsAnalyticsTag(options) {
+  const [entry] = tsAnalytics(options);
+  if (!entry)
+    return "";
+  return `<script defer data-site="${String(entry["data-site"])}" src="${String(entry.src)}"></script>`;
+}
+var stx_default = tsAnalytics;
+
+export { randomToken, generateAppId, DEFAULT_API_ENDPOINT, resolveApiEndpoint, tsAnalytics, tsAnalyticsTag, stx_default };

package/dist/chunk-j261vgyp.js

@@ -0,0 +1,305 @@
+// @bun
+// src/utils/user-agent.ts
+function parseUserAgent(ua) {
+  if (!ua || ua === "unknown") {
+    return { deviceType: "desktop", browser: "Unknown", os: "Unknown" };
+  }
+  let deviceType = "desktop";
+  if (/mobile|android|iphone|ipod|blackberry|iemobile|opera mini/i.test(ua)) {
+    deviceType = "mobile";
+  } else if (/ipad|tablet|playbook|silk/i.test(ua)) {
+    deviceType = "tablet";
+  }
+  let browser = "Unknown";
+  if (/\bdia\b|diahq|diabrowser/i.test(ua))
+    browser = "Dia";
+  else if (/arc\//i.test(ua))
+    browser = "Arc";
+  else if (/edg/i.test(ua))
+    browser = "Edge";
+  else if (/opr\b|opera/i.test(ua))
+    browser = "Opera";
+  else if (/brave/i.test(ua))
+    browser = "Brave";
+  else if (/vivaldi/i.test(ua))
+    browser = "Vivaldi";
+  else if (/yabrowser/i.test(ua))
+    browser = "Yandex";
+  else if (/whale/i.test(ua))
+    browser = "Whale";
+  else if (/puffin/i.test(ua))
+    browser = "Puffin";
+  else if (/qqbrowser/i.test(ua))
+    browser = "QQ Browser";
+  else if (/ucbrowser/i.test(ua))
+    browser = "UC Browser";
+  else if (/samsungbrowser/i.test(ua))
+    browser = "Samsung Internet";
+  else if (/silk/i.test(ua))
+    browser = "Amazon Silk";
+  else if (/duckduckgo/i.test(ua))
+    browser = "DuckDuckGo";
+  else if (/firefox|fxios/i.test(ua))
+    browser = "Firefox";
+  else if (/chrome|chromium|crios/i.test(ua))
+    browser = "Chrome";
+  else if (/safari/i.test(ua) && !/chrome|chromium/i.test(ua))
+    browser = "Safari";
+  else if (/trident|msie/i.test(ua))
+    browser = "IE";
+  else if (/bot|crawl|spider|slurp|bingpreview/i.test(ua))
+    browser = "Bot";
+  let os = "Unknown";
+  if (/windows nt 10/i.test(ua))
+    os = "Windows 10";
+  else if (/windows nt 11/i.test(ua))
+    os = "Windows 11";
+  else if (/windows/i.test(ua))
+    os = "Windows";
+  else if (/mac os x|macintosh/i.test(ua))
+    os = "macOS";
+  else if (/iphone|ipad|ipod/i.test(ua))
+    os = "iOS";
+  else if (/android/i.test(ua))
+    os = "Android";
+  else if (/linux/i.test(ua))
+    os = "Linux";
+  else if (/cros/i.test(ua))
+    os = "Chrome OS";
+  return { deviceType, browser, os };
+}
+var BOT_UA_PATTERN = new RegExp([
+  "bot|crawl|spider|slurp|preview|scan|probe|monitor(?:ing)?|checker|validator",
+  "headless|phantomjs|puppeteer|playwright|selenium|webdriver|electron",
+  "curl|wget|python-requests|python-urllib|aiohttp|httpx|go-http-client|okhttp",
+  "java/|libwww|lwp::|php/|guzzle|axios|node-fetch|undici|bun/",
+  "facebookexternalhit|whatsapp|telegrambot|discordbot|slackbot|twitterbot",
+  "pingdom|uptimerobot|statuscake|newrelic|datadog|site24x7",
+  "gptbot|claudebot|ccbot|bytespider|amazonbot|anthropic|perplexity"
+].join("|"), "i");
+function isBot(ua) {
+  if (!ua || ua === "unknown" || ua.length < 12)
+    return true;
+  return BOT_UA_PATTERN.test(ua);
+}
+function getBrowserFamily(browser) {
+  const chromiumBased = ["Chrome", "Edge", "Opera", "Brave", "Vivaldi", "Arc", "Dia", "Whale", "Samsung Internet"];
+  if (chromiumBased.includes(browser))
+    return "Chromium";
+  if (browser === "Firefox")
+    return "Firefox";
+  if (browser === "Safari")
+    return "Safari";
+  return "Other";
+}
+
+// src/utils/geolocation.ts
+var COUNTRY_NAMES = {
+  US: "United States",
+  GB: "United Kingdom",
+  CA: "Canada",
+  AU: "Australia",
+  DE: "Germany",
+  FR: "France",
+  JP: "Japan",
+  CN: "China",
+  IN: "India",
+  BR: "Brazil",
+  MX: "Mexico",
+  ES: "Spain",
+  IT: "Italy",
+  NL: "Netherlands",
+  SE: "Sweden",
+  NO: "Norway",
+  DK: "Denmark",
+  FI: "Finland",
+  CH: "Switzerland",
+  AT: "Austria",
+  BE: "Belgium",
+  PL: "Poland",
+  RU: "Russia",
+  KR: "South Korea",
+  SG: "Singapore",
+  HK: "Hong Kong",
+  TW: "Taiwan",
+  NZ: "New Zealand",
+  IE: "Ireland",
+  PT: "Portugal",
+  CZ: "Czech Republic",
+  GR: "Greece",
+  IL: "Israel",
+  ZA: "South Africa",
+  AR: "Argentina",
+  CL: "Chile",
+  CO: "Colombia",
+  PH: "Philippines",
+  TH: "Thailand",
+  MY: "Malaysia",
+  ID: "Indonesia",
+  VN: "Vietnam",
+  AE: "UAE",
+  SA: "Saudi Arabia",
+  TR: "Turkey",
+  UA: "Ukraine",
+  RO: "Romania",
+  HU: "Hungary"
+};
+var NAME_TO_CODE = Object.fromEntries(Object.entries(COUNTRY_NAMES).map(([code, name]) => [name, code]));
+function countryCodeOf(nameOrCode) {
+  if (/^[A-Z]{2}$/i.test(nameOrCode))
+    return nameOrCode.toUpperCase();
+  return NAME_TO_CODE[nameOrCode];
+}
+function countryFlagEmoji(code) {
+  if (!/^[A-Z]{2}$/i.test(code))
+    return "";
+  const cc = code.toUpperCase();
+  return String.fromCodePoint(127462 + cc.charCodeAt(0) - 65, 127462 + cc.charCodeAt(1) - 65);
+}
+var ipGeoCache = new Map;
+function getCountryFromHeaders(headers) {
+  if (!headers)
+    return;
+  const countryCode = headers["cloudfront-viewer-country"] || headers["CloudFront-Viewer-Country"] || headers["x-country-code"] || headers["cf-ipcountry"];
+  if (countryCode && countryCode !== "XX") {
+    return COUNTRY_NAMES[countryCode.toUpperCase()] || countryCode.toUpperCase();
+  }
+  return;
+}
+function anonymizeIp(ip, mode = "partial") {
+  if (!ip || mode === "none")
+    return ip;
+  if (mode === "full")
+    return "";
+  if (ip.includes(":")) {
+    const parts = ip.split(":");
+    return `${parts.slice(0, 3).join(":")}::`;
+  }
+  const octets = ip.split(".");
+  if (octets.length === 4) {
+    octets[3] = "0";
+    return octets.join(".");
+  }
+  return ip;
+}
+var REFERRER_MAP = [
+  { match: "mail.google", name: "Gmail", channel: "Email" },
+  { match: "mail.yahoo", name: "Yahoo Mail", channel: "Email" },
+  { match: "outlook.", name: "Outlook", channel: "Email" },
+  { match: "mail.proton", name: "Proton Mail", channel: "Email" },
+  { match: "chatgpt.", name: "ChatGPT", channel: "AI" },
+  { match: "chat.openai", name: "ChatGPT", channel: "AI" },
+  { match: "openai.", name: "ChatGPT", channel: "AI" },
+  { match: "perplexity", name: "Perplexity", channel: "AI" },
+  { match: "gemini.google", name: "Gemini", channel: "AI" },
+  { match: "bard.google", name: "Gemini", channel: "AI" },
+  { match: "claude.ai", name: "Claude", channel: "AI" },
+  { match: "copilot.microsoft", name: "Copilot", channel: "AI" },
+  { match: /(^|\.)you\.com$/, name: "You.com", channel: "AI" },
+  { match: "phind.", name: "Phind", channel: "AI" },
+  { match: "google", name: "Google", channel: "Search" },
+  { match: "bing", name: "Bing", channel: "Search" },
+  { match: "duckduckgo", name: "DuckDuckGo", channel: "Search" },
+  { match: "yahoo", name: "Yahoo", channel: "Search" },
+  { match: "yandex", name: "Yandex", channel: "Search" },
+  { match: "baidu", name: "Baidu", channel: "Search" },
+  { match: "ecosia", name: "Ecosia", channel: "Search" },
+  { match: "startpage", name: "Startpage", channel: "Search" },
+  { match: "search.brave", name: "Brave Search", channel: "Search" },
+  { match: "qwant", name: "Qwant", channel: "Search" },
+  { match: "search.marginalia", name: "Marginalia", channel: "Search" },
+  { match: /(^|\.)ask\.com$/, name: "Ask", channel: "Search" },
+  { match: "reddit", name: "Reddit", channel: "Social" },
+  { match: "facebook", name: "Facebook", channel: "Social" },
+  { match: /(^|\.)fb\.com$/, name: "Facebook", channel: "Social" },
+  { match: /(^|\.)fb\.me$/, name: "Facebook", channel: "Social" },
+  { match: "instagram", name: "Instagram", channel: "Social" },
+  { match: /^t\.co$/, name: "Twitter", channel: "Social" },
+  { match: "twitter", name: "Twitter", channel: "Social" },
+  { match: /(^|\.)x\.com$/, name: "Twitter", channel: "Social" },
+  { match: "linkedin", name: "LinkedIn", channel: "Social" },
+  { match: /(^|\.)lnkd\.in$/, name: "LinkedIn", channel: "Social" },
+  { match: "youtube", name: "YouTube", channel: "Social" },
+  { match: /(^|\.)youtu\.be$/, name: "YouTube", channel: "Social" },
+  { match: "pinterest", name: "Pinterest", channel: "Social" },
+  { match: "tiktok", name: "TikTok", channel: "Social" },
+  { match: "threads.net", name: "Threads", channel: "Social" },
+  { match: "mastodon", name: "Mastodon", channel: "Social" },
+  { match: "quora", name: "Quora", channel: "Social" },
+  { match: "snapchat", name: "Snapchat", channel: "Social" },
+  { match: "tumblr", name: "Tumblr", channel: "Social" },
+  { match: "telegram", name: "Telegram", channel: "Social" },
+  { match: /^t\.me$/, name: "Telegram", channel: "Social" },
+  { match: "news.ycombinator", name: "Hacker News", channel: "Social" },
+  { match: "ycombinator", name: "Hacker News", channel: "Social" },
+  { match: "github", name: "GitHub", channel: "Referral" },
+  { match: "gitlab", name: "GitLab", channel: "Referral" },
+  { match: "stackoverflow", name: "Stack Overflow", channel: "Referral" },
+  { match: "medium.com", name: "Medium", channel: "Referral" },
+  { match: "dev.to", name: "DEV", channel: "Referral" }
+];
+function matchReferrer(host) {
+  return REFERRER_MAP.find((e) => typeof e.match === "string" ? host.includes(e.match) : e.match.test(host));
+}
+function parseReferrerSource(referrer) {
+  if (!referrer)
+    return "Direct";
+  try {
+    const host = new URL(referrer).hostname.toLowerCase();
+    const entry = matchReferrer(host);
+    if (entry)
+      return entry.name;
+    return host.startsWith("www.") ? host.slice(4) : host;
+  } catch {
+    return "Unknown";
+  }
+}
+var SPAM_REFERRERS = [
+  "semalt.com",
+  "buttons-for-website.com",
+  "buttons-for-your-website.com",
+  "darodar.com",
+  "best-seo-offer.com",
+  "best-seo-solution.com",
+  "free-share-buttons.com",
+  "free-social-buttons.com",
+  "get-free-traffic-now.com",
+  "social-buttons.com",
+  "success-seo.com",
+  "trafficmonetizer.org",
+  "simple-share-buttons.com",
+  "4webmasters.org",
+  "ilovevitaly.com",
+  "priceg.com",
+  "blackhatworth.com",
+  "econom.co",
+  "savetubevideo.com",
+  "kambasoft.com",
+  "voucherssite.com",
+  "sharebutton.net",
+  "sitevaluation.org",
+  "dailyrank.net",
+  "lifehac\u0138er.com",
+  "o-o-6-o-o.com",
+  "humanorightswatch.org",
+  "guardlink.org",
+  "cenoval.ru",
+  "descargar-musica-gratis.net"
+];
+function isSpamReferrer(referrer) {
+  if (!referrer)
+    return false;
+  try {
+    const host = new URL(referrer).hostname.toLowerCase().replace(/^www\./, "");
+    return SPAM_REFERRERS.some((d) => host === d || host.endsWith(`.${d}`));
+  } catch {
+    return false;
+  }
+}
+function getRegionFromHeaders(headers) {
+  if (!headers)
+    return;
+  return headers["cloudfront-viewer-country-region-name"] || headers["CloudFront-Viewer-Country-Region-Name"] || headers["cf-region"];
+}
+
+export { parseUserAgent, isBot, getBrowserFamily, countryCodeOf, countryFlagEmoji, getCountryFromHeaders, anonymizeIp, parseReferrerSource, isSpamReferrer, getRegionFromHeaders };